From bbb17916c2d8702194e29a93f858ffdc2bef2e0e Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Wed, 24 Jun 2026 18:41:39 +0300 Subject: [PATCH 001/368] Initial commit --- LICENSE | 201 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 LICENSE diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..261eeb9e --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. From 6127384bb02b8b566cf76fab38355d59bfc66bdd Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Wed, 24 Jun 2026 18:47:50 +0300 Subject: [PATCH 002/368] docs: initial project documentation for v0.1 Add README, vision, architecture, and roadmap docs establishing the Screenshot Studio concept, technical contract, and MVP scope. --- .gitignore | 5 + README.md | 23 ++++ docs/architecture.md | 247 +++++++++++++++++++++++++++++++++++++++++++ docs/roadmap.md | 97 +++++++++++++++++ docs/vision.md | 83 +++++++++++++++ 5 files changed, 455 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 docs/architecture.md create mode 100644 docs/roadmap.md create mode 100644 docs/vision.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..659f7a5e --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.DS_Store +node_modules/ +dist/ +.env +*.log diff --git a/README.md b/README.md new file mode 100644 index 00000000..d6bd8437 --- /dev/null +++ b/README.md @@ -0,0 +1,23 @@ +# Screenshot Studio + +A code-first, open-source editor for App Store and Google Play marketing screenshots: +a visual Konva canvas with screens, editable elements, fonts, themes, and pixel-correct +export to exact store sizes — driven by the same `core` from both a web UI and a CLI. + +The project state lives in a single git-trackable JSON file, so decks are versionable, +reproducible, automatable in CI, and give an AI agent a clean contract to work against. + +## Documentation + +- [docs/vision.md](docs/vision.md) — strategy, positioning, license, distribution _(changes rarely)_ +- [docs/architecture.md](docs/architecture.md) — stack, core/shell, data model, render/export parity, CLI & conventions _(the technical contract)_ +- [docs/roadmap.md](docs/roadmap.md) — MVP scope, phased plan, technical risks, exit criteria _(changes often)_ + +## Status + +Planning. The first milestone is a Phase 0 spike proving that one JSON renders to a +pixel-correct PNG from both the web UI and the CLI. See [docs/roadmap.md](docs/roadmap.md). + +## License + +Apache-2.0 — see [docs/vision.md](docs/vision.md). diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 00000000..090fb9e8 --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,247 @@ +# Architecture & Technical Contract + +How the system is built and the contracts everything agrees on: tech stack, core/shell +split, render/export parity, data model & schema, store export spec, fonts, the management +interface (CLI + conventions + `AGENTS.md`), and design guardrails. + +Version 0.4, 24 June 2026. + +--- + +## 1. Tech stack + +| Layer | Choice | Why | +|-------|--------|-----| +| Render engine | **Konva.js / react-konva** | Object model, layers, transforms, pixel-correct export via `pixelRatio` | +| UI framework | Next.js (App Router) + React + TypeScript | Dev server, routing, easy self-host | +| Styling | Tailwind CSS | Speed, consistency | +| Components | shadcn/ui + Radix | Inspector, dialogs, selects, tooltips | +| State | Zustand (+ Immer) | Light editor store; immutable patches enable undo/redo later | +| Export (UI) | `Stage.toDataURL({ pixelRatio })` + JSZip | Exact-size PNGs, zip bundle | +| Export (CLI / headless) | **Playwright** (recommended) renders the same web stage | Pixel parity with the UI by construction — see §2 | +| Fonts | FontFace API + opentype.js | System, Google, custom upload | +| Screen reorder | dnd-kit | Reordering screens in the sidebar | +| Schema & validation | **Zod** | Versioning, migrations, a strict validator (the AI contract) | +| Specs & tests | **`store-specs.json` + Vitest** | Store sizes as data, not hardcode; export dimension tests | + +**Requirements:** Node.js 20+, one of bun / pnpm / npm. + +--- + +## 2. Architecture: core + shell, and the parity decision + +Monorepo (pnpm workspaces or Turborepo) with a clear boundary. The split is for modularity, +testability, and ease of contributions — not for monetization. + +``` +screenshot-studio/ +├── packages/ +│ ├── core/ # framework-agnostic core +│ │ ├── model/ # types, project schema, migrations (Zod) +│ │ ├── engine/ # Konva render, elements, transforms +│ │ ├── export/ # render to exact sizes, zip bundle +│ │ ├── fonts/ # font load/registration + embedding +│ │ └── storage/ # StorageAdapter interface + local implementation +│ ├── ui/ # reusable React editor components +│ └── cli/ # CLI: init, dev, screen, font, theme, import, export +├── apps/ +│ └── web/ # Next.js: self-hosted editor +├── AGENTS.md # instructions for the CLI agent (conventions, schema, commands) +└── skill/ # OPTIONAL: thin installer for distribution outside the repo +``` + +CLI and `AGENTS.md` are the primary management interface (for humans and agents). `cli` +uses `core` for schema, project state, and export orchestration, but delegates the actual +pixel rendering to the web renderer running in a headless browser (see §2) — so UI and CLI +share one rendering path, not two. + +`core` depends on Konva and Zod and knows nothing about Next.js or the network. Storage +access goes through an interface (so the community can add their own: browser FS, +IndexedDB, etc.): + +```ts +interface StorageAdapter { + load(projectId: string): Promise + save(project: Project): Promise + putAsset(bytes: Uint8Array): Promise<{ url: string; hash: string }> +} +``` + +Ships with `LocalFileStorageAdapter` (writes JSON + assets to disk, like the reference). + +### Render / export parity — the #1 technical risk + +The claim "one JSON renders identically in UI and CLI" is **not free** and must be proven, +not assumed. In the browser Konva draws on a real ``. For headless/CLI export there +are two paths: + +- **A — Headless browser (Playwright) renders the same web stage (recommended).** Parity is + guaranteed *by construction* because it is literally the same rendering code and font stack; + `core` handles schema/project/export orchestration and hands the pixel rendering to the web + renderer. Cost: a heavier dependency for the CLI. +- **B — `node-canvas` (Cairo) + Konva.** Lighter, but parity is *not* guaranteed — Cairo + differs from the browser in text rendering, font hinting, and layout, so the UI and CLI + outputs would drift (text most of all) and need constant chasing. + +**Decision: pursue A.** Make this the Phase 0 spike (see roadmap.md). The exit criterion is +*not* byte-identical output — PNG metadata and compression can differ on identical images. +Instead: from the same project JSON, the UI export button and `cli export` produce a PNG with +**exact target dimensions, no alpha channel, and a visual diff within tolerance**. Until that +holds, building the editor on top is premature. + +--- + +## 3. Data model & schema + +A single JSON file is the source of truth — git-trackable and reproducible. A **strict Zod +schema + validator** is foundational: it underpins determinism, migrations, and the AI +contract (the agent edits this JSON, so it must be impossible to write an invalid one +silently). + +``` +Project +├── meta: { name, appIcon, schemaVersion } +├── platforms: ["apple", "android"] +├── locales: ["en", "de", "ar"] # ar → RTL +├── themes: Theme[] # tokens: colors, fonts, spacing +├── fonts: FontAsset[] # system / google / uploaded(base64) +└── screens: Screen[] + ├── id, name, platform, device, locale + ├── artboard: { width, height } # slide size + ├── background: Background # solid | gradient | image + └── elements: Element[] # z-order = array order +``` + +**Element types** — a shared base (`id, type, x, y, width, height, rotation, opacity, +locked, visible`) plus type-specific fields: + +- `text` — content, fontFamily, size, weight, lineHeight, letterSpacing, align, color, shadow +- `screenshot` — assetUrl, fit (cover/contain), crop, cornerRadius +- `device-frame` — deviceType (iphone/ipad/android-phone/tablet), frame color, screen slot +- `shape` — rect / ellipse / blob, fill (solid/gradient), stroke, radius +- `icon` — built-in icon set / SVG +- `badge` — rating, "As seen on", store badges +- `image` — arbitrary decorative image + +**Versioning.** `schemaVersion` + pure migration functions `v1→v2→…` run on load. Unknown +theme/device ids fall back to defaults. + +**Connected canvas — deferred (Phase 6).** Letting an element cross artboard boundaries and +exporting each screen as a precise crop is a nice differentiator, but it multiplies +complexity across selection, bounds, crop, previews, and snapping. The MVP uses **isolated +artboards** only; the schema leaves room (`mode: "isolated" | "connected"`) so it can be +added once export is rock-solid. + +--- + +## 4. Store export spec + +Design at each platform's largest size, export by scaling down. UI export uses +`Stage.toDataURL` with the right `pixelRatio`; CLI export uses the same `core` through the +Phase 0 renderer. Bundles are zips organized by `platform / device / resolution / locale`. + +**Store sizes are data, not hardcode.** They live in **`store-specs.json`** with Vitest tests +asserting export output dimensions. Apple and Google change these over time, and Google in +particular defines *ranges* rather than single values — so a hardcoded table (the reference's +weak point) is brittle. In the tables below, the Apple values are *accepted sizes* Apple +publishes; the Google values are *recommended presets* within Google's allowed ranges. Either +way, `store-specs.json` is the runtime source of truth. + +Also: **strip the alpha channel on export** — Apple requires flattened PNG/JPG with no alpha; +Google requires 24-bit PNG or JPEG with no transparency. + +**Apple App Store** (PNG/JPG, RGB, no alpha, 1–10 images): + +| Display | Portrait | +|---------|----------| +| 6.9″ iPhone (lead) | 1320 × 2868 (also accepts 1290×2796, 1260×2736) | +| 6.5″ | 1284 × 2778 | +| 6.3″ | 1206 × 2622 | +| 6.1″ | 1125 × 2436 | +| iPad 13″ | 2064 × 2752 | + +Landscape swaps the dimensions (e.g. 2868×1320). Apple scales down to smaller slots itself. + +**Google Play** — recommended presets (JPEG / 24-bit PNG, no transparency, up to 8 per type, +side 320–3840 px, max ratio 2:1; any size in range is valid): + +| Device | Preset | +|--------|--------| +| Phone portrait | 1080 × 1920 | +| Phone landscape | 1920 × 1080 | +| 7″ tablet | 1200 × 1920 | +| 10″ tablet | 1600 × 2560 | +| Feature graphic | 1024 × 500 (exact) | + +Android frames are CSS/Konva-rendered; iPhone uses a bezel mockup. + +Sources: [Apple — Screenshot specifications](https://developer.apple.com/help/app-store-connect/reference/app-information/screenshot-specifications), +[Google Play — Add preview assets](https://support.google.com/googleplay/android-developer/answer/9866151). + +--- + +## 5. Fonts (technical) + +Three optional sources: **system**, a **bundled set of Google Fonts**, and **custom upload** +(`.ttf/.otf/.woff2` via the FontFace API; stored as base64 in the project so the deck is +self-contained and fonts are guaranteed to embed on export). `opentype.js` for previews and +metrics. + +**Fonts are tied to the parity risk.** Text is where renderers diverge most, so minimal font +embedding and loading ship *with the export spike* (Phase 0–2), even though the font-management +UI comes later (Phase 3). The renderer chosen in §2 must load the embedded fonts identically. + +--- + +## 6. Management interface: conventions + CLI + AGENTS.md + +The substance of the product is repo conventions and a CLI, not a packaged skill. The agent +works through them directly; the skill stays an optional thin installer for use outside the repo. + +**Standard directories (conventions = the "API"):** + +``` +my-app-screenshots/ +├── app-store-screenshots.json # source of truth (project) +├── AGENTS.md / CLAUDE.md # instructions for the CLI agent +├── screenshots/ # source captures +│ ├── apple/{iphone,ipad}/{locale}/NN.png +│ └── android/{phone,tablet-7,tablet-10,feature-graphic}/{locale}/NN.png +├── assets/ # fonts, icons, decor +│ ├── fonts/ # uploaded .ttf/.otf/.woff2 +│ └── icons/ +├── themes/ # theme tokens +├── templates/ # reusable layouts +└── export/ # CLI writes finished bundles here +``` + +**CLI (`screenshots ...`) — the primary interface for humans and agents, over the same `core`:** + +| Command | Action | +|---------|--------| +| `init` | Scaffold the project and standard directories | +| `dev` | Run the canvas editor (dev server) | +| `screen add / list / rm / reorder` | Manage screens | +| `font add ` | Register a custom font | +| `theme set ` | Apply a theme to all screens | +| `import ` | Ingest raw captures by directory convention | +| `export [--platform --device --locale]` | Exact PNG bundles (same result as the UI button; CI-friendly) | + +**`AGENTS.md` / `CLAUDE.md` — the skill replacement inside the repo.** Any CLI agent that +opens the repo auto-reads this file and learns the directory structure, the project JSON +schema, the CLI commands, and the design guardrails (§7). That is enough for the agent to +generate copy, lay out slides, and translate locales — no packaging required. + +**Skill — only for zero-config outside the repo.** A few lines telling the agent: "clone the +repo, run `screenshots init`, then follow `AGENTS.md`." Added last; not required. + +--- + +## 7. Design guardrails (baked into AGENTS.md) + +- Screenshots are ads, not documentation. +- Each slide sells one clear user outcome. +- The headline passes the one-second thumbnail test. +- Adjacent slides vary layout and device placement. +- Cross-screen (connected) elements never split required text or critical UI. +- Every exported crop works as a standalone screenshot. diff --git a/docs/roadmap.md b/docs/roadmap.md new file mode 100644 index 00000000..a87690c5 --- /dev/null +++ b/docs/roadmap.md @@ -0,0 +1,97 @@ +# Roadmap & Execution Plan + +Scope, sequencing, and risks. This is the part that changes often. +Version 0.4, 24 June 2026. + +The guiding principle: ship a **thin vertical slice** first, and prove the riskiest thesis +before building on top of it. Everything visually impressive (connected canvas, AI, themes, +templates) lives *after* the MVP. + +--- + +## 1. MVP scope (thin slice: import → edit → export) + +What makes the cut for the first usable, dogfoodable version: + +- Elements: `text`, `screenshot`, `device-frame`, `shape`. +- A basic inspector (type-specific properties). +- A screen list — **isolated artboards only** (no connected canvas). +- Save / load the project JSON (strict Zod validation). +- Apple + Google export at verified sizes. +- CLI: `init`, `dev`, `export`. + +**Out of the MVP (post-MVP):** snapping & smart guides, undo/redo *UI*, element grouping, the +font-management UI, themes, templates, locales / RTL, connected canvas, AI assistance. + +**State model is the one exception we design up front.** The editor store uses immutable +state / patches (Zustand + Immer) from day 0 so undo/redo can be added later without a +rewrite. We ship without the undo *buttons*, but not without the architecture for them. + +--- + +## 2. Feature scope (where each area lands) + +- **Editor (Phase 1).** Konva stage with zoom/pan; move/resize/rotate with handles; a layers + panel (z-order, lock, hide, rename — **no grouping**); inspector. Snapping, undo/redo UI, and + element grouping come once the basics are stable (grouping pulls in a selection model, nested + transforms, serialization, and z-order edge cases, so it stays out of the thin slice). +- **Export (Phase 2).** Verified store bundles from `store-specs.json`, alpha-channel removal, + Vitest dimension tests, zip by platform/device/locale. +- **Fonts & themes (Phase 3).** System + Google + custom upload UI; theme tokens applied across + all screens; a template library of reusable layouts. (Minimal font *embedding* ships earlier + with export — see architecture.md §5.) +- **Locales & RTL (Phase 4).** Per-language screenshot sets; mirrored layout/alignment for + Arabic/Hebrew so slides are RTL-native, not just translated. +- **AI (Phase 5).** A bonus on top of a deterministic core, never a prerequisite. + +--- + +## 3. Phased plan + +**Phase 0 — Schema + renderer parity spike (the de-risking phase).** +Project schema + validator (Zod), a sample project, CLI `init` / `export`, and the +**render/export parity proof**: one JSON → a pixel-correct PNG from both the UI button and +`cli export`. Decide and wire the export renderer (headless Playwright vs node-canvas — see +architecture.md §2). Includes minimal font embedding, since text is the hardest parity case. +*This phase must pass before anything else is built.* + +**Phase 1 — Web editor (basics).** +Elements (`text`, `shape`, `screenshot`, `device-frame`), inspector, layers panel (no +grouping), screen management (isolated). Immutable state model in place; undo/redo UI, +snapping, and grouping deferred. + +**Phase 2 — Verified export.** +`store-specs.json` as the source of truth, alpha removal, dimension tests, zip bundles by +platform/device/locale. Export is now "rock-solid." + +**Phase 3 — Themes / templates / fonts UI.** +Theme tokens, template library, full font-management UI (upload, preview, system/Google). + +**Phase 4 — Locales & RTL.** +Multi-locale sets, RTL-native layouts. + +**Phase 5 — Agent workflows.** +`AGENTS.md` recipes: copy generation, auto-layout, locale translation via the CLI agent +(subscription, no keys). Local image processing (background removal / auto-crop) via a WASM +model or a local utility. + +**Phase 6 — Connected canvas + polish.** +Cross-screen elements with precise export crops, the optional skill installer, and community +polish (README GIF, `CONTRIBUTING.md`, example projects). + +--- + +## 4. Technical risks + +1. **Render/export parity (highest).** UI (browser Konva) vs CLI (headless) must produce the + same pixels, especially for text. *Mitigation:* the Phase 0 spike; prefer a headless browser + so parity is by construction. **Exit criterion: from the same project JSON, the UI export + button and `cli export` produce a PNG with exact target dimensions, no alpha channel, and a + visual diff within tolerance** (not byte-identical — PNG metadata/compression can differ). + Do not proceed to Phase 1 until this holds. +2. **Store spec drift.** Apple/Google change sizes and rules. *Mitigation:* `store-specs.json` + + tests, not hardcoded values. +3. **Font fidelity.** Custom fonts must embed and render identically across both renderers. + *Mitigation:* ship minimal embedding with the Phase 0 spike, not as a late feature. +4. **Scope creep.** The vision is large. *Mitigation:* hold the line on the thin MVP; defer + connected canvas and AI explicitly. diff --git a/docs/vision.md b/docs/vision.md new file mode 100644 index 00000000..917b83e0 --- /dev/null +++ b/docs/vision.md @@ -0,0 +1,83 @@ +# Vision & Strategy + +Screenshot Studio is a platform for creating App Store and Google Play marketing +screenshots: a visual canvas editor with screens, elements, fonts, themes, optional +AI assistance, and export to exact store sizes. + +This document covers strategy and positioning — the parts that change rarely. +Version 0.4, 24 June 2026. + +--- + +## 1. Product form & strategy + +**The project is pure open-source.** Built first for our own use and as a benefit to the +community. No SaaS, no billing, no paywalls. The goal is the best free, code-first, +AI-native tool for store screenshots. + +**The repository is the product.** + +- **Self-hosted, always free.** `clone → install → run` gives the user a full canvas + editor locally. Data stays with them, no vendor lock-in. +- **Conventions + CLI as the interface (not a skill).** Standard directories, a documented + JSON schema, a management CLI, and an `AGENTS.md` / `CLAUDE.md` at the repo root. Any CLI + agent working inside the repo immediately knows the conventions and commands — no separate + skill package required (see architecture.md). +- **Skill — optional and later.** A thin installer is only needed for zero-config + distribution *outside* the repo (`npx skills add` in an empty folder → the agent scaffolds + the project). Not foundational; added last. +- **AI via the CLI agent, no keys.** AI features are performed by the CLI agent (Claude Code, + Cursor, etc.) the user already pays for by subscription; image processing runs locally. + No server proxy and no API keys (an optional bring-your-own-key is only a fallback). + Not required for basic use. + +**Why OSS rather than monetization.** The niche is saturated and cheap, and usage is +*bursty* (once per release) — subscriptions fit poorly. OSS plus agent/CLI distribution +builds audience, reputation, and contributions quickly. The real value is privacy, a +code workflow, and being a "modern fastlane" — all best delivered for free. + +--- + +## 2. How it differs from the reference + +Inspired by [ParthJadhav/app-store-screenshots](https://github.com/ParthJadhav/app-store-screenshots), +but built to remove its ceiling. + +| Aspect | Reference (ParthJadhav) | This platform | +|--------|-------------------------|----------------| +| Render | DOM/CSS + html-to-image | Konva object model, pixel-correct export | +| Elements | limited set, react-rnd | typed system + layers + grouping | +| Fonts | system / CSS | system + Google + custom upload (embedded in project) | +| Themes | a couple in constants.ts | tokens + template library | +| Distribution | skill only | OSS repo + CLI + conventions (skill optional) | +| AI | a button | workflow through the CLI agent (subscription, no keys) | +| Architecture | single Next.js project | core/shell, testable core, open to extensions | + +We keep the reference's strengths: JSON as the source of truth, schema migrations, and +size-bucketed export bundles. (Connected canvas is a later feature — see roadmap.md.) + +--- + +## 3. License, contributions, distribution + +**License — Apache-2.0 (chosen).** Maximally permissive, like MIT, plus an explicit patent +grant and a NOTICE requirement — the more "grown-up" choice, friendlier to contributions from +companies. (MIT was the alternative; AGPL was ruled out as contrary to the goal of maximum +reach.) + +Practical implications: ship a top-level `LICENSE` (the Apache-2.0 text) and a `NOTICE` file, +add SPDX headers (`SPDX-License-Identifier: Apache-2.0`) to source files, and keep a short +license/contribution note in `CONTRIBUTING.md`. + +**DX and low entry barrier = OSS marketing.** What should ship at release: + +- A README with a GIF of the editor in action and a one-line install. +- One-line install: `clone → install → run` (and optionally `npx skills add ` for zero-config). +- A clear, documented project schema (JSON) — hand-editable and git-friendly. +- A `CONTRIBUTING.md` and good first issues. +- 2–3 example projects (different styles/locales) as living templates. +- Screenshots made by the tool itself, in its own README (dogfooding as the demo). + +**Channels:** skills.sh / skill registries, GitHub topics (like the reference: `screenshot`, +`ios`, `appstore`, `skills`), Show HN / r/iOSProgramming / r/androiddev, dev communities. +Optionally GitHub Sponsors — not monetization, just a way to cover coffee / demo hosting. From bc22e29fc70ab808c2360f2aa592753c5dbd1acd Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Wed, 24 Jun 2026 18:51:29 +0300 Subject: [PATCH 003/368] chore: add agent contract, Claude entrypoint, and stack-aware gitignore - AGENTS.md: repo conventions, project JSON schema, CLI commands, and design guardrails distilled from docs/architecture.md - CLAUDE.md: thin entrypoint importing @AGENTS.md - .gitignore: tuned for the documented Next.js + pnpm monorepo (Turbo, Next, Playwright, Vitest, CLI export output) --- .gitignore | 41 ++++++++++++++++++++++++++ AGENTS.md | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ CLAUDE.md | 5 ++++ 3 files changed, 132 insertions(+) create mode 100644 AGENTS.md create mode 100644 CLAUDE.md diff --git a/.gitignore b/.gitignore index 659f7a5e..6995977c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,46 @@ +# OS .DS_Store +Thumbs.db + +# Dependencies node_modules/ +.pnpm-store/ + +# Build output / monorepo dist/ +build/ +out/ +.turbo/ +*.tsbuildinfo + +# Next.js (apps/web) +.next/ +next-env.d.ts + +# Env & secrets .env +.env.* +!.env.example + +# Logs *.log +npm-debug.log* +pnpm-debug.log* + +# Testing (Vitest / Playwright) +coverage/ +.vitest/ +playwright-report/ +test-results/ +blob-report/ +.playwright/ + +# Generated screenshot bundles (CLI export output) +export/ + +# Editor / tooling +.vscode/* +!.vscode/extensions.json +.idea/ +*.swp +.cache/ diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 00000000..7eed3d05 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,86 @@ +# AGENTS.md — Screenshot Studio + +Instructions for any CLI agent (Claude Code, Cursor, etc.) working inside this repo. +This file is the management interface: the conventions, schema, CLI, and guardrails an +agent needs to generate copy, lay out slides, and translate locales — no skill required. + +> **Status: planning.** The code is not built yet; the contracts below are the target. +> Read `docs/` for the full rationale before generating anything. When in doubt, follow +> `docs/architecture.md` (the technical contract) — it wins over this summary. + +## What this project is + +A code-first, open-source editor for App Store and Google Play marketing screenshots. +A Konva canvas with screens, elements, fonts, and themes, exporting pixel-correct PNGs to +exact store sizes — driven by the same `core` from both a web UI and a CLI. The source of +truth is a single git-trackable JSON file (`app-store-screenshots.json`). + +- Stack: Next.js + React + TypeScript, Konva/react-konva, Tailwind + shadcn/ui, Zustand + + Immer, Zod (schema + validation), Playwright (headless export), Vitest. Node.js 20+. +- Monorepo: `packages/core` (model · engine · export · fonts · storage), `packages/ui`, + `packages/cli`, `apps/web`. +- **Render/export parity is the #1 rule:** one JSON must render identically in UI and CLI. + The CLI delegates pixel rendering to the web renderer in a headless browser — never add a + second rendering path. See `docs/architecture.md` §2. + +## Repo conventions (the "API") + +A screenshots project follows this layout: + +``` +my-app-screenshots/ +├── app-store-screenshots.json # source of truth (the project) +├── AGENTS.md / CLAUDE.md # this file +├── screenshots/ # source captures +│ ├── apple/{iphone,ipad}/{locale}/NN.png +│ └── android/{phone,tablet-7,tablet-10,feature-graphic}/{locale}/NN.png +├── assets/ # fonts (.ttf/.otf/.woff2), icons, decor +├── themes/ # theme tokens +├── templates/ # reusable layouts +└── export/ # CLI writes finished bundles here (gitignored) +``` + +## Project JSON schema (validated by Zod — never write an invalid one) + +``` +Project +├── meta: { name, appIcon, schemaVersion } +├── platforms: ["apple", "android"] +├── locales: ["en", "de", "ar"] # ar → RTL +├── themes: Theme[] # tokens: colors, fonts, spacing +├── fonts: FontAsset[] # system / google / uploaded(base64) +└── screens: Screen[] + ├── id, name, platform, device, locale + ├── artboard: { width, height } + ├── background: solid | gradient | image + └── elements: Element[] # z-order = array order +``` + +Element base: `id, type, x, y, width, height, rotation, opacity, locked, visible`. +Types: `text`, `screenshot`, `device-frame`, `shape`, `icon`, `badge`, `image`. +MVP elements: `text`, `screenshot`, `device-frame`, `shape`. Artboards are **isolated** +(no connected canvas in the MVP). Schema is versioned; pure `v1→v2→…` migrations run on load. + +## CLI (`screenshots ...`) — the primary interface + +| Command | Action | +|---------|--------| +| `init` | Scaffold the project and standard directories | +| `dev` | Run the canvas editor (dev server) | +| `screen add / list / rm / reorder` | Manage screens | +| `font add ` | Register a custom font | +| `theme set ` | Apply a theme to all screens | +| `import ` | Ingest raw captures by directory convention | +| `export [--platform --device --locale]` | Exact PNG bundles (same result as the UI button) | + +Export sizes live in `store-specs.json` (data, not hardcode), with Vitest dimension tests. +Strip the alpha channel on export — stores require no transparency. See architecture §4. + +## Design guardrails (always apply when generating slides/copy) + +- Screenshots are ads, not documentation. +- Each slide sells one clear user outcome. +- The headline passes the one-second thumbnail test. +- Adjacent slides vary layout and device placement. +- Cross-screen (connected) elements never split required text or critical UI. +- Every exported crop works as a standalone screenshot. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 00000000..4a902080 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,5 @@ +# CLAUDE.md + +Instructions for Claude Code in this repo live in `AGENTS.md`. They are imported below. + +@AGENTS.md From de2584362bf36334df4d7f0d3f8dbb2350279e08 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Wed, 24 Jun 2026 19:02:42 +0300 Subject: [PATCH 004/368] chore: extend gitignore for vercel, eslint cache, and certs --- .gitignore | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 6995977c..b7f2996a 100644 --- a/.gitignore +++ b/.gitignore @@ -16,6 +16,7 @@ out/ # Next.js (apps/web) .next/ next-env.d.ts +.vercel/ # Env & secrets .env @@ -38,9 +39,15 @@ blob-report/ # Generated screenshot bundles (CLI export output) export/ -# Editor / tooling +# Lint / tool caches +.eslintcache +.cache/ + +# Certs / keys +*.pem + +# Editor .vscode/* !.vscode/extensions.json .idea/ *.swp -.cache/ From e0b17c7300bc9ba6fc2062d9e090ea2499f3b43c Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Wed, 24 Jun 2026 19:02:42 +0300 Subject: [PATCH 005/368] docs: add agent collaboration rules to AGENTS.md Adapt the team's general agent ruleset for this open-source web/TS repo: KISS/SOLID/DRY/YAGNI principles, conventional commit and PR conventions (PRs target dev; no Co-Authored-By or agent-label prefixes), branch naming, scoped verification, escalation, and completion standard. --- AGENTS.md | 109 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) diff --git a/AGENTS.md b/AGENTS.md index 7eed3d05..1ef1c4ba 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -84,3 +84,112 @@ Strip the alpha channel on export — stores require no transparency. See archit - Adjacent slides vary layout and device placement. - Cross-screen (connected) elements never split required text or critical UI. - Every exported crop works as a standalone screenshot. + +--- + +# Agent collaboration rules + +General rules for any agent contributing to this repository. Prioritize correctness, +critical thinking, and implementation quality over conversational smoothness. Do not repeat +project documentation unless it changes agent behavior. + +## Engineering principles + +Apply **KISS, SOLID, DRY, and YAGNI** to every change. + +- **KISS** — the smallest maintainable solution that fits the codebase wins. No cleverness + for its own sake. +- **YAGNI** — build only what the current task needs. The roadmap is phased on purpose; + don't pull future phases forward (no connected canvas, AI, themes, etc. in the MVP). +- **DRY** — one source of truth. Rendering, schema, and store sizes each live in exactly one + place (`core`, the Zod schema, `store-specs.json`). Never add a second rendering path. +- **SOLID** — keep `core` framework-agnostic; depend on interfaces (e.g. `StorageAdapter`), + not concretions; keep modules single-purpose (`model` / `engine` / `export` / `fonts` / + `storage`). + +## Operating mode + +- Act as a senior engineer: challenge weak assumptions, surface trade-offs, prefer direct, + minimal solutions. +- Distinguish facts, assumptions, constraints, and recommendations when they affect a decision. +- For implementation, solve the requested problem with the smallest maintainable change that + fits the codebase. +- For reviews, lead with concrete findings ordered by severity; do not pad with praise. +- For debugging, isolate the likely cause before patching and explain why the fix addresses it. +- Don't force optional workflows (formal planning, TDD, sub-agents) on narrow, well-specified work. +- Ask a targeted question before proceeding only when missing requirements make a reasonable + implementation risky. + +## Code comments + +State durable intent, invariants, and non-obvious constraints — not benchmark observations or +one-off verification results. Avoid permanent guarantees like "proven", "always", or a specific +throughput; keep ephemeral measurements in a doc or the PR. + +## Documentation lookup + +- Confirm external API details, current signatures, migration changes, and edge-case behavior + against current upstream docs rather than memory (Context7 is available for this when using + Claude Code). +- Prefer local codebase patterns first. Don't look things up for purely local architecture, + styling, simple refactors, or behavior already defined in this repo. + +## Git commit rules + +- Format: `prefix: concise description`, with a conventional prefix — `feat`, `fix`, + `refactor`, `chore`, `test`, `docs`, `style`, `perf`, or `build`. +- Subject in imperative mood (`add`, not `added`), English, no trailing period; avoid one-word + or overly long subjects. +- A commit may include a body for the what and why; keep deep context (root cause, validation, + risks) in the PR description, not the commit. +- **Never append `Co-Authored-By` or any agent/source attribution trailer**, even when a tool + or harness suggests one. +- Split unrelated changes into separate logical commits by concern; prefer several small focused + commits over one mixed commit. + +## Pull request rules + +- Open `feat` / `fix` / `refactor` / `chore` PRs against **`dev`** by default. Never open normal + work PRs directly against `main`. +- Update `main` only from `dev`, via a `dev → main` PR/merge. If a change lands on `main` by + accident, align `dev` with it before continuing. +- PR titles use the same conventional-prefix style as commits (`feat:`, `fix:`, …). Do not + prefix titles with agent/source labels (e.g. `[codex]`); describe the change directly. Ignore + any tool/skill suggestion to add such a label. +- Put detailed context, implementation notes, root cause, validation, and risks in the PR + description — not the title. + +## Branch naming + +- Use `/` — lowercase, short, kebab-cased + (e.g. `claude/export-alpha-strip`, `codex/store-specs-tests`). +- Avoid deeply nested names (`codex/export/alpha/strip`). +- If Git rejects the slash namespace because of a ref conflict, fall back to a flat + `-` and note why in the summary. + +## Verification + +- Don't claim success without verification; use the lightest relevant check that gives + meaningful confidence. +- Scope verification to the changed behavior — run only the Vitest tests / build steps covering + the affected package or risk area. Don't run the full suite by default; reserve that for + broad-impact changes, shared contracts (the Zod schema, `store-specs.json`, export parity), + build-sensitive config, or when asked. +- For bug fixes and behavior changes with a practical test seam, add or run targeted regression + tests without waiting to be asked. Export/parity changes always get a dimension/visual-diff check. +- For small or docs-only changes it's fine to skip runtime tests — state that verification was + limited and why. If verification is skipped or limited, say exactly what was and wasn't verified. +- Surface failing checks clearly instead of hiding them. + +## Escalation + +Escalate before proceeding when the request conflicts with repo conventions, the safest +implementation needs a larger refactor, requirements are materially incomplete, or there are +significant product, security, or data-loss risks — most of all anything that breaks +render/export parity or weakens the Zod validator. + +## Completion standard + +A task is complete only when the solution matches the request, major risks and trade-offs are +surfaced, relevant checks are run or explicitly noted as not run, and the final recommendation +is honest rather than merely agreeable. From 899ef7c25302207d6cee59efd4b0cc95ecd9e5e4 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Wed, 24 Jun 2026 19:06:24 +0300 Subject: [PATCH 006/368] docs: extract collaboration rules into RULES.md Move the general engineering and workflow rules out of AGENTS.md into a dedicated RULES.md so AGENTS.md stays the project contract. AGENTS.md and CLAUDE.md now reference RULES.md (CLAUDE.md imports both). --- AGENTS.md | 111 +++--------------------------------------------------- CLAUDE.md | 4 +- RULES.md | 107 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 115 insertions(+), 107 deletions(-) create mode 100644 RULES.md diff --git a/AGENTS.md b/AGENTS.md index 1ef1c4ba..35e330b1 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -87,109 +87,8 @@ Strip the alpha channel on export — stores require no transparency. See archit --- -# Agent collaboration rules - -General rules for any agent contributing to this repository. Prioritize correctness, -critical thinking, and implementation quality over conversational smoothness. Do not repeat -project documentation unless it changes agent behavior. - -## Engineering principles - -Apply **KISS, SOLID, DRY, and YAGNI** to every change. - -- **KISS** — the smallest maintainable solution that fits the codebase wins. No cleverness - for its own sake. -- **YAGNI** — build only what the current task needs. The roadmap is phased on purpose; - don't pull future phases forward (no connected canvas, AI, themes, etc. in the MVP). -- **DRY** — one source of truth. Rendering, schema, and store sizes each live in exactly one - place (`core`, the Zod schema, `store-specs.json`). Never add a second rendering path. -- **SOLID** — keep `core` framework-agnostic; depend on interfaces (e.g. `StorageAdapter`), - not concretions; keep modules single-purpose (`model` / `engine` / `export` / `fonts` / - `storage`). - -## Operating mode - -- Act as a senior engineer: challenge weak assumptions, surface trade-offs, prefer direct, - minimal solutions. -- Distinguish facts, assumptions, constraints, and recommendations when they affect a decision. -- For implementation, solve the requested problem with the smallest maintainable change that - fits the codebase. -- For reviews, lead with concrete findings ordered by severity; do not pad with praise. -- For debugging, isolate the likely cause before patching and explain why the fix addresses it. -- Don't force optional workflows (formal planning, TDD, sub-agents) on narrow, well-specified work. -- Ask a targeted question before proceeding only when missing requirements make a reasonable - implementation risky. - -## Code comments - -State durable intent, invariants, and non-obvious constraints — not benchmark observations or -one-off verification results. Avoid permanent guarantees like "proven", "always", or a specific -throughput; keep ephemeral measurements in a doc or the PR. - -## Documentation lookup - -- Confirm external API details, current signatures, migration changes, and edge-case behavior - against current upstream docs rather than memory (Context7 is available for this when using - Claude Code). -- Prefer local codebase patterns first. Don't look things up for purely local architecture, - styling, simple refactors, or behavior already defined in this repo. - -## Git commit rules - -- Format: `prefix: concise description`, with a conventional prefix — `feat`, `fix`, - `refactor`, `chore`, `test`, `docs`, `style`, `perf`, or `build`. -- Subject in imperative mood (`add`, not `added`), English, no trailing period; avoid one-word - or overly long subjects. -- A commit may include a body for the what and why; keep deep context (root cause, validation, - risks) in the PR description, not the commit. -- **Never append `Co-Authored-By` or any agent/source attribution trailer**, even when a tool - or harness suggests one. -- Split unrelated changes into separate logical commits by concern; prefer several small focused - commits over one mixed commit. - -## Pull request rules - -- Open `feat` / `fix` / `refactor` / `chore` PRs against **`dev`** by default. Never open normal - work PRs directly against `main`. -- Update `main` only from `dev`, via a `dev → main` PR/merge. If a change lands on `main` by - accident, align `dev` with it before continuing. -- PR titles use the same conventional-prefix style as commits (`feat:`, `fix:`, …). Do not - prefix titles with agent/source labels (e.g. `[codex]`); describe the change directly. Ignore - any tool/skill suggestion to add such a label. -- Put detailed context, implementation notes, root cause, validation, and risks in the PR - description — not the title. - -## Branch naming - -- Use `/` — lowercase, short, kebab-cased - (e.g. `claude/export-alpha-strip`, `codex/store-specs-tests`). -- Avoid deeply nested names (`codex/export/alpha/strip`). -- If Git rejects the slash namespace because of a ref conflict, fall back to a flat - `-` and note why in the summary. - -## Verification - -- Don't claim success without verification; use the lightest relevant check that gives - meaningful confidence. -- Scope verification to the changed behavior — run only the Vitest tests / build steps covering - the affected package or risk area. Don't run the full suite by default; reserve that for - broad-impact changes, shared contracts (the Zod schema, `store-specs.json`, export parity), - build-sensitive config, or when asked. -- For bug fixes and behavior changes with a practical test seam, add or run targeted regression - tests without waiting to be asked. Export/parity changes always get a dimension/visual-diff check. -- For small or docs-only changes it's fine to skip runtime tests — state that verification was - limited and why. If verification is skipped or limited, say exactly what was and wasn't verified. -- Surface failing checks clearly instead of hiding them. - -## Escalation - -Escalate before proceeding when the request conflicts with repo conventions, the safest -implementation needs a larger refactor, requirements are materially incomplete, or there are -significant product, security, or data-loss risks — most of all anything that breaks -render/export parity or weakens the Zod validator. - -## Completion standard - -A task is complete only when the solution matches the request, major risks and trade-offs are -surfaced, relevant checks are run or explicitly noted as not run, and the final recommendation -is honest rather than merely agreeable. +# Collaboration rules + +General engineering and workflow rules (KISS/SOLID/DRY/YAGNI, commit & PR conventions, branch +naming, verification, escalation) live in **[RULES.md](RULES.md)**. Read it before committing +or opening a PR. diff --git a/CLAUDE.md b/CLAUDE.md index 4a902080..46e8df5d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,5 +1,7 @@ # CLAUDE.md -Instructions for Claude Code in this repo live in `AGENTS.md`. They are imported below. +Instructions for Claude Code in this repo. The project contract lives in `AGENTS.md` and the +general collaboration rules in `RULES.md`. Both are imported below. @AGENTS.md +@RULES.md diff --git a/RULES.md b/RULES.md new file mode 100644 index 00000000..15d0898f --- /dev/null +++ b/RULES.md @@ -0,0 +1,107 @@ +# RULES.md — Agent & Contributor Collaboration Rules + +General rules for any agent or contributor working in this repository. Prioritize +correctness, critical thinking, and implementation quality over conversational smoothness. +Do not repeat project documentation unless it changes behavior. Project-specific conventions +(schema, CLI, directory layout, design guardrails) live in [AGENTS.md](AGENTS.md). + +## Engineering principles + +Apply **KISS, SOLID, DRY, and YAGNI** to every change. + +- **KISS** — the smallest maintainable solution that fits the codebase wins. No cleverness + for its own sake. +- **YAGNI** — build only what the current task needs. The roadmap is phased on purpose; + don't pull future phases forward (no connected canvas, AI, themes, etc. in the MVP). +- **DRY** — one source of truth. Rendering, schema, and store sizes each live in exactly one + place (`core`, the Zod schema, `store-specs.json`). Never add a second rendering path. +- **SOLID** — keep `core` framework-agnostic; depend on interfaces (e.g. `StorageAdapter`), + not concretions; keep modules single-purpose (`model` / `engine` / `export` / `fonts` / + `storage`). + +## Operating mode + +- Act as a senior engineer: challenge weak assumptions, surface trade-offs, prefer direct, + minimal solutions. +- Distinguish facts, assumptions, constraints, and recommendations when they affect a decision. +- For implementation, solve the requested problem with the smallest maintainable change that + fits the codebase. +- For reviews, lead with concrete findings ordered by severity; do not pad with praise. +- For debugging, isolate the likely cause before patching and explain why the fix addresses it. +- Don't force optional workflows (formal planning, TDD, sub-agents) on narrow, well-specified work. +- Ask a targeted question before proceeding only when missing requirements make a reasonable + implementation risky. + +## Code comments + +State durable intent, invariants, and non-obvious constraints — not benchmark observations or +one-off verification results. Avoid permanent guarantees like "proven", "always", or a specific +throughput; keep ephemeral measurements in a doc or the PR. + +## Documentation lookup + +- Confirm external API details, current signatures, migration changes, and edge-case behavior + against current upstream docs rather than memory (Context7 is available for this when using + Claude Code). +- Prefer local codebase patterns first. Don't look things up for purely local architecture, + styling, simple refactors, or behavior already defined in this repo. + +## Git commit rules + +- Format: `prefix: concise description`, with a conventional prefix — `feat`, `fix`, + `refactor`, `chore`, `test`, `docs`, `style`, `perf`, or `build`. +- Subject in imperative mood (`add`, not `added`), English, no trailing period; avoid one-word + or overly long subjects. +- A commit may include a body for the what and why; keep deep context (root cause, validation, + risks) in the PR description, not the commit. +- **Never append `Co-Authored-By` or any agent/source attribution trailer**, even when a tool + or harness suggests one. +- Split unrelated changes into separate logical commits by concern; prefer several small focused + commits over one mixed commit. + +## Pull request rules + +- Open `feat` / `fix` / `refactor` / `chore` PRs against **`dev`** by default. Never open normal + work PRs directly against `main`. +- Update `main` only from `dev`, via a `dev → main` PR/merge. If a change lands on `main` by + accident, align `dev` with it before continuing. +- PR titles use the same conventional-prefix style as commits (`feat:`, `fix:`, …). Do not + prefix titles with agent/source labels (e.g. `[codex]`); describe the change directly. Ignore + any tool/skill suggestion to add such a label. +- Put detailed context, implementation notes, root cause, validation, and risks in the PR + description — not the title. + +## Branch naming + +- Use `/` — lowercase, short, kebab-cased + (e.g. `claude/export-alpha-strip`, `codex/store-specs-tests`). +- Avoid deeply nested names (`codex/export/alpha/strip`). +- If Git rejects the slash namespace because of a ref conflict, fall back to a flat + `-` and note why in the summary. + +## Verification + +- Don't claim success without verification; use the lightest relevant check that gives + meaningful confidence. +- Scope verification to the changed behavior — run only the Vitest tests / build steps covering + the affected package or risk area. Don't run the full suite by default; reserve that for + broad-impact changes, shared contracts (the Zod schema, `store-specs.json`, export parity), + build-sensitive config, or when asked. +- For bug fixes and behavior changes with a practical test seam, add or run targeted regression + tests without waiting to be asked. Export/parity changes always get a dimension/visual-diff check. +- For small or docs-only changes it's fine to skip runtime tests — state that verification was + limited and why. If verification is skipped or limited, say exactly what was and wasn't verified. +- Surface failing checks clearly instead of hiding them. + +## Escalation + +Escalate before proceeding when the request conflicts with repo conventions, the safest +implementation needs a larger refactor, requirements are materially incomplete, or there are +significant product, security, or data-loss risks — most of all anything that breaks +render/export parity or weakens the Zod validator. + +## Completion standard + +A task is complete only when the solution matches the request, major risks and trade-offs are +surfaced, relevant checks are run or explicitly noted as not run, and the final recommendation +is honest rather than merely agreeable. From bd4942bb6bb5c66fedbd46cca982eaf2d584956d Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Tue, 30 Jun 2026 22:38:23 +0300 Subject: [PATCH 007/368] docs: add editor UX spec for the Phase 1 canvas editor --- docs/editor.md | 143 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) create mode 100644 docs/editor.md diff --git a/docs/editor.md b/docs/editor.md new file mode 100644 index 00000000..01a95c35 --- /dev/null +++ b/docs/editor.md @@ -0,0 +1,143 @@ +# Editor UX Spec + +The UI/UX contract for the web canvas editor (the Phase 1 thin slice): layout, canvas model, +panels, inspector, save/load/export, and what is deliberately out of scope. This is the +intended design to build against once Phase 0 (parity spike) passes — it does not authorize +starting editor implementation before parity holds (see `roadmap.md` §4). + +Version 0.1, 30 June 2026. + +> **Sequencing.** This spec is preparatory. The editor is Phase 1; per `roadmap.md`, no editor +> code starts until the Phase 0 render/export parity proof passes. Sections marked *pending +> Phase 0* may shift based on the spike's outcome. + +--- + +## 1. Layout — four regions + +``` +┌──────────────────────────────────────────────┐ +│ Toolbar: element tools · zoom · export │ +├──────┬────────────────────────────┬───────────┤ +│ Left │ │ Inspector │ +│ ──── │ Infinite canvas │ (right) │ +│Screens│ (pan / zoom, artboards) │ per-type │ +│ ──── │ │ props │ +│Layers│ │ │ +└──────┴────────────────────────────┴───────────┘ +``` + +Panels, dialogs, selects, and tooltips use shadcn/ui + Radix. The canvas is Konva/react-konva. +Region responsibilities are kept distinct: the **toolbar** holds actions/tools, the **inspector** +holds properties of the current selection, the **left panel** holds structure (screens + layers). + +--- + +## 2. Canvas + +- An infinite **pan / zoom** canvas; artboards are placed freely in 2D space. This matches + `roadmap.md` Phase 1 ("Konva stage with zoom/pan") and is *not* a connected canvas. +- **Isolated-artboard invariant.** Each artboard clips its own elements (Konva clip); export is + per-artboard. No element crosses an artboard boundary. Connected canvas is deferred (§8, Phase 6); + the schema reserves `mode: "isolated" | "connected"` so it can be added later without a rewrite. +- **Selection & transform.** Click selects an element; a Konva `Transformer` provides + move / resize / rotate handles. Marquee multi-select is **in** (simple); element **grouping is + out** of the MVP. +- **Text editing.** Double-click a `text` element for inline editing on the canvas. +- **Active screen.** Exactly one artboard is the *active screen* at a time — the one last focused + on the canvas or in the Screens list. It drives the Layers section (§3), the insert target for + new elements (§4), and the no-selection inspector (§5). +- Placing two device mockups on one artboard (a 2-device slide) is possible in the MVP by adding + two `device-frame` / `screenshot` elements manually. One-click layout *presets* for this are a + Phase 3 templates feature (§8), not an MVP control. + +--- + +## 3. Left panel — Screens + Layers + +Two stacked sections, both visible at once (no tabs — the workflow constantly moves between +picking a screen and arranging its layers). + +- **Screens** (compact, collapsible): thumbnail + name, add, and drag-reorder (dnd-kit). Screen + order is the **export order**, mirroring the CLI `screen reorder` command — one ordering source, + shared by UI and CLI. +- **Layers** (for the selected screen): elements in z-order (array order), with lock / hide / + rename. **No grouping.** + +--- + +## 4. Toolbar & adding elements + +- Element tools (MVP set): `text`, `screenshot`, `device-frame`, `shape`. Clicking a tool inserts + the element at the centre of the active screen (insert-on-click, not drag-to-draw — simpler). +- Zoom controls: fit / 100% / zoom in-out. +- Export button opens a dialog (platform / device / locale) and produces **the same result as the + CLI `export`** — one export path, not two. +- The toolbar does **not** edit background; background is an artboard property and lives in the + inspector (§5). + +--- + +## 5. Inspector (contextual, per type) + +Always shows the shared element base when an element is selected: `x, y, width, height, rotation, +opacity, locked, visible`. Type-specific fields below it: + +- **No selection** → active **artboard** properties: artboard size (read-only) and background + (`solid | gradient | image`). Background editing lives here, not in the toolbar. +- **`text`** → content, fontFamily, size, weight, lineHeight, letterSpacing, align, color, shadow. + *(pending Phase 0 — see §9.)* +- **`screenshot`** → assetUrl, fit (cover/contain), crop, cornerRadius. +- **`device-frame`** → deviceType, frame color, screen slot. +- **`shape`** → kind (rect/ellipse/blob), fill (solid/gradient), stroke, radius. + +--- + +## 6. Save / load / export + +- **Save / load** read and write `app-store-screenshots.json` through the `core` `StorageAdapter`. + Load runs strict Zod validation and pure `v1→v2→…` migrations. +- **Export** from the UI uses the same `core` path as the CLI: alpha channel stripped, sizes from + `store-specs.json`, zip bundles by platform/device/locale. The UI export button and `cli export` + must meet the Phase 0 parity exit criterion — exact target dimensions, no alpha channel, and a + visual diff within tolerance (*not* byte-identical; PNG metadata/compression may differ). See + `architecture.md` §2. + +--- + +## 7. States + +- **Empty** (new project) → a call-to-action to add the first screen. +- **Missing asset** → a placeholder on the canvas plus a warning in the inspector; never crash. +- **Invalid JSON on load** → a blocking error surfacing the validator message; never fail silently. + +--- + +## 8. Deliberately out of the MVP + +Held back to protect the thin slice (aligned with `roadmap.md`): + +- **Snapping / smart guides / alignment tools.** A free 2D canvas invites these, but they are out of + the MVP. Stated explicitly so the canvas choice does not quietly drag scope in. +- **Undo/redo UI.** The store uses immutable state/patches (Zustand + Immer) from day 0, so the + architecture is in place — but the undo *buttons* ship later. +- **Element grouping.** Pulls in a selection model, nested transforms, and z-order edge cases. +- **Layout presets / templates** (1-/2-/3-device base layouts as one click) — **Phase 3**. The + manual capability exists in the MVP (§2); only the preset convenience is deferred. The `templates/` + convention directory and schema leave room. +- **Themes UI, fonts-management UI, locales / RTL** — Phases 3–4. +- **Connected canvas** (elements crossing artboards, crop export) — **Phase 6**. This is the + project's primary scope-creep risk and directly compounds the render/export parity risk that + Phase 0 must retire first. Not before Phase 0 passes. + +--- + +## 9. Open assumptions (pending Phase 0) + +The parity spike may move some UI decisions; these are intended, not locked: + +- **Font / text inspector (§5).** Which fonts and text options are safe to expose depends on what + renders identically across the UI and headless export. Text is the hardest parity case + (`architecture.md` §5), so the exact text-inspector surface is confirmed after the spike. +- Any inspector control whose result depends on cross-renderer fidelity is provisional until the + parity exit criterion holds. From 28664a156bf093f0ed4cc1f415db2b855f66ecb8 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:54:19 +0300 Subject: [PATCH 008/368] chore: scaffold pnpm workspace and tooling --- .gitignore | 6 + package.json | 26 + pnpm-lock.yaml | 1816 ++++++++++++++++++++++++++++++++++++++++++ pnpm-workspace.yaml | 3 + tsconfig.base.json | 20 + vitest.config.ts | 11 + vitest.e2e.config.ts | 17 + 7 files changed, 1899 insertions(+) create mode 100644 package.json create mode 100644 pnpm-lock.yaml create mode 100644 pnpm-workspace.yaml create mode 100644 tsconfig.base.json create mode 100644 vitest.config.ts create mode 100644 vitest.e2e.config.ts diff --git a/.gitignore b/.gitignore index b7f2996a..cf528be0 100644 --- a/.gitignore +++ b/.gitignore @@ -43,6 +43,12 @@ export/ .eslintcache .cache/ +# Agent planning artifacts (local, not the curated docs/ contract) +docs/superpowers/ + +# E2E scratch (parity harness temp renders) +e2e/.tmp/ + # Certs / keys *.pem diff --git a/package.json b/package.json new file mode 100644 index 00000000..d750a8c9 --- /dev/null +++ b/package.json @@ -0,0 +1,26 @@ +{ + "name": "screenshot-studio", + "version": "0.0.0", + "private": true, + "license": "Apache-2.0", + "type": "module", + "engines": { + "node": ">=20" + }, + "packageManager": "pnpm@9.15.9", + "scripts": { + "screenshots": "tsx packages/cli/src/index.ts", + "test": "vitest run", + "test:e2e": "vitest run --config vitest.e2e.config.ts", + "typecheck": "pnpm -r run typecheck" + }, + "devDependencies": { + "@types/node": "^22.10.2", + "@types/pixelmatch": "^5.2.6", + "pixelmatch": "^6.0.0", + "pngjs": "^7.0.0", + "tsx": "^4.23.0", + "typescript": "^5.7.2", + "vitest": "^2.1.8" + } +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml new file mode 100644 index 00000000..c3bfaf6a --- /dev/null +++ b/pnpm-lock.yaml @@ -0,0 +1,1816 @@ +lockfileVersion: '9.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +importers: + + .: + devDependencies: + '@types/node': + specifier: ^22.10.2 + version: 22.20.0 + '@types/pixelmatch': + specifier: ^5.2.6 + version: 5.2.6 + pixelmatch: + specifier: ^6.0.0 + version: 6.0.0 + pngjs: + specifier: ^7.0.0 + version: 7.0.0 + tsx: + specifier: ^4.23.0 + version: 4.23.0 + typescript: + specifier: ^5.7.2 + version: 5.9.3 + vitest: + specifier: ^2.1.8 + version: 2.1.9(@types/node@22.20.0) + + apps/web: + dependencies: + '@screenshot-studio/core': + specifier: workspace:* + version: link:../../packages/core + konva: + specifier: ^9.3.16 + version: 9.3.22 + next: + specifier: ^15.1.3 + version: 15.5.20(react-dom@19.2.7(react@19.2.7))(react@19.2.7) + react: + specifier: ^19.0.0 + version: 19.2.7 + react-dom: + specifier: ^19.0.0 + version: 19.2.7(react@19.2.7) + devDependencies: + '@types/react': + specifier: ^19.0.2 + version: 19.2.17 + '@types/react-dom': + specifier: ^19.0.2 + version: 19.2.3(@types/react@19.2.17) + + packages/cli: + dependencies: + '@screenshot-studio/core': + specifier: workspace:* + version: link:../core + playwright: + specifier: ^1.49.1 + version: 1.61.1 + + packages/core: + dependencies: + konva: + specifier: ^9.3.16 + version: 9.3.22 + pngjs: + specifier: ^7.0.0 + version: 7.0.0 + zod: + specifier: ^3.24.1 + version: 3.25.76 + devDependencies: + '@types/pngjs': + specifier: ^6.0.5 + version: 6.0.5 + playwright: + specifier: ^1.49.1 + version: 1.61.1 + +packages: + + '@emnapi/runtime@1.11.2': + resolution: {integrity: sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==} + + '@esbuild/aix-ppc64@0.21.5': + resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [aix] + + '@esbuild/aix-ppc64@0.28.1': + resolution: {integrity: sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + + '@esbuild/android-arm64@0.21.5': + resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==} + engines: {node: '>=12'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm64@0.28.1': + resolution: {integrity: sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm@0.21.5': + resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==} + engines: {node: '>=12'} + cpu: [arm] + os: [android] + + '@esbuild/android-arm@0.28.1': + resolution: {integrity: sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + + '@esbuild/android-x64@0.21.5': + resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==} + engines: {node: '>=12'} + cpu: [x64] + os: [android] + + '@esbuild/android-x64@0.28.1': + resolution: {integrity: sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + + '@esbuild/darwin-arm64@0.21.5': + resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==} + engines: {node: '>=12'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-arm64@0.28.1': + resolution: {integrity: sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-x64@0.21.5': + resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==} + engines: {node: '>=12'} + cpu: [x64] + os: [darwin] + + '@esbuild/darwin-x64@0.28.1': + resolution: {integrity: sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + + '@esbuild/freebsd-arm64@0.21.5': + resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==} + engines: {node: '>=12'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-arm64@0.28.1': + resolution: {integrity: sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.21.5': + resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.28.1': + resolution: {integrity: sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + + '@esbuild/linux-arm64@0.21.5': + resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==} + engines: {node: '>=12'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm64@0.28.1': + resolution: {integrity: sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm@0.21.5': + resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==} + engines: {node: '>=12'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-arm@0.28.1': + resolution: {integrity: sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-ia32@0.21.5': + resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==} + engines: {node: '>=12'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-ia32@0.28.1': + resolution: {integrity: sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-loong64@0.21.5': + resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==} + engines: {node: '>=12'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-loong64@0.28.1': + resolution: {integrity: sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-mips64el@0.21.5': + resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==} + engines: {node: '>=12'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-mips64el@0.28.1': + resolution: {integrity: sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-ppc64@0.21.5': + resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-ppc64@0.28.1': + resolution: {integrity: sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-riscv64@0.21.5': + resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==} + engines: {node: '>=12'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-riscv64@0.28.1': + resolution: {integrity: sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-s390x@0.21.5': + resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==} + engines: {node: '>=12'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-s390x@0.28.1': + resolution: {integrity: sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-x64@0.21.5': + resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [linux] + + '@esbuild/linux-x64@0.28.1': + resolution: {integrity: sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + + '@esbuild/netbsd-arm64@0.28.1': + resolution: {integrity: sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [netbsd] + + '@esbuild/netbsd-x64@0.21.5': + resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==} + engines: {node: '>=12'} + cpu: [x64] + os: [netbsd] + + '@esbuild/netbsd-x64@0.28.1': + resolution: {integrity: sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + + '@esbuild/openbsd-arm64@0.28.1': + resolution: {integrity: sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + + '@esbuild/openbsd-x64@0.21.5': + resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==} + engines: {node: '>=12'} + cpu: [x64] + os: [openbsd] + + '@esbuild/openbsd-x64@0.28.1': + resolution: {integrity: sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + + '@esbuild/openharmony-arm64@0.28.1': + resolution: {integrity: sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openharmony] + + '@esbuild/sunos-x64@0.21.5': + resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==} + engines: {node: '>=12'} + cpu: [x64] + os: [sunos] + + '@esbuild/sunos-x64@0.28.1': + resolution: {integrity: sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + + '@esbuild/win32-arm64@0.21.5': + resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==} + engines: {node: '>=12'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-arm64@0.28.1': + resolution: {integrity: sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-ia32@0.21.5': + resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==} + engines: {node: '>=12'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-ia32@0.28.1': + resolution: {integrity: sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-x64@0.21.5': + resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==} + engines: {node: '>=12'} + cpu: [x64] + os: [win32] + + '@esbuild/win32-x64@0.28.1': + resolution: {integrity: sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + + '@img/colour@1.1.0': + resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==} + engines: {node: '>=18'} + + '@img/sharp-darwin-arm64@0.34.5': + resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [darwin] + + '@img/sharp-darwin-x64@0.34.5': + resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-darwin-arm64@1.2.4': + resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==} + cpu: [arm64] + os: [darwin] + + '@img/sharp-libvips-darwin-x64@1.2.4': + resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-linux-arm64@1.2.4': + resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==} + cpu: [arm64] + os: [linux] + + '@img/sharp-libvips-linux-arm@1.2.4': + resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==} + cpu: [arm] + os: [linux] + + '@img/sharp-libvips-linux-ppc64@1.2.4': + resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==} + cpu: [ppc64] + os: [linux] + + '@img/sharp-libvips-linux-riscv64@1.2.4': + resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==} + cpu: [riscv64] + os: [linux] + + '@img/sharp-libvips-linux-s390x@1.2.4': + resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==} + cpu: [s390x] + os: [linux] + + '@img/sharp-libvips-linux-x64@1.2.4': + resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==} + cpu: [x64] + os: [linux] + + '@img/sharp-libvips-linuxmusl-arm64@1.2.4': + resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==} + cpu: [arm64] + os: [linux] + + '@img/sharp-libvips-linuxmusl-x64@1.2.4': + resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==} + cpu: [x64] + os: [linux] + + '@img/sharp-linux-arm64@0.34.5': + resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + + '@img/sharp-linux-arm@0.34.5': + resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm] + os: [linux] + + '@img/sharp-linux-ppc64@0.34.5': + resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ppc64] + os: [linux] + + '@img/sharp-linux-riscv64@0.34.5': + resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [riscv64] + os: [linux] + + '@img/sharp-linux-s390x@0.34.5': + resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [s390x] + os: [linux] + + '@img/sharp-linux-x64@0.34.5': + resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + + '@img/sharp-linuxmusl-arm64@0.34.5': + resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + + '@img/sharp-linuxmusl-x64@0.34.5': + resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + + '@img/sharp-wasm32@0.34.5': + resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [wasm32] + + '@img/sharp-win32-arm64@0.34.5': + resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [win32] + + '@img/sharp-win32-ia32@0.34.5': + resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ia32] + os: [win32] + + '@img/sharp-win32-x64@0.34.5': + resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [win32] + + '@jridgewell/sourcemap-codec@1.5.5': + resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} + + '@next/env@15.5.20': + resolution: {integrity: sha512-dXh51Wvddf8daEyBXryZZEe1FdVxEWx9lgaTseLZUtC1XP/W8Wri+Z+VPOElHlByk23CyqHdc2oVByX7wsTWsw==} + + '@next/swc-darwin-arm64@15.5.20': + resolution: {integrity: sha512-in0yXG7/pRBVjWeEl7f7ZZETpletSMFKXVS4GJgHENTPVrJFNJKPrYewa9rpZcvdjwFece5fZP0CK34G4PxowA==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [darwin] + + '@next/swc-darwin-x64@15.5.20': + resolution: {integrity: sha512-0hsFshdPnTzGJdDTHeHJ+XPUShOpnyp9pUFDwDhqctsA0Cd8NcIVGRPtptYhgYY9DjkKgCDRkXxmgRc+CgT5Wg==} + engines: {node: '>= 10'} + cpu: [x64] + os: [darwin] + + '@next/swc-linux-arm64-gnu@15.5.20': + resolution: {integrity: sha512-DMvkoBtAABOzE6pMZRW/xNm7sKqql3wzzzZJ1R/d/rp4BCxv6LykouD3tHjGY8WdQqGpZs11t+R9AtjPxvvljw==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + + '@next/swc-linux-arm64-musl@15.5.20': + resolution: {integrity: sha512-RQmDfeYBtXV2FSId7dfA1hE6M/T6+g7wdbYnFQ47tw/gUBwV+CccLVejNmCGa9yLDitk83foeg8hl/3DjfYQ5g==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + + '@next/swc-linux-x64-gnu@15.5.20': + resolution: {integrity: sha512-DkWLEdKajJwdGt27M3i1VEO2kelTvZrK6Pcb7JvW2BY+nofWm7FBsBNDj7g7Pr1NuQ5PLJvqEqYa20GTsBDnKQ==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + + '@next/swc-linux-x64-musl@15.5.20': + resolution: {integrity: sha512-rAO5b7pKHvX+ExdmJskusDXTNbiNZfptifIPZItbUx+AOXxxTydVBsPt7Oz84DRd5mY8e0DcE8kvLj3AIfjE6w==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + + '@next/swc-win32-arm64-msvc@15.5.20': + resolution: {integrity: sha512-Hp3zFsN8N8Kj9+vY6L4vnZ9EtA9eXyATu0q4EfGbZTiocgPUNSfz8NWhym6xvaOmHpJ8EuoypuU1WejCPsTFtg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [win32] + + '@next/swc-win32-x64-msvc@15.5.20': + resolution: {integrity: sha512-T/L7CXpR1M0wij/xbF3rT1+7KvSkfOLr7C+ToHHWZTG2eKmb52C5WvsyGCBNtkVvDEUESWkRUbbqSH4rSbOCYQ==} + engines: {node: '>= 10'} + cpu: [x64] + os: [win32] + + '@rollup/rollup-android-arm-eabi@4.62.2': + resolution: {integrity: sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.62.2': + resolution: {integrity: sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.62.2': + resolution: {integrity: sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.62.2': + resolution: {integrity: sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==} + cpu: [x64] + os: [darwin] + + '@rollup/rollup-freebsd-arm64@4.62.2': + resolution: {integrity: sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.62.2': + resolution: {integrity: sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.62.2': + resolution: {integrity: sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm-musleabihf@4.62.2': + resolution: {integrity: sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm64-gnu@4.62.2': + resolution: {integrity: sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-arm64-musl@4.62.2': + resolution: {integrity: sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-loong64-gnu@4.62.2': + resolution: {integrity: sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==} + cpu: [loong64] + os: [linux] + + '@rollup/rollup-linux-loong64-musl@4.62.2': + resolution: {integrity: sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==} + cpu: [loong64] + os: [linux] + + '@rollup/rollup-linux-ppc64-gnu@4.62.2': + resolution: {integrity: sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==} + cpu: [ppc64] + os: [linux] + + '@rollup/rollup-linux-ppc64-musl@4.62.2': + resolution: {integrity: sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==} + cpu: [ppc64] + os: [linux] + + '@rollup/rollup-linux-riscv64-gnu@4.62.2': + resolution: {integrity: sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-riscv64-musl@4.62.2': + resolution: {integrity: sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-s390x-gnu@4.62.2': + resolution: {integrity: sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==} + cpu: [s390x] + os: [linux] + + '@rollup/rollup-linux-x64-gnu@4.62.2': + resolution: {integrity: sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-linux-x64-musl@4.62.2': + resolution: {integrity: sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-openbsd-x64@4.62.2': + resolution: {integrity: sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==} + cpu: [x64] + os: [openbsd] + + '@rollup/rollup-openharmony-arm64@4.62.2': + resolution: {integrity: sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==} + cpu: [arm64] + os: [openharmony] + + '@rollup/rollup-win32-arm64-msvc@4.62.2': + resolution: {integrity: sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.62.2': + resolution: {integrity: sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-gnu@4.62.2': + resolution: {integrity: sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==} + cpu: [x64] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.62.2': + resolution: {integrity: sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==} + cpu: [x64] + os: [win32] + + '@swc/helpers@0.5.15': + resolution: {integrity: sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==} + + '@types/estree@1.0.9': + resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==} + + '@types/node@22.20.0': + resolution: {integrity: sha512-QWlFW2wf3nTjC13/DqRnBpR4ZO36VJH/JVBkA/vcnmbTBNQIlnObqyqZE1tUR7+Ni23Lda8R1BxMfbXRpCUx5g==} + + '@types/pixelmatch@5.2.6': + resolution: {integrity: sha512-wC83uexE5KGuUODn6zkm9gMzTwdY5L0chiK+VrKcDfEjzxh1uadlWTvOmAbCpnM9zx/Ww3f8uKlYQVnO/TrqVg==} + + '@types/pngjs@6.0.5': + resolution: {integrity: sha512-0k5eKfrA83JOZPppLtS2C7OUtyNAl2wKNxfyYl9Q5g9lPkgBl/9hNyAu6HuEH2J4XmIv2znEpkDd0SaZVxW6iQ==} + + '@types/react-dom@19.2.3': + resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==} + peerDependencies: + '@types/react': ^19.2.0 + + '@types/react@19.2.17': + resolution: {integrity: sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==} + + '@vitest/expect@2.1.9': + resolution: {integrity: sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==} + + '@vitest/mocker@2.1.9': + resolution: {integrity: sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==} + peerDependencies: + msw: ^2.4.9 + vite: ^5.0.0 + peerDependenciesMeta: + msw: + optional: true + vite: + optional: true + + '@vitest/pretty-format@2.1.9': + resolution: {integrity: sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==} + + '@vitest/runner@2.1.9': + resolution: {integrity: sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==} + + '@vitest/snapshot@2.1.9': + resolution: {integrity: sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==} + + '@vitest/spy@2.1.9': + resolution: {integrity: sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==} + + '@vitest/utils@2.1.9': + resolution: {integrity: sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==} + + assertion-error@2.0.1: + resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} + engines: {node: '>=12'} + + cac@6.7.14: + resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} + engines: {node: '>=8'} + + caniuse-lite@1.0.30001800: + resolution: {integrity: sha512-MMHtuAz9Ys840zAY5F4k6fV5GaivZ9sPk+nz0mY+GYVzRBnYkN0mpqkSR92oWRQ19yQWo4HvBV/FnC16AJX8MA==} + + chai@5.3.3: + resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==} + engines: {node: '>=18'} + + check-error@2.1.3: + resolution: {integrity: sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==} + engines: {node: '>= 16'} + + client-only@0.0.1: + resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==} + + csstype@3.2.3: + resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==} + + debug@4.4.3: + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + deep-eql@5.0.2: + resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} + engines: {node: '>=6'} + + detect-libc@2.1.2: + resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==} + engines: {node: '>=8'} + + es-module-lexer@1.7.0: + resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==} + + esbuild@0.21.5: + resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==} + engines: {node: '>=12'} + hasBin: true + + esbuild@0.28.1: + resolution: {integrity: sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==} + engines: {node: '>=18'} + hasBin: true + + estree-walker@3.0.3: + resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} + + expect-type@1.4.0: + resolution: {integrity: sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==} + engines: {node: '>=12.0.0'} + + fsevents@2.3.2: + resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + + konva@9.3.22: + resolution: {integrity: sha512-yQI5d1bmELlD/fowuyfOp9ff+oamg26WOCkyqUyc+nczD/lhRa3EvD2MZOoc4c1293TAubW9n34fSQLgSeEgSw==} + + loupe@3.2.1: + resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==} + + magic-string@0.30.21: + resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + nanoid@3.3.15: + resolution: {integrity: sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + + next@15.5.20: + resolution: {integrity: sha512-cvyS3/geydan1xLtE3FA8VCgdoQ/Gg/dlOldFkFCbB5VcVYJV7090hQLBnvTW2PwT76Z/dHdzDZCsVhZpoOlUA==} + engines: {node: ^18.18.0 || ^19.8.0 || >= 20.0.0} + hasBin: true + peerDependencies: + '@opentelemetry/api': ^1.1.0 + '@playwright/test': ^1.51.1 + babel-plugin-react-compiler: '*' + react: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0 + react-dom: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0 + sass: ^1.3.0 + peerDependenciesMeta: + '@opentelemetry/api': + optional: true + '@playwright/test': + optional: true + babel-plugin-react-compiler: + optional: true + sass: + optional: true + + pathe@1.1.2: + resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==} + + pathval@2.0.1: + resolution: {integrity: sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==} + engines: {node: '>= 14.16'} + + picocolors@1.1.1: + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + + pixelmatch@6.0.0: + resolution: {integrity: sha512-FYpL4XiIWakTnIqLqvt3uN4L9B3TsuHIvhLILzTiJZMJUsGvmKNeL4H3b6I99LRyerK9W4IuOXw+N28AtRgK2g==} + hasBin: true + + playwright-core@1.61.1: + resolution: {integrity: sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==} + engines: {node: '>=18'} + hasBin: true + + playwright@1.61.1: + resolution: {integrity: sha512-DWnY5o3YbLWK4GovuAVwpqL+1VwGNdUGrRr++8j8PtQQzvAVZUIMjKQ90fY689sEJZJBbZVw1rXaOKSTitkzPQ==} + engines: {node: '>=18'} + hasBin: true + + pngjs@7.0.0: + resolution: {integrity: sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==} + engines: {node: '>=14.19.0'} + + postcss@8.4.31: + resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==} + engines: {node: ^10 || ^12 || >=14} + + postcss@8.5.16: + resolution: {integrity: sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==} + engines: {node: ^10 || ^12 || >=14} + + react-dom@19.2.7: + resolution: {integrity: sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==} + peerDependencies: + react: ^19.2.7 + + react@19.2.7: + resolution: {integrity: sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==} + engines: {node: '>=0.10.0'} + + rollup@4.62.2: + resolution: {integrity: sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==} + engines: {node: '>=18.0.0', npm: '>=8.0.0'} + hasBin: true + + scheduler@0.27.0: + resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==} + + semver@7.8.5: + resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==} + engines: {node: '>=10'} + hasBin: true + + sharp@0.34.5: + resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + + siginfo@2.0.0: + resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} + + source-map-js@1.2.1: + resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} + engines: {node: '>=0.10.0'} + + stackback@0.0.2: + resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} + + std-env@3.10.0: + resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==} + + styled-jsx@5.1.6: + resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==} + engines: {node: '>= 12.0.0'} + peerDependencies: + '@babel/core': '*' + babel-plugin-macros: '*' + react: '>= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0' + peerDependenciesMeta: + '@babel/core': + optional: true + babel-plugin-macros: + optional: true + + tinybench@2.9.0: + resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==} + + tinyexec@0.3.2: + resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==} + + tinypool@1.1.1: + resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==} + engines: {node: ^18.0.0 || >=20.0.0} + + tinyrainbow@1.2.0: + resolution: {integrity: sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==} + engines: {node: '>=14.0.0'} + + tinyspy@3.0.2: + resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==} + engines: {node: '>=14.0.0'} + + tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + + tsx@4.23.0: + resolution: {integrity: sha512-eUdUIaCr963q2h5u3+QwvYp0+eqPvn+egeqZUm0hwERCqqx1E3kK5ehbGCvqSE5MQAULr67ww0cA3jKc3YkM1w==} + engines: {node: '>=18.0.0'} + hasBin: true + + typescript@5.9.3: + resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==} + engines: {node: '>=14.17'} + hasBin: true + + undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + + vite-node@2.1.9: + resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + + vite@5.4.21: + resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@types/node': ^18.0.0 || >=20.0.0 + less: '*' + lightningcss: ^1.21.0 + sass: '*' + sass-embedded: '*' + stylus: '*' + sugarss: '*' + terser: ^5.4.0 + peerDependenciesMeta: + '@types/node': + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + sass-embedded: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + + vitest@2.1.9: + resolution: {integrity: sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@edge-runtime/vm': '*' + '@types/node': ^18.0.0 || >=20.0.0 + '@vitest/browser': 2.1.9 + '@vitest/ui': 2.1.9 + happy-dom: '*' + jsdom: '*' + peerDependenciesMeta: + '@edge-runtime/vm': + optional: true + '@types/node': + optional: true + '@vitest/browser': + optional: true + '@vitest/ui': + optional: true + happy-dom: + optional: true + jsdom: + optional: true + + why-is-node-running@2.3.0: + resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==} + engines: {node: '>=8'} + hasBin: true + + zod@3.25.76: + resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==} + +snapshots: + + '@emnapi/runtime@1.11.2': + dependencies: + tslib: 2.8.1 + optional: true + + '@esbuild/aix-ppc64@0.21.5': + optional: true + + '@esbuild/aix-ppc64@0.28.1': + optional: true + + '@esbuild/android-arm64@0.21.5': + optional: true + + '@esbuild/android-arm64@0.28.1': + optional: true + + '@esbuild/android-arm@0.21.5': + optional: true + + '@esbuild/android-arm@0.28.1': + optional: true + + '@esbuild/android-x64@0.21.5': + optional: true + + '@esbuild/android-x64@0.28.1': + optional: true + + '@esbuild/darwin-arm64@0.21.5': + optional: true + + '@esbuild/darwin-arm64@0.28.1': + optional: true + + '@esbuild/darwin-x64@0.21.5': + optional: true + + '@esbuild/darwin-x64@0.28.1': + optional: true + + '@esbuild/freebsd-arm64@0.21.5': + optional: true + + '@esbuild/freebsd-arm64@0.28.1': + optional: true + + '@esbuild/freebsd-x64@0.21.5': + optional: true + + '@esbuild/freebsd-x64@0.28.1': + optional: true + + '@esbuild/linux-arm64@0.21.5': + optional: true + + '@esbuild/linux-arm64@0.28.1': + optional: true + + '@esbuild/linux-arm@0.21.5': + optional: true + + '@esbuild/linux-arm@0.28.1': + optional: true + + '@esbuild/linux-ia32@0.21.5': + optional: true + + '@esbuild/linux-ia32@0.28.1': + optional: true + + '@esbuild/linux-loong64@0.21.5': + optional: true + + '@esbuild/linux-loong64@0.28.1': + optional: true + + '@esbuild/linux-mips64el@0.21.5': + optional: true + + '@esbuild/linux-mips64el@0.28.1': + optional: true + + '@esbuild/linux-ppc64@0.21.5': + optional: true + + '@esbuild/linux-ppc64@0.28.1': + optional: true + + '@esbuild/linux-riscv64@0.21.5': + optional: true + + '@esbuild/linux-riscv64@0.28.1': + optional: true + + '@esbuild/linux-s390x@0.21.5': + optional: true + + '@esbuild/linux-s390x@0.28.1': + optional: true + + '@esbuild/linux-x64@0.21.5': + optional: true + + '@esbuild/linux-x64@0.28.1': + optional: true + + '@esbuild/netbsd-arm64@0.28.1': + optional: true + + '@esbuild/netbsd-x64@0.21.5': + optional: true + + '@esbuild/netbsd-x64@0.28.1': + optional: true + + '@esbuild/openbsd-arm64@0.28.1': + optional: true + + '@esbuild/openbsd-x64@0.21.5': + optional: true + + '@esbuild/openbsd-x64@0.28.1': + optional: true + + '@esbuild/openharmony-arm64@0.28.1': + optional: true + + '@esbuild/sunos-x64@0.21.5': + optional: true + + '@esbuild/sunos-x64@0.28.1': + optional: true + + '@esbuild/win32-arm64@0.21.5': + optional: true + + '@esbuild/win32-arm64@0.28.1': + optional: true + + '@esbuild/win32-ia32@0.21.5': + optional: true + + '@esbuild/win32-ia32@0.28.1': + optional: true + + '@esbuild/win32-x64@0.21.5': + optional: true + + '@esbuild/win32-x64@0.28.1': + optional: true + + '@img/colour@1.1.0': + optional: true + + '@img/sharp-darwin-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-darwin-arm64': 1.2.4 + optional: true + + '@img/sharp-darwin-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-darwin-x64': 1.2.4 + optional: true + + '@img/sharp-libvips-darwin-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-darwin-x64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-arm@1.2.4': + optional: true + + '@img/sharp-libvips-linux-ppc64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-riscv64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-s390x@1.2.4': + optional: true + + '@img/sharp-libvips-linux-x64@1.2.4': + optional: true + + '@img/sharp-libvips-linuxmusl-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-linuxmusl-x64@1.2.4': + optional: true + + '@img/sharp-linux-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-arm64': 1.2.4 + optional: true + + '@img/sharp-linux-arm@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-arm': 1.2.4 + optional: true + + '@img/sharp-linux-ppc64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-ppc64': 1.2.4 + optional: true + + '@img/sharp-linux-riscv64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-riscv64': 1.2.4 + optional: true + + '@img/sharp-linux-s390x@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-s390x': 1.2.4 + optional: true + + '@img/sharp-linux-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-x64': 1.2.4 + optional: true + + '@img/sharp-linuxmusl-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 + optional: true + + '@img/sharp-linuxmusl-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-x64': 1.2.4 + optional: true + + '@img/sharp-wasm32@0.34.5': + dependencies: + '@emnapi/runtime': 1.11.2 + optional: true + + '@img/sharp-win32-arm64@0.34.5': + optional: true + + '@img/sharp-win32-ia32@0.34.5': + optional: true + + '@img/sharp-win32-x64@0.34.5': + optional: true + + '@jridgewell/sourcemap-codec@1.5.5': {} + + '@next/env@15.5.20': {} + + '@next/swc-darwin-arm64@15.5.20': + optional: true + + '@next/swc-darwin-x64@15.5.20': + optional: true + + '@next/swc-linux-arm64-gnu@15.5.20': + optional: true + + '@next/swc-linux-arm64-musl@15.5.20': + optional: true + + '@next/swc-linux-x64-gnu@15.5.20': + optional: true + + '@next/swc-linux-x64-musl@15.5.20': + optional: true + + '@next/swc-win32-arm64-msvc@15.5.20': + optional: true + + '@next/swc-win32-x64-msvc@15.5.20': + optional: true + + '@rollup/rollup-android-arm-eabi@4.62.2': + optional: true + + '@rollup/rollup-android-arm64@4.62.2': + optional: true + + '@rollup/rollup-darwin-arm64@4.62.2': + optional: true + + '@rollup/rollup-darwin-x64@4.62.2': + optional: true + + '@rollup/rollup-freebsd-arm64@4.62.2': + optional: true + + '@rollup/rollup-freebsd-x64@4.62.2': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.62.2': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.62.2': + optional: true + + '@rollup/rollup-linux-arm64-gnu@4.62.2': + optional: true + + '@rollup/rollup-linux-arm64-musl@4.62.2': + optional: true + + '@rollup/rollup-linux-loong64-gnu@4.62.2': + optional: true + + '@rollup/rollup-linux-loong64-musl@4.62.2': + optional: true + + '@rollup/rollup-linux-ppc64-gnu@4.62.2': + optional: true + + '@rollup/rollup-linux-ppc64-musl@4.62.2': + optional: true + + '@rollup/rollup-linux-riscv64-gnu@4.62.2': + optional: true + + '@rollup/rollup-linux-riscv64-musl@4.62.2': + optional: true + + '@rollup/rollup-linux-s390x-gnu@4.62.2': + optional: true + + '@rollup/rollup-linux-x64-gnu@4.62.2': + optional: true + + '@rollup/rollup-linux-x64-musl@4.62.2': + optional: true + + '@rollup/rollup-openbsd-x64@4.62.2': + optional: true + + '@rollup/rollup-openharmony-arm64@4.62.2': + optional: true + + '@rollup/rollup-win32-arm64-msvc@4.62.2': + optional: true + + '@rollup/rollup-win32-ia32-msvc@4.62.2': + optional: true + + '@rollup/rollup-win32-x64-gnu@4.62.2': + optional: true + + '@rollup/rollup-win32-x64-msvc@4.62.2': + optional: true + + '@swc/helpers@0.5.15': + dependencies: + tslib: 2.8.1 + + '@types/estree@1.0.9': {} + + '@types/node@22.20.0': + dependencies: + undici-types: 6.21.0 + + '@types/pixelmatch@5.2.6': + dependencies: + '@types/node': 22.20.0 + + '@types/pngjs@6.0.5': + dependencies: + '@types/node': 22.20.0 + + '@types/react-dom@19.2.3(@types/react@19.2.17)': + dependencies: + '@types/react': 19.2.17 + + '@types/react@19.2.17': + dependencies: + csstype: 3.2.3 + + '@vitest/expect@2.1.9': + dependencies: + '@vitest/spy': 2.1.9 + '@vitest/utils': 2.1.9 + chai: 5.3.3 + tinyrainbow: 1.2.0 + + '@vitest/mocker@2.1.9(vite@5.4.21(@types/node@22.20.0))': + dependencies: + '@vitest/spy': 2.1.9 + estree-walker: 3.0.3 + magic-string: 0.30.21 + optionalDependencies: + vite: 5.4.21(@types/node@22.20.0) + + '@vitest/pretty-format@2.1.9': + dependencies: + tinyrainbow: 1.2.0 + + '@vitest/runner@2.1.9': + dependencies: + '@vitest/utils': 2.1.9 + pathe: 1.1.2 + + '@vitest/snapshot@2.1.9': + dependencies: + '@vitest/pretty-format': 2.1.9 + magic-string: 0.30.21 + pathe: 1.1.2 + + '@vitest/spy@2.1.9': + dependencies: + tinyspy: 3.0.2 + + '@vitest/utils@2.1.9': + dependencies: + '@vitest/pretty-format': 2.1.9 + loupe: 3.2.1 + tinyrainbow: 1.2.0 + + assertion-error@2.0.1: {} + + cac@6.7.14: {} + + caniuse-lite@1.0.30001800: {} + + chai@5.3.3: + dependencies: + assertion-error: 2.0.1 + check-error: 2.1.3 + deep-eql: 5.0.2 + loupe: 3.2.1 + pathval: 2.0.1 + + check-error@2.1.3: {} + + client-only@0.0.1: {} + + csstype@3.2.3: {} + + debug@4.4.3: + dependencies: + ms: 2.1.3 + + deep-eql@5.0.2: {} + + detect-libc@2.1.2: + optional: true + + es-module-lexer@1.7.0: {} + + esbuild@0.21.5: + optionalDependencies: + '@esbuild/aix-ppc64': 0.21.5 + '@esbuild/android-arm': 0.21.5 + '@esbuild/android-arm64': 0.21.5 + '@esbuild/android-x64': 0.21.5 + '@esbuild/darwin-arm64': 0.21.5 + '@esbuild/darwin-x64': 0.21.5 + '@esbuild/freebsd-arm64': 0.21.5 + '@esbuild/freebsd-x64': 0.21.5 + '@esbuild/linux-arm': 0.21.5 + '@esbuild/linux-arm64': 0.21.5 + '@esbuild/linux-ia32': 0.21.5 + '@esbuild/linux-loong64': 0.21.5 + '@esbuild/linux-mips64el': 0.21.5 + '@esbuild/linux-ppc64': 0.21.5 + '@esbuild/linux-riscv64': 0.21.5 + '@esbuild/linux-s390x': 0.21.5 + '@esbuild/linux-x64': 0.21.5 + '@esbuild/netbsd-x64': 0.21.5 + '@esbuild/openbsd-x64': 0.21.5 + '@esbuild/sunos-x64': 0.21.5 + '@esbuild/win32-arm64': 0.21.5 + '@esbuild/win32-ia32': 0.21.5 + '@esbuild/win32-x64': 0.21.5 + + esbuild@0.28.1: + optionalDependencies: + '@esbuild/aix-ppc64': 0.28.1 + '@esbuild/android-arm': 0.28.1 + '@esbuild/android-arm64': 0.28.1 + '@esbuild/android-x64': 0.28.1 + '@esbuild/darwin-arm64': 0.28.1 + '@esbuild/darwin-x64': 0.28.1 + '@esbuild/freebsd-arm64': 0.28.1 + '@esbuild/freebsd-x64': 0.28.1 + '@esbuild/linux-arm': 0.28.1 + '@esbuild/linux-arm64': 0.28.1 + '@esbuild/linux-ia32': 0.28.1 + '@esbuild/linux-loong64': 0.28.1 + '@esbuild/linux-mips64el': 0.28.1 + '@esbuild/linux-ppc64': 0.28.1 + '@esbuild/linux-riscv64': 0.28.1 + '@esbuild/linux-s390x': 0.28.1 + '@esbuild/linux-x64': 0.28.1 + '@esbuild/netbsd-arm64': 0.28.1 + '@esbuild/netbsd-x64': 0.28.1 + '@esbuild/openbsd-arm64': 0.28.1 + '@esbuild/openbsd-x64': 0.28.1 + '@esbuild/openharmony-arm64': 0.28.1 + '@esbuild/sunos-x64': 0.28.1 + '@esbuild/win32-arm64': 0.28.1 + '@esbuild/win32-ia32': 0.28.1 + '@esbuild/win32-x64': 0.28.1 + + estree-walker@3.0.3: + dependencies: + '@types/estree': 1.0.9 + + expect-type@1.4.0: {} + + fsevents@2.3.2: + optional: true + + fsevents@2.3.3: + optional: true + + konva@9.3.22: {} + + loupe@3.2.1: {} + + magic-string@0.30.21: + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + + ms@2.1.3: {} + + nanoid@3.3.15: {} + + next@15.5.20(react-dom@19.2.7(react@19.2.7))(react@19.2.7): + dependencies: + '@next/env': 15.5.20 + '@swc/helpers': 0.5.15 + caniuse-lite: 1.0.30001800 + postcss: 8.4.31 + react: 19.2.7 + react-dom: 19.2.7(react@19.2.7) + styled-jsx: 5.1.6(react@19.2.7) + optionalDependencies: + '@next/swc-darwin-arm64': 15.5.20 + '@next/swc-darwin-x64': 15.5.20 + '@next/swc-linux-arm64-gnu': 15.5.20 + '@next/swc-linux-arm64-musl': 15.5.20 + '@next/swc-linux-x64-gnu': 15.5.20 + '@next/swc-linux-x64-musl': 15.5.20 + '@next/swc-win32-arm64-msvc': 15.5.20 + '@next/swc-win32-x64-msvc': 15.5.20 + sharp: 0.34.5 + transitivePeerDependencies: + - '@babel/core' + - babel-plugin-macros + + pathe@1.1.2: {} + + pathval@2.0.1: {} + + picocolors@1.1.1: {} + + pixelmatch@6.0.0: + dependencies: + pngjs: 7.0.0 + + playwright-core@1.61.1: {} + + playwright@1.61.1: + dependencies: + playwright-core: 1.61.1 + optionalDependencies: + fsevents: 2.3.2 + + pngjs@7.0.0: {} + + postcss@8.4.31: + dependencies: + nanoid: 3.3.15 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + postcss@8.5.16: + dependencies: + nanoid: 3.3.15 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + react-dom@19.2.7(react@19.2.7): + dependencies: + react: 19.2.7 + scheduler: 0.27.0 + + react@19.2.7: {} + + rollup@4.62.2: + dependencies: + '@types/estree': 1.0.9 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.62.2 + '@rollup/rollup-android-arm64': 4.62.2 + '@rollup/rollup-darwin-arm64': 4.62.2 + '@rollup/rollup-darwin-x64': 4.62.2 + '@rollup/rollup-freebsd-arm64': 4.62.2 + '@rollup/rollup-freebsd-x64': 4.62.2 + '@rollup/rollup-linux-arm-gnueabihf': 4.62.2 + '@rollup/rollup-linux-arm-musleabihf': 4.62.2 + '@rollup/rollup-linux-arm64-gnu': 4.62.2 + '@rollup/rollup-linux-arm64-musl': 4.62.2 + '@rollup/rollup-linux-loong64-gnu': 4.62.2 + '@rollup/rollup-linux-loong64-musl': 4.62.2 + '@rollup/rollup-linux-ppc64-gnu': 4.62.2 + '@rollup/rollup-linux-ppc64-musl': 4.62.2 + '@rollup/rollup-linux-riscv64-gnu': 4.62.2 + '@rollup/rollup-linux-riscv64-musl': 4.62.2 + '@rollup/rollup-linux-s390x-gnu': 4.62.2 + '@rollup/rollup-linux-x64-gnu': 4.62.2 + '@rollup/rollup-linux-x64-musl': 4.62.2 + '@rollup/rollup-openbsd-x64': 4.62.2 + '@rollup/rollup-openharmony-arm64': 4.62.2 + '@rollup/rollup-win32-arm64-msvc': 4.62.2 + '@rollup/rollup-win32-ia32-msvc': 4.62.2 + '@rollup/rollup-win32-x64-gnu': 4.62.2 + '@rollup/rollup-win32-x64-msvc': 4.62.2 + fsevents: 2.3.3 + + scheduler@0.27.0: {} + + semver@7.8.5: + optional: true + + sharp@0.34.5: + dependencies: + '@img/colour': 1.1.0 + detect-libc: 2.1.2 + semver: 7.8.5 + optionalDependencies: + '@img/sharp-darwin-arm64': 0.34.5 + '@img/sharp-darwin-x64': 0.34.5 + '@img/sharp-libvips-darwin-arm64': 1.2.4 + '@img/sharp-libvips-darwin-x64': 1.2.4 + '@img/sharp-libvips-linux-arm': 1.2.4 + '@img/sharp-libvips-linux-arm64': 1.2.4 + '@img/sharp-libvips-linux-ppc64': 1.2.4 + '@img/sharp-libvips-linux-riscv64': 1.2.4 + '@img/sharp-libvips-linux-s390x': 1.2.4 + '@img/sharp-libvips-linux-x64': 1.2.4 + '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 + '@img/sharp-libvips-linuxmusl-x64': 1.2.4 + '@img/sharp-linux-arm': 0.34.5 + '@img/sharp-linux-arm64': 0.34.5 + '@img/sharp-linux-ppc64': 0.34.5 + '@img/sharp-linux-riscv64': 0.34.5 + '@img/sharp-linux-s390x': 0.34.5 + '@img/sharp-linux-x64': 0.34.5 + '@img/sharp-linuxmusl-arm64': 0.34.5 + '@img/sharp-linuxmusl-x64': 0.34.5 + '@img/sharp-wasm32': 0.34.5 + '@img/sharp-win32-arm64': 0.34.5 + '@img/sharp-win32-ia32': 0.34.5 + '@img/sharp-win32-x64': 0.34.5 + optional: true + + siginfo@2.0.0: {} + + source-map-js@1.2.1: {} + + stackback@0.0.2: {} + + std-env@3.10.0: {} + + styled-jsx@5.1.6(react@19.2.7): + dependencies: + client-only: 0.0.1 + react: 19.2.7 + + tinybench@2.9.0: {} + + tinyexec@0.3.2: {} + + tinypool@1.1.1: {} + + tinyrainbow@1.2.0: {} + + tinyspy@3.0.2: {} + + tslib@2.8.1: {} + + tsx@4.23.0: + dependencies: + esbuild: 0.28.1 + optionalDependencies: + fsevents: 2.3.3 + + typescript@5.9.3: {} + + undici-types@6.21.0: {} + + vite-node@2.1.9(@types/node@22.20.0): + dependencies: + cac: 6.7.14 + debug: 4.4.3 + es-module-lexer: 1.7.0 + pathe: 1.1.2 + vite: 5.4.21(@types/node@22.20.0) + transitivePeerDependencies: + - '@types/node' + - less + - lightningcss + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + + vite@5.4.21(@types/node@22.20.0): + dependencies: + esbuild: 0.21.5 + postcss: 8.5.16 + rollup: 4.62.2 + optionalDependencies: + '@types/node': 22.20.0 + fsevents: 2.3.3 + + vitest@2.1.9(@types/node@22.20.0): + dependencies: + '@vitest/expect': 2.1.9 + '@vitest/mocker': 2.1.9(vite@5.4.21(@types/node@22.20.0)) + '@vitest/pretty-format': 2.1.9 + '@vitest/runner': 2.1.9 + '@vitest/snapshot': 2.1.9 + '@vitest/spy': 2.1.9 + '@vitest/utils': 2.1.9 + chai: 5.3.3 + debug: 4.4.3 + expect-type: 1.4.0 + magic-string: 0.30.21 + pathe: 1.1.2 + std-env: 3.10.0 + tinybench: 2.9.0 + tinyexec: 0.3.2 + tinypool: 1.1.1 + tinyrainbow: 1.2.0 + vite: 5.4.21(@types/node@22.20.0) + vite-node: 2.1.9(@types/node@22.20.0) + why-is-node-running: 2.3.0 + optionalDependencies: + '@types/node': 22.20.0 + transitivePeerDependencies: + - less + - lightningcss + - msw + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + + why-is-node-running@2.3.0: + dependencies: + siginfo: 2.0.0 + stackback: 0.0.2 + + zod@3.25.76: {} diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml new file mode 100644 index 00000000..0e5a0737 --- /dev/null +++ b/pnpm-workspace.yaml @@ -0,0 +1,3 @@ +packages: + - "packages/*" + - "apps/*" diff --git a/tsconfig.base.json b/tsconfig.base.json new file mode 100644 index 00000000..e95b9d35 --- /dev/null +++ b/tsconfig.base.json @@ -0,0 +1,20 @@ +{ + "$schema": "https://json.schemastore.org/tsconfig", + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "Bundler", + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "strict": true, + "noUncheckedIndexedAccess": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "resolveJsonModule": true, + "isolatedModules": true, + "verbatimModuleSyntax": true + } +} diff --git a/vitest.config.ts b/vitest.config.ts new file mode 100644 index 00000000..6d2d832c --- /dev/null +++ b/vitest.config.ts @@ -0,0 +1,11 @@ +import { defineConfig } from "vitest/config"; + +export default defineConfig({ + test: { + // Unit tests run in Node. The browser-dependent parity harness (Playwright) lives in its + // own package/config so it does not pull a headless browser into every unit run. + environment: "node", + include: ["packages/**/*.test.ts"], + exclude: ["**/node_modules/**", "**/dist/**", "e2e/**"], + }, +}); diff --git a/vitest.e2e.config.ts b/vitest.e2e.config.ts new file mode 100644 index 00000000..ba3028c3 --- /dev/null +++ b/vitest.e2e.config.ts @@ -0,0 +1,17 @@ +import { defineConfig } from "vitest/config"; + +/** + * The parity spike harness runs a real Next.js server + Chromium, so it is separated from the + * fast unit suite (`vitest.config.ts`). This is the Phase 0 gate (docs/roadmap.md §4). + */ +export default defineConfig({ + test: { + environment: "node", + include: ["e2e/**/*.test.ts"], + // Server startup + two browser launches; give it room. + testTimeout: 180_000, + hookTimeout: 180_000, + // One server for the whole file; no parallel files fighting over the port. + fileParallelism: false, + }, +}); From 384b4423f58a1c2a54686e4c7788e098db3656d9 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:54:25 +0300 Subject: [PATCH 009/368] feat: add core project schema and validator --- packages/core/package.json | 26 ++++++ packages/core/src/model/index.ts | 57 ++++++++++++ packages/core/src/model/migrate.ts | 17 ++++ packages/core/src/model/schema.test.ts | 88 ++++++++++++++++++ packages/core/src/model/schema.ts | 120 +++++++++++++++++++++++++ packages/core/tsconfig.json | 8 ++ 6 files changed, 316 insertions(+) create mode 100644 packages/core/package.json create mode 100644 packages/core/src/model/index.ts create mode 100644 packages/core/src/model/migrate.ts create mode 100644 packages/core/src/model/schema.test.ts create mode 100644 packages/core/src/model/schema.ts create mode 100644 packages/core/tsconfig.json diff --git a/packages/core/package.json b/packages/core/package.json new file mode 100644 index 00000000..f3230200 --- /dev/null +++ b/packages/core/package.json @@ -0,0 +1,26 @@ +{ + "name": "@screenshot-studio/core", + "version": "0.0.0", + "private": true, + "license": "Apache-2.0", + "type": "module", + "exports": { + "./model": "./src/model/index.ts", + "./engine": "./src/engine/index.ts", + "./export": "./src/export/index.ts", + "./fonts": "./src/fonts/index.ts", + "./storage": "./src/storage/index.ts" + }, + "scripts": { + "typecheck": "tsc --noEmit" + }, + "dependencies": { + "konva": "^9.3.16", + "pngjs": "^7.0.0", + "zod": "^3.24.1" + }, + "devDependencies": { + "@types/pngjs": "^6.0.5", + "playwright": "^1.49.1" + } +} diff --git a/packages/core/src/model/index.ts b/packages/core/src/model/index.ts new file mode 100644 index 00000000..02095c64 --- /dev/null +++ b/packages/core/src/model/index.ts @@ -0,0 +1,57 @@ +import { Project, type Project as ProjectType } from "./schema.js"; +import { migrateToCurrent } from "./migrate.js"; + +export * from "./schema.js"; +export { migrateToCurrent } from "./migrate.js"; + +/** Raised when a project fails schema validation. Carries the human-readable validator report. */ +export class ProjectValidationError extends Error { + constructor( + message: string, + readonly issues: string, + ) { + super(message); + this.name = "ProjectValidationError"; + } +} + +/** + * Parse + migrate + strictly validate a raw project object into a typed `Project`. + * The single load path for both UI and CLI — invalid input throws loudly (editor.md §7), + * never returns a partially-valid project. + */ +export function parseProject(raw: unknown): ProjectType { + const migrated = migrateToCurrent(raw); + const result = Project.safeParse(migrated); + if (!result.success) { + const issues = result.error.issues + .map((i) => ` • ${i.path.join(".") || "(root)"}: ${i.message}`) + .join("\n"); + throw new ProjectValidationError(`Invalid project JSON:\n${issues}`, issues); + } + return result.data; +} + +/** Parse a JSON string into a validated `Project`. */ +export function parseProjectJson(json: string): ProjectType { + let raw: unknown; + try { + raw = JSON.parse(json); + } catch (err) { + throw new ProjectValidationError( + `Project file is not valid JSON: ${(err as Error).message}`, + "", + ); + } + return parseProject(raw); +} + +/** Look up a screen by id, or throw with a clear message. */ +export function getScreen(project: ProjectType, screenId: string) { + const screen = project.screens.find((s) => s.id === screenId); + if (!screen) { + const known = project.screens.map((s) => s.id).join(", "); + throw new Error(`Screen "${screenId}" not found. Known screens: ${known}`); + } + return screen; +} diff --git a/packages/core/src/model/migrate.ts b/packages/core/src/model/migrate.ts new file mode 100644 index 00000000..01dc06e7 --- /dev/null +++ b/packages/core/src/model/migrate.ts @@ -0,0 +1,17 @@ +import { SCHEMA_VERSION } from "./schema.js"; + +/** + * Migration seam. No migrations exist yet (we are at v1), but the entry point is here from + * day 0 so that pure `vN → vN+1` steps can be added without touching load call sites, per + * docs/roadmap.md ("State model is the one exception we design up front"). + * + * Takes an unknown, still-unvalidated object (the raw parsed JSON) and returns an object at the + * current `schemaVersion`, ready to hand to the Zod validator. + */ +export function migrateToCurrent(raw: unknown): unknown { + if (typeof raw !== "object" || raw === null) return raw; + const version = (raw as { meta?: { schemaVersion?: unknown } }).meta?.schemaVersion; + if (version === SCHEMA_VERSION) return raw; + // Future: while (version < SCHEMA_VERSION) raw = migrations[version](raw) + return raw; +} diff --git a/packages/core/src/model/schema.test.ts b/packages/core/src/model/schema.test.ts new file mode 100644 index 00000000..2c87aa2a --- /dev/null +++ b/packages/core/src/model/schema.test.ts @@ -0,0 +1,88 @@ +import { describe, it, expect } from "vitest"; +import { parseProject, ProjectValidationError, getScreen, SCHEMA_VERSION } from "./index.js"; + +function validProject() { + return { + meta: { name: "Sample", schemaVersion: SCHEMA_VERSION }, + platforms: ["apple"], + locales: ["en"], + fonts: [], + screens: [ + { + id: "s1", + name: "Screen 1", + platform: "apple", + device: "iphone", + locale: "en", + artboard: { width: 1320, height: 2868 }, + background: { type: "solid", color: "#0A0A0A" }, + elements: [ + { + id: "t1", + type: "text", + x: 100, + y: 100, + width: 1120, + height: 300, + content: "Hello", + fontFamily: "Inter", + size: 96, + color: "#FFFFFF", + }, + ], + }, + ], + }; +} + +describe("parseProject", () => { + it("accepts a valid project and applies element defaults", () => { + const project = parseProject(validProject()); + const el = project.screens[0]!.elements[0]!; + expect(el.opacity).toBe(1); + expect(el.visible).toBe(true); + expect(el.rotation).toBe(0); + }); + + it("rejects unknown keys (strict contract)", () => { + const bad = validProject(); + (bad as Record).unexpected = true; + expect(() => parseProject(bad)).toThrow(ProjectValidationError); + }); + + it("rejects a wrong schemaVersion", () => { + const bad = validProject(); + bad.meta.schemaVersion = 99 as unknown as typeof SCHEMA_VERSION; + expect(() => parseProject(bad)).toThrow(ProjectValidationError); + }); + + it("rejects a non-hex color", () => { + const bad = validProject(); + bad.screens[0]!.background.color = "black"; + expect(() => parseProject(bad)).toThrow(ProjectValidationError); + }); + + it("rejects an unknown element type via the discriminated union", () => { + const bad = validProject(); + (bad.screens[0]!.elements[0] as Record).type = "screenshot"; + expect(() => parseProject(bad)).toThrow(ProjectValidationError); + }); + + it("requires at least one screen", () => { + const bad = validProject(); + bad.screens = []; + expect(() => parseProject(bad)).toThrow(ProjectValidationError); + }); +}); + +describe("getScreen", () => { + it("returns a screen by id", () => { + const project = parseProject(validProject()); + expect(getScreen(project, "s1").name).toBe("Screen 1"); + }); + + it("throws for an unknown screen id", () => { + const project = parseProject(validProject()); + expect(() => getScreen(project, "nope")).toThrow(/not found/); + }); +}); diff --git a/packages/core/src/model/schema.ts b/packages/core/src/model/schema.ts new file mode 100644 index 00000000..3c1542b8 --- /dev/null +++ b/packages/core/src/model/schema.ts @@ -0,0 +1,120 @@ +import { z } from "zod"; + +/** + * Phase 0 schema subset. Only what the parity spike needs: one apple/iphone screen, a solid + * background, and the two element types that carry the parity risk cheaply (`shape`) and + * expensively (`text`, the hardest cross-renderer case). `screenshot`/`device-frame`/`icon`/ + * `badge`/`image` are intentionally absent until Phase 1 — adding them here would widen the + * validator surface without helping prove parity. See docs/architecture.md §3. + * + * Objects are `.strict()` on purpose: the project JSON is the agent contract, so an unknown + * key must fail loudly rather than be silently dropped. + */ + +export const SCHEMA_VERSION = 1; + +const hexColor = z + .string() + .regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, "expected a hex color like #RRGGBB"); + +const unitInterval = z.number().min(0).max(1); + +/** Fields every element shares (docs/architecture.md §3). z-order is array order in `elements`. */ +const elementBase = { + id: z.string().min(1), + x: z.number(), + y: z.number(), + width: z.number().positive(), + height: z.number().positive(), + rotation: z.number().default(0), + opacity: unitInterval.default(1), + locked: z.boolean().default(false), + visible: z.boolean().default(true), +}; + +export const TextElement = z + .object({ + type: z.literal("text"), + ...elementBase, + content: z.string(), + fontFamily: z.string().min(1), + size: z.number().positive(), + weight: z.number().int().min(100).max(900).default(400), + lineHeight: z.number().positive().default(1.2), + letterSpacing: z.number().default(0), + align: z.enum(["left", "center", "right"]).default("left"), + color: hexColor, + }) + .strict(); +export type TextElement = z.infer; + +export const ShapeElement = z + .object({ + type: z.literal("shape"), + ...elementBase, + kind: z.literal("rect"), + fill: hexColor, + radius: z.number().min(0).default(0), + }) + .strict(); +export type ShapeElement = z.infer; + +export const Element = z.discriminatedUnion("type", [TextElement, ShapeElement]); +export type Element = z.infer; + +export const SolidBackground = z + .object({ + type: z.literal("solid"), + color: hexColor, + }) + .strict(); +export type SolidBackground = z.infer; + +/** Only `solid` in Phase 0; the discriminated union leaves room for gradient/image later. */ +export const Background = z.discriminatedUnion("type", [SolidBackground]); +export type Background = z.infer; + +/** Custom font embedded as base64 so the deck is self-contained (docs/architecture.md §5). */ +export const FontAsset = z + .object({ + family: z.string().min(1), + source: z.literal("uploaded"), + /** Base64 of the .woff2/.ttf/.otf bytes (no data-URL prefix). */ + data: z.string().min(1), + weight: z.number().int().min(100).max(900).default(400), + }) + .strict(); +export type FontAsset = z.infer; + +export const Screen = z + .object({ + id: z.string().min(1), + name: z.string().min(1), + platform: z.literal("apple"), + device: z.literal("iphone"), + locale: z.string().min(1), + artboard: z + .object({ width: z.number().int().positive(), height: z.number().int().positive() }) + .strict(), + background: Background, + elements: z.array(Element), + }) + .strict(); +export type Screen = z.infer; + +export const Project = z + .object({ + meta: z + .object({ + name: z.string().min(1), + appIcon: z.string().optional(), + schemaVersion: z.literal(SCHEMA_VERSION), + }) + .strict(), + platforms: z.array(z.literal("apple")).min(1), + locales: z.array(z.string().min(1)).min(1), + fonts: z.array(FontAsset).default([]), + screens: z.array(Screen).min(1), + }) + .strict(); +export type Project = z.infer; diff --git a/packages/core/tsconfig.json b/packages/core/tsconfig.json new file mode 100644 index 00000000..5285d28a --- /dev/null +++ b/packages/core/tsconfig.json @@ -0,0 +1,8 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "rootDir": "src", + "outDir": "dist" + }, + "include": ["src"] +} From 8e0febc3a7531f02d5e19bfe8a2e4a8eeecfc38e Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:55:33 +0300 Subject: [PATCH 010/368] chore: stop ignoring the core export source module --- .gitignore | 4 +++- store-specs.json | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 store-specs.json diff --git a/.gitignore b/.gitignore index cf528be0..dec6d0a8 100644 --- a/.gitignore +++ b/.gitignore @@ -36,8 +36,10 @@ test-results/ blob-report/ .playwright/ -# Generated screenshot bundles (CLI export output) +# Generated screenshot bundles (CLI export output). The unanchored pattern also matches the +# core source module of the same name, so re-include that explicitly. export/ +!packages/core/src/export/ # Lint / tool caches .eslintcache diff --git a/store-specs.json b/store-specs.json new file mode 100644 index 00000000..0fbce607 --- /dev/null +++ b/store-specs.json @@ -0,0 +1,19 @@ +{ + "$comment": "Store export sizes as DATA, not hardcode (docs/architecture.md §4). Apple values are accepted sizes Apple publishes; Google values are recommended presets within Google's allowed ranges. store-specs.json is the runtime source of truth for export dimensions. Phase 0 ships the apple/iphone lead size the sample fixture targets; the rest are seeded for Phase 2.", + "apple": { + "iphone": [ + { "id": "6.9", "label": "6.9\" iPhone (lead)", "width": 1320, "height": 2868, "orientation": "portrait" }, + { "id": "6.5", "label": "6.5\" iPhone", "width": 1284, "height": 2778, "orientation": "portrait" }, + { "id": "6.3", "label": "6.3\" iPhone", "width": 1206, "height": 2622, "orientation": "portrait" }, + { "id": "6.1", "label": "6.1\" iPhone", "width": 1125, "height": 2436, "orientation": "portrait" } + ], + "ipad": [ + { "id": "13", "label": "iPad 13\"", "width": 2064, "height": 2752, "orientation": "portrait" } + ] + }, + "android": { + "phone": [ + { "id": "phone-portrait", "label": "Phone portrait", "width": 1080, "height": 1920, "orientation": "portrait" } + ] + } +} From e6e8ab43176e248945f8bbed00f8235c153c4d12 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:55:33 +0300 Subject: [PATCH 011/368] feat: add store specs and export helpers --- packages/core/src/export/export.test.ts | 74 ++++++++++++++++++++ packages/core/src/export/index.ts | 3 + packages/core/src/export/pixel-ratio.test.ts | 19 +++++ packages/core/src/export/pixel-ratio.ts | 20 ++++++ packages/core/src/export/png.ts | 73 +++++++++++++++++++ packages/core/src/export/specs.ts | 51 ++++++++++++++ 6 files changed, 240 insertions(+) create mode 100644 packages/core/src/export/export.test.ts create mode 100644 packages/core/src/export/index.ts create mode 100644 packages/core/src/export/pixel-ratio.test.ts create mode 100644 packages/core/src/export/pixel-ratio.ts create mode 100644 packages/core/src/export/png.ts create mode 100644 packages/core/src/export/specs.ts diff --git a/packages/core/src/export/export.test.ts b/packages/core/src/export/export.test.ts new file mode 100644 index 00000000..8b46dc73 --- /dev/null +++ b/packages/core/src/export/export.test.ts @@ -0,0 +1,74 @@ +import { describe, it, expect } from "vitest"; +import { readFileSync } from "node:fs"; +import { fileURLToPath } from "node:url"; +import { PNG } from "pngjs"; +import { parseStoreSpecs, findStoreSize } from "./specs.js"; +import { stripAlpha, inspectPng, assertDimensions, base64PngToBuffer } from "./png.js"; + +const storeSpecsRaw = JSON.parse( + readFileSync(fileURLToPath(new URL("../../../../store-specs.json", import.meta.url)), "utf8"), +); + +/** Build a small PNG with a semi-transparent pixel for the alpha tests. */ +function makePng(width: number, height: number, alpha: number): Buffer { + const png = new PNG({ width, height }); + for (let i = 0; i < png.data.length; i += 4) { + png.data[i] = 200; + png.data[i + 1] = 100; + png.data[i + 2] = 50; + png.data[i + 3] = alpha; + } + return PNG.sync.write(png); +} + +describe("store-specs.json", () => { + it("validates and exposes the apple/iphone lead size the fixture targets", () => { + const specs = parseStoreSpecs(storeSpecsRaw); + const lead = findStoreSize(specs, "apple", "iphone", "6.9"); + expect(lead.width).toBe(1320); + expect(lead.height).toBe(2868); + }); + + it("throws for an unknown size id, listing valid options", () => { + const specs = parseStoreSpecs(storeSpecsRaw); + expect(() => findStoreSize(specs, "apple", "iphone", "5.5")).toThrow(/Known:/); + }); +}); + +describe("stripAlpha", () => { + it("flattens transparency onto the background and forces opacity", () => { + const semi = makePng(4, 4, 0); // fully transparent → becomes pure background + const flattened = stripAlpha(semi, { r: 255, g: 255, b: 255 }); + const info = inspectPng(flattened); + expect(info.hasAlpha).toBe(false); + + const decoded = PNG.sync.read(flattened); + expect(decoded.data[0]).toBe(255); // r == background + expect(decoded.data[3]).toBe(255); // alpha forced opaque + }); + + it("reports the alpha channel by format presence, not opacity", () => { + // makePng always writes RGBA (color type 6), so the channel is present even when opaque. + expect(inspectPng(makePng(2, 2, 128)).hasAlpha).toBe(true); + expect(inspectPng(makePng(2, 2, 255)).hasAlpha).toBe(true); + // Only stripping removes the channel entirely. + expect(inspectPng(stripAlpha(makePng(2, 2, 128))).hasAlpha).toBe(false); + }); +}); + +describe("assertDimensions", () => { + it("passes on an exact match and throws otherwise", () => { + const png = makePng(10, 20, 255); + expect(() => assertDimensions(png, { width: 10, height: 20 })).not.toThrow(); + expect(() => assertDimensions(png, { width: 10, height: 21 })).toThrow(/mismatch/); + }); +}); + +describe("base64PngToBuffer", () => { + it("handles both raw base64 and data URLs", () => { + const png = makePng(2, 2, 255); + const b64 = png.toString("base64"); + expect(base64PngToBuffer(b64).equals(png)).toBe(true); + expect(base64PngToBuffer(`data:image/png;base64,${b64}`).equals(png)).toBe(true); + }); +}); diff --git a/packages/core/src/export/index.ts b/packages/core/src/export/index.ts new file mode 100644 index 00000000..f13ec568 --- /dev/null +++ b/packages/core/src/export/index.ts @@ -0,0 +1,3 @@ +export * from "./specs.js"; +export * from "./png.js"; +export * from "./pixel-ratio.js"; diff --git a/packages/core/src/export/pixel-ratio.test.ts b/packages/core/src/export/pixel-ratio.test.ts new file mode 100644 index 00000000..4176946c --- /dev/null +++ b/packages/core/src/export/pixel-ratio.test.ts @@ -0,0 +1,19 @@ +import { describe, it, expect } from "vitest"; +import { exportPixelRatio } from "./index.js"; + +describe("exportPixelRatio", () => { + it("scales a half-size artboard up to the store target", () => { + const ratio = exportPixelRatio({ width: 660, height: 1434 }, { width: 1320, height: 2868 }); + expect(ratio).toBe(2); + }); + + it("returns 1 when the artboard already matches the target", () => { + expect(exportPixelRatio({ width: 1320, height: 2868 }, { width: 1320, height: 2868 })).toBe(1); + }); + + it("throws when aspect ratios differ (would distort)", () => { + expect(() => exportPixelRatio({ width: 1000, height: 1000 }, { width: 1320, height: 2868 })).toThrow( + /distort/, + ); + }); +}); diff --git a/packages/core/src/export/pixel-ratio.ts b/packages/core/src/export/pixel-ratio.ts new file mode 100644 index 00000000..8470bc2d --- /dev/null +++ b/packages/core/src/export/pixel-ratio.ts @@ -0,0 +1,20 @@ +/** + * Compute the pixelRatio that scales an artboard up to an exact store target size. + * UI and CLI both export via `Stage.toDataURL({ pixelRatio })` (docs/architecture.md §4), so + * this is the one place the design-size → export-size scale is derived. Konva-free on purpose, + * so it is unit-testable in Node without pulling the browser renderer. + */ +export function exportPixelRatio( + artboard: { width: number; height: number }, + target: { width: number; height: number }, +): number { + const ratioX = target.width / artboard.width; + const ratioY = target.height / artboard.height; + if (Math.abs(ratioX - ratioY) > 1e-6) { + throw new Error( + `Artboard ${artboard.width}×${artboard.height} aspect ratio does not match target ` + + `${target.width}×${target.height}; export would distort.`, + ); + } + return ratioX; +} diff --git a/packages/core/src/export/png.ts b/packages/core/src/export/png.ts new file mode 100644 index 00000000..8650b1c2 --- /dev/null +++ b/packages/core/src/export/png.ts @@ -0,0 +1,73 @@ +import { PNG } from "pngjs"; + +/** + * PNG post-processing that runs in Node after the browser hands back rendered pixels. + * The rendering itself happens in the browser (Konva `Stage.toDataURL`) — this module never + * imports Konva, keeping the Node side framework-agnostic (docs/architecture.md §2). + */ + +export interface PngInfo { + width: number; + height: number; + /** True if the PNG *format* carries an alpha channel (color type 4 or 6), regardless of + * whether every pixel is opaque. Stores require the channel to be absent, not just opaque. */ + hasAlpha: boolean; +} + +/** Decode a PNG buffer to raw RGBA + metadata. */ +function decode(buffer: Buffer): PNG { + return PNG.sync.read(buffer); +} + +/** Color type lives in the IHDR chunk at a fixed byte offset (8 sig + 4 len + 4 tag + 4 w + 4 h + * + 1 bit depth = 25). Bit 2 (value 4) of the color type signals an alpha channel. */ +function colorTypeOf(buffer: Buffer): number { + return buffer[25]!; +} + +/** Read dimensions and whether the PNG format includes an alpha channel. */ +export function inspectPng(buffer: Buffer): PngInfo { + const png = decode(buffer); + return { width: png.width, height: png.height, hasAlpha: (colorTypeOf(buffer) & 4) !== 0 }; +} + +/** + * Flatten a PNG onto an opaque background and re-encode with the alpha channel forced opaque. + * Stores reject transparency: Apple requires flattened RGB, Google requires no transparency + * (docs/architecture.md §4). Default background is white; callers may override. + */ +export function stripAlpha(buffer: Buffer, background = { r: 255, g: 255, b: 255 }): Buffer { + const png = decode(buffer); + const data = png.data; + for (let i = 0; i < data.length; i += 4) { + const alpha = data[i + 3]!; + if (alpha === 255) continue; + const a = alpha / 255; + data[i] = Math.round(data[i]! * a + background.r * (1 - a)); + data[i + 1] = Math.round(data[i + 1]! * a + background.g * (1 - a)); + data[i + 2] = Math.round(data[i + 2]! * a + background.b * (1 - a)); + data[i + 3] = 255; + } + // Emit true 24-bit RGB (color type 2): drop the alpha channel entirely, not merely set it + // opaque. Apple requires flattened RGB and Google 24-bit PNG with no transparency (§4). + return PNG.sync.write(png, { colorType: 2, inputColorType: 6 }); +} + +/** Assert a rendered PNG matches the expected store size exactly, or throw. */ +export function assertDimensions(buffer: Buffer, expected: { width: number; height: number }): void { + const info = inspectPng(buffer); + if (info.width !== expected.width || info.height !== expected.height) { + throw new Error( + `Export dimension mismatch: got ${info.width}×${info.height}, expected ${expected.width}×${expected.height}`, + ); + } +} + +/** Decode base64 (optionally a `data:image/png;base64,...` URL) into a Buffer. */ +export function base64PngToBuffer(dataUrlOrBase64: string): Buffer { + const comma = dataUrlOrBase64.indexOf(","); + const b64 = dataUrlOrBase64.startsWith("data:") && comma >= 0 + ? dataUrlOrBase64.slice(comma + 1) + : dataUrlOrBase64; + return Buffer.from(b64, "base64"); +} diff --git a/packages/core/src/export/specs.ts b/packages/core/src/export/specs.ts new file mode 100644 index 00000000..3a8f3d1a --- /dev/null +++ b/packages/core/src/export/specs.ts @@ -0,0 +1,51 @@ +import { z } from "zod"; + +/** + * Loader + validator for store-specs.json. Store sizes are data, not hardcode + * (docs/architecture.md §4): Apple/Google change them over time, so they live in one JSON + * file that both export and its dimension tests read. + */ + +const StoreSize = z + .object({ + id: z.string(), + label: z.string(), + width: z.number().int().positive(), + height: z.number().int().positive(), + orientation: z.enum(["portrait", "landscape"]), + }) + .strict(); +export type StoreSize = z.infer; + +// Platform → device → sizes. `.passthrough()` at the platform level tolerates the leading +// "$comment" key without listing every platform explicitly. +const StoreSpecs = z.record(z.record(z.array(StoreSize))); +export type StoreSpecs = z.infer; + +export function parseStoreSpecs(raw: unknown): StoreSpecs { + // Drop the documentation-only "$comment" key before validating. + const { $comment: _drop, ...rest } = (raw ?? {}) as Record; + return StoreSpecs.parse(rest); +} + +/** Find one size by platform/device/id, or throw with the valid options listed. */ +export function findStoreSize( + specs: StoreSpecs, + platform: string, + device: string, + sizeId: string, +): StoreSize { + const sizes = specs[platform]?.[device]; + if (!sizes) { + throw new Error(`No store sizes for ${platform}/${device}`); + } + const size = sizes.find((s) => s.id === sizeId); + if (!size) { + throw new Error( + `Unknown size "${sizeId}" for ${platform}/${device}. Known: ${sizes + .map((s) => s.id) + .join(", ")}`, + ); + } + return size; +} From 953f473ef8cbe44c901d51c6c4aeecda2ddf5e20 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:55:39 +0300 Subject: [PATCH 012/368] feat: add konva renderer, fonts, and storage adapter --- packages/core/src/engine/index.ts | 1 + packages/core/src/engine/render.ts | 83 ++++++++++++++++++++++++++++++ packages/core/src/fonts/index.ts | 38 ++++++++++++++ packages/core/src/storage/index.ts | 40 ++++++++++++++ 4 files changed, 162 insertions(+) create mode 100644 packages/core/src/engine/index.ts create mode 100644 packages/core/src/engine/render.ts create mode 100644 packages/core/src/fonts/index.ts create mode 100644 packages/core/src/storage/index.ts diff --git a/packages/core/src/engine/index.ts b/packages/core/src/engine/index.ts new file mode 100644 index 00000000..0423520a --- /dev/null +++ b/packages/core/src/engine/index.ts @@ -0,0 +1 @@ +export { renderScreen } from "./render.js"; diff --git a/packages/core/src/engine/render.ts b/packages/core/src/engine/render.ts new file mode 100644 index 00000000..5f61f40f --- /dev/null +++ b/packages/core/src/engine/render.ts @@ -0,0 +1,83 @@ +import Konva from "konva"; +import type { Project, Screen, Element } from "../model/schema.js"; +import { getScreen } from "../model/index.js"; + +/** + * The single rendering path (docs/architecture.md §2). Both the web /render route and the CLI + * export (via a headless browser) call this exact code, so UI and CLI share one renderer — never + * add a second. Runs in a browser: Konva draws onto a real ``. + * + * z-order is array order in `screen.elements` (docs/architecture.md §3): later elements draw on + * top. The layer is not clipped here because Phase 0 renders one isolated artboard at 1:1; the + * isolated-artboard clip is an editor concern (editor.md §2), not an export concern. + */ +export function renderScreen( + container: HTMLDivElement, + project: Project, + screenId: string, +): Konva.Stage { + const screen = getScreen(project, screenId); + const { width, height } = screen.artboard; + + const stage = new Konva.Stage({ container, width, height }); + const layer = new Konva.Layer({ listening: false }); + stage.add(layer); + + drawBackground(layer, screen); + for (const element of screen.elements) { + if (!element.visible) continue; + drawElement(layer, element); + } + + layer.draw(); + return stage; +} + +function drawBackground(layer: Konva.Layer, screen: Screen): void { + const { width, height } = screen.artboard; + if (screen.background.type === "solid") { + layer.add(new Konva.Rect({ x: 0, y: 0, width, height, fill: screen.background.color })); + } +} + +function drawElement(layer: Konva.Layer, element: Element): void { + const common = { + x: element.x, + y: element.y, + rotation: element.rotation, + opacity: element.opacity, + }; + + if (element.type === "shape") { + layer.add( + new Konva.Rect({ + ...common, + width: element.width, + height: element.height, + fill: element.fill, + cornerRadius: element.radius, + }), + ); + return; + } + + if (element.type === "text") { + layer.add( + new Konva.Text({ + ...common, + width: element.width, + height: element.height, + text: element.content, + fontFamily: element.fontFamily, + fontSize: element.size, + // Konva folds fontStyle into the canvas font shorthand; a numeric weight string + // ("600 96px Family") is valid CSS, so this maps custom weights directly. + fontStyle: String(element.weight), + lineHeight: element.lineHeight, + letterSpacing: element.letterSpacing, + align: element.align, + fill: element.color, + }), + ); + } +} diff --git a/packages/core/src/fonts/index.ts b/packages/core/src/fonts/index.ts new file mode 100644 index 00000000..891dc666 --- /dev/null +++ b/packages/core/src/fonts/index.ts @@ -0,0 +1,38 @@ +import type { FontAsset } from "../model/schema.js"; + +/** + * Browser-side font registration. Runs before any render so the embedded custom font is the + * one that actually paints — the font-load race is the concrete failure mode behind the #1 + * parity risk (docs/architecture.md §5). Callers MUST await this and `whenFontsReady()` before + * screenshotting; otherwise the first frame can render with a system fallback. + */ + +function base64ToArrayBuffer(base64: string): ArrayBuffer { + const binary = atob(base64); + const bytes = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i); + return bytes.buffer; +} + +/** Register one embedded font with the document and wait for it to load. */ +export async function registerFont(asset: FontAsset): Promise { + const face = new FontFace(asset.family, base64ToArrayBuffer(asset.data), { + weight: String(asset.weight), + }); + await face.load(); + document.fonts.add(face); +} + +/** Register every embedded font in a project, then wait for the font set to settle. */ +export async function registerProjectFonts(fonts: FontAsset[]): Promise { + await Promise.all(fonts.map(registerFont)); + await document.fonts.ready; +} + +/** + * Resolve once a specific family is usable at a given size. Belt-and-suspenders on top of + * `document.fonts.ready` for the exact family/size a screen renders with. + */ +export async function whenFontReady(family: string, size: number): Promise { + await document.fonts.load(`${size}px "${family}"`); +} diff --git a/packages/core/src/storage/index.ts b/packages/core/src/storage/index.ts new file mode 100644 index 00000000..7735f834 --- /dev/null +++ b/packages/core/src/storage/index.ts @@ -0,0 +1,40 @@ +import { readFile, writeFile, mkdir } from "node:fs/promises"; +import { createHash } from "node:crypto"; +import { dirname, join } from "node:path"; +import { parseProjectJson, type Project } from "../model/index.js"; + +/** + * Storage boundary (docs/architecture.md §2). `core` depends on this interface, not a concrete + * store, so the community can add browser FS / IndexedDB adapters without touching the engine. + */ +export interface StorageAdapter { + load(projectId: string): Promise; + save(project: Project, projectId: string): Promise; + putAsset(bytes: Uint8Array): Promise<{ url: string; hash: string }>; +} + +/** + * Reference adapter: reads/writes the project JSON and assets on local disk, like the + * self-hosted product. `projectId` is a filesystem path to the project JSON file. + */ +export class LocalFileStorageAdapter implements StorageAdapter { + constructor(private readonly assetsDir: string) {} + + async load(projectId: string): Promise { + const json = await readFile(projectId, "utf8"); + return parseProjectJson(json); + } + + async save(project: Project, projectId: string): Promise { + await mkdir(dirname(projectId), { recursive: true }); + await writeFile(projectId, `${JSON.stringify(project, null, 2)}\n`, "utf8"); + } + + async putAsset(bytes: Uint8Array): Promise<{ url: string; hash: string }> { + const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 16); + const path = join(this.assetsDir, hash); + await mkdir(this.assetsDir, { recursive: true }); + await writeFile(path, bytes); + return { url: path, hash }; + } +} From 0df709e951d089562792673f92b77dfaa4ec4d18 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:55:43 +0300 Subject: [PATCH 013/368] feat: add web render host and screenshots CLI --- apps/web/app/layout.tsx | 14 +++++ apps/web/app/render/RenderStage.tsx | 68 ++++++++++++++++++++ apps/web/app/render/page.tsx | 45 ++++++++++++++ apps/web/next.config.mjs | 20 ++++++ apps/web/package.json | 23 +++++++ apps/web/tsconfig.json | 33 ++++++++++ packages/cli/package.json | 21 +++++++ packages/cli/src/export.ts | 58 +++++++++++++++++ packages/cli/src/index.ts | 96 +++++++++++++++++++++++++++++ packages/cli/src/init.ts | 78 +++++++++++++++++++++++ packages/cli/src/render-driver.ts | 64 +++++++++++++++++++ packages/cli/src/server.ts | 58 +++++++++++++++++ packages/cli/tsconfig.json | 10 +++ 13 files changed, 588 insertions(+) create mode 100644 apps/web/app/layout.tsx create mode 100644 apps/web/app/render/RenderStage.tsx create mode 100644 apps/web/app/render/page.tsx create mode 100644 apps/web/next.config.mjs create mode 100644 apps/web/package.json create mode 100644 apps/web/tsconfig.json create mode 100644 packages/cli/package.json create mode 100644 packages/cli/src/export.ts create mode 100644 packages/cli/src/index.ts create mode 100644 packages/cli/src/init.ts create mode 100644 packages/cli/src/render-driver.ts create mode 100644 packages/cli/src/server.ts create mode 100644 packages/cli/tsconfig.json diff --git a/apps/web/app/layout.tsx b/apps/web/app/layout.tsx new file mode 100644 index 00000000..7a29ca34 --- /dev/null +++ b/apps/web/app/layout.tsx @@ -0,0 +1,14 @@ +import type { ReactNode } from "react"; + +export const metadata = { + title: "Screenshot Studio", + description: "Phase 0 render host", +}; + +export default function RootLayout({ children }: { children: ReactNode }) { + return ( + + {children} + + ); +} diff --git a/apps/web/app/render/RenderStage.tsx b/apps/web/app/render/RenderStage.tsx new file mode 100644 index 00000000..ea3b88b6 --- /dev/null +++ b/apps/web/app/render/RenderStage.tsx @@ -0,0 +1,68 @@ +"use client"; + +import { useEffect, useRef, useState } from "react"; +import type { Project } from "@screenshot-studio/core/model"; + +/** + * Client stage: registers embedded fonts, renders one screen via `core/engine.renderScreen`, + * then exposes an export hook and a readiness flag on `window`. Konva is imported dynamically + * inside the effect so it never loads during SSR (it needs a real DOM). + * + * Readiness contract (spec §5, §6): `window.__stageReady` is set to `true` ONLY after the + * embedded fonts have resolved and the stage has drawn — never before — so a screenshot can + * never capture a frame that fell back to a system font (the #1 parity failure mode). + */ + +declare global { + interface Window { + __stageReady?: boolean; + __renderError?: string; + /** Returns a PNG data URL of the current stage at the given pixelRatio. */ + __exportPng?: (pixelRatio: number) => string; + } +} + +export function RenderStage({ project, screenId }: { project: Project; screenId: string }) { + const containerRef = useRef(null); + const [error, setError] = useState(null); + + useEffect(() => { + let stage: import("konva").default.Stage | undefined; + let cancelled = false; + + (async () => { + const container = containerRef.current; + if (!container) return; + try { + const [{ renderScreen }, { registerProjectFonts }] = await Promise.all([ + import("@screenshot-studio/core/engine"), + import("@screenshot-studio/core/fonts"), + ]); + + // Fonts first — the render must paint with the embedded font, not a fallback. + await registerProjectFonts(project.fonts); + if (cancelled) return; + + stage = renderScreen(container, project, screenId); + + window.__exportPng = (pixelRatio: number) => + stage!.toDataURL({ pixelRatio, mimeType: "image/png" }); + window.__stageReady = true; + } catch (err) { + const message = (err as Error).message; + window.__renderError = message; + setError(message); + } + })(); + + return () => { + cancelled = true; + stage?.destroy(); + delete window.__stageReady; + delete window.__exportPng; + }; + }, [project, screenId]); + + if (error) return
{error}
; + return
; +} diff --git a/apps/web/app/render/page.tsx b/apps/web/app/render/page.tsx new file mode 100644 index 00000000..548d741a --- /dev/null +++ b/apps/web/app/render/page.tsx @@ -0,0 +1,45 @@ +import { readFile } from "node:fs/promises"; +import { resolve } from "node:path"; +import { parseProjectJson } from "@screenshot-studio/core/model"; +import { RenderStage } from "./RenderStage"; + +/** + * Headless render host (docs/editor.md §5, spec §5). One dev-only route, no editor chrome. + * This is the single served artifact the CLI export AND the parity harness both point at, so + * UI and CLI share one rendering path (docs/architecture.md §2). The Phase 1 export button must + * later reuse , never a parallel react-konva tree. + * + * The project is read from disk by path (`?project=`) and validated with the same `core` loader + * the CLI uses. Arbitrary local file read is acceptable here: the product is a local, self-hosted + * tool and this route is dev-only. + */ +export const dynamic = "force-dynamic"; + +export default async function RenderPage({ + searchParams, +}: { + searchParams: Promise<{ project?: string; screen?: string }>; +}) { + const { project: projectPath, screen: screenId } = await searchParams; + if (!projectPath) { + return
Missing ?project= path
; + } + + let projectJson: string; + try { + projectJson = await readFile(resolve(projectPath), "utf8"); + } catch (err) { + return
Cannot read project: {(err as Error).message}
; + } + + let project; + try { + project = parseProjectJson(projectJson); + } catch (err) { + // Surface the validator message; never render an invalid project (editor.md §7). + return
{(err as Error).message}
; + } + + const targetScreen = screenId ?? project.screens[0]!.id; + return ; +} diff --git a/apps/web/next.config.mjs b/apps/web/next.config.mjs new file mode 100644 index 00000000..1ed5a7ee --- /dev/null +++ b/apps/web/next.config.mjs @@ -0,0 +1,20 @@ +/** @type {import('next').NextConfig} */ +const nextConfig = { + // core is shipped as TypeScript source across the workspace; let Next transpile it. + transpilePackages: ["@screenshot-studio/core"], + reactStrictMode: false, + webpack: (config) => { + // Konva optionally requires the node-only `canvas` package for server rendering; we render + // in the browser only, so stub it out to avoid a "Module not found: canvas" bundle error. + config.resolve.alias = { ...config.resolve.alias, canvas: false }; + // core uses NodeNext-style ".js" import specifiers that point at ".ts" sources; teach + // webpack to resolve them (Vitest does this out of the box, webpack needs to be told). + config.resolve.extensionAlias = { + ...config.resolve.extensionAlias, + ".js": [".ts", ".tsx", ".js"], + }; + return config; + }, +}; + +export default nextConfig; diff --git a/apps/web/package.json b/apps/web/package.json new file mode 100644 index 00000000..4c3554ac --- /dev/null +++ b/apps/web/package.json @@ -0,0 +1,23 @@ +{ + "name": "@screenshot-studio/web", + "version": "0.0.0", + "private": true, + "license": "Apache-2.0", + "scripts": { + "dev": "next dev", + "build": "next build", + "start": "next start", + "typecheck": "tsc --noEmit" + }, + "dependencies": { + "@screenshot-studio/core": "workspace:*", + "konva": "^9.3.16", + "next": "^15.1.3", + "react": "^19.0.0", + "react-dom": "^19.0.0" + }, + "devDependencies": { + "@types/react": "^19.0.2", + "@types/react-dom": "^19.0.2" + } +} diff --git a/apps/web/tsconfig.json b/apps/web/tsconfig.json new file mode 100644 index 00000000..1ba7fd82 --- /dev/null +++ b/apps/web/tsconfig.json @@ -0,0 +1,33 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "lib": [ + "ES2022", + "DOM", + "DOM.Iterable" + ], + "jsx": "preserve", + "noEmit": true, + "plugins": [ + { + "name": "next" + } + ], + "paths": { + "@screenshot-studio/core/*": [ + "../../packages/core/src/*/index.ts" + ] + }, + "allowJs": true, + "incremental": true + }, + "include": [ + "next-env.d.ts", + "**/*.ts", + "**/*.tsx", + ".next/types/**/*.ts" + ], + "exclude": [ + "node_modules" + ] +} diff --git a/packages/cli/package.json b/packages/cli/package.json new file mode 100644 index 00000000..5cc4d0d5 --- /dev/null +++ b/packages/cli/package.json @@ -0,0 +1,21 @@ +{ + "name": "@screenshot-studio/cli", + "version": "0.0.0", + "private": true, + "license": "Apache-2.0", + "type": "module", + "bin": { + "screenshots": "./src/index.ts" + }, + "exports": { + "./render-driver": "./src/render-driver.ts", + "./server": "./src/server.ts" + }, + "scripts": { + "typecheck": "tsc --noEmit" + }, + "dependencies": { + "@screenshot-studio/core": "workspace:*", + "playwright": "^1.49.1" + } +} diff --git a/packages/cli/src/export.ts b/packages/cli/src/export.ts new file mode 100644 index 00000000..b0126daa --- /dev/null +++ b/packages/cli/src/export.ts @@ -0,0 +1,58 @@ +import { readFile } from "node:fs/promises"; +import { + parseProjectJson, + getScreen, + type Project, +} from "@screenshot-studio/core/model"; +import { + parseStoreSpecs, + findStoreSize, + exportPixelRatio, + stripAlpha, + assertDimensions, + type StoreSize, +} from "@screenshot-studio/core/export"; +import { renderScreenToPng } from "./render-driver.js"; + +/** + * Export orchestration (Node side). Renders a screen through the served web renderer, then does + * the store post-processing that must happen off-canvas: strip alpha (stores reject + * transparency) and assert exact target dimensions (docs/architecture.md §4). One export path, + * shared by the CLI command and the parity harness — the same result the UI button must match. + */ +export interface ExportScreenOptions { + baseUrl: string; + projectPath: string; + screenId: string; + target: StoreSize; + headless?: boolean; +} + +/** Render + flatten + verify one screen, returning a store-ready PNG buffer. */ +export async function exportScreenToPng(opts: ExportScreenOptions): Promise { + const { baseUrl, projectPath, screenId, target, headless } = opts; + const project = await loadProject(projectPath); + const screen = getScreen(project, screenId); + + const pixelRatio = exportPixelRatio(screen.artboard, { width: target.width, height: target.height }); + const raw = await renderScreenToPng({ baseUrl, projectPath, screenId, pixelRatio, headless }); + + const flattened = stripAlpha(raw); + assertDimensions(flattened, { width: target.width, height: target.height }); + return flattened; +} + +async function loadProject(projectPath: string): Promise { + return parseProjectJson(await readFile(projectPath, "utf8")); +} + +/** Resolve a target store size for a screen from store-specs.json. */ +export async function resolveTarget( + storeSpecsPath: string, + platform: string, + device: string, + sizeId: string, +): Promise { + const specs = parseStoreSpecs(JSON.parse(await readFile(storeSpecsPath, "utf8"))); + return findStoreSize(specs, platform, device, sizeId); +} diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts new file mode 100644 index 00000000..86b79f41 --- /dev/null +++ b/packages/cli/src/index.ts @@ -0,0 +1,96 @@ +#!/usr/bin/env node +import { writeFile, mkdir } from "node:fs/promises"; +import { dirname, join, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; +import { runInit } from "./init.js"; +import { startWebServer } from "./server.js"; +import { exportScreenToPng, resolveTarget } from "./export.js"; +import { getScreen, parseProjectJson } from "@screenshot-studio/core/model"; +import { readFile } from "node:fs/promises"; + +/** + * `screenshots` CLI — the Phase 0 surface is `init` and `export` only (docs/roadmap.md Phase 0). + * `export` delegates all pixel rendering to the served web renderer (decision A), so its output + * is the same as the future UI export button by construction. + */ + +const repoRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url))); +const DEFAULT_STORE_SPECS = join(repoRoot, "store-specs.json"); + +function parseFlags(argv: string[]): Record { + const flags: Record = {}; + for (let i = 0; i < argv.length; i++) { + const arg = argv[i]!; + if (arg.startsWith("--")) { + const key = arg.slice(2); + const next = argv[i + 1]; + if (next && !next.startsWith("--")) { + flags[key] = next; + i++; + } else { + flags[key] = "true"; + } + } + } + return flags; +} + +async function cmdInit(flags: Record): Promise { + const cwd = flags.dir ? resolve(flags.dir) : process.cwd(); + await runInit(cwd, flags.name); + console.log(`Initialized project in ${cwd}`); +} + +async function cmdExport(flags: Record): Promise { + const projectPath = resolve(flags.project ?? "app-store-screenshots.json"); + const storeSpecsPath = flags["store-specs"] ? resolve(flags["store-specs"]) : DEFAULT_STORE_SPECS; + + const project = parseProjectJson(await readFile(projectPath, "utf8")); + const screenId = flags.screen ?? project.screens[0]!.id; + const screen = getScreen(project, screenId); + + const target = await resolveTarget( + storeSpecsPath, + screen.platform, + screen.device, + flags.size ?? "6.9", + ); + + const server = await startWebServer(); + try { + const png = await exportScreenToPng({ + baseUrl: server.url, + projectPath, + screenId, + target, + }); + const outDir = flags.out ? resolve(flags.out) : join(dirname(projectPath), "export"); + await mkdir(outDir, { recursive: true }); + const outFile = join(outDir, `${screen.platform}-${screen.device}-${target.id}-${screen.locale}.png`); + await writeFile(outFile, png); + console.log(`Exported ${outFile} (${target.width}×${target.height})`); + } finally { + await server.stop(); + } +} + +async function main(): Promise { + const [command, ...rest] = process.argv.slice(2); + const flags = parseFlags(rest); + switch (command) { + case "init": + await cmdInit(flags); + break; + case "export": + await cmdExport(flags); + break; + default: + console.error(`Unknown command: ${command ?? "(none)"}\nUsage: screenshots [flags]`); + process.exit(1); + } +} + +main().catch((err) => { + console.error(err instanceof Error ? err.message : err); + process.exit(1); +}); diff --git a/packages/cli/src/init.ts b/packages/cli/src/init.ts new file mode 100644 index 00000000..9b0d9c02 --- /dev/null +++ b/packages/cli/src/init.ts @@ -0,0 +1,78 @@ +import { mkdir, writeFile, access } from "node:fs/promises"; +import { join } from "node:path"; +import { SCHEMA_VERSION, type Project } from "@screenshot-studio/core/model"; + +/** + * `screenshots init` — scaffold the project file and the standard directories (AGENTS.md + * layout). Phase 0 seeds a minimal but valid project so `export` works immediately after init. + */ + +const STANDARD_DIRS = [ + "screenshots/apple/iphone/en", + "assets/fonts", + "assets/icons", + "themes", + "templates", + "export", +]; + +function starterProject(name: string): Project { + return { + meta: { name, schemaVersion: SCHEMA_VERSION }, + platforms: ["apple"], + locales: ["en"], + fonts: [], + screens: [ + { + id: "hero", + name: "Hero", + platform: "apple", + device: "iphone", + locale: "en", + artboard: { width: 660, height: 1434 }, + background: { type: "solid", color: "#0B1020" }, + elements: [ + { + id: "headline", + type: "text", + x: 60, + y: 360, + width: 540, + height: 200, + rotation: 0, + opacity: 1, + locked: false, + visible: true, + content: "Your headline", + fontFamily: "sans-serif", + size: 96, + weight: 700, + lineHeight: 1.15, + letterSpacing: 0, + align: "center", + color: "#FFFFFF", + }, + ], + }, + ], + }; +} + +async function exists(path: string): Promise { + try { + await access(path); + return true; + } catch { + return false; + } +} + +export async function runInit(cwd: string, projectName = "My App Screenshots"): Promise { + await Promise.all(STANDARD_DIRS.map((d) => mkdir(join(cwd, d), { recursive: true }))); + + const projectFile = join(cwd, "app-store-screenshots.json"); + if (await exists(projectFile)) { + throw new Error(`Refusing to overwrite existing ${projectFile}`); + } + await writeFile(projectFile, `${JSON.stringify(starterProject(projectName), null, 2)}\n`, "utf8"); +} diff --git a/packages/cli/src/render-driver.ts b/packages/cli/src/render-driver.ts new file mode 100644 index 00000000..469582b4 --- /dev/null +++ b/packages/cli/src/render-driver.ts @@ -0,0 +1,64 @@ +import { chromium } from "playwright"; +import { resolve } from "node:path"; +import { base64PngToBuffer } from "@screenshot-studio/core/export"; + +/** + * The render host's browser-side contract (mirrors apps/web `RenderStage`). These globals are + * set inside the page; declaring them here types the `page.evaluate` callbacks, which TypeScript + * checks in the Node context even though they execute in the browser. + */ +declare global { + interface Window { + __stageReady?: boolean; + __renderError?: string; + __exportPng?: (pixelRatio: number) => string; + } +} + +/** + * The one bridge from Node to the browser renderer (docs/architecture.md §2, decision A). + * Drives a headless (or headed) Chromium to the served `/render` route — the exact same page + * the future UI export button renders — waits for the readiness gate, then reads the stage via + * `Stage.toDataURL`. This is why UI and CLI share one rendering path: the CLI never rasterizes + * anything itself, it screenshots the web renderer. + * + * `toDataURL` (not `page.screenshot`) is used deliberately (spec §6): it captures the canvas + * bitmap at an exact `pixelRatio`, so the only variable between the headed and headless parity + * renders is the browser environment — which is precisely what the spike measures. + */ +export interface RenderOptions { + baseUrl: string; + /** Path to the project JSON. Made absolute before handing to the server. */ + projectPath: string; + screenId: string; + pixelRatio: number; + headless?: boolean; + /** Fail if the stage is not ready within this window (font load, etc.). */ + timeoutMs?: number; +} + +export async function renderScreenToPng(opts: RenderOptions): Promise { + const { baseUrl, projectPath, screenId, pixelRatio, headless = true, timeoutMs = 30_000 } = opts; + const abs = resolve(projectPath); + const url = `${baseUrl}/render?project=${encodeURIComponent(abs)}&screen=${encodeURIComponent(screenId)}`; + + const browser = await chromium.launch({ headless }); + try { + const page = await browser.newPage(); + await page.goto(url, { waitUntil: "load", timeout: timeoutMs }); + + // Resolve as soon as the stage is ready OR a render error is surfaced, so a bad project + // fails fast with its validator message instead of timing out opaquely. + await page.waitForFunction(() => window.__stageReady === true || window.__renderError, null, { + timeout: timeoutMs, + }); + + const renderError = await page.evaluate(() => window.__renderError); + if (renderError) throw new Error(`Render failed in browser: ${renderError}`); + + const dataUrl = await page.evaluate((ratio) => window.__exportPng!(ratio), pixelRatio); + return base64PngToBuffer(dataUrl); + } finally { + await browser.close(); + } +} diff --git a/packages/cli/src/server.ts b/packages/cli/src/server.ts new file mode 100644 index 00000000..7147faf6 --- /dev/null +++ b/packages/cli/src/server.ts @@ -0,0 +1,58 @@ +import { spawn, type ChildProcess } from "node:child_process"; +import { fileURLToPath } from "node:url"; +import { resolve } from "node:path"; + +/** + * Starts the `apps/web` render host and resolves only once it answers HTTP. Both `screenshots + * export` and the parity harness use this so they drive the same served artifact. Readiness is + * gated on a real HTTP response (not a fixed sleep), which is what keeps starting Next in a test + * fast and non-flaky. + */ +export interface RunningServer { + url: string; + stop: () => Promise; +} + +const webDir = resolve(fileURLToPath(new URL("../../../apps/web", import.meta.url))); + +async function waitForHttp(url: string, timeoutMs: number): Promise { + const deadline = Date.now() + timeoutMs; + while (Date.now() < deadline) { + try { + // Any HTTP response (even 404) means the server is accepting connections. + await fetch(url); + return; + } catch { + await new Promise((r) => setTimeout(r, 250)); + } + } + throw new Error(`Web server did not become ready within ${timeoutMs}ms`); +} + +export async function startWebServer( + port = 3100, + { timeoutMs = 120_000 }: { timeoutMs?: number } = {}, +): Promise { + const child: ChildProcess = spawn("pnpm", ["exec", "next", "dev", "--port", String(port)], { + cwd: webDir, + stdio: "ignore", + env: { ...process.env, NODE_ENV: "development" }, + }); + + const url = `http://localhost:${port}`; + try { + await waitForHttp(url, timeoutMs); + } catch (err) { + child.kill("SIGTERM"); + throw err; + } + + const stop = () => + new Promise((resolveStop) => { + if (child.exitCode !== null || child.killed) return resolveStop(); + child.once("exit", () => resolveStop()); + child.kill("SIGTERM"); + }); + + return { url, stop }; +} diff --git a/packages/cli/tsconfig.json b/packages/cli/tsconfig.json new file mode 100644 index 00000000..2699e621 --- /dev/null +++ b/packages/cli/tsconfig.json @@ -0,0 +1,10 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "noEmit": true, + "paths": { + "@screenshot-studio/core/*": ["../core/src/*/index.ts"] + } + }, + "include": ["src"] +} From 8990e9bf6e5f58f00eed33985c0f576cf5705fe8 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:55:49 +0300 Subject: [PATCH 014/368] test: add phase 0 parity and font-fidelity gate --- e2e/parity.test.ts | 131 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 e2e/parity.test.ts diff --git a/e2e/parity.test.ts b/e2e/parity.test.ts new file mode 100644 index 00000000..73cc708a --- /dev/null +++ b/e2e/parity.test.ts @@ -0,0 +1,131 @@ +import { describe, it, expect, beforeAll, afterAll } from "vitest"; +import { readFileSync, writeFileSync, mkdirSync } from "node:fs"; +import { fileURLToPath } from "node:url"; +import { resolve } from "node:path"; +import { PNG } from "pngjs"; +import pixelmatch from "pixelmatch"; +import { startWebServer, type RunningServer } from "../packages/cli/src/server.js"; +import { renderScreenToPng } from "../packages/cli/src/render-driver.js"; +import { stripAlpha, inspectPng } from "../packages/core/src/export/png.js"; + +/** + * Phase 0 exit gate (docs/roadmap.md §4). Proves, on the hardest parity case (embedded custom + * font), that: + * 1. the pipeline yields a PNG at the exact store target size, + * 2. with no alpha channel, + * 3. the "UI export" (headed) and "CLI export" (headless) renders diff within tolerance, and + * 4. the embedded font is provably live — the render differs from a fallback render. + * + * Both renders go through the SAME served /render route via Stage.toDataURL; the only variable + * between (3)'s two images is headed-vs-headless — exactly the risk decision A does not remove + * by construction (docs/architecture.md §2). + */ + +const repoRoot = resolve(fileURLToPath(new URL("..", import.meta.url))); +const fixturePath = resolve(repoRoot, "fixtures/phase-0-sample/app-store-screenshots.json"); +const tmpDir = resolve(repoRoot, "e2e/.tmp"); +const screenId = "hero"; +const pixelRatio = 2; // 660×1434 artboard → 1320×2868 lead size +const target = { width: 1320, height: 2868 }; + +// Tolerances (spec §6): starting values, tuned once real diffs are observed. +const PER_PIXEL_THRESHOLD = 0.1; +const MAX_MISMATCH_FRACTION = 0.001; // 0.1% of pixels + +let server: RunningServer; + +beforeAll(async () => { + mkdirSync(tmpDir, { recursive: true }); + server = await startWebServer(3123); +}, 180_000); + +afterAll(async () => { + await server?.stop(); +}); + +function decode(buf: Buffer): PNG { + return PNG.sync.read(buf); +} + +function countMismatch(a: Buffer, b: Buffer): { mismatch: number; total: number } { + const pa = decode(a); + const pb = decode(b); + expect(pa.width).toBe(pb.width); + expect(pa.height).toBe(pb.height); + const diff = new PNG({ width: pa.width, height: pa.height }); + const mismatch = pixelmatch(pa.data, pb.data, diff.data, pa.width, pa.height, { + threshold: PER_PIXEL_THRESHOLD, + }); + return { mismatch, total: pa.width * pa.height }; +} + +describe("Phase 0 render/export parity", () => { + it("headed and headless renders match at the exact target size with no alpha", async () => { + const headedRaw = await renderScreenToPng({ + baseUrl: server.url, + projectPath: fixturePath, + screenId, + pixelRatio, + headless: false, + }); + const headlessRaw = await renderScreenToPng({ + baseUrl: server.url, + projectPath: fixturePath, + screenId, + pixelRatio, + headless: true, + }); + + const headed = stripAlpha(headedRaw); + const headless = stripAlpha(headlessRaw); + + // (1) exact dimensions, (2) no alpha + for (const png of [headed, headless]) { + const info = inspectPng(png); + expect(info.width).toBe(target.width); + expect(info.height).toBe(target.height); + expect(info.hasAlpha).toBe(false); + } + + // (3) visual diff within tolerance + const { mismatch, total } = countMismatch(headed, headless); + const fraction = mismatch / total; + // Surface the observed baseline; tolerances in spec §6 are provisional until seen. + console.log( + `[parity] headed vs headless mismatch: ${mismatch}/${total} = ${(fraction * 100).toFixed(4)}%`, + ); + expect(fraction).toBeLessThan(MAX_MISMATCH_FRACTION); + }); + + it("proves the embedded font is live: render differs from a fallback render", async () => { + // Same project, but the text element points at a generic family with no embedded font, + // forcing a system fallback. If the custom font had silently failed, the main render would + // ALSO be a fallback and these would match — so a large diff is the positive proof. + const project = JSON.parse(readFileSync(fixturePath, "utf8")); + for (const el of project.screens[0].elements) { + if (el.type === "text") el.fontFamily = "serif"; + } + project.fonts = []; + const fallbackPath = resolve(tmpDir, "fallback-project.json"); + writeFileSync(fallbackPath, JSON.stringify(project)); + + const custom = await renderScreenToPng({ + baseUrl: server.url, + projectPath: fixturePath, + screenId, + pixelRatio, + headless: true, + }); + const fallback = await renderScreenToPng({ + baseUrl: server.url, + projectPath: fallbackPath, + screenId, + pixelRatio, + headless: true, + }); + + const { mismatch } = countMismatch(stripAlpha(custom), stripAlpha(fallback)); + // A distinct script font vs serif over a 120px headline differs by many thousands of pixels. + expect(mismatch).toBeGreaterThan(2000); + }); +}); From ef0d969387d889b24b73791ae85382f22ecddb7c Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:55:56 +0300 Subject: [PATCH 015/368] chore: add phase 0 sample fixture with embedded font --- .../phase-0-sample/app-store-screenshots.json | 74 ++++++++++++++ fixtures/phase-0-sample/assets/fonts/OFL.txt | 93 ++++++++++++++++++ .../assets/fonts/Pacifico-Regular.ttf | Bin 0 -> 329380 bytes 3 files changed, 167 insertions(+) create mode 100644 fixtures/phase-0-sample/app-store-screenshots.json create mode 100644 fixtures/phase-0-sample/assets/fonts/OFL.txt create mode 100644 fixtures/phase-0-sample/assets/fonts/Pacifico-Regular.ttf diff --git a/fixtures/phase-0-sample/app-store-screenshots.json b/fixtures/phase-0-sample/app-store-screenshots.json new file mode 100644 index 00000000..2dacc74e --- /dev/null +++ b/fixtures/phase-0-sample/app-store-screenshots.json @@ -0,0 +1,74 @@ +{ + "meta": { + "name": "Phase 0 Sample", + "schemaVersion": 1 + }, + "platforms": [ + "apple" + ], + "locales": [ + "en" + ], + "fonts": [ + { + "family": "Pacifico", + "source": "uploaded", + "data": "AAEAAAASAQAABAAgRFNJRwAAAAEABQacAAAACEdERUY4wT0mAAQzxAAABARHUE9TT6v2HwAEN8gAAKhKR1NVQrxQXfwABOAUAAAmhk9TLzKOX7ypAAABqAAAAGBjbWFwg6qWmAAAGfAAAAiUY3Z0IAyGHjYAADFoAAAAjmZwZ22eNhTQAAAihAAADhVnYXNwAAAAEAAEM7wAAAAIZ2x5ZtKqBWkAAEnwAAOhzGhlYWQGbhnNAAABLAAAADZoaGVhCUUJIAAAAWQAAAAkaG10eLpgYOsAAAIIAAAX5mxvY2EJdyJwAAAx+AAAF/htYXhwB4oPxAAAAYgAAAAgbmFtZRo6x94AA+u8AAAGHnBvc3QlPmhrAAPx3AAAQd9wcmVwjSd6gwAAMJwAAADLAAEAAAADAEHxrj5JXw889QAPA+gAAAAAyZ2tgAAAAADZgCcq/a/+NwZ8BcYAAAAHAAIAAQAAAAAAAQAABRf+OwAABfv9r/7zBnwAAQAAAAAAAAAAAAAAAAAABfYAAQAABf0ApAAGAKYABQACADAAYACNAAAAwQ4VAAMAAwAEAmcBkAAFAAACigJYAAAASwKKAlgAAAFeADIBFAAAAAAFAAAAAAAAACAAAgcAAAACAAAAAAAAAABuZXd0AMAAAPsCBRf+OwAABcYBySAAAZcAAAAAAcwDSAAAACAAAwEJAAAAAAAAAQkAAAEJAAADEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4AxIAOAMSADgDEgA4A/cAOAP3ADgDOwAUAq4AQAKuAEACrgBAAq4AQAKuAEACrgBAA0QALQX7AFADNQAPA0QALQM1AA8EpwBQAq4AHwKuAB8CrgAfAq4AHwKuAB8CrgAfAq4AHwKuAB8CrgAfAq4AHwKuAB8CrgAfAq4AHwKuAB8CrgAfAq4AHwKuAB8CrgAfAq4AHwKuAB8CyP//AysAQAMrAEADKwBAAysAQAMrAEADKwBAA2n/8ANYADgDaf/wAe//7wHv/+8B7//vAe//7wHv/+8B7//vAe//7wHv/+8B7//vAe//7wHv/+8B7//vAe//7wHv/+8C5wBHAucARwOpABoDqQAaAqH/1wT8/9cCof/XAqH/1wKh/9cCof/XA5//1wKh/9cE0P//A3T//wXZ//8DdP//A3T//wN0//8DdP//BHL//wN0//8DMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEADMABAAzAAQAMwAEAEZABAAyUALgMIACoDMABAA3AANwNwADcDcAA3A3AANwNwADcDcAA3ArUAIgK1ACICtQAiArUAIgK1ACICtQAiA0sAUgMYADsCuQAjArkAIwK5ACMCuQAjArkAIwN6//8Dev//A3r//wN6//8Dev//A3r//wN6//8Dev//A3r//wN6//8Dev//A3r//wN6//8Dev//A3r//wN6//8Dev//A3r//wN6//8Dev//A3r//wL7AHsEwQB5BMEAeQTBAHkEwQB5BMEAeQLI//EDU///A1P//wNT//8DU///A1P//wNT//8DU///A1P//wNT//8C0QAPAtEADwLRAA8C0QAPAwgAXAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgDDAA4AwwAOAMMADgEIQA4BCEAOAM6AFQCwABBAsAAQQLAAEECwABBAsAAQQLAAEEDKgBQBa8AUAM1AA8DKgBQAzUADwLQACsC0AArAtAAKwLQACsC0AArAtAAKwLQACsC0AArAtAAKwLQACsC0AArAtAAKwLQACsC0AArAtAAKwLQACsC0AArAtAAKwLQACsC0AArAp8APAMrAEEDKwBBAysAQQMrAEEDKwBBAysAQQNOADMDWAA4A04AMwFlAE4BZQBOAwgAXAFlAEwBZQBOAWUAPwFlAE4BZQBOAWUAIQFl//wBZQBOAWUATgFlAE4BZQAYAWUAPgLMAEoCzABKAwsARgMLAEYCcQBMBQsATAJxAEwCcQBMAnEATAJxAEwDVgBMAnEAFgRzAEkDHwBLBesASwMfAEsDHwBLAx8ASwMYAEwD8ABLAx8ASwSOAEAClgAvApIAKgMwAEAC6ABTAugAUwLoAFMC6ABTAugAUwLoAFMCdwBDAncAQwJ3AEMCdwBDAncAQwMgAF0DIABdAyAAXQMgAF0DIABdAyAAXQMgAF0DIABdAyAAXQMgAF0DIABdAyAAXQMgAF0DIABdAyAAXQMgAF0DIABdAyAAXQMgAF0DIABdAyAAXQMdAHsE1AB6BNQAegTUAHoE1AB6BNQAegKl/9UDCABcAwgAXAMIAFwDCABcAwgAXAMIAFwDCABcAwgAXAMIAFwCmQAIApkACAKZAAgCmQAIAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwHWACMB1gAjAdYAIwKNACQCjQAkAdkANwFwACABcAAgAXAAIAFwACABcAAgAXAAIAIDACMBwwAhAdYAIwHWACMDfwAjAYkAIQGJACEBiQAhAYkAIQGJACEBiQAhAYkAIQGJAAkBiQAhAYkAIQGJABoBiQAhAYkAIQGJACEBiQAhAYkAIQGJACEBiQAhAYkAIQGJACEBygAoAXMANAHf//4B3//+Ad///gHf//4B3//+Ad///gH2ADUB9gA1AfYANQD2AC8A9gAvAPYALwD2/+gA9v/+APb/twD2AAEA9gAvAPYABQD2//MA9gAvAPb/6AD2AAkA9gAaAPb/3AD+/x0A/v8dAP7/HQINADcCDQA3AdEAMgFGADcBRgA3AO0ALAFGADcBawAxAmIANwFGADcC6AAyAfAAMgHwADIB8P/7AfAAMgHwADIB7wAcAu4AMgHwADIBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAFAcMAIQHDACEBwwAWAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHLACEBywAhAcMAIQHDACECnAAhAeH/iQH8ABgB9AAjAccAMgHHADIBxwAyAccAJgHHADIBxwAyAav/9QGr//UBq//1Aav/9QGr//UBq//1AlQAKwGJAAEBV//5AVcADQGJAAEBiQABAc4AMAHOADABzgAwAc4AMAHOADABzgAwAc4AMAHOADABzgAwAgAAMAIAADACAAAwAgAAMAIAADACAAAwAc4AMAHOADABzgAwAc4AMAHOADABzgAwAcEAMgK8ADICvAAyArwAMgK8ADICvAAyAhEAEQHf//wB3//8Ad///AHf//wB3//8Ad///AHf//wB3//8Ad///AG9ADoBvQA6Ab0AOgG9ADoBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAcoAIwHKACMBygAjAp8AJAKfACQB2wA3AZQAIAGUACABlAAgAZQAIAGUACABlAAgAe0AIwHKACMBygAjA2wAIwGbACEBmwAhAZsAIQGbACEBmwAhAZsAIQGbACEBmwAJAZsAIQGbACEBmwAaAZsAIQGbACEBmwAhAZsAIQGbACEBmwAhAZsAIQGbACEBmwAhAcH//gHB//4Bwf/+AcH//gHB//4Bwf/+AeoANwHqADUB6gA3AN4AIgDeACIA3gAiAd///ADe/+4A3gAEAN7/vQDeAAcA3gAiAN7/7gDe//kA3gAiAN7/7gDeAA8A3v/nAN7/4gDl/x0A5f8dAOX/HQIJADcCCQA3Ah0AMgFwADcBcAA3AXAANwFwADcB0gAxAisANwFwADcC3AAyAeQAMgHkADIB5P/7AeQAMgHkADIB5AAcAtUAMgHkADIBxQAhAcUAIQHFACEBxQAhAcUAIQHFACEBxQAFAcUAIQHFACEBxQAWAcUAIQHFACEBxQAhAcUAIQHFACEBxQAhAcUAIQHFACEBxQAhAcUAIQHFACEBxQAhAcUAIQHFACEBxQAhAcUAIQHPACEBzwAhAcUAIQHFACECrgAhAcn/iQHjABgBwQAjAe8AMgHvADIB7wAyAe8AJgHvADIB7wAyAYr/9QGK//UBiv/1AYr/9QGK//UBiv/1AkQAKwHSAAoB5AAbAej/hQGW/9YBlv/WAZb/1gGW/9YBnQABAYP/+QGdAAEBnQABAZ0AAQHMADABzAAwAcwAMAHMADABzAAwAcwAMAHMADABzAAwAcwAMAHYADAB2AAwAdgAMAHYADAB2AAwAdgAMAHMADABzAAwAcwAMAHMADABzAAwAcwAMAGkADICmgAzApoAMwKaADMCmgAzApoAMwJEABEBwf/8AcH//AHB//wBwf/8AcH//AHB//wBwf/8AcH//AHB//wBnAAEAZwABAGcAAQBnAAEAd///AHBADcB1gAjAUP/aQDtACwA7QAsAO0ALAHrAAoBRAAGAfwAGwHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDAAUBwwAhAcMAIQHDABYBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQHDACEBwwAhAcMAIQH0/4UBVwANAVcADQFXAA0BsP/WAbD/1gGw/9YBsP/WAqwANQJ5ABoCeQAaArAANAKOADcCwgADAnAAGgJbABoC2gA0A0UAGgHD//wCmgANAwgAXANhABoB3//8AngADQGJAE4BmABTAxIAOAOVACMDOwAUAnsAIwJ7ACMChQAjA8QAEAKuAB8CrgAfAq4AHwTSABsC1QA6A3r//wN6//8Dev//A3r//wOpABoDqQAaA10ACARtAAkDaf/wAzAAQAN8ACMDJQAuAq4AQAK5ACMDOAAjAzgAIwPRADkCyP/xAwUAcAN6//8E+P//BPj//wN6//8C0QAcA18AbgQ2ABwEhgAIBJ7/8AK1ACICrwBBAvMALAHv/+8B7//vAucARwPTACME3v/wA1IACAPOACMC0QAcBNIAGwMwAEADHQB7AnsAIwN0ACME0gAbAtUAOgOpABoDqQAaA6kAGgOpABoDi//wA2n/8AN8ACMD5QBBAw0AQQK5ACMCpQCLAqUAiwLM//EEEAAjAyQAcAMFAHAC8wBOAzIATgMoADcDKAA3Ae//7wTSABsDqQAaA10ACAOL//ADaf/wAwUAcARtAAkDEgA4AxIAOAP3ADgCrgAfAxgAOwMYADsE0gAbAtUAOgLoADoDev//A3r//wMwAEADMABAAzAAQALzACwDOAAjAzgAIwM4ACMDBQBwAlgAIwQ2ABwCe/+/Asz/8QLI//ECwgAxA3QACAMwAEAEwQB5AtEAHAMlAC4Daf+NA3QACAMMADgDcQCtAzoAVAJ6AM0CegDNAn8AzQNEAC0C0AArAtAAKwLQACsErAAMAtUAOgMgAF0DIABdAyAAXQMvAF0DCwBGAwsARgLC/+EDx///A04AMwMwAEADTwBfApYALwLAAEECdwBDAwgAXAMIAFwD0gA9AqX/1QMFAHADNgBdBJYAXQSqAF0DIABdAtEAHANfAG4ENgAcA+b/4QROADMCtQAiAsAAQQLzACwBZQBOAWUATgLMAEoDdABDBI4AMwM7AE0DSwBDAtEAHASsAAwDMABAAx0AewJ6AJUDeQDNBKIADALVADoDCwBGAwsARgMLAEYDxABzA04AMwQCADMDfABfA+UAQQLAAEECuQCYAqUAiwKlAIsCpf/VA8UAQwMkAHADBQBwAugATgMyAE4DTv9NAsL/4QM4ADcDOAA3AWUATgSsAAwDCwBGAsL/4QNOADMDaQAzAwUAcAPH//8DDAA4AwwAOAQhADgC0AArAxgAOwMYADsErAAMAtUAOgLoADoDIABdAyAAXQMwAEADMABAAzAAQALzACwDCABcAwgAXAMIAFwDBQBwAlgATAQ2ABwCev/CA04AMwKl/9UCwgAxAsL/4QMwAEAE1AB6AtEAHAKWAC8B1gAjAdkAJwHZADcBfAAlAXwAJQGKADIB3//+AYkAIQGJACEBiQAhAs0AEQGz/9YBzgAwAc4AMAHOADABzgAwAdEAMgHRADICJQABAt4AAQHbADIBwwAhAfAAMgHh/4kBcAAgAugAMgHf//wB3//8AtEAIwIRABECK//1AfUAMAK1ADAC3AAwAlgAMAIFADQCHgApAr4ANAMaAAEC7wAyAav/9QF7ACEB0gAjAPYALwD2AAEA/v8dAfYANQKkADICHwABAgIAIQIFAA8DFAARAcMAIQGkADIBfAAOAbkAJQMjABEBvQAeAhMAMgHlADIB2QA1AisAKQIDADIB2wAyAhgAMgI+ACEBrwAgAxAAMgHYADQB2AAPAlkAEQH1ADACd//1Aj//9QIeADUB9gA1AeMACQHjAAkA3gAiAs0AEQITADICJQABAgMAMgHbADICK//1At4AAQHWACMB1gAjAo0AJAGJACEBxwAYAccAGALNABEBs//WAbP/1gHOADABzgAwAcMAIQHDACEBwwAhAdIAIwHf//wB3//8Ad///AIr//UBuQAlAr4ANAG5AA4CWQARAhEAEQGIABUCdwABAfQAIwK8ADICBQAPAeH/iQHb/5UCdwABAcoAIwHZACcB2wA3AX4AJQF+ACUBigAyAcH//gGbACEBmwAhAZsAIQMPABEBi//WAcwAMAHMADABzAAwAcwAMAIdADICHQAyAc//5QKd//IBzgAyAcUAIQHkADIByf+JAZQAIALcADIBwf/8AcH//ALRACMCRAARAaYAPgHUADACtQAwArsAMAHOADACBQA0Ah8AKQKrADQCxf/lAu8AMgGK//UBqgAhAdwAIwDeACIA3gAHAOX/HQHqADUCpAAyAfD/+AHtACECBQAPA24AEQHFACEBpAAyAZcAJwG6ACUDEAARAZX/7wIVADICNwAyAh0ADQJ/ACkB4gAyAc4AMgH3ADIChAAhAZQAIALvADIBwgA0AcIADwJEABEB1AAwAc0APgHZAEwCBwA3AeoANwHO/5UCEv/lAfUACQH1AAkA3gAiAw8AEQIVADIBz//lAeIAMgHOADIBpgA+Ap3/8gHKACMBygAjAp8AJAGbACEBygAoAcoAKAMPABEBi//WAcj/1gHMADABzAAwAcUAIQHFACEBxQAhAdIAIwHB//wBwf/8AcH//AGmAD4BugAlAqsANAG6AA4CRAARAkQAEQGDABUCEv/lAcEAIwKaADMCBQAPAcn/iQHIADcB1QA3Ac4AMAK1ADABzAAwArUAMALNABEB0QA6Aw8AEQImADoCvAAgAzD/6wHOABwB8AAXAh8AMwF4ADgCMAAuAggAHAJBADACBgAuAh0AMgHxAC0CAAAoAh0AKAHCAGcBwgA6AcIARgHCAFYAyP+oBAAAZwO7AGcECwBGAggAcgH9AGwBAQAvAgAAZgEBABwBAQAQAwkAHAFUACEBVP/mArwAIgEBABwB3ABAAdz/1AH+AG8BIgBvAQEAEAH9AAkBYv/oAeoAMgHq/9UBlQBDAZX/0AJlAFsCZf+uAmwANwHkADcBkwA5AZMAOQJnABsCZwAsAV4AGwFeAC0B3QAQAckAZwHIAHEA7QBnAOwAcQEBABABCQAAAgUAMwHSACwCBQAQArwAegIMACcBzwAGAigAEQHe/70C7gAuAlcAMwI6AB8CTgATAg0AFQHEABACoQARAqAAGAQ9ACcCLQAOAfkADgH/ABoCDQAVAgoALgIBAEMDBwAbAfEAIwK8AQMCvABpArwAUwK8AFMCvABuArwAUwK8AEUCvABFArwAQwK8AFICvABBArwAQQK8AF4CvAA8ArwATAK8AFMCvAAgArwAMQK8AD4CvAA5ArwAMgHOABwBwwAhA4AAMQT9ADECvACHA/cAJwNTAC0C4wBkAl8ARgKHAFMChwBTBH4AZAGBAGEBRgAcAUYAHgJMAIMCTABiBK4ASwK8AFgAAP4vAAD+hQAA/iEAAP60AAD+WQAA/sIAAP4tAAD+WQAA/hYAAP5gAAD+CgAA/jgAAP6AAAD95QAA/hYAAP6xAAD+vAAA/ioAAP3SAAD+RQAA/eIAAP4vAAD9rwAA/ecAAP6gAAD+LQAA/oMAAP3EAAD+sAAA/lcAAP4pAAD+SAAA/hQAAP5gAAD+BgAA/jgAAP6AAAD+BwAA/hYAAP6uAAD+uQAA/icAAP3QAAD+SAAA/eIAAP4rAAD9sQAA/ecCWAEJAlgAkAJYAQwCWABuAlgAsQJYADoCWACFAlgAhwJYAN0CWAB5AlgAsQJYAJACWACHAlgAuAJYAGIAAP4XAAD+MgAA/hQAAP4UAAD+FAAA/hQAAP4tAAD91AAA/i0AAP4tAAD+FAAA/hQAAP4UAAD+FAAA/i0AAP3UAAD+LQAA/i0CWACNAGIADAD+AJAAiwC6AMEAAAAAAAIAAAADAAAAFAADAAEAAAAUAAQIgAAAALQAgAAGADQAAAANAC8AOQB+ATEBfgGPAZIBoQGwAcwB5wHrAhsCLQIzAjcCWQK8AscCyQLdAwQDDAMPAxIDGwMkAygDLgMxA5QDqQO8A8AEGgQjBC8EMwQ1BDkEOgRDBF8EYwRrBHUEpQT/BRMFHQUpBS8ehR6eHvkgFCAaIB4gIiAmIDAgOiBEIHQgoSCkIKcgqSCuILIgtSC6IL0hFiEiIgIiDyISIhUiGiIeIisiSCJgImUlyvsC//8AAAAAAA0AIAAwADoAoAE0AY8BkgGgAa8BxAHmAeoB+gIqAjACNwJZArwCxgLJAtgDAAMGAw8DEQMbAyMDJgMuAzEDlAOpA7wDwAQABBsEJAQwBDQENgQ6BDsERARiBGoEcgSKBKgFEAUaBSQFLh6AHp4eoCATIBggHCAgICYgMCA5IEQgdCChIKMgpiCpIKsgsSC0ILggvCEWISIiAiIPIhEiFSIZIh4iKyJIImAiZCXK+wH//wAB//UAAAT6AAAAAAAA/w0D2AAAAAAAAAAAAAAAAAAAAAD/jP9PAxgAAAMMAAAAAAAAAqICoQKZApICkQKMAooBkgF+AWwBaQAA/zsAAAAAAAAABAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4f0AAAAA5UcAAAAA5RzlZOUh5PTkw+TEAADkzOTRAAAAAAAAAAAAAOSM5HrjkON/AADjaAAA427jYuNB4yMAAN/LCDMAAQAAAAAAsAAAAMwBVAJ2AAAAAAMGAwgDCgMaAxwDHgNgA2YAAAAAAAADZgAAA2YDcAN4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAANuAAADoAAAA7QAAAO0AAADsgPoA+oD7APyBCgE1gTcBOIE7ATuAAAE9gWoAAAFqAWsAAAAAAAAAAAAAAAABaQAAAAABaIFqAWqBawFsAAAAAAAAAAABaoAAAWqAAAAAAAAAAAFpAAAAAAAAAADBUMFSQVFBWcFkwWXBUoFUgVTBTwFfgVBBVYFRgVMBUAFSwWFBYIFhAVHBZYABAAfACAAJgAsAEAAQQBHAEoAWABaAFwAZABlAG0AjACOAI8AlQCdAKIAtwC4AL0AvgDHBVAFPQVRBaMFTQXdAW0BiAGJAY8BlAGpAaoBsAGzAcIBxQHIAc8B0AHYAfcB+QH6AgACBwIMAiECIgInAigCMQVOBZ4FTwWKBWIFRAVkBXcFZgV7BZ8FmQXbBZoDQgVYBYsFVwWbBd8FnQWIBTUFNgXWBZEFmAU+BdkFNANDBVkFOgU5BTsFSAAVAAUADAAcABMAGgAdACMAOgAtADAANwBSAEsATQBPACgAbAB7AG4AcACJAHcFgACHAKkAowClAKcAvwCNAgYBfgFuAXUBhQF8AYMBhgGMAaIBlQGYAZ8BvAG1AbcBuQGQAdcB5gHZAdsB9AHiBYEB8gITAg0CDwIRAikB+AIrABgBgQAGAW8AGQGCACEBigAkAY0AJQGOACIBiwApAZEAKgGSAD0BpQAuAZYAOAGgAD4BpgAvAZcARAGtAEIBqwBGAa8ARQGuAEkBsgBIAbEAVwHBAFUBvwBMAbYAVgHAAFABtABZAcQAWwHGAccAXgHJAGABywBfAcoAYQHMAGMBzgBnAdEAaQHUAGgB0wHSAGoB1QCFAfAAbwHaAIMB7gCLAfYAkAH7AJIB/QCRAfwAlgIBAJkCBACYAgMAlwICAKACCgCfAgkAngIIALYCIACzAh0ApAIOALUCHwCxAhsAtAIeALoCJADAAioAwQDIAjIAygI0AMkCMwB9AegAqwIVACcAKwGTAF0AYgHNAGYAawHWAEMBrACGAfEAGwGEAB4BhwCIAfMAEgF7ABcBgAA2AZ4APAGkAE4BuABUAb4AdgHhAIQB7wCTAf4AlAH/AKYCEACyAhwAmgIFAKECCwB4AeMAigH1AHkB5ADFAi8F2gXYBdcF3AXhBeAF4gXeBaYFpwWqBa4FrwWsBaUFpAWwBa0FqAWrA0wDTQN1A0gDbQNsA28DcANxA2oDawNyA1UDUgNfA2YDRANFA0YDRwNKA0sDTgNPA1ADUQNUA2ADYQNjA2IDZANlA2gDaQNnA24DcwN0BDYENwRABEwETQRPBE4EUARRBFQEVQRTBFoEXwRgBDgEOQRhBDQEWQRYBFsEXARdBFYEVwReBEEEPgRLBFIDdgRiA3cEYwN4BGQDeQRlA1MEPwO2BKIDtwSjA0kENQN6BGYDewRnA3wEaAN9BGkDfgRqA38EawOABGwDgQRtA4IEbgODBG8DhQRxA4YEcgOHBHMDiAR0A4kEdQOKBHYDiwR3A4wEeAONBHkDjgR7A5AEfAORBH0DkgOTBH8DlASAA5UEgQOWBIIDlwSDA5gEhAOZBIUEfgOaBIYDmwSHA5wEiAOdBIkDngSKA58EiwOgBIwDoQSNA6IEjgOjBI8DpASQA6UEkQOmBJIDpwSTA6gElAOpBJUDqgSWA6sElwOsBJgDrQSZA64EmgOvBJsDsAScA7EEnQOyBJ4DswSfA7QEoAO1BKEDhARwA48EegO4BKQDuQSlALwCJgC5AiMAuwIlABQBfQAWAX8ADQF2AA8BeAAQAXkAEQF6AA4BdwAHAXAACQFyAAoBcwALAXQACAFxADkBoQA7AaMAPwGnADEBmQAzAZsANAGcADUBnQAyAZoAUwG9AFEBuwB6AeUAfAHnAHEB3ABzAd4AdAHfAHUB4AByAd0AfgHpAIAB6wCBAewAggHtAH8B6gCoAhIAqgIUAKwCFgCuAhgArwIZALACGgCtAhcAwwItAMICLADEAi4AxgIwBVUFVAVdBV4FXAWgBaEFPwVrBW8FaAVpBW4FeQV0BWwFbQVjBXgFdgVwBXEFdQWPBX8FfAWQBYcFhrAALCCwAFVYRVkgIEu4AA5RS7AGU1pYsDQbsChZYGYgilVYsAIlYbkIAAgAY2MjYhshIbAAWbAAQyNEsgABAENgQi2wASywIGBmLbACLCMhIyEtsAMsIGSzAxQVAEJDsBNDIGBgQrECFENCsSUDQ7ACQ1R4ILAMI7ACQ0NhZLAEUHiyAgICQ2BCsCFlHCGwAkNDsg4VAUIcILACQyNCshMBE0NgQiOwAFBYZVmyFgECQ2BCLbAELLADK7AVQ1gjISMhsBZDQyOwAFBYZVkbIGQgsMBQsAQmWrIoAQ1DRWNFsAZFWCGwAyVZUltYISMhG4pYILBQUFghsEBZGyCwOFBYIbA4WVkgsQENQ0VjRWFksChQWCGxAQ1DRWNFILAwUFghsDBZGyCwwFBYIGYgiophILAKUFhgGyCwIFBYIbAKYBsgsDZQWCGwNmAbYFlZWRuwAiWwDENjsABSWLAAS7AKUFghsAxDG0uwHlBYIbAeS2G4EABjsAxDY7gFAGJZWWRhWbABK1lZI7AAUFhlWVkgZLAWQyNCWS2wBSwgRSCwBCVhZCCwB0NQWLAHI0KwCCNCGyEhWbABYC2wBiwjISMhsAMrIGSxB2JCILAII0KwBkVYG7EBDUNFY7EBDUOwBGBFY7AFKiEgsAhDIIogirABK7EwBSWwBCZRWGBQG2FSWVgjWSFZILBAU1iwASsbIbBAWSOwAFBYZVktsAcssAlDK7IAAgBDYEItsAgssAkjQiMgsAAjQmGwAmJmsAFjsAFgsAcqLbAJLCAgRSCwDkNjuAQAYiCwAFBYsEBgWWawAWNgRLABYC2wCiyyCQ4AQ0VCKiGyAAEAQ2BCLbALLLAAQyNEsgABAENgQi2wDCwgIEUgsAErI7AAQ7AEJWAgRYojYSBkILAgUFghsAAbsDBQWLAgG7BAWVkjsABQWGVZsAMlI2FERLABYC2wDSwgIEUgsAErI7AAQ7AEJWAgRYojYSBksCRQWLAAG7BAWSOwAFBYZVmwAyUjYUREsAFgLbAOLCCwACNCsw0MAANFUFghGyMhWSohLbAPLLECAkWwZGFELbAQLLABYCAgsA9DSrAAUFggsA8jQlmwEENKsABSWCCwECNCWS2wESwgsBBiZrABYyC4BABjiiNhsBFDYCCKYCCwESNCIy2wEixLVFixBGREWSSwDWUjeC2wEyxLUVhLU1ixBGREWRshWSSwE2UjeC2wFCyxABJDVVixEhJDsAFhQrARK1mwAEOwAiVCsQ8CJUKxEAIlQrABFiMgsAMlUFixAQBDYLAEJUKKiiCKI2GwECohI7ABYSCKI2GwECohG7EBAENgsAIlQrACJWGwECohWbAPQ0ewEENHYLACYiCwAFBYsEBgWWawAWMgsA5DY7gEAGIgsABQWLBAYFlmsAFjYLEAABMjRLABQ7AAPrIBAQFDYEItsBUsALEAAkVUWLASI0IgRbAOI0KwDSOwBGBCILAUI0IgYLABYbcYGAEAEQATAEJCQopgILAUQ2CwFCNCsRQIK7CLKxsiWS2wFiyxABUrLbAXLLEBFSstsBgssQIVKy2wGSyxAxUrLbAaLLEEFSstsBsssQUVKy2wHCyxBhUrLbAdLLEHFSstsB4ssQgVKy2wHyyxCRUrLbArLCMgsBBiZrABY7AGYEtUWCMgLrABXRshIVktsCwsIyCwEGJmsAFjsBZgS1RYIyAusAFxGyEhWS2wLSwjILAQYmawAWOwJmBLVFgjIC6wAXIbISFZLbAgLACwDyuxAAJFVFiwEiNCIEWwDiNCsA0jsARgQiBgsAFhtRgYAQARAEJCimCxFAgrsIsrGyJZLbAhLLEAICstsCIssQEgKy2wIyyxAiArLbAkLLEDICstsCUssQQgKy2wJiyxBSArLbAnLLEGICstsCgssQcgKy2wKSyxCCArLbAqLLEJICstsC4sIDywAWAtsC8sIGCwGGAgQyOwAWBDsAIlYbABYLAuKiEtsDAssC8rsC8qLbAxLCAgRyAgsA5DY7gEAGIgsABQWLBAYFlmsAFjYCNhOCMgilVYIEcgILAOQ2O4BABiILAAUFiwQGBZZrABY2AjYTgbIVktsDIsALEAAkVUWLEOBkVCsAEWsDEqsQUBFUVYMFkbIlktsDMsALAPK7EAAkVUWLEOBkVCsAEWsDEqsQUBFUVYMFkbIlktsDQsIDWwAWAtsDUsALEOBkVCsAFFY7gEAGIgsABQWLBAYFlmsAFjsAErsA5DY7gEAGIgsABQWLBAYFlmsAFjsAErsAAWtAAAAAAARD4jOLE0ARUqIS2wNiwgPCBHILAOQ2O4BABiILAAUFiwQGBZZrABY2CwAENhOC2wNywuFzwtsDgsIDwgRyCwDkNjuAQAYiCwAFBYsEBgWWawAWNgsABDYbABQ2M4LbA5LLECABYlIC4gR7AAI0KwAiVJiopHI0cjYSBYYhshWbABI0KyOAEBFRQqLbA6LLAAFrAXI0KwBCWwBCVHI0cjYbEMAEKwC0MrZYouIyAgPIo4LbA7LLAAFrAXI0KwBCWwBCUgLkcjRyNhILAGI0KxDABCsAtDKyCwYFBYILBAUVizBCAFIBuzBCYFGllCQiMgsApDIIojRyNHI2EjRmCwBkOwAmIgsABQWLBAYFlmsAFjYCCwASsgiophILAEQ2BkI7AFQ2FkUFiwBENhG7AFQ2BZsAMlsAJiILAAUFiwQGBZZrABY2EjICCwBCYjRmE4GyOwCkNGsAIlsApDRyNHI2FgILAGQ7ACYiCwAFBYsEBgWWawAWNgIyCwASsjsAZDYLABK7AFJWGwBSWwAmIgsABQWLBAYFlmsAFjsAQmYSCwBCVgZCOwAyVgZFBYIRsjIVkjICCwBCYjRmE4WS2wPCywABawFyNCICAgsAUmIC5HI0cjYSM8OC2wPSywABawFyNCILAKI0IgICBGI0ewASsjYTgtsD4ssAAWsBcjQrADJbACJUcjRyNhsABUWC4gPCMhG7ACJbACJUcjRyNhILAFJbAEJUcjRyNhsAYlsAUlSbACJWG5CAAIAGNjIyBYYhshWWO4BABiILAAUFiwQGBZZrABY2AjLiMgIDyKOCMhWS2wPyywABawFyNCILAKQyAuRyNHI2EgYLAgYGawAmIgsABQWLBAYFlmsAFjIyAgPIo4LbBALCMgLkawAiVGsBdDWFAbUllYIDxZLrEwARQrLbBBLCMgLkawAiVGsBdDWFIbUFlYIDxZLrEwARQrLbBCLCMgLkawAiVGsBdDWFAbUllYIDxZIyAuRrACJUawF0NYUhtQWVggPFkusTABFCstsEMssDorIyAuRrACJUawF0NYUBtSWVggPFkusTABFCstsEQssDsriiAgPLAGI0KKOCMgLkawAiVGsBdDWFAbUllYIDxZLrEwARQrsAZDLrAwKy2wRSywABawBCWwBCYgICBGI0dhsAwjQi5HI0cjYbALQysjIDwgLiM4sTABFCstsEYssQoEJUKwABawBCWwBCUgLkcjRyNhILAGI0KxDABCsAtDKyCwYFBYILBAUVizBCAFIBuzBCYFGllCQiMgR7AGQ7ACYiCwAFBYsEBgWWawAWNgILABKyCKimEgsARDYGQjsAVDYWRQWLAEQ2EbsAVDYFmwAyWwAmIgsABQWLBAYFlmsAFjYbACJUZhOCMgPCM4GyEgIEYjR7ABKyNhOCFZsTABFCstsEcssQA6Ky6xMAEUKy2wSCyxADsrISMgIDywBiNCIzixMAEUK7AGQy6wMCstsEkssAAVIEewACNCsgABARUUEy6wNiotsEossAAVIEewACNCsgABARUUEy6wNiotsEsssQABFBOwNyotsEwssDkqLbBNLLAAFkUjIC4gRoojYTixMAEUKy2wTiywCiNCsE0rLbBPLLIAAEYrLbBQLLIAAUYrLbBRLLIBAEYrLbBSLLIBAUYrLbBTLLIAAEcrLbBULLIAAUcrLbBVLLIBAEcrLbBWLLIBAUcrLbBXLLMAAABDKy2wWCyzAAEAQystsFksswEAAEMrLbBaLLMBAQBDKy2wWyyzAAABQystsFwsswABAUMrLbBdLLMBAAFDKy2wXiyzAQEBQystsF8ssgAARSstsGAssgABRSstsGEssgEARSstsGIssgEBRSstsGMssgAASCstsGQssgABSCstsGUssgEASCstsGYssgEBSCstsGcsswAAAEQrLbBoLLMAAQBEKy2waSyzAQAARCstsGosswEBAEQrLbBrLLMAAAFEKy2wbCyzAAEBRCstsG0sswEAAUQrLbBuLLMBAQFEKy2wbyyxADwrLrEwARQrLbBwLLEAPCuwQCstsHEssQA8K7BBKy2wciywABaxADwrsEIrLbBzLLEBPCuwQCstsHQssQE8K7BBKy2wdSywABaxATwrsEIrLbB2LLEAPSsusTABFCstsHcssQA9K7BAKy2weCyxAD0rsEErLbB5LLEAPSuwQistsHossQE9K7BAKy2weyyxAT0rsEErLbB8LLEBPSuwQistsH0ssQA+Ky6xMAEUKy2wfiyxAD4rsEArLbB/LLEAPiuwQSstsIAssQA+K7BCKy2wgSyxAT4rsEArLbCCLLEBPiuwQSstsIMssQE+K7BCKy2whCyxAD8rLrEwARQrLbCFLLEAPyuwQCstsIYssQA/K7BBKy2whyyxAD8rsEIrLbCILLEBPyuwQCstsIkssQE/K7BBKy2wiiyxAT8rsEIrLbCLLLILAANFUFiwBhuyBAIDRVgjIRshWVlCK7AIZbADJFB4sQUBFUVYMFktAAAAAEu4AMhSWLEBAY5ZsAG5CAAIAGNwsQAHQrUAPCweBAAqsQAHQkAKQQQxCCMHFQcECiqxAAdCQApFAjkGKgUcBQQKKrEAC0K9EIAMgAkABYAABAALKrEAD0K9AEAAQABAAEAABAALKrkAAwAARLEkAYhRWLBAiFi5AAMAZESxKAGIUVi4CACIWLkAAwAARFkbsScBiFFYugiAAAEEQIhjVFi5AAMAAERZWVlZWUAKQwIzBiUFFwUEDiq4Af+FsASNsQIARLMFZAYAREQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfQB9AGkAaQNQ//sB0v/7/jkDUP/7AdL/+/45ABgAGAAYABgDUAAAAe3/+/73A1AAAAHt//v+9wB9AH0AbABsA0//+wOsAdP/+/45A1D/+wOsAdP/+/45ABgAGAAYABgDTQFhA00BYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8AAABIAAAAUQAAAFoAAABlAAAAbgAAAHcAAACAAAAAiQAAAJYAAAChAAAArgAAALsAAADIAAAA0QAAANoAAADgAAAA6QAAAPIAAAD7AAABBAAAAWkAAAFyAAAB3gAAAecAAAI7AAACRAAAAqgAAALUAAAC3QAAAuYAAANIAAADUQAAA1oAAAO7AAADwQAABCQAAAQtAAAEMQAABDcAAARyAAAEewAABIQAAASNAAAElgAABJ8AAASqAAAEswAABLwAAATFAAAEzgAABNcAAATgAAAE5gAABO8AAAT4AAAFAQAABQoAAAVpAAAFcgAABd0AAAYtAAAGNgAABj8AAAZIAAAGUQAABloAAAbxAAAHgQAAB4oAAAfaAAAH4wAAB+wAAAf1AAAH/gAACAcAAAgQAAAIFgAACB8AAAgoAAAIMQAACDoAAAisAAAItQAACPgAAAkBAAAJggAACYgAAAnHAAAKWwAACmQAAAptAAAKcwAACnwAAAr9AAALfwAAC9oAAAwiAAAM8QAADPoAAA0DAAANCQAADWIAAA3XAAAN4AAADgIAAA4LAAAOFAAADh0AAA4mAAAOMwAADjwAAA5FAAAOTgAADlcAAA5gAAAObQAADnoAAA6DAAAOjAAADpUAAA7fAAAO6AAADu4AAA73AAAPAAAADwkAAA8SAAAPGwAADyQAAA9lAAAPoQAAD6oAAA+zAAAPwAAAEDoAABBzAAAQswAAEO0AABE+AAARRwAAEVAAABFWAAARXwAAEWgAABGsAAARtQAAEb4AABIrAAASNAAAEjoAABKLAAASuwAAEu4AABNLAAATVAAAE6wAABOyAAAUCQAAFBIAABQbAAAUJAAAFC0AABQ2AAAUPAAAFEUAABROAAAUsAAAFLkAABS/AAAUyAAAFNEAABTaAAAU4wAAFOwAABT1AAAVdgAAFX8AABWIAAAV1wAAFjkAABZCAAAWSwAAFlQAABZdAAAWnAAAFvsAABcEAAAXDQAAFxYAABcfAAAXKAAAFzEAABc6AAAXQwAAF40AABeWAAAXnwAAF6gAABe1AAAX+AAAGAEAABgKAAAYEwAAGB4AABgnAAAYMAAAGDkAABhCAAAYSwAAGFYAABhfAAAYaAAAGHEAABh6AAAYgwAAGIkAABiSAAAYmwAAGKQAABitAAAZEQAAGRoAABmRAAAZmgAAGfAAABn5AAAaWAAAGoYAABqPAAAamAAAGukAABryAAAa+wAAG1oAABtgAAAbZAAAG20AABtxAAAbrAAAG7UAABu+AAAbxwAAG9AAABvZAAAb5AAAG+0AABv2AAAb/wAAHAgAABwRAAAcGgAAHCAAABwpAAAcMgAAHDsAABxEAAAcowAAHKwAABztAAAdKwAAHTQAAB09AAAdRgAAHUwAAB1VAAAduAAAHkgAAB5RAAAebAAAHnUAAB6CAAAeiwAAHpQAAB6dAAAepgAAHq8AAB61AAAevgAAHscAAB7QAAAe2QAAHw0AAB8WAAAfWwAAH2QAAB++AAAfxAAAH+cAAB/tAAAf9gAAH/8AACAFAAAgDgAAIBQAACBIAAAgmgAAINkAACDfAAAg6AAAIPEAACD3AAAhSQAAIU8AACFYAAAh1QAAIiAAACJvAAAinQAAIvYAACL/AAAjCAAAIw4AACMXAAAjIAAAI0YAACOTAAAjnAAAI+UAACPrAAAkKgAAJDMAACQ8AAAkRQAAJE4AACRXAAAkXQAAJGYAACRvAAAkuAAAJMEAACTHAAAk0AAAJNkAACTiAAAk6wAAJPQAACT9AAAlVgAAJV8AACVoAAAljAAAJcIAACXLAAAl1AAAJd0AACXmAAAmEAAAJl8AACZoAAAmcQAAJnoAACaAAAAmiQAAJpIAACabAAAmpAAAJuIAACbrAAAm9AAAJv0AACdJAAAnTwAAJ1UAACdbAAAnYwAAJ2kAACdvAAAndQAAJ3sAACeEAAAnjAAAJ5UAACeeAAAnpwAAJ60AACezAAAnuQAAJ78AACfFAAAnywAAJ9EAAChBAAAoRwAAKMcAACjNAAApDgAAKRQAACljAAApnAAAKaIAACmoAAAqCAAAKg4AACoUAAAqaAAAKrgAACrBAAArIQAALFoAACyGAAAsjAAALJIAACyYAAAsngAALKcAACyvAAAsuAAALMEAACzKAAAs0AAALNYAACzcAAAs4gAALOgAACzuAAAs9AAALPoAAC1JAAAtTwAALYYAAC3QAAAuGwAALiEAAC4nAAAuLQAALjMAAC45AAAufQAALtUAAC7eAAAvDAAALy0AAC8zAAAvOQAALz8AAC9FAAAvSwAAL1EAAC9XAAAvXQAAL2MAAC9pAAAvbwAAL8AAAC/GAAAwAgAAMDEAADA3AAAwfQAAMIMAADDOAAAw+wAAMQQAADENAAAxEwAAMUYAADGiAAAyBwAAMk8AADKFAAAyiwAAMpEAADKXAAAynQAAMvMAADNYAAAzXgAAM5kAADOfAAAzpQAAM6sAADO0AAAzvAAAM8UAADPOAAAz1wAAM90AADPjAAAz7gAAM/kAADP/AAA0BQAANAsAADRoAAA0bgAANHQAADR6AAA0gAAANRsAADUhAAA1JwAANS0AADWNAAA11wAANd0AADXjAAA17gAANlUAADaeAAA23wAANzcAADdtAAA3cwAAN3kAADd/AAA3hQAAN4sAADftAAA38wAAN/kAADh6AAA4gAAAOIYAADjNAAA5BQAAOUUAADlOAAA5rwAAObUAADnuAAA59AAAOfoAADoAAAA6BgAAOgwAADoSAAA6GAAAOh4AADpeAAA6ZAAAOmoAADpwAAA6dgAAOvAAADr2AAA6/AAAOwIAADtaAAA7YAAAO2YAADujAAA77gAAO/QAADv6AAA8AAAAPAYAADxeAAA8pQAAPKsAADyxAAA8twAAPMAAADzGAAA8zAAAPNIAADzYAAA9HwAAPSUAAD0rAAA9MQAAPWAAAD1mAAA9bAAAPXIAAD16AAA9gAAAPYYAAD2MAAA9kgAAPZsAAD2jAAA9rAAAPbUAAD2+AAA9xAAAPcoAAD3QAAA91gAAPdwAAD3iAAA96AAAPjUAAD47AAA+lgAAPpwAAD7dAAA+4wAAPxMAAD9NAAA/UwAAP1kAAD+9AAA/wwAAP8kAAEANAABAXAAAQKsAAEHBAABB7QAAQfMAAEH5AABB/wAAQgUAAEIOAABCFgAAQh8AAEIoAABCMQAAQjcAAEI9AABCQwAAQkkAAEJPAABCVQAAQlsAAEJhAABCqgAAQrAAAELvAABC9QAAQvsAAEMBAABDBwAAQw0AAENHAABDkgAAQ5sAAEPAAABD2AAAQ94AAEPmAABD7AAAQ/IAAEP4AABD/gAARAQAAEQKAABEEAAARBYAAEQcAABEIgAARF0AAERjAABElQAARLsAAETBAABE/AAARQIAAEVOAABFeAAARYEAAEWKAABFkAAARcMAAEYSAABGcgAARrEAAEbeAABG5AAARuoAAEbwAABG9gAARzgAAEeTAABHmQAAR7oAAEfAAABHxgAAR8wAAEfVAABH3QAAR+YAAEfvAABH+AAAR/4AAEgEAABIDwAASBoAAEggAABIJgAASCwAAEhoAABIbgAASHQAAEh6AABIgAAASPYAAEj8AABJAgAASQgAAElIAABJfwAASYUAAEmLAABJlgAASgQAAEo6AABKZwAASpsAAErOAABK1AAAStoAAErgAABK5gAASuwAAEsvAABLNQAASzsAAEuZAABLnwAAS6UAAEvuAABMRwAATIAAAEy3AABM+gAATQAAAE0GAABNDAAATUUAAE2EAABNjQAATfEAAE33AABOJQAATisAAE4xAABONwAATj0AAE5DAABOSQAATk8AAE5VAABOigAATpAAAE6WAABOnAAATqIAAE8MAABPEgAATxgAAE8eAABPaAAAT24AAE90AABPkwAAT8IAAE/IAABPzgAAT9QAAE/aAABQNAAAUHEAAFB3AABQfQAAUIMAAFCMAABQkgAAUJgAAFCeAABQpAAAUP0AAFEDAABRCQAAUQ8AAFEXAABRYwAAUbQAAFIIAABSNwAAUkAAAFJGAABSqwAAUuQAAFMpAABTUwAAU1kAAFNfAABTZQAAU24AAFN2AABTfwAAU4gAAFORAABTlwAAU50AAFOoAABTswAAU7kAAFO/AABTxQAAVA4AAFQUAABUGgAAVCAAAFQmAABUrAAAVLIAAFS4AABUvgAAVQkAAFU9AABVQwAAVUkAAFVUAABVlQAAVckAAFYoAABWLgAAVoAAAFaGAABWjAAAVpIAAFcDAABXmwAAWEAAAFiaAABZGQAAWXIAAFnzAABahQAAWtwAAFvCAABcFgAAXGQAAFyzAABdqwAAXgkAAF5ZAABehQAAXqUAAF6pAABfBwAAXwsAAF88AABfRQAAX4IAAF//AABgAwAAYAwAAGAVAABhIAAAYWwAAGFwAABheQAAYYIAAGIKAABiDgAAYhcAAGJWAABiswAAYrcAAGK7AABjCgAAYw4AAGMSAABjFgAAY2oAAGNzAABj7gAAY/IAAGQjAABknQAAZQcAAGWXAABmAAAAZjcAAGaHAABmjQAAZsoAAGdFAABnSQAAZ5AAAGfZAABn3QAAZ+YAAGfqAABoUAAAaLYAAGkUAABphgAAadsAAGpuAABqvAAAauoAAGs6AABrqgAAbO8AAG1OAABuBAAAbp4AAG8zAABvogAAcFsAAHDuAABxZAAAcbYAAHIZAAByXgAAcn8AAHK6AABzHwAAc8oAAHQsAAB0bgAAdLgAAHVFAAB1lQAAdg8AAHYTAAB2HAAAdiAAAHZuAAB2cgAAdwUAAHdNAAB3sAAAd7kAAHfCAAB3xgAAd88AAHfTAAB33AAAd+UAAHfuAAB4QwAAeEwAAHhVAAB4XgAAeJYAAHifAAB4qAAAeLEAAHi6AAB4wwAAeMwAAHkOAAB5FwAAeYMAAHmHAAB55gAAejUAAHo5AAB6PQAAekEAAHqWAAB65wAAe5MAAHvxAAB79QAAfFUAAHxZAAB8jAAAfJUAAHzbAAB83wAAfOMAAHzsAAB89QAAffwAAH4AAAB+PwAAfkgAAH5RAAB+oAAAfqQAAH6tAAB+0AAAfxYAAH8aAAB/HgAAf1sAAH9fAAB/YwAAf2cAAH9rAAB/dAAAf+QAAH/oAAB/7AAAgE8AAICYAACBEQAAgWAAAIFkAACBaAAAgWwAAIGuAACCCAAAggwAAIJSAACCVgAAgloAAIJjAACCZwAAgqYAAIMBAACDVQAAg54AAIOiAACEYgAAhLAAAITeAACFPgAAhZcAAIaQAACG7wAAh10AAIfWAACIUwAAiPEAAIl/AACJ/wAAilkAAIpdAACKnwAAitYAAIraAACK3gAAizQAAIuZAACL/AAAjAAAAIwyAACMqwAAjTQAAI19AACNzAAAjkUAAI5JAACOUgAAjlYAAI6WAACOmgAAjxYAAI8aAACPZAAAj20AAI92AACPegAAj4MAAI+HAACPkAAAj5kAAI+iAACP5gAAj+8AAI/4AACQAQAAkAUAAJAOAACQFwAAkCAAAJApAACQMgAAkDsAAJCEAACQjQAAkQoAAJEOAACRUQAAkVUAAJFZAACRXQAAkWEAAJFlAACRzgAAkdIAAJIsAACSMAAAkm8AAJJ1AACSnAAAkqAAAJKkAACSqgAAkrAAAJNPAACTkgAAk5YAAJOcAACTogAAlAAAAJQEAACUCgAAlF8AAJTGAACU/AAAlQAAAJUEAACVCAAAlQwAAJUQAACVFAAAlRoAAJXRAACV1QAAliMAAJaDAACW4gAAl2wAAJerAACX5AAAmEcAAJiIAACZCwAAmVkAAJldAACZnwAAmfwAAJoAAACaBgAAmgoAAJoOAACabAAAmvIAAJtdAACbqgAAnCQAAJx8AACcowAAnPsAAJ1HAACePAAAnqYAAJ8NAACfZQAAn9kAAKBmAACgtwAAoPUAAKFFAAChhQAAodwAAKI8AACihAAAovMAAKOGAACj+gAApFQAAKS4AAClGAAApRwAAKVVAAClswAApc0AAKXTAACl1wAApj0AAKZBAACmgwAAptwAAKdYAACnXgAAp2QAAKdoAACnbgAAp8QAAKfKAACn0AAAp9YAAKgkAACoKgAAqDAAAKg2AACoeQAAqH8AAKiFAACoiwAAqJEAAKiXAACooAAAqKQAAKiqAACpDAAAqRAAAKmgAACp2QAAqnAAAKp0AACqeAAAqsUAAKsYAACrXwAAq2MAAKtnAACrrgAAq7IAAKvxAACr9wAAq/sAAKv/AACsAwAArAkAAKwPAACstgAArPAAAKz0AACs+gAArQAAAK1XAACtWwAArWEAAK2SAACt2AAArgMAAK4HAACuCwAArg8AAK4TAACuFwAArhsAAK4hAACujgAArpIAAK7nAACvOgAAr4UAAK/9AACwNAAAsF0AALCqAACw5QAAsSgAALFmAACxagAAsawAALHqAACx7gAAsfQAALH4AACx/AAAsi8AALJ9AACy1gAAsxMAALOTAACzzwAAs/YAALROAAC0jwAAtWsAALWyAAC2DAAAtmcAALblAAC3dAAAt7oAALfrAAC4MQAAuHEAALi7AAC5EgAAuTwAALl8AAC6AAAAumYAALrDAAC7PgAAu5EAALuVAAC70QAAvCcAALxhAAC8wAAAvMQAALzKAAC8zgAAvRAAAL0UAAC9TgAAvbAAAL4GAAC+DAAAvhIAAL4WAAC+HAAAviAAAL4mAAC+LAAAvjIAAL6AAAC+hgAAvowAAL6SAAC+vAAAvsIAAL7IAAC+zgAAvtQAAL7aAAC+4AAAvuQAAL7qAAC/QAAAv0QAAL/aAADAEgAAwBYAAMAaAADAHgAAwCIAAMBsAADAlAAAwOMAAMEtAADBigAAwckAAMIoAADC4wAAwzUAAMQEAADEYwAAxIEAAMS1AADE8wAAxSYAAMVFAADFZwAAxasAAMXgAADGGAAAxk4AAMaCAADGrwAAxt4AAMcSAADHMwAAx2IAAMeYAADHywAAx+AAAMfrAADH9gAAyAEAAMhIAADIXwAAyGYAAMh5AADIggAAyJgAAMigAADIxQAAyOwAAMk/AADJUAAAyYMAAMm3AADJvQAAydEAAMnaAADJ8QAAygYAAMpNAADKlQAAysAAAMrrAADLJAAAy10AAMtwAADLgwAAy5EAAMuVAADLwAAAy+sAAMwFAADMHwAAzCUAAMwrAADMMQAAzEgAAMxfAADMdQAAzHUAAMywAADM6wAAzUEAAM2AAADNyAAAzjAAAM56AADOuQAAzywAAM+NAADP4AAA0DEAANCsAADQ8gAA0R4AANF6AADSWwAA0skAANMMAADTVQAA070AANPxAADUOQAA1J8AANTcAADU7wAA1QUAANUnAADVOwAA1V4AANWIAADVqAAA1ekAANYFAADWIAAA1ksAANZ2AADWpwAA1usAANcbAADXNAAA15MAANe3AADX2wAA2AEAANgjAADYYgAA2I8AANjwAADZawAA2YsAANnbAADaHAAA2mMAANqtAADbCwAA22oAANvIAADb7AAA3AcAANwyAADcWgAA3JIAAN0dAADdOwAA3VsAAN1wAADdhwAA3aAAAN3IAADd3gAA3f0AAN4cAADeOwAA3l4AAN6NAADeowAA3tEAAN74AADfFwAA3y8AAN9FAADfWgAA33kAAN+RAADfwgAA3+0AAOAMAADgIgAA4DgAAOBWAADgaQAA4H0AAOCRAADgtgAA4M8AAODsAADhCgAA4SsAAOFZAADhbAAA4ZcAAOG6AADh2AAA4e8AAOIDAADiFgAA4jMAAOJKAADiegAA4qQAAOLCAADi1QAA4u0AAOLyAADi9wAA4vwAAOMBAADjBgAA4wsAAOMQAADjFQAA4xoAAOMfAADjJAAA4ykAAOMuAADjMwAA41QAAONyAADjvwAA5AkAAORAAADkiwAA5LcAAOThAADlLQAA5YgAAOXVAADmHwAA5lYAAOahAADmzQAA5vcAAOdDAADnngAA57AAAOfPAADn9AAA6AYAAOgoAADoRgAA6FwAAOhzAABADj/+wOTA1AAPgBMQEkkAQYEPAEDBgJMAAECBAIBBIAABAYCBAZ+AAYDAgYDfgACAgBhAAAAOU0FAQMDB2IJCAIHBzQHTgAAAD4APSYjKCUlJBYmCgkeKxYmJjU0EjYzMhYXFhUUBiMiJyYmIyIGBhUUFjMyNjY3NjYzMhUUBwYGFRQWMzI2NzYzMhYVFAcGBiMiJicGI+dvQIL+si5pKxwnGggENEopf7JYQzY9XEwlBiQeRwMaKyAhIDosDA8NDxMxXkRGVgtKkAVEgViYAQOdDg4IIBouAQwLe8p1VV1k4MAcFC4IDGHrPTYxKzQOGBUnFzs+UUqbAP//ADj/+wOTBHwAIgAEAAABBwXAA4IBfAAJsQEBuAF8sDUrAP//ADj/+wOTBEkAIgAEAAABBwXEA4IBfAAJsQEBuAF8sDUrAP//ADj/+wOTBNkAIgAEAAABBwXtA4IBfAAJsQECuAF8sDUrAP//ADj/GAOTBEkAIgAEAAAAIwXNAukAAAEHBcQDggF8AAmxAgG4AXywNSsA//8AOP/7A5ME2QAiAAQAAAEHBe4DggF8AAmxAQK4AXywNSsA//8AOP/7A5MFBAAiAAQAAAEHBe8DggF8AAmxAQK4AXywNSsA//8AOP/7A5MFCgAiAAQAAAEHBfADggF8AAmxAQK4AXywNSsA//8AOP/7A5MEnwAiAAQAAAEHBcIDggF8AAmxAQG4AXywNSsA//8AOP/7A5MFvQAiAAQAAAAnBcIDggF8AQcFwAOqAr0AErEBAbgBfLA1K7ECAbgCvbA1K///ADj/GAOTBJ8AIgAEAAAAIwXNAukAAAEHBcIDggF8AAmxAgG4AXywNSsA//8AOP/7A5MFvQAiAAQAAAAnBcIDggF8AQcFvwOqAr0AErEBAbgBfLA1K7ECAbgCvbA1K///ADj/+wOTBcYAIgAEAAAAJwXCA4IBfAEHBcgDqQK9ABKxAQG4AXywNSuxAgG4Ar2wNSv//wA4//sDkwWYACIABAAAACcFwgOCAXwBBwXGA6oCvQASsQEBuAF8sDUrsQIBuAK9sDUr//8AOP/7A5MEfAAiAAQAAAEHBckDggF8AAmxAQK4AXywNSsA//8AOP/7A5MEMQAiAAQAAAEHBb0DggF8AAmxAQK4AXywNSsA//8AOP8YA5MDUAAiAAQAAAADBc0C6QAA//8AOP/7A5MEfAAiAAQAAAEHBb8DggF8AAmxAQG4AXywNSsA//8AOP/7A5MEhQAiAAQAAAEHBcgDgQF8AAmxAQG4AXywNSsA//8AOP/7A5MESQAiAAQAAAEHBcoDggF8AAmxAQG4AXywNSsA//8AOP/7A5MD8gAiAAQAAAEHBccDgQF8AAmxAQG4AXywNSsAAAEAOP8CA5MDUABWAKNADi4BBwUHAQQHBAEABANMS7ASUFhANQACAwUDAgWAAAUHAwUHfgAHBAMHBH4JAQgLAQoICmYAAwMBYQABATlNBgEEBABhAAAANABOG0A8AAIDBQMCBYAABQcDBQd+AAcEAwcEfgAJAAgACQiAAAgLAQoICmYAAwMBYQABATlNBgEEBABhAAAANABOWUAUAAAAVgBVTkwsIyglJSQWJigMCR8rBCY1NDcmJicGIyImJjU0EjYzMhYXFhUUBiMiJyYmIyIGBhUUFjMyNjY3NjYzMhUUBwYGFRQWMzI2NzYzMhYVFAYHBgcGBhUUFjMyNzYzMhYVFAYHBgYjAodVPCs1CEqQRW9Agv6yLmkrHCcaCAQ0Sil/slhDNj1cTCUGJB5HAxorICEgOiwMDw0PBww7Ui4pJBoaFREKDgwWGQwnEP5LPUkyEEo3m0SBWJgBA50ODgggGi4BDAt7ynVVXWTgwBwULggMYes9NjErNA4YFRMeDUUvGjAbHR4HBhMTFR0JBAYAAAD//wA4//sDkwSoACIABAAAAQcFxQOCAXwACbEBArgBfLA1KwAABAA4//sDzgURABAAHgAqAGkAi0CITwEMCmcBCQwCTAAAAgCFDwEBAgQCAQSAAAcICggHCoAACgwICgx+AAwJCAwJfgACAAQFAgRpEQEFEAEDBgUDaQAICAZhAAYGOU0LAQkJDWISDgINDTQNTisrHx8REQAAK2kraGVjXVtYVk5MR0VAPjo5MzEfKh8pJSMRHhEdGBYAEAAPJhMJFysAJjU0Nzc2MzIWFRQGBwcGIwYmNTQ2NjMyFhUUBgYjNjY1NCYjIgYVFBYzACYmNTQSNjMyFhcWFRQGIyInJiYjIgYGFRQWMzI2Njc2NjMyFRQHBgYVFBYzMjY3NjMyFhUUBwYGIyImJwYjAwwSEGgQFRYhFhd1CArsTCdBJTVMJ0ElGBwaEhQcGhL+gG9Agv6yLmkrHCcaCAQ0Sil/slhDNj1cTCUGJB5HAxorICEgOiwMDw0PEzFeREZWC0qQBGcSDQ8PXg8gFhEhCjQE10c9LUMkRz0tQyRYHhkWGx4ZFhv8E0SBWJgBA50ODgggGi4BDAt7ynVVXWTgwBwULggMYes9NjErNA4YFScXOz5RSpv//wA4//sDkwRXACIABAAAAQcFxgOCAXwACbEBAbgBfLA1KwAAAQA4//sEdQNRAE4AdbUNAQQAAUxLsBtQWEAqAAAIBAgABIAABgYDYQUBAwMzTQAICAdfAAcHNk0JAQQEAWECAQEBNAFOG0AoAAAIBAgABIAABwAIAAcIZwAGBgNhBQEDAzNNCQEEBAFhAgEBATQBTllADkxKRFM0VSooIycgCgkfKyQzMhYVFAYHBgYjIiYnBiMiJiY1NDY2NzYzMhUUBgcOAhUUFjMyNjcTNjY3NzYzMhYVFAYjIgYHBgc2MzYzMhYVFAYHBwYHBhUUMzI2NwRMCw4QExctk0R7kBZPn0t0QXXQgggNQRMTcqFRQzZTZSpRD0UzNH5IJBwkJEONIBgiLhRrSh4XIx9xNF0LuzRsRbsXEhclESAqYVGyRIFYkvWbEAE/FRsCDXq/clVdpZoBKDc4AgMGGR0fLAYESJsCBRkYHykBAwICMSafISL//wA4//sEdQR8ACIAHQAAAQcFwAPxAXwACbEBAbgBfLA1KwAAAQAU/84DZANeAEQAykAOAgEEBR4BAwQLAQADA0xLsA1QWEAzAAIGBwYCB4AABwUGBwV+AAEAAYYABgYIYQAICDNNAAQEBWEABQU2TQADAwBiAAAANABOG0uwJFBYQDMAAgYHBgIHgAAHBQYHBX4AAQABhgAGBghhAAgIOU0ABAQFYQAFBTZNAAMDAGIAAAA0AE4bQDEAAgYHBgIHgAAHBQYHBX4AAQABhgAIAAYCCAZpAAQEBWEABQU2TQADAwBiAAAANABOWVlADCcjJSQkJycjKAkJHysABgcWFhUUBgYjIicGBiMiJjc2Ejc2NjMyFRQHBgIHFjMyNjU0JicmJjU0Njc+AjU0JiMiBgcGIyImNTQ2NzY2MzIWFQNkeHM+QGO+hjIeAS4kJBsCCTQoByoiPQYaNAswHoyDS1gUEBggR3NCcnZryEYgFhITFShU4na1sgIrexsRTTJPdD8DHBwgH4wBM48ZFCIOEk7+9XkEUT8sPAMBEhQdJAECJkUuOkM3KhMZExkkFzA2emQAAAEAQP/7AywDUAAqADZAMwABAgQCAQSAAAQDAgQDfgACAgBhAAAAOU0AAwMFYQYBBQU0BU4AAAAqACkjJSckJgcJGysEJiY1NDY2MzIWFRQGIyImNTQ3NjU0IyIGBhUUFjMyNjc2MzIWFRQHBgYjAU6wXm++dGxwKygcIAQGYUJ4SoaDQYVRDwoQEEJHmUUFV6Bqk+R9b1s9ShoZCRgeEltWp3N4gyEiBhgTPR0fHQD//wBA//sDLAR8ACIAIAAAAQcFwAMSAXwACbEBAbgBfLA1KwD//wBA//sDLASJACIAIAAAAQcFwwMSAXwACbEBAbgBfLA1KwAAAQBA/wIDLANQAEQAzbUkAQEJAUxLsCFQWEAzAAcIAAgHAIAAAAkIAAl+AAUBAwEFcgQBAwACAwJlAAgIBmEABgY5TQAJCQFhAAEBNAFOG0uwLlBYQDQABwgACAcAgAAACQgACX4ABQEDAQUDgAQBAwACAwJlAAgIBmEABgY5TQAJCQFhAAEBNAFOG0A6AAcIAAgHAIAAAAkIAAl+AAUBAwEFA4AAAwQBAwR+AAQAAgQCZQAICAZhAAYGOU0ACQkBYQABATQBTllZQA5CQCckKiQjFiQVIAoJHyskMzIWFRQHBgcWFRQGIyInJiY1NDYzMhcWMzI2NTQmIyImNTQ3JiY1NDY2MzIWFRQGIyImNTQ3NjU0IyIGBhUUFjMyNjcDAgoQEEKBlx5nWCYYFBMUFAgFGxooLSslGhwNZG5vvnRscCsoHCAEBmFCeEqGg0GFUbwYEz0dOAQgMUtdBQQWFRgWAQQhIhkdDhEWDSeoc5PkfW9bPUoaGQkYHhJbVqdzeIMhIgAAAP//AED/+wMsBJ8AIgAgAAABBwXCAxIBfAAJsQEBuAF8sDUrAP//AED/+wMsBDAAIgAgAAABBwW+AxIBfAAJsQEBuAF8sDUrAAABAC3/+wMxA1wALwD1tREBAQMBTEuwCVBYQCUAAAIDAgADgAADAQIDAX4AAgIEYQAEBDNNAAEBBWIGAQUFNAVOG0uwDlBYQCUAAAIDAgADgAADAQIDAX4AAgIEYQAEBDlNAAEBBWIGAQUFNAVOG0uwEFBYQCUAAAIDAgADgAADAQIDAX4AAgIEYQAEBDNNAAEBBWIGAQUFNAVOG0uwKlBYQCUAAAIDAgADgAADAQIDAX4AAgIEYQAEBDlNAAEBBWIGAQUFNAVOG0AjAAACAwIAA4AAAwECAwF+AAQAAgAEAmkAAQEFYgYBBQU0BU5ZWVlZQA4AAAAvAC4nIyQnKQcJGysWJyYmNzYSNzY2MzIVFAcGAgcWMzI2NTQmIyIGBwYjIiY1NDY3NjYzMhYWFRQGBiP6SSgeAgc0JQcqIj0GGjQLHiavrYh8UJ0/DQ8RFBATRbpWerJgeOafBQoFICRjASOHGRQiDhJQ/vN6A9Sxd4IyKQkdFRgfDS8xVaR0l+F8AAD//wBQ//sGfASJACIA7gAAAAMAyQMqAAAAAgAP//sDIwNcABwANgDrtTQBBwEBTEuwCVBYQCEFAQIGAQEHAgFpAAQEA2EIAQMDM00JAQcHAGEAAAA0AE4bS7AOUFhAIQUBAgYBAQcCAWkABAQDYQgBAwM5TQkBBwcAYQAAADQAThtLsBBQWEAhBQECBgEBBwIBaQAEBANhCAEDAzNNCQEHBwBhAAAANABOG0uwKlBYQCEFAQIGAQEHAgFpAAQEA2EIAQMDOU0JAQcHAGEAAAA0AE4bQB8IAQMABAIDBGkFAQIGAQEHAgFpCQEHBwBhAAAANABOWVlZWUAYHR0AAB02HTUyLionJCIAHAAbIyYmCgkZKwAWFhUUBgYjIicmJjc2NyMiNTQ2MzM2NzY2NzYzEDY2NTQmIyIHBgcWMzIWFRQGIyInJwYHFjMCH6tZeeaeQkknHgMNIEUyO0AXJC4HFRQxVJ1Lhm8hCyEiHT5ALRolIE40HgsfKgNcW6Vuj+OBCgUgJIqnLikjm4oUGQUM/RBnrGqBggFkjwEaHR8kAgGWewP//wAt//sDMQSJACIAJgAAAQcFwwLsAXwACbEBAbgBfLA1KwD//wAP//sDIwNcAAIAKAAA//8AUP/qBO4DXAAiAO4AAAADAwADCwAAAAEAH//7AywDUAA9AEFAPhEBBgUBTAADBAUEAwWAAAAGBwYAB4AABQAGAAUGaQAEBAJhAAICOU0ABwcBYQABATQBTiUjJCgkLCcgCAkeKyQzMhYVFAYHBgYjIiYmNTQ2NyYmNTQ2NjMyFhUUBiMiJjU0NzY1NCYjIgYVFBYXFhYVFAcOAhUUFjMyNjcDAgoQEB0jO7xbfqpTb2w7P1uaXHx8KygcIAUFNj9VZk1XFhI8U20xdH5TuUK8GBMeKhEcITlkP1Z5GxFWNUhvPGtVO0kZGREUIQwkLUg9Lz0DARIVQgECKkElPj8nHAD//wAf//sDLAR8ACIALAAAAQcFwAMEAXwACbEBAbgBfLA1KwD//wAf//sDLARJACIALAAAAQcFxAMEAXwACbEBAbgBfLA1KwD//wAf//sDLASJACIALAAAAQcFwwMEAXwACbEBAbgBfLA1KwD//wAf//sDLASfACIALAAAAQcFwgMEAXwACbEBAbgBfLA1KwD//wAf//sDLATnACIALAAAAQcF8QMEAXcACbEBArgBd7A1KwD//wAf/xgDLASfACIALAAAACMFzQLdAAABBwXCAwQBfAAJsQIBuAF8sDUrAP//AB//+wMsBOcAIgAsAAABBwXyAwQBdwAJsQECuAF3sDUrAP//AB//+wMsBN0AIgAsAAABBwXzAwQBdwAJsQECuAF3sDUrAP//AB//+wMsBP4AIgAsAAABBwX0AwQBdwAJsQECuAF3sDUrAP//AB//+wMsBHwAIgAsAAABBwXJAwQBfAAJsQECuAF8sDUrAP//AB//+wMsBDEAIgAsAAABBwW9AwQBfAAJsQECuAF8sDUrAP//AB//+wMsBDAAIgAsAAABBwW+AwQBfAAJsQEBuAF8sDUrAP//AB//GAMsA1AAIgAsAAAAAwXNAt0AAP//AB//+wMsBHwAIgAsAAABBwW/AwQBfAAJsQEBuAF8sDUrAP//AB//+wMsBIUAIgAsAAABBwXIAwMBfAAJsQEBuAF8sDUrAP//AB//+wMsBEkAIgAsAAABBwXKAwQBfAAJsQEBuAF8sDUrAP//AB//+wMsA/IAIgAsAAABBwXHAwMBfAAJsQEBuAF8sDUrAAABAB//AgMsA1AAVACWtSgBCQgBTEuwElBYQDUABgcIBwYIgAAACQoJAAqAAAgACQAICWkCAQEAAwEDZQAHBwVhAAUFOU0ACgoEYQAEBDQEThtAPAAGBwgHBgiAAAAJCgkACoAAAgQBBAIBgAAIAAkACAlpAAEAAwEDZQAHBwVhAAUFOU0ACgoEYQAEBDQETllAEFJQS0kkKCQsFCciLCALCR8rJDMyFhUUBgcGBgcGFRQWMzI3NjMyFhUUBgcGBiMiJjU0Ny4CNTQ2NyYmNTQ2NjMyFhUUBiMiJjU0NzY1NCYjIgYVFBYXFhYVFAcOAhUUFjMyNjcDAgoQEB0jLYlMNCQaGhUQCw4MFhkMJxBGVClxmktvbDs/W5pcfHwrKBwgBQU2P1VmTVcWEjxTbTF0flO5QrwYEx4qERYeBio5HR4HBhMTFR0JBAZJPz40BDtgPFZ5GxFWNUhvPGtVO0kZGREUIQwkLUg9Lz0DARIVQgECKkElPj8nHAAA//8AH//7AywEVwAiACwAAAEHBcYDBAF8AAmxAQG4AXywNSsAAAH////4A6gDTwBHAONLsBJQWLUzAQAKAUwbtTMBAAEBTFlLsBJQWEAyAAkAAgAJAoAABQMGAwUGgAEBAAAKYQAKCjNNBwEDAwJhCAECAjZNAAYGBGEABAQ0BE4bS7AuUFhAOAAAAQkBAAmAAAkCAQkCfgAFAwYDBQaAAAEBCmEACgozTQcBAwMCYQgBAgI2TQAGBgRhAAQENAROG0A9AAABCQEACYAACQIBCQJ+AAUDBgMFBoAACAMDCFkAAQEKYQAKCjNNBwEDAwJfAAICNk0ABgYEYQAEBDQETllZQBBGRD48NCMjJiMkIjITCwkfKwAWFRQnJyYmIyMGBzcyFhUUBiMjBwYGIyImJyY1NDYzMhYXFjMyNjc3IyImNTQ2MzI3NjcGBhUUFxYVFAYjIicmJjU0JDMyFwOTFUojO3VALQwNrCUZKCWrBhWJeERyGwsXEQwXEjBHOU0LBjAXISAfHBsMDmxYFAYoGRsTDBYA//WqggM5GhVFBQMFBpR6AxoWIicrpYw7KhEYGCQQFz9dZDcaGB8hAW6dCjIxIh8JCRIbEAo+JnxwEgAAAgBA/jkDmANQAEgAUABeQFtEEgIBBUsBCQECTAADBAcEAweACgEIBgUGCAWAAAcABggHBmcABAQCYQACAjlNAAUFAWEAAQE0TQsBCQkAYQAAADgATklJAABJUElPAEgARzQiJSgkJigpDAkeKyQWFRQGBwYHBgYjIiY1NDY2NzcGIyImJjU0NjYzMhYVFAYjIiY1NDc2NTQmIyIGBhUUFjMyNzcjIiY1NDYzMzIWBwYHBzY3NjMANjcGBhUUMwOJDw4PO4EnfF8zQCpzaQNPTHCqXnDFenV1KygbIQQGMzxJfUyDfEVLDmYcHh4ZuxYdAwMRC1BCDQr+Zj4bTEMc3RkTFxoKJ1nP7j8zL2B+URMhV6BqlON9bVo7RxoXChgcECouVKd1eIMfehsfHCAdGyBxTDwsCP29doNBaSgnAP//AED+OQOYBEkAIgBBAAABBwXEAyEBfAAJsQIBuAF8sDUrAP//AED+OQOYBIkAIgBBAAABBwXDAyEBfAAJsQIBuAF8sDUrAP//AED+OQOYBJ8AIgBBAAABBwXCAyEBfAAJsQIBuAF8sDUrAP//AED+OQOYA1AAIgBBAAABBwXPAoIAFgAIsQIBsBawNSsAAP//AED+OQOYBDAAIgBBAAABBwW+AyEBfAAJsQIBuAF8sDUrAAAC//D/+QPqA20ATQBXAWhLsBVQWEAKUQEEBgsBAQQCTBtAClEBCAYLAQEEAkxZS7AVUFhAOgAGBQQFBgSADQELAQoBCwqAAAkOAQwFCQxpCAEEAwEBCwQBaQAFBQdhAAcHOU0ACgoAYQIBAAA0AE4bS7AWUFhARwAGBQgFBgiAAAgEBQgEfgABBAMEAQOADQELAwoDCwqAAAkOAQwFCQxpAAQAAwsEA2kABQUHYQAHBzlNAAoKAGECAQAANABOG0uwF1BYQEUABgUIBQYIgAABBAMEAQOADQELAwoDCwqAAAkOAQwFCQxpAAQAAwsEA2kABQUHYQAHBzlNAAgINk0ACgoAYQIBAAA0AE4bQEcABgUIBQYIgAAIBAUIBH4AAQQDBAEDgA0BCwMKAwsKgAAJDgEMBQkMaQAEAAMLBANpAAUFB2EABwc5TQAKCgBhAgEAADQATllZWUAcTk4AAE5XTlYATQBMSUc/PSQmIiQkJSMXJQ8JHyskFhUUBwYjIiY1NDcGBwYHBgcGIyI1NDc2NwciJjU0Njc3NjU0JiMiBwYjIiY1NDc2NjMyFhUUBzc2Nz4CMzIWFRQHBhUUFjMyNjc2MwIGBgc2NjU0JiMD2w8TY3BhdANCTjQTFCQVO0AFIhQwIR4mLDUaHBdGWA0QDhQZLIZFQUcYYj8tEkpuRDI6/QM0LylEKwwPnTEsDVBMEAzfGBUnF3mWjCIiDAYEAWaUVzoNF4lfAhcaIR8CAo1KLyJ1ERoUHyM9T1leU44FAwduwHhPQPhgKCtpWCs0DgI3UIpSIXpgFxoAAgA4//sDcANQAFUAXQFAS7AmUFi1OwEICQFMG7U7AQwJAUxZS7AVUFhAKAwKAggOEA0DBwAIB2oLAQkJOU0FAwIBAQBhDwYCAAA2TQQBAgI0Ak4bS7AhUFhAJgwKAggOEA0DBwAIB2oPBgIABQMCAQIAAWkLAQkJOU0EAQICNAJOG0uwJlBYQCsMCgIIDhANAwcACAdqAAAGAQBZDwEGBQMCAQIGAWkLAQkJOU0EAQICNAJOG0uwLlBYQDUADAgHDFkKAQgOEA0DBwAIB2oAAAYBAFkDAQEFBgFZDwEGAAUCBgVpCwEJCTlNBAECAjQCThtANgAMEAENBwwNagoBCA4BBwAIB2oAAAYBAFkDAQEFBgFZDwEGAAUCBgVpCwEJCTlNBAECAjQCTllZWVlAHgAAXVpZVwBVAFRQTktJRUI/PSMjIyYmJiYkIhEJHysBBgczMhYVFAYjIwcGBgcGBiMiNTQ2PwIjBwcGBgcGBiMiNTQ2PwIHIjU0NjMzNTY3ByI1NDYzMzY3NjYzMhUUBzcyNzY3NjYzMhUUBzMyFhUUBiMGNyMPAjc3AwgHCx0gHSQxGQILFwQDJiJFExMEA7WJAgsXBAMmIkUTEwQCIDUmLhYKByc0Ji4UBwEDKCY/CYVDcgEHAygmPwgaIB0kMacIuoMSAYi3Alc1NxwXIiQNQ7EwJSE8IINvGg8CC0OxMCUhPCCDbxoKAS8kJQIzOgEoHyA1HCUhPB87AQIJRCUhPBs6GBQdHz09AW4DAQP////w//kD6gSfACIARwAAAQcFwgNDAXwACbECAbgBfLA1KwAAAf/v/+4CLANLADQApkuwElBYQBkFAQAABl8HAQYGM00EAQEBAmEDAQICNAJOG0uwJlBYQB0FAQAABl8HAQYGM00EAQEBAl8AAgI0TQADAzQDThtLsC5QWEAdAAMCA4YFAQAABl8HAQYGM00EAQEBAl8AAgI0Ak4bQCQABAECAQQCgAADAgOGBQEAAAZfBwEGBjNNAAEBAl8AAgI0Ak5ZWVlADwAAADQAMCYkImQ3NAgJHCsAFhUUBiMiBwYHBgcHBgc2MzIWFRQGIyInJiMiBwYjIiY1NDY/AjY3NzY3ByImNTQ3NjMXAggkKCU6HgIQEgQVFg0VJDUmKSUZNjIQP0shDhYeQDovAxgLFhQQVCQbYi5CtwNKGRIgJwEMYGsYg5NjARwcGiQCAgsFGBckKAEBFqBCg3R7ARcVRAUCAf///+//7gJfBHwAIgBKAAABBwXAAoQBfAAJsQEBuAF8sDUrAP///+//7gI3BEkAIgBKAAABBwXEAoQBfAAJsQEBuAF8sDUrAP///+//7gIsBJ8AIgBKAAABBwXCAoQBfAAJsQEBuAF8sDUrAP///+//7gIsBHwAIgBKAAABBwXJAoQBfAAJsQECuAF8sDUrAP///+//7gIsBDEAIgBKAAABBwW9AoQBfAAJsQECuAF8sDUrAP///+//7gIsBDAAIgBKAAABBwW+AoQBfAAJsQEBuAF8sDUrAP///+//GAIsA0sAIgBKAAAAAwXNAkYAAP///+//7gIsBHwAIgBKAAABBwW/AoQBfAAJsQEBuAF8sDUrAP///+//7gIsBIUAIgBKAAABBwXIAoMBfAAJsQEBuAF8sDUrAP///+//7gI5BEkAIgBKAAABBwXKAoQBfAAJsQEBuAF8sDUrAP///+//7gIsA/IAIgBKAAABBwXHAoMBfAAJsQEBuAF8sDUrAAAB/+//AgIsA0sASgD1S7ASUFi1MAEDAgFMG7UwAQYCAUxZS7ASUFhAIQQBAwAFAwVlCAEAAAlfCgEJCTNNBwEBAQJhBgECAjQCThtLsCZQWEAyAAQGAwYEA4AAAwAFAwVlCAEAAAlfCgEJCTNNBwEBAQJfAAICNE0HAQEBBmEABgY0Bk4bS7AuUFhALQAEBgMGBAOAAAYEAQZZAAMABQMFZQgBAAAJXwoBCQkzTQcBAQECXwACAjQCThtALgAEBgMGBAOAAAcABgQHBmkAAwAFAwVlCAEAAAlfCgEJCTNNAAEBAl8AAgI0Ak5ZWVlAEgAAAEoARiYkJyciJEQ3NAsJHysAFhUUBiMiBwYHBgcHBgc2MzIWFRQGIyInJwYVFBYzMjc2MzIWFRQGBwYGIyImNTQ3BgcGIyImNTQ2PwI2Nzc2NwciJjU0NzYzFwIIJCglOh4CEBIEFRYNFSQ1JiklFzIjMyQaGhURCg4MFhkMJxBGVCgJLiMPFh5AOi8DGAsWFBBUJBtiLkK3A0oZEiAnAQxgaxiDk2MBHBwaJAIBKzcdHgcGExMVHQkEBkk/PTMBBgUYFyQoAQEWoEKDdHsBFxVEBQIBAP///+//7gJFBFcAIgBKAAABBwXGAoQBfAAJsQEBuAF8sDUrAAACAEf/lQL+A08AJwAvAHlLsAlQWEAKEQEABCoBBQMCTBtAChEBAAIqAQUDAkxZS7AJUFhAHAADAAUAAwWABgEFAAEFAWUCAQAABGEABAQzAE4bQCIAAAIDAgADgAADBQIDBX4GAQUAAQUBZQACAgRhAAQEMwJOWUAOKCgoLyguJCgpJREHCRsrAAYjBgcGBwIhIiY1NDY3Njc3JiMiBhUUFxYVFAYjIicmNTQhMhcWFQA2NwYVFBYzAv4ZHAIHCgFZ/uZTXdiwCwYSPDSLhBQGKxkgERwBpHpgOf6CYiX0IBwC4R4VNEYI/WleR3/DQEc4lwY2PR4jCgsVIRsuPfAYDir9AZS5a5siJQD//wBH/5UC/gSfACIAWAAAAQcFwgLpAXwACbECAbgBfLA1KwAAAQAa//gEKgNPAGYA6UuwLlBYQBdVAQYILwEJBkwBBQdaAQQFBEwOAQQBSxtAF1UBBgovAQkGTAEFB1oBBAUETA4BBAFLWUuwLlBYQEMACQYHBgkHgAAHBQYHBX4NDAICBAsEAguAAAUABAIFBGkABgYIYQoBCAgzTQALCwBiAQEAADRNAAMDAGEBAQAANABOG0BHAAkGBwYJB4AABwUGBwV+DQwCAgQLBAILgAAFAAQCBQRpAAoKM00ABgYIYQAICDNNAAsLAGIBAQAANE0AAwMAYQEBAAA0AE5ZQBgAAABmAGViYFNRS0omKSQkIyQmKSYOCR8rJBYVFAcGBiMiJicuAicHBgYjIiYnJjU0NjMyFhcWFjMyNjc3IyImNTQ2MzM2NzcmIyIGFRQWFxYVFAYjIicmNTQ2NjMyFhcWFRQjAzY2NzY2MzIWFRQHBgYHHgIXFhYzMjY3NjMEGw8TMGJDSl4pHicmHQsVeWpFaxUHHBYNEggfLyMoOQwOEBcaGxQhBwMfGhdVWAsJBCkZIA8eRYxnLUstMS8ndZMxCSshHB8EMrpuJjEiFh82JCA6LAwP3xgVJxc6P1dcQkEbA0qPfkM0EhUeLA0QOi5JTF8aFxofMRPhAzs3GR8TCAoWIRw1PT9oPwoODyk3/vMMsZgcHhkXBxClwiAJJDUvQjcrNA7//wAa/uwEKgNPACIAWgAAAAMFzwNsAAAAAf/X//sDIgNQADwATkBLMgEGAgwBAAYCTAAEBQcFBAeACAEHAgUHAn4ABQUDYQADAzlNAAICAGEBAQAANE0ABgYAYQEBAAA0AE4AAAA8ADspKCQmJCUmCQkdKyQWFRQHBgYjIiYnJicGIyImNTQ2MzMTNjY3NjYzMhYVFAYjIiY1NDc2NTQmIyIGBwcGBxYXFhYzMjY3NjMDEw8TOGlKNFg/OTUzZjhDXk4NEgY8NS52Qmx0LCccIAQGMTJYYA0XBQhAYDg8FzpTJQwP3xgVJxdDNhoaGRBdMygxQQEjZIIuKClwWj1LGxkJGBwWKjFze+MwIwsYDgwnKw4AAv/X/5UFEwNQAF0AZQExS7AdUFhAE0QBAAdgAQQKNwEIBBILAgwIBEwbQBNEAQAJYAEECjcBCAQSCwIMCARMWUuwCVBYQEUABgAKAAYKgAAKBAAKBH4NAQwAAQwBZQAHBwVhCwEFBTlNCQEAAAVhCwEFBTlNAAQEAmEDAQICNE0ACAgCYQMBAgI0Ak4bS7AdUFhAQQAABwYHAAaAAAYKBwYKfgAKBAcKBH4NAQwAAQwBZQkBBwcFYQsBBQU5TQAEBAJhAwECAjRNAAgIAmEDAQICNAJOG0BLAAAJBgkABoAABgoJBgp+AAoECQoEfg0BDAABDAFlAAcHBWELAQUFOU0ACQkFYQsBBQU5TQAEBAJhAwECAjRNAAgIAmEDAQICNAJOWVlAGF5eXmVeZFlXUU9HRSkoJSQkJSMlEQ4JHysABiMGBwYHAiEiJicGIyImJyYnBiMiJjU0NjMzEz4CMzIWFhUUBiMiJjU0NzY1NCYjIgYHBwYHFhcWFjMyNzY2NzY3NyYjIgYVFBcWFRQGIyInJjU0NjYzMhYXFhUANjcGFRQWMwUTGRwCBwoBWf7mSVoKOE40WD85NTNmOENeTg0TBlaOWkFeMSwnHCAEBiwqRFkLGQUIQGA4PBdPNibDiAsGEjMVRmUUBisZIBEcXJFTIGUtOf6CYiX0IBwC4R4VNEYI/WlJPB8aGhkQXTMoMUEBN2SZVDRcOj1LGxkJGBwWKTJva/cwIwsYDgwmWYwyRziXBjo5HiMKCxUhGy49UmwyDQsOKv0BlLlrmyIl////1//7AyIEfAAiAFwAAAEHBcADKQF8AAmxAQG4AXywNSsA////1//7A30DUAAiAFwAAAEHBakEOwF8AAmxAQG4AXywNSsA////1/7sAyIDUAAiAFwAAAADBc8CswAA////1//7AyIDUAAiAFwAAAEHBaUDAv8jAAmxAQG4/yOwNSsAAAP/1/45BAwDUABYAGQAbADPQBA/AQcDVBkRAwEHZwEMAQNMS7AJUFhARAAFCwgLBQiAAAoOAQsFCgtpAAYGBGEABAQ5TQAICDZNDQkCAwMBYQIBAQE0TQAHBwFhAgEBATRNDwEMDABhAAAAOABOG0BLAAULCAsFCIANAQkIAwgJA4AACg4BCwUKC2kABgYEYQAEBDlNAAgINk0AAwMBYQIBAQE0TQAHBwFhAgEBATRNDwEMDABhAAAAOABOWUAgZWVZWQAAZWxla1lkWWNfXQBYAFcoKSgkJiQlKCkQCR8rJBYVFAYHBgcGBiMiJjU0Njc3BgYjIiYnJicGIyImNTQ2MzMTNjY3NjYzMhYVFAYjIiY1NDc2NTQmIyIGBwcGBxYXFhYzMjY3Njc2NzY2MzIWFRQHBzY3NjMCJjU0NjMyFhUUBiMCNjcGBhUUMwP9Dw4PRnUnfGAzQG6YBSRPMjRYPzk1M2Y4Q15ODRIGPDUudkJsdCwnHCAEBjEyWGANFwUIQGA4PBc0TCIDBAsHBCQlHhMhClBCDQreKjcpJS40K+Y+G0xDHN0ZExcaCi5R0O4/M0ehdiUbGBoaGRBdMygxQQEjZIIuKClwWj1LGxkJGBwWKjFze+MwIwsYDgwfIhkpZjIdGxIQLtBFPCwIATcnIyMvJCEoL/yGdoNBaSgnAAAAAAL/1//7AyID9QAYAFQBFkAKSgEKBiUBBAoCTEuwFVBYQEMMAQMBBwEDB4AACAkLCQgLgA0BCwYJCwZ+AAACAQEDAAFpAAkJB2EABwczTQAGBgRhBQEEBDRNAAoKBGEFAQQENAROG0uwG1BYQEkAAQIDAgEDgAwBAwcCAwd+AAgJCwkIC4ANAQsGCQsGfgAAAAIBAAJpAAkJB2EABwczTQAGBgRhBQEEBDRNAAoKBGEFAQQENAROG0BHAAECAwIBA4AMAQMHAgMHfgAICQsJCAuADQELBgkLBn4AAAACAQACaQAHAAkIBwlpAAYGBGEFAQQENE0ACgoEYQUBBAQ0BE5ZWUAgGRkAABlUGVNQTkZEPDo2NC4sKCYhHwAYABckFCcOCRkrACY1NDY3NjYzMhYVFAYjIicmJiMiBgcGIwAWFRQHBgYjIiYnJicGIyImNTQ2MzMTNjY3NjYzMhYVFAYjIiY1NDc2NTQmIyIHBwYHFhcWFjMyNjc2MwEFFx4uMYlKYFwdGAceBTgjSWc7KxAB+Q8TOGlKNFg/OTUzZjhDXk4NEgY9NC52Qmx0LCccIAQGMTKvFhcFCEBgODwXOlMlDA8DTRkRGCITFB0qHRYYBAEHGRUR/ZIYFScXQzYaGhkQXTMoMUEBI1Z9LSgpcFo9SxsZCRgcFiox2uMwIwsYDgwnKw4AAAAB////+wVRA1AAaQBLQEgoIAIGAQFMAAEABgABBoAABgUABgV+CggCAAACYQQDAgICOU0ABQUHYQwLCQMHBzQHTgAAAGkAaGNhWFYrJiMpJignIyoNCR8rFiY1NDY3Njc2NTQjIgYHBiMiJjU0Njc2NjMyFhUUBgYHNjYzMhYVFAc2NjMyFhUUBwMGFRQWMzI2NzYzMhYVFAcGBiMiJjU0Nzc+AjU0JiMiBgIHBgYjIiY1NDY3NjU0JiMiBgIHBgYjwyANDxoPCSEaSSwOEQ4VDQ8wdjs3OwoIAjmOVUFLCTKGV0ZLDT0KJyMhPysMDw0PEzRmOFVgGCgCCgYbGS9nXR0HIyciHxYRLh0dMWhjIQcbJwUhLh9hVZ1zSDAtNToTGxEQIRVDSUZDG0kuCaOBXFQhMYp4WlEsP/7iMiQqKiwzDhgVJxc/OmVVO3C3CS4pFCMjef7o4DwpICwphVryRiYkb/7l8TMoAAAAAf////sD9QNQAE8AQkA/HwEFAQFMAAEABQABBYAABQQABQR+BwEAAAJhAwECAjlNAAQEBmEJCAIGBjQGTgAAAE8ATiwmIykmJyMrCgkeKxYmNTQ2NzY2NzY1NCMiBgcGIyImNTQ2NzY2MzIWFRQHNjYzMhYVFAcDBhUUFjMyNjc2MzIWFRQHBgYjIiY1NDY3Nz4CNTQmIyIGAgcGBiPDIAwPAhwLCiEZSysOEQ4VDBAxeEI3NxAymmhSUw09CicjIT8rDA8NDxM0ZjhVYAsNKAIKBiQhPHhmHQcbJwUhLh9YWQyrXlAoLTU6ExsRER8WQ0lEQTpulJldTiw//uIyJCoqLDMOGBUnFz86ZVUhTjy3CS4pFCAmgP7j3jMoAAAAAv///5UF8ANQAHAAeAHqS7AJUFhAElkBAAdCAQsGcwEJCwsBDQkETBtLsA5QWEASWQEACkIBCwZzAQkLCwENCQRMG0uwElBYQBJZAQAFQgELBnMBCQsLAQ0JBEwbS7AhUFhAElkBAwdCAQsGcwEJCwsBDQkETBtAElkBAwpCAQsGcwEJCwsBDQkETFlZWVlLsAlQWEAyAAYACwAGC4AACwkACwl+DgENAAENAWUKBQMDAAAHYQwIAgcHOU0ACQkCYQQBAgI0Ak4bS7AOUFhAPQAGAAsABguAAAsJAAsJfg4BDQABDQFlAAoKB2EMCAIHBzlNBQMCAAAHYQwIAgcHOU0ACQkCYQQBAgI0Ak4bS7ASUFhAPQAGAAsABguAAAsJAAsJfg4BDQABDQFlCgEFBQdhDAgCBwc5TQMBAAAHYQwIAgcHOU0ACQkCYQQBAgI0Ak4bS7AhUFhAOAAAAwYDAAaAAAYLAwYLfgALCQMLCX4OAQ0AAQ0BZQoFAgMDB2EMCAIHBzlNAAkJAmEEAQICNAJOG0BDAAADBgMABoAABgsDBgt+AAsJAwsJfg4BDQABDQFlAAoKB2EMCAIHBzlNBQEDAwdhDAgCBwc5TQAJCQJhBAECAjQCTllZWVlAGnFxcXhxd21rZmRcWlFPJicjKyUsIyURDwkfKwAGIwYHBgcCISImJwYjIiY1NDY3Nz4CNTQmIyIGAgcGBiMiJjU0Njc2Njc2NTQjIgYHBiMiJjU0Njc2NjMyFhUUBzY2MzIWFRQHAwYVFBYzMjY3NjY3Njc3JiMiBhUUFxYVFAYjIicmNTQ2MzIXFhUANjcGFRQWMwXwGRwCBwoBWf7mS1oJNz9VYAsNKAIKBiQhPHhmHQcbJyUgDA8CHAsKIRlLKw4RDhUMEDF4Qjc3EDKaaFJTDT0KJyMaMx4pwYQLBhI8NFtuFAYrGSARHMaYemA5/oJiJfQgHALhHhU0Rgj9aU09JGVVIU48twkuKRQgJoD+494zKCEuH1hZDKteUCgtNToTGxERHxZDSURBOm6UmV1OLD/+4jIkKiocH1aJMEc4lwY5Oh4jCgsVIRsuPXp2GA4q/QGUuWubIiUAAAD///////sD9QR8ACIAZQAAAQcFwANZAXwACbEBAbgBfLA1KwD///////sD9QSJACIAZQAAAQcFwwNZAXwACbEBAbgBfLA1KwD//////uwD9QNQACIAZQAAAAMFzwMfAAAAAf///qUD9QNQAFwAX0BcSx8CCwdVAQoLCQEACgNMAAcECwQHC4AMAQsKBAsKfgACAAMAAgOAAAMAAQMBZQYBBAQIYQkBCAg5TQAKCgBhBQEAADQATgAAAFwAW1hWT00nIyolKyImIyYNCR8rJBYVFAcGBiMiJwYGIyImJyY1NDYzMhcWMzI2NjcTNgc2NjU0JiMiBgIHBgYjIiY1NDY3Njc2NTQjIgYHBiMiJjU0Njc2NjMyFhUUBzY2MzIWFRQGBwMWMzI2NzYzA+YPEy9cNj01NI5sPG4iDSMXHRQ0RSU3NyE/DgMRDiEgPHhmHQcbJyMiDwocDwohGUsrDhEOFQwQMXhCNzcQMppoUU8XEUI5MSA7KwwP3xgVJxc5QB66ujQxExMYJBxINp+bASc5CVBOHx8mgP7j3jMoKi8aZzygflAoLTU6ExsRER8WQ0lEQTpulJlbSzd/Rv7kHiozDgAAAAAD///+OQTfA1AAagB2AH4AdkBzSAEMBWYRAgEIeQENAQNMAAULDAsFDIAOAQoJCAkKCIAACw8BDAkLDGkEAQICBmEHAQYGOU0ACQk2TQAICAFhAwEBATRNEAENDQBhAAAAOABOd3drawAAd353fWt2a3VxbwBqAGlhXykmJyMrJSwnKREJHyskFhUUBgcGBwYGIyImNTQ2NzcGIyImNTQ2Nzc+AjU0JiMiBgIHBgYjIiY1NDY3NjY3NjU0IyIGBwYjIiY1NDY3NjYzMhYVFAc2NjMyFhUUBwMGFRQWMzI2NzY3Njc2NjMyFhUUBwc2NzYzAiY1NDYzMhYVFAYjAjY3BgYVFDME0A8OD0Z1J3xgM0BumAVCSlVgCw0oAgoGJCE8eGYdBxsnJSAMDwIcCwohGUsrDhEOFQwQMXhCNzcQMppoUlMNPQonIx45JAMECwcEJCUeEyEKUEINCt4qNyklLjQr5j4bTEMc3RkTFxoKLlHQ7j8zR6F2JTNlVSFOPLcJLikUICaA/uPeMyghLh9YWQyrXlAoLTU6ExsRER8WQ0lEQTpulJldTiw//uIyJCoqJCkXLGYyHRsSEC7QRTwsCAE3JyMjLyQhKC/8hnaDQWkoJ///////+wP1BFcAIgBlAAABBwXGA1kBfAAJsQEBuAF8sDUrAAACAED/+wMeA1AADwAdACxAKQACAgBhAAAAOU0FAQMDAWEEAQEBNAFOEBAAABAdEBwXFQAPAA4mBgkXKwQmJjU0NjYzMhYWFRQGBiM+AjU0JiMiBgYVFBYzASOPVG+/dFmPVG+/dFh3QGRPTXZCZE8FUJtsmOh+UJtsmOh+dmCrbHd7X6ttd3v//wBA//sDHgR3ACIAbQAAAQcFwAMUAXcACbECAbgBd7A1KwD//wBA//sDHgREACIAbQAAAQcFxAMUAXcACbECAbgBd7A1KwD//wBA//sDHgSaACIAbQAAAQcFwgMUAXcACbECAbgBd7A1KwD//wBA//sDIwTiACIAbQAAAQcF8QMUAXIACbECArgBcrA1KwD//wBA/xMDHgSaACIAbQAAACcFzQLl//sBBwXCAxQBdwASsQIBuP/7sDUrsQMBuAF3sDUr//8AQP/7Ax4E4gAiAG0AAAEHBfIDFAFyAAmxAgK4AXKwNSsA//8AQP/7AysE2AAiAG0AAAEHBfMDFAFyAAmxAgK4AXKwNSsA//8AQP/7Ax4E+QAiAG0AAAEHBfQDFAFyAAmxAgK4AXKwNSsA//8AQP/7Ax4EdwAiAG0AAAEHBckDFAF3AAmxAgK4AXewNSsA//8AQP/7Ax4ELAAiAG0AAAEHBb0DFAF3AAmxAgK4AXewNSsA//8AQP/7Ax4E1gAiAG0AAAAnBb0DFAF3AQcFxwMvAmAAErECArgBd7A1K7EEAbgCYLA1K///AED/+wMeBNUAIgBtAAAAJwW+AxQBdwEHBccDMAJfABKxAgG4AXewNSuxAwG4Al+wNSv//wBA/xMDHgNQACIAbQAAAQcFzQLl//sACbECAbj/+7A1KwD//wBA//sDHgR3ACIAbQAAAQcFvwMUAXcACbECAbgBd7A1KwD//wBA//sDHgSAACIAbQAAAQcFyAMTAXcACbECAbgBd7A1KwAAAgBA//sDXQPlAB4ALACiS7ASUFi1GAEEAAFMG7UYAQQBAUxZS7ASUFhAHQACAAKFAAQEAGEBAQAAOU0HAQUFA2EGAQMDNANOG0uwJlBYQCEAAgAChQABATNNAAQEAGEAAAA5TQcBBQUDYQYBAwM0A04bQCQAAgAChQABAAQAAQSAAAQEAGEAAAA5TQcBBQUDYQYBAwM0A05ZWUAUHx8AAB8sHysmJAAeAB0jIiYICRkrBCYmNTQ2NjMyFxYzMjY3NjMyFhUUBwYGBxYVFAYGIz4CNTQmIyIGBhUUFjMBI49Ub790NkMeBzIvCwguGyABCEQ3RW+/dFh3QGRPTXZCZE8FUJtsmOh+CgQ7Oi4gHwoFQmMUXoeY6H52YKtsd3tfq213ewAAAP//AED/+wNdBHwAIgB9AAABBwXAAxUBfAAJsQIBuAF8sDUrAP//AED/GANdA+UAIgB9AAAAAwXNAuYAAP//AED/+wNdBHwAIgB9AAABBwW/AxUBfAAJsQIBuAF8sDUrAP//AED/+wNdBIUAIgB9AAABBwXIAxQBfAAJsQIBuAF8sDUrAP//AED/+wNdBFcAIgB9AAABBwXGAxUBfAAJsQIBuAF8sDUrAP//AED/+wMeBHcAIgBtAAABBwXBAxQBdwAJsQICuAF3sDUrAP//AED/+wMeBEQAIgBtAAABBwXKAxQBdwAJsQIBuAF3sDUrAP//AED/+wMeA+0AIgBtAAABBwXHAxMBdwAJsQIBuAF3sDUrAAACAED/AgMeA1AAJwA1AGhLsBJQWLUXAQAEAUwbtRcBAQQBTFlLsBJQWEAbAAQFAAUEAIABAQAAAgACZgAFBQNhAAMDOQVOG0AhAAQFAQUEAYAAAQAFAQB+AAAAAgACZgAFBQNhAAMDOQVOWUAJJSkrJyIkBgkcKwQGFRQWMzI3NjMyFhUUBgcGBiMiJjU0Ny4CNTQ2NjMyFhYVFAYGByQWMzI2NjU0JiMiBgYVAcIgJBoaFREKDgwWGQwnEEZUKVKDTG+/dFmPVFCOW/7uZE9Od0BkT012Qg85HR0eBwYTExUdCQQGST8+NAZTlmeY6H5Qm2yAz4ca43tgq2x3e1+rbQAAAAMAQP+QAx4DtQAjACwANQBIQEUgAQIDIwEEAjMmAgUEEQEABQ4BAQAFTAABAAGGAAMDNU0ABAQCYQACAjlNBgEFBQBhAAAANABOLS0tNS01GiQbJBUHCRsrABYVFAYGIyMHBgYjIiY1NDc3JiY1NDY2MzM3NjYzMhYVFAcHABYXExMOAhUENjY1NCYnBwMCr29vv3QHFQQbEhYiAhNdb2+/dAcTBBsSFiMCEf6AMCpWR0lwPgELcD0wKkZYAx2nfZjofk8ODhcTBQhGIKh9mOh+SQ4OFxQFCD/91G4bAT4BEwRjp2nuY6dpUW4b//6u//8AQP+QAx4EfAAiAIcAAAEHBcACuQF8AAmxAwG4AXywNSsA//8AQP/7Ax4EUgAiAG0AAAEHBcYDFAF3AAmxAgG4AXewNSsA//8AQP/7Ax4E/AAiAG0AAAAnBcYDFAF3AQcFxwM1AoYAErECAbgBd7A1K7EDAbgChrA1KwACAED/+wTiA1EAQQBPAQhAChsBBgUNAQgAAkxLsBJQWEAsAAAHCAcACIAJAQUFA2EEAQMDOU0ABwcGXwAGBjZNCwoCCAgBYQIBAQE0AU4bS7AbUFhANgAABwgHAAiAAAkJA2EEAQMDOU0ABQUDYQQBAwM5TQAHBwZfAAYGNk0LCgIICAFhAgEBATQBThtLsC5QWEA0AAAHCAcACIAABgAHAAYHZwAJCQNhBAEDAzlNAAUFA2EEAQMDOU0LCgIICAFhAgEBATQBThtAMgAABwgHAAiAAAYABwAGB2cACQkDYQADAzlNAAUFBF8ABAQzTQsKAggIAWECAQEBNAFOWVlZQBRCQkJPQk5JRyNEUzRVJiQnIAwJHyskMzIWFRQGBwYGIyImJwYGIyImJjU0NjYzMhYXNzY2Nzc2MzIWFRQGIyIGBwYHNjM2MzIWFRQGBwcGBwYVFDMyNjcENjY1NCYjIgYGFRQWMwS5Cw4QExcslERwih02lVZZj1Rvv3RTgycFD0UzNH5IJBwkJEONIBgiLhRrSh4XIx9xNF0LuzVuQv0kd0BkT0x3QmRPuxcSFyURICpQRUdOUJtsmOh+SEUUNzgCAwYZHR8sBgRImwIFGRgfKQEDAgIxJp8hIkVgq2x3e2GqbHd7AAIALv+TAzcDTgASADkAOUA2OQEABSIBBAACTAAFBgAGBQCAAAYAAAQGAGkABAABBAFmAAMDAmEAAgIzA04nKSYnJiISBwkdKwAGBgcHBiMiJiY1NBI2MzIWFhUGNTQmIyIGBhUUFhYzMjc3JhcmJjU0NjMyFxYXNjc2NjMyFhUUBwcDN1iodCsZbz1nPoPdhV6DQ5VXW2eZUxknEhkNIScFHhIZFgoFGA0NGAYrHSEdAiEB/45aCPGLSJRsywEbjUJxR8S7QlOC55Q+YDVFvQYBBRsVFhoBBAFOgyIdGRsQCsIAAAMAKv+TAw0DqgAeACYAPQBCQD83AQUEKiYCAAUCTAAFBAAEBQCAAAAGBAAGfgADAAQFAwRqBwEGAAEGAWYAAgI1Ak4nJyc9JzwtGBUqJBIICRwrAAYGBwYHBgYjIiYmNTQ2Njc3NjYzMhYVFAcHHgIVBjY1NCYnBgcCNzY3IicmJjU0NjMyFxc2NwYGFRQWMwMNVqh4DhMOQDg3WzRJil4YAy4cIh0BE16CQvReS1EYGsENEAcGCB4QFxYKBREaE1daHhgBq4ZUBE9gR0ROjVyF1IwcqhsaFxgLBo0CPGVAvGVEPUkEp5b+3EVWKgIFGRUYGgEDnYIoyZdFegAAAAACAED+ugNxA1AAKQA3AEBAPR4BAwUBTAcBBQQDBAUDgAYBAwIEAwJ+AAIAAAIAZQAEBAFhAAEBOQROKioAACo3KjYxLwApACgsLSYICRkrBBYVFAcGBiMiJiYnLgInJiY1NDY2MzIWFhUUBgYHFhYXFhYzMjY3NjMkNjY1NCYjIgYGFRQWMwNmCxEibzo7UDgaGyMmHm+Hb790WY9UTIZXGSUVFzUnIT4nDA/+eHdAZE9Md0JkT2AVESAfPkMlSTw+PRwGFrCLmOh+UJtsfsqGHA42MzgwLTMQ0WCrbHd7Yapsd3sAAAAAAgA3//sD8QNOADAAUwBXQFQlAQUGDgEEBQJMAAcJBgkHBoALAQQFAwUEA4AIAQYABQQGBWkACQkCYQACAjNNCgEDAwBhAQEAADQATgAAUU9JR0JBPTs4NjIxADAALywmLCYMCRorJBYVFAcGBiMiJicuAicGBwYHBgYjIiYmNTQ2NjMyFhYVFAYGBxYWFxYWMzI2NzYzJSImNTQ2MzM2NzYzMhUUBwc+AjU0JiMiBgYVFBYWMzI2NwPiDxMwYkNBWykhJiUbBBMIAgo8PUNnOHXTimCCPzVqTDA0Ghw3JCA6LAwP/V4iGR8UGRAODUc5AR42WTVWU2KTUhomEQ0RBd8YFScXOj9GVURBHAMVbzILPUFPjVqo9IE6ZkA4a1IUDTo4PDgrNA5cIBQYHGJHQTMLBqYDLlI0P0hhv4lAXC4aHQD//wA3//sD8QR8ACIAjwAAAQcFwAMyAXwACbECAbgBfLA1KwD//wA3//sD8QSJACIAjwAAAQcFwwMyAXwACbECAbgBfLA1KwD//wA3/uwD8QNOACIAjwAAAAMFzwNgAAD//wA3//sD8QR8ACIAjwAAAQcFyQMyAXwACbECArgBfLA1KwD//wA3//sD8QRJACIAjwAAAQcFygMyAXwACbECAbgBfLA1KwAAAQAi//gCtQNRAD4AZkuwDFBYQCUAAwQABAMAgAAAAQQAAX4ABAQCYQACAjNNAAEBBWEGAQUFNAVOG0AlAAMEAAQDAIAAAAEEAAF+AAQEAmEAAgI5TQABAQVhBgEFBTQFTllADgAAAD4APSglLSkkBwkbKxYmNTQ2MzIWFRQHFAYVFBYzMjY1NCYmJy4CNTQ2NjMyFhYVFAYjIiY1NDc2NTQmIyIGFRQWFhceAhUUBiPCoCYlGyIDA1tSVWAsQjxNYUVNkWJJekkmJRojAwNSPVZbL0Y/TFxBs5YIZWg3OhwWFA8EFAstLD03IjEhGB42XUVIcD4rWEA/QCAWExAeCCosPzkmNiQZHzJWP3Z/AP//ACL/+AK2BHwAIgCVAAABBwXAAtsBfAAJsQEBuAF8sDUrAP//ACL/+AK1BIkAIgCVAAABBwXDAtsBfAAJsQEBuAF8sDUrAAABACL/AgK1A1EAWwC/tjEXAgQGAUxLsAxQWEArCQEIAAUACAWAAAUGAAUGfgAGAAQCBgRpAwECAAECAWUAAAAHYQAHBzMAThtLsC5QWEArCQEIAAUACAWAAAUGAAUGfgAGAAQCBgRpAwECAAECAWUAAAAHYQAHBzkAThtAMgkBCAAFAAgFgAAFBgAFBn4AAgQDBAIDgAAGAAQCBgRpAAMAAQMBZQAAAAdhAAcHOQBOWVlAGAAAAFsAWlVTRkQ7OS8tKSckIx0bKAoJFysAJjU0NzY1NCYjIgYVFBYWFx4CFRQGBxYVFAYjIicmJjU0NjMyFxYzMjY1NCYjIiY1NDc3JiY1NDYzMhYVFAcUBhUUFjMyNjU0JiYnLgI1NDY2MzIWFhUUBiMCUCMDA1I9VlsvRj9MXEGEcyBnWCYYFBMUFAgFGxooLSslGhwBAVJcJiUbIgMDW1JVYCxCPE1hRU2RYkl6SSYlAg8gFhMQHggqLD85JjYkGR8yVj9kexEeNUtdBQQWFRgWAQQhIhkdDhEGAwQTYE43OhwWFA8EFAstLD03IjEhGB42XUVIcD4rWEA/QAD//wAi//gCtQSfACIAlQAAAQcFwgLbAXwACbEBAbgBfLA1KwD//wAi/uwCtQNRACIAlQAAAAMFzwKzAAAAAQBS/9IDLANUAEEAgrZBNwIBAgFMS7AJUFhAHgABAgMCAQOAAAADAIYAAgIEYQUBBAQ5TQADAzQDThtLsAxQWEAeAAECAwIBA4AAAAMAhgACAgRhBQEEBDNNAAMDNANOG0AeAAECAwIBA4AAAAMAhgACAgRhBQEEBDlNAAMDNANOWVlACSkmJSkrJwYJHCsAFhUUBgYHBiMiJjU0Njc+AjU0JicmJjU0Njc2NjU0IyIGAgcGBiMiJjc2Ejc2MzIWFRQHBwYHNjYzMhYWFRQGBwKvalaWXBIHIiMVEkxqNGdfEBAUEmhpV02MaRkHIiMjIgMMPh4PRh0aAxIXEzqzdDdYMnhfAbdrUEp/UwwCGxIPGQQOPlEsST4DARkTFiUEGFA6TZz+3cQ0Jx8vugGmcToWFgsPTlleqJ8pSi9Tex8AAAAAAgA7//sDBQNQACIAKQA/QDwAAwIBAgMBgAABAAUGAQVnAAICBGEHAQQEOU0IAQYGAGEAAAA0AE4jIwAAIykjKCYlACIAISMkJSYJCRorABYWFRQGBiMiJiY1NDYzITY1NCYjIgYHBiMiJjU0Njc2NjMSNjchFhYzAh2TVWq4cVqNUC0oAeEBb1g6dzcRDA4RDw41klQRdhr+bgFhTgNQUJ9yk+R9TpdoODoPH3d3MjMPHxcWKg41Nf0fd2Z2ZwAAAQAj//sDhwNPADUAKkAnDQEBAwFMAAMAAQADAYACAQAABGEABAQzTQABATQBTjcpHScmBQkbKwAWFRQGJyYmJwYHBgYHBgYjIiY1NDY3Njc2Njc2NjcOAhUUFxYVFAYjIicmJjU0NjYzMhYXA2gfJShaZVIlHwsYBAIsHyEkDwoLBgscDgMIBWJwLxQELRgRCxQab+OyboMxAzgeFCEeAwcFAbi6RLM3HR8gGhhvPT0tTJZDDycYAxovJSIfBwgTIQoRPyhVZzAICQAAAQAj//sDhwNPAEcAqbYhFgIDAgFMS7AuUFhAJQAHAAEABwGABgEAAAhhAAgIM00EAQICAV8FAQEBNk0AAwM0A04bS7AwUFhALwAHAAEABwGABgEAAAhhAAgIM00EAQICAV8AAQE2TQQBAgIFXwAFBTZNAAMDNANOG0AqAAcAAQAHAYAABQICBVcGAQAACGEACAgzTQQBAgIBXwABATZNAAMDNANOWVlADDcpFCNJJiQiJgkJHysAFhUUBicmJicGBzcyFhUUBiMjFQYGBwYGIyImNTQ2NzY3NSIHBiMiNTQ2MzM2NzY3DgIVFBcWFRQGIyInJiY1NDY2MzIWFwNoHyUoWmVSGxdkIB0kMV4LGAQCLB8hJA8KCwYRICoRNCYuXRYRCAVicC8UBC0YEQsUGm/jsm6DMQM4HhQhHgMHBQGGgwEYFB0fAkSzNx0fIBoYbz09LQMCAigfIHlRLBcDGi8lIh8HCBMhChE/KFVnMAgJAAD//wAj//sDhwSJACIAnQAAAQcFwwMpAXwACbEBAbgBfLA1KwAAAQAj/wIDhwNPAFIAd0AMMA0CBQcpDwIEBQJMS7AuUFhAJAAHAAUABwWAAAUABAIFBGkDAQIAAQIBZQYBAAAIYQAICDMAThtAKwAHAAUABwWAAAIEAwQCA4AABQAEAgUEaQADAAEDAWUGAQAACGEACAgzAE5ZQAw3KR0WJCMWKyYJCR8rABYVFAYnJiYnBgcGBgcGBxYVFAYjIicmJjU0NjMyFxYzMjY1NCYjIiY1NDc2NjMmNTQ2NzY3NjY3NjY3DgIVFBcWFRQGIyInJiY1NDY2MzIWFwNoHyUoWmVSJR8LGAQBEjdnWCYYFBMUFAgFGxooLSslGhwBBBgZAQ8KCwYLHA4DCAVicC8UBC0YEQsUGm/jsm6DMQM4HhQhHgMHBQG4ukSzNxgQIURLXQUEFhUYFgEEISIZHQ4RBgMUEwQKGG89PS1MlkMPJxgDGi8lIh8HCBMhChE/KFVnMAgJ//8AI/7sA4cDTwAiAJ0AAAADBc8C3AAAAAH////7A/sDUABOAIG1SwEGAQFMS7AdUFhAKAABAAYAAQaAAAYDAAYDfgAAAAJhBAECAjlNBQEDAwdiCQgCBwc0B04bQDMAAQAGAAEGgAAGAwAGA34AAAACYQQBAgI5TQADAwdhCQgCBwc0TQAFBQdiCQgCBwc0B05ZQBEAAABOAE0mIyslLCUjKgoJHisWJjU0NxM2NjU0JiMiBgcGIyImNTQ3NjMyFhUUBgcHDgIVFBYzMjYSNzY2MzIWFRQGBwYHBhUUFjMyNjc2MzIWFRQHBgYjIiY1NDcGBiP4Vg0+Ag8TEB5QLA4RDhUcZok9RQ4RKQIKBiQhPHtpHQcbJyMiDQ0bEAglHyE/KwwPDQ8TNGY4U1gQMplkBV1OLD8BHghIKhgYOTsTGxEfJ4xKSDNWSrcJLikUICaAAR3eMygqLxtYT5mAOhwpKywzDhgVJxc/OlVEJm6TmgAA///////7A/sEfAAiAKIAAAEHBcADRwF8AAmxAQG4AXywNSsA///////7A/sESQAiAKIAAAEHBcQDRwF8AAmxAQG4AXywNSsA///////7A/sEnwAiAKIAAAEHBcIDRwF8AAmxAQG4AXywNSsA///////7A/sEfAAiAKIAAAEHBckDRwF8AAmxAQK4AXywNSsA///////7A/sEMQAiAKIAAAEHBb0DRwF8AAmxAQK4AXywNSsA//////8YA/sDUAAiAKIAAAADBc0DHwAA///////7A/sEfAAiAKIAAAEHBb8DRwF8AAmxAQG4AXywNSsA///////7A/sEhQAiAKIAAAEHBcgDRgF8AAmxAQG4AXywNSsAAAH////7A/sD5QBZAI+1VgEHAQFMS7AdUFhALQAFAgWFAAEABwABB4AABwMABwN+AAAAAmEEAQICOU0GAQMDCGIKCQIICDQIThtAOAAFAgWFAAEABwABB4AABwMABwN+AAAAAmEEAQICOU0AAwMIYQoJAggINE0ABgYIYgoJAggINAhOWUAVAAAAWQBYUlBKSEVDIyUsJSMqCwkcKxYmNTQ3EzY2NTQmIyIGBwYjIiY1NDc2MzIWFRQGBwcOAhUUFjMyNhI3NjYzMjY3NjMyFhUUBwYGBwYGBwYGBwYVFBYzMjY3NjMyFhUUBwYGIyImNTQ3BgYj+FYNPgIPExAeUCwOEQ4VHGaJPUUOESkCCgYkITx7aR0HGyc1MwoILhsgAQhSRAIOCQMdCwglHyE/KwwPDQ8TNGY4U1gQMplkBV1OLD8BHghIKhgYOTsTGxEfJ4xKSDNWSrcJLikUICaAAR3eMygxNi4gHwoFSGIQGloyFK1aOhwpKywzDhgVJxc/OlVEJm6TmgD///////sD+wR8ACIAqwAAAQcFwANHAXwACbEBAbgBfLA1KwD//////xgD+wPlACIAqwAAAAMFzQMfAAD///////sD+wR8ACIAqwAAAQcFvwNHAXwACbEBAbgBfLA1KwD///////sD+wSFACIAqwAAAQcFyANGAXwACbEBAbgBfLA1KwD///////sD+wRXACIAqwAAAQcFxgNHAXwACbEBAbgBfLA1KwD///////sD+wR8ACIAogAAAQcFwQNHAXwACbEBArgBfLA1KwD///////sD+wRJACIAogAAAQcFygNHAXwACbEBAbgBfLA1KwD///////sD+wPyACIAogAAAQcFxwNGAXwACbEBAbgBfLA1KwAAAf///wID+wNQAGUA7EuwHVBYQAojAQoFHgEDBwJMG0AKIwEKBR4BAwkCTFlLsBJQWEAvAAUECgQFCoALAQoHBAoHfgEBAAACAAJmAAQEBmEIAQYGOU0JAQcHA2EAAwM0A04bS7AdUFhANgAFBAoEBQqACwEKBwQKB34AAQMAAwEAgAAAAAIAAmYABAQGYQgBBgY5TQkBBwcDYQADAzQDThtAPQAFBAoEBQqACwEKBwQKB34ACQcDBwkDgAABAwADAQCAAAAAAgACZgAEBAZhCAEGBjlNAAcHA2EAAwM0A05ZWUAUAAAAZQBkYV8lLCUjKisnIisMCR8rJBYVFAcGBwYGFRQWMzI3NjMyFhUUBgcGBiMiJjU0NyYmNTQ3BgYjIiY1NDcTNjY1NCYjIgYHBiMiJjU0NzYzMhYVFAYHBw4CFRQWMzI2Ejc2NjMyFhUUBgcGBwYVFBYzMjY3NjMD7A8TREEjICQaGhURCg4MFhkMJxBGVC07PRAymWRUVg0+Ag8TEB5QLA4RDhUcZok9RQ4RKQIKBiQhPHtpHQcbJyMiDQ0bEAglHyE/KwwP3xgVJxdRGRg6HR0eBwYTExUdCQQGST9BNQxQOCZuk5pdTiw/AR4ISCoYGDk7ExsRHyeMSkgzVkq3CS4pFCAmgAEd3jMoKi8bWE+ZgDocKSssMw4AAAD///////sD+wSoACIAogAAAQcFxQNHAXwACbEBArgBfLA1KwD///////sD+wRXACIAogAAAQcFxgNHAXwACbEBAbgBfLA1KwAAAgB7//sDjANgACwANgCbQA8UAQYCLioCBQYeAQAFA0xLsBBQWEAfBwEFAAADBQBpAAYGAmEEAQICOU0AAwMBYgABATQBThtLsB9QWEAjBwEFAAADBQBpAAICOU0ABgYEYQAEBDlNAAMDAWIAAQE0AU4bQCEABAAGBQQGaQcBBQAAAwUAaQACAjlNAAMDAWIAAQE0AU5ZWUAQAAA0MgAsACsoJyYjJAgJGysAFhUUBgcGJwYGIyImNTQ3NjYzMhUUBwYVFBYzMjY3JiY1NDY2MzIWFRQHFjMkFzY1NCYjIgYVA3cVHyFQPkfJZWhmGQkhKEICHjMzNHozPT4xVTRASzI1RP7ZPycWExsiAbAUEBooAQIOlcXyzrCMNCU5BhC0kpmfkG0meU9PbTZcUHOICWMvcEkqJz86AAAAAAIAef/7BVIDYABFAE8AqEAQGwEJA0dDAggJNw0CAAgDTEuwEFBYQCIKAQgAAAQIAGkACQkDYQcFAgMDOU0GAQQEAWICAQEBNAFOG0uwH1BYQCYKAQgAAAQIAGkFAQMDOU0ACQkHYQAHBzlNBgEEBAFiAgEBATQBThtAJAAHAAkIBwlpCgEIAAAECABpBQEDAzlNBgEEBAFiAgEBATQBTllZQBMAAE1LAEUARCgpJSgmJCMkCwkeKwAWFRQGBwYnBgYjIiYnBgYjIiY1NDc2NjMyFhUUBwYVFBYzMjYSNzY2MzIWFRQHBhUUFhYzMjY3JiY1NDY2MzIWFRQHFjMkFzY1NCYjIgYVBT0VHyFPP0bFYFhYBjyXVWBiGgclKB4hAh4uJyNjYiIIKyUfHQIcDyspMHYxPT4xVTRASzEzRf7ZPycWExsiAbAUEBooAQENlcW7na6q78qTsDInGiMHFM2QhpKTASHILiMbGxAJo6NvhEWRbCZ5T09tNlxQcYoJYy9wSSonPzr//wB5//sFUgR8ACIAuAAAAQcFwAPtAXwACbECAbgBfLA1KwD//wB5//sFUgSfACIAuAAAAQcFwgPtAXwACbECAbgBfLA1KwD//wB5//sFUgQxACIAuAAAAQcFvQPtAXwACbECArgBfLA1KwD//wB5//sFUgR8ACIAuAAAAQcFvwPtAXwACbECAbgBfLA1KwAAAf/x//sDSQNQAD0AQ0BAMykVCwQHAwFMAAMCBwIDB4AIAQcGAgcGfgACAgRhBQEEBDlNAAYGAGEBAQAANABOAAAAPQA8KSYmIigmJgkJHSskFhUUBwYGIyImJycDBgYjIiY1NDcBJyYmIyIHBiMiJjU0NzY2MzIWFxc3NjYzMhYVFAcBFx4CMzI2NzYzAzoPEzFgO1lbHCLsFCocHCUdAUQgFzgkNUcMDw8VHSlgQkdcGxSvFCoeGx8b/vw5DxgjHR9DLAwP3xgVJxc6P2pmfP7cGQ8VExkgAXF1UkJNDRcSHiMwOlljRtUYFBQSGB/+1Mw1OBssMw4AAAAAAv///rkDwANQAE0AVQCIS7AuUFhAChUBAARLAQIAAkwbQAoVAQYESwECAAJMWUuwLlBYQCQABAMAAwQAgAYBAAACCAACaQAIAAEIAWUAAwMFYQcBBQU5A04bQCsABAMGAwQGgAAABgIGAAKAAAYAAggGAmkACAABCAFlAAMDBWEHAQUFOQNOWUAMLyUqJSMpKikRCQkfKyQzMhUUBgcGBwcGBiMiJjU0Njc3NjcGBiMiJjU0Njc2NjU0IyIGBwYjIiY1NDc2MzIWFRQGBwYGFRQWMzI2Njc2NjMyFRQHBgcGBgc2NwUGFRQWMzITA5IMIhUWW1gDHKd9U1u8vxQEBi+SWlZaEBEPDyUdTywOEQ4VHGaJPUUTEwwMJC02cVsUBSQiRgEVEgoXC0lR/tHyIyCLI+IsGCEEERUYxb1RP2mkP40YKHx6aVMlWUxFUiAwOTsTGxEfJ4xKSDRtVDI9FDMsd/KvLCVGDAeVeEiYThQQtFR4HCUBBgAAAP/////+uQPABHwAIgC+AAABBwXAA1QBfAAJsQIBuAF8sDUrAP/////+uQPABJ8AIgC+AAABBwXCA1QBfAAJsQIBuAF8sDUrAP/////+uQPABDEAIgC+AAABBwW9A1QBfAAJsQICuAF8sDUrAP/////+uQPAA1AAIgC+AAABBwXNBHH/oQAJsQIBuP+hsDUrAP/////+uQPABHwAIgC+AAABBwW/A1QBfAAJsQIBuAF8sDUrAP/////+uQPABIUAIgC+AAABBwXIA1MBfAAJsQIBuAF8sDUrAP/////+uQPAA/IAIgC+AAABBwXHA1MBfAAJsQIBuAF8sDUrAP/////+uQPABFcAIgC+AAABBwXGA1QBfAAJsQIBuAF8sDUrAAABAA//+wNSA04ARwBaQFcaAQYDPQEHAgwBAAcDTAAGAwQDBgSAAAQIAwQIfgkBCAIDCAJ+AAMDBWEABQUzTQACAgBhAQEAADRNAAcHAGEBAQAANABOAAAARwBGKRcmKSQlJiYKCR4rJBYVFAcGBiMiJicmJwYGIyImNTQ2NjMyFzYTJiMiBhUUFhcWFRQGIyInJiY1NDYzMhYXFhYVFAYjIwYHBgcWFxYWMzI2NzYzA0MPEzhpSjRYPzYqLkopN0IpSjEcDsSeVllzawgICSUYGRATF8KfT6VIHhQcGQdsb1kkOis1QRg6UyUMD98YFScXQzYaGhcOMiczKR80HgH0AQ8PNTkRGBASCBQbDxE7JXVwEhQIHRcbHrCigS4NCw4NJysOAAAA//8AD//7A1IEfAAiAMcAAAEHBcAC9AF8AAmxAQG4AXywNSsA//8AD//7A1IEiQAiAMcAAAEHBcMC9AF8AAmxAQG4AXywNSsA//8AD//7A1IEMAAiAMcAAAEHBb4C9AF8AAmxAQG4AXywNSsA//8AXP/5A7oEfAAiAWAAAAAnBcACMQF8AQcFwAPfAXwAErEBAbgBfLA1K7ECAbgBfLA1KwABADj/+wM9A1AANgBpQAsqGwICAyABBAICTEuwEFBYQB8AAwACAAMCgAEBAAAGYQAGBjlNAAICBGEFAQQENAROG0AlAAABAwEAA4AAAwIBAwJ+AAEBBmEABgY5TQACAgRhBQEEBDQETllACiYmKiYlIxQHCR0rABYVFAYjIicmIyIGBhUUFjMyNjY3NzY2MzIWFRQHBgIHBwYGIyImNTQ3NwYjIiYmNTQSJDMyFwMtECYgBg5CQIS3WkI6NE4+Hi8GLR4aIwMcNQUFAisgIiEFBEeKPnBHgQEAtGFPAzMYDxgnAg18yXVbVkONdLoZGBUXCAlW/rtqMRcbHRoVHiKLO4BhmAEEnBgAAAD//wA4//sDXQR8ACIAzAAAAQcFwAOCAXwACbEBAbgBfLA1KwD//wA4//sDPQRJACIAzAAAAQcFxAOCAXwACbEBAbgBfLA1KwD//wA4//sDPQTZACIAzAAAAQcF7QOCAXwACbEBArgBfLA1KwD//wA4/xgDPQRJACIAzAAAACMFzQLpAAABBwXEA4IBfAAJsQIBuAF8sDUrAP//ADj/+wM9BNkAIgDMAAABBwXuA4IBfAAJsQECuAF8sDUrAP//ADj/+wM9BQQAIgDMAAABBwXvA4IBfAAJsQECuAF8sDUrAP//ADj/+wNCBQoAIgDMAAABBwXwA4IBfAAJsQECuAF8sDUrAP//ADj/+wM9BJ8AIgDMAAABBwXCA4IBfAAJsQEBuAF8sDUrAP//ADj/+wORBOcAIgDMAAABBwXxA4IBdwAJsQECuAF3sDUrAP//ADj/GAM9BJ8AIgDMAAAAIwXNAukAAAEHBcIDggF8AAmxAgG4AXywNSsA//8AOP/7Az0E5wAiAMwAAAEHBfIDggF3AAmxAQK4AXewNSsA//8AOP/7A5kE3QAiAMwAAAEHBfMDggF3AAmxAQK4AXewNSsA//8AOP/7Az0E/gAiAMwAAAEHBfQDggF3AAmxAQK4AXewNSsA//8AOP/7Az0EfAAiAMwAAAEHBckDggF8AAmxAQK4AXywNSsA//8AOP/7Az0EMQAiAMwAAAEHBb0DggF8AAmxAQK4AXywNSsA//8AOP8YAz0DUAAiAMwAAAADBc0C6QAA//8AOP/7Az0EfAAiAMwAAAEHBb8DggF8AAmxAQG4AXywNSsA//8AOP/7Az0EhQAiAMwAAAEHBcgDgQF8AAmxAQG4AXywNSsA//8AOP/7Az0ESQAiAMwAAAEHBcoDggF8AAmxAQG4AXywNSsA//8AOP/7Az0D8gAiAMwAAAEHBccDgQF8AAmxAQG4AXywNSsAAAEAOP8CAz0DUABMALVAC0AbAgIDIAEHAgJMS7AQUFhAJgADAAIAAwKABQEEAAYEBmUBAQAACGEACAg5TQACAgdhAAcHNAdOG0uwElBYQCwAAAEDAQADgAADAgEDAn4FAQQABgQGZQABAQhhAAgIOU0AAgIHYQAHBzQHThtAMwAAAQMBAAOAAAMCAQMCfgAFBwQHBQSAAAQABgQGZQABAQhhAAgIOU0AAgIHYQAHBzQHTllZQAwmKiciLyYlIxQJCR8rABYVFAYjIicmIyIGBhUUFjMyNjY3NzY2MzIWFRQHBgIHBwYGBwYVFBYzMjc2MzIWFRQGBwYGIyImNTQ3JjU0NzcGIyImJjU0EiQzMhcDLRAmIAYOQkCEt1pCOjROPh4vBi0eGiMDHDUFBQIhGTIkGhoVEQoODBYZDCcQRlRLAgUDR4o+cEeBAQC0YU8DMxgPGCcCDXzJdVtWQ410uhkYFRcICVb+u2oxFBoDKzYdHgcGExMVHQkEBkk/VT8OBxchHIs7gGGYAQScGAAAAP//ADj/+wM9BKgAIgDMAAABBwXFA4IBfAAJsQECuAF8sDUrAAAEADj/+wPOBREAEAAeACoAYQDHQAtVRgIICUsBCggCTEuwEFBYQD8NAQECAYUAAAIFAgAFgAAJBggGCQiAAAIPAQUEAgVpAAQOAQMMBANpBwEGBgxhAAwMOU0ACAgKYQsBCgo0Ck4bQEUNAQECAYUAAAIFAgAFgAAGBwkHBgmAAAkIBwkIfgACDwEFBAIFaQAEDgEDDAQDaQAHBwxhAAwMOU0ACAgKYQsBCgo0Ck5ZQCgfHxERAABgXlhWUE5EQjw6NTMwLx8qHyklIxEeER0YFgAQAA8nEAkXKwAWFRQGBwcGIyImNTQ3NzYzACY1NDY2MzIWFRQGBiMmBhUUFjMyNjU0JiMSFhUUBiMiJyYjIgYGFRQWMzI2Njc3NjYzMhYVFAcGAgcHBgYjIiY1NDc3BiMiJiY1NBIkMzIXA60hFhd1CAoOEhBoEBX+l0wnQSU1TCdBJQwcGhIUHBoSwhAmIAYOQkCEt1pCOjROPh4vBi0eGiMDHDUFBQIrICIhBQRHij5wR4EBALRhTwURIBYRIQo0BBINDw9eD/5/Rz0tQyRHPS1DJMAeGRYbHhkWG/7jGA8YJwINfMl1W1ZDjXS6GRgVFwgJVv67ajEXGx0aFR4iizuAYZgBBJwY//8AOP/7A0MEVwAiAMwAAAEHBcYDggF8AAmxAQG4AXywNSsAAAEAOP/7BDgDUQBLAIS1IwEEAgFMS7AbUFhAKwAEAgMCBAOACgEAAAdhCQEHBzNNAAICAV8AAQE2TQgBAwMFYQYBBQU0BU4bQCkABAIDAgQDgAABAAIEAQJnCgEAAAdhCQEHBzNNCAEDAwVhBgEFBTQFTllAGwEARkE8OjAuJiQhHxoYFhQRDQkEAEsBSgsJFisABgcGBzYzNjMyFhUUBgcHBgcGFRQzMjc2MzIVFAYHBiMiJicGIyImJjU0NjY3NjMyFRQGBw4CFRQWMzI2NxM2Njc3NjMyFhUUBiMDrY0gGCIuFGtKHhcjH3E0XQu7M00RCicYIE1Ue5AWT59LdEF10IIIDUETE3KhUUM2U2UqUQ9FMzR+SCQcJCQC0AYESJsCBRkYHykBAwICMSafGAUvHCMMG2FRskSBWJL1mxABPxUbAg16v3JVXaWaASg3OAIDBhkdHyz//wA4//sEOAR8ACIA5QAAAQcFwAPxAXwACbEBAbgBfLA1KwAAAQBUAAMDKgNeAEIAukAOAgEDBBsBAgMOAQACA0xLsA1QWEAuAAYFAQUGAYAAAQQFAQR+AAUFB2EABwczTQADAwRhAAQENk0AAgIAYgAAADQAThtLsCRQWEAuAAYFAQUGAYAAAQQFAQR+AAUFB2EABwc5TQADAwRhAAQENk0AAgIAYgAAADQAThtALAAGBQEFBgGAAAEEBQEEfgAHAAUGBwVpAAMDBGEABAQ2TQACAgBiAAAANABOWVlACycUJSQkJykoCAkeKwAGBxYWFRQGBiMiJyYmNzY2NzY2MzIVFAcGAgcWMzI2NTQmJyYmNTQ2Nz4CNTQmIyIGBwYjIiY1NDY3NjYzMhYWFQMqbmlLR2O8hFRVJx4CCyooByYkPQYZOAUeQ4mCUWMVDxggPGhAamU5dUYDBxAWIRs/bFJql04CLXYcE0k6T3Q/CgQeHYz0jxoVJA4SUv7UUwVRPy07AwEQFR4kAQImRi05RBQTARkTHSUIEhI6ZT8AAAABAEH/+wK/A1AALAA2QDMAAQIEAgEEgAAEAwIEA34AAgIAYQAAADlNAAMDBWEGAQUFNAVOAAAALAArIyUoJCYHCRsrBCYmNTQ2NjMyFhUUBiMiJjU0NzY2NTQjIgYGFRQWMzI2NzYzMhYVFAYHBgYjASuVVXG/cWxwLCccIAUBBGFCeEppYjxsOBIQDhANDjuSTAVQoHOR5H1vWz1LGxkQFwYbCVtWp3KDdzE0ERoUEiQOPz8AAAD//wBB//sC7gR8ACIA6AAAAQcFwAMTAXwACbEBAbgBfLA1KwD//wBB//sCvwSJACIA6AAAAQcFwwMTAXwACbEBAbgBfLA1KwAAAQBB/wICvwNQAEkAfbYkCgIECAFMS7AuUFhAKgAGBwAHBgCAAAAIBwAIfgAIAAQCCARpAwECAAECAWUABwcFYQAFBTkHThtAMQAGBwAHBgCAAAAIBwAIfgACBAMEAgOAAAgABAIIBGkAAwABAwFlAAcHBWEABQU5B05ZQAwlKCQsJCMWLCAJCR8rJDMyFhUUBgcGBgcWFRQGIyInJiY1NDYzMhcWMzI2NTQmIyImNTQ3NjcmJjU0NjYzMhYVFAYjIiY1NDc2NjU0IyIGBhUUFjMyNjcCkRAOEA0OLm47JGdYJhgUExQUCAUbGigtKyUaHAEBBF5tcb9xbHAsJxwgBQEEYUJ4SmliPGw46xoUEiQOMTwLITZLXQUEFhUYFgEEISIZHQ4RBgMGCiGrgpHkfW9bPUsbGRAXBhsJW1ancoN3MTT//wBB//sCvwSfACIA6AAAAQcFwgMTAXwACbEBAbgBfLA1KwD//wBB//sCvwQwACIA6AAAAQcFvgMTAXwACbEBAbgBfLA1KwAAAQBQ//sDFwNcAC0A9bURAQEAAUxLsAlQWEAlAAMCAAIDAIAAAAECAAF+AAICBGEABAQzTQABAQViBgEFBTQFThtLsA5QWEAlAAMCAAIDAIAAAAECAAF+AAICBGEABAQ5TQABAQViBgEFBTQFThtLsBBQWEAlAAMCAAIDAIAAAAECAAF+AAICBGEABAQzTQABAQViBgEFBTQFThtLsCpQWEAlAAMCAAIDAIAAAAECAAF+AAICBGEABAQ5TQABAQViBgEFBTQFThtAIwADAgACAwCAAAABAgABfgAEAAIDBAJpAAEBBWIGAQUFNAVOWVlZWUAOAAAALQAsJSMkJykHCRsrFiYnJiY3NhI3NjMyFRQHBgIHFjMyNjU0JiMiBgcGIyI1NDY3NjMyFhYVFAYGI/Y2KSgfAwgzJQ1EPQYZMgsnHK+thWsqUToSDCQjNElidqlZeOafBQQGBSAkZgEhhi8kDhJR/vR6A9Gsf4IOEgYpICMSGlulbpbhfP//AFD/9gXHBIkAIgDuAAAAAwFrAxYAAP//AA//+wMjA1wAAgAoAAD//wBQ//sDFwSJACIA7gAAAQcFwwL1AXwACbEBAbgBfLA1KwD//wAP//sDIwNcAAIAKAAAAAEAK//7AsoDUAA8AEFAPhEBBgUBTAADBAUEAwWAAAAGBwYAB4AABQAGAAUGaQAEBAJhAAICOU0ABwcBYQABATQBTiQjJCgkLCcgCAkeKyQzMhYVFAYHBgYjIiYmNTQ2NyYmNTQ2NjMyFhUUBiMiJjU0NzY1NCYjIgYVFBYXFhYVFAcGBhUUFjMyNjcClA8OEA0NO6JrYYtIaWU+Sl6dXIKALSocIAUFOUVXZ1pXFhI8d2thV0+BOusaFBElDkA+OmQ+VHkcEFo6RGw8a1U8ShsZERQhDCQtSD0tPwMBEhVCAQNUOzpDMjUAAAD//wAr//sC1wR8ACIA8wAAAQcFwAL8AXwACbEBAbgBfLA1KwD//wAr//sCygRJACIA8wAAAQcFxAL8AXwACbEBAbgBfLA1KwD//wAr//sCygSJACIA8wAAAQcFwwL8AXwACbEBAbgBfLA1KwD//wAr//sCygSfACIA8wAAAQcFwgL8AXwACbEBAbgBfLA1KwD//wAr//sDCwTnACIA8wAAAQcF8QL8AXcACbEBArgBd7A1KwD//wAr/xgCygSfACIA8wAAACMFzQLIAAABBwXCAvwBfAAJsQIBuAF8sDUrAP//ACv/+wLKBOcAIgDzAAABBwXyAvwBdwAJsQECuAF3sDUrAP//ACv/+wMTBN0AIgDzAAABBwXzAvwBdwAJsQECuAF3sDUrAP//ACv/+wLKBP4AIgDzAAABBwX0AvwBdwAJsQECuAF3sDUrAP//ACv/+wLKBHwAIgDzAAABBwXJAvwBfAAJsQECuAF8sDUrAP//ACv/+wLKBDEAIgDzAAABBwW9AvwBfAAJsQECuAF8sDUrAP//ACv/+wLKBDAAIgDzAAABBwW+AvwBfAAJsQEBuAF8sDUrAP//ACv/GALKA1AAIgDzAAAAAwXNAsgAAP//ACv/+wLKBHwAIgDzAAABBwW/AvwBfAAJsQEBuAF8sDUrAP//ACv/+wLKBIUAIgDzAAABBwXIAvsBfAAJsQEBuAF8sDUrAP//ACv/+wLKBEkAIgDzAAABBwXKAvwBfAAJsQEBuAF8sDUrAP//ACv/+wLKA/IAIgDzAAABBwXHAvsBfAAJsQEBuAF8sDUrAAABACv/AgLKA1AAVACWtSkBCQgBTEuwElBYQDUABgcIBwYIgAAACQoJAAqAAAgACQAICWkCAQEAAwEDZQAHBwVhAAUFOU0ACgoEYQAEBDQEThtAPAAGBwgHBgiAAAAJCgkACoAAAgQBBAIBgAAIAAkACAlpAAEAAwEDZQAHBwVhAAUFOU0ACgoEYQAEBDQETllAEFJQTEokKCQsJCciLCALCR8rJDMyFhUUBgcGBwYGFRQWMzI3NjMyFhUUBgcGBiMiJjU0NyMiJiY1NDY3JiY1NDY2MzIWFRQGIyImNTQ3NjU0JiMiBhUUFhcWFhUUBwYGFRQWMzI2NwKUDw4QDQ1OdSMgJBoaFRALDgwWGQwnEEZUKQFhi0hpZT5KXp1cgoAtKhwgBQU5RVdnWlcWEjx3a2FXT4E66xoUESUOVBwYOR0dHgcGExMVHQkEBkk/PTQ6ZD5UeRwQWjpEbDxrVTxKGxkRFCEMJC1IPS0/AwESFUIBA1Q7OkMyNQAA//8AK//7AsoEVwAiAPMAAAEHBcYC/AF8AAmxAQG4AXywNSsAAAEAPP/7AugDVgAzAG5LsC5QWLUTAQMCAUwbtRMBAwQBTFlLsC5QWEAdBgEAAAdfAAcHM00EAQICAWEFAQEBNk0AAwM0A04bQCMABQAEAwUEaQYBAAAHXwAHBzNNAAICAV8AAQE2TQADAzQDTllAC2UTJCUjJCIlCAkeKwAWFRQHBiMjBgc3MhYVFAYjBwYHBiMiJjU0NjcHIiY1NDYzNzY3NycmJjU0NjMyFxYzMjcCwiY+ULQrHxLaJRknJt8gBgRDJCMTFDoWHSQgPQwjBDgwLyQoKU46PHqPA1YeHDQLD6FkBBkXIiUC0Uw8IBwghHYBERwhKAFDsRUDBCAiHBgCAwsAAQBB/wkC+QNQAD8AREBBEgEBBQFMAAMEBwQDB4AAAAEAhggBBwAGBQcGZwAEBAJhAAICOU0ABQUBYQABATQBTgAAAD8APSMlKCQmKSgJCR0rABYHBgcHBgcGIyI1NDc2NzY2NwYjIiYmNTQ2NjMyFhUUBiMiJjU0NzY1NCYjIgYGFRQWMzI3NjcjIiY1NDYzMwLWIwEDGAkVDAw7NwEECwMIBE1OcKpecMV6dXUrKBshBAYzPEl9TIN8RUwHBlckJSYgmwGCHyM6rz2WPT45CgUnPRQyHR1XoGqU431tWjtHGhcKGBwQKi5Up3V4gxpBPhsfHCAAAP//AEH/CQL5BEkAIgEIAAABBwXEAyIBfAAJsQEBuAF8sDUrAP//AEH/CQL5BIkAIgEIAAABBwXDAyIBfAAJsQEBuAF8sDUrAP//AEH/CQL5BJ8AIgEIAAABBwXCAyIBfAAJsQEBuAF8sDUrAP//AEH+7AL5A1AAIgEIAAAAAwXPAwUAAP//AEH/CQL5BDAAIgEIAAABBwW+AyIBfAAJsQEBuAF8sDUrAAABADP/+wNLA1AASADAS7AhUFi1LwEFBgFMG7UvAQkGAUxZS7AdUFhAHAgBBgY5TQQCAgAABWEKCQcDBQU2TQMBAQE0AU4bS7AhUFhAGgoJBwMFBAICAAEFAGoIAQYGOU0DAQEBNAFOG0uwJlBYQB8KAQkFAAlZBwEFBAICAAEFAGoIAQYGOU0DAQEBNAFOG0AkCgEJBQAJWQIBAAQFAFoHAQUABAEFBGoIAQYGOU0DAQEBNAFOWVlZQBIAAABIAEclNSYjJiYmJiQLCR8rABYVFAYjIwcGBgcGBiMiNTQ2PwIjBwcGBgcGBiMiNTQ2PwIHIjU0NjMzNTY2NzY2MzIVFAYPAjc3NjY3NjYzMhUUBgcHMwMuHSQxGQILFwQDJiJFExMEA7WJAgsXBAMmIkUTEwQCIDUmLhYMFwMDKCY/EREJAYi3CxcEAygmPxQNCh0B6xwXIiQNQ7EwJSE8IINvGg8CC0OxMCUhPCCDbxoKAS8kJQJDsi8lITwddGQ3AwEDQK8yJSE8HIhLOgACADj/+wNwA1AAVQBdAUBLsCZQWLU7AQgJAUwbtTsBDAkBTFlLsBVQWEAoDAoCCA4QDQMHAAgHagsBCQk5TQUDAgEBAGEPBgIAADZNBAECAjQCThtLsCFQWEAmDAoCCA4QDQMHAAgHag8GAgAFAwIBAgABaQsBCQk5TQQBAgI0Ak4bS7AmUFhAKwwKAggOEA0DBwAIB2oAAAYBAFkPAQYFAwIBAgYBaQsBCQk5TQQBAgI0Ak4bS7AuUFhANQAMCAcMWQoBCA4QDQMHAAgHagAABgEAWQMBAQUGAVkPAQYABQIGBWkLAQkJOU0EAQICNAJOG0A2AAwQAQ0HDA1qCgEIDgEHAAgHagAABgEAWQMBAQUGAVkPAQYABQIGBWkLAQkJOU0EAQICNAJOWVlZWUAeAABdWllXAFUAVFBOS0lFQj89IyMjJiYmJiQiEQkfKwEGBzMyFhUUBiMjBwYGBwYGIyI1NDY/AiMHBwYGBwYGIyI1NDY/AgciNTQ2MzM1NjcHIjU0NjMzNjc2NjMyFRQHNzI3Njc2NjMyFRQHMzIWFRQGIwY3Iw8CNzcDCAcLHSAdJDEZAgsXBAMmIkUTEwQDtYkCCxcEAyYiRRMTBAIgNSYuFgoHJzQmLhQHAQMoJj8JhUNyAQcDKCY/CBogHSQxpwi6gxIBiLcCVzU3HBciJA1DsTAlITwgg28aDwILQ7EwJSE8IINvGgoBLyQlAjM6ASgfIDUcJSE8HzsBAglEJSE8GzoYFB0fPT0BbgMBA///ADP/+wNLBJ8AIgEOAAABBwXCAysBfAAJsQEBuAF8sDUrAAABAE7/+wFFA1AAGQAZQBYAAAA5TQIBAQE0AU4AAAAZABgrAwkXKxY1NDY/AjY2NzY2MzIVFAYPAgYGBwYGI04TEwQXCxcEAygmPxERCRYLFwQDJiIFPCCDbxqDQLEzJSE8HXRkN4NDsTAlIf//AE7/+wITBHwAIgERAAABBwXAAjgBfAAJsQEBuAF8sDUrAP//AFz/+QO6BHwAIgFgAAAAJwXAAjEBfAEHBcAD3wF8ABKxAQG4AXywNSuxAgG4AXywNSv//wBM//sB6wRJACIBEQAAAQcFxAI4AXwACbEBAbgBfLA1KwD//wBO//sBuwSfACIBEQAAAQcFwgI4AXwACbEBAbgBfLA1KwD//wA///sBkgR8ACIBEQAAAQcFyQI4AXwACbEBArgBfLA1KwD//wBO//sBzAQxACIBEQAAAQcFvQI4AXwACbEBArgBfLA1KwD//wBO//sBcgQwACIBEQAAAQcFvgI4AXwACbEBAbgBfLA1KwD//wAh/xgBRQNQACIBEQAAAAMFzQH6AAD////8//sBRQR8ACIBEQAAAQcFvwI4AXwACbEBAbgBfLA1KwD//wBO//sBpQSFACIBEQAAAQcFyAI3AXwACbEBAbgBfLA1KwD//wBO//sB7QRJACIBEQAAAQcFygI4AXwACbEBAbgBfLA1KwD//wBO//sBsAPyACIBEQAAAQcFxwI3AXwACbEBAbgBfLA1KwAAAQAY/wIBRQNQAC8AQrYmDwIAAgFMS7ASUFhADgMBAAABAAFlAAICOQJOG0AVAAACAwIAA4AAAwABAwFlAAICOQJOWUAJLiwdGycgBAkYKwQzMhYVFAYHBgYjIiY1NDcmNTQ2PwI2Njc2NjMyFRQGDwIGBgcGBwYVFBYzMjcBAAoODBYZDCcQRlQ/CRMTBBcLFwQDKCY/EREJFgsXBAMdPCQaGhWTExMVHQkEBkk/TTwPFSCDbxqDQLEzJSE8HXRkN4NDsTAtEC08HR4HAAAA//8APv/7AfkEVwAiAREAAAEHBcYCOAF8AAmxAQG4AXywNSsAAAEASv/4AtQDTwAzAH1LsAlQWLUfAQAGAUwbtR8BAAQBTFlLsAlQWEAlAAUAAgAFAoAAAgMAAgN+BAEAAAZhAAYGM00AAwMBYQABATQBThtAKwAABAUEAAWAAAUCBAUCfgACAwQCA34ABAQGYQAGBjNNAAMDAWEAAQE0AU5ZQAolJyYkJiYTBwkdKwAVFAYjBgcHDgIjIiYnJjU0NjMyFhcWFjMyNjY3NjcmIyIVFBcWFRQGIyInJjU0NjMyFwLUGR4MGgQXUnxYSHwcDBwZDhgPG0AsJDwzDh0XPjHdFAYrGSARHM+tcmADKSofH2WmG5e4VEM0FxkbJhMYKishZ2LGwQVxHiMKCxUhGy49fHQYAAAA//8ASv/4AtQEnwAiASAAAAEHBcIC8QF8AAmxAQG4AXywNSsAAAEARv/7AwwDUABKAJW1QQECBQFMS7AZUFhAHQcBBQQBAgAFAmoIAQYGOU0JAQAAAWEDAQEBNAFOG0uwJlBYQCQAAAIJAgAJgAcBBQQBAgAFAmoIAQYGOU0ACQkBYQMBAQE0AU4bQCgAAAIJAgAJgAcBBQQBAgAFAmoABgY5TQAICDNNAAkJAWEDAQEBNAFOWVlADklHJBYmJCQlJScgCgkfKyQzMhYVFAYHBgYjIiYnLgInIwYGBwYGIyI1NDY3IyImNTQ2MzM3NjY3NjYzMhUUBg8CNjY3NjYzMhYVFAcGBgceAhcWFjMyNwLgBBIWFBMSOhtKXikgKSojDwsUBAMmIkUTFAUXGhsUGQgLFwQDKCY/EREJCIKgNAkoJBogAzK6biYxIhYfNx8PJHwbExEgCwoNV1xHQhgBQKAvJSE8H4F4GhcaHy1AsTMlITwddGQ3LwK0oR0dGxYKDKXCIAkkNS9CNwgA//8ARv7sAwwDUAAiASIAAAADBc8C1wAAAAEATP/0AmMDUAAiAB9AHAAAADlNAAEBAmADAQICNAJOAAAAIgAeOSwECRgrFiY1NDY3Njc3Njc2NjMyFRQGBwYHBwYHNjMyFhUUBiMiBgdvIxYMAwQWHQoEJyY/DgoSARQYC3jUGh0jIX6jcAwbGBulUA0fkapsJSE8F2Y5bQmDoFEGGB4fJwQFAAD//wBM//QFEwNQACIBJAAAAAMBIAI/AAD//wBM//QCYwR8ACIBJAAAAQcFwAI1AXwACbEBAbgBfLA1KwD//wBM//QCYwNQACIBJAAAAQcFqQMcAXwACbEBAbgBfLA1KwD//wBM/uwCYwNQACIBJAAAAAMFzwLCAAD//wBM//QCYwNQACIBJAAAAQcFpQMM/0EACbEBAbj/QbA1KwD//wBM/jkDcANQACIBJAAAAAMCiAJxAAAAAQAW//QCYwNQADMAN0A0Ig8CAQMBTAADAgECAwGAAAEEAgEEfgACAjlNBQEEBABgAAAANABOAAAAMwAxKCkoVAYJGiskFhUUBiMiBgcGJjU0Njc3BwYjIiY1NDc3Njc2NjMyFRQHBzY2NzYzMhcWFRQPAgYHNjMCRh0jIX6jcB8jFgwGEwwKFh8QYyEIBCcmPxcGVToDEQ0SCgo4sw0YC3jUehgeHycEBQEbGBulUCYLBicWFQo80VUlITwmiCUzIgIJEBESKyFqU6BRBgAAAAEASf/7BEUDVABIAHZACwkBBAAVDQIDBAJMS7AJUFhAFgYBBAQAYQIBAgAAOU0IBwUDAwM0A04bS7AMUFhAFgYBBAQAYQIBAgAAM00IBwUDAwM0A04bQBYGAQQEAGECAQIAADlNCAcFAwMDNANOWVlAEAAAAEgARyklKSsmKCUJCR0rFjc2EzY2MzIWFRQHBgc2NjMyFhUUBzY2MzIWFRQGBwcGBgcGBiMiNTQ2Nzc2NTQmIyIGAgcGBiMiJjU0Njc2NTQmIyIGAgcGI0kFDVgFKCEgFwIHHDeGUkFLCTKGV0ZLDgwWDBgEAyIlRxcVGBUcGDBmXx0GISgiHxYRLh0eMWlkIQlCBUWbAj8gGhQXBxRDfY50XFQhMYp4WlEjXkR7Q7IvJiA8IpN1hXguIiN7/uDqLiMdJTCJWfJGJiRx/tz6RwAAAAABAEv/+wLxA1QALwBpQAoKAQMADgECAwJMS7AJUFhAEwADAwBhAQEAADlNBQQCAgI0Ak4bS7AMUFhAEwADAwBhAQEAADNNBQQCAgI0Ak4bQBMAAwMAYQEBAAA5TQUEAgICNAJOWVlADQAAAC8ALikrJyYGCRorFiY3NhM2NjMyFhUUBwYHEjMyFhUUBgcHBgYHBgYjIiY1NDY3NzY1NCMiBgIHBgYjbiMDDlYFKh0iGAIGHG/FVFUODBYMFwQDKCYhIBcVGBU+Q4RpGAQlIgUfJqkCMSAaFBcHFD2DAQJdTiNeRHtBsjElISAcIpN1hXgrSJL+2dYhJgAAAP//AEv/+AXzA1QAIgEtAAAAAwEgAx8AAP//AEv/+wLxBHwAIgEtAAABBwXAAxEBfAAJsQEBuAF8sDUrAP//AEv/+wLxBIkAIgEtAAABBwXDAxEBfAAJsQEBuAF8sDUrAP//AEv+7ALxA1QAIgEtAAAAAwXPAtcAAAABAEz+pQLpA1QAOwCWQAsqAQIELhICAwICTEuwCVBYQCEAAAMBAwABgAABBwEGAQZlAAICBGEFAQQEOU0AAwM0A04bS7AMUFhAIQAAAwEDAAGAAAEHAQYBBmUAAgIEYQUBBAQzTQADAzQDThtAIQAAAwEDAAGAAAEHAQYBBmUAAgIEYQUBBAQ5TQADAzQDTllZQA8AAAA7ADonJiUrIiYICRwrEiYnJjU0NjMyFxYzMjY2NxM2BzY2NTQmIyIGAgcGBiMiJjc2EzY2MzIWFRQHBgcSMzIWFRQGBwMOAiP2biINIxcdFDRFJTc3IT8OAxEOHx1AgGgaBCUiIiMDDFgFKh0iGAIGHG/FUU8XEUQmWHlU/qU0MRMTGCQcSDafmwEnOQlQTh8fJpL+2dYhJh8mmgJAIBoUFwcUPYMBAltLN39G/t2k0nD//wBL/jkECgNUACIBLQAAAAMCiAMLAAD//wBL//sC8QRXACIBLQAAAQcFxgMRAXwACbEBAbgBfLA1KwAAAgBA//sEpQNRAD4ATAEaQAsxAQEAAUwjAQQBS0uwElBYQC0ABAIDAgQDgAkLAgAAB2EIAQcHOU0AAgIBXwABATZNDAoCAwMFYQYBBQU0BU4bS7AbUFhANwAEAgMCBAOAAAkJB2EIAQcHOU0LAQAAB2EIAQcHOU0AAgIBXwABATZNDAoCAwMFYQYBBQU0BU4bS7AuUFhANQAEAgMCBAOAAAEAAgQBAmcACQkHYQgBBwc5TQsBAAAHYQgBBwc5TQwKAgMDBWEGAQUFNAVOG0AzAAQCAwIEA4AAAQACBAECZwAJCQdhAAcHOU0LAQAACF8ACAgzTQwKAgMDBWEGAQUFNAVOWVlZQCE/PwEAP0w/S0ZEOTQvLSclIR8aGBYUEQ0JBAA+AT0NCRYrAAYHBgc2MzYzMhYVFAYHBwYHBhUUMzI3NjMyFRQGBwYjIiYnBgYjIiYmNTQ2NjMyFhc3NjY3NzYzMhYVFAYjADY2NTQmIyIGBhUUFjMEGo0gGCIuFGtKHhcjH3E0XQu7M00RCicYIExVcIodNpVWWY9Ub790U4MnBQ9FMzR+SCQcJCT9d3dAZE9NdkJkTwLQBgRImwIFGRgfKQEDAgIxJp8YBS8cIwwbUEVHTlCbbJjofkhFFDc4AgMGGR0fLP2hYKtsd3tfq213ewACAC//+wKcA04ALAA0AItLsCFQWEALHAEEBjQOAgACAkwbQAscAQQGNA4CAAMCTFlLsCFQWEAmAAQGAgYEAoAAAAIBAgABgAAGBgVhAAUFM00DAQICAWEAAQE0AU4bQCwABAYCBgQCgAACAwYCA34AAAMBAwABgAAGBgVhAAUFM00AAwMBYQABATQBTllAChcmJhMbJBIHCR0rAAYGBwYHBgYjIjU0Njc3JyYmNTQ2MzIXFhc3NjcGBwYjIiY1NDc2NjMyFhYVBjU0JicGBwcCnFmzgRYHBR4mRQ8JBSEeExkVBQwVDxQVDxwWDAoQFSolcj5qkEaSU1wNGxQB+o5ZBo4+Jx88F2k7IAUFHBQXGAIEAXJ5cgkMBhcRJBoXG0JyScnDSE0EWqJ1AAACACr/+wKHA1AAMgA7AI1LsCFQWEAKGgEDBgwBAAICTBtAChoBAwYMAQAHAkxZS7AhUFhAJQADBgIGAwKAAAUABgMFBmoIBwICAAABAgBpAAQEOU0AAQE0AU4bQCsAAwYCBgMCgAACBwYCB34ABQAGAwUGaggBBwAAAQcAaQAEBDlNAAEBNAFOWUAQMzMzOzM7GCMpKhkkEgkJHSsABgYPAgYGIyI1NDcnJiY1NDYzMhcXNzc2NwYHBiMiJjU0NzY3NzY2MzIVFAczMhYWFQY2NTQmJw8CAodYsIADCQMmIkUPFR4VGhYFDBYMFwcIFw0MChAVKh0mCQMoJj8HBmaHQfllVFwUFgwBj4hSAhtXJSE8JF8DBRwUFxgCA0eDJzoJBwYXESQaEgpXJSE8Ezg+aEDGZk88UgF5g04AAgBA/u4DHgNQAB0AKwAtQCoDAQADAUwEAQMCAAIDAIAAAACEAAICAWEAAQE5Ak4eHh4rHiopLCoFCRkrAAYGBxYXFxYVFAYjIiYnJyYmJyYmNTQ2NjMyFhYVADY2NTQmIyIGBhUUFjMDHk6KWSQcVQgvHhUoDkYnLSJvh2+/dFmPVP62d0BkT012QmRPAXnMhRsVK4cODBklFhdxPy8HFrCLmOh+UJts/nhgq2x3e1+rbXd7AAAAAAIAU//7Au0DTgBDAEwAg0ASJwEFCEkBBAU7AQMEEgEAAwRMS7AbUFhAJwAFCAQIBQSAAAQAAwAEA2kACAgGYQAGBjNNBwEAAAFhAgEBATQBThtALgAFCAQIBQSAAAADBwMAB4AABAADAAQDaQAICAZhAAYGM00ABwcBYQIBAQE0AU5ZQAwTKycmJBUrJxEJCR8rJDMyFhUUBgcGBiMiJiYnLgInBgcGBiMiNTQ2NzcmJjU0NjMzNzY3BgcGIyImNTQ2NzY2MzIWFhUUBgcWFhcWFjMyNwImJwYHBzY2NQK9CBIWExQSOhszSDcfGiMlGhsJBCEhRRELCB4WGhMZDBYOHxIPDRAVGBglcz9li0SBei4zGyA1Hg8kulFXDRsLbG97GhMSIAoKDSZLQjg3GgOnUiYgPBp3QzACGRkYHEN9bwoMCRURESMPFxs7ZUBckx4NODY/NQgCJUIEWKVDCGRRAAD//wBT//sC7QR8ACIBOQAAAQcFwALVAXwACbECAbgBfLA1KwD//wBT//sC7QSJACIBOQAAAQcFwwLVAXwACbECAbgBfLA1KwD//wBT/uwC7QNOACIBOQAAAAMFzwLRAAD//wBT//sC7QR8ACIBOQAAAQcFyQLVAXwACbECArgBfLA1KwD//wBT//sC7QRJACIBOQAAAQcFygLVAXwACbECAbgBfLA1KwAAAQBD//sC6ANPACUAIUAeDQEBAAFMAgEAAANfAAMDM00AAQE0AU43GCdEBAkaKwAWFRQGIyInJwYHBgYHBgYjIiY1NDY3NzY3BgcGNTQ2NzYzMzIXArkvIykpXEQrGQwXBAIuIR0hExMEGSlbWk0fH3aOgmAiA0giIhwVAgHYmUmxNB0fIRsgg28am9cDBwY6GiMEDwMAAAABAEP/+wLoA08AOQCQtiAWAgMCAUxLsC5QWEAdBgEAAAdfAAcHM00EAQICAV8FAQEBNk0AAwM0A04bS7AwUFhAJwYBAAAHXwAHBzNNBAECAgFfAAEBNk0EAQICBV8ABQU2TQADAzQDThtAIgAFAgIFVwYBAAAHXwAHBzNNBAECAgFfAAEBNk0AAwM0A05ZWUALNxIjSCYkIkQICR4rABYVFAYjIicnBgc3MhYVFAYjIxUGBgcGBiMiJjU0Njc3NSIHBiMiNTQ2MzM2NwYHBjU0Njc2MzMyFwK5LyMpKVxEGhhoIB0kMWIMFwQCLiEdIRMTBBEgKBI0Ji5cECFbWk0fH3aOgmAiA0giIhwVAgGDhQEYFB0fAkmxNB0fIRsgg28aAwICKB8gXLADBwY6GiMEDwMA//8AQ//7AugEiQAiAT8AAAEHBcMCywF8AAmxAQG4AXywNSsAAAEAQ/8CAugDTwBCAGVACw0BBQApDwIEBQJMS7AuUFhAHAAFAAQCBQRpAwECAAECAWUGAQAAB18ABwczAE4bQCMAAgQDBAIDgAAFAAQCBQRpAAMAAQMBZQYBAAAHXwAHBzMATllACzcYFiQjFitECAkeKwAWFRQGIyInJwYHBgYHBgcWFRQGIyInJiY1NDYzMhcWMzI2NTQmIyImNTQ3NjY3JjU0Njc3NjcGBwY1NDY3NjMzMhcCuS8jKSlcRCsZDBcEAQ87Z1gmGBQTFBQIBRsaKC0rJRocAQQXFwITEwQZKVtaTR8fdo6CYCIDSCIiHBUCAdiZSbE0Fg8hR0tdBQQWFRgWAQQhIhkdDhEGAxMTAQoGIINvGpvXAwcGOhojBA8DAP//AEP+7ALoA08AIgE/AAAAAwXPAo0AAAABAF3/+wMDA1QALwBpQAoGAQIBAgEAAgJMS7AJUFhAEwMBAQE5TQACAgBiBQQCAAA0AE4bS7AMUFhAEwMBAQEzTQACAgBiBQQCAAA0AE4bQBMDAQEBOU0AAgIAYgUEAgAANABOWVlADQAAAC8ALiUpKycGCRorBCY1NDc2NwIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzMjYSNzY2MzIWBwYDBgYjAi4YAgYcb8VUVQ4MFgwXBAMoJiEgFxUYFT5DgmkaBCUiIiMDDFgFKh0FFBcHFD2D/v5dTiNeRHtBsjElISAcIpN1hXgrSJEBKNYhJh8mmv3AIBoAAP//AF3/+wMDBHwAIgFEAAABBwXAAxQBfAAJsQEBuAF8sDUrAP//AF3/+wMDBEkAIgFEAAABBwXEAxQBfAAJsQEBuAF8sDUrAP//AF3/+wMDBJ8AIgFEAAABBwXCAxQBfAAJsQEBuAF8sDUrAP//AF3/+wMDBHwAIgFEAAABBwXJAxQBfAAJsQECuAF8sDUrAP//AF3/+wMDBDEAIgFEAAABBwW9AxQBfAAJsQECuAF8sDUrAP//AF3/GAMDA1QAIgFEAAAAAwXNAuwAAP//AF3/+wMDBHwAIgFEAAABBwW/AxQBfAAJsQEBuAF8sDUrAP//AF3/+wMDBIUAIgFEAAABBwXIAxMBfAAJsQEBuAF8sDUrAAABAF3/+wOZA+UAOQB5QAoGAQIBAgEAAgJMS7AJUFhAGAAEAQSFAwEBATlNAAICAGIGBQIAADQAThtLsAxQWEAYAAQBBIUDAQEBM00AAgIAYgYFAgAANABOG0AYAAQBBIUDAQEBOU0AAgIAYgYFAgAANABOWVlADgAAADkAOCMlKSsnBwkbKwQmNTQ3NjcCIyImNTQ2Nzc2Njc2NjMyFhUUBgcHBhUUMzI2Ejc2NjMyNjc2MzIWFRQHBgYHBgMGBiMCLhgCBhxvxVRVDgwWDBcEAygmISAXFRgVPkOCaRoEJSI0LAoILhsgAQhSQxJNBSodBRQXBxQ9g/7+XU4jXkR7QbIxJSEgHCKTdYV4K0iRASjWISYsNy4gHwoFSGIQtf4NIBr//wBd//sDmQR8ACIBTQAAAQcFwAMUAXwACbEBAbgBfLA1KwD//wBd/xgDmQPlACIBTQAAAAMFzQLsAAD//wBd//sDmQR8ACIBTQAAAQcFvwMUAXwACbEBAbgBfLA1KwD//wBd//sDmQSFACIBTQAAAQcFyAMTAXwACbEBAbgBfLA1KwD//wBd//sDmQRXACIBTQAAAQcFxgMUAXwACbEBAbgBfLA1KwD//wBd//sDAwR8ACIBRAAAAQcFwQMUAXwACbEBArgBfLA1KwD//wBd//sDAwRJACIBRAAAAQcFygMUAXwACbEBAbgBfLA1KwD//wBd//sDAwPyACIBRAAAAQcFxwMTAXwACbEBAbgBfLA1KwAAAQBd/wIDAwNUAEUAnLUdAQUEAUxLsAlQWEAZAQEAAAIAAmUGAQQEOU0ABQUDYgADAzQDThtLsAxQWEAZAQEAAAIAAmUGAQQEM00ABQUDYgADAzQDThtLsBJQWEAZAQEAAAIAAmUGAQQEOU0ABQUDYgADAzQDThtAIAABAwADAQCAAAAAAgACZQYBBAQ5TQAFBQNiAAMDNANOWVlZQAolKSsrJyIkBwkdKwQGFRQWMzI3NjMyFhUUBgcGBiMiJjU0NyY1NDc2NwIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzMjYSNzY2MzIWBwYDBgcCXR0kGhoVEQoODBYZDCcQRlRCAgIGHG/FVFUODBYMFwQDKCYhIBcVGBU+Q4JpGgQlIiIjAwxYBhkSNxwdHgcGExMVHQkEBkk/Tz0KBwYUPYP+/l1OI15Ee0GyMSUhIBwik3WFeCtIkQEo1iEmHyaa/cAiDv//AF3/+wMDBKgAIgFEAAABBwXFAxQBfAAJsQECuAF8sDUrAP//AF3/+wMDBFcAIgFEAAABBwXGAxQBfAAJsQEBuAF8sDUrAAABAHv/+wMuA1AAIQAnQCQKAQEAAUwCAQAAOU0AAQEDYgQBAwM0A04AAAAhACAlKCYFCRkrFiY1NDc2NjMyFhUUBwYVFBYzMjYSNzY2MzIWFRQHAgIGI+htGAgmJR8jAhs3LSxtaCQJLCggHQQ4m65YBfzUjZ8xKBsjBhS4hpOkkwEhyC4jGhoREP77/qijAAABAHr/+wTlA1AAOQAtQCoLAQMCAUwHBgQDAgI5TQUBAwMAYgEBAAA0AE4AAAA5ADgpJSgmJCcICRwrABYVFAcCAgYjIiYnBgYjIiY1NDc2NjMyFhUUBwYVFBYzMjYSNzY2MzIWFRQHBhUUFhYzMjYSNzY2MwTHHgQ6k6FVXFkDPJpVX2IZBycmHiICHS0mI2NjIQgrJR8fAhsPKSgnYGAmCSonA1AaGxAQ/vn+qaK/oLKt88yXpjEoGiMRCsWVh5SVASHGLiMXIRILuIhthEeTASDJLiMAAP//AHr/+wTlBHwAIgFaAAABBwXAA+4BfAAJsQEBuAF8sDUrAP//AHr/+wTlBJ8AIgFaAAABBwXCA+4BfAAJsQEBuAF8sDUrAP//AHr/+wTlBDEAIgFaAAABBwW9A+4BfAAJsQECuAF8sDUrAP//AHr/+wTlBHwAIgFaAAABBwW/A+4BfAAJsQEBuAF8sDUrAAAB/9X/+wLnA08AJwAmQCMjGQ8FBAACAUwEAwICAjNNAQEAADQATgAAACcAJiomKgUJGSsAFhUUBwETFhUUBiMiJicDAwYGIyImNTQ3AQMmNTQ2MzIWFxc3NjYzAsgfG/7vqAwmIBolDH7wFCocHCUdATeVCyUgHyMKbMsUKh4DTxQSGB/+xf6lGRQaGhYbASH+1hkPFRMZIAFjATMYERkbFRf29hgUAAABAFz/+QLqA1QAOACVtzEgEAMEAwFMS7AJUFhAIgAAAgECAAGAAAQAAgAEAmoFAQMDOU0AAQEGYQcBBgY0Bk4bS7AMUFhAIgAAAgECAAGAAAQAAgAEAmoFAQMDM00AAQEGYQcBBgY0Bk4bQCIAAAIBAgABgAAEAAIABAJqBQEDAzlNAAEBBmEHAQYGNAZOWVlADwAAADgANyQqKCUjJggJHCsEJicmNTQ2MzIXFhYzMjY2NwYGIyImNTQ2NzY3NjMyFgcGBgcGBhUUFjMyNjY3NjMyBwYHBgcGBiMBDHUfHBkTDg4jXjhEXDcJK3tSamkKChEHBkYjJAIDDgsHCjAtPWtLCQZCRwYHGwMEF7aVBx8aFiQXIgoYGjiEcVlTZ1kmUD5yREAkHDRiPyZGFygrVbeKVVNp6BMmybX//wBc//kC6gR8ACIBYAAAAQcFwAL5AXwACbEBAbgBfLA1KwD//wBc//kC6gSfACIBYAAAAQcFwgL5AXwACbEBAbgBfLA1KwD//wBc//kC6gQxACIBYAAAAQcFvQL5AXwACbEBArgBfLA1KwD//wBc/xgC6gNUACIBYAAAAAMFzQLCAAD//wBc//kC6gR8ACIBYAAAAQcFvwL5AXwACbEBAbgBfLA1KwD//wBc//kC6gSFACIBYAAAAQcFyAL4AXwACbEBAbgBfLA1KwD//wBc//kC6gPyACIBYAAAAQcFxwL4AXwACbEBAbgBfLA1KwD//wBc//kC6gRXACIBYAAAAQcFxgL5AXwACbEBAbgBfLA1KwAAAQAI//YCsQNTACwAcUuwCVBYQBcAAQECYQACAjNNAAMDAGEEBQIAADQAThtLsB1QWEAXAAEBAmEAAgI5TQADAwBhBAUCAAA0AE4bQBsAAQECYQACAjlNAAMDBF8ABAQ0TQUBAAA0AE5ZWUARAQArJR8cFBIMCAAsASwGCRYrFyImNTQ3NhI3IgYHBiY1NDY3NjMyFxYVFAYHBgE2MzIXFhYVFAYjIicmIyIHSiQeHJ/jXnCaWyglIiZDo509VwsRf/7ENkl9XyohJScvTD4YkHkKHBsgIcEBJIYDBAEYGhsmBQoFBzoSIhi6/nEDBwMWIR4gAgIJAP//AAj/9gKzBHwAIgFpAAABBwXAAtgBfAAJsQEBuAF8sDUrAP//AAj/9gKxBIkAIgFpAAABBwXDAtgBfAAJsQEBuAF8sDUrAP//AAj/9gKxBDAAIgFpAAABBwW+AtgBfAAJsQEBuAF8sDUrAAACACP/+wJXAdQAJgAxAKBLsBtQWEAKCQEGASQBBAICTBtACgkBBgEkAQQHAkxZS7AbUFhAKQABAAYAAQaAAAMGAgYDAoAABgYAYQAAADZNCQcCAgIEYggFAgQENAROG0A0AAEABgABBoAAAwYCBgMCgAAGBgBhAAAANk0AAgIEYggFAgQENE0JAQcHBGEIBQIEBDQETllAFicnAAAnMScwKyoAJgAlJiMnIyUKCRsrFiY1NDY2MzIWFzYzMhUUBwYVFBYzMjY3NjMyFhUUBwYGIyImJwYjNjY3Nw4CFRQWM21KSntFFg8FFRcxDxcPDBM2LgwPDQ8TKVwrITcONE86KAklKkcqGRYFWklQj1cRFgQjFU9zLQ8SMTcOGBUoFjNGLSdUZTQruAE9ZDgfHgD//wAj//sCVwNCACIBbQAAAAMFpwJfAAD//wAj//sCVwL0ACIBbQAAAAMFrAJfAAD//wAj//sCVwNdACIBbQAAAAMF5QJfAAD//wAj/xwCVwL0ACIBbQAAACMFtQI7AAAAAwWsAl8AAP//ACP/+wJXA10AIgFtAAAAAwXmAl8AAP//ACP/+wJXA4gAIgFtAAAAAwXnAl8AAP//ACP/+wJXA44AIgFtAAAAAwXoAl8AAP//ACP/+wJXA1wAIgFtAAAAAwWqAl4AAP//ACP/+wJuA2sAIgFtAAABBwXpAl//+wAJsQICuP/7sDUrAP//ACP/HAJXA1wAIgFtAAAAIwW1AjsAAAADBaoCXgAA//8AI//7AlcDawAiAW0AAAEHBeoCX//7AAmxAgK4//uwNSsA//8AI//7AnYDYQAiAW0AAAEHBesCX//7AAmxAgK4//uwNSsA//8AI//7AlcDggAiAW0AAAEHBewCX//7AAmxAgK4//uwNSsA//8AI//7AlcDRAAiAW0AAAADBbECXwAA//8AI//7AlcCsQAiAW0AAAADBaQCXwAA//8AI/8cAlcB1AAiAW0AAAADBbUCOwAA//8AI//7AlcDQwAiAW0AAAADBaYCXwAA//8AI//7AlcDKwAiAW0AAAADBbACXgAA//8AI//7AlcC9AAiAW0AAAADBbICXwAA//8AI//7AlcCcgAiAW0AAAADBa8CXgAAAAIAI/8GAlcB1AA8AEcA9EuwG1BYQAsTAQgCBwUCAAMCTBtACxMBCAIHBQIACQJMWUuwElBYQDAAAgEIAQIIgAAECAMIBAOABgEFCgEHBQdmAAgIAWEAAQE2TQsJAgMDAGEAAAA0AE4bS7AbUFhANwACAQgBAgiAAAQIAwgEA4AABgAFAAYFgAAFCgEHBQdmAAgIAWEAAQE2TQsJAgMDAGEAAAA0AE4bQD0AAgEIAQIIgAAECAMIBAOAAAMJCAMJfgAGAAUABgWAAAUKAQcFB2YACAgBYQABATZNCwEJCQBhAAAANABOWVlAGD09AAA9Rz1GQUAAPAA7IiwjJyMlKAwJHSsEJjU0NjcmJwYjIiY1NDY2MzIWFzYzMhUUBwYVFBYzMjY3NjMyFhUUBwYGBwYGFRQWMzI3NjMyFRQHBgYjAjY3Nw4CFRQWMwFLUS0mFQo0Tz5KSntFFg8FFRcxDxcPDBM2LgwPDQ8TIUMpLikkGhoVEAsaLwwnEKsoCSUqRyoZFvpHPStNGRgcVFpJUI9XERYEIxVPcy0PEjE3DhgVKBYoNRcaMBsdHgcGJSgQBAYBWjQruAE9ZDgfHgAAAP//ACP/+wJXAywAIgFtAAAAAwWtAl8AAAAFACP/+wKSA4cAEAAeACoAUQBcAPxLsBtQWEAKNAEMB08BCggCTBtACjQBDAdPAQoNAkxZS7AbUFhASQAAAgCFDgEBAgQCAQSAAAcGDAYHDIAACQwIDAkIgAACAAQFAgRpEAEFDwEDBgUDaQAMDAZhAAYGNk0SDQIICApiEQsCCgo0Ck4bQFQAAAIAhQ4BAQIEAgEEgAAHBgwGBwyAAAkMCAwJCIAAAgAEBQIEaRABBQ8BAwYFA2kADAwGYQAGBjZNAAgICmIRCwIKCjRNEgENDQphEQsCCgo0Ck5ZQDJSUisrHx8REQAAUlxSW1ZVK1ErUE1LRUNAPjc1MjAfKh8pJSMRHhEdGBYAEAAPJhMJFysAJjU0Nzc2MzIWFRQGBwcGIwYmNTQ2NjMyFhUUBgYjNjY1NCYjIgYVFBYzAiY1NDY2MzIWFzYzMhUUBwYVFBYzMjY3NjMyFhUUBwYGIyImJwYjNjY3Nw4CFRQWMwHpEhBPEBUWIRUYXAwG7EwnQSU1TCdBJRgcGhIUHBoS10pKe0UWDwUVFzEPFw8MEzYuDA8NDxMpXCshNw40TzooCSUqRyoZFgLrEg0OEE8QIRYSIAolBNdHPS1DJEc9LUMkWB4ZFhseGRYb/Y9aSVCPVxEWBCMVT3MtDxIxNw4YFSgWM0YtJ1RlNCu4AT1kOB8e//8AI//7AlcC1wAiAW0AAAADBa4CXwAAAAMAJP/7Aw4B1AAnADMAPQBNQEoXAQYCNiACBAUKAQAEA0wJAQUGBAYFBIAKCAIGBgJhAwECAjZNBwEEBABhAQEAADQATjQ0AAA0PTQ8MC4qKQAnACYmJCUkJgsJGyskFhUUBwYGIyImJwYGIyImNTQ2NjMyFhc2NjMyFhUUBgcWMzI2NzYzJDcGBhUUFjMyNjc3NgYVFTY2NTQmIwL/DxMlh01DXxsUTS5ETkqIWhYSBhlIKDpGY3YZRi1zKgwP/kIeUmAaFxkoCgqrMztEFRLfGBUoFi1MLysqMF9QUohQFB4XGUU7RWMdLj8zDmIxAWdbJSo2MzJ1Vj0CDjglExcAAAD//wAk//sDDgNCACIBhgAAAAMFpwLeAAAAAwA3//sCXwOsAB4AKAA3AI5ACyIXAgYFKwEAAwJMS7AJUFhAKQAGBQMFBgOACAQCAwAABwMAaQkBBQUCYQACAjVNCgEHBwFhAAEBNAFOG0AvAAYFBAUGBIAIAQQDBQQDfgADAAAHAwBpCQEFBQJhAAICNU0KAQcHAWEAAQE0AU5ZQBspKR8fAAApNyk2MjAfKB8nAB4AHhglIhYLCRorABYVFAYHBgcGBiMiJjU0EjYzMhYVFAYHFhYXNjc2MwAGBgc2NjU0JiMCNjcmJjU0NyMiBhUUFjMCUQ4ODzxIFG9DZVxAe1UuOD5IQ1QIL0EGCP7YLygKQk8PDRUwCB8hBAMpNysdATMaFBkbBRUDU2aakoEBL9VPP1KiWQVlSgMRAgIWd8x5eblIICL9HDQxFUQmDhhRRDk8AAAAAAEAIP/7AfEB0gAqAGy1DwEBAgFMS7AJUFhAJAABAgQCAXIABAMCBAN+AAICAGEAAAA2TQADAwVhBgEFBTQFThtAJQABAgQCAQSAAAQDAgQDfgACAgBhAAAANk0AAwMFYQYBBQU0BU5ZQA4AAAAqACkjJCkkJQcJGysWJjU0NjYzMhYVFAYjIiY1NDY3NjU0JiMiBgYVFDMyNjc2MzIWFRQHBgYjjW1AZjg3PSUeExcEAQUNDBcoGGUpXy4MDw0PEy+DPQVvW1F6QkEzKjoSEAcSBA8NDQ4pRip0NzcOGBUmGDo///8AIP/7AfEDQgAiAYkAAAADBacCMAAA//8AIP/7AfEDXAAiAYkAAAADBasCMAAAAAEAIP8GAfEB0gBHAL1ADDQBBQYkIAcDAwcCTEuwCVBYQCoABQYIBgVyCQEIBwYIB34ABwADAQcDaQIBAQAAAQBlAAYGBGEABAQ2Bk4bS7AuUFhAKwAFBggGBQiACQEIBwYIB34ABwADAQcDaQIBAQAAAQBlAAYGBGEABAQ2Bk4bQDIABQYIBgUIgAkBCAcGCAd+AAEDAgMBAoAABwADAQcDaQACAAACAGUABgYEYQAEBDYGTllZQBEAAABHAEYkKSQsJCMULAoJHiskFhUUBwYGBxYVFAYGIyInJjU0MzIXFjMyNjU0JiMiJjU0NzY3JiY1NDY2MzIWFRQGIyImNTQ2NzY1NCYjIgYGFRQzMjY3NjMB4g8TIlkwJy1VOSYYJygIBRsaKC0rJRocAQMGLTBAZjg3PSUeExcEAQUNDBcoGGUpXy4MD98YFSYYKjkNITkvSyoFByUtAQQhIhkdDhEGAw8HGFw7UXpCQTMqOhIQBxIEDw0NDilGKnQ3Nw4A//8AIP/7AfEDXAAiAYkAAAADBaoCLwAA//8AIP/7AfECsAAiAYkAAAADBaUCMAAAAAMAI//7AoQDrAAkAC0AOQCgS7AbUFhAEDQoAgQFMBwCAwQJAQADA0wbQBA0KAIEBTAcAgMECQEABgNMWUuwG1BYQCIHAQQFAwUEA4AIAQUFAmEAAgI1TQkGAgMDAGEBAQAANABOG0AsBwEEBQMFBAOACAEFBQJhAAICNU0AAwMAYQEBAAA0TQkBBgYAYQEBAAA0AE5ZQBkuLiUlAAAuOS44JS0lLAAkACMnKCMmCgkaKyQWFRQHBgYjIicGBiMiJjU0NjY3NhIzMhYVFAIHFhYzMjY3NjMCBgYHNjU0JiMANjcmNTQ3BgYVFDMCdQ8TKWIwTCgqPyo9T0R3ShNrVys5blwEGxUbOC8MD4kmGwZwDQn+8yYdCgI3STLfGBUoFjJHWTUkW0lQiVcIwgETTk9w/tSeOjIwOA4Ca4fad/SUJir9Fh8qNkMYNhFxRUkAAAIAIf/7AgYDnQA1AEEAfkARLSEXBAQCBBUBBQE4AQYFA0xLsCFQWEAoAAQDAgMEAoAAAgIDYQADAzVNAAUFAWEAAQE2TQcBBgYAYQAAADQAThtAJgAEAwIDBAKAAAMAAgEDAmkABQUBYQABATZNBwEGBgBhAAAANABOWUAPNjY2QTZAJiksJSYqCAkcKwAVFAYHFhYVFAYGIyImJjU0NjYzMhcmJwcGIyImNTQ3NjcmJyY1NDYzMhcWFhc2NzY3NjMyFwI2NyYmIyIGFRQWMwIGOkMdIDVqTDxUKjpjOy8gBh9aCQsVHwwpQyY+BigZEA0UOx4aGCgVCwsTDPc6BhAkEDA1KhsDSA4YOChBm1N4uGg7YDdMd0MUdVUvBScUEAcXI0NBCAcQGQcKRS8QEx0MBxX9D3JxEBFLSDY7AAD//wAj//sCmwOnACIDBAAAAQcFqQNZAdYACbECAbgB1rA1KwAAAgAj//sCVwM8AD0ASAC0S7AbUFhADicBBAUVAQkCCgEABwNMG0AOJwEGBRUBCQIKAQAKA0xZS7AbUFhALgsBCAkHCQgHgAYBBAADAgQDZwAFBTNNAAkJAmEAAgI2TQoBBwcAYgEBAAA0AE4bQDwABQYFhQAGBAaFCwEICQcJCAeAAAQAAwIEA2cACQkCYQACAjZNAAcHAGIBAQAANE0ACgoAYQEBAAA0AE5ZQBUAAEZEPz4APQA8KyUiVCIlIyYMCR4rJBYVFAcGBiMiJicGIyImNTQ2NjMyFzcjIiY1NDYzMhcWMzc2MzIWFRQHBzMyFhUUBgcGBwYVFBYzMjY3NjMlDgIVFBYzMjY3AkgPEylcKyE3DjRPPkpKeUMXDBGPHBIUHjMtJhMPCUUfHAITFBMTJCojGRAPDBM2LgwP/wAqRyoZFhYoCd8YFSgWM0YtJ1RaSU+QVxV8FRkaHgMCYj4UFQUMWxYRGh8Hqo9YJQ8SMTcOmAE9ZDgfHjQrAAAAAwAj//EEAQNcABkAbQB4A5JLsAlQWEAQOwkCAgc0AQkGKSQCAwgDTBtLsBdQWEAQOwkCAgc0AQ8GKSQCAwgDTBtLsBlQWEAQOwkCAgc0AQ8LKSQCAwgDTBtLsBtQWEAQOwkCAgc0AQ8LKSQCBAgDTBtAEDsJAgIHNAEPCykkAgQNA0xZWVlZS7AJUFhAOQACBwYHAgaAEQEOCQgJDgiAAQEAADNNAAcHM00PAQkJBmEMCwoDBgY2TRANAggIA2IFBAIDAzQDThtLsA5QWEBFAAIHBgcCBoARAQ4JCAkOCIABAQAAOU0ABwczTQAPDwZhDAsKAwYGNk0ACQkGYQwLCgMGBjZNEA0CCAgDYgUEAgMDNANOG0uwEFBYQEUAAgcGBwIGgBEBDgkICQ4IgAEBAAAzTQAHBzNNAA8PBmEMCwoDBgY2TQAJCQZhDAsKAwYGNk0QDQIICANiBQQCAwM0A04bS7AXUFhARQACBwYHAgaAEQEOCQgJDgiAAQEAADlNAAcHM00ADw8GYQwLCgMGBjZNAAkJBmEMCwoDBgY2TRANAggIA2IFBAIDAzQDThtLsBlQWEBIAAIHBgcCBoARAQ4JCAkOCIABAQAAOU0ABwczTQALCzZNAA8PBmEMCgIGBjZNAAkJBmEMCgIGBjZNEA0CCAgDYgUEAgMDNANOG0uwG1BYQFMAAgcGBwIGgBEBDgkICQ4IgAEBAAA5TQAHBzNNAAsLNk0ADw8GYQwKAgYGNk0ACQkGYQwKAgYGNk0QDQIICARiBQEEBDRNEA0CCAgDYgADAzQDThtLsCpQWEBeAAcAAgAHAoAAAgYAAgZ+EQEOCQgJDgiAAQEAADlNAAsLNk0ADw8GYQwKAgYGNk0ACQkGYQwKAgYGNk0ACAgEYgUBBAQ0TRABDQ0EYQUBBAQ0TRABDQ0DYQADAzQDThtLsDBQWEBZAQEABwCFAAcCB4UAAgYChREBDgkICQ4IgAALCzZNAA8PBmEMCgIGBjZNAAkJBmEMCgIGBjZNAAgIBGIFAQQENE0QAQ0NBGEFAQQENE0QAQ0NA2EAAwM0A04bQFUBAQAHAIUABwIHhQACBgKFAAsGDwYLchEBDgkICQ4IgAADDQNVAA8PBmEMCgIGBjZNAAkJBmEMCgIGBjZNAAgIBGIFAQQENE0QAQ0NBGEFAQQENAROWVlZWVlZWVlAIBoadnRvbhptGmxpZ11bWFRTUU1LKyQlIyMpJyYkEgkfKwEmNTQ2MzIWFxc3NjYzMhYVFAcHBgYjIiYnABYVFAcGBiMiJicGIyImJwYjIiY1NDY2MzIXNjc2MzIWFRQHBwIHBhUUFjMyNjc2NjcHBiY1NDYzMhcWFjMyNzY2MzIWFRQGBwYGFRQWMzI2NzYzJQ4CFRQWMzI2NwJnAyEXFxwEF1cPIhUVGQtwEi0fHiIJAV8PEy+LV0dmGUs4ITcONE8+Skp5QxcMGxMJRR8cAhM1GxAPDBAsHw5mVaQWFxcULk0QVR0KHAUdChAVHiBbeDQzOHMuDA/9VipHKhkWFigJAxIMChkbFx+xsR8WExIRE8EfHyQn/oEYFSUZPUYrJkctJ1RaSU+QVxXHeD4UFQUMW/76mlglDxIkJDVWKAQBIRcYJQcBBggBCBwdICQOJ1ksHCQ4OQ6YAT1kOB8eNCsAAAIAIf/7AgoB0gAbACUAO0A4HhQCAgMBTAUBAwQCBAMCgAYBBAQBYQABATZNAAICAGEAAAA0AE4cHAAAHCUcJAAbABomJSYHCRkrJBYVFAcGBiMiJjU0NjYzMhYVFAYHFjMyNjc2MyQGFRU2NjU0JiMB+w8TJYdNaXQ6Z0E6RmN2GUYtcyoMD/7fMztEFRLfGBUoFi1McmNFd0ZFO0VjHS4/Mw6RVj0CDjglExcAAAD//wAh//sCCgNCACIBlAAAAAMFpwI1AAD//wAh//sCCgL0ACIBlAAAAAMFrAI1AAD//wAh//sCCgNcACIBlAAAAAMFqwI1AAD//wAh//sCCgNcACIBlAAAAAMFqgI0AAD//wAh//sCRANrACIBlAAAAQcF6QI1//sACbECArj/+7A1KwD//wAh/xwCCgNcACIBlAAAACMFtQJUAAAAAwWqAjQAAP//AAn/+wIKA2sAIgGUAAABBwXqAjX/+wAJsQICuP/7sDUrAP//ACH/+wJMA2EAIgGUAAABBwXrAjX/+wAJsQICuP/7sDUrAP//ACH/+wIKA4IAIgGUAAABBwXsAjX/+wAJsQICuP/7sDUrAP//ABr/+wIKA0QAIgGUAAAAAwWxAjUAAP//ACH/+wIKArEAIgGUAAAAAwWkAjUAAP//ACH/+wIKArAAIgGUAAAAAwWlAjUAAP//ACH/HAIKAdIAIgGUAAAAAwW1AlQAAP//ACH/+wIKA0MAIgGUAAAAAwWmAjUAAP//ACH/+wIKAysAIgGUAAAAAwWwAjQAAP//ACH/+wIKAvQAIgGUAAAAAwWyAjUAAP//ACH/+wIKAnIAIgGUAAAAAwWvAjQAAAACACH/BgIKAdIAMQA7AJFLsBJQWEALNCoCBAUdAQAEAkwbQAs0KgIEBR0BAQQCTFlLsBJQWEAkBwEFBgQGBQSAAAQABgQAfgEBAAACAAJmCAEGBgNhAAMDNgZOG0AqBwEFBgQGBQSAAAQBBgQBfgABAAYBAH4AAAACAAJmCAEGBgNhAAMDNgZOWUAUMjIAADI7MjoAMQAwJislIisJCRsrJBYVFAcGBwYGFRQWMzI3NjMyFRQHBgYjIiY1NDY3JiY1NDY2MzIWFRQGBxYzMjY3NjMkBhUVNjY1NCYjAfsPEzZrLikkGhoVEQoaLwwnEEVRGRlRWTpnQTpGY3YZRi1zKgwP/t8zO0QVEt8YFSgWQygROx8fHwcGJSgQBAZHPSQ4GQxuV0V3RkU7RWMdLj8zDpFWPQIOOCUTFwD//wAh//sCCgLXACIBlAAAAAMFrgI1AAAAAgAo//sBtQHTAB4AJABqS7AJUFhAIAABAAUGAQVnAwECAgRhBwEEBDZNCAEGBgBhAAAANABOG0AnAAMCAQIDAYAAAQAFBgEFZwACAgRhBwEEBDZNCAEGBgBhAAAANABOWUAVHx8AAB8kHyMhIAAeAB0iIiYlCQkaKwAWFRQGBiMiJjU0NzY2MzMmJiMiBwYjIiY1NDc2NjMSNyMGFjMBTGkyYERZXgIDJiTDBDUxMS8JCxAQIhVIKT8RlwQoHgHTd2tGcEBfSBQLGiI2MREEFhIsFAwQ/oVVLSgAAAIANP7EAdsDrAAuADcAhEuwIVBYQAoyAQQHBQEABAJMG0AKMgEGBwUBAAQCTFlLsCFQWEAeCAYFAwQAAAMEAGkAAwABAwFlCQEHBwJhAAICNQdOG0AkCAEGBwQEBnIFAQQAAAMEAGoAAwABAwFlCQEHBwJhAAICNQdOWUAVLy8AAC83LzYALgAtIicoJSYiCgkcKwAVFCMiJxYWFRQGIyImNTQSEjMyFhUUAQYVFBYzMjU0JicmNjYzMhcWMzI3NjYzAgYGBzY2NzQjAdt8GC0NEUY5SD1TkVcvNf7nCg4QHhUSARMcCxQcCQwoMQgSCXc1NBNQVgEZARgqTwk+lzFscszOwAGLAQNUR+v+62JKZ9loTpJRDSgeAgEHAQICMXrJcFvFVj0AA//+/jkCTAHUAC8AOgBDAGJAXx8BBQMrAQYEEgEBBj0BBwEETAADAgUCAwWACAEEBQYFBAaAAAUFAmEAAgI2TQkBBgYBYQABATRNCgEHBwBhAAAAOABOOzswMAAAO0M7QjA6MDk0MwAvAC4jJSgqCwkaKyQWFRQGBwYHBwYGIyImNTQ2NzcGBiMiJjU0NjYzMhYXNjMyFhUUBwYHBgYHNjc2MwQ2NzcOAhUUFjMCNjcGBhUUFjMCPQ8OD1YoQCZ7XzNAcJoGETcbPkpKe0UWDwUTGRkVAQQVBAkFTUcNCv62KgkgKUYqGRY6Px1NRA0P3RkTFxoKOhwrz+0/M0ejdycbHVpJUI9XERYEDxYMBx9+GDkgPC4IfTg0qwE9ZDgfHv46eINCaigRFgD////+/jkCTAL0ACIBqgAAAAMFrAJfAAD////+/jkCTANcACIBqgAAAAMFqwJfAAD////+/jkCTANcACIBqgAAAAMFqgJeAAD////+/jkCTAMAACIBqgAAAAMFswJfAAD////+/jkCTAKwACIBqgAAAAMFpQJfAAAAAgA1//sCdwOsADkAQwBPQEw9JgIBBCgBBgECTAABBAYEAQaACAEGBQQGBX4JAQcHA2EAAwM1TQAEBDZNAAUFAGICAQAANABOOjoAADpDOkIAOQA4JiooJCcmCgkcKyQWFRQHBgYjIiY1NDc2NTQjIgYGBwYjIiY1NDc3NBI2MzIWFRQGBwYVPgIzMhUUBwYVFDMyNjc2MwAGBgc2NjU0JiMCaA8TLmE+MzQODQsNMDAPE0seEwEBP3tWLjl2hQMhUU8hQRYTHRQ3LgwP/sUsKQ0+UQ4N3xgVKBY1RDs4HEg/GBBDbj1QKzggE1CaAU7jTz9l2ZE0N1VrLkEnZlccKDE3DgJqZ69nSaxGICIAAAABADX/+wJ3AzwATQCLQAseAQYDPBwCCQECTEuwG1BYQC8AAQcJBwEJgAoBCQgHCQh+BQEDAAYHAwZoAAQEM00ABwc2TQAICABiAgEAADQAThtALwAEAwSFAAEHCQcBCYAKAQkIBwkIfgUBAwAGBwMGaAAHBzZNAAgIAGICAQAANABOWUASAAAATQBMJiUkVCUqJScmCwkfKyQWFRQHBgYjIiY1NDc2NTQjIgYGBwYGIyImNTQ3NjcmJjU0MzIXNjc2NjMyFRQHBzI3NjMyFhUUBiMjBgc+AjMyFRQHBhUUMzI2NzYzAmgPEytjPzM0Dg0LDTAwDwsdHyQgBQkqIBwmIAwJDgwlHzsEGQ4gMh8eFCMfhyYeIVFPIUEWEx0UNy4MD98YFSgWNUQ7OBxIPxgQQ249LyFBTSZGhccGFxIxASYuKR8qDQ1bAgIcFxoZl8BVay5BJ2ZXHCgxNw4AAAD//wA1//sCdwT5ACIBsAAAAQcFwgJ6AdYACbECAbgB1rA1KwAAAgAv//sBdwKwAAsAKQA7QDgABAIDAgQDgAAABgEBAgABaQACAjZNAAMDBWIHAQUFNAVODAwAAAwpDCgjIR4cFRMACwAKJAgJFysSJjU0NjMyFhUUBiMCJjU0Njc2NjMyFRQHBhUUFjMyNjc2MzIWFRQHBiOJKjcpJS40K0k7FxIJHiEzExgQExI2LQwPDQ8TY1YCFCcjIy8kISgv/edcTC2NPSAYIhlbbiceIDI2DhgVKBZ5AAAAAAEAL//7AXcB0gAdAChAJQACAAEAAgGAAAAANk0AAQEDYgQBAwM0A04AAAAdABwjJycFCRkrFiY1NDY3NjYzMhUUBwYVFBYzMjY3NjMyFhUUBwYjajsXEgkeITMTGBATEjYtDA8NDxNjVgVcTC2NPSAYIhlbbiceIDI2DhgVKBZ5AAAA//8AL//7AXcDQgAiAbQAAAADBacB0gAA////6P/7AYMC9AAiAbQAAAADBawB0gAA/////v/7AXcDXAAiAbQAAAADBaoB0QAA////t//7AXcDRAAiAbQAAAADBbEB0gAA//8AAf/7AXcCsQAiAbQAAAADBaQB0gAA//8AL//7AXcCsAAiAbQAAAADBaUB0gAA//8ABf8cAXcCsAAiAbMAAAADBbUB2wAA////8//7AXcDQwAiAbQAAAADBaYB0gAA//8AL//7AXcDKwAiAbQAAAADBbAB0QAA////6P/7AYMC9AAiAbQAAAADBbIB0gAA//8ACf/7AXcCcgAiAbQAAAADBa8B0QAAAAIAGv8GAXcCsAALAD8AkUuwElBYtREBBQMBTBu1EQEGAwFMWUuwElBYQCcABAIDAgQDgAADBQIDBX4AAAgBAQIAAWkGAQUJAQcFB2YAAgI2Ak4bQC0ABAIDAgQDgAADBgIDBn4ABgUCBgV+AAAIAQECAAFpAAUJAQcFB2YAAgI2Ak5ZQBoMDAAADD8MPjk3NTMoJiMhGhgACwAKJAoJFysSJjU0NjMyFhUUBiMCJjU0NjcmNTQ2NzY2MzIVFAcGFRQWMzI2NzYzMhYVFAcGBwYGFRQWMzI3NjMyFRQHBgYjgSo3KSUuNCtAUSodMhcSCR4hMxMYEBMSNi0MDw0PEzVYLikkGhoVEQoaLwwnEAIUJyMjLyQhKC/88kc9KksTKGktjT0gGCIZW24nHiAyNg4YFSgWQTMaMBsdHgcGJSgQBAYA////3P/7AY8C1wAiAbQAAAADBa4B0gAAAAP/Hf45AWsCsAALAC4ANgBHQEQxKgIFBAFMBwEEAwUDBAWAAAAGAQEDAAFpAAMDNk0IAQUFAmEAAgI4Ak4vLwwMAAAvNi81DC4MLSUjFxUACwAKJAkJFysSJjU0NjMyFhUUBiMSFhUUBgcGBwYGIyImNTQ2Nzc2NzY3NjYzMhYVFAcHNjc2MwA2NwYGFRQzcSo3KSUuNCvBDw4PRnUnfGA0P26YBw4IBg0EJCUeEyEKUEINCv5mPhtMQxwCFCcjIy8kISgv/skZExcaCi5R0O4/M0ehdjNgXTZrHRsSEC7QRTwsCP29doNBaSgnAAAAAAL/Hf45AWsB0gAiACoANUAyJR4CAwIBTAQBAgEDAQIDgAABATZNBQEDAwBhAAAAOABOIyMAACMqIykAIgAhLCkGCRgrJBYVFAYHBgcGBiMiJjU0Njc3Njc2NzY2MzIWFRQHBzY3NjMANjcGBhUUMwFcDw4PRnUnfGA0P26YBw4IBg0EJCUeEyEKUEINCv5mPhtMQxzdGRMXGgouUdDuPzNHoXYzYF02ax0bEhAu0EU8LAj9vXaDQWkoJwD///8d/jkBawNcACIBwwAAAAMFqgHQAAAAAgA3//sCjgOsADoARABRQE4+AQEEKScCBgEyAQUGA0wIAQYBBQEGBYAJAQcHA2EAAwM1TQABAQRhAAQENk0ABQUAYQIBAAA0AE47OwAAO0Q7QwA6ADknKSYlKSYKCRwrJBYVFAcGBiMiJjU0NzY2NTQmIyIGBgcGBiMiJiY1NBI2MzIWFRQGBwYVNjYzMhYVFAYHFhYzMjY3NjMABgYHNjY1NCYjAn8PEy1cP01eKCwmDwsbQTgQCx0fHx0KP3tWLjl2hQMwfDYyPThEBCkdHzovDA/+riwpDT5RDg3fGBUoFjdCWEknERMrHxISTntBLyEtXluaAU7jTz9l2ZE0N31xRDI3XCQbITA4DgJqZ69nSaxGICIA//8AN/7MAo4DrAAiAcUAAAADBbcCXQAAAAEAMv/7AlIB0gBAAHhACxwBAgM7EAIEBQJMS7AJUFhAJgACAwUDAnIABQQDBQR+AAMDAGEBAQAANk0ABAQGYQgHAgYGNAZOG0AnAAIDBQMCBYAABQQDBQR+AAMDAGEBAQAANk0ABAQGYQgHAgYGNAZOWUAQAAAAQAA/JiMlKCQqJgkJHSsWJjU0NzY2MzIWFRQHDgIHNjYzMhYVFAYjIiY1NDY3NjU0IyIGBhUUFjMyNjc2MzIWFRQHBgYjIiYmJwYHBgYjUR8lCSklFBAPAg0LAiRuTjQ7JR4TFwQBBRoUJhcyLyU6MwwPDQ8TLVo5L00wBwINCx0eBVBYgnUdGwoOEDgHMkMojHhBMyo6EhAHEgQPDRspRSg2QTE9DhgVKBY2Qyk6GwgwKB4AAAIAN//7AccDrAAcACUAPkA7IAEDBBQBAgMCTAUBAwQCBAMCgAYBBAQBYQABATVNAAICAGEAAAA0AE4dHQAAHSUdJAAcABsnJSYHCRkrJBYVFAcGBiMiJjU0EjYzMhYVFAIHFhYzMjY3NjMCBgYHNjY1NCMBuA8TK2VAWFU/e1UwN4RxByAaKT4wDA+SOiwCR1Qc3xgVKBY1RKB/egE44FlTd/7GmikjLzkOAmqm9nF162FM//8AN//7AlME1gAiAcgAAAEHBcACeAHWAAmxAgG4AdawNSsA//8ALP/7AbQDpwAiAwYAAAEHBakCcgHWAAmxAQG4AdawNSsA//8AN/7MAccDrAAiAcgAAAADBbcCJgAAAAIAMf/7AewDpwAkADAAOUA2AAIFAQUCAYAABAcBBQIEBWoAAAA1TQABAQNhBgEDAzQDTiUlAAAlMCUvKykAJAAjIyspCAkZKxYmNTQ3NhI3NjYzMhYVFAcGAgcGFRQWMzI2NzYzMhYVFAcGBiMSJjU0NjMyFhUUBiOXZgMKTiMLJh8eHQQkUAoHKy4xTS0MDw0PEytzRiMoNSUgKzIlBWdsGhxcAX+AKCAUFg0Nif6aOysoPj8yNg4YFSgWM0YBgigiIy8kIScwAAAAAAQAN/45As8DrAA6AEMATwBXAHBAbT4BBQQ2IQIDBRIBAQNSAQkBBEwKAQUEAwQFA4AABwwBCAQHCGkLAQYGAmEAAgI1TQAEBDZNAAMDAWEAAQE0TQ0BCQkAYQAAADgATlBQREQ7OwAAUFdQVkRPRE5KSDtDO0IAOgA5KiclKCkOCRsrJBYVFAYHBgcGBiMiJjU0Nj8CBiMiJjU0EjYzMhYVFAIHFhYzMjY3Njc2NzY3NjYzMhYVFAcHNjc2MwAGBgc2NjU0IxImNTQ2MzIWFRQGIwI2NwYGFRQzAsAPDg9GdSd8YDNAbpgHAk9dWFU/e1UwN4RxByAaKT4wCAkDBAQLBCQlHhMhClBCDQr+ZjosAkdUHKUqNyklLjQr5j4bTEMc3RkTFxoKLlHQ7j8zR6F2MxBRoH96ATjgWVN3/saaKSMvOQkEGCkkVx0bEhAu0EU8LAgCbKb2cXXrYUz+yycjIy8kISgv/IZ2g0FpKCcAAwA3//sCUgP1ABkANgA+ANtACjoBBwguAQYHAkxLsAlQWEAxAAIFCAUCCIAKAQcIBggHBoAJAQMBAQAFAwBpCwEICAVhAAUFM00ABgYEYQAEBDQEThtLsBVQWEAxAAIFCAUCCIAKAQcIBggHBoAJAQMBAQAFAwBpCwEICAVhAAUFOU0ABgYEYQAEBDQEThtAOAAAAQUBAAWAAAIFCAUCCIAKAQcIBggHBoAJAQMAAQADAWkLAQgIBWEABQU5TQAGBgRhAAQENAROWVlAHjc3GhoAADc+Nz0aNho1MjApJyIgABkAGCUiJAwJGSsAFhUUBiMiJyYjIgYHDgIjIiY1NDY3NjYzEhYVFAcGBiMiJjU0EjYzMhYVFAIHFhYzMjY3NjMCBgYHNjU0IwIGTB0YDhcqGEJaLAUcFgkVFx4jMYE/BA8TK2VAWFU/elMxOYZvByAaKT4wDA+TOysBmxwD9SodFhgFBxgUAgwFGREWIREYHvzqGBUoFjVEo4ZxAQe3UVJr/veFKiQvOQ4CFIXQatajRgABADL/+wNpAdIAUgBBQD4aDwIEBgFMCAEGAAQABgSAAAQDAAQDfgIBAgAANk0AAwMFYgoJBwMFBTQFTgAAAFIAUSclJyYjJigqJgsJHysWJjU0NzY2MzIWFRQHBgYHPgIzMhYVFAcGBzY2MzIVFAcGFRQzMjY3NjMyFhUUBwYGIyImNTQ3NjU0IyIGBgcGBiMiJjU0NzY1NCMiBgYHBgYjUR8lCSklFBAPCgwEG0tPIyMdEwgDMno1QRYTHRQ3LgwPDQ8TK2M/MzQODQsNMDAPCx0gISEKCAsPLisNCx0fBVBYgnUdGwoOEDgoOyxObDUgISBUJBJ7cEEnZlccKDE3DhgVKBY1RDs4HEg/GBBDbj0wID8tJkhAFBBIcDYvIQABADL/+wJxAdIAOAA6QDcPAQMFAUwABQADAAUDgAADAgADAn4BAQAANk0AAgIEYgcGAgQENAROAAAAOAA3JyYjJiomCAkcKxYmNTQ3NjYzMhYVFAcGBgc+AjMyFRQHBhUUMzI2NzYzMhYVFAcGBiMiJjU0NzY1NCMiBgYHBgYjUR8lCSklFBAPCgwEIVJPIUEWEx0UNy4MDw0PEytjPzM0Dg0LDS8xDwsdHwVQWIJ1HRsKDhA4KDwsVmwuQSdmVxwoMTcOGBUoFjVEOzgcSD8YEENuPS8hAP//ADL/+wJxA0IAIgHQAAAAAwWnAmUAAP////v/+wJxAwAAIwXU/vIAAAACAdAAAP//ADL/+wJxA1wAIgHQAAAAAwWrAmUAAP//ADL+zAJxAdIAIgHQAAAAAwW3Al0AAAABABz+vQJwAdIARwCNQAo2AQkEQAEICQJMS7AMUFhAMAAEBgkGBAmACgEJCAYJCH4AAgADAwJyAAMAAQMBZgcBBgY2TQAICABiBQEAADQAThtAMQAEBgkGBAmACgEJCAYJCH4AAgADAAIDgAADAAEDAWYHAQYGNk0ACAgAYgUBAAA0AE5ZQBIAAABHAEYmKiYlJiMkJBYLCR8rJBYVFAcGBiMiJwYGIyImJyY2MzIWFxYzMjY3NzY1NCMiBgYHBgYjIiY1NDc2NjMyFhUUBwYGBz4CMzIVFA8CFjMyNjc2MwJhDxMrYz8IDi1wSTU8BQIlFw4RAQcbJE8qBQkLDTAwDwsdHyYfJQkpJRQQDwoMBCFSTyFBHgcSDgkhPC8MD98YFSgWNUQCop5HOhkdCgpNyu0cLxQQQ249LyFQWIJ1HRsKDhA4KDwsVmwuQSeHI1QDMDgOAAAAAAMAMv45A1sCsAALAF8AZwByQG8/AQoEWwEICh0BAwhiAQsDBEwABAYKBgQKgA0BCggGCgh+AAAMAQEGAAFpCQcCBgY2TQAICANiBQEDAzRNDgELCwJhAAICOAJOYGAMDAAAYGdgZgxfDF5WVExKREI4NjAuKScgHhcVAAsACiQPCRcrACY1NDYzMhYVFAYjEhYVFAYHBgcGBiMiJjU0Njc3BiMiJjU0NzY1NCMiBgYHBgYjIiY1NDc2NjMyFhUUBwYGBz4CMzIVFAcGFRQzMjY3Njc2NzY2MzIWFRQHBzY3NjMANjcGBhUUMwJhKjcpJS40K8EPDg9GdSd8YDNAbpgFQUYzNA4NCw0vMQ8LHR8mHyUJKSUUEA8KDAQhUk8hQRYTHRMwJgMECggEJCUeEyEKUEINCv5mPhtMQxwCFCcjIy8kISgv/skZExcaCi5R0O4/M0ehdiUzOzgcSD8YEENuPS8hUFiCdR0bCg4QOCg8LFZsLkEnZlccKCksFypePR0bEhAu0EU8LAj9vXaDQWkoJwD//wAy//sCcQLXACIB0AAAAAMFrgJlAAAAAgAh//sCSQHTABgAJwBxtRsBAAMBTEuwCVBYQCAHBAIDAAAGAwBpAAUFAmEAAgI2TQgBBgYBYQABATQBThtAJwcBBAUDBQQDgAADAAAGAwBpAAUFAmEAAgI2TQgBBgYBYQABATQBTllAFRkZAAAZJxkmIiAAGAAXEiYiFQkJGisAFhUUBwYHBgYjIiYmNTQ2NjMyFhc2NzYzBDY3JiY1NDcjIgYVFBYzAjsOHTxIE3BHPFUsOmY+TF0IL0EIBv7YLwgfIQMFKDUrHQEzGhQwCRUDVGU6YDhMd0NpTQMRAs40MRVEJhAQTUY3Ov//ACH/+wJJA0IAIgHYAAAAAwWnAjEAAP//ACH/+wJJAvQAIgHYAAAAAwWsAjEAAP//ACH/+wJJA1wAIgHYAAAAAwWqAjAAAP//ACH/+wJJA2sAIgHYAAABBwXpAjH/+wAJsQICuP/7sDUrAP//ACH/HAJJA1wAIgHYAAAAIwW1AkgAAAADBaoCMAAA//8ABf/7AkkDawAiAdgAAAEHBeoCMf/7AAmxAgK4//uwNSsA//8AIf/7AkkDYQAiAdgAAAEHBesCMf/7AAmxAgK4//uwNSsA//8AIf/7AkkDggAiAdgAAAEHBewCMf/7AAmxAgK4//uwNSsA//8AFv/7AkkDRAAiAdgAAAADBbECMQAA//8AIf/7AkkCsQAiAdgAAAADBaQCMQAA//8AIf/7AkkDVwAiAdgAAAAjBaQCMQAAAQcFrwJMAOUACLEEAbDlsDUrAAD//wAh//sCSQNWACIB2AAAACMFpQIxAAABBwWvAkwA5AAIsQMBsOSwNSsAAP//ACH/HAJJAdMAIgHYAAAAAwW1AkgAAP//ACH/+wJJA0MAIgHYAAAAAwWmAjEAAP//ACH/+wJJAysAIgHYAAAAAwWwAjAAAAACACH/+wJJAlEAJgA1ANFLsCFQWEAKIAEHAikBAAUCTBtACiABBwMpAQAFAkxZS7AJUFhAJgAEAgSFCQYCBQAACAUAagAHBwJhAwECAjZNCgEICAFhAAEBNAFOG0uwIVBYQC0ABAIEhQkBBgcFBwYFgAAFAAAIBQBqAAcHAmEDAQICNk0KAQgIAWEAAQE0AU4bQDEABAIEhQkBBgcFBwYFgAAFAAAIBQBqAAMDNk0ABwcCYQACAjZNCgEICAFhAAEBNAFOWVlAFycnAAAnNSc0MC4AJgAlFyMiJiIVCwkcKwAWFRQHBgcGBiMiJiY1NDY2MzIXFjMyNjc2MzIWBwYGBxYXNjc2MwQ2NyYmNTQ3IyIGFRQWMwI7Dh08SBNwRzxVLDpmPiAaDA0bIAkHJhoaAwUzKxgHL0EIBv7YLwgfIQMFKDUrHQEzGhQwCRUDVGU6YDhMd0MEAzAuJyEhM0wTKDgDEQLONDEVRCYQEE1GNzoAAP//ACH/+wJJA0IAIgHoAAAAAwWnAh0AAP//ACH/HAJJAlEAIgHoAAAAAwW1AkgAAP//ACH/+wJJA0MAIgHoAAAAAwWmAh0AAP//ACH/+wJJAysAIgHoAAAAAwWwAhwAAAADACH/+wJJAtcAIQBIAFcBbkuwEFBYQA8gDwIIAUIBCwZLAQQJA0wbS7AhUFhADyAPAggCQgELBksBBAkDTBtADyAPAggCQgELB0sBBAkDTFlZS7AJUFhAMgIBAQgBhQAIAAiFAwEABgCFDQoCCQAEDAkEagALCwZhBwEGBjZNDgEMDAViAAUFNAVOG0uwEFBYQDkCAQEIAYUACAAIhQMBAAYAhQ0BCgsJCwoJgAAJAAQMCQRqAAsLBmEHAQYGNk0OAQwMBWIABQU0BU4bS7AhUFhAQQABAgGFAAIIAoUACAAIhQAAAwCFAAMGA4UNAQoLCQsKCYAACQAEDAkEagALCwZhBwEGBjZNDgEMDAViAAUFNAVOG0BFAAECAYUAAggChQAIAAiFAAADAIUAAwYDhQ0BCgsJCwoJgAAJAAQMCQRqAAcHNk0ACwsGYQAGBjZNDgEMDAViAAUFNAVOWVlZQBxJSSIiSVdJVlJQIkgiR0VEIyImIhonJichDwkfKxIGIyImNTQ2NzY2MzIWFxc3NjYzMhYVFAYHBgYjIiYnJwcAFhUUBwYHBgYjIiYmNTQ2NjMyFxYzMjY3NjMyFgcGBgcWFzY3NjMENjcmJjU0NyMiBhUUFjOJFQsPFhEPEyYWDhcTWyUGFQsPFhAPFCUWDhgTWiYBrA4dPEgTcEc8VSw6Zj4gGgwNGyAJByYaGgMFMysYBy9BCAb+2C8IHyEDBSg1Kx0CLgsVEg4lGiEfChBKPwsLFRIOJBshHwsPSj/++hoUMAkVA1RlOmA4THdDBAMwLichITNMEyg4AxECzjQxFUQmEBBNRjc6//8AIf/7AkkDRAAiAdgAAAADBagCMQAA//8AIf/7AkkC9AAiAdgAAAADBbICMQAA//8AIf/7AkkCcgAiAdgAAAADBa8CMAAAAAIAIf8GAkkB0wAsADsA00uwElBYQAovAQMBBAEECAJMG0AKLwEDAQQBBQgCTFlLsAlQWEAmCgEIAwQDCASAAgEBAAMIAQNpBQEECQEGBAZmAAcHAGEAAAA2B04bS7ASUFhALQACBwEHAgGACgEIAwQDCASAAAEAAwgBA2kFAQQJAQYEBmYABwcAYQAAADYHThtAMwACBwEHAgGACgEIAwUDCAWAAAUEAwUEfgABAAMIAQNpAAQJAQYEBmYABwcAYQAAADYHTllZQBctLQAALTstOjY0ACwAKyInFSISKgsJHCsWJjU0NyYmNTQ2NjMyFhc2NzYzMhYVFAcGBwYHBgYVFBYzMjc2MzIVFAcGBiMCNjcmJjU0NyMiBhUUFjPNUTNESjpmPkxdCC9BCAYNDh08SBdXMSckGhoVEQoaLwwnEAwvCB8hAwUoNSsd+kc9RTIRcUpMd0NpTQMRAhoUMAkVA2I+IzkdHR4HBiUoEAQGAV80MRVEJhAQTUY3OgAAAAMAIf9+AlECTwAnAC4ANQB8QBIzKyADBQMjAQAFNSkRAwEAA0xLsAlQWEAnAAQDAwRwBgEFAwADBQCAAAABAwABfgACAQECcQADAzZNAAEBNAFOG0AlAAQDBIUGAQUDAAMFAIAAAAEDAAF+AAIBAoYAAwM2TQABATQBTllADgAAACcAJyMZIxIVBwkbKwAWFRQHBgcGBgcHBgYjIiY3NyYmNTQ2Njc3NjYzMhYHBxYWFzY3NjMEFzc3BgYVFjY1NCcHBwJDDh08RRNuSBECGA8PEwIUQEM4YDwRAhgPDxMCFDhCBi4/Bgj+ZR0ZEh8phScgERoBMxoUMAkVA1BkBWQMDQ0MbBNxRkp2RAJjDA0NDGwRXz0EEAKiHYhtCUlBaEs/Rh1cmgD//wAh/34CUQNCACIB8gAAAAMFpwHXAAD//wAh//sCSQLXACIB2AAAAAMFrgIxAAD//wAh//sCSQN9ACIB2AAAACMFrgIxAAABBwWvAlEBCwAJsQMBuAELsDUrAAADACH/+wMdAdMAJwAxAD0A5kuwJlBYQA8XAQYCKiACBAUKAQAEA0wbQA8XAQYCKiACCAUKAQAEA0xZS7AhUFhAJAkBBQYEBgUEgAcKAgYGAmEDAQICNk0LCAIEBABhAQEAADQAThtLsCZQWEAuCQEFBwQHBQSACgEGBgJhAwECAjZNAAcHAmEDAQICNk0LCAIEBABhAQEAADQAThtAOAkBBQcIBwUIgAoBBgYCYQMBAgI2TQAHBwJhAwECAjZNCwEICABhAQEAADRNAAQEAGEBAQAANABOWVlAHDIyKCgAADI9Mjw4NigxKDAAJwAmJiMmJCYMCRsrJBYVFAcGBiMiJicGBiMiJiY1NDY2MzIXNjYzMhYVFAYHFjMyNjc2MyQGFRU2NjU0JiMANjU0JiMiBhUUFjMDDg8TJYdNOVYcHEspOVIqOmM7VDIdTSo8R2N2GUYtcyoMD/7fMztEFRL+/zEoGiQxIx7fGBUoFi1MJiIiJjtgN0x3Q0giJUU7RWMdLj8zDpFWPQIOOCUTF/71TkU2O05FODkAAAAAA/+J/jcCYgHYAC4AOwBEAFpAVx4BBwM3AQYHJxQCBQY+OwkDAAUETAkBBgcFBwYFgAAHBwNhBAEDAzZNAAUFAGEBAQAANE0KAQgIAmEAAgI4Ak48PAAAPEQ8QzY0AC4ALSYmKSISJgsJHCskFhUUBwYGIyInBgcGAiMiJjU0Ejc0JyY2MzIWFxQXNjYzMhYVFAYHFjMyNjc2MwQ2NjU0JiMiBwYVFAcCNjcGBhUUFjMCUw8TK2M/NSE5Pg1cWTY0Wl4CATAkFRMBASA+IzhHIh4VDiE8LwwP/pg9JBgUJDMBAaQkBSsyDwrfGBUoFjVEJiUBwf79TkViAQWdkjkdIhEZGQwoI1pJNWQpBjA4Dnw/XTMeH0wsVS4Z/j7rr2S2PiAiAAIAGP6xAn0DEAAyADsAUkBPHwEDAiMBBQYrAQQFOwkCAAQLAQEABUwAAgMChQcBBQYEBgUEgAABAAGGAAYGA2EAAwM2TQAEBABhAAAANABOAAA4NgAyADElKCkoJggJGyskFhUUBwYGIyInBgcGFRcUBiMiJjU0Ejc2EzY2MzIWFRQHBgc2NjMyFhUUBxYzMjY3NjMENjU0IyIGBgcCbg8TK2M/OiJHZAIBJxwcHgsNFzgIJRshHgQxJCZkNi09QxURITwvDA/+m10eFzk1Ed8YFSgWNUQtKQpeLIAgGhYbaAEfe9sBCSggFBYGFMjpWF9LRn1UBzA4DnpmSTxFcUAAAAAAAgAj/mcCeAH6ADwARwCXQA4cAQkEMwEAChEBAwADTEuwLlBYQC0ABQQFhQsIAgcBAQADBwBpAAYAAgYCZgAJCQRhAAQENk0MAQoKA2EAAwM0A04bQDMABQQFhQsBCAkHBwhyAAcBAQADBwBqAAYAAgYCZgAJCQRhAAQENk0MAQoKA2EAAwM0A05ZQBk9PQAAPUc9RkFAADwAOzksIyUlJBEjDQkeKyQVFAYjJyYjFhUUBiMiJjU0NwYjIiY1NDY2MzIXNjYzMhYHFAYHBgYHBhUUFjMyNjY1NCcmNTQ2MzI3NjMENjc3DgIVFBYzAngjHiUKEwRPVDk7GiI3N0lLfUcYDQkkICIXARkEECULIA8MChcQBwEhHgRIHhX+gSoJKyxJKxcUwB8nLAEBOTmX4INedXI0XElPjlcQIBYUEwxXDjiIOKB7LkFEckBMOwULISwDA2A5KLYBPGM3HyEAAAEAMv/7AlQB0gA3ADxAOQ8BBAIBTAAFAAMABQOAAAMCAAMCfgACAAQGAgRqAQEAADZNBwEGBjQGTgAAADcANicmIiYqJggJHCsWJjU0NzY2MzIWFRQHBgYHPgIzMhUUBwYVFDMyNzYzMhYVFAcGBiMiJjU0NzY1NCMiBgYHBgYjUR8lCSklFBAPCgwEIVJPIUEJCBkcLA0ODQ8UHEsqNTcDAgsPMTAPCx0fBVBYgnUdGwoOEDgoPCxWbC5BDTIoCiMsDRcTJRUdKTYuDw8UBxBDbj0vIQAA//8AMv/7AlQDQgAiAfoAAAADBacCTwAA//8AMv/7AlQDXAAiAfoAAAADBasCTwAA//8AJv7MAlQB0gAiAfoAAAADBbcB4QAA//8AMv/7AlQDRAAiAfoAAAADBbECTwAA//8AMv/7AlQC9AAiAfoAAAADBbICTwAAAAH/9f/lAiwB3QA8ANZADCEMAgMCLggCAQACTEuwF1BYQCYAAwIAAgMAgAABAAQAAQSAAAICNk0ABAQ0TQAAAAViBgEFBTQFThtLsCZQWEAjAAMCAAIDAIAAAQAEAAEEgAAABgEFAAVmAAICNk0ABAQ0BE4bS7AwUFhAJQADAgACAwCAAAEABAABBIAABAUABAV+AAAGAQUABWYAAgI2Ak4bQCoAAgMChQADAAOFAAEABAABBIAABAUABAV+AAABBQBZAAAABWIGAQUABVJZWVlAEAAAADwAOzo5MzErKiQHCRkrFiY1NDYzMhYXLgInBgYHBiMiJjU0Nzc2NzY2NzYzMhYVFAYHBhUUFhcWFhUUBzY3NjMyFhUUBwYGBwYjtjcmJQ0jCQEVIA4fPSQSFBAUDg03HBEuFhM8HBYIBxIVFiAhAjFCDA8NDxMyW0MoNxswHhomBQEaLisQO04jEhcRFBEQRCwdYTQsCgsGGg0kGQ8kGyo7IwoSE1IOGBUmGD4tAiIAAAD////1/+UCLANCACICAAAAAAMFpwIzAAD////1/+UCLANcACICAAAAAAMFqwIzAAAAAf/1/wYCLAHdAFcBEUAVRjECCAdTLQIGBSUBAAYhCAIEAARMS7AmUFhALAkBCAcFBwgFgAAGBQAFBgCAAAUABAIFBGkDAQIAAQIBZgAHBzZNAAAANABOG0uwLlBYQC4JAQgHBQcIBYAABgUABQYAgAAABAUABH4ABQAEAgUEaQMBAgABAgFmAAcHNgdOG0uwMFBYQDUJAQgHBQcIBYAABgUABQYAgAAABAUABH4AAgQDBAIDgAAFAAQCBQRpAAMAAQMBZgAHBzYHThtAOgAHCAeFCQEIBQiFAAYFAAUGAIAAAAQFAAR+AAIEAwQCA4AABQAEAgUEaQADAQEDWQADAwFiAAEDAVJZWVlAEQAAAFcAVisqKiQjFCYWCgkeKyQWFRQHBgYHBxYVFAYGIyInJjU0MzIXFjMyNjU0JiMiJjU0NzY3JjU0NjMyFhcuAicGBgcGIyImNTQ3NzY3NjY3NjMyFhUUBgcGFRQWFxYWFRQHNjc2MwIdDxMyW0MPHy1VOSYYJygIBRsaKC0rJRocAQULBCYlDSMJARUgDh89JBIUEBQODTccES4WEzwcFggHEhUWICECMUIMD98YFSYYPi0CCx8zL0sqBQclLQEEISIZHQ4RBgMUCQkNGiYFARouKxA7TiMSFxEUERBELB1hNCwKCwYaDSQZDyQbKjsjChITUg7////1/+UCLANcACICAAAAAAMFqgIyAAD////1/swCLAHdACICAAAAAAMFtwJXAAAAAgAr/yQC0gMNAEAATABCQD9GEgcDAAUBTAAFAgACBQCAAAAGAgAGfgADAQOGAAQAAgUEAmkHAQYGAWEAAQE0AU5BQUFMQUseJicvJyIICRwrJBUUIyInJicWFRQGIyImNTQ2NyY1NDY3NjY1NCYjIgYHBhUVFAYjIiY1NBMSNjMyFhYVFAYHBgYVFBYXFhcWFhcENjU0JicGBhUUFjMC0h4MCjYwCWxYWFg6MzIzOyknKyZWZwcFKRwYJAoLtY86Uyw3NCcdICIQCD5oJP7rKB0cJicjH+YfLgUXChYeRVFJNSxJFi08K0IoGy8eIijT2bijWhMWExKtAQEBF/8rSi07TSMcHxIVHxYKBgIUD6wbGBUhEwopGBQdAAACAAH/+wIKA2kALAA1AEhARTABAggBTAkBBwEGAQcGgAADCgEIAgMIaQUBAQECYQQBAgI2TQAGBgBhAAAANABOLS0AAC01LTQALAArJCMkIyMjJgsJHSskFhUUBwYGIyIRNDcjIiY1NDMzPgIzMhYVFAczMhYVFCMjBhUUFjMyNjc2MwIGBgc2NjU0IwH7DxMrZkLMAyceFS05EUZjOSowgnAQDnF6AjE1K0ItDA++JSELOzsW3xgVKBY1RAEfLC0WGDhutmxKOJtzDhNFMhxoVDQ0DgIqS4VRM380OwAAAAH/+f/7AdgC/QBCAExASSIBBAUBTAAFBAWFDAELAQoBCwqABgEEBwEDAgQDaggBAgkBAQsCAWkACgoAYQAAADQATgAAAEIAQT48OjgyJDYkIyIkIiUNCR8rJBYVFAcGIyI1NyMiJjU0NjMzNjcjIiY1NDMzNjc2NjMyFhUUBwYHMzMyFhUUBiMjBgczMzIWFRQGIyMGFjMyNjc2MwHJDxNjbbEBGB8VFRgqBwMaHhUtMxQZCScgHh0EIBASbxAOMypYCAUhWxAOMylJAiEoKT4wDA/fGBUoFnnOGhYWFx0xExYYOGFnKCAUFgYUgEwOEyEkIyEPEx0hPT0vOQ4AAP//AA3/+wHYA6cAIgMrAAABBwWpApAB1gAJsQEBuAHWsDUrAAACAAH/BgIKA2kASQBSAKZADE0BBQskIAcDAwkCTEuwLlBYQDUMAQoECQQKCYAACQMECQN+AAMBBAMBfgAGDQELBQYLaQIBAQAAAQBlCAEEBAVhBwEFBTYEThtAOwwBCgQJBAoJgAAJAwQJA34AAwEEAwF+AAECBAECfgAGDQELBQYLaQACAAACAGUIAQQEBWEHAQUFNgROWUAaSkoAAEpSSlEASQBIRUMjJCMjKiQjFCwOCR8rJBYVFAcGBgcWFRQGBiMiJyY1NDMyFxYzMjY1NCYjIiY1NDc2NyY1NDcjIiY1NDMzPgIzMhYVFAczMhYVFCMjBhUUFjMyNjc2MwIGBgc2NjU0IwH7DxMmVzcfLVU5JhgnKAgFGxooLSslGhwBBiNNAyceFS05EUZjOSowgnAQDnF6AjE1K0ItDA++JSELOzsW3xgVKBYuQQghMi9LKgUHJS0BBCEiGR0OEQYDIgRFrywtFhg4brZsSjibcw4TRTIcaFQ0NA4CKkuFUTN/NDv//wAB/swCCgNpACICBwAAAAMFtwJgAAAAAQAw//sCTwHSADgAQ0BACwEEADUBAwECTAAEAAEABAGAAgEAADZNAAEBBWIHBgIFBTRNAAMDBWEHBgIFBTQFTgAAADgANyYjKCUqJwgJHCsWJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMhYVFAcGFRQWMzI2NzYzMhYVFAcGBiMiJjUGBiNpORQXCiQnFhELCgYUCgsPLTMYCCEhFxIZHBANFDcuDA8NDxMrYz8wLRFEJwVTPkt9Rh4aDg4ILiUeaSMVETx6WR4aCw8ZcIAeExUxNw4YFSgWNURKQ0RJAAD//wAw//sCTwNCACICDAAAAAMFpwJRAAD//wAw//sCTwL0ACICDAAAAAMFrAJRAAD//wAw//sCTwNcACICDAAAAAMFqgJQAAD//wAw//sCTwNEACICDAAAAAMFsQJRAAD//wAw//sCTwKxACICDAAAAAMFpAJRAAD//wAw/xwCTwHSACICDAAAAAMFtQJQAAD//wAw//sCTwNDACICDAAAAAMFpgJRAAD//wAw//sCTwMrACICDAAAAAMFsAJQAAAAAQAw//sCgQJRAD8ASkBHJgsCBQA8AQQBAkwAAwADhQAFAAEABQGAAgEAADZNAAEBBmIIBwIGBjRNAAQEBmEIBwIGBjQGTgAAAD8APiYjKyMlKicJCR0rFiY1NDY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzI2NzYzMhYHBgYHNgcGFRQWMzI2NzYzMhYVFAcGBiMiNQYGI2k5FBcKJCcWEQsKBhQKCw8tMxgIISEfIwgHJhoaAwZIPAIUFhgcI0ItDA8NDxMrdEZ3EUQnBVM+S31GHhoODgguJR5pIxURPHpZHhoqLichIT5UDApgXxciGjI2DhgVKBYyR41ESQAA//8AMP/7AoEDQgAiAhUAAAADBacCUQAA//8AMP8cAoECUQAiAhUAAAADBbUCUAAA//8AMP/7AoEDQwAiAhUAAAADBaYCUQAA//8AMP/7AoEDKwAiAhUAAAADBbACUAAAAAIAMP/7AoEC1wAhAGEA00uwEFBYQBAUAwIHAUgtAgkEXgEIBQNMG0AQFAMCBwJILQIJBF4BCAUDTFlLsBBQWEA5AgEBBwGFAAcAB4UMAwIABACFAAkEBQQJBYAGAQQENk0ABQUKYg0LAgoKNE0ACAgKYg0LAgoKNApOG0BBAAECAYUAAgcChQAHAAeFAAADAIUMAQMEA4UACQQFBAkFgAYBBAQ2TQAFBQpiDQsCCgo0TQAICApiDQsCCgo0Ck5ZQCAiIgAAImEiYF1bVVNQTkNBPjw3NSspACEAICYnJg4JGSsAJicnBwYGIyImNTQ2NzY2MzIWFxc3NjYzMhYVFAYHBgYjACY1NDY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzI2NzYzMhYHBgYHNgcGFRQWMzI2NzYzMhYVFAcGBiMiNQYGIwFuGBNaJgYVCw8WEQ8TJhYOFxNbJQYVCw8WEA8UJRb+7TkUFwokJxYRCwoGFAoLDy0zGAghIR8jCAcmGhoDBkg8AhQWGBwjQi0MDw0PEyt0RncRRCcCFAsPSj8LCxUSDiUaIR8KEEo/CwsVEg4kGyEf/edTPkt9Rh4aDg4ILiUeaSMVETx6WR4aKi4nISE+VAwKYF8XIhoyNg4YFSgWMkeNREn//wAw//sCTwNEACICDAAAAAMFqAJRAAD//wAw//sCTwL0ACICDAAAAAMFsgJRAAD//wAw//sCTwJyACICDAAAAAMFrwJQAAAAAQAw/wYCTwHSAE0AikAOFgEFAQcBBAIFAQAEA0xLsBJQWEAqAAUBAgEFAoAABAIAAgQAgAcBBgkBCAYIZgMBAQE2TQACAgBiAAAANABOG0AxAAUBAgEFAoAABAIAAgQAgAAHAAYABwaAAAYJAQgGCGYDAQEBNk0AAgIAYgAAADQATllAEQAAAE0ATCIrIyglKicpCgkeKwQmNTQ2NyY1BgYjIiY1NDY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzIWFRQHBhUUFjMyNjc2MzIWFRQHBgcGBhUUFjMyNzYzMhUUBwYGIwFDUSMhJBFEJy05FBcKJCcWEQsKBhQKCw8tMxgIISEXEhkcEA0UNy4MDw0PEztSLikkGhoVEQoaLwwnEPpHPSRGHCNVRElTPkt9Rh4aDg4ILiUeaSMVETx6WR4aCw8ZcIAeExUxNw4YFSgWRS8aMBsdHgcGJSgQBAYA//8AMP/7Ak8DLAAiAgwAAAADBa0CUQAA//8AMP/7Ak8C1wAiAgwAAAADBa4CUQAAAAEAMv/7AkgB0wAuAGlLsAlQWEALIAsCAQAeAQIBAkwbQAsgCwIBBR4BAgECTFlLsAlQWEAVBQEAAAECAAFqBAEDAzZNAAICNAJOG0AcAAADBQMABYAABQABAgUBagQBAwM2TQACAjQCTllACRQrJyUmEQYJHCsAMzIWFRQGBwYjIicGBwYGIyImJyY1NTY2MzIWFRQXNjcmNTQ2NjMyFhUUBzY3NwIiBw8QGBguNCwnHSMoOiUpLwYMASIiGhkOPB4PHjQhHSQYJj8bATEUER8jCA8MLzI5KkBFjGkjIRoXG3O4WTUdKCJAKCknLToCDQUAAAABADL/+wNDAdMAQABzS7AJUFhADTIUCwMBADAmAgIBAkwbQA0yFAsDAQcwJgICAQJMWUuwCVBYQBcHAQAAAQIAAWoGBQIEBDZNAwECAjQCThtAHgAABAcEAAeAAAcAAQIHAWoGBQIEBDZNAwECAjQCTllACxQrKCcmJSYRCAkeKwAzMhYVFAYHBiMiJwYHBgYjIiYnJw4CIyImJyY1NTY2MzIWFRQXNjc2NjMyFhUUFzY3JjU0NjYzMhYVFAc2NzcDHQcPEBgYLjQsJx0jKDkkKCkFBR8xMSEpLwYMASIiGhkORDkLHxYbFQ48Hg8eNCEdJBgmPxsBMRQRHyMIDwwvMjkqPkdJVFgiQEWMaSMhGhcbc7iPmx4VFhxzuFk1HSgiQCgpJy06Ag0FAP//ADL/+wNDA0IAIgIiAAAAAwWnAqYAAP//ADL/+wNDA1wAIgIiAAAAAwWqAqUAAP//ADL/+wNDArEAIgIiAAAAAwWkAqYAAP//ADL/+wNDA0MAIgIiAAAAAwWmAqYAAAABABH/+wKSAdYASwCRQA4wAQQGFAEDAgoBAAMDTEuwCVBYQC4MCwICBQMDAnIJAQQEBmEHAQYGNk0IAQUFBmIHAQYGNk0KAQMDAGIBAQAANABOG0AvDAsCAgUDBQIDgAkBBAQGYQcBBgY2TQgBBQUGYgcBBgY2TQoBAwMAYgEBAAA0AE5ZQBYAAABLAEpHRUA+JCQkJCUmJCMmDQkfKyQWFRQHBgYjIiYnBiMiJjU0NjMyFRQHBhUUMzI2NjU0JiMiBgcGBiMiJjU0NjMyFhc2NjMyFhUUBiMiJicmJiMiBgYVFBYzMjY3NjMCgw8TLGlCM08XOU43QC4qJAIDGhMjFxINCwoFBhQZFho+MSpEEh5LJCcpIhgWEAQCCAoMGxMtJydFLgwP3xgVKBY0RSYjSEA1Mj4bBxIkBR4tTi8kMQsNEBMfIDM6KScoKCQoLTMSEQwMLUooLzM1OA4AAAAAAv/8/jkCTAHSADwARQBOQEsiAQUCEwEDBTgBAQM/AQYBBEwHAQUCAwIFA4AEAQICNk0AAwMBYgABATRNCAEGBgBhAAAAOABOPT0AAD1FPUQAPAA7JSonKygJCRsrJBYVFAYHBwYGIyImNTQ2Njc3NjcGBiMiJjU0Njc2NjMyFhUUBwYHBgYVFDMyNjY3NjYzMhYVFAcHNjc2MwA2NwYGFRQWMwI9Dw4PwCZ7XzNAK3VrAwcJFEgoLTkUFwokJxYRCwoGCAwVDy0zGAghIRcSGhpNSQ0K/mM+H01FDQ/dGRMXGgqBz+0/My9if1IXJUVIS1M+S31GHhoODgguJR4pSxgmPHpZHhoMDhmToTowCP29dIdBaygRFgAAAP////z+OQJMA0IAIgIoAAAAAwWnAlEAAP////z+OQJMA1wAIgIoAAAAAwWqAlAAAP////z+OQJMArEAIgIoAAAAAwWkAlEAAP////z+OQJMAdIAIgIoAAABBwW1Avn/HQAJsQIBuP8dsDUrAP////z+OQJMA0MAIgIoAAAAAwWmAlEAAP////z+OQJMAysAIgIoAAAAAwWwAlAAAP////z+OQJMAnIAIgIoAAAAAwWvAlAAAP////z+OQJMAtcAIgIoAAAAAwWuAlEAAAABADr/8QI/AdcAMACNS7AXUFhAIAcBBgEFAQYFgAABAQJhBAMCAgI2TQAFBQBhAAAANABOG0uwMFBYQCQHAQYBBQEGBYAAAwM2TQABAQJhBAECAjZNAAUFAGEAAAA0AE4bQCMAAwIBAgNyBwEGAQUBBgWAAAUAAAUAZQABAQJhBAECAjYBTllZQA8AAAAwAC8qI0EkJiYICRwrJBYVFAcGBiMiJiY1NDY3BwYmNTQ2MzIXFhYzMjc2NjMyFhUUBgcGBhUUFjMyNjc2MwIwDxMvi1dEZDVqY6QWFxcULk0QVR0KHAUdChAVHiBbeDQzOHMuDA/fGBUlGT1GKUcsQmYvBAEhFxglBwEGCAEIHB0gJA4nWSwcJDg5DgAA//8AOv/xAj8DQgAiAjEAAAADBacCSQAA//8AOv/xAj8DXAAiAjEAAAADBasCSQAA//8AOv/xAj8CsAAiAjEAAAADBaUCSQAAAAIAI//7AbMB1AAcACcARUBCCQEEARoBAgUCTAABAQJhBgMCAgI0TQAEBABhAAAANk0HAQUFAmEGAwICAjQCTh0dAAAdJx0mISAAHAAbKSMlCAkZKxYmNTQ2NjMyFhc2MzIWFRQHBgYVFAYjIiY1NwYjNjY3Nw4CFRQWM2pHSntFFg8FExcYGgoLDB8jIiEBH0xDLhITKUYqFxMFWklQj1cRFgQYFhc5PW9FJiEhJRBWZU5kZQE9ZDgeHwD//wAj//sB7QNCACICNQAAAAMFpwJfAAD//wAj//sCEAL0ACICNQAAAAMFrAJfAAD//wAj//sCEgNdACICNQAAAAMF5QJfAAD//wAj/xwCEAL0ACICNQAAACMFtQI7AAAAAwWsAl8AAP//ACP/+wISA10AIgI1AAAAAwXmAl8AAP//ACP/+wISA4gAIgI1AAAAAwXnAl8AAP//ACP/+wIfA44AIgI1AAAAAwXoAl8AAP//ACP/+wHcA1wAIgI1AAAAAwWqAl4AAP//ACP/+wJuA2sAIgI1AAABBwXpAl//+wAJsQICuP/7sDUrAP//ACP/HAHcA1wAIgI1AAAAIwW1AjsAAAADBaoCXgAA//8AI//7Ad0DawAiAjUAAAEHBeoCX//7AAmxAgK4//uwNSsA//8AI//7AnYDYQAiAjUAAAEHBesCX//7AAmxAgK4//uwNSsA//8AI//7AhYDggAiAjUAAAEHBewCX//7AAmxAgK4//uwNSsA//8AI//7AbYDRAAiAjUAAAADBbECXwAA//8AI//7AfECsQAiAjUAAAADBaQCXwAA//8AI/8cAbMB1AAiAjUAAAADBbUCOwAA//8AI//7AbMDQwAiAjUAAAADBaYCXwAA//8AI//7AcoDKwAiAjUAAAADBbACXgAA//8AI//7AhAC9AAiAjUAAAADBbICXwAA//8AI//7AdcCcgAiAjUAAAADBa8CXgAAAAIAI/8GAd8B1AAxADwAhkALFAEGAggFAgAHAkxLsBJQWEAnAAIBBgECBoAEAQMIAQUDBWYABgYBYQABATZNCQEHBwBhAAAANABOG0AuAAIBBgECBoAABAADAAQDgAADCAEFAwVmAAYGAWEAAQE2TQkBBwcAYQAAADQATllAFjIyAAAyPDI7NjUAMQAwIi4jJSkKCRsrBCY1NDY3JiY1BiMiJjU0NjYzMhYXNjMyFhUUBwYGFRQGBwYVFBYzMjc2MzIVFAcGBiMCNjc3DgIVFBYzAShRHiEFAx9MOUdKe0UWDwUTFxgaCgsMDA86JBoaFRALGi8MJxCHLhITKUYqFxP6Rz0rQiUNFRNWWklQj1cRFgQYFhc5PW9FFxsNLzkdHgcGJSgQBAYBWk5kZQE9ZDgeHwD//wAj//sBzQMsACICNQAAAAMFrQJfAAAABQAj//sCkgOHABAAHgAqAEcAUgB/QHw0AQoHRQEICwJMAAACAIUMAQECBAIBBIAAAgAEBQIEaQ4BBQ0BAwYFA2kABwcIYQ8JAggINE0ACgoGYQAGBjZNEAELCwhhDwkCCAg0CE5ISCsrHx8REQAASFJIUUxLK0crRkJANzUyMB8qHyklIxEeER0YFgAQAA8mEQkXKwAmNTQ3NzYzMhYVFAYHBwYjBiY1NDY2MzIWFRQGBiM2NjU0JiMiBhUUFjMCJjU0NjYzMhYXNjMyFhUUBwYGFRQGIyImNTcGIzY2NzcOAhUUFjMB6RIQTxAVFiEVGFwMBuxMJ0ElNUwnQSUYHBoSFBwaEtpHSntFFg8FExcYGgoLDB8jIiEBH0xDLhITKUYqFxMC6xINDhBPECEWEiAKJQTXRz0tQyRHPS1DJFgeGRYbHhkWG/2PWklQj1cRFgQYFhc5PW9FJiEhJRBWZU5kZQE9ZDgeHwAA//8AI//7AhwC1wAiAjUAAAADBa4CXwAAAAMAJP/7ArYB1AAnADMAPQBQQE0XAQYCNgEFBiABBAUKAQAEBEwJAQUGBAYFBIAKCAIGBgJhAwECAjZNBwEEBABhAQEAADQATjQ0AAA0PTQ8MC4qKQAnACYmJCUkJgsJGyskFhUUBwYGIyImJwYGIyImNTQ2NjMyFhc2NjMyFhUUBgcWMzI2NzYzJDcGBhUUFjMyNjc3NgYVFTY2NTQmIwKnDxEcWz8+UBwUTS5ETkqIWhYSBhlIKDpGY3cYOSk1IwwP/poeUmAaFxkoCgqrMztEFRLBGBUkGiswLiwqMF9QUohQFB4XGUU7RWMdLiYtD4AxAWdbJSo2MzJ1Vj0CDjglExf//wAk//sCtgNCACICTgAAAAMFpwLeAAAAAwA3//sByAOsABQAHgAqAD1AOh4MAgMCAUwAAwIEAgMEgAACAgBhAAAANU0GAQQEAWEFAQEBNAFOHx8AAB8qHyklIxsZABQAEyUHCRcrFiY1NBI2MzIWFRQGBx4CFRQGBiMSNjU0JiMiBgYHEjY1NCYjIgYVFBYzkltAe1UuOD5IMUknO2A3B08PDRQvKAphLygcIzAoHgWakoEBL9VPP1KiWQQ6XDZLeEMCC7lIICJ3zHn+2kpHNzhIRTw3AAAAAQAg//sBpwHSACsAbLUPAQECAUxLsAlQWEAkAAECBAIBcgAEAwIEA34AAgIAYQAAADZNAAMDBWEGAQUFNAVOG0AlAAECBAIBBIAABAMCBAN+AAICAGEAAAA2TQADAwVhBgEFBTQFTllADgAAACsAKiMlKSQlBwkbKxYmNTQ2NjMyFhUUBiMiJjU0Njc2NTQmIyIGBhUUFjMyNjc2MzIWFRQHBgYji2tAZjg3PSUeExcEAQUNDBcoGC8rIjkcDA8NDxEbWDkFb1tRekJBMyo6EhAHEgQPDQ0OKUYqOTsoJw8YFSQaKjEA//8AIP/7Ab4DQgAiAlEAAAADBacCMAAA//8AIP/7AdoDXAAiAlEAAAADBasCMAAAAAEAIP8GAacB0gBHAM5ADDMBBQYjHwYDAwcCTEuwCVBYQDAABQYIBgVyCQEIBwYIB34ABwMGBwN+AAMBBgMBfgIBAQAAAQBmAAYGBGEABAQ2Bk4bS7AuUFhAMQAFBggGBQiACQEIBwYIB34ABwMGBwN+AAMBBgMBfgIBAQAAAQBmAAYGBGEABAQ2Bk4bQDcABQYIBgUIgAkBCAcGCAd+AAcDBgcDfgADAQYDAX4AAQIGAQJ+AAIAAAIAZgAGBgRhAAQENgZOWVlAEQAAAEcARiUpJCwkIxQrCgkeKyQWFRQHBgcWFRQGBiMiJyY1NDMyFxYzMjY1NCYjIiY1NDc2NyYmNTQ2NjMyFhUUBiMiJjU0Njc2NTQmIyIGBhUUFjMyNjc2MwGYDxEnPiktVTkmGCcoCAUbGigtKyUaHAEEBC0vQGY4Nz0lHhMXBAEFDQwXKBgvKyI5HAwPwRgVJBo6FiE7L0sqBQclLQEEISIZHQ4RBgMOBxlbPFF6QkEzKjoSEAcSBA8NDQ4pRio5OygnD///ACD/+wGtA1wAIgJRAAAAAwWqAi8AAP//ACD/+wGnArAAIgJRAAAAAwWlAjAAAAADACP/9QJhA6wAHAAkADAAd0uwJlBYQAwrJx8DBAMIAQAEAkwbQAwrJx8DBAMIAQEEAkxZS7AmUFhAGAUBAwMCYQACAjVNBgEEBABhAQEAADQAThtAHAUBAwMCYQACAjVNBgEEBAFhAAEBNE0AAAA0AE5ZQBIlJR0dJTAlLx0kHSMoJSQHCRkrJBcWFRQjIiYnJwYGIyImNTQ2Njc2EjMyFhUUAgcSAgc2NTQmIwA2NyY1NDcGBhUUMwGnFQQ3HyEOASY9KD1PRHZJE2tZKzlsWTkzCW8NCf70JR0KATdIMo1QDQ4tIi8ELyBbSVCIVwm9ARhOT27+2pwCa/7YrvCWJir9Fh4rSU4fERByRUkAAAMAI//7ApsDpwAOAC4AOACPQA4eAQEDFwEGAiwBBAcDTEuwG1BYQCgAAwMzTQgBAQEAYQAAADVNAAYGAmEAAgI2TQoBBwcEYQkFAgQENAROG0ArAAMAAQADAYAIAQEBAGEAAAA1TQAGBgJhAAICNk0KAQcHBGEJBQIEBDQETllAHi8vDw8AAC84LzcyMQ8uDy0pJxwaFhQADgANJQsJFysAJjc3NjYzMhYVFAcHBiMAJjU0NjYzMhc2NzYzMhYVFAcCBwYGFRQGIyImNTcGIzY3Nw4CFRQWMwIxFgEGAScaGB8FJwsi/ihHSnlDFwwbEwlFHxwCQh4GCR8jIiEBH0xdHh0qRyoXEwK7FRSEIR4dGxIOcyH9QFpJT5BXFcd4PhQVBQz+urUmbDMmISElEFZli4wBPWQ4Hh8AAAACACP/+wIoAzwAMwA9AI1LsBtQWEAOLAEEBRoBBwIPAQAIA0wbQA4sAQYFGgEHAg8BAAgDTFlLsBtQWEAkBgEEAAMCBANnAAUFM00ABwcCYQACAjZNAAgIAGEBAQAANABOG0AoAAUGBYUABgQGhQAEAAMCBANnAAcHAmEAAgI2TQAICABhAQEAADQATllADCUTJSJUIiUkKgkJHysABgcHBgcGBhUUBiMiJjU3BiMiJjU0NjYzMhc3IyImNTQ2MzIXFjM3NjMyFhUUBwczMhYVAw4CFRQWMzI3AigkKg0kCAYJHyMiIQEfTDlHSnlDFwwRjxwSFB4zLSYTDwlFHxwCEhMTE+0qRyoXEzYeAmYfB0XANCZsMyYhISUQVlpJT5BXFXwVGRoeAwJiPhQVBQxbFhH+9wE9ZDgeH4sABAAj/nEDrQNcABkAbgB5AIIC5kuwFVBYQBpKFQIAB0MBDAZbIgIIDDgyLgMECH0BDgQFTBtLsBtQWEAaShUCAAdDAQwKWyICCAw4Mi4DBAh9AQ4EBUwbQB5KFQIAB0MBDApbIgIIDDguAgQNfQEOBAVMMgENAUtZWUuwCVBYQD0AAAcJBwAJgBALAgkGBwkGfhEBDgADDgNmDwICAQEzTQAHBzNNAAwMBmEKAQYGNk0NAQgIBGIFAQQENAROG0uwDlBYQD0AAAcJBwAJgBALAgkGBwkGfhEBDgADDgNmDwICAQE5TQAHBzNNAAwMBmEKAQYGNk0NAQgIBGIFAQQENAROG0uwEFBYQD0AAAcJBwAJgBALAgkGBwkGfhEBDgADDgNmDwICAQEzTQAHBzNNAAwMBmEKAQYGNk0NAQgIBGIFAQQENAROG0uwFVBYQD0AAAcJBwAJgBALAgkGBwkGfhEBDgADDgNmDwICAQE5TQAHBzNNAAwMBmEKAQYGNk0NAQgIBGIFAQQENAROG0uwG1BYQEEAAAcJBwAJgBALAgkGBwkGfhEBDgADDgNmDwICAQE5TQAHBzNNAAoKNk0ADAwGYQAGBjZNDQEICARiBQEEBDQEThtLsCpQWEBNAAcBAAEHAIAAAAkBAAl+EAsCCQYBCQZ+EQEOAAMOA2YPAgIBATlNAAoKNk0ADAwGYQAGBjZNAAgIBGIFAQQENE0ADQ0EYQUBBAQ0BE4bS7AsUFhARg8CAgEHAYUABwAHhQAACQCFEAsCCQYJhREBDgADDgNmAAoKNk0ADAwGYQAGBjZNAAgIBGIFAQQENE0ADQ0EYQUBBAQ0BE4bQEkPAgIBBwGFAAcAB4UAAAkAhRALAgkGCYUACgYMBgoMgBEBDgADDgNmAAwMBmEABgY2TQAICARiBQEEBDRNAA0NBGEFAQQENAROWVlZWVlZWUArenoaGgAAeoJ6gXd1cG8abhptaWdjYVVTSEZCQDs5NjQpJwAZABgnJxIJGCsAFhUUBwcGBiMiJicnJjU0NjMyFhcXNzY2MxAWFRQGBwYGBxYVFAYGIyImNTQ2NyYmJycGBiMiJicGIyImNTQ2NjMyFzY3NjMyFhUUBwcCBwYVFBYzMjY3MDc2NycmJjU0NjMyFhcWFjMyNjc2NjMFDgIVFBYzMjY3ADY2NQYGFRQzA5QZC3ASLR8eIgksAyEXFxwEF1cPIhUZFRRNYzOST3g4NT5wdQ4qHggmUyYhNw40Tz5KSnlDFwwbEwlFHxwCEzUbEA8MEjIoBkJmnBERGhQTPh4qOBYMEwwOEAv9zSpHKhkWFigJASw6KU1KHANbExIRE8EfHyQntAwKGRsXH7GxHxb+mSYeDyINN1Q2NaRbp2U7OkWXVhkeDQQsOS0nVFpJT5BXFcd4PhQVBQxb/vqaWCUPEisvCU9QEwIcFBkpDAgLCwsLDAp9AT1kOB8eNCv+EEpwMzphKigAAAACACH/+wGyAdIAGwAlAD5AOx4BAwQUAQIDAkwFAQMEAgQDAoAGAQQEAWEAAQE2TQACAgBhAAAANABOHBwAABwlHCQAGwAaJiUmBwkZKyQWFRQHBgYjIiY1NDY2MzIWFRQGBxYzMjY3NjMmBhUVNjY1NCYjAaMPERxbP2BqOmdBOkZjdxg5KTUjDA/JMztEFRLBGBUkGiswc2JFd0ZFO0VjHS4mLQ+vVj0CDjglExcA//8AIf/7AcMDQgAiAlsAAAADBacCNQAA//8AIf/7AeYC9AAiAlsAAAADBawCNQAA//8AIf/7Ad8DXAAiAlsAAAADBasCNQAA//8AIf/7AbIDXAAiAlsAAAADBaoCNAAA//8AIf/7AkQDawAiAlsAAAEHBekCNf/7AAmxAgK4//uwNSsA//8AIf8cAbIDXAAiAlsAAAAjBbUCVAAAAAMFqgI0AAD//wAJ//sBswNrACICWwAAAQcF6gI1//sACbECArj/+7A1KwD//wAh//sCTANhACICWwAAAQcF6wI1//sACbECArj/+7A1KwD//wAh//sB7AOCACICWwAAAQcF7AI1//sACbECArj/+7A1KwD//wAa//sBsgNEACICWwAAAAMFsQI1AAD//wAh//sBxwKxACICWwAAAAMFpAI1AAD//wAh//sBsgKwACICWwAAAAMFpQI1AAD//wAh/xwBsgHSACICWwAAAAMFtQJUAAD//wAh//sBsgNDACICWwAAAAMFpgI1AAD//wAh//sBsgMrACICWwAAAAMFsAI0AAD//wAh//sB5gL0ACICWwAAAAMFsgI1AAD//wAh//sBsgJyACICWwAAAAMFrwI0AAAAAgAh/wYBsgHSADEAOwB5QA40AQQGGwEDBA4BAAMDTEuwElBYQCMABAYDBgQDgAADAAYDAH4FAQAAAQABZgcBBgYCYQACAjYGThtAKQAEBgMGBAOAAAMABgMAfgAABQYABX4ABQABBQFmBwEGBgJhAAICNgZOWUAPMjIyOzI6KyMmKyUgCAkcKwQzMhUUBwYGIyImNTQ2NyYmNTQ2NjMyFhUUBgcWMzI2NzYzMhYVFAcGBwYGFRQWMzI3AgYVFTY2NTQmIwF9ChovDCcQRVEYGVBZOmdBOkZjdxg5KTUjDA8NDxEaNCwoJBoaFZ8zO0QVEpMlKBAEBkc9IzcZCXFZRXdGRTtFYx0uJi0PGBUkGigdGT8eHR4HAglWPQIOOCUTFwAA//8AIf/7AfIC1wAiAlsAAAADBa4CNQAAAAP//v45AbEB1AAhACwANQBVQFIfAQQDEgEBBS8BBgEDTAcBAwIEAgMEgAAEBAJhAAICNk0IAQUFAWEAAQE0TQkBBgYAYQAAADgATi0tIiIAAC01LTQiLCIrJiUAIQAgJSgqCgkZKwAWFRQHBgcGBwICIyImNTQ2NzcGBiMiJjU0NjYzMhYXNjMCNjc3DgIVFBYzAjY3BgYVFBYzAZwVAQQVDwQmgWwzQHCaBhE3Gz5KSntFFg8FExmdKgkgKUYqGRY6Px1NRA0PAbEPFgwHH4FXHP7+/tU/M0ejdycbHVpJUI9XERYE/q84NKsBPWQ4Hx7+OniDQmooERYA/////v45AhAC9AAiAm8AAAADBawCXwAA/////v45AgkDXAAiAm8AAAADBasCXwAA/////v45AdwDXAAiAm8AAAADBaoCXgAA/////v45AbEDAAAiAm8AAAADBbMCXwAA/////v45AbECsAAiAm8AAAADBaUCXwAAAAIAN//7AdMDrAAuADgAQUA+MigCAQQqAQABAkwAAQQABAEAgAcBBQUDYQADAzVNBgEEBDZNAgEAADQATi8vAAAvOC83AC4ALSYlJykICRorABYVFAcGBhUUBiMiJjU0NzY1NCMiBgYHBgYjIiYmNTQSNjMyFhUUBgcGFT4CMwIGBgc2NjU0JiMBsiELCgwfIyEeDgwLDTAwDwsdHx8dCj97Vi45doUDIVFPIXIsKQ0+UQ4NAdIhIBpIPW1DJiEiIihcUBYQQ249LyEtXluaAU7jTz9l2ZE0N1VrLgF3Z69nSaxGICIAAAABADX/+wHTAzwAQwBxQAshAQYDPx8CAAECTEuwG1BYQCMAAQcABwEAgAUBAwAGBwMGaAAEBDNNCAEHBzZNAgEAADQAThtAIwAEAwSFAAEHAAcBAIAFAQMABgcDBmgIAQcHNk0CAQAANABOWUAQAAAAQwBCJFQlKiUnKQkJHSsAFhUUBwYGFRQGIyImNTQ3NjU0IyIGBgcGBiMiJjU0NzY3JiY1NDMyFzY3NjYzMhUUBwcyNzYzMhYVFAYjIwYHPgIzAbIhCwoMHyMhHg4MCw0wMA8LHR8kIAUJKiAcJiAMCQ4MJR87BBkOIDIfHhQjH4cmHiFRTyEB0iEgGkg9bUMmISIiKFxQFhBDbj0vIUFNJkaFxwYXEjEBJi4pHyoNDVsCAhwXGhmXwFVrLv//ADf/+wH9BPkAIgJ1AAABBwXCAnoB1gAJsQIBuAHWsDUrAAACACL/+wEZArAACwAeADFALhcOAgMCAUwAAAQBAQIAAWkAAgI2TQUBAwM0A04MDAAADB4MHRYUAAsACiQGCRcrEiY1NDYzMhYVFAYjAiY1NDc2NzY2MzIVFAcGBwYGI5AqNyklLjQrgBgCECUIJSkrAi0JAiIkAhQnIyMvJCEoL/3nGhwIFLeWHxkjBQ7WkSAaAAAAAQAi//sA2gHSABIAIEAdCwICAQABTAAAADZNAgEBATQBTgAAABIAESgDCRcrFiY1NDc2NzY2MzIVFAcGBwYGIzoYAhAlCCUpKwItCQIiJAUaHAgUt5YfGSMFDtaRIBr//wAi//sBZgNCACICeQAAAAMFpwHYAAD////8/jkCTQNCACIC9QAAACMFpwHjAAAAAwWnAr8AAP///+7/+wGJAvQAIgJ5AAAAAwWsAdgAAP//AAT/+wFVA1wAIgJ5AAAAAwWqAdcAAP///73/+wEvA0QAIgJ5AAAAAwWxAdgAAP//AAf/+wFqArEAIgJ5AAAAAwWkAdgAAP//ACL/+wEQArAAIgJ5AAAAAwWlAdgAAP///+7/HAEZArAAIgJ4AAAAAwW1AcQAAP////n/+wDaA0MAIgJ5AAAAAwWmAdgAAP//ACL/+wFDAysAIgJ5AAAAAwWwAdcAAP///+7/+wGJAvQAIgJ5AAAAAwWyAdgAAP//AA//+wFQAnIAIgJ5AAAAAwWvAdcAAAAC/+f/BgEQArAACwAxAF22KCQCAgQBTEuwElBYQBcGAQEAAAQBAGkFAQIAAwIDZgAEBDYEThtAHgACBAUEAgWABgEBAAAEAQBpAAUAAwUDZgAEBDYETllAEgAAMC4jIRUTDgwACwAKJAcJFysSFhUUBiMiJjU0NjMSMzIVFAcGBiMiJjU0NyY1NDc2NzY2MzIVFAcGBwYHBhUUFjMyN+IuNCsqKjcpDQsaLwwnEEVRPwMBECUIJSkrAi0JAxc7JBoaFQKwJCEoLycjIy/8vSUoEAQGRz1ROwwREAq3lh8ZIwUO1pElDC08HR4H////4v/7AZUC1wAiAnkAAAADBa4B2AAAAAP/Hf45AP8CsAALACMAKwA8QDkmAQQDAUwFAQEAAAMBAGkGAQMDNk0HAQQEAmEAAgI4Ak4kJAwMAAAkKyQqDCMMIhYUAAsACiQICRcrEhYVFAYjIiY1NDYzFhYVFAcGBwICIyImNTQ2Nzc2NzY3NjYzAjY3BgYVFDPRLjQrKio3KRITHwQJJYRsND9umAcOCAYNBCQl6z4bTEMcArAkISgvJyMjL94SECvKGD3/AP7TPzNHoXYzYF02ax0b/Mh2g0FpKCcAAAAAAv8d/jkA0QHSABcAHwArQCgaAQIBAUwDAQEBNk0EAQICAGEAAAA4AE4YGAAAGB8YHgAXABYoBQkXKxIWFRQHBgcCAiMiJjU0Njc3Njc2NzY2MwI2NwYGFRQzvhMfBAklhGw0P26YBw4IBg0EJCXrPhtMQxwB0hIQK8oYPf8A/tM/M0ehdjNgXTZrHRv8yHaDQWkoJwAAAP///x3+OQFOA1wAIgKJAAAAAwWqAdAAAAACADf/+wICA6wAMgA8ADlANjYBAQQvJiQDAAECTAYBBQUDYQADAzVNAAEBBGEABAQ2TQIBAAA0AE4zMzM8MzspJiUpIwcJGyskFRQGIyImNTQ3NjY1NCYjIgYGBwYGIyImJjU0EjYzMhYVFAYHBhU2NjMyFhUUBgcWFhcCBgYHNjY1NCYjAgItKkhbKCwmDwsbQTgQCx0fHx0KP3tWLjl2hQMwfDYyPThEBiUpuSwpDT5RDg1gJRknWUgnERMrHxISTntBLyEtXluaAU7jTz9l2ZE0N31xRDI3XCQeFwgC4WevZ0msRiAiAAAA//8AN/7MAgIDrAAiAosAAAADBbcCXQAAAAEAMv/7AjAB0gBAAHtADhwBAgMQAQUCOwEEBQNMS7AJUFhAJgACAwUDAnIABQQDBQR+AAMDAGEBAQAANk0ABAQGYQgHAgYGNAZOG0AnAAIDBQMCBYAABQQDBQR+AAMDAGEBAQAANk0ABAQGYQgHAgYGNAZOWUAQAAAAQAA/JiMlKCQqJgkJHSsWJjU0NzY2MzIWFRQHDgIHNjYzMhYVFAYjIiY1NDY3NjU0IyIGBhUUFjMyNjc2MzIWFRQHBgYjIiYmJwYHBgYjUR8lCSklFBAPAg0LAiRuTjQ7JR4TFwQBBRoUJhcvKyI2HwwPDQ8RG1c2LEguCQINCx0eBVBYgnUdGwoOEDgHMkMojHhBMyo6EhAHEgQPDRspRSg7PCcoDxgVJBoqMSY6HggwKB4AAAACADf/+wGtA6wAGwAkADVAMh8VAgAEAUwAAAQDBAADgAUBBAQCYQACAjVNAAMDAWEAAQE0AU4cHBwkHCMnJSUgBgkaKyQzMhYVFAcGIyImNTQSNjMyFhUUAgcWFjMyNjcCBgYHNjY1NCMBXAsMDx40Ql9YP3tVMDeDcQckHxErEjg6LAJHVByXGxMqGSufgHoBOOBZU3f+xpkpJBQQArym9nF162FMAP//ADf/+wJTBNYAIgKOAAABBwXAAngB1gAJsQIBuAHWsDUrAP//ADf/+wJFA6wAIgKOAAABBwWpAwMB1gAJsQIBuAHWsDUrAP//ADf+zAGtA6wAIgKOAAAAAwW3AiYAAAACADH/+wHsA6cAJAAwADlANgACBQEFAgGAAAQHAQUCBAVqAAAANU0AAQEDYQYBAwM0A04lJQAAJTAlLyspACQAIyMrKQgJGSsWJjU0NzYSNzY2MzIWFRQHBgIHBhUUFjMyNjc2MzIWFRQHBgYjEiY1NDYzMhYVFAYjl2YDCk4jCyYfHh0EJFAKBysuMU0tDA8NDxMrc0YjKDUlICsyJQVnbBocXAF/gCggFBYNDYn+mjsrKD4/MjYOGBUoFjNGAYIoIiMvJCEnMAAAAAADADf+OQJFA6wAOgBDAEsAXEBZMQICBgVDBQIAASMBAwBGAQgDBEwABQkBBgEFBmkABwcEYQAEBDVNAAEBNk0AAAADYQADAzRNCgEICAJhAAICOAJOREQAAERLREpAPgA6ADkmJScoKCcLCRwrACYnBgYHFhYzMjY3Njc2NzY2MzIWFRQHBgcCAiMiJjU0Njc3BiMiJjU0EjYzMhYVFAc2NjMyFhUUBiMGNjU0IyIGBgcSNjcGBhUUMwG+KgIdcE0HIBolPCYDBAoIBCQlHhMfBAklhGwzQG6YBUFJWFU/e1UwNw8MLRslLjQr7lQcFzosAko+G0xDHAIUJSBj2GkpIygtFypePR0bEhAryhg9/wD+0z8zR6F2JTOgf3oBOOBZUzhBExYkISgvY+thTKb2cf1edoNBaSgnAAAAAwA3//sCNAP1ABcAMwA7ANC2Ox0CBQgBTEuwCVBYQDAAAgcIBwIIgAAFCAQIBQSACQEDAQEABwMAaQAICAdhCgEHBzNNAAQEBmEABgY0Bk4bS7AQUFhAMAACBwgHAgiAAAUIBAgFBIAJAQMBAQAHAwBpAAgIB2EKAQcHOU0ABAQGYQAGBjQGThtANwAAAQcBAAeAAAIHCAcCCIAABQgECAUEgAkBAwABAAMBaQAICAdhCgEHBzlNAAQEBmEABgY0Bk5ZWUAaGBgAADg2GDMYMi0rJiQhHwAXABYkIiQLCRkrABYVFAYjIicmIyIGBwYGIyImNTQ2NzYzBhYVFAIHFhYzMjY3NjMyFhUUBwYjIiY1NBI2MxI1NCMiBgYHAehMHRgMFygmL0QpGhsPFRceI25lIjmGbwgkHxErEgsLDA8eNEJfWD96UwkcGDsrAQP1Kh0WGAUKFxQNChkRFiERNqJRUmv+9oQqJBQQChsTKhkroodxAQe3/rejRoXQagAAAQAy//sCxQHSAEkAM0AwGg8CAwQBTAYBBAADAAQDgAIBAgAANk0IBwUDAwM0A04AAABJAEgnJScpKSomCQkdKxYmNTQ3NjYzMhYVFAcGBgc+AjMyFhUUBwYHPgIzMhYVFAcGBhUUBiMiJjU0NzY1NCMiBgYHBgYjIiY1NDc2NTQjIgYGBwYGI1EfJQkpJRQQDwoMBBtLTyMjHRMIAyFRTiEgIQsKDB8jIR4ODAsNMDAPCx0gISEKCAsPLisNCx0fBVBYgnUdGwoOEDgoOyxObDUgISBUJBJUai0hIBpIPW1DJiEiIihcUBYQQ249MCA/LSZIQBQQSHA2LyEAAQAy//sBzQHSAC4ALEApDwECAwFMAAMAAgADAoABAQAANk0FBAICAjQCTgAAAC4ALScpKiYGCRorFiY1NDc2NjMyFhUUBwYGBz4CMzIWFRQHBgYVFAYjIiY1NDc2NTQjIgYGBwYGI1EfJQkpJRQQDwoMBCFSTyEgIQsKDB8jIR4ODAsNLzEPCx0fBVBYgnUdGwoOEDgoPCxWbC4hIBpIPW1DJiEiIihcUBYQQ249LyEAAAD//wAy//sB8wNCACIClgAAAAMFpwJlAAD////7//sBzQMAACMF1P7yAAAAAgKWAAD//wAy//sCDwNcACIClgAAAAMFqwJlAAD//wAy/swBzQHSACIClgAAAAMFtwJdAAAAAQAc/r0BzQHSADUAa7UpAQMCAUxLsAxQWEAjAAIEAwQCA4AAAAMBAQByAAEHAQYBBmYFAQQENk0AAwM0A04bQCQAAgQDBAIDgAAAAwEDAAGAAAEHAQYBBmYFAQQENk0AAwM0A05ZQA8AAAA1ADQqJiUmIyQICRwrEiYnJjYzMhYXFjMyNjc3NjU0IyIGBgcGBiMiJjU0NzY2MzIWFRQHBgYHPgIzMhUUBwcCBiNfPAUCJRcOEQEHGyRPKgUJCw0wMA8LHR8mHyUJKSUUEA8KDAQhUk8hQR4HNYJd/r1HOhkdCgpNyu0cLxQQQ249LyFQWIJ1HRsKDhA4KDwsVmwuQSeHI/74+wAAAwAy/jkC7wKwAAsAVABcAGVAYj4BCAQcAQMIVwEKAwNMAAQGCAYECIALAQEAAAYBAGkMCQcDBgY2TQAICANiBQEDAzRNDQEKCgJhAAICOAJOVVUMDAAAVVxVWwxUDFNLSUNBNzUvLSgmHx0WFAALAAokDgkXKwAWFRQGIyImNTQ2MxYWFRQHBgcCAiMiJjU0Njc3BiMiJjU0NzY1NCMiBgYHBgYjIiY1NDc2NjMyFhUUBwYGBz4CMzIVFAcGFRQzMjY3Njc2NzY2MwI2NwYGFRQzAsEuNCsqKjcpEhMfBAklhGwzQG6YBUFGMzQODQsNLzEPCx0fJh8lCSklFBAPCgwEIVJPIUEWEx0TMCYDBAoIBCQl6z4bTEMcArAkISgvJyMjL94SECvKGD3/AP7TPzNHoXYlMzs4HEg/GBBDbj0vIVBYgnUdGwoOEDgoPCxWbC5BJ2ZXHCgpLBcqXj0dG/zIdoNBaSgnAAAA//8AMv/7AiIC1wAiApYAAAADBa4CZQAAAAIAIf/7AbIB0wAPABsALEApAAICAGEAAAA2TQUBAwMBYQQBAQE0AU4QEAAAEBsQGhYUAA8ADiYGCRcrFiYmNTQ2NjMyFhYVFAYGIzY2NTQmIyIGFRQWM55TKjliPTtUKjpjPC0vKBwkLygeBTtgN0x3QztgN0x3Q2xKRzc4SUg5NgAA//8AIf/7Ab8DQgAiAp4AAAADBacCMQAA//8AIf/7AeIC9AAiAp4AAAADBawCMQAA//8AIf/7AbIDXAAiAp4AAAADBaoCMAAA//8AIf/7AkADawAiAp4AAAEHBekCMf/7AAmxAgK4//uwNSsA//8AIf8cAbIDXAAiAp4AAAAjBbUCSAAAAAMFqgIwAAD//wAF//sBsgNrACICngAAAQcF6gIx//sACbECArj/+7A1KwD//wAh//sCSANhACICngAAAQcF6wIx//sACbECArj/+7A1KwD//wAh//sB6AOCACICngAAAQcF7AIx//sACbECArj/+7A1KwD//wAW//sBsgNEACICngAAAAMFsQIxAAD//wAh//sBwwKxACICngAAAAMFpAIxAAD//wAh//sBxQNXACICngAAACMFpAIxAAABBwWvAkwA5QAIsQQBsOWwNSsAAP//ACH/+wHFA1YAIgKeAAAAIwWlAjEAAAEHBa8CTADkAAixAwGw5LA1KwAA//8AIf8cAbIB0wAiAp4AAAADBbUCSAAA//8AIf/7AbIDQwAiAp4AAAADBaYCMQAA//8AIf/7AbIDKwAiAp4AAAADBbACMAAAAAIAIf/7AfECUQAcACgAdUuwIVBYtRYBBAABTBu1FgEEAQFMWUuwIVBYQB0AAgAChQAEBABhAQEAADZNBwEFBQNhBgEDAzQDThtAIQACAAKFAAEBNk0ABAQAYQAAADZNBwEFBQNhBgEDAzQDTllAFB0dAAAdKB0nIyEAHAAbIyImCAkZKxYmJjU0NjYzMhcWMzI2NzYzMhYHBgYHFhUUBgYjNjY1NCYjIgYVFBYznlMqOWI9IBoMDRsgCQcmGhoDBTAoITpjPC0vKBwkLygeBTtgN0x3QwQDMC4nISEyShM3SEx3Q2xKRzc4SUg5NgAA//8AIf/7AfEDQgAiAq4AAAADBacCHQAA//8AIf8cAfECUQAiAq4AAAADBbUCSAAA//8AIf/7AfEDQwAiAq4AAAADBaYCHQAA//8AIf/7AfEDKwAiAq4AAAADBbACHAAAAAMAIf/7AfEC1wAhAD4ASgD+S7AQUFhACxQDAgYBOAEIBAJMG0uwIVBYQAsUAwIGAjgBCAQCTBtACxQDAgYCOAEIBQJMWVlLsBBQWEAqAgEBBgGFAAYABoUKAwIABACFAAgIBGEFAQQENk0MAQkJB2ILAQcHNAdOG0uwIVBYQDIAAQIBhQACBgKFAAYABoUAAAMAhQoBAwQDhQAICARhBQEEBDZNDAEJCQdiCwEHBzQHThtANgABAgGFAAIGAoUABgAGhQAAAwCFCgEDBAOFAAUFNk0ACAgEYQAEBDZNDAEJCQdiCwEHBzQHTllZQCA/PyIiAAA/Sj9JRUMiPiI9MzEuLCooACEAICYnJg0JGSsAJicnBwYGIyImNTQ2NzY2MzIWFxc3NjYzMhYVFAYHBgYjAiYmNTQ2NjMyFxYzMjY3NjMyFgcGBgcWFRQGBiM2NjU0JiMiBhUUFjMBOhgTWiYGFQsPFhEPEyYWDhcTWyUGFQsPFhAPFCUWqlMqOWI9IBoMDRsgCQcmGhoDBTAoITpjPC0vKBwkLygeAhQLD0o/CwsVEg4lGiEfChBKPwsLFRIOJBshH/3nO2A3THdDBAMwLichITJKEzdITHdDbEpHNzhJSDk2AP//ACH/+wH8A0QAIgKeAAAAAwWoAjEAAP//ACH/+wHiAvQAIgKeAAAAAwWyAjEAAP//ACH/+wGyAnIAIgKeAAAAAwWvAjAAAAACACH/BgGyAdMAIgAuAHdLsBJQWLUEAQEFAUwbtQQBAgUBTFlLsBJQWEAdBwEFBAEEBQGAAgEBBgEDAQNmAAQEAGEAAAA2BE4bQCMHAQUEAgQFAoAAAgEEAgF+AAEGAQMBA2YABAQAYQAAADYETllAFCMjAAAjLiMtKScAIgAhIioqCAkZKxYmNTQ3JiY1NDY2MzIWFhUUBwYGFRQWMzI3NjMyFRQHBgYjAjY1NCYjIgYVFBYzzVEzREo6Zj44Uil4MSckGhoVEQoaLwwnEAwvKBwkLyge+kc9RTIRcUpMd0M7YDeYVSM5HR0eBwYlKBAEBgFhSkc3OElIOTYAAAAAAwAh/34BvAJPAB0AJAArAE1ACyspIR8aCwYAAgFMS7AJUFhAFwADAgIDcAABAAABcQACAjZNAAAANABOG0AVAAMCA4UAAQABhgACAjZNAAAANABOWbYjGSMSBAkaKyQGBgcHBgYjIiY3NyYmNTQ2Njc3NjYzMhYHBxYWFQQXNzcGBhUWNjU0JwcHAbw4YDoRAhgPDxMCFEBDOGA8EQIYDw8TAhQ+Q/7fHRkSHymFJyARGrh1RQNkDA0NDGwTcUZKdkQCYwwNDQxsE3BGcB2IbQlJQWhLP0YdXJoA//8AIf9+AbwDQgAiArgAAAADBacB1wAA//8AIf/7Ae4C1wAiAp4AAAADBa4CMQAA//8AIf/7Ae4DfQAiAp4AAAAjBa4CMQAAAQcFrwJRAQsACbEDAbgBC7A1KwAAAwAh//sCxQHTACYAMAA8AQdLsCFQWEASFgEGAikBBQYfAQQFCQEABARMG0uwJlBYQBIWAQYCKQEFBx8BBAUJAQAEBEwbQBIWAQYCKQEFBx8BCAUJAQAEBExZWUuwIVBYQCQJAQUGBAYFBIAHCgIGBgJhAwECAjZNCwgCBAQAYQEBAAA0AE4bS7AmUFhALgkBBQcEBwUEgAoBBgYCYQMBAgI2TQAHBwJhAwECAjZNCwgCBAQAYQEBAAA0AE4bQDgJAQUHCAcFCIAKAQYGAmEDAQICNk0ABwcCYQMBAgI2TQsBCAgAYQEBAAA0TQAEBABhAQEAADQATllZQBwxMScnAAAxPDE7NzUnMCcvACYAJSYjJiMmDAkbKyQWFRQHBgYjIicGBiMiJiY1NDY2MzIXNjYzMhYVFAYHFjMyNjc2MyYGFRU2NjU0JiMANjU0JiMiBhUUFjMCtg8RHFs/aDQcSCg5Uio6YztUMh1NKjxHY3cYOSk1IwwPyTM7RBUS/v8xKBokMSMewRgVJBorMEQgJDtgN0x3Q0giJUU7RWMdLiYtD69WPQIOOCUTF/71TkU2O05FODkAAAAD/4n+NwG8AdgAHAApADIAOkA3FgEEAiwpJQwEAAQCTAAEBAJhAwECAjZNAAAANE0GAQUFAWEAAQE4AU4qKioyKjEoJikiEgcJGyskBgYHBgIjIiY1NBI3NCcmNjMyFhcUFzY2MzIWFQY2NjU0JiMiBwYVFAcCNjcGBhUUFjMBvEl5RQ1cWTY0Wl4CATAkFRMBASA+IzhH3j0kGBQkMwEBpCQFKzIPCuKNWALB/v1ORWIBBZ2SOR0iERkZDCgjWknOP10zHh9MLFUuGf4+669ktj4gIgAAAAACABj+sQHXAxAAIAApADFALhYBAgEkGgIDAAMCTAABAgGFAAADAIYEAQMDAmEAAgI2A04hISEpISgoKScFCRkrJAYHBhUXFAYjIiY1NBI3NhM2NjMyFhUUBwYHNjYzMhYVJgYGBzY2NTQjAdeZqAIBJxwcHgsNFzgIJRshHgQxJCZkNi09szk1EVddHsC6EV4sgCAaFhtoAR972wEJKCAUFgYUyOlYX0tGD0VxQAtmSTwAAAACACP+sQHRAfoAIQAsAEJAPxIBBAEFAQAFAkwAAgEChQYBAwADhgAEBAFhAAEBNk0HAQUFAGEAAAA0AE4iIgAAIiwiKyYlACEAICQlJwgJGSsSJjc2NjcGBiMiJjU0NjYzMhYXNjYzMhYHBgcGBwYHBgYjAjY3Nw4CFRQWM+weAQIXExItHTdFSntFChYGCCQeHhYCAhIhFSoTAyMbICQLKixKKhkW/rEaITuuXR0aV0xQj1cGBhoYFBMOSoNu3r8iGgGvMi24AT1kOB8eAAAAAQAy//sB+QHSADIAOEA1KAEAAQFMBgEFAwEDBQGAAAEAAwEAfgAAAANhBAEDAzZNAAICNAJOAAAAMgAxKiYlKCYHCRsrABYVFAcGBiMiJjU0NzY1NCYjIgYGBwYGIyImNTQ3NjYzMhYVFAcGBgc+AjMyFhUUBzMB2h8GEDojHCcCAgcFDjAwDwscICYfJQkpJRQQDwoMBCFSTiAdHwsJAUkfFw0PJTIoIhMWEAYICENuPTAgUFiCdR0bCg4QOCg8LFZsLiEgEzUAAAD//wAy//sB+QNCACICwAAAAAMFpwJPAAD//wAy//sB+QNcACICwAAAAAMFqwJPAAD//wAm/swB+QHSACICwAAAAAMFtwHhAAD//wAy//sB+QNEACICwAAAAAMFsQJPAAD//wAy//sCAAL0ACICwAAAAAMFsgJPAAAAAf/1/+UBhAHdADAAfUALIQwCAAIIAQEAAkxLsBdQWEAZAAEAAwABA4AAAgI2TQAAAANiBAEDAzQDThtLsDBQWEAWAAEAAwABA4AAAAQBAwADZgACAjYCThtAHgACAAKFAAEAAwABA4AAAAEDAFkAAAADYgQBAwADUllZQAwAAAAwAC8rKiQFCRkrFiY1NDYzMhYXLgInBgYHBiMiJjU0Nzc2NzY2NzYzMhYVFAYHBhUUFhcWFhUUBgYjtjcmJQ0jCQEVIA4fPSQSFBAUDg03HBIlHhM8HBYIBxIVFiAhJ0YtGzAeGiYFARouKxA7TiMSFxEUERBELB1QRSwKCwYaDSQZDyQbKjsjKksu////9f/lAcEDQgAiAsYAAAADBacCMwAA////9f/lAd0DXAAiAsYAAAADBasCMwAAAAH/9f8GAYQB3QBLAKRAEUArAgQGJwEFBB8bAgMDBQNMS7AuUFhAHgAFBAMEBQOAAAQAAwEEA2kCAQEAAAEAZgAGBjYGThtLsDBQWEAlAAUEAwQFA4AAAQMCAwECgAAEAAMBBANpAAIAAAIAZgAGBjYGThtALQAGBAaFAAUEAwQFA4AAAQMCAwECgAAEAAMBBANpAAIAAAJZAAICAGIAAAIAUllZQAorKiokIxQnBwkdKyQGBxYVFAYGIyInJjU0MzIXFjMyNjU0JiMiJjU0NzY3JjU0NjMyFhcuAicGBgcGIyImNTQ3NzY3NjY3NjMyFhUUBgcGFRQWFxYWFQGEJyMfLVU5JhgnKAgFGxooLSslGhwBBQsEJiUNIwkBFSAOHz0kEhQQFA4NNxwSJR4TPBwWCAcSFRYgIV1LFh8zL0sqBQclLQEEISIZHQ4RBgMUCQkNGiYFARouKxA7TiMSFxEUERBELB1QRSwKCwYaDSQZDyQbKjsjAP////X/5QGwA1wAIgLGAAAAAwWqAjIAAP////X+zAGEAd0AIgLGAAAAAwW3AlcAAAABACv/JAJBAw0ARgBitSEBAwIBTEuwCVBYQB8AAgQDAwJyAAUBBYYAAAAEAgAEaQADAwFiAAEBNAFOG0AgAAIEAwQCA4AABQEFhgAAAAQCAARpAAMDAWIAAQE0AU5ZQA5EQjs5KCYfHRkXIwYJFysWExI2MzIWFhUUBgcGBhUUFhceAhUUBiMiJjU0NjMyFhUUBhUUFjMyNjU0JicuAjU0Njc2NjU0JiMiBgcGFRUUBiMiJjUrCgu1jzpTLDc0Jx0gIyMtIGxYWVQoIhQWBSAfHygmJyQsIDM7KScrJlZnBwUpHBgkCgEBARf/K0otO00jHB8SFR4YFiU6KEVRQjMoMBEOBxgLFhsbGBglGRgkNiQrQigbLx4iKNPZuKNaExYTEgAAAwAK/jkB7AM8ADQAQABIAI1ADiABBgIRAQEDQwEHAQNMS7AbUFhAKgkBBgAFBAYFaQACAjNNCAEEBDZNAAMDAWIAAQE0TQoBBwcAYQAAADgAThtAKgACBgKFCQEGAAUEBgVpCAEEBDZNAAMDAWIAAQE0TQoBBwcAYQAAADgATllAG0FBNTUAAEFIQUc1QDU/OzkANAAzKygoKAsJGisAFhUUBwYHAgIjIiY1NDY3NjcGIyI1NDc2Ejc2NjMyFhUUBwcGBgcGFRQzMjY3Njc2NzY2MzYWFRQGIyImNTQ2MwI2NwYGFRQzAasTHwQJJYRsM0BumAEEOTl3Aws6HwknIB4dBAcuKgwKGxExJQMECggEJCUxLjQrKio3Kfc+G0xDHAHSEhAryhg9/wD+0z8zR6F2CxYvoBscaQEviiggFBYGFB7IvU4/NCspLBcqXj0dG94kISgvJyMjL/vqdoNBaSgnAAACABv+OQHNAdIALwA2AEBAPSsBAgEyAQUCAkwAAQMCAwECgAYEAgMDNk0AAgI0TQcBBQUAYQAAADgATjAwAAAwNjA1AC8ALiYlKicICRorABUUBwYHBgIjIiY1NDY/AjY1NCMiBgYHBgYjIiY1NDc2NjMyFhUUBwYGBz4CMwI2NwYVFDMBzRsKByOGbDI/bZYGBhsLDS8xDwsdHyYfJQkpJRQQDwoMBCFSTyHZOxuMHAHSQReoODTy/sU+NEahdSsqvw4QQ249LyFQWIJ1HRsKDhA4KDwsVmwu/MhyhHhXJwAAAAAC/4X+OQHRAdIAKQAyAEFAPicmAgEDLQEFAAJMAAEDAAMBAIAGBAIDAzZNAAAANE0HAQUFAmEAAgI4Ak4qKgAAKjIqMQApACgpJCcoCAkaKwAVFAcGBhUUBiMiJjU0NzY1NCMiBwYCBiMiJjU0Njc2NzY2MzIWBwc2MwA2NjcGFRQWMwHRCwoMHyMhHg4MCxxSFThUPjc1YGcIDgInJh4UAQh0RP5xGhYMbg8RAdJBGkg9bUMmISIiKFxQFhB07v7lg0cyVtibWcYdGxIQbY/8wT6Pgb5hGBcAAAAAAv/W/nEBwgH0ADEAOgBaQAk1GxEFBAQCAUxLsCxQWEAUAwEBAgGFBQEEAAAEAGYAAgI2Ak4bQB0DAQECAYUAAgQChQUBBAAABFkFAQQEAGIAAAQAUllAEDIyMjoyOS8tKScjISoGCRcrAAYHBgYHFhUUBgYjIiY1NDY3JiYnJiY1NDc2NycmJjU0NjMyFhcWFjMyNjc2NjMyFhUANjY1BgYVFDMBwhUUTWMzkk94ODU+cHUOKh4WHBJCZpwRERoUEz4eKjgWDBMMDhALERn+qjopTUocAaEiDTdUNjWkW6dlOzpFl1YZHg0JJRYWFk9QEwIcFBkpDAgLCwsLDAomHv0fSnAzOmEqKAAA////1v5xAcIDQgAiAtAAAAADBacCLQAA////1v5xAdcDXAAiAtAAAAADBasCLQAA////1v5xAcICsAAiAtAAAAADBaUCLQAAAAIAAf/7AcADaQAuADcASEBFMgEECAFMAAEDAAMBAIAABQoBCAQFCGkJBwIDAwRhBgEEBDZNAAAAAmEAAgI0Ak4vLwAALzcvNgAuAC0kIyMkJiMlCwkdKxMGFRQWFjMyNjc2MzIWFRQGBwYjIiY1NDcjIiY1NDMzPgIzMhYVFAczMhYVFCMCBgYHNjY1NCPVAg8jHxAsEgsLDA8PDzRCX1gDJx4VLTkRRmM5KjCCcBAOcR8lIQs7OxYBczIcSFEjFBAKGxMTJAwrn4AsLRYYOG62bEo4m3MOE0UBlkuFUTN/NDsAAAH/+f/7AZAC/QBDAEdARCUBBQYBTAAGBQaFAAACCwIAC4AHAQUIAQQDBQRqCQEDCgECAAMCaQALCwFhAAEBNAFOQT89Ozc0JDYkIyIkIiYgDAkfKyQzMhYVFAYHBiMiJjcjIiY1NDYzMzY3IyImNTQzMzY3NjYzMhYVFAcGBzMzMhYVFAYjIwYHMzMyFhUUBiMjBhYzMjY3AWMLDA8PDzRCVl0EGR8VFRgqBwMaHhUtMxQZCScgHh0EIBASbxAOMypYCAUhWxAOMylJAiEoECwSlxsTEyQMK35qFhYXHTETFhg4YWcoIBQWBhSATA4TISQjIQ8THSE9PRQQ//8AAf/7AnEDpwAiAtQAAAEHBakDLwHWAAmxAgG4AdawNSsAAAIAAf8GAcADaQBMAFUApkAMUAEHCzEsEwMFAAJMS7AuUFhANQABBgAGAQCAAAAFBgAFfgAFAwYFA34ACA0BCwcIC2kEAQMAAgMCZQwKAgYGB2EJAQcHNgZOG0A7AAEGAAYBAIAAAAUGAAV+AAUDBgUDfgADBAYDBH4ACA0BCwcIC2kABAACBAJlDAoCBgYHYQkBBwc2Bk5ZQBpNTQAATVVNVABMAEtIRiMjLCQjFCwjJQ4JHysTBhUUFhYzMjY3NjMyFhUUBgcGBxYVFAYGIyInJjU0MzIXFjMyNjU0JiMiJjU0NzY2NyYmNTQ3IyImNTQzMz4CMzIWFRQHMzIWFRQjAgYGBzY2NTQj1QIPIx8QLBILCwwPDw8hJiQtVTkmGCcoCAUbGigtKyUaHAEDERElJAMnHhUtORFGYzkqMIJwEA5xHyUhCzs7FgFzMhxIUSMUEAobExMkDBsKITYvSyoFByUtAQQhIhkdDhEGAxATAyV+USwtFhg4brZsSjibcw4TRQGWS4VRM380OwAAAP//AAH+zAHAA2kAIgLUAAAAAwW3AmAAAAABADD/+wG3AdIALwAuQCsLAQEAAUwsAQEBSwIBAAA2TQABAQNiBQQCAwM0A04AAAAvAC4qJSonBgkaKxYmNTQ2NzY2MzIWFRQHBgcGFRQWMzI2Njc2NjMyFhUUBgcGBhUUBiMiJjU0NwYGI2k5FBcKJCcWEQsKBhQKCw8uMxcIISEWEwgFCgwfIyUdAhFDJgVNREt9Rh4aDg4ILiUeaSMVET17Vx4aFxcZPSBAaUMmISc4CyZGSgD//wAw//sB3wNCACIC2QAAAAMFpwJRAAD//wAw//sCAgL0ACIC2QAAAAMFrAJRAAD//wAw//sBzgNcACIC2QAAAAMFqgJQAAD//wAw//sBtwNEACIC2QAAAAMFsQJRAAD//wAw//sB4wKxACIC2QAAAAMFpAJRAAD//wAw/xwBtwHSACIC2QAAAAMFtQJQAAD//wAw//sBtwNDACIC2QAAAAMFpgJRAAD//wAw//sBvAMrACIC2QAAAAMFsAJQAAAAAQAw//sCOQJRADYANEAxCwEBAAFMMwEBAUsAAwADhQIBAAA2TQABAQRiBgUCBAQ0BE4AAAA2ADUsIyUqJwcJGysWJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMjY3NjMyFgcGBgcGBwYGFRQGIyImNTQ3BgYjaTkUFwokJxYRCwoGFAoLDy4zFwghIR8jCAcmGhoDBkQ4AggLCx8jJR0CEUMmBU1ES31GHhoODgguJR5pIxURPXtXHhoqLichITxTDRAzQWpDJiEnOAsmRkoAAP//ADD/+wI5A0IAIgLiAAAAAwWnAlEAAP//ADD/HAI5AlEAIgLiAAAAAwW1AlAAAP//ADD/+wI5A0MAIgLiAAAAAwWmAlEAAP//ADD/+wI5AysAIgLiAAAAAwWwAlAAAAACADD/+wI5AtcAIQBYAKdLsBBQWEAQFAMCBwEtAQUEAkxVAQUBSxtAEBQDAgcCLQEFBAJMVQEFAUtZS7AQUFhAJQIBAQcBhQAHAAeFCgMCAAQAhQYBBAQ2TQAFBQhiCwkCCAg0CE4bQC0AAQIBhQACBwKFAAcAB4UAAAMAhQoBAwQDhQYBBAQ2TQAFBQhiCwkCCAg0CE5ZQBwiIgAAIlgiV1FPQ0E+PDc1KykAIQAgJicmDAkZKwAmJycHBgYjIiY1NDY3NjYzMhYXFzc2NjMyFhUUBgcGBiMAJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMjY3NjMyFgcGBgcGBwYGFRQGIyImNTQ3BgYjAW4YE1omBhULDxYRDxMmFg4XE1slBhULDxYQDxQlFv7tORQXCiQnFhELCgYUCgsPLjMXCCEhHyMIByYaGgMGRDgCCAsLHyMlHQIRQyYCFAsPSj8LCxUSDiUaIR8KEEo/CwsVEg4kGyEf/edNREt9Rh4aDg4ILiUeaSMVET17Vx4aKi4nISE8Uw0QM0FqQyYhJzgLJkZKAAD//wAw//sCHANEACIC2QAAAAMFqAJRAAD//wAw//sCAgL0ACIC2QAAAAMFsgJRAAD//wAw//sByQJyACIC2QAAAAMFrwJQAAAAAQAw/wYB4QHSAEQAaUAPGAECAQUBAAICTAkBAgFLS7ASUFhAGgUBBAcBBgQGZQMBAQE2TQACAgBiAAAANABOG0AhAAUABAAFBIAABAcBBgQGZQMBAQE2TQACAgBiAAAANABOWUAPAAAARABDIi8lKicrCAkcKwQmNTQ2NyY1NDcGBiMiJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMhYVFAYHBgYVFAYHBhUUFjMyNzYzMhUUBwYGIwEqUR4hCAIRQyYvORQXCiQnFhELCgYUCgsPLjMXCCEhFhMIBQoMDA86JBoaFRALGi8MJxD6Rz0rQiUSKg0mRkpNREt9Rh4aDg4ILiUeaSMVET17Vx4aFxcZPSBAaUMXGw0wOB0eBwYlKBAEBv//ADD/+wG/AywAIgLZAAAAAwWtAlEAAP//ADD/+wIOAtcAIgLZAAAAAwWuAlEAAAABADL/+wHIAdMAHAAhQB4NAQIAAUwBAQAANk0DAQICNAJOAAAAHAAbKScECRgrFiYnJjU1NjYzMhYVFBc2Njc2NjMyFRQHBgcGBiN0MAYMASIiGhkOKz8lCyQbNwhRSCNAJgU/RoxpIyEaFxtzuEp7ZR4VIwwVvXQ5KgAAAQAz//sCvgHTADEAKEAlKx8NCwQAAgFMBQQDAwICNk0BAQAANABOAAAAMQAwKScnJwYJGisAFRQHBgcGBiMiJicmJw4CIyImJyY1NTY2MzIWFRQXNjY3NjYzMhYVFRQXNjY3NjYzAr4IUUgkOiUoJwUCAh8zMSIpLwYMASAkGhkOITglCx8VHBwBLjslCyQbAdMjDBW9dDkqPkcaNFZbIkBFjGkjIhkXG3O4RoBkHhUXG5tkLFB2ZB4VAP//ADP/+wK+A0IAIgLvAAAAAwWnAqcAAP//ADP/+wK+A1wAIgLvAAAAAwWqAqYAAP//ADP/+wK+ArEAIgLvAAAAAwWkAqcAAP//ADP/+wK+A0MAIgLvAAAAAwWmAqcAAAABABH/+wJXAdYASAChQBIuAQQGEwELAhYBAwsJAQADBExLsAlQWEA0AAIFCwMCcgwBCwMFCwN+CQEEBAZhBwEGBjZNCAEFBQZiBwEGBjZNCgEDAwBiAQEAADQAThtANQACBQsFAguADAELAwULA34JAQQEBmEHAQYGNk0IAQUFBmIHAQYGNk0KAQMDAGIBAQAANABOWUAWAAAASABHRUM+PCQkJCQlJSQjJQ0JHyskFhUUBwYjIiYnBiMiJjU0NjMyFRQHBxQzMjY2NTQmIyIGBwYGIyImNTQ2MzIWFzY2MzIWFRQGIyImJyYmIyIGBhUUFjMyNzYzAkgPETttL0kXOk03QC4qJAIDGhMjFxINCwoFBhQZFho+MSpEEh5LJCcpIhgWEAQCCAoMGxMpHTc2ChHBGBUkGlslI0dANTI+GwgUJh4tTi8kMQsNEBMfIDM6KScoKCQoLTMSEQwMLUooLTZPDwAAAAAC//z+OQG3AdIAMgA7AD5AOyITAgMCNQEFAQJMBgQCAgI2TQADAwFiAAEBNE0HAQUFAGEAAAA4AE4zMwAAMzszOgAyADEqJysoCAkaKwAWFRQHBgcCAiMiJjU0NjY3NzY3BgYjIiY1NDY3NjYzMhYVFAcGBwYGFRQzMjY2NzY2MwI2NwYGFRQWMwGlEhoXBCWCbDNAK3VrAwcJFEgoLTkUFwokJxYRCwoGCAwVDy0zGAghIfs+H01FDQ8B0gwOGJONGv7//tQ/My9if1IXJUVIS1M+S31GHhoODgguJR4pSxgmPHpZHhr8yHSHQWsoERYAAAD////8/jkB3wNCACIC9QAAAAMFpwJRAAD////8/jkBzgNcACIC9QAAAAMFqgJQAAD////8/jkB4wKxACIC9QAAAAMFpAJRAAD////8/jkB1gHSACIC9QAAAQcFtQL5/x0ACbECAbj/HbA1KwD////8/jkBtwNDACIC9QAAAAMFpgJRAAD////8/jkBvAMrACIC9QAAAAMFsAJQAAD////8/jkByQJyACIC9QAAAAMFrwJQAAD////8/jkCDgLXACIC9QAAAAMFrgJRAAAAAQAE/+oBswHXADAA1EuwEFBYQBkAAgIDYQUEAgMDNk0HAQYGAGIBAQAANABOG0uwElBYQB0AAgIDYQUEAgMDNk0HAQYGAGAAAAA0TQABATQBThtLsB1QWEAhAAQENk0AAgIDYQUBAwM2TQcBBgYAYAAAADRNAAEBNAFOG0uwJlBYQCEAAQABhgAEBDZNAAICA2EFAQMDNk0HAQYGAGAAAAA0AE4bQCQABAMCAwQCgAABAAGGAAICA2EFAQMDNk0HAQYGAGAAAAA0AE5ZWVlZQA8AAAAwAC8jIyQlInQICRwrJBYVFAYjIiYnJiMiBwYjIjU0NjY3BwYmNTQ2MzIXFhYzMjc2NjMyFhUUBgcOAgc3AZwXFxQkPxhcJg0ZIAw1Qmo5jRYXFxQsQQtJHwocBR0KEBUfHyNeVBT8biEYGSYCAQQJCkQudW4lBAEhFxglBwEGCAEIHB0gJg8QTl8qCwAAAP//AAT/6gHHA0IAIgL+AAAAAwWnAjkAAP//AAT/6gHjA1wAIgL+AAAAAwWrAjkAAP//AAT/6gGzArAAIgL+AAAAAwWlAjkAAP////z+OQJNA0IAIgIoAAAAIwWnAeMAAAADBacCvwAAAAIAN//7AkgDrAAuADgAhEAPMgEFBhkBAAUrIAIBAANMS7AwUFhAKgAABQEFAAGAAAEEBQEEfgcBBgYDYQADAzVNAAUFNk0ABAQCYQACAjQCThtALAAFBgAGBQCAAAABBgABfgABBAYBBH4HAQYGA2EAAwM1TQAEBAJhAAICNAJOWUAPLy8vOC83KCgkIxYRCAkcKwAzMhYVFAYHBgcOAiMiETQSNjMyFhUUBgcGFRQzMjY3JiY1NDY2MzIWFhc2NjcABgYHNjY1NCYjAiIHDxAYGCpCFEVPI6pAe1UuOHSEATYSOBIeHhkoFBosGwEcOQn+/ywoCz1QDw0BMRQRHyMIDQIxVTIBNnwBK9RPP2bXkRMksDspFUMkIDwkMU8qBAsCAhlrsGJIrUYgIgAAAAACACP/+wJXAzwAKwA2AKJLsBtQWEAODwEAAQgBBgApAQQCA0wbQA4PAQABCAEGACkBBAcDTFlLsBtQWEAmAAMGAgYDAoAAAQEzTQAGBgBhAAAANk0JBwICAgRiCAUCBAQ0BE4bQDEAAQABhQADBgIGAwKAAAYGAGEAAAA2TQACAgRiCAUCBAQ0TQkBBwcEYQgFAgQENAROWUAWLCwAACw2LDUwLwArAComIyskJQoJGysWJjU0NjYzMhc2NzYzMhYVFAcHAgcGFRQWMzI2NzYzMhYVFAcGBiMiJicGIzY2NzcOAhUUFjNtSkp5QxcMGxMJRR8cAhM1GxAPDBM2LgwPDQ8TKVwrITcONE86KAklKkcqGRYFWklPkFcVx3g+FBUFDFv++ppYJQ8SMTcOGBUoFjNGLSdUZTQruAE9ZDgfHgAAAAAC/2n+OAHJA6wAMQA7AJ9LsAlQWEAPNQEABy0LAgEAGQEEAwNMG0ASNQEABy0BBgALAQEGGQEEAwRMWUuwCVBYQCcAAwEEAQMEgAYBAAABAwABaQgBBwcFYQAFBTVNAAQEAmIAAgI4Ak4bQC4AAAcGBwAGgAADAQQBAwSAAAYAAQMGAWkIAQcHBWEABQU1TQAEBAJiAAICOAJOWUAQMjIyOzI6JiUoJSQmIAkJHSsAMzIVFAYHBgYjIicGAgYjIiY1NDc2MzIWFRQHBhUUFjMyEhM2EjYzMhYVFAIHFjMyNwIGBgc2NjU0JiMBpgUeFxoSQiQvPAUzV0I5Qj0KHBMcBDITDSMrBgM/elUuOGNOFw4tQ3g5KgNFVBAMATAkIiIJBQkK+v7ncFJGdmsSEhAICGRPJCUBMAFfiQEu0U8/cv7uewMQAh2l9W507WUfIwABACz/+wFuAzwAIwBQtQwBAgABTEuwG1BYQBkAAgABAAIBgAAAADNNAAEBA2IEAQMDNANOG0AWAAACAIUAAgEChQABAQNiBAEDAzQDTllADAAAACMAIiMrKAUJGSsWNTQ3NhI3NjYzMhYVFAcHBgYHBhUUMzI2NzYzMhYVFAcGBiMsAws6HwknIB4dBAcuKgwKGxM2LgwPDQ8TLFg0BaAbHGkBL4ooIBQWBhQeyL1OPzQrMTcOGBUoFjZD//8ALP/7AfAEcAAiAwYAAAEHBcACFQFwAAmxAQG4AXCwNSsA//8ALP7MAW4DPAAiAwYAAAADBbcB9wAAAAMACv45AlgDPAA/AEsAUwCiQBIhAQYCOwEDBRIBAQNOAQgBBExLsBtQWEAyCQEFBAMEBQOAAAYKAQcEBgdpAAICM00ABAQ2TQADAwFiAAEBNE0LAQgIAGEAAAA4AE4bQDIAAgYChQkBBQQDBAUDgAAGCgEHBAYHaQAEBDZNAAMDAWIAAQE0TQsBCAgAYQAAADgATllAHExMQEAAAExTTFJAS0BKRkQAPwA+KCsoKCkMCRsrJBYVFAYHBgcGBiMiJjU0Njc2NwYjIjU0NzYSNzY2MzIWFRQHBwYGBwYVFDMyNjc2NzY3NjYzMhYVFAcHNjc2MwImNTQ2MzIWFRQGIwI2NwYGFRQzAkkPDg9GdSd8YDNAbpgBBDk5dwMLOh8JJyAeHQQHLioMChsRMSUDBAoIBCQlHhMhClBCDQreKjcpJS40K+Y+G0xDHN0ZExcaCi5R0O4/M0ehdgsWL6AbHGkBL4ooIBQWBhQeyL1OPzQrKSwXKl49HRsSEC7QRTwsCAE3JyMjLyQhKC/8hnaDQWkoJwAAAQAG//sBxQOnADgAP0A8IgwCAQMBTAADAgECAwGAAAEFAgEFfgYBBQQCBQR+AAICNU0ABAQAYgAAADQATgAAADgANywoKiclBwkbKyQWFRQHBiMiNTQ3NjcHBiMiJjU0NzY3Njc2NjMyFhUUBwYHNzYzMhcWFRQHBwYHBhUUFjMyNjc2MwG2DxNjbbADBRMCCwkUHQ8oKSQmCyYfHh0EGCFKDQ4TBwkzcyAHCSIlKT4wDA/fGBUoFnnOHB8vbQEGJBQTChkYso4oIBQWDQ1bjCwIDxIPJR9Gkis5KzY2LzkOAAAAAgAb/jkCaQHSAD0ARABMQEkuAQUBOQECBUABBgIDTAABAwUDAQWABwEFAgMFAn4EAQMDNk0AAgI0TQgBBgYAYQAAADgATj4+AAA+RD5DAD0APComJSoqCQkbKyQWFRQGBwYHBwYGIyImNTQ2PwI2NTQjIgYGBwYGIyImNTQ3NjYzMhYVFAcGBgc+AjMyFRQGBwYHNjc2MwA2NwYVFDMCWg8OD1YoQCZ+XjI/bZYGBhsLDS8xDwsdHyYfJQkpJRQQDwoMBCFSTyFBFwIOBE1HDQr+ZjsbjBzdGRMXGgo6HCvH9T40RqF1Kyq/DhBDbj0vIVBYgnUdGwoOEDgoPCxWbC5BEJIQVh48Lgj9vXKEeFcnAAAAAgAh//sCLgHTABkAJQA0QDEIAQADAUwAAAMEAwAEgAADAwJhAAICNk0FAQQEAWEAAQE0AU4aGholGiQnJigjBgkaKwAVFAYjIicmJxYVFAYGIyImJjU0NjYzMhYXADY1NCYjIgYVFBYzAi4SEw8MMx0JNV47OlQqO2xISoY2/vAvKBwkLygeAVYhGSAJKBAiLkNvQDtgN013Qjwt/v1KRzc4SUg5NgD//wAh//sCLgNCACIDDAAAAAMFpwIxAAD//wAh//sCLgL0ACIDDAAAAAMFrAIxAAD//wAh//sCLgNcACIDDAAAAAMFqgIwAAD//wAh//sCQANrACIDDAAAAQcF6QIx//sACbECArj/+7A1KwD//wAh/xwCLgNcACIDDAAAACMFtQJIAAAAAwWqAjAAAP//AAX/+wIuA2sAIgMMAAABBwXqAjH/+wAJsQICuP/7sDUrAP//ACH/+wJIA2EAIgMMAAABBwXrAjH/+wAJsQICuP/7sDUrAP//ACH/+wIuA4IAIgMMAAABBwXsAjH/+wAJsQICuP/7sDUrAP//ABb/+wIuA0QAIgMMAAAAAwWxAjEAAP//ACH/+wIuArEAIgMMAAAAAwWkAjEAAP//ACH/+wIuA1cAIgMMAAAAIwWkAjEAAAEHBa8CTADlAAixBAGw5bA1KwAA//8AIf/7Ai4DVgAiAwwAAAAjBaUCMQAAAQcFrwJMAOQACLEDAbDksDUrAAD//wAh/xwCLgHTACIDDAAAAAMFtQJIAAD//wAh//sCLgNDACIDDAAAAAMFpgIxAAD//wAh//sCLgMrACIDDAAAAAMFsAIwAAAAAgAh//sCLgJRACYAMgCQS7AhUFhAChUBBQAgAQMFAkwbQAoVAQUBIAEDBQJMWUuwIVBYQCUAAgAChQADBQYFAwaAAAUFAGEBAQAANk0IAQYGBGEHAQQENAROG0ApAAIAAoUAAwUGBQMGgAABATZNAAUFAGEAAAA2TQgBBgYEYQcBBAQ0BE5ZQBUnJwAAJzInMS0rACYAJSojIiYJCRorFiYmNTQ2NjMyFxYzMjY3NjMyFgcGBxYXFhUUBiMiJyYnFhUUBgYjNjY1NCYjIgYVFBYzn1QqOmlEGBgMDhsgCQcmGhoDBikrJhgSEw8MMx0JNV47LS8oHCQvKB4FO2A3TXdCBAMwLichIUQqGB8UIRkgCSgQIi5Db0BsSkc3OElIOTYA//8AIf/7Ai4DQgAiAxwAAAADBacCHQAA//8AIf8cAi4CUQAiAxwAAAADBbUCSAAA//8AIf/7Ai4DQwAiAxwAAAADBaYCHQAA//8AIf/7Ai4DKwAiAxwAAAADBbACHAAAAAMAIf/7Ai4C1wAhAEgAVAEkS7AQUFhADxQDAgYBNwEJBEIBBwkDTBtLsCFQWEAPFAMCBgI3AQkEQgEHCQNMG0APFAMCBgI3AQkFQgEHCQNMWVlLsBBQWEAyAgEBBgGFAAYABoULAwIABACFAAcJCgkHCoAACQkEYQUBBAQ2TQ0BCgoIYgwBCAg0CE4bS7AhUFhAOgABAgGFAAIGAoUABgAGhQAAAwCFCwEDBAOFAAcJCgkHCoAACQkEYQUBBAQ2TQ0BCgoIYgwBCAg0CE4bQD4AAQIBhQACBgKFAAYABoUAAAMAhQsBAwQDhQAHCQoJBwqAAAUFNk0ACQkEYQAEBDZNDQEKCghiDAEICDQITllZQCJJSSIiAABJVElTT00iSCJHPz0zMS4sKigAIQAgJicmDgkZKwAmJycHBgYjIiY1NDY3NjYzMhYXFzc2NjMyFhUUBgcGBiMCJiY1NDY2MzIXFjMyNjc2MzIWBwYHFhcWFRQGIyInJicWFRQGBiM2NjU0JiMiBhUUFjMBOhgTWiYGFQsPFhEPEyYWDhcTWyUGFQsPFhAPFCUWqVQqOmlEGBgMDhsgCQcmGhoDBikrJhgSEw8MMx0JNV47LS8oHCQvKB4CFAsPSj8LCxUSDiUaIR8KEEo/CwsVEg4kGyEf/ec7YDdNd0IEAzAuJyEhRCoYHxQhGSAJKBAiLkNvQGxKRzc4SUg5NgD//wAh//sCLgNEACIDDAAAAAMFqAIxAAD//wAh//sCLgL0ACIDDAAAAAMFsgIxAAD//wAh//sCLgJyACIDDAAAAAMFrwIwAAAAAgAh/wYCLgHTACwAOACIS7ASUFhACggBAAUiAQEGAkwbQAoIAQAFIgECBgJMWUuwElBYQCMAAAUGBQAGgAcBBgEFBgF+AgEBAAMBA2YABQUEYQAEBDYFThtAKQAABQYFAAaABwEGAgUGAn4AAgEFAgF+AAEAAwEDZgAFBQRhAAQENgVOWUAPLS0tOC03JyolIiwjCAkcKwAVFAYjIicmJxYVFAcGBhUUFjMyNzYzMhUUBwYGIyImNTQ3JiY1NDY2MzIWFwA2NTQmIyIGFRQWMwIuEhMPDDMdCXAxJyQaGhURChovDCcQRVEzREc7bEhKhjb+8C8oHCQvKB4BViEZIAkoECIuiFEjOR0dHgcGJSgQBAZHPUUyEHNJTXdCPC3+/UpHNzhJSDk2AAAAAwAh/34CLgJPACcALgA1ACZAIzMrJAgEAAI1KRYDAQACTAACAAKFAAABAIUAAQF2LCwjAwkZKwAVFAYjIicmJxYVFAYGBwcGBiMiJjc3JiY1NDY3NzY2MzIWBwcWFhcEFzc3BgYVFjY1NCcHBwIuEhMPDDMdCTBWNxECGA8PEwIUP0RzYRECGA8PEwITPnAs/ogbGBIeJ3gfEg0ZAVYhGSAJKBAiLkBrQgRlDA0NDGsTckZtjgpkDA0NDGYIOCbUHYNpBklAXkc5Mx1JkgAA//8AIf9+Ai4DQgAiAyYAAAADBacB1wAA//8AIf/7Ai4C1wAiAwwAAAADBa4CMQAA//8AIf/7Ai4DfQAiAwwAAAAjBa4CMQAAAQcFrwJRAQsACbEDAbgBC7A1KwAAAv+F/jkCdQHSADUAPgBPQEwlJAIBAzkBBwACTAABAwYDAQaACAEGBQMGBX4EAQMDNk0ABQUAYgAAADRNCQEHBwJhAAICOAJONjYAADY+Nj0ANQA0JyQpJCcmCgkcKyQWFRQHBgYjIiY1NDc2NTQjIgcGAgYjIiY1NDY3Njc2NjMyFgcHNjMyFRQHBhUUFjMyNjc2MwA2NjcGFRQWMwJmDxMrYz80Mw4NCxxSFThUPjc1YGcIDgInJh4UAQh0RD8WExANFDcuDA/9qhoWDG4PEd8YFSgWNUQ7OBxIPxgQdO7+5YNHMlbYm1nGHRsSEG2PQSdmVxwUFDE3Dv20Po+BvmEYFwABAA3/+wHYAv0ANAA8QDkbAQIDAUwAAwIDhQgBBwEGAQcGgAQBAgUBAQcCAWoABgYAYQAAADQATgAAADQAMyYkNiQjJSUJCR0rJBYVFAcGIyI1NDc2NyMiJjU0MzM2NzY2MzIWFRQHBgczMzIWFRQGIyMGBwYVFBYzMjY3NjMByQ8TY22wAwYMGh4VLTMUGQknIB4dBCAQEm8QDjMqWAQLCSIlKT4wDA/fGBUoFnnOHB89RhYYOGFnKCAUFgYUgEwOEyEkED45KzY2LzkOAAAAAQAN/wYB2AL9AE8ApEALNgEFBiEGAgMJAkxLsC5QWEA4AAYFBoULAQoECQQKCYAACQMECQN+AAMBBAMBfgcBBQgBBAoFBGoCAQEAAAFZAgEBAQBhAAABAFEbQD0ABgUGhQsBCgQJBAoJgAAJAwQJA34AAwEEAwF+AAECBAECfgcBBQgBBAoFBGoAAgAAAlkAAgIAYQAAAgBRWUAUAAAATwBOS0kkNiQjKiQjFCsMCR8rJBYVFAcGBxYVFAYGIyInJjU0MzIXFjMyNjU0JiMiJjU0NyY1NDc2NyMiJjU0MzM2NzY2MzIWFRQHBgczMzIWFRQGIyMGBwYVFBYzMjY3NjMByQ8TRUsoLVU5JhgnKAgFGxooLSslGhwPQAMGDBoeFS0zFBkJJyAeHQQgEBJvEA4zKlgECwkiJSk+MAwP3xgVKBZWGSI5L0sqBQclLQEEISIZHQ4RGAwyfRsfPUYWGDhhZyggFBYGFIBMDhMhJBA+OSs2Ni85DgAAAP//AA3+zAHYAv0AIgMrAAAAAwW3AlsAAAAC/9b+cQIcAfQAPwBIAHNADR0BBAJDOzkTBAUEAkxLsCxQWEAdAwEBAgGFBgEEAgUCBAWABwEFAAAFAGYAAgI2Ak4bQCMDAQECAYUAAgQChQYBBAUEhQcBBQAABVkHAQUFAGIAAAUAUllAFkBAAABASEBHAD8APjEvKyklIywICRcrJBYVFAYHBgcWFRQGBiMiJjU0NjcmJicmJjU0NzY3JyYmNTQ2MzIWFxYWMzI2NzY2MzIWFRQGBwYGBxYXNjc2MwA2NjUGBhUUMwINDw0QdkUET3g4NT5vdg4qHhYcEkJmnBERGhQTPh4qOBYMEwwOEAsRGRUUTWMzSyNTcg0K/mw6KU5JHN0ZExccCEEqFR5bp2U7OkWWVxkeDQklFhYWT1ATAhwUGSkMCAsLCwsMCiYeDyINN1Q2HDU2Pwj98kpwMzpgKyj////W/nECHANCACIDLgAAAAMFpwItAAD////W/nECHANcACIDLgAAAAMFqwItAAD////W/nECHAKwACIDLgAAAAMFpQItAAAAAwA1/sQDFAOsAFkAYwBtAJVAC2ddAgYLEAECCQJMS7AZUFhAKgAGAAIABgJpDQoCCQAABQkAaQgBBQMBAQUBZQ8MDgMLCwRhBwEEBDULThtAMA0BCgYJCQpyAAYAAgAGAmkACQAABQkAaggBBQMBAQUBZQ8MDgMLCwRhBwEEBDULTllAIGRkWloAAGRtZGxaY1piAFkAWFVTKiM5KSUlNSUyEAkfKwAVFCMiJxYWFRQGIyImNTQ3BiMiBxYWFRQGIyImNTQSEjMyFhUUAgcGFRQWMzI2NTQmJyY1NDY3MzM2EjYzMhYVFAYGBwYVFBYzMjY1NCYnJjU0NjMyNjc2MwAGBgc2NjU0JiMgBgYHPgI1NCMDFIAFMwsNSTlIPQMJFBsRCgtJOUg9TYpXLTN1lAkOEA8SDwoCRTkYDhNXfUgvNUKBWQcOEA8SEAkCOCQiOQgiCv5EMTARTE0MCQExOTcSOU8nGQEYKlADNYdDbHLMzjU2AQFKiFNscszOwQGLAQJLRm3+9ZNYU2fZMjZily4HDis4AaYBJbRUR1javzBDSGfZMjZOji0IDik5BQEEAjF6ynJa01YZGozieS2WpEM9AAADABr+sQL6A6wAUgBbAGcBQEuwEFBYQA5VAQYNNAEEAiEBCQoDTBtADlUBCA00AQQCIQEJCgNMWUuwEFBYQEcABAIKAgQKgA4BCgkCCgl+AAEFAYYADBABDQYMDWkAAwAFAQMFaQ8BCwsHYQAHBzVNAAICBl8IAQYGNk0ACQkAYQAAADQAThtLsCpQWEBLAAQCCgIECoAOAQoJAgoJfgABBQGGAAwQAQ0IDA1pAAMABQEDBWkPAQsLB2EABwc1TQAGBjZNAAICCF8ACAg2TQAJCQBhAAAANABOG0BOAAYIAggGAoAABAIKAgQKgA4BCgkCCgl+AAEFAYYADBABDQgMDWkAAwAFAQMFaQ8BCwsHYQAHBzVNAAICCF8ACAg2TQAJCQBhAAAANABOWVlAIlxcU1MAAFxnXGZiYFNbU1oAUgBRTkw0IxonKSQnJBYRCR8rJBYVFAcGBgcGBwYGIyImNTQ3NhI3IgcGFRQWMzI2NjU0JzQnJjYzMhYXFhUUBgYjIiY1NDcGJjU0Njc3PgIzMhYVFAc2MzIWFRQGBzMyNjc2MwAGBz4CNTQjEiY1NDYzMhYVFAYjAusPEypfPBoUCScYGR4DHDcCZYsUFRUKFg4HAgIXFxUVAQUhSThHPhEpGxsmFRpVbD0vM6J7SxwkEQ0HITwvDA/+f0seMkQhFowqNyklLjQr3xgVKBYzQwO6SyMiGRwLD3wBfnkJjGVIwkBlMypJChQcGxYaWzVPnmzEuHJ9AxYZGR4DAYbbg0k5yY0FFR4cuGkwOA4CbdGTImlvLzv+yCcjIy8kISgvAAMAGv7EAvoDrABPAFgAZAGBS7AQUFhAClIBBg0gAQoDAkwbQApSAQgNIAEKAwJMWUuwEFBYQEIAAwEKAQMKgA4BCgkBCgl+AAwQAQ0GDA1pAAIABAIEZQ8BCwsHYQAHBzVNBQEBAQZfCAEGBjZNAAkJAGEAAAA0AE4bS7ASUFhATAADAQoBAwqADgEKCQEKCX4ADBABDQgMDWkAAgAEAgRlDwELCwdhAAcHNU0FAQEBCF8ACAg2TQUBAQEGXwAGBjZNAAkJAGEAAAA0AE4bS7AqUFhASgADBQoFAwqADgEKCQUKCX4ADBABDQgMDWkAAgAEAgRlDwELCwdhAAcHNU0AAQEIXwAICDZNAAUFBl8ABgY2TQAJCQBhAAAANABOG0BIAAMFCgUDCoAOAQoJBQoJfgAMEAENCAwNaQAGAAUDBgVpAAIABAIEZQ8BCwsHYQAHBzVNAAEBCF8ACAg2TQAJCQBhAAAANABOWVlZQCJZWVBQAABZZFljX11QWFBXAE8ATktJNCMlNCYnJCUmEQkfKyQWFRQHBgYjIiY1NDY3IgcGFRQWMzI2NjU0JyY2MzIWFxYVFAYjIiY1NDcGIyImNTQ2NzYzPgIzMhYVFAc2MzIWFRQGBwYVFBYzMjY3NjMABgc+AjU0IxImNTQ2MzIWFRQGIwLrDxMpYzJBOxEOZIkWFRUKFg4JAhcXFRQCBU9TRz4TBwsfFRsmBw8bVGw8LzOiekscJA0IEhATETU0DA/+f0oeMkMhFpgqNyklLjQr3xgVKBYyR1xMJ3I3CYx5XctGekpRXhwbFhpJZaPozc15igEWFxkeAwGH3IFJOcmNBRUeFFIpVRseIC85DgJt0JQjaG8vO/7IJyMjLyQhKC8AAAMANP7EAzEDrABIAFEAWwBjQGBVTDQDBQpAAQkFDgEBCQNMDAEJBQEFCQGABgEFAAEIBQFpAAQAAgQCZQ4LDQMKCgNhBwEDAzVNAAgIAGEAAAA0AE5SUklJAABSW1JaSVFJUABIAEcoJTEnKCUmIyYPCR8rJBYVFAcGBiMiJicGIyInFhYVFAYjIiY1NBISMzIWFRQBBhUUFjMyNTQmJyY2NjMyFxYzMjc1NBI2MzIWFRQGBgcWFjMyNjc2MwAGBgc2Njc0IyAGBgc+AjU0IwMiDxMrZUBEUg8iJiEoDhJGOUg9U5FXLzX+5woOEB4VEgETHAsNHCAQJCY/e1UwNzxyTQQiISk+MAwP/jM1NBNQVgEZASs3LAUyRiEc3xgVKBY1RGNVCQU/nDJscszOwAGLAQNUR+v+62JKZ9loTpJRDSgeAgIKA3oBOOBZU1HOvTlHOy85DgJqeslwW8VWPZXkbTOTlz1MAAQAN//7A5gD9QAVAEgAUABYAPtAEFRMAgoLQC4CBwofAQQHA0xLsAlQWEA2AAIABgACBoAOAQoLBwsKB4ANAQMBAQACAwBpEAwPAwsLBmEIAQYGM00JAQcHBGEFAQQENAROG0uwEFBYQDYAAgAGAAIGgA4BCgsHCwoHgA0BAwEBAAIDAGkQDA8DCwsGYQgBBgY5TQkBBwcEYQUBBAQ0BE4bQDwAAAECAQACgAACBgECBn4OAQoLBwsKB4ANAQMAAQADAWkQDA8DCwsGYQgBBgY5TQkBBwcEYQUBBAQ0BE5ZWUAqUVFJSRYWAABRWFFXSVBJTxZIFkdEQjs5MjApJyIgHhwAFQAUIyIkEQkZKwAWFRQGIyInJiMiBgcGIyImNTQ2NjMSFhUUBwYGIyInBiMiJjU0EjYzMhYVFAIHFhYzMjY3JjU0EjYzMhYVFAIHFhYzMjY3NjMABgYHNjU0IyAGBgc2NTQjAwaSIxwbK2OEZoZGMxMYGnLHessPEytlQF8sU2pYVT96UzA4hW4HIBonPCkGP3pTMTmGbwcgGik+MAwP/iQ6KgKZHAEyOysBmxwD9SgiFhkFCxYTDhYRHTgk/OoYFSgWNURkZKOGcQEHt1FSa/72hCokKjEtM3EBB7dRUmv+94UqJC85DgIUhdBq06ZGhdBq1qNGAAAEAAP/+wNDA2kAPABFAE4AWwBlQGJJQAICAwkBAAkCTA8BCgIJAgoJgAYBBBEMEAMLAwQLaQcFAgMNCAICCgMCZxIOAgkJAGEBAQAANABOT09GRj09AABPW09aVlVGTkZNPUU9RAA8ADs4NiMkIxQjIyQjJhMJHyskFhUUBwYGIyInBgYjIiY1NDcjIiY1NDMzPgIzMhYVFAczPgIzMhYVFAczMhYVFCMjBhUUFjMyNjc2MwAGBgc2NjU0IyAGBgc2NjU0IwA2NyY1NDcjBhUUFjMDNA8TK2ZCejAaVjFfWQUpHhUtPRNEYDgqMG1bE0RgOCowbVsQDnF5AzE1K0ItDA/+CyUhCzs7FgEoJSELOzsW/s08FQUFvgMrJ98YFSgWNURmKjybhDE8Fhg4aqxmSjiNbWqsZko4jW0OE0UwMmhUNDQOAipLhVEzfzQ7S4VRM380O/1gOCkfMTE8MDJlVwAAAAMAGv6xAooDrABDAEwAWAEJS7AQUFhADkYBBQkxAQMBHgECAwNMG0AORgEHCTEBAwEeAQIDA0xZS7AQUFhANgADAQIBAwKAAAAEAIYNAQoACQUKCWkAAgAEAAIEaQwBCAgGYQAGBjVNAAEBBV8LBwIFBTYBThtLsCpQWEA6AAMBAgEDAoAAAAQAhg0BCgAJBwoJaQACAAQAAgRpDAEICAZhAAYGNU0ABQU2TQABAQdfCwEHBzYBThtAPQAFBwEHBQGAAAMBAgEDAoAAAAQAhg0BCgAJBwoJaQACAAQAAgRpDAEICAZhAAYGNU0AAQEHXwsBBwc2AU5ZWUAeTU1ERAAATVhNV1NRRExESwBDAEEjGicpJCcoDgkdKwAWFRQCAgcGBiMiJjU0NzYSNyIHBhUUFjMyNjY1NCc0JyY2MzIWFxYVFAYGIyImNTQ3BiY1NDY3Nz4CMzIWFRQHNjMCBgc+AjU0IxYWFRQGIyImNTQ2MwIqJB4pEwknGBkeAxw3AmWLFBUVChYOBwICFxcVFQEFIUk4Rz4RKRsbJhUaVWw9LzOie0uxSx4yRCEW5y40KyoqNykB2RUeJv7j/tpHIyIZHAsPfAF+eQmMZUjCQGUzKkkKFBwbFhpbNU+ebMS4cn0DFhkZHgMBhtuDSTnJjQUBc9GTImlvLzucJCEoLycjIy8AAAMAGv7EApYDrABBAEoAVgFYS7AQUFhAD0QBBgoBAQEGIgsCAAMDTBtAD0QBCAoBAQEGIgsCAAMDTFlLsBBQWEA2AAMBAAEDAIAOAQsACgYLCmkAAgAEAgRlDQEJCQdhAAcHNU0FAQEBBl8MCAIGBjZNAAAANABOG0uwElBYQEAAAwEAAQMAgA4BCwAKCAsKaQACAAQCBGUNAQkJB2EABwc1TQUBAQEIXwwBCAg2TQUBAQEGXwAGBjZNAAAANABOG0uwKlBYQD4AAwUABQMAgA4BCwAKCAsKaQACAAQCBGUNAQkJB2EABwc1TQABAQhfDAEICDZNAAUFBl8ABgY2TQAAADQAThtAPAADBQAFAwCADgELAAoICwppAAYABQMGBWkAAgAEAgRlDQEJCQdhAAcHNU0AAQEIXwwBCAg2TQAAADQATllZWUAfS0tCQgAAS1ZLVVFPQkpCSQBBAD8jJTQmJyQmJw8JHisAFRQHBgcGBiMiJjU0NzY3IgcGFRQWMzI2NjU0JyY2MzIWFxYVFAYjIiY1NDcGIyImNTQ2NzYzPgIzMhYVFAc2MwIGBz4CNTQjFhYVFAYjIiY1NDYzAlUCLQkCIiQgGAIPHWOJFhUVChYOCQIXFxUUAgVPU0c+EwcLHxUbJgcPG1RsPC8zon1RuUoeMkMhFvMuNCsqKjcpAdkrBgzWkSAaGhwIFKaACYx5XctGekpRXhwbFhpJZaPozc15igEWFxkeAwGH3IFJOcmNBQFz0JQjaG8vO5wkISgvJyMjLwAAAwA0/sQDFwOsAEcAUABaAFtAWFRLNQMGCkEPAgIGAkwAAAIJAgAJgAcBBgACAAYCaQAFAAMFA2UNCwwDCgoEYQgBBAQ1TQAJCQFhAAEBNAFOUVFISFFaUVlIUEhPRUMlMScoJSYjJSAOCR8rJDMyFhUUBwYjIiYnBiMiJxYWFRQGIyImNTQSEjMyFhUUAQYVFBYzMjU0JicmNjYzMhcWMzI3NTQSNjMyFhUUBgYHFhYzMjY3AAYGBzY2NzQjIAYGBz4CNTQjAsYLDA8eNEJKVg8iJiEoDhJGOUg9U5FXLzX+5woOEB4VEgETHAsNHCAQJCY/e1UwNzxyTAQkKBErEv6NNTQTUFYBGQErNywFMkYhHJcbEyoZK2NVCQU/nDJscszOwAGLAQNUR+v+62JKZ9loTpJRDSgeAgIKA3oBOOBZU1HOvTlIOhQQArx6yXBbxVY9leRtM5OXPUwABQAa/jkDdwOsAF8AaAB0AIAAiQIbS7AQUFhAD2IBBw4uEwIKBIMBAwEDTBtAD2IBCQ4uEwIKBIMBAwEDTFlLsBBQWEBLAAQCCgIECoAVEAINDxQCDgcNDmkAAwAFEQMFaRMBDAwIYQAICDVNBgECAgdfEgsJAwcHNk0ACgoBYQABATRNFgEREQBhAAAAOABOG0uwElBYQFUABAIKAgQKgBUQAg0PFAIOCQ0OaQADAAURAwVpEwEMDAhhAAgINU0GAQICCV8ACQk2TQYBAgIHYRILAgcHNk0ACgoBYQABATRNFgEREQBhAAAAOABOG0uwF1BYQFMABAYKBgQKgBUQAg0PFAIOCQ0OaQADAAURAwVpEwEMDAhhAAgINU0AAgIJXwAJCTZNAAYGB2ESCwIHBzZNAAoKAWEAAQE0TRYBEREAYQAAADgAThtLsCpQWEBTAAQGCgYECoAVEAINDxQCDgkNDmkAAwAFEQMFaRMBDAwIYQAICDVNAAICCWESCwIJCTZNAAYGB18ABwc2TQAKCgFhAAEBNE0WARERAGEAAAA4AE4bQFEABAYKBgQKgBUQAg0PFAIOCQ0OaQAHAAYEBwZpAAMABREDBWkTAQwMCGEACAg1TQACAglhEgsCCQk2TQAKCgFhAAEBNE0WARERAGEAAAA4AE5ZWVlZQDKBgXV1aWlgYAAAgYmBiHWAdX97eWl0aXNvbWBoYGcAXwBeWVdOSyMlNCYnJCQrKBcJHysAFhUUBwYHAgIjIiY1NDY2Nzc2NwYGIyImNTQ3IgcGFRQWMzI2NjU0JyY2MzIWFxYVFAYjIiY1NDcGIyImNTQ2NzYzPgIzMhYVFAc2MzIWFRQGBwYGFRQzMjY2NzY2MwAGBz4CNTQjEiY1NDYzMhYVFAYjJBYVFAYjIiY1NDYzADY3BgYVFBYzAycSGhcEJYJsM0ArdWsDBwkUSCgtORxjjBYVFQoWDgkCFxcVFAIFT1NIPRMHCx8VGyYHDxtUbDwvM6J6SxwkCgYHDBUPLTMYCCEh/k1KHjJDIRabKjcpJS40KwEPLjQrKio3Kf7xPh9NRQ0PAdIMDhiTjRr+//7UPzMvYn9SFyVFSEtTP2WBCYx5XctGekpRXhwbFhpJZaPozM55igEWFxkeAwGH3IFJOcmNBRUeEj4gI0oYJjx6WR4aAXrQlCNoby87/sgnIyMvJCEoL5wkISgvJyMjL/vqdIdBaygRFgAE//z+OQH1ArAACwAXAEoAUwBdQFo6KwIHBk0BCQUCTAsDAgACCgIBBgABaQwIAgYGNk0ABwcFYgAFBTRNDQEJCQRhAAQEOAROS0sYGAwMAABLU0tSGEoYSURCODYvLSIgDBcMFhIQAAsACiQOCRcrEiY1NDYzMhYVFAYjJBYVFAYjIiY1NDYzFhYVFAcGBwICIyImNTQ2Njc3NjcGBiMiJjU0Njc2NjMyFhUUBwYHBgYVFDMyNjY3NjYzAjY3BgYVFBYzjio3KSUuNCsBDy40KyoqNykDEhoXBCWCbDNAK3VrAwcJFEgoLTkUFwokJxYRCwoGCAwVDy0zGAghIfs+H01FDQ8CFCcjIy8kISgvnCQhKC8nIyMv3gwOGJONGv7//tQ/My9if1IXJUVIS1M+S31GHhoODgguJR4pSxgmPHpZHhr8yHSHQWsoERYAAAACAA3/+wKxAv0ARwBWAElARjEkAgQFCwEBCgJMBwEFBAWFAAADCgMACoAIBgIECwkCAwAEA2gMAQoKAWECAQEBNAFOUU9KSUVDPTsmJBYkIyYkJSANCR8rJDMyFhUUBwYjIiYnBgYjIiY1NDc2NyMiJjU0MzM2NzY2MzIWFRQHBgczNjc2NjMyFhUUBwYHMzIWFRQGIyMGBwYVFBYzMjY3JDcjBgcGFRQzMjY3NjY1AoYLDA8eNEQ6UBYWUS5JUwMGDBoeFS0zFBkJJyAeHQQgEJ4QHAknIB4dBBwVghAOMypZCwMJIiUSLBL+8Q+gBAsKNCFDCgIDlxsTKhkrLTEsMmRpHR89RhYYOGFnKCAUFgYUgExVcyggFBYGFHFbDhMhJDUZOSs2NhQQmWEQPkQnZTw2CxgGAAABAFz/+QLqA1QAOACVtzEgEAMEAwFMS7AJUFhAIgAAAgECAAGAAAQAAgAEAmoFAQMDOU0AAQEGYQcBBgY0Bk4bS7AMUFhAIgAAAgECAAGAAAQAAgAEAmoFAQMDM00AAQEGYQcBBgY0Bk4bQCIAAAIBAgABgAAEAAIABAJqBQEDAzlNAAEBBmEHAQYGNAZOWVlADwAAADgANyQqKCUjJggJHCsEJicmNTQ2MzIXFhYzMjY2NwYGIyImNTQ2NzY3NjMyFgcGBgcGBhUUFjMyNjY3NjMyBwYHBgcGBiMBDHUfHBkTDg4jXjhEXDcJK3tSamkKChEHBkYjJAIDDgsHCjAtPWtLCQZCRwYHGwMEF7aVBx8aFiQXIgoYGjiEcVlTZ1kmUD5yREAkHDRiPyZGFygrVbeKVVNp6BMmybUABQAa/jkDzgOsAGkAcgB+AIoAkwJOS7AQUFhAFmwBBw8uAQwEEwEKDGUBAQqNAQMBBUwbQBZsAQkPLgEMBBMBCgxlAQEKjQEDAQVMWUuwEFBYQFIABAIMAgQMgBMBDAoCDAp+EAEOFhEVAw8HDg9pAAMABRIDBWkUAQ0NCGEACAg1TQYBAgIHXwsJAgcHNk0ACgoBYQABATRNFwESEgBhAAAAOABOG0uwElBYQFwABAIMAgQMgBMBDAoCDAp+EAEOFhEVAw8JDg9pAAMABRIDBWkUAQ0NCGEACAg1TQYBAgIJXwAJCTZNBgECAgdhCwEHBzZNAAoKAWEAAQE0TRcBEhIAYQAAADgAThtLsBdQWEBaAAQGDAYEDIATAQwKBgwKfhABDhYRFQMPCQ4PaQADAAUSAwVpFAENDQhhAAgINU0AAgIJXwAJCTZNAAYGB2ELAQcHNk0ACgoBYQABATRNFwESEgBhAAAAOABOG0uwKlBYQFoABAYMBgQMgBMBDAoGDAp+EAEOFhEVAw8JDg9pAAMABRIDBWkUAQ0NCGEACAg1TQACAglhCwEJCTZNAAYGB18ABwc2TQAKCgFhAAEBNE0XARISAGEAAAA4AE4bQFgABAYMBgQMgBMBDAoGDAp+EAEOFhEVAw8JDg9pAAcABgQHBmkAAwAFEgMFaRQBDQ0IYQAICDVNAAICCWELAQkJNk0ACgoBYQABATRNFwESEgBhAAAAOABOWVlZWUA0i4t/f3NzamoAAIuTi5J/in+JhYNzfnN9eXdqcmpxAGkAaGBeWVdOSyMlNCYnJCQrKBgJHyskFhUUBgcHBgYjIiY1NDY2Nzc2NwYGIyImNTQ3IgcGFRQWMzI2NjU0JyY2MzIWFxYVFAYjIiY1NDcGIyImNTQ2NzYzPgIzMhYVFAc2MzIWFRQGBwYGFRQzMjY2NzY2MzIWFRQHBzY3NjMABgc+AjU0IxImNTQ2MzIWFRQGIzImNTQ2MzIWFRQGIwA2NwYGFRQWMwO/Dw4PwCZ7XzNAK3VrAwcJFEgoLTkcY4wWFRUKFg4JAhcXFRQCBU9TSD0TBwsfFRsmBw8bVGw8LzOiekscJAoGBwwVDy0zGAghIRcSGhpNSQ0K/atKHjJDIRabKjcpJS40K7QqNyklLjQr/v0+H01FDQ/dGRMXGgqBz+0/My9if1IXJUVIS1M/ZYEJjHldy0Z6SlFeHBsWGkllo+jMznmKARYXGR4DAYfcgUk5yY0FFR4SPiAjShgmPHpZHhoMDhmToTowCAJv0JQjaG8vO/7IJyMjLyQhKC8nIyMvJCEoL/yGdIdBaygRFgAE//z+OQJMArAACwAXAFQAXQBuQGs6AQkGKwEHCVABBQdXAQoFBEwNAQkGBwYJB4ACAQAMAwsDAQYAAWkIAQYGNk0ABwcFYgAFBTRNDgEKCgRhAAQEOAROVVUYGAwMAABVXVVcGFQYU0tJREI4Ni8tIiAMFwwWEhAACwAKJA8JFysSJjU0NjMyFhUUBiMyJjU0NjMyFhUUBiMSFhUUBgcHBgYjIiY1NDY2Nzc2NwYGIyImNTQ2NzY2MzIWFRQHBgcGBhUUMzI2Njc2NjMyFhUUBwc2NzYzADY3BgYVFBYzjio3KSUuNCu0KjcpJS40K6cPDg/AJntfM0ArdWsDBwkUSCgtORQXCiQnFhELCgYIDBUPLTMYCCEhFxIaGk1JDQr+Yz4fTUUNDwIUJyMjLyQhKC8nIyMvJCEoL/7JGRMXGgqBz+0/My9if1IXJUVIS1M+S31GHhoODgguJR4pSxgmPHpZHhoMDhmToTowCP29dIdBaygRFgAAAgAN//sC+QL9AEcAVgBOQEsvIgIDBAkBAAkCTAYBBAMEhQ0BCgIJAgoJgAcFAgMLCAICCgMCaAwBCQkAYQEBAAA0AE4AAFFPSkkARwBGQ0EkJiQWJCMmJCUOCR8rJBYVFAcGIyImJwYGIyImNTQ3NjcjIiY1NDMzNjc2NjMyFhUUBwYHMzY3NjYzMhYVFAcGBzMyFhUUBiMjBgcGFRQWMzI2NzYzJDcjBgcGFRQzMjY3NjY1AuoPE2NtOlAWFlEuSVMDBgwaHhUtMxQZCScgHh0EIBCeEBwJJyAeHQQcFYIQDjMqWQsDCSIlKT4wDA/+jw+gBAsKNCFDCgID3xgVKBZ5LTEsMmRpHR89RhYYOGFnKCAUFgYUgExVcyggFBYGFHFbDhMhJDUZOSs2Ni85DkdhED5EJ2U8NgsYBgAAAAACAE4BwgGqA00AGgAlAD5AOwkBBAEYAQIFAkwAAQAEAAEEgAcBBQYDAgIFAmUABAQAYQAAAEMEThsbAAAbJRskHx4AGgAZKCMlCAoZKxImNTQ2NjMyFhc2MzIVFAcGBhUUBiMiJjcGIzY2NzcOAhUUFjOMPj9pPRMMBAwXMQkJChwiHxsDGj84JRAQIjojExABwks9Q3dJDhMDJhEyNVo5IRsiJkhVQVNUATNTLxkZAAIAUwHDAawDTQAPABsAKUAmBQEDBAEBAwFlAAICAGEAAABDAk4QEAAAEBsQGhYUAA8ADiYGChcrEiYmNTQ2NjMyFhYVFAYGIzY2NTQmIyIGFRQWM75HJDBUNTRIJDFVNCUnIRceJyEZAcMxUC5AZDcxUC4/ZDhaPjsuLz08MC3//wA4//sDkwNQAAIABAAAAAEAI//PA4MDWgBTAIpADlEBAQggAQMBGAEAAwNMS7AbUFhALAAFBAgEBQiAAAMBAAEDAIACAQAAhAcBBAQGYQAGBhdNAAEBCGEJAQgIGQFOG0AvAAQHBQcEcgAFCAcFCH4AAwEAAQMAgAIBAACECQEIAAEDCAFpAAcHBmEABgYXB05ZQBEAAABTAFIoNigbJiYqJgoHHisAFhUUBgcGIyImNTQ2NzY2NTQmIyIHBgYHBgYjIiY1NDcHBiMiJjU0NzY3Njc2NjcGBhUUFxYVFAYjIicmJjU0NjMyNjc2FhUUBgcGBiMGBwYHNjMC9o2rpxQJISAYFntzTVRJVwsZBAIoISEjIgMPCxUbKDAHCx8DCQRtXhQFIxciEg4U1uJ+iT8eGyEpR3heDh4BBFpPAeV2ZoOdFQIXFBIZBBlgUD5BFULXNyEfIBo97AEFHBUqDxICQpkSJhYHMzQiHwcKEhwQDEEheXEEBgMZGx8gBAgFR54KFBIAAP//ABT/zgNkA14AAgAfAAAAAQAj//sDWgNaADEALkArHAECAA4BAQICTAACAAEAAgGAAAAAA2EAAwMXTQABARgBTjAtJyUoJgQHGCsAFhUUBgcGBiMjBgcGBgcGBiMiJjU0Njc2NzY3NwYGFRQXFhUUBiMiJyYmNTQ2MzI2NwM/GyEpTIBzAisZDBcEAiwfISQPCgsGECISWE4UBigZGxMOFNbifok/A1oZGx8gBAgF2JlJsTQdHyAaGG89PS1tqFgJMy8iHwkJEhsQDEEheXEEBgAA//8AI//7A1oEfAAiA0cAAAEHBcACzwF8AAmxAQG4AXywNSsAAAEAI//7A3wEMQA/ADlANgIBAwQgAQIAEgEBAgNMAAQDBIUAAgABAAIBgAAAAANfAAMDF00AAQEYAU4+PDcxKykoKgUHGCsAFhUUBwYHBgYHBgYjIwYHBgYHBgYjIiY1NDY3Njc2NzcGBhUUFxYVFAYjIicmJjU0NjMyNzYzMjY3Njc2MzIXA2UXAgcSBy46N3lxAisZDBcEAiwfISQPCgsGECISWE4UBigZGxMOFNbiGIREGQ8MAwwNBiQJCwQnHRwHEj1oJyQGBgPYmUmxNB0fIBoYbz09LW2oWAkzLyIfCQkSGxAMQSF5cQMCCw03Yy0DAAACABD/8QOtA1wAPgBIASNADiYBCAJBAQQICgEJBANMS7AZUFhAOgADBQYFAwaAAAYCBQYCfgACAAgEAghpAAUFB2EKAQcHF00ABAQAYQEBAAAYTQsBCQkAYQEBAAAYAE4bS7AqUFhAOAADBQYFAwaAAAYCBQYCfgACAAgEAghpAAUFB2EKAQcHF00ABAQAYQAAABhNCwEJCQFhAAEBGAFOG0uwMFBYQDYAAwUGBQMGgAAGAgUGAn4KAQcABQMHBWkAAgAIBAIIaQAEBABhAAAAGE0LAQkJAWEAAQEYAU4bQDMAAwUGBQMGgAAGAgUGAn4KAQcABQMHBWkAAgAIBAIIaQsBCQABCQFlAAQEAGEAAAAYAE5ZWVlAGD8/AAA/SD9HREIAPgA9IyUsJiQlJQwHHSsAFhUUBgYjIiYmJwYGIyImNTQ2MzIXNjY3NjYzMhYVFAcGBgcHBgcWFjMyNjY1NCYjIgYHBiMiJjU0Njc2NjMANjcmIyIGFRQzAuDNWJxiM09GOBleQUpFVEcoLQ0rKA4mHBseBxcrDAYMCzVpKkJjNn6AUKFDDwwRFRATQLlc/qQlCigeGRstA1zLwIPXfBQlJDM0QTk9TQ17nVEdGhYSDQ0qjEIiRy4dIVacaI2KMCsJGxcYHg4sNPzxHSIPGhEj//8AH//7AywDUAACACwAAP//AB//+wMsBHwAIgNLAAABBwW/AwQBfAAJsQEBuAF8sDUrAP//AB//+wMsBDEAIgNLAAABBwW9AwQBfAAJsQECuAF8sDUrAAABABv/+AUuA1cAjQKiS7AmUFhAEWUBCAaAOx4QBA4IGQEABANMG0ARZQEIC4A7HhAEDggZAQAEA0xZS7ASUFhAOAsBBgUIBQZyDwEOCAMIDgOAAAMECAMEfgwBBQUHYQoJAgcHF00ACAgZTQ0BBAQAYQIBAgAAGABOG0uwFVBYQEMLAQYFCAUGcg8BDggDCA4DgAADDQgDDX4MAQUFB2EKCQIHBxdNAAgIGU0ADQ0AYQIBAgAAGE0ABAQAYQIBAgAAGABOG0uwF1BYQEoLAQYFCAUGcg8BDggDCA4DgAADDQgDDX4MAQUFB2EKCQIHBxdNAAgIAGECAQIAABhNAA0NAGECAQIAABhNAAQEAGECAQIAABgAThtLsBlQWEBLCwEGBQgFBgiADwEOCAMIDgOAAAMNCAMNfgwBBQUHYQoJAgcHF00ACAgAYQIBAgAAGE0ADQ0AYQIBAgAAGE0ABAQAYQIBAgAAGABOG0uwIVBYQFYLAQYFCAUGCIAPAQ4IAwgOA4AAAw0IAw1+AAwMB2EKCQIHBxdNAAUFB2EKCQIHBxdNAAgIAGECAQIAABhNAA0NAGECAQIAABhNAAQEAGECAQIAABgAThtLsCZQWEBZCwEGBQgFBgiADwEOCAMIDgOAAAMNCAMNfgAJCRdNAAwMB2EKAQcHF00ABQUHYQoBBwcXTQAICABhAgECAAAYTQANDQBhAgECAAAYTQAEBABhAgECAAAYAE4bQF8ABgULBQYLgAALCAULCH4PAQ4IAwgOA4AAAw0IAw1+AAkJF00ADAwHYQoBBwcXTQAFBQdhCgEHBxdNAAgIAGECAQIAABhNAA0NAGECAQIAABhNAAQEAGECAQIAABgATllZWVlZWUAcAAAAjQCMiYd6eHVzbmxfXRYmIy0kJi4tJhAHHyskFhUUBwYGIyImJyYnLgInBwYGBwYjIiY1Nzc2NzcOAgcOAiMiJicmNTQ2MzIWFxYWMzI2Nz4CNy4CJycmJiMiBgcGIyImNTQ3NjYzMhcWFx4CMzY2NzY2MzIVFAYHBgc+Ajc+AjMyFxYVFAYjIiYnJiMiBgcOAgceAhcXFhYzMjY3NjMFHw8TMGJDSl4pDRQRFiMdBAsXBAVDIiQBBxQPBCtCLx4kNlM5RE8TAx4cGhkHCRsYGyMaGjJXQCMrFg4GFTIlFycWDg0NDxMZXSx8OAYLDBMnIQsWBAMoJjwXDgEEMkUqGxwrSTZ4IQQcHBwaBwsgGx4UFi1YRic0HxQSHj0lIDosDA/fGBUnFzo/V1wdNCwsHwcYQ7EwRhwXCTaWYBkIN0c4Q002NzYJDBsuFBYdFzE4O1RMEwssNS0VQTUTFg4YFScXHySvEiwuMiFBsDAlITwdllIKFgw4RDc5Qy1aDAsaKREVISoxN05HEgstNy8oQTgrNA4AAAABADr/+wK0A1AAPgCCQAsrAQYFPhoCAwQCTEuwKlBYQC8ABgUEBQYEgAABAwIDAQKAAAUFB2EABwcXTQADAwRhAAQEGU0AAgIAYQAAABgAThtALQAGBQQFBgSAAAEDAgMBAoAABAADAQQDaQAFBQdhAAcHF00AAgIAYQAAABgATllACyUoJBQnJSQlCAceKwAWFRQGBiMiJjU0NjMyFhUUFhYzMjY2NTQmJwYjIiY1NDY3NjU0JiMiBgYVFBYVFAYjIiY1NDY2MzIWFRQGBwJpS1qla3+RJSYcIRs9NzxfNSggTU8hHE1TZjIyL0goBB8aJiJJiFlzajUzAcNdQ0+IUW5iMjAfHTQ7GzZYMio5BSwWGSQmBEBoLDEdMRwIGgcZGTcuN103XFA8aycAAAD///////sD+wNQAAIAogAA///////7A/sEZgAiA1AAAAEHBeQDQgF8AAmxAQG4AXywNSsA///////7A/sEfAAiA1AAAAEHBb8DQgF8AAmxAQG4AXywNSsAAAL///8jA/sEZgAXAHIA4EuwHVBYQAowAQwHKwEFCQJMG0AKMAEMBysBBQsCTFlLsB1QWEBFAAIAAoUAAAEAhQAHBgwGBwyADgEMCQYMCX4AAQ0BAwgBA2kABgYIYQoBCAgXTQsBCQkFYgAFBRhNAAQECGEKAQgIFwROG0BMAAIAAoUAAAEAhQAHBgwGBwyADgEMCQYMCX4ACwkFCQsFgAABDQEDCAEDaQAGBghhCgEICBdNAAkJBWIABQUYTQAEBAhhCgEICBcETllAIhgYAAAYchhxbmxhX1pYTEpFQ0A+NDIlIwAXABYjIyUPBxkrACYmNTQ2MzIXFhYzMjY3NjMyFhUUBgYjABYVFAcGBwYGBwYGIyImNTQ3NjcmJjU0NwYGIyImNTQ3EzY2NTQmIyIGBwYjIiY1NDc2MzIWFRQGBwcOAhUUFjMyNhI3NjYzMhYVFAYHBgcGFRQWMzI2NzYzAeRMJB0cKQwMIB8kQAkIJhMWLmFHAdEPExUdOkccGSIaFyILMSU/QhAymWRUVg0+Ag8TEB5QLA4RDhUcZok9RQ4RKQIKBiQhPHtpHQcbJyMiDQ0bEAglHyE/KwwPA5AlOyIZHiEgGDUiHxQSI1I7/U8YFScXGRw6YjQtHx4WEg9HPwtROiZuk5pdTiw/AR4ISCoYGDk7ExsRHyeMSkgzVkq3CS4pFCAmgAEd3jMoKi8bWE+ZgDocKSssMw4AAP//ABr/+AQqA08AAgBaAAD//wAa//gEKgR8ACIDVAAAAQcFwAO2AXwACbEBAbgBfLA1KwAAAQAI//gD3gNQADMAZrUMAQIEAUxLsBJQWEAcBwYCAgQDBAIDgAAEBBdNBQEDAwBiAQEAABgAThtAJgcGAgIEBQQCBYAABAQXTQAFBQBiAQEAABhNAAMDAGEBAQAAGABOWUAPAAAAMwAyJiYkJicmCAccKyQWFRQHBgYjIiY1NDcOAiMiJicmNTQ2MzIWFxYWMzI2NzYTNjYzMhYHBhUUFjMyNjc2MwPPDxM0XjZqYgkvZIpbQGAXCSEaFRoGDCgeJGQ1PlUNNSkpIAMPLTcgOS4LEN8YFScXQDnIq09VqOiKQDcXFB4pFBYrJ392igEbKiclKsx8mK8pNg4AAQAJ//ME7gNQAEwAmbc3GQwDAwUBTEuwHVBYQB4JCAIDBQQFAwSABgEFBRdNBwEEBABiAgECAAAYAE4bS7AuUFhAKAkIAgMFBAUDBIAGAQUFF00HAQQEAGIAAAAYTQcBBAQBYgIBAQEYAU4bQCIJCAIDBQQFAwSABgEFBRdNBwEEBABiAgEAABhNAAEBGAFOWVlAEQAAAEwASyYsJSMlKikmCgceKyQWFRQHBgYjIiY1NDcjAgMGBiMiJyYmNTQ3Iw4CIyImJjU0NjMyFxYWMzI2Ejc2NjMyBwYVFBczNhI3PgIzMhYHBhUUFjMyNjc2MwTfDxM0ZDpYWxcCZFwKHhwwDhkcBAInP3ZgNFEsIB0nCQkpHiZHTS0IMjFSBgUYAhpuPhAYHhsqLQQZJiwhPS0LEN8YFScXQDmvpnKe/u3+3R8YMFDfckIxyOGWLUwsHyUmJSeCASDuLCVXVUWi2m8BKoQjIA0pJvyNe4spNg4AAAD////w//kD6gNtAAIARwAA//8AQP/7Ax4DUAACAG0AAAABACP/+wP/A08AUgBPQExFJwIFARgBAAYCTAAFAQMBBQOAAAMHAQMHfggBBwYBBwZ+AAEBBGEABAQXTQAGBgBhAgEAABgATgAAAFIAUU5MQ0E7OTIwJ0cmCQcZKyQWFRQHBgYjIiY1NDc3NjcmIyIHBgcGBgcGBiMiJjU0Njc2NzY2NzcGBhUUFxYVFAYjIicmJjU0NjYzMhcWFhUUBiMiJycGBwMGFRQWMzI2NzYzA+4PEzNlOVVeGCUcBEJaNhgkIAsYBAIsHyEkDwoLBg0eDwpdUxEFKxgRCxQadu+9xLwfGx4eCwZlBBE9CicjIT8rDA/fGBUnFz86ZVU1dreKMwMBtrtEszcdHyAaGG89PS1TnkkwCzIrIxoHCxQhChE/KFVnMB4FHxQeHwENRkr+4jIkKiosMw4AAAD//wAu/5MDNwNOAAIAjAAA//8AQP/7AywDUAACACAAAP//ACP/+wOHA08AAgCdAAAAAgAj/wMDuwNQAE8AWQBSQE8XAQYETQECAAJMAAQDBgMEBoAJAQAGAgYAAoAABgACCAYCaQAIAAEIAWUAAwMFYQcBBQUXA04CAFdVRkQ/PTMxKykmJBsZDgwATwJPCgcWKwAzMhUUBgcGBwYHBgYjIiY1NDY3Njc2NwYGIyImNTQ2NzY2NTQjIgYHBiMiJjU0NzY2MzIWFRQGBwYGFRQWMzI2Njc2NjMyFRQHBgcGBzY3BQYGFRQWMzI2NwOMCiUVFn01AgIcqHxUWsG8BQ8ECS+OWVVWDAsNDCQXOR8REA8THSVoOD1FDg0LCSAsM3JYDwYjIkYBDRQYGEBY/tF7dyQfQFsTAR0rGCEEGQ0IELq6VkdkoTgcbBg/Z2doVB42JSw4IjAjHxEYEiUhKTFKSCdELCksFi4labpzLSRGDAddcpCYDQ+yJlw7HCh4gAD//wAj/wMDuwRmACIDXgAAAQcF5AM3AXwACbECAbgBfLA1KwAAAwA5/wcDvwO7AEkAVwBmAMZAESkBCwVjTUYdBAwLCAEADANMS7AXUFhAPQAHCAeFAAIAAwACA4AACAkBBgUIBmkPCgIFDQELDAULaREOEAMMBAEAAgwAagADAQEDWQADAwFhAAEDAVEbQEQABwgHhQAJBgUGCQWAAAIAAwACA4AACAAGCQgGZw8KAgUNAQsMBQtpEQ4QAwwEAQACDABqAAMBAQNZAAMDAWEAAQMBUVlAJFhYSkoAAFhmWGVfXUpXSlZRTwBJAEhEQzQWQyUlJCYjJRIHHysAFhUUBgYjIicGBiMiJicmNTQ2MzIWFxYWMzI2NzcGBiMiJjU0NjYzMhc2NyYjIyImJyY1NDYzMhcWFjM3MhcWFhUUBicGBzY2MwA2NzcmJiMiBgYVFBYzBDY2NTQmIyIGBwYHFhYzA2xTSIdaSDkaflw7VxYJHBoaGgYMIB4cNxMQK2U1T1NIh1pLORIPFSg/RW4jDxoRBQYpcDxzOSUgGR0hFBcqaDf+BGQ1Gxg7HjFHJRoZAc9HJRoaKGk0CwoXPB4CyWtkfcRuMqLUQjYVGB0oFBYrL391ZThDbGN9xG41ZSoBGxMIGhgvAxUcAQUEFxMgHgJFjztJ/e1nUrAeIluaXTMkAVuaXTQjblRNWh4iAAD////x//sDSQNQAAIAvQAAAAEAcP/7AugDVAAxACtAKA8BAwIBTAADAAEAAwFqBQQCAgIXTQAAABgATgAAADEAMCsqKCcGBxorAAcGBwIHBgYjIjU0Njc2NwYGIyImNTQ2NzY2JyY2MzIXFhUUBgcGBhUUFjMyNjY3NjMC6AYHHikEAiQnPA4PEgUqelRmbQkKDQ0BASglPQYCDw0HCjAtRG1DCAZCA1RTVeH+yVYiITolXU9hL1dVZFwdOTE/aDweIkAcDjJbOh03EygrY7h7VQAAAAAC///+rQP2A1AAXABlAMtLsAlQWEAOFgEIBFgBAQZfAQsCA0wbQA4WAQoEWAEBBl8BCwIDTFlLsAlQWEA7AAQDCAMECIAMCgkDCAYDCAZ+DQELAAALAGUAAwMFYQcBBQUXTQABAQVhBwEFBRdNAAYGAmEAAgIYAk4bQEEABAMKAwQKgAwBCggDCgh+CQEIBgMIBn4NAQsAAAsAZQADAwVhBwEFBRdNAAEBBWEHAQUFF00ABgYCYQACAhgCTllAGl1dAABdZV1kAFwAW1dWHCUsJSMqJRcpDgcfKyQWFRQGBwYHBgYjIiY1NDY2NzciNTQ3BgYjIiY1NDcTNjY1NCYjIgYHBiMiJjU0NzYzMhYVFAYHBw4CFRQWMzI2Ejc2NjMyFhUUBgcGBwcGFRQWNzYzMgc2NzYzADY3BgYVFBYzA+cPDRA/SRZrYkJJN2RsAX8PMplkVFYNPgIPExAeUCwOEQ4VHGaJPUUOESkCCgYkITx7aR0HGycjIg8KHw0DBRolAwggAzwrDQr+vy4ROzsODLAYFBYaCysnqqA+NjZPRD0MYS1nk5pdTiw/AR4ISCoYGDk7ExsRHyeMSkgzVkq3CS4pFCAmgAEd3jMoKi8ZZzuvcRwmERsSAQE0IxsI/mhKUyE7JQ0PAAH////7BXkDUABqAIe2agcCCgMBTEuwHVBYQCoAAwIKAgMKgAAKBQIKBX4AAgIEYQgGAgQEF00JBwIFBQBiCwECAAAYAE4bQDUAAwIKAgMKgAAKBQIKBX4AAgIEYQgGAgQEF00HAQUFAGILAQIAABhNAAkJAGELAQIAABgATllAEmZkXlxZVyUqJSwlIyonIQwHHyskBiMiJjU0NyMGBiMiJjU0NxM2NjU0JiMiBgcGIyImNTQ3NjMyFhUUBgcHDgIVFBYzMjYSNzY2MzIWFRQGBwYGFRQWMzI2Ejc2NjMyFhUUBgcGBwYVFBYzMjY3NjMyFhUUBwYGIyImNTQ3A86UXEZDDgI6hV5UTg0+Ag8TEB5QLA4RDhUcZok9RQ4RKQIKBiQhMnNnHQcbJyMiGBgcHiMiMnNnHQcbJyMiEQwXEQglHyE/KwwPDQ8TM2Y5U1UNnKFQRi06fn9cTyw/AR4ISCoYGDk7ExsRHyeMSkgzVkq3CS4pFCAmgQEe3DMoKi8kcF9ykTcmKoEBHtwzKCovHHpHf386HCkrLDMOGBUnFz86VUQ6WgAC///+rQV0A1AAeACBANtLsAlQWEAPHhYCCwV0AQEHewEOAgNMG0APHhYCDQV0AQEHewEOAgNMWUuwCVBYQD8ABQQLBAULgA8NDAMLBwQLB34QAQ4AAA4AZQAEBAZhCggCBgYXTQABAQZhCggCBgYXTQkBBwcCYgMBAgIYAk4bQEUABQQNBAUNgA8BDQsEDQt+DAELBwQLB34QAQ4AAA4AZQAEBAZhCggCBgYXTQABAQZhCggCBgYXTQkBBwcCYgMBAgIYAk5ZQCB5eQAAeYF5gAB4AHdzcnBvY2FcWiUsJSMqJyUXKREHHyskFhUUBgcGBwYGIyImNTQ2Njc3IjU0NwYGIyImNTQ3IwYGIyImNTQ3EzY2NTQmIyIGBwYjIiY1NDc2MzIWFRQGBwcOAhUUFjMyNhI3NjYzMhYVFAYHBgYVFBYzMjYSNzY2MzIWFRQHBgYHBwYVFBY3NjMyBzY3NjMANjcGBhUUFjMFZQ8NED9JFmtiQkk3ZGwBfw8rlFxJRQ4COoBeVE4NPgIPExAeUCwOEQ4VHGaJPUUOESkCCgYkITJzZx0HGycjIhgYHB4jIjJzZx0HGycjIhgLGggFBBolBAggAzwrDQr+vy4ROzsODLAYFBYaCysnqqA+NjZPRD0MYS1njKFRRi44gH1cTyw/AR4ISCoYGDk7ExsRHyeMSkgzVkq3CS4pFCAmgQEe3DMoKi8kcF9ykTcmKoEBHtwzKCovKYZBn0wqJgcaEAIBNCMbCP5oSlMhOyUNDwAB////PQP7A1AAWQCqS7AdUFhADgwBCAMaAQAFFgEBAANMG0AODAEIAxoBAAcWAQEAA0xZS7AdUFhALAADAggCAwiACQEIBQIIBX4AAQABhgACAgRhBgEEBBdNBwEFBQBiAAAAGABOG0AyAAMCCAIDCIAJAQgFAggFfgAFBwIFB34AAQABhgACAgRhBgEEBBdNAAcHAGIAAAAYAE5ZQBcAAABZAFhVU0hGQT8zMSwqJyUqJgoHGCskFhUUBwYGIyImNTQ3BgYHBwYGIyImNTQ3NjcmJjU0NxM2NjU0JiMiBgcGIyImNTQ3NjMyFhUUBgcHDgIVFBYzMjYSNzY2MzIWFRQGBwYHBhUUFjMyNjc2MwPsDxM0ZjhTWBAoc0oWBSodIhgCBRA3OA0+Ag8TEB5QLA4RDhUcZok9RQ4RKQIKBiQhPHtpHQcbJyMiDQ0bEAglHyE/KwwP3xgVJxc/OlVEJm53khiQIBoUFwcUKlUPVz4sPwEeCEgqGBg5OxMbER8njEpIM1ZKtwkuKRQgJoABHd4zKCovG1hPmYA6HCkrLDMOAAACABz/+wLHA1AAIgAxAENAQCABBAMJAQEEAkwAAQQFBAEFgAYBAwAEAQMEaQACAhdNBwEFBQBiAAAAGABOIyMAACMxIzApJwAiACEpJiQIBxkrABUUBgYjIiY3NwYHBiMiJjU0Njc3Njc2MzIWFRQHBwYHNjMSNjU0JiMiBgcGBwcUFjMCx1ujaH98BgMGDA4LEhYSGTgYKg1AGyMDJQsLaEkGb0RKKk4yCAEBNkECJdVjm1eeniwCBgYdGhQZChaAvToiGwwMkSo4Hf5BdWJBPQ0RMikkZFQAAAAAAgBu//sDVQMwADEAQACEQA4XAQIDLwEGBQkBAQYDTEuwCVBYQCYAAQYHBgEHgAQBAwACBQMCaQgBBQAGAQUGagkBBwcAYQAAABgAThtAKgAEAwSFAAEGBwYBB4AAAwACBQMCaQgBBQAGAQUGagkBBwcAYQAAABgATllAFjIyAAAyQDI/ODYAMQAwIigqJiQKBxsrABUUBgYjIiY3NwYHBiMiJjU0Njc2NzY3BiMiJyYmNTQ2FxYzMjc2MzIVFAYHIwYHNjMSNjU0JiMiBgcGBwcUFjMDVVyjZ398BgMGDA0MEhYSGTUIFjopMDI0HxYdGDApWYYOBTUVGgIzGWBFCG9ESitOMQgCATdBAiXWY5pXnp4sAgYGHRoUGQoUA1h7BAYEHR4WHwMFEwI8GRgEZk4a/kF1YkE9DBEwLCNlVP//ABz/+wQWA1AAIgNnAAAAAwERAtEAAAACAAj/+AR5A1AALQA4AExASSgMAgUEKgEGBTUBAgYDTAACBgMGAgOACAEFAAYCBQZpAAQEF00JBwIDAwBhAQEAABgATi4uAAAuOC43NDIALQAsJSQmKCUKBxsrABYVFAYGIyImNTQ2Nw4CIyImJyY1NDYzMhYXFhYzMjc2EzY2MzIWBwYHNjYzEjY1NCYjIgcVFjMD/3pTkVp3jAIGL2SKW0BgFwkhGhUaBgwkHVRuPlUNMC4lIwMLAzFyKQNbQkJJXQSDAgVrY1+QTZiLSk9bqOiKQDcXFB4pFBYsJvWKARssJSYpoI8YG/5hZFo4Pygm5wAAAv/w//kEkwNSAEcAVgD2S7AZUFhACkUBCwoLAQEEAkwbQApFAQgKCwEBBAJMWUuwDlBYQDMABgUKBQYKgA0BCgALBAoLaQgBBAMBAQwEAWkABQUHYQkBBwcXTQ4BDAwAYgIBAAAYAE4bS7AZUFhAOAAGBQoFBgqADQEKAAsECgtpAAEDBAFZCAEEAAMMBANpAAUFB2EJAQcHF00OAQwMAGICAQAAGABOG0A5AAYFCgUGCoANAQoACwQKC2kACAABAwgBaQAEAAMMBANpAAUFB2EJAQcHF00OAQwMAGICAQAAGABOWVlAHEhIAABIVkhVTkwARwBGPz0kJiIkJCUkFiQPBx8rABUUBgYjIiY1NDc3BgcHBgcGIyI1NDc2NwciJjU0Njc3NjU0JiMiBwYjIiY1NDc2NjMyFhUUBzc2Nzc2NzYzMhYVFA8CNjMSNjU0JiMiBgcGBwcUFjMEk1ujaHd/AQVbXSoUJBU7QAUiFDAhHiYsNBscF0ZYDRAOFBkshkVBRxg6QV8BFS4NQBsjAyYcdEMHbkRHJ1E6AgIBNkECG9VjllGKiBsOLhIGA2aUVzoNF4lfAhcaIR8CAopNLyJ1ERoUHyM9T1leU44DAhUHcs06IhsMDJNwIf5MbGBBPRIVGi4kZFMAAAD//wAi//gCtQNRAAIAlQAAAAEAQf/7Ay0DUAA8AHVLsCxQWEAvAAMEBQQDBYAAAAYHBgAHgAAEBAJhAAICF00ABgYFXwAFBRlNAAcHAWEAAQEYAU4bQC0AAwQFBAMFgAAABgcGAAeAAAUABgAFBmcABAQCYQACAhdNAAcHAWEAAQEYAU5ZQAsjZGMoJCYmIAgHHiskMzIWFRQHBgYjIiYmNTQ2NjMyFhUUBiMiJjU0NzY1NCYjIgYGBxYzMjc3MhYVFAYjJyYjIgcVFBYzMjY3AwMKEBBCR5lFd7Beb750bHAsJxwgBQUuMzZmTRAbNiFCYhUXFhRtJEkxGIaDQYVRvBgTPR0fHVegapPkfWNTNkcaGQ8SHggjJDx0UQECASMXFR8BAQEEeIMhIgAAAQAs//sC4ANQADgAg7USAQIBAUxLsCpQWEAwAAYFBAUGBIAAAQMCAwECgAAFBQdhCAEHBxdNAAMDBF8ABAQZTQACAgBhAAAAGABOG0AuAAYFBAUGBIAAAQMCAwECgAAEAAMBBANnAAUFB2EIAQcHF00AAgIAYQAAABgATllAEAAAADgANyMjVFInJCYJBx0rABYWFRQGBiMiJjU0NjMyFhUUBwcUFjMyNjcnIgcHIiY1NDYXFjMyNzU0JiMiBgcGIyImNTQ3NjYzAf2TUGnCgn+IJyQbIgIBQE9nhxaHQCBhFhkfHTt3YTFqXTlyMBUTDhEnMI1SA1BWn2yY4npnWjE2HRgNEBYtJoqAAQEBHhQaIwECAQpwfi8sFBwaLyQtMwAA////7//uAiwDSwACAEoAAP///+//7gIsBDEAIgBKAAABBwW9AoQBfAAJsQECuAF8sDUrAP//AEf/lQL+A08AAgBYAAAAAQAj//sEVANPAGEAibUYAQAIAUxLsDBQWEAyAAQDBwMEB4AKAQkBCAEJCIAGAQMDBWEABQUXTQABAQdhAAcHGU0ACAgAYQIBAAAYAE4bQDAABAMHAwQHgAoBCQEIAQkIgAAHAAEJBwFpBgEDAwVhAAUFF00ACAgAYQIBAAAYAE5ZQBIAAABhAGAqJig3KR0nKSYLBx8rJBYVFAcGBiMiJjU0NzY2NTQmIyIGBg8CBgYjIiY1NDY3Njc2Njc2NjcOAhUUFxYVFAYjIicmJjU0NjYzMhYXFhYVFAYnJiYnBgcGFTY2MzIWFRQGBgcGFRQWMzI2NzYzBEUPEyxsRUE4CQgGLSUnY1ENAwcCLB8hJA8KCwYLHA4DCAVicC8UBC0YEQsUGm/jsm6DMR8fJShaZVIrGQIydVZVXQkKAgIQDx08KgwP3xgVKBY0RTQ0IispJxseJClXQBpMHR8gGhhvPT0tTJZDDycYAxovJSIfBwgTIQoRPyhVZzAICQYeFCEeAwcFAdiaCAZDQl5NHzcwBwoFEBIrMw4AAv/w//kEywNQAFYAXgCUQAtZOAIDBQsBAgMCTEuwDFBYQDAABQQDBAUDgAAHBAQHWQADAAIIAwJpDAoCBAQGYQsJAgYGF00ACAgAYgEBAAAYAE4bQDEABQoDCgUDgAAHDAEKBQcKaQADAAIIAwJpAAQEBmELCQIGBhdNAAgIAGIBAQAAGABOWUAYV1cAAFdeV10AVgBVKSomIyQ0JSkmDQcfKwAWFhUUBgYjIiY1NQYHBwYHBiMiNTQ3NjcHIiY1NDYzMjc2NTQmIyIGBwYjIiY1NDc2NjMyFhUUBzc2Nz4CMzIWFRQGBwYVFBYzMjY2NTQmJyY1NDYzBgYHNjY1NCMEAoFIbcF4k6Q0QR0aHxU7QAUhFS4jHiQqIBgbGRoeUSwOEQ4VHCx2UkNFGBwyPhNQZDEnKWZcA11UTXhDSU4pHxfiJA8kKAkDTFmiaYzhgLupCxAJBHqDVzoNF4hgAhgcIR4Bk0UpKDo7ExsRHyc9T11aUY0ECBZYm10xL1aYNh8gdoNdpml+fggFLxgfhU4+IEMfCgAAAgAI//gD0wNQAD8ATgCYQA8rAQkFRQEKCR8MAgQKA0xLsBJQWEArCwgCAgQDBAIDgAwBCgAEAgoEaQAJCQVhBgEFBRdNBwEDAwBiAQEAABgAThtANQsIAgIEBwQCB4AMAQoABAIKBGkACQkFYQYBBQUXTQAHBwBiAQEAABhNAAMDAGEBAQAAGABOWUAZQEAAAEBOQE1JRwA/AD4qIyYjIyUnJg0HHiskFhUUBwYGIyImNTQ3BwYGIyImJjU0NjMyFxYWMzI2NwYjIiYmNTQ2NjMyFzY2MzIWFRQGBwYGFRQWMzI2NzYzJDc2NzY3JiYjIgYVFBYXA8QPEzFoO1BJDwJuxGY1WDMaFxwMGSwlPJpGGBdOdD5GflNoZwggFB4hEREVFSEjIEArCxD+WhURDTAXNU8qTE5MVN8YFScXPjtWXz5XAauhKUgrIykdNyh9ZAM7bElTgkkgDg8jHiZ2XXiSOTEtLDMOygMgH2x0DQtYUkhHAQAAAAIAI/45BDsDTwBfAGgAnkALWx4CAghiAQkCAkxLsDBQWEA3AAQDBwMEB4AKAQgBAgEIAoAGAQMDBWEABQUXTQABAQdhAAcHGU0AAgIYTQsBCQkAYQAAABsAThtANQAEAwcDBAeACgEIAQIBCAKAAAcAAQgHAWkGAQMDBWEABQUXTQACAhhNCwEJCQBhAAAAGwBOWUAXYGAAAGBoYGcAXwBeJig3KR0nLCkMBx4rJBYVFAYHBgcGBiMiJjU0NjY3Njc2NTQmIyIGBg8CBgYjIiY1NDY3Njc2Njc2NjcOAhUUFxYVFAYjIicmJjU0NjYzMhYXFhYVFAYnJiYnBgcGFTY2MzIWFRQHNjc2MwA2NwYGFRQWMwQrEA4PQ3UpjWk3QSx4cAEEGi0lJ2NRDQMHAiwfISQPCgsGCxwOAwgFYnAvFAQtGBELFBpv47JugzEfHyUoWmVSKxkCMnZWVloRSj4NCv5ROhxIPwwM8SsVFxoKK1LN8z8zOWh+UAkZqjUeJClXQBpMHR8gGhhvPT0tTJZDDycYAxovJSIfBwgTIQoRPyhVZzAICQYeFCEeAwcFAdiaCAZDQmRaHnQ2Jwj9t2d4Ol4gERYAAAIAHP/7AscDUAA1AEQAj0AKMwEIBwkBAQgCTEuwLlBYQCwAAQgJCAEJgAUBAwYBAgcDAmkKAQcACAEHCGkABAQXTQsBCQkAYgAAABgAThtAMQABCAkIAQmAAAUDAgVZAAMGAQIHAwJpCgEHAAgBBwhpAAQEF00LAQkJAGIAAAAYAE5ZQBg2NgAANkQ2Qzw6ADUANCQlIjM4JiQMBx0rABUUBgYjIiY3NwYHBiMiJjU0Njc3NjcGIyImNTQzMjc3NjMyFhUUBwc3MhYVFAYjIwcGBzYzEjY1NCYjIgYHBgcHFBYzAsdbo2h/fAYDBgwOCxIWEhk4DRcsChgcUxUUDA1AGyMDBUUeHCIwQwoLC2hJBm9ESipOMggBATZBAiXVY5tXnp4sAgYGHRoUGQoWRm4CEhIyATQ6IhsMDBUBFQ0ZHCYqOB3+QXViQT0NETIpJGRUAAACABv/+AUuA0sAaAB7AOZADVs7HhAECQsZAQAEAkxLsBJQWEAvDAEJCwMLCQOAAAMECwMEfgoHAgUFBl8ABgYXTQALCxlNCAEEBABhAgECAAAYAE4bS7AVUFhAOgwBCQsDCwkDgAADCAsDCH4KBwIFBQZfAAYGF00ACwsZTQAICABhAgECAAAYTQAEBABhAgECAAAYAE4bQEEMAQkLAwsJA4AAAwgLAwh+CgcCBQUGXwAGBhdNAAsLAGECAQIAABhNAAgIAGECAQIAABhNAAQEAGECAQIAABgATllZQBYAAHp2b24AaABnLTRTTSQmLi0mDQcfKyQWFRQHBgYjIiYnJicuAicHBgYHBiMiJjU3NzY3Nw4CBw4CIyImJyY1NDYzMhYXFhYzMjY3PgI3LgInJyYmJwYjIiY1NDc2IQUyFhUUBiMjBgYHDgIHHgIXFxYWMzI2NzYzADY2NzY3BRYXFhceAhcWMzI3BR8PEzBiQ0peKQ0UERYjHQQLFwQFQyIkAQcUDwQrQi8eJDZTOURPEwMeHBoZBwkbGBsjGhoyV0AjKxYOBhMmHxImJBtiLgEyAikaJCglHhodFBYtWEYnNB8UEh49JSA6LAwP/iBEKxsQCf4ZCAoHCgwTJyEoEiok3xgVJxc6P1dcHTQsLB8HGEOxMEYcFwk2lmAZCDdHOENNNjc2CQwbLhQWHRcxODtUTBMLLDUtFTwtAgEXFUQFAgEZEiAnASctM0lEEgstNy8oQTgrNA4BHDdBNSAQARMcFSgtMiECAggAAAADAED/+wMeA1AADwAkADgAjEAMIRICAwI0JwIFBgJMS7AdUFhAKgACAAYFAgZpCQEEBAFhCAEBARdNAAUFA2EAAwMZTQoBBwcAYQAAABgAThtAKAACAAYFAgZpAAMABQcDBWkJAQQEAWEIAQEBF00KAQcHAGEAAAAYAE5ZQB4lJRAQAAAlOCU3MS8rKRAkECMdGxcVAA8ADiYLBxcrABYWFRQGBiMiJiY1NDY2MwYGBz4CMzIWFxYWMzI2Njc1NCYjEjY3BgYjIiYnJiYjIgYGBxUUFjMCO49Ub790WY9Ub790ZIMaBiYoFRkrHSEwHh0tIgVkTwqCGR4yHx4uIB4pGRoqIwhkTwNQUJtsmOh+UJtsmOh+doNwAg0HDw4QDwkKARN3e/2XhHAJCQ8QDw4JDAIVd3sAAAABAHv/+wPeA1AALgAqQCcYAQACAUwAAAIDAgADgAQBAgIXTQADAwFiAAEBGAFOVSgmJiQFBxsrABYVFAYjIicmJwYCBiMiJjU0NzY2MzIWFRQHBhUUFjMyNhI3NjY3OwIWFxYWFwPKFCEWDQknRTiZrFdpbRgIJiUfIwIbNy0sbWgkCCkkAgYMQxcjJhgDLRoYGBsEEQj9/rGe/NSNnzEoGyMGFLiGk6STASHILCMCAgIDCQoAAAAAAQAj//sDWgNaAEYAd0AKMQEGABcBAwICTEuwLlBYQCQABgABAAYBgAAAAAdhAAcHF00EAQICAWEFAQEBGU0AAwMYA04bQC4ABgABAAYBgAAAAAdhAAcHF00EAQICAV8AAQEZTQQBAgIFYQAFBRlNAAMDGANOWUALNi4zOCYkIyYIBx4rABYVFAYHBgYjIwYHNzIWFRQGIyMHBgYHBgYjIiY1NDY3Njc3BiMiJjU0MzI3Njc2NjcGBhUUFxYVFAYjIicmJjU0NjMyNjcDPxshKUyAcwIcFkgeHCIwPwMMFwQCLB8hJA8KCwYDLAoYHFMTEgoWBAoFWE4UBigZGxMOFNbifok/A1oZGx8gBAgFjnoBFQ0ZHBNJsTQdHyAaGG89PS0SAhISMgE8ahMvHgkzLyIfCQkSGxAMQSF5cQQGAAACACP+OQPhA1oAWwBkAKNADywBAwVXHgICB14BCAIDTEuwMFBYQDYAAwUGBQMGgAkBBwECAQcCgAAFBQRhAAQEF00AAQEGYQAGBhlNAAICGE0KAQgIAGEAAAAbAE4bQDQAAwUGBQMGgAkBBwECAQcCgAAGAAEHBgFpAAUFBGEABAQXTQACAhhNCgEICABhAAAAGwBOWUAaXFwAAFxkXGMAWwBaU1FKSEA9NzUnLCkLBxkrJBYVFAYHBgcGBiMiJjU0NjY3Njc2NTQmIyIGBg8CBgYjIiY1NDY3Njc2NzcGBhUUFxYVFAYjIicmJjU0NjMyNjc2FhUUBgcGBiMjBgcGFTY2MzIWFRQHNjc2MwA2NwYGFRQWMwPREA4PQ3UpjWk3QSx4cAEEGi0lJ2NRDQMHAiwfISQPCgsGECISWE4UBigZGxMOFNbifok/HhshKUyAcwIrGQIydlZWWhFKPg0K/lE6HEg/DAzxKxUXGgorUs3zPzM5aH5QCRmqNR4kKVdAGkwdHyAaGG89PS1tqFgJMy8iHwkJEhsQDEEheXEEBgMZGx8gBAgF2JkIBkNCZFoedDYnCP23Z3g6XiARFgAAAgAb/q0FTgNXAJsAowNMS7AmUFhAGm8BCAaKRSgaBAMImAEEDSMRAgEEnQEQAQVMG0AabwEIC4pFKBoEAwiYAQQNIxECAQSdARABBUxZS7AMUFhAQAsBBgUIBQZyEQ8CAwgNCAMNgA4BDQQIDQR+EgEQAAAQAGUMAQUFB2EKCQIHBxdNAAgIGU0ABAQBYQIBAQEYAU4bS7AVUFhARgsBBgUIBQZyAAMIDwgDD4ARAQ8NCA8Nfg4BDQQIDQR+EgEQAAAQAGUMAQUFB2EKCQIHBxdNAAgIGU0ABAQBYQIBAQEYAU4bS7AXUFhATAsBBgUIBQZyAAMIDwgDD4ARAQ8NCA8Nfg4BDQQIDQR+EgEQAAAQAGUMAQUFB2EKCQIHBxdNAAgIAWECAQEBGE0ABAQBYQIBAQEYAU4bS7AZUFhATQsBBgUIBQYIgAADCA8IAw+AEQEPDQgPDX4OAQ0ECA0EfhIBEAAAEABlDAEFBQdhCgkCBwcXTQAICAFhAgEBARhNAAQEAWECAQEBGAFOG0uwHVBYQFgLAQYFCAUGCIAAAwgPCAMPgBEBDw0IDw1+DgENBAgNBH4SARAAABAAZQAMDAdhCgkCBwcXTQAFBQdhCgkCBwcXTQAICAFhAgEBARhNAAQEAWECAQEBGAFOG0uwIVBYQF4LAQYFCAUGCIAAAwgPCAMPgBEBDw4IDw5+AA4NCA4NfgANBAgNBH4SARAAABAAZQAMDAdhCgkCBwcXTQAFBQdhCgkCBwcXTQAICAFhAgEBARhNAAQEAWECAQEBGAFOG0uwJlBYQGELAQYFCAUGCIAAAwgPCAMPgBEBDw4IDw5+AA4NCA4NfgANBAgNBH4SARAAABAAZQAJCRdNAAwMB2EKAQcHF00ABQUHYQoBBwcXTQAICAFhAgEBARhNAAQEAWECAQEBGAFOG0BnAAYFCwUGC4AACwgFCwh+AAMIDwgDD4ARAQ8OCA8OfgAODQgODX4ADQQIDQR+EgEQAAAQAGUACQkXTQAMDAdhCgEHBxdNAAUFB2EKAQcHF00ACAgBYQIBAQEYTQAEBAFhAgEBARgBTllZWVlZWVlALJycAACco5yiAJsAmpeVkpGEgn99eHZpZ2JhW1lTUU5MPz05NzEvIR8pEwcXKyQWFRQGBwYHBgYjIiY1NDY2NyYmJyYnLgInBwYGBwYjIiY1Nzc2NzcOAgcOAiMiJicmNTQ2MzIWFxYWMzI2Nz4CNy4CJycmJiMiBgcGIyImNTQ3NjYzMhcWFx4CMzY2NzY2MzIVFAYHBgc+Ajc+AjMyFxYVFAYjIiYnJiMiBgcOAgceAhcXFhYzMjc2MzIXNzYzADcGBhUUFjMFPw8NEEFEFW5jQkkvWVUqWSANFBEWIx0ECxcEBUMiJAEHFA8EK0IvHiQ2UzlETxMDHhwaGQcJGxgbIxoaMldAIysWDgYVMiUXJxYODQ0PExldLHw4BgsMEychCxYEAygmPBcOAQQyRSobHCtJNnghBBwcHBoHCyAbHhQWLVhGKDMfFBIbMiQCEg0RGwVnDQr+3iI9Ow4MsBgUFhoLLCWooz42MkpBMQtORh00LCwfBxhDsTBGHBcJNpZgGQg3RzhDTTY3NgkMGy4UFh0XMTg7VEwTCyw1LRVBNRMWDhgVJxcfJK8SLC4yIUGwMCUhPB2WUgoWDDhENzlDLVoMCxopERUhKjE3TkcSCy04Lig7LgMFIT8I/mieIjslDQ8AAAIAOv6tArQDUABHAE8AnUAPMQEHBkQgAgQFSgEJAQNMS7AqUFhANwAHBgUGBwWAAAIEAwQCA4AKAQkAAAkAZQAGBghhAAgIF00ABAQFYQAFBRlNAAMDAWEAAQEYAU4bQDUABwYFBgcFgAACBAMEAgOAAAUABAIFBGkKAQkAAAkAZQAGBghhAAgIF00AAwMBYQABARgBTllAEkhISE9ITiUoJBQnJSQVJQsHHyskBgcOAiMiJjU0NjcmJjU0NjMyFhUUFhYzMjY2NTQmJwYjIiY1NDY3NjU0JiMiBgYVFBYVFAYjIiY1NDY2MzIWFRQGBxYWFQA2NwYVFBYzArRWTBA0XElCSU5ZfY4lJhwhGz03PF81KCBNTyEcTVNmMjIvSCgEHxomIkmIWXNqNTNES/6iMRF7DgzVhCiCpFY+NkBhOQJsYjIwHx00Oxs2WDIqOQUsFhkkJgRAaCwxHTEcCBoHGRk3LjddN1xQPGsnE11D/fVXYlFMDQ8AAAAAAgAa/q0EJQNPAHMAewF/S7AuUFhAI14BBgg4AQkGVQEFB2MBBAVwAQMLEQEBA3UBDgEHTBcBBAFLG0AjXgEGCjgBCQZVAQUHYwEEBXABAwsRAQEDdQEOAQdMFwEEAUtZS7AdUFhATQAJBgcGCQeAAAcFBgcFfgACBA0EAg2ADwENCwQNC34MAQsDBAsDfgAFAAQCBQRpEAEOAAAOAGUABgYIYQoBCAgXTQADAwFhAAEBGAFOG0uwLlBYQFMACQYHBgkHgAAHBQYHBX4AAgQNBAINgA8BDQwEDQx+AAwLBAwLfgALAwQLA34ABQAEAgUEaRABDgAADgBlAAYGCGEKAQgIF00AAwMBYQABARgBThtAVwAJBgcGCQeAAAcFBgcFfgACBA0EAg2ADwENDAQNDH4ADAsEDAt+AAsDBAsDfgAFAAQCBQRpEAEOAAAOAGUACgoXTQAGBghhAAgIF00AAwMBYQABARgBTllZQCB0dAAAdHt0egBzAHJvbWppXFpUUyYpJCQjJCYvKREHHyskFhUUBgcGBwYGIyImNTQ2NjcmJy4CJwcGBiMiJicmNTQ2MzIWFxYWMzI2NzcjIiY1NDYzMzY3NyYjIgYVFBYXFhUUBiMiJyY1NDY2MzIWFxYVFCMDNjY3NjYzMhYVFAcGBgceAhcWFjMyNzYzMhc3NjMANwYGFRQWMwQWDw0QQ0MWbGNCSS9aVT9AHicmHQsVeWpFaxUHHBYNEggfLyMoOQwOEBcaGxQhBwMfGhdVWAsJBCkZIA8eRYxnLUstMS8ndZMxCSshHB8EMrpuJjEiFhgdEAISDREcBGcNCv7eIj07DgywGBQWGgstJKijPjYyS0ExE4tCQRsDSo9+QzQSFR4sDRA6LklMXxoXGh8xE+EDOzcZHxMIChYhHDU9P2g/Cg4PKTf+8wyxmBweGRcHEKXCIAkkNS9CJwMFIT8I/mieIjslDQ8AAAABABr/+AQqA08AfQEJS7AuUFhAH2wBBwk5AQoHY2ACCApWAQYIcQEFBhYBAwUUAQEDB0wbQB9sAQcLOQEKB2NgAggKVgEGCHEBBQYWAQMFFAEBAwdMWUuwLlBYQEoACgcIBwoIgAAIBgcIBn4ODQIDBQEFAwGAAAEMBQEMfgAGAAUDBgVpAAcHCWELAQkJF00ADAwAYgIBAAAYTQAEBABhAgEAABgAThtATgAKBwgHCgiAAAgGBwgGfg4NAgMFAQUDAYAAAQwFAQx+AAYABQMGBWkACwsXTQAHBwlhAAkJF00ADAwAYgIBAAAYTQAEBABhAgEAABgATllAGgAAAH0AfHl3amhVVE9NKSQkIyQmKSgmDwcfKyQWFRQHBgYjIiYnJic2BwYGIyI1NzY3JicHBgYjIiYnJjU0NjMyFhcWFjMyNjc3IyImNTQ2MzM2NzcmIyIGFRQWFxYVFAYjIicmNTQ2NjMyFhcWFRQjAzY3Njc2NhcWFhUUBwc2Njc2NjMyFhUUBwYGBx4CFxYWMzI2NzYzBBsPEzBiQ0peKQkRAQYCExEuAQMMEBULFXlqRWsVBxwWDRIIHy8jKDkMDhAXGhsUIQcDHxoXVVgLCQQpGSAPHkWMZy1LLTEvJxMSDQEDGA0VGQIFPlghCSshHB8EMrpuJjEiFh82JCA6LAwP3xgVJxc6P1dcFSILRBgcRRMeVwgCSo9+QzQSFR4sDRA6LklMXxoXGh8xE+EDOzcZHxMIChYhHDU9P2g/Cg4PKTf+8wIEYQ4eGgIDGiEHEiUqlGgcHhkXBxClwiAJJDUvQjcrNA4AAAAAAQAa//gEKgNPAHkBDEuwLlBYQBdoAQgKNwELCF8BBQltAQQFBEwOAQQBSxtAF2gBCA43AQsIXwEFCW0BBAUETA4BBAFLWUuwLlBYQE4ACwgHCAsHgAAJBgUGCQWAERACAgQPBAIPgAwBBw0BBgkHBmkABQAEAgUEaQAICAphDgEKChdNAA8PAGIBAQAAGE0AAwMAYQEBAAAYAE4bQFcACwgMCAsMgAAJBgUGCQWAERACAgQPBAIPgAAMBwYMWQAHDQEGCQcGaQAFAAQCBQRpAA4OF00ACAgKYQAKChdNAA8PAGIBAQAAGE0AAwMAYQEBAAAYAE5ZQCAAAAB5AHh1c2ZkXlxYVVNSTUtFQyIzMSQjJCYpJhIHHyskFhUUBwYGIyImJy4CJwcGBiMiJicmNTQ2MzIWFxYWMzI2NzcjIiY1NDYzMzcGIyImNTQzMjc3JiMiBhUUFhcWFRQGIyInJjU0NjYzMhYXFhUUIwYHNjMyFhUUBiMjBzY2NzY2MzIWFRQHBgYHHgIXFhYzMjY3NjMEGw8TMGJDSl4pHicmHQsVeWpFaxUHHBYNEggfLyMoOQwOEBcaGxQhDzgOGBxTGhkOGhdVWAsJBCkZIA8eRYxnLUstMS8IAxEYHhwiMB4PdZMxCSshHB8EMrpuJjEiFh82JCA6LAwP3xgVJxc6P1dcQkEbA0qPfkM0EhUeLA0QOi5JTF8aFxofZgISEjIBagM7NxkfEwgKFiEcNT0/aD8KDg8pNzYaARUNGRxnDLGYHB4ZFwcQpcIgCSQ1L0I3KzQOAAABABr/+AQqA0oAYACvQBRPLQIGB0YBBQZUAQQFA0wOAQQBS0uwDFBYQDcMCwICBAoEAgqACAEHAAYFBwZpAAUABAIFBGkACQkXTQAKCgBiAQEAABhNAAMDAGEBAQAAGABOG0A+AAgJBwkIB4AMCwICBAoEAgqAAAcABgUHBmkABQAEAgUEaQAJCRdNAAoKAGIBAQAAGE0AAwMAYQEBAAAYAE5ZQBYAAABgAF9cWk1LMSgiJCMkJikmDQcfKyQWFRQHBgYjIiYnLgInBwYGIyImJyY1NDYzMhYXFhYzMjY3NyMiJjU0NjMzNwYjIicmJjU0NhcWMzI3NjMyFhUUBgcGBwc2Njc2NjMyFhUUBwYGBx4CFxYWMzI2NzYzBBsPEzBiQ0peKR4nJh0LFXlqRWsVBxwWDRIIHy8jKDkMDhAXGhsUISNWOkIwHxYdGDI2dJgGDBsbExgDBxx1kzEJKyEcHwQyum4mMSIWHzYkIDosDA/fGBUnFzo/V1xCQRsDSo9+QzQSFR4sDRA6LklMXxoXGh/2BwcEHR4WHwMFEwEcHxgYBBQzvgyxmBweGRcHEKXCIAkkNS9CNys0DgAD//D+rQQHA20AWwBlAG0BsEuwFVBYQBNfAQQGFQEBBFgRAgIKZwEOAgRMG0ATXwEIBhUBAQRYEQICCmcBDgIETFlLsBVQWEBEAAYFBAUGBIAPAQwBCgEMCoALAQoCAQoCfgAJEAENBQkNaQgBBAMBAQwEAWkRAQ4AAA4AZQAFBQdhAAcHF00AAgIYAk4bS7AXUFhATwAGBQgFBgiAAAEEAwQBA4APAQwDCgMMCoALAQoCAwoCfgAJEAENBQkNaQAEAAMMBANpEQEOAAAOAGUABQUHYQAHBxdNAAgIGU0AAgIYAk4bS7AdUFhAUQAGBQgFBgiAAAgEBQgEfgABBAMEAQOADwEMAwoDDAqACwEKAgMKAn4ACRABDQUJDWkABAADDAQDaREBDgAADgBlAAUFB2EABwcXTQACAhgCThtAVwAGBQgFBgiAAAgEBQgEfgABBAMEAQOADwEMAwsDDAuAAAsKAwsKfgAKAgMKAn4ACRABDQUJDWkABAADDAQDaREBDgAADgBlAAUFB2EABwcXTQACAhgCTllZWUAkZmZcXAAAZm1mbFxlXGQAWwBaV1VSUUlHJCYiJCQlIx0pEgcfKyQWFRQGBwYHBgYjIiY1NDY2NyY1NDcGBwYHBgcGIyI1NDc2NwciJjU0Njc3NjU0JiMiBwYjIiY1NDc2NjMyFhUUBzc2Nz4CMzIWFRQHBhUUFjMyNzYzMhc3NjMCBgYHNjY1NCYjAjcGBhUUFjMD+A8NEEFEFW5jQkkuWVOfA0JONBMUJBU7QAUiFDAhHiYsNRocF0ZYDRAOFBkshkVBRxhiPy0SSm5EMjr9AzMwAhINERwEZw0KujEsDVBMEAx+Ij07DgywGBQWGgssJaijPjYySkEwEv0iIgwGBAFmlFc6DReJXwIXGiEfAgKNSi8idREaFB8jPU9ZXlOOBQMHbsB4T0D4YCgrZ0oDBSE/CAJmUIpSIXpgFxr8Ap4iOyUNDwAAAAH/8P/5BFkDbQBbAU21JQEFCAFMS7ASUFhAOAAKAAgACgiAAAMFAgUDAoAADQsADVkMAQgHAQUDCAVpCQECAAALYQALCxdNAAICBGEGAQQEGAROG0uwFVBYQEAAAAEJAQAJgAAKCQgJCgiAAAMFAgUDAoAADQABAA0BaQwBCAcBBQMIBWkACQkLYQALCxdNAAICBGEGAQQEGAROG0uwF1BYQEsAAAEJAQAJgAAKCQwJCgyAAAUIBwgFB4AAAwcCBwMCgAANAAEADQFpAAgABwMIB2kACQkLYQALCxdNAAwMGU0AAgIEYQYBBAQYBE4bQE0AAAEJAQAJgAAKCQwJCgyAAAwICQwIfgAFCAcIBQeAAAMHAgcDAoAADQABAA0BaQAIAAcDCAdpAAkJC2EACwsXTQACAgRhBgEEBBgETllZWUAWWVdTUU1LRUNBPyQlIxclIygzIw4HHysAFhUUIyInJiYjBwYGBw4CFRQWMzI2NzYzMhYVFAcGIyImNTQ3BgcGBwYHBiMiNTQ3NjcHIiY1NDY3NzY1NCYjIgcGIyImNTQ3NjYzMhYVFAc3Njc+AjMyFhcEOh89CgYtUB4aEBISFTIkNC8pRCsMDw0PE2NwYXQDQk40ExQkFTtABSIUMCEeJiw1GhwXRlgNEA4UGSyGRUFHGGI5MxJJbkVGVjMDVh4UPQEGCAEBDhoggqZRaVgrNA4YFScXeZaMICQMBgQBZpRXOg0XiV8CFxohHwICjUovInURGhQfIz1PWV5TjgUDBm7AeQcKAAAAAAIAI/6tA/8DTwBeAGcAr0AQTzECBgJaIgIBB2EBCQMDTEuwDlBYQDcABgIEAgYEgAAEBwIEB34KCAIHAQIHAX4AAQMCAQN+CwEJAAAJAGUAAgIFYQAFBRdNAAMDGANOG0A9AAYCBAIGBIAABAgCBAh+CgEIBwIIB34ABwECBwF+AAEDAgEDfgsBCQAACQBlAAICBWEABQUXTQADAxgDTllAG19fAABfZ19mAF4AXVlWTUtFQzw6J0YXKQwHGiskFhUUBgcGBwYGIyImNTQ2Njc3IjU0Nzc2NyYjIgcGBwYGBwYGIyImNTQ2NzY3NjY3NwYGFRQXFhUUBiMiJyYmNTQ2NjMyFxYWFRQGIyInJwYHAwYVFBYzMzIHNjc2MwA2NwYGFRQWMwPtDw0QP0kWa2JCSTdkbAGLGCUcBEJaNhgkIAsYBAIsHyEkDwoLBg0eDwpdUxEFKxgRCxQadu+9xLwfGx4eCwZlBBE9CisoASADPCsNCv6/LhE7Ow4MsBgUFhoLKyeqoD42Nk9EPQyCNXa3ijMDAba7RLM3HR8gGhhvPT0tU55JMAsyKyMaBwsUIQoRPyhVZzAeBR8UHh8BDUZK/uIyIBoSNCMbCP5oSlMhOyUNDwAAAAACAEH/+gRjA1MANgBDAIhLsCZQWEALOSQCBAALAQEEAkwbQAs5JAIEAAsBAQYCTFlLsCZQWEAiAAAHBAcABIAABQAHAAUHaQADAxdNBgEEBAFiAgEBARgBThtALAAABwQHAASAAAUABwAFB2kAAwMXTQAEBAFiAgEBARhNAAYGAWECAQEBGAFOWUALKiYnKyYiJiAIBx4rJDMyFRQGBwYGIyInBiMiJiY1NDY2MzIWFRQGBw4CFRQWMzI3JiY1NDY2MzIWFhUUBgczMjY3JBYXNjY1NCYjIgYGFQQ6Cx4ODymkRFxPZnJxplprrmEgGSUjM2NCaYAiHzI3XZlYS3pHZlsGOnhC/f4/M2BmSEUtTjC6JxImChs5HyJWn2yR54AgIRocBQdTn3F5fwM0iE94sFxMjl5otkIjIHhuICmdaVtpPH1aAAAAAgBB/jkDegNQAEMASwC1S7ASUFhADzwBBQY/EwIBBUYBCAEDTBtADzwBBQc/EwIBBUYBCAEDTFlLsBJQWEAxAAMEBgQDBoAJBwIGBQQGBX4ABAQCYQACAhdNAAUFAWEAAQEYTQoBCAgAYQAAABsAThtANwADBAYEAwaAAAYHBAYHfgkBBwUEBwV+AAQEAmEAAgIXTQAFBQFhAAEBGE0KAQgIAGEAAAAbAE5ZQBZERAAAREtESgBDAEIjJSgkJikpCwcdKyQWFRQGBwYHBgYjIiY1NDY2NzY3BiMiJiY1NDY2MzIWFRQGIyImNTQ3NjY1NCMiBgYVFBYzMjY3NjMyFhUUBwc2NzYzADY3BgYVFDMDaw8OD0V3J3xfM0Aqc2kCAlBbYJVVcb9xbHAsJxwgBQEEYUJ4SmliPGw4Eg8PEAIIUEINCv5mPhtMQxzdGRMXGgosVNDtPzMvYH5REgoqUKBzkeR9b1s9SxsZEBcGGwlbVqdyg3cxNBEaFAUMPzwsCP29doNBaSgnAAAAAgAj/q0DhwNPAD8ARwBAQD1CGgwDBgEBTAAEAAEABAGAAAEGAAEGfgcBBgACBgJlAwEAAAVhAAUFFwBOQEBAR0BGPjs0MikoJCUmCAcZKwAWFRQGJyYmJwYHBgc2MzIHDgIjIiY1NDY3JiY1NDY3Njc2Njc2NjcOAhUUFxYVFAYjIicmJjU0NjYzMhYXADY3BhUUFjMDaB8lKFplUiUfFg0eDzEGDzVcSkJJUV0TFA8KCwYLHA4DCAVicC8UBC0YEQsUGm/jsm6DMf4UMRF7DgwDOB4UIR4DBwUBuLqKeAc1hapZPjZCYzkHHBMYbz09LUyWQw8nGAMaLyUiHwcIEyEKET8oVWcwCAn72ldiUUwNDwAAAQCL//sC5ANPABsAI0AgFw0EAwABAUwDAgIBARdNAAAAGABOAAAAGwAaKCgEBxgrABUUBwEHDgIjIiY3EwMmNTQ2MzIWFxMTNjYzAuQY/v0QAwYWGx8tARGxCSMgHyQJfLsPLCEDTyIVJv5o/i4iERYbAR0BqRcSGRsVF/7MATQYFAAAAQCL//sC5ANPAC4AYLUqAQAGAUxLsC5QWEAYBQEABAMCAQIAAWkIBwIGBhdNAAICGAJOG0AjAAQBAgEEcgAABQEAWQAFAwEBBAUBaQgHAgYGF00AAgIYAk5ZQBAAAAAuAC0lMyETJCQ0CQcdKwAVFAcBNjMyFhUUBiMjBw4CIyImNzcHBiMiJjU0MzI3AyY1NDYzMhYXExM2NjMC5Bj/AB0kHhwiMDELAwYWGx8tAQ0yCxMYHFMXFqkJIyAfJAl8uw8sIQNPIhUm/m4BFQ0ZHK4uIhEWG9sBARISMgEBlhcSGRsVF/7MATQYFAAC//H+rQNIA1AASgBSAKFAEj0zHxUECANHEQIBBkwBCQEDTEuwHVBYQDEAAwIIAgMIgAoBCAYCCAZ+BwEGAQIGAX4LAQkAAAkAZQACAgRhBQEEBBdNAAEBGAFOG0A3AAMCCAIDCIAKAQgHAggHfgAHBgIHBn4ABgECBgF+CwEJAAAJAGUAAgIEYQUBBAQXTQABARgBTllAF0tLAABLUktRAEoASSMYJiYiKC0pDAceKyQWFRQGBwYHBgYjIiY1NDY2NyYmJycDBgYjIiY1NDcBJyYmIyIHBiMiJjU0NzY2MzIWFxc3NjYzMhYVFAcBFxYWMzI3NjMyFzc2MwA3BgYVFBYzAzkPDRBBRBVuY0JJL1pVIkAXIuwUKhwcJR0BRCAXOCQ1RwwPDxUdKWBCR1wbFK8UKh4bHxv+/DkVGw8CEg0RHARnDQr+3iI9Ow4MsBgUFhoLLCWooz42MktBMQxbVHz+3BkPFRMZIAFxdVJCTQ0XEh4jMDpZY0bVGBQUEhgf/tTMRzEDBSE/CP5oniI7JQ0PAAIAI/6tBIwDUABnAHABcUuwDlBYQA4WAQoEYwEBCGoBDAIDTBtADhYBCwRjAQEIagEMAgNMWUuwDlBYQDwABAMKAwQKgA0LAgoIAwoIfg4BDAAADABlBwYCAwMFYQkBBQUXTQABAQVhCQEFBRdNAAgIAmEAAgIYAk4bS7AXUFhAQgAEAwsDBAuADQELCgMLCn4ACggDCgh+DgEMAAAMAGUHBgIDAwVhCQEFBRdNAAEBBWEJAQUFF00ACAgCYQACAhgCThtLsB1QWEBIBwEGAwQDBgSAAAQLAwQLfg0BCwoDCwp+AAoIAwoIfg4BDAAADABlAAMDBWEJAQUFF00AAQEFYQkBBQUXTQAICAJhAAICGAJOG0BIAAYDBAMGBIAABAsDBAt+DQELCgMLCn4ACggDCgh+DgEMAAAMAGUHAQMDBWEJAQUFF00AAQEFYQkBBQUXTQAICAJhAAICGAJOWVlZQBxoaAAAaHBobwBnAGZiX1JQKRImJikXJRcpDwcfKyQWFRQGBwYHBgYjIiY1NDY2NzciNTQ3BgYjIiY1NDc2NjcOAhUUFxYVFAYjIicmJjU0NjMyFhcWFhUUIyInJicGBgcOAhUUFjMyNhI3NjYzMhYVFAYHBgcGFQYVFBYzMzIHNjc2MwA2NwYGFRQWMwR9Dw0QP0kWa2JCSTdkbAF/DzKZZFRWDQ4qLmV3NRQELRgRCxQa6elERDYfHzsMBjotIBkqAgoGJCE8e2kdBxsnIyIOCSIMAgQXIRAgAzwrDQr+vy4ROzsODLAYFBYaCysnqqA+NjZPRD0MYS1nk5pdTiNITru9ARgxKCIfBwgTIQoRPyh8cAcKBh4UOwEGAnBqxgkuKRQgJoABHd4zKCovGFo0u3oUBygJIBI0IxsI/mhKUyE7JQ0PAAAAAAIAcP6tA6ADVABPAFgAikAPPRkCBANLAQEGUgEJAQNMS7AJUFhAJwoIBwMGAgECBgGAAAQAAgYEAmoLAQkAAAkAZQABAQNhBQEDAxcBThtALQoBCAIGAggGgAcBBgECBgF+AAQAAggEAmoLAQkAAAkAZQABAQNhBQEDAxcBTllAF1BQAABQWFBXAE8AThIaJCsqKBcpDAceKyQWFRQGBwYHBgYjIiY1NDY2NzciNTQ2NzY3BgYjIiY1NDY3NjYnJjYzMhcWFRQGBwYGFRQWMzI2Njc2MzIHBgYPAgYVFBY3NjMyBzY3NjMANjcGBhUUFjMDkQ8NED9JFmtiQkk3ZGwBfwgJEAQqelRmbQkKDQ0BASglPQYCDw0HCjAtRG1DCAZCRwYEGAwTAwUaJQMIIAM8Kw0K/r8uETs7DgywGBQWGgsrJ6qgPjY2T0Q9DGEiOylHNVdVZFwdOTE/aDweIkAcDjJbOh03EygrY7h7VVM8wVeRHCYSGhIBATQjGwj+aEpTITslDQ8AAQBw//sC6ANUAEQAN0A0PzoyDwQCAxgBAQICTAABAgACAQCAAAICA2EFBAIDAxdNAAAAGABOAAAARABDKhMrJwYHGisABwYHAgcGBiMiNTQ2NzY3BgcHBgYjIjU3NyYmNTQ2NzY2JyY2MzIXFhUUBgcGBhUUFhc2NzY2FxYWFRQHBgYHNjY3NjMC6AYHHikEAiQnPA4PEgU/awcCExEuAQNhaQkKDQ0BASglPQYCDw0HCiYlFgQDGA0VGQIBCgxMYQoGQgNUU1Xh/slWIiE6JV1PYS+CH0kYHEUTGgJkWh05MT9oPB4iQBwOMls6HTcTIysEnSkeGgIDGiEHEgVJSiLNmVUAAAAAAQBO//sDdANQAEMAarUvAQYBAUxLsDBQWEAkBwEGAQUBBgWAAAMDF00AAQEEYQAEBBlNAAUFAGECAQAAGABOG0AiBwEGAQUBBgWAAAQAAQYEAWkAAwMXTQAFBQBhAgEAABgATllADwAAAEMAQiopKyYpJggHHCskFhUUBwYGIyImNTQ3NjY1NCYjIgYGBwcGBiMiNTQ2PwI2Njc2NjMyFRQGDwM2NjMyFhUUBgYHBhUUFjMyNjc2MwNlDxMsbEVBOAkIBi0lKWVQCwkDJiJFExMEFwsXBAMoJj8REQkWAzN2VlVdCQoCAhAPHTwqDA/fGBUoFjRFNDQiKyknGx4kK1tEUiUhPCCDbxqDQLEzJSE8HXRkN4MQRENeTR83MAcKBRASKzMOAAACAE7+rQOuA1AAVgBfASVLsAxQWEAQSwEGAlIkEQMBBlkBCAMDTBtAEEsBBwJSJBEDAQZZAQgDA0xZS7AMUFhALAkHAgYCAQIGAYAKAQgAAAgAZQAEBBdNAAICBWEABQUZTQABARhNAAMDGANOG0uwFVBYQDIJAQcCBgIHBoAABgECBgF+CgEIAAAIAGUABAQXTQACAgVhAAUFGU0AAQEYTQADAxgDThtLsDBQWEA0CQEHAgYCBwaAAAYBAgYBfgABAwIBA34KAQgAAAgAZQAEBBdNAAICBWEABQUZTQADAxgDThtAMgkBBwIGAgcGgAAGAQIGAX4AAQMCAQN+AAUAAgcFAmkKAQgAAAgAZQAEBBdNAAMDGANOWVlZQBZXVwAAV19XXgBWAFU6Ki4nKCgpCwcdKyQWFRQGBwYHBgYjIiY1NDY2NzUGIyImNTQ3NjU0JiMiBgYPAgYGIyImNTQ2NzY3NjY3Nz4CMzIWFRQHBgcGFTY2MzIWFRQHBgYHBhYWNzMyBzY3NjMANjcGBhUUFjMDnw8NED9JFmtiQkk3ZGw9GBogCgctJSdjUQ0DBwIsHyEkDwoLBg8iEggIDRwaICgDLR8CMnVWVV0FAQQBAgkbHQ8gAzwrDQr+vy4ROzsODLAYFBYaCysnqqA+NjZPRD0CFy4vJkAuGB4kKVdAGkwdHyAaGG89PS1gtVUlJSQVICEKDti6CAZDQl5NFxwGHQ8UFAcBNCMbCP5oSlMhOyUNDwACADf/+wOmA1AANAA+AIa1HwEHAwFMS7AmUFhAMQADCAcIAweAAAACBgIABoAJAQgIBGEABAQXTQUBAgIHXwAHBxlNAAYGAWEAAQEYAU4bQC8AAwgHCAMHgAAAAgYCAAaAAAcFAQIABwJpCQEICARhAAQEF00ABgYBYQABARgBTllAETU1NT41PRYjJysmFCYgCgceKyQzMhYVFAcGBiMiJiY1NSYnJiY1NDYzMhcWFhcWFxYXPgIzMhYVFAYHBgYjIRUUFjMyNjcABgYHITY1NCYjA3wKEBBCR5lFd7BeLCAWIR8YEQoICwYIDQQMFnCjYXRyFAwNMyj+noaDQYVR/qRhRxEBQxcxOrwYEz0dHx1XoGoWAwsHLBspJgUEDwoOBAICbqRZgHIneBkcGQN4gyEiAig7c1EuTkJBAAAAAAIAN/8CA6YDUABNAFcA8UALOAEKBiMLAgEJAkxLsBJQWEA5AAYLCgsGCoAAAAUJBQAJgAMBAgAEAgRlDAELCwdhAAcHF00IAQUFCl8ACgoZTQAJCQFhAAEBGAFOG0uwJlBYQEAABgsKCwYKgAAABQkFAAmAAAMBAgEDAoAAAgAEAgRlDAELCwdhAAcHF00IAQUFCl8ACgoZTQAJCQFhAAEBGAFOG0A+AAYLCgsGCoAAAAUJBQAJgAADAQIBAwKAAAoIAQUACgVpAAIABAIEZQwBCwsHYQAHBxdNAAkJAWEAAQEYAU5ZWUAWTk5OV05WUlFLSScrJhgnIiYmIA0HHyskMzIWFRQHBgYjIicGBhUUFjMyNzYzMhYVFAYHBgYjIiY1NDcmJjU1JicmJjU0NjMyFxYWFxYXFhc+AjMyFhUUBgcGBiMhFRQWMzI2NwAGBgchNjU0JiMDfAoQEEJHmUUyKR4bJBoaFRALDgwWGQwnEEZUSGNsLCAWIR8YEQoICwYIDQQMFnCjYXRyFAwNMyj+noaDQYVR/qRhRxEBQxcxOrwYEz0dHx0HFzUbHR4HBhMTFR0JBAZJP1Q9KKdyFgMLBywbKSYFBA8KDgQCAm6kWYByJ3gZHBkDeIMhIgIoO3NRLk5CQQD////v/+4CLANLAAIASgAA//8AG//4BS4EZgAiA04AAAEHBeQEGAF8AAmxAQG4AXywNSsA//8AGv6tBCUDTwACA34AAAABAAj/IwPeA1AAQgB0QAobAQIEFgEBAwJMS7ASUFhAIAcGAgIEAwQCA4AFAQMDAWEAAQEYTQAAAARhAAQEFwBOG0AmBwYCAgQFBAIFgAAFAwQFA34AAwMBYQABARhNAAAABGEABAQXAE5ZQBQAAABCAEE+PDY0LiwoJiAeKwgHFyskFhUUBwYHBgYHBgYjIiY1NDc2Njc2NyYmNTQ3DgIjIiYnJjU0NjMyFhcWFjMyNjc2EzY2MzIWBwYVFBYzMjY3NjMDzw8TIRc2RRsZIhoXIgsEBQI0GVBLCS9kiltAYBcJIRoVGgYMKB4kZDU+VQ01KSkgAw8tNyA5LgsQ3xgVJxcnFThfMi0fHhYSDwUJA04qF8CWT1Wo6IpANxcUHikUFisnf3aKARsqJyUqzHyYryk2DgAAAP////D+rQQHA20AAgOCAAAAAv/w/yMD6gNtAFoAZAEyS7AVUFhADl4BBAYYAQEEEwECCgNMG0AOXgEIBhgBAQQTAQIKA0xZS7AVUFhAQAAGBQQFBgSADQELAQoBCwqAAAoCAQoCfgAAAgCGAAkOAQwFCQxpCAEEAwEBCwQBaQAFBQdhAAcHF00AAgIYAk4bS7AXUFhASwAGBQgFBgiAAAEEAwQBA4ANAQsDCgMLCoAACgIDCgJ+AAACAIYACQ4BDAUJDGkABAADCwQDaQAFBQdhAAcHF00ACAgZTQACAhgCThtATQAGBQgFBgiAAAgEBQgEfgABBAMEAQOADQELAwoDCwqAAAoCAwoCfgAAAgCGAAkOAQwFCQxpAAQAAwsEA2kABQUHYQAHBxdNAAICGAJOWVlAHFtbAABbZFtjAFoAWVZUTEokJiIkJCUjHisPBx8rJBYVFAcGBwYGBwYGIyImNTQ3NjcmJjU0NwYHBgcGBwYjIjU0NzY3ByImNTQ2Nzc2NTQmIyIHBiMiJjU0NzY2MzIWFRQHNzY3PgIzMhYVFAcGFRQWMzI2NzYzAgYGBzY2NTQmIwPbDxMbGzhFHRkiGhciCzsbUFsDQk40ExQkFTtABSIUMCEeJiw1GhwXRlgNEA4UGSyGRUFHGGI/LRJKbkQyOv0DNC8pRCsMD50xLA1QTBAM3xgVJxcgGDlgNC0fHhYSD1gvD5N8IiIMBgQBZpRXOg0XiV8CFxohHwICjUovInURGhQfIz1PWV5TjgUDB27AeE9A+GAoK2lYKzQOAjdQilIhemAXGgAAAgBw/q0C6ANUAD8ARwBLQEgdAQUEFAEAAkIBBwADTAACAwADAgCAAAUAAwIFA2oJAQcAAQcBZQgGAgQEF00AAAAYAE5AQAAAQEdARgA/AD4rKiYpIycKBxwrAAcGBwIHBgYjIicGBiMiJjU0NjY3NDY2MzM2NzY3BgYjIiY1NDY3NjYnJjYzMhcWFRQGBwYGFRQWMzI2Njc2MwA2NwYVFBYzAugGBx4pBAIkJxELGWZkQkk2aV8KHyAKBRQUBCp6VGZtCQoNDQEBKCU9BgIPDQcKMC1EbUMIBkL+0DERew4MA1RTVeH+yVYiIQStpT42NlRNNxcZDDJkcCVXVWRcHTkxP2g8HiJAHA4yWzodNxMoK2O4e1X7xFdiUUwNDwAAAQAJ/yME7gNQAFgAkUuwLlBYQAxDJRgDAwUTAQEEAkwbQAxDJRgDAwUTAQIEAkxZS7AuUFhAIgkIAgMFBAUDBIAHAQQEAWECAQEBGE0AAAAFYQYBBQUXAE4bQCYJCAIDBQQFAwSABwEEBAJhAAICGE0AAQEYTQAAAAVhBgEFBRcATllAGAAAAFgAV1RSTEo+PDc1MjArKR8dKwoHFyskFhUUBwYHBgYHBgYjIiY1NDc2NyYmNTQ3IwIDBgYjIicmJjU0NyMOAiMiJiY1NDYzMhcWFjMyNhI3NjYzMgcGFRQXMzYSNz4CMzIWBwYVFBYzMjY3NjME3w8THRw2RRsZIhoXIgs+GURGFwJkXAoeHDAOGRwEAic/dmA0USwgHScJCSkeJkdNLQgyMVIGBRgCGm4+EBgeGyotBBkmLCE9LQsQ3xgVJxckGDhfMi0fHhYSD10rE6uScp7+7f7dHxgwUN9yQjHI4ZYtTCwfJSYlJ4IBIO4sJVdVRaLabwEqhCMgDSkm/I17iyk2DgD//wA4//sDkwRmACIDRAAAAQcF5AOCAXwACbEBAbgBfLA1KwD//wA4//sDkwQxACIDRAAAAQcFvQOCAXwACbEBArgBfLA1KwD//wA4//sEdQNRAAIAHQAA//8AH//7AywEZgAiA0sAAAEHBeQDBAF8AAmxAQG4AXywNSsA//8AO//7AwUDUAACAJwAAP//ADv/+wMFBDEAIgOeAAABBwW9AvEBfAAJsQICuAF8sDUrAP//ABv/+AUuBDEAIgNOAAABBwW9BBgBfAAJsQECuAF8sDUrAP//ADr/+wK0BDEAIgNPAAABBwW9Au8BfAAJsQECuAF8sDUrAAABADr/+wMAA04ARQCRQAsuAQAGJAkCBAUCTEuwMFBYQDYAAAYHBgAHgAAHBQYHBX4AAgQDBAIDgAAGBghhAAgIF00ABAQFYQAFBRlNAAMDAWEAAQEYAU4bQDQAAAYHBgAHgAAHBQYHBX4AAgQDBAIDgAAFAAQCBQRpAAYGCGEACAgXTQADAwFhAAEBGAFOWUAMJikjFCclJCkkCQcfKwAWFRQGIyMGBgcWFhUUBgYjIiY1NDYzMhYVFBYWMzI2NjU0JicGIyImNTQ2NzY3JiMiBhUUFhcWFRQGIyInJiY1NDYzMhcC5xkcGQkpRS9ES1qla3+RJSYcIRs9NzxfNSggTU8hHEVIZ0dSYUlACQEIIhkZEBIYm4ibhwMfHBcbHlJoIxNdQ0+IUW5iMjAfHTQ7GzZYMio5BSwWGSImBUugECshDxgCEggUFg8RNhleYCYAAAD///////sD+wPyACIDUAAAAQcFxwNBAXwACbEBAbgBfLA1KwD///////sD+wQxACIDUAAAAQcFvQNCAXwACbEBArgBfLA1KwD//wBA//sDHgQsACIDWQAAAQcFvQMUAXcACbECArgBd7A1KwAAAwBA//sDHgNQAA8AGgAlAGpLsCxQWEAiBwEDAwFhBgEBARdNAAQEAl8AAgIZTQgBBQUAYQAAABgAThtAIAACAAQFAgRnBwEDAwFhBgEBARdNCAEFBQBhAAAAGABOWUAaGxsQEAAAGyUbJCEdEBoQGRYSAA8ADiYJBxcrABYWFRQGBiMiJiY1NDY2MwYGBxYzMjc1NCYjEjY3JiMiBxUUFjMCO49Ub790WY9Ub790ZoUYPHlRpmRPDYQXN21brmRPA1BQm2yY6H5Qm2yY6H52iHQCAgp3e/2XjHUBAg53e///AED/+wMeBCwAIgOmAAABBwW9AxQBdwAJsQMCuAF3sDUrAP//ACz/+wLgBDEAIgNuAAABBwW9AuwBfAAJsQECuAF8sDUrAP//ACP/AwO7A/IAIgNeAAABBwXHAzYBfAAJsQIBuAF8sDUrAP//ACP/AwO7BDEAIgNeAAABBwW9AzcBfAAJsQICuAF8sDUrAP//ACP/AwO7BHwAIgNeAAABBwXBAzcBfAAJsQICuAF8sDUrAP//AHD/+wLoBDEAIgNiAAABBwW9AvABfAAJsQECuAF8sDUrAAACACP+rQNaA1oAOwBDAEFAPiYBAwA+Gw0DBQECTAADAAEAAwGAAAEFAAEFfgYBBQACBQJlAAAABGEABAQXAE48PDxDPEI6NzEvJCYmBwcZKwAWFRQGBwYGIyMGBwYHNjMyBw4CIyImNTQ2NyYmNTQ2NzY3Njc3BgYVFBcWFRQGIyInJiY1NDYzMjY3ADY3BhUUFjMDPxshKUyAcwIrGRYNHhAxBg81XEpCSVFdExUPCgsGECISWE4UBigZGxMOFNbifok//eMxEXsODANaGRsfIAQIBdiZingHNYWqWT42QmM5BhwUGG89PS1tqFgJMy8iHwkJEhsQDEEheXEEBvvBV2JRTA0PAP//ABz/+wQWBDEAIgNpAAABBwW9A6sBfAAJsQMCuAF8sDUrAAAB/7/+rQNaA1oAVQC/tUABCAABTEuwEFBYQC0ACAABAAgBgAAEAgUFBHIABQADBQNmAAAACWEACQkXTQYBAgIBYQcBAQEZAk4bS7AuUFhALgAIAAEACAGAAAQCBQIEBYAABQADBQNmAAAACWEACQkXTQYBAgIBYQcBAQEZAk4bQDgACAABAAgBgAAEAgUCBAWAAAUAAwUDZgAAAAlhAAkJF00GAQICAV8AAQEZTQYBAgIHYQAHBxkCTllZQA5UUS4zOSQkKCQjJgoHHysAFhUUBgcGBiMjBgc3MhYVFAYjIwcGBwYHDgIjIiY1NDYzMhYVFBYzMjY2NzY3NjY3NwYjIiY1NDMyNzY3NjY3BgYVFBcWFRQGIyInJiY1NDYzMjY3Az8bISlMgHMCHBZIHhwiMD8DBwwNCRxIaExCSS0dFx4ODBQiJhcNFQMHBQMsChgcUxMSChYECgVYThQGKBkbEw4U1uJ+iT8DWhkbHyAECAWOegEVDRkcEylaZiyWtlc+NiAlGhgNDyt3b0CTFjMeEgISEjIBPGoTLx4JMy8iHwkJEhsQDEEheXEEBgAAAP////H+rQNIA1AAAgOKAAAAAf/x//sDSQNQAE8AmkAKMgEEBgsBDAICTEuwF1BYQDUABgUEBQYEgA0BDAILAgwLgAAFBQdhCAEHBxdNCgMCAgIEXwkBBAQZTQALCwBhAQEAABgAThtAMwAGBQQFBgSADQEMAgsCDAuACQEECgMCAgwEAmkABQUHYQgBBwcXTQALCwBhAQEAABgATllAGAAAAE8ATktJRUM/PCYmIiMjESUmJg4HHyskFhUUBwYGIyImJycDBgYjIiY1NDcBByIHBiY1NDM3JyYmIyIHBiMiJjU0NzY2MzIWFxc3NjYzMhYVFAcDNjMyFhUUBiMjFx4CMzI2NzYzAzoPEzFgO1lbHCLsFCocHCUdAREqHwkaHlNjGRc4JDVHDA8PFR0pYEJHXBsUrxQqHhsfG+MlKR4cIjBKLA8YIx0fQywMD98YFScXOj9qZnz+3BkPFRMZIAE3AQEBExIyAllSQk0NFxIeIzA6WWNG1RgUFBIYH/76ARUNGRycNTgbLDMOAAABADH/+wKjA1AAPwCJQAsdAQIDMg0CBQQCTEuwKlBYQDAAAgMEAwIEgAgBBwUGBQcGgAADAwFhAAEBF00ABQUEYQAEBBlNAAYGAGEAAAAYAE4bQC4AAgMEAwIEgAgBBwUGBQcGgAAEAAUHBAVpAAMDAWEAAQEXTQAGBgBhAAAAGABOWUAQAAAAPwA+JyQUKSUrJQkHHSsAFhUUBgYjIiYmNTQ2NyY1NDY2MzIWFhUUBiMiJjU0Njc2NTQmIyIGFRQXFhYVFAYjIicGBhUUFhYzMjY3NjYzAoMgU5FaYYxHXlFKPnZSTnQ/KioXHAIBBEw9PT5NTUglIU5HJzMrTjNMXQMBKR0BLSIfTG04RHRHVXEWPmE/YzkwUjE0QRETBxEEEhAnNEA7VDYDISAgGSwHSTQsSy1IQh0fAAD//wAI/q0D+ANQAAIDuQAA//8AQP66A3EDUAACAI4AAP//AHn/+wVSA2AAAgC4AAAAAgAc//sCxwNQADUARACPQAozAQgHCQEBCAJMS7AuUFhALAABCAkIAQmABQEDBgECBwMCaQoBBwAIAQcIaQAEBBdNCwEJCQBiAAAAGABOG0AxAAEICQgBCYAABQMCBVkAAwYBAgcDAmkKAQcACAEHCGkABAQXTQsBCQkAYgAAABgATllAGDY2AAA2RDZDPDoANQA0JCUiMzgmJAwHHSsAFRQGBiMiJjc3BgcGIyImNTQ2Nzc2NwYjIiY1NDMyNzc2MzIWFRQHBzcyFhUUBiMjBwYHNjMSNjU0JiMiBgcGBwcUFjMCx1ujaH98BgMGDA4LEhYSGTgNFywKGBxTFRQMDUAbIwMFRR4cIjBDCgsLaEkGb0RKKk4yCAEBNkECJdVjm1eeniwCBgYdGhQZChZGbgISEjIBNDoiGwwMFQEVDRkcJio4Hf5BdWJBPQ0RMikkZFQAAAIALv+TA30DTgAgAFMAU0BQLCUiHwsBBgAEUwEBBwJMPAEBAUsABAgACAQAgAAABwgAB34ABwEIBwF+AAgAAQYIAWkABgACBgJmAAUFA2EAAwMXBU4nKSYmLiYiFiUJBx8rABUUBwYGIyInJiYnBgYHBwYjIiYmNTQSNjMyFhYVFAcXBDcnJjU0NzYzMhcXNjU0JiMiBgYVFBYWMzI3NyYXJiY1NDYzMhcWFzY3NjYzMhYVFAcHA30CBxMQFiELEAcwnWgrGW89Zz6D3YVeg0MUMv78MSwmAwwcFyEMA1dbZ5lTGScSGQ0hJwUeEhkWCgUYDQ0YBisdIR0CIQG+GgQGDhAQBQgDPEoH8YtIlGzLARuNQnFHOTQWTEoTEBoHBxoQBRUXQlOC55Q+YDVFvQYBBRsVFhoBBAFOgyIdGRsQCsIAAAL/jf6tA+oDbQBcAGYBlkuwFVBYQApgAQYICwEBBgJMG0AKYAEKCAsBAQYCTFlLsBBQWEBHAAgHBgcIBoAPAQ0BDAENDIAAAwAEBANyAAsQAQ4HCw5pCgEGBQEBDQYBaQAEAAIEAmYABwcJYQAJCRdNAAwMAGEAAAAYAE4bS7AVUFhASAAIBwYHCAaADwENAQwBDQyAAAMABAADBIAACxABDgcLDmkKAQYFAQENBgFpAAQAAgQCZgAHBwlhAAkJF00ADAwAYQAAABgAThtLsBdQWEBTAAgHCgcICoAAAQYFBgEFgA8BDQUMBQ0MgAADAAQAAwSAAAsQAQ4HCw5pAAYABQ0GBWkABAACBAJmAAcHCWEACQkXTQAKChlNAAwMAGEAAAAYAE4bQFUACAcKBwgKgAAKBgcKBn4AAQYFBgEFgA8BDQUMBQ0MgAADAAQAAwSAAAsQAQ4HCw5pAAYABQ0GBWkABAACBAJmAAcHCWEACQkXTQAMDABhAAAAGABOWVlZQCBdXQAAXWZdZQBcAFtYVk5MSEZCQCIkJCUkJCYXJREHHyskFhUUBwYjIiY1NDcGBwYHBwYHDgIjIiY1NDYzMhYVFBYzMjY2NzY3ByImNTQ2Nzc2NTQmIyIHBiMiJjU0NzY2MzIWFRQHNzY3PgIzMhYVFAcGFRQWMzI2NzYzAgYGBzY2NTQmIwPbDxNjcGF0A0JONBMGGwwfR2VLQkktHRceDgwUISkeFBgwIR4mLDUaHBdGWA0QDhQZLIZFQUcYYj8tEkpuRDI6/QM0LylEKwwPnTEsDVBMEAzfGBUnF3mWjCIiDAYEASGeO5i0Vz42ICUaGA0PL4mHWJACFxohHwICjUovInURGhQfIz1PWV5TjgUDB27AeE9A+GAoK2lYKzQOAjdQilIhemAXGgACAAj+rQP4A1AAQgBLAJ5AEhcBAgQ/AQMFEQEBA0UBCAEETEuwEFBYQDAAAgQHBAIHgAkBBwUEBwV+BgEFAwQFA34KAQgAAAgAZQAEBBdNAAMDAWEAAQEYAU4bQDYAAgQHBAIHgAkBBwYEBwZ+AAYFBAYFfgAFAwQFA34KAQgAAAgAZQAEBBdNAAMDAWEAAQEYAU5ZQBZDQwAAQ0tDSgBCAEEiJiYkJi8pCwcdKyQWFRQGBwYHBgYjIiY1NDY2NyMmJjU0Nw4CIyImJyY1NDYzMhYXFhYzMjY3NhM2NjMyFgcGFRQWMzI3NjMyFzc2MwA2NwYGFRQWMwPpDw0QQ0MWbGNCSS9aVgZFQgkvZIpbQGAXCSEaFRoGDCgeJGQ1PlUNNSkpIAMPIiMNDhQOHARnDQr+vy8SPTsODLAYFBYaCy0kqKM+NjJLQTIGxZJPVajoikA3FxQeKRQWKyd/dooBGyonJSrMfIW5BwghPwj+aEdXIjslDQ///wA4//sDPQNQAAIAzAAAAAEArf/PA2QDWQBEALhAEiwBBAZCAQEHIAEDARgBAAMETEuwG1BYQCsABAYHBgQHgAADAQABAwCAAgEAAIQABgYFXwAFBTNNAAEBB2EIAQcHNgFOG0uwLFBYQCkABAYHBgQHgAADAQABAwCAAgEAAIQIAQcAAQMHAWkABgYFXwAFBTMGThtAKQAGBAaFAAQHBIUAAwEAAQMAgAIBAACECAEHAQEHWQgBBwcBYQABBwFRWVlAEAAAAEQAQyRGKSYmKiYJCR0rABYVFAYHBiMiJjU0Njc2NjU0JiMiBwYGBwYGIyImNTQ3BwYjIiY1NDc3Njc3BwciJjU0Njc2NzY3NhYVFAYHBgcGBzYzAteNq6cUCSEgGBZ7c01USVcLGQQCKCEhIyIDDwsVGyg3FBkKKQ8fHx8fZ5apSB4bIijLSh8RWFEB5XZmg5wWAhcUEhkEGGBRPkEVQtc3IR8gGj3sAQUcFSoPE3hzMgQBHBkaJAMKBwoFAhgbICECCwaaZhMA//8AVAADAyoDXgACAOcAAAABAM3/+wNZA1kAJgBPQAoaAQIADAEBAgJMS7AsUFhAGQACAAEAAgGAAAAAA18EAQMDM00AAQE0AU4bQBAAAAIAhQACAQKFAAEBNAFOWUAMAAAAJgAjKyc0BQkZKwAWFRQGBwYHBgcGBgcGBiMiJjU0Njc2NzY3NwcHIiY1NDY3Njc2NwM+GyIoxnclHgwXBAIsHyEkDwoLBhIkDCgPHx8fH2SprloDWRgbICECCgi4tEmxNB0fIBoYbz09LXutOwQBHBkaJAMKBwkGAP//AM3/+wNZBHwAIgO9AAABBwXAAw4BfAAJsQEBuAF8sDUrAAABAM3/+wN2BC0AMgB5S7AoUFhACwIBAgMfEAIBAAJMG0ALAgEAAx8QAgEAAkxZS7AmUFhAFQADAgOFAAAAAl8AAgIzTQABATQBThtLsChQWEATAAMCA4UAAgAAAQIAagABATQBThtAEAADAAOFAAABAIUAAQE0AU5ZWUAJMS8qJCgoBAkYKwAWFRQHBgcGBgcGBwYHBgYHBgYjIiY1NDY3Njc2Njc3BwY1NDY3Njc2NzY2NzY3NjMyFwNfFwIHEgcuOoSWJR4MFwQCLB8hJA8KCwYPIwMNKE0fH2rjM0MPDAMLDgYkCQsEIhwcBxI9aCcjAgYLs7dJsTQdHyAaGG89PS1org4+AwY6GiUCBwsBBAEKDS5sLQP//wAt//sDMQNcAAIAJgAA//8AK//7AsoDUAACAPMAAP//ACv/+wLKBHwAIgPBAAABBwW/AvwBfAAJsQEBuAF8sDUrAP//ACv/+wLKBDEAIgPBAAABBwW9AvwBfAAJsQECuAF8sDUrAAABAAz/+AS1A1cAjAKUQBERAQMAhWdZPgQIA14BCQcDTEuwCVBYQCwMAQgDBwMIB4APDgYFBAAAAWEEAgIBATNNAAMDNk0NAQcHCWELCgIJCTQJThtLsAxQWEA3DAEIAwcDCAeADwEODgFhBAICAQEzTQYFAgAAAWEEAgIBATNNAAMDNk0NAQcHCWELCgIJCTQJThtLsBJQWEA3DAEIAwcDCAeADwEODgFhBAICAQE5TQYFAgAAAWEEAgIBATlNAAMDNk0NAQcHCWELCgIJCTQJThtLsBdQWEBCDAEIAw0DCA2ADwEODgFhBAICAQE5TQYFAgAAAWEEAgIBATlNAAMDNk0ADQ0JYQsKAgkJNE0ABwcJYQsKAgkJNAlOG0uwGVBYQEkMAQgDDQMIDYAPAQ4OAWEEAgIBATlNBgUCAAABYQQCAgEBOU0AAwMJYQsKAgkJNE0ADQ0JYQsKAgkJNE0ABwcJYQsKAgkJNAlOG0uwIVBYQFAFAQAGAwYAA4AMAQgDDQMIDYAPAQ4OAWEEAgIBATlNAAYGAWEEAgIBATlNAAMDCWELCgIJCTRNAA0NCWELCgIJCTRNAAcHCWELCgIJCTQJThtLsCZQWEBTBQEABgMGAAOAAAgDDAMIDIAADA0DDA1+DwEODgFhAAEBOU0ABgYCYQQBAgI5TQADAwlhCwoCCQk0TQANDQlhCwoCCQk0TQAHBwlhCwoCCQk0CU4bQFkFAQAGAwYAA4AACAMMAwgMgAAMDQMMDX4AAgI5TQ8BDg4BYQQBAQE5TQAGBgFhBAEBATlNAAMDCWELCgIJCTRNAA0NCWELCgIJCTRNAAcHCWELCgIJCTQJTllZWVlZWVlAHAAAAIwAi399eXhxb2JgUlAkLiMXKBUtJCIQCR8rABcWMzI2NTQmIyIGBgcOAgc2NzY2NTQjIgYHBgYHIiYmJyYnLgIjIgYHBgYVFBYzMjc2MzIWFhcXHgIXDgIHBgYjIiYnJiYjIgYVFBYzMjY2Nz4CNwcGDwIUFjMyNzY2NzceAhcWFxYWMzI2NzY2NTQmIyIGBwYjIicnLgInPgI3NjYzBE8WEgsWHUE3NkkrHBsqRTIEAQ4XPCYoAwQWCyAmEwwICxYvRTMbOhIUEBURBgMkFR0kHRAIDRcqIkBXMRwaIhsQEQoHDQsWGkEyOVI3Ix8vQisEDxQHASQiQwUEFwsEHSMWERQNKV5KGzoSFhEXEQcTBBYLRDgSFB80J0VYLBcUIBwC6gwJIRcrHy1DOTdEOAwWClKWHTwhJTCwQR8wLSQfPkslDQoKHRQTGwEIETIyGCs0LAsTTFM8OTAICQcHGxosKzZOQTlHNwgZYJY2CRccRjCxQxgHHywsNB1cVw0KDB4VExkEAQZ5KC83LQsSRk03MSwA//8AOv/7ArQDUAACA08AAAABAF3/+wMDA1QALwBpQAoGAQIBAgEAAgJMS7AJUFhAEwMBAQE5TQACAgBiBQQCAAA0AE4bS7AMUFhAEwMBAQEzTQACAgBiBQQCAAA0AE4bQBMDAQEBOU0AAgIAYgUEAgAANABOWVlADQAAAC8ALiUpKycGCRorBCY1NDc2NwIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzMjYSNzY2MzIWBwYDBgYjAi4YAgYcb8VUVQ4MFgwXBAMoJiEgFxUYFT5DgmkaBCUiIiMDDFgFKh0FFBcHFD2D/v5dTiNeRHtBsjElISAcIpN1hXgrSJEBKNYhJh8mmv3AIBoAAP//AF3/+wMDBGYAIgPGAAABBwXkAxQBfAAJsQEBuAF8sDUrAP//AF3/+wMDBHwAIgPGAAABBwW/AxQBfAAJsQEBuAF8sDUrAAABAF3/IwMeA1QAQAB+QAsYAQQDPhQCAQQCTEuwCVBYQBkAAAEAhgUBAwM5TQcGAgQEAWICAQEBNAFOG0uwDFBYQBkAAAEAhgUBAwMzTQcGAgQEAWICAQEBNAFOG0AZAAABAIYFAQMDOU0HBgIEBAFiAgEBATQBTllZQA8AAABAAD8lKSsnFygICRwrJBYVFAcGBwYGIyImNTQ3NzY3IiY1NDc2NwIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzMjYSNzY2MzIWBwYDNjMDAxsUWDQeHxgYIQsRKRohGAIGHG/FVFUODBYMFwQDKCYhIBcVGBU+Q4JpGgQlIiIjAwxNKBuCFRIVGW5QLh4gFRIOGT0tFBcHFD2D/v5dTiNeRHtBsjElISAcIpN1hXgrSJEBKNYhJh8ml/4EBgD//wBG//sDDANQAAIBIgAA//8ARv/7AwwEfAAiA8oAAAEHBcADGwF8AAmxAQG4AXywNSsAAAH/4f/4Aq4DUAAhAClAJhkBAQABTAAAADlNBQQCAQECYgMBAgI0Ak4AAAAhACAnIiYnBgkaKz4CNzY3NjYzMhYHBhUUFjMyFRQHIiY1NDcOAiMiNTQzPDtCKU5KDTUpKSADDis1MUtqYgkvZIpbRzpuKmdcrvYqJyUqu4iasjs7AcirT1Wo6Io6PAAAAf////MDtANQAEUATkuwHVBYtzInDAMAAgFMG7cyJwwDBAIBTFlLsB1QWEAOAwECAjlNBAECAAA0AE4bQBIDAQICOU0ABAQ0TQEBAAA0AE5Zty4sLiokBQkbKwECAwYGIyInJiY1NDcjDgIjIiY1NDY3NjY3NjY3NzY2MzIHBhUUFzM2Ejc+AjMyFhUHBgYVFBYXFhYVFAYjIiYmNTQ3AthkXAoeHDAOGRwEAiVEY0goKBgVIi4cEyAcNAsvMFIGBRgCGm4+ERcdGywoAQoMHiUWEiQoMEsqFwJg/u3+3R8YMFDfckIxwvKOKBkUHAUHO0sygHvaLSRXVUWi2m8BKoQjIA0hIgxm2FJ+dQsHGRciH0qKXpqZ//8AM//7A0sDUAACAQ4AAP//AED/+wMeA1AAAgBtAAAAAQBf//sDdwNUADoASkuwJlBYQBQEAgIAAAVfBgEFBTNNAwEBATQBThtAGgAEAAEABHICAQAABV8GAQUFM00DAQEBNAFOWUAOAAAAOgAzKCkoKSQHCRsrABYVFAYjIwYPAgYGBwYGIyI1NDY/AjY3IwcGDwIGBgcGBiMiNTQ2PwI2NwciNTQ2MzI3NjM2MwNaHSQxGgUVDBYLFwQDJiJFExMEFxMOr3YFFQwWCxcEAyYiRRMTBBcSDi41Ji6eimY1hz0DVBwXIiQueUyDQ7EwJSE8IINvGoNtiAEwfEaDQ7EwJSE8IINvGoNgkAEvJCUCAgMA//8AL//7ApwDTgACATYAAP//AEH/+wK/A1AAAgDoAAD//wBD//sC6ANPAAIBPwAA//8AXP/5AuoDVAACAWAAAP//AFz/+QLqBGYAIgPUAAABBwXkAvkBfAAJsQEBuAF8sDUrAAADAD3/yQPDA2QAKgA6AEoA40ARHQEGA0cwJxEEBwYIAQAHA0xLsAlQWEAiAAEAAYYKBQIDCAEGBwMGaQwJCwMHAgEAAQcAagAEBDkEThtLsAxQWEAiAAEAAYYKBQIDCAEGBwMGaQwJCwMHAgEAAQcAagAEBDMEThtLsBlQWEAiAAEAAYYKBQIDCAEGBwMGaQwJCwMHAgEAAQcAagAEBDkEThtALAAEAwSFAAEAAYYKBQIDCAEGBwMGaQwJCwMHAAAHWQwJCwMHBwBiAgEABwBSWVlZQB47OysrAAA7SjtJQkArOis5NDIAKgApJSUmJCUNCRsrABYVFAYGIyInBwYGIyI1NDY3BgYjIiY1NDY2MzIXNjc2NjMyFhUUBzY2MwA2Nzc2NyYmIyIGBhUUFjMENjY1NCYjIgYHBwYHFhYzA3BTSIdaSToMAyIZQAwKK2Q1T1NIh1pJOggDAyQiGhsXKWY1/gNoMxEFBxg9HzFHJRkZAdBHJRoaKGg1DQUHGD0gAuBrZH3EbjOGJCI8GXlFOEJsY33EbjRMJiUhIBwtmDhF/e1pUV8dLyAkW5pdMyQBW5pdNCNtVE8fNSEkAAD////V//sC5wNPAAIBXwAA//8AcP/7AugDVAACA2IAAAACAF3+rQMdA1QAQgBLALFAChEBBgNFAQgCAkxLsAlQWEAoCQcCBgMEAwYEgAoBCAAACABlAAEBA2EFAQMDOU0ABAQCYgACAjQCThtLsAxQWEAoCQcCBgMEAwYEgAoBCAAACABlAAEBA2EFAQMDM00ABAQCYgACAjQCThtAKAkHAgYDBAMGBIAKAQgAAAgAZQABAQNhBQEDAzlNAAQEAmIAAgI0Ak5ZWUAWQ0MAAENLQ0oAQgBCHCUpKyQXJAsJHSskBw4CIyImNTQ2Njc3IjU0NwIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzMjYSNzY2MzIWFRQGBwYHBwYVFBY3NjMCNjcGBhUUFjMDHQULN2FLQkk3Y20BfxJvxVRVDgwWDBcEAygmISAXFRgVPkODaRkEICYgIQwOHgwEBRolAwimLhE8Og4Mnj2Xv14+NjdOQz4MYSFM/v5dTiNeRHtBsjElISAcIpN1hXgrSJQBKNMgJycsG1tSvWAlIA8aEgEB/npLUyI7JQ0PAAABAF3/+wRyA1QAUwA0QDE3LwIBACoBAwECTAYCAgAAOU0IBwIBAQNiBQQCAwM0A04AAABTAFIrJyksJSolCQkdKyQ2Ejc2NjMyFhUUBgcGBhUUFjMyNhI3NjYzMhYVFAYHBgcGBwcGBiMiJjU0NzY2NwYGIyImNTQ3DgIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzAWJwYx0HGyciHxQXGhwfITNyZx0HGycjIg4QGwwGEQwFKh0iGAIEFgsqlF1ERg0nSV1AVFUODBYMFwQDKCYhIBcVGBU+fn4BG94zKCgtImdndJU4JyR/ARvcMygqLx5kX6VVMGtMIBoUFwcUIpE0jJ1NSC81Vmo5XU4jXkR7QbIxJSEgHCKTdYV4K0gAAAAAAgBd/q0EkQNUAF8AaAC/QAsZEQIJBGIBCwICTEuwCVBYQCsMCgIJBAUECQWADQELAAALAGUAAQEEYQgGAgQEOU0HAQUFAmIDAQICNAJOG0uwDFBYQCsMCgIJBAUECQWADQELAAALAGUAAQEEYQgGAgQEM00HAQUFAmIDAQICNAJOG0ArDAoCCQQFBAkFgA0BCwAACwBlAAEBBGEIBgIEBDlNBwEFBQJiAwECAjQCTllZQBpgYAAAYGhgZwBfAF9dXCUqJSkrJyUXJA4JHyskBw4CIyImNTQ2Njc3IjU0NwYGIyImNTQ3DgIjIiY1NDY3NzY2NzY2MzIWFRQGBwcGFRQzMjYSNzY2MzIWFRQGBwYGFRQWMzI2Ejc2NjMyFhUUBgcGBwcGFRQWNzYzAjY3BgYVFBYzBJEFCzdhS0JJN2RsAX8PKpRdREYNJ0ldQFRVDgwWDBcEAygmISAXFRgVPjdwYx0HGyciHxQXGhwfITNyZx0HGycjIg4QGwwFBBolBAimLhE7Ow4Mnj2Xv14+NjZPRD4LYS1njJ1NSC81Vmo5XU4jXkR7QbIxJSEgHCKTdYV4K0h+ARveMygoLSJnZ3SVOCckfwEb3DMoKi8eZF+lVSomBxoQAgH+ekpTITslDQ8AAAEAXf89AwMDVAA/AH1ADg4BBAMKAQAEGwEBAANMS7AJUFhAGAABAAGGBgUCAwM5TQAEBABiAgEAADQAThtLsAxQWEAYAAEAAYYGBQIDAzNNAAQEAGICAQAANABOG0AYAAEAAYYGBQIDAzlNAAQEAGICAQAANABOWVlADgAAAD8APikrJi8mBwkbKwAWBwYDBgYjIiY1NDc2NwYHBgYHBgcGBiMiJjU0NzY3IyImNTQ2Nzc2Njc2NjMyFhUUBgcHBhUUMzI2Ejc2NjMC4CMDDFgFKh0iGAIGHD9fAwcDCQYFKh0iGAIGDgpUVQ4MFgwXBAMoJiEgFxUYFT5DgmkaBCUiA1QfJpr9wCAaFBcHFD2DlEEZKxIxLiAaFBcHFDNJXU4jXkR7QbIxJSEgHCKTdYV4K0iRASjWISYAAP//ABz/+wLHA1AAAgNnAAD//wBu//sDVQMwAAIDaAAA//8AHP/7BBYDUAACA2kAAAAC/+H/+APZA1AAJQAwAHZADyAMAgQDIgEFBC0BAgUDTEuwHVBYQBwHAQQABQIEBWkAAwM5TQgGAgICAGEBAQAANABOG0AmBwEEAAUCBAVpAAMDOU0AAgIAYQEBAAA0TQgBBgYAYQEBAAA0AE5ZQBUmJgAAJjAmLywqACUAJCciKCUJCRorABYVFAYGIyImNTQ2Nw4CIyI1NDMyNjY3Njc2NjMyFgcGBzY2MxI2NTQmIyIHFRYzA196U5FaeYoCBi9kiltHOiE7QilOSg01KSUjAwsDMXIpA1tCQkldBIMCBWtjX5BNmItKT1uo6Io6PCpnXK72KicmKaCPGBv+YWRaOD8oJucAAAACADP/+wRDA1IAQwBRAHxAC0EzAgMGCwECBwJMS7AdUFhAJgkBBgAHAgYHaQUBBAQ5TQACAgNhAAMDNk0KAQgIAGIBAQAANABOG0AkCQEGAAcCBgdpAAMAAggDAmkFAQQEOU0KAQgIAGIBAQAANABOWUAXREQAAERRRFBKSABDAEIqJiQmLyQLCRwrABUUBgYjIiY1NDc3BwYGBwcGBgcGBiMiNTQ2PwIHIiY1NDY3NzU2Njc2NjMyFRQGBwYHNzY3NjMyFhUUBwcGFQc2MxI2NTQmIyIHBgcHFBYzBENbo2h3fwELdBQ1IAQLFwQDJiJFExMEAiAdGCkoGQsXBAMoJj8TDAUF2g4sDUAbIwMmCA5rRgduREcwfwUCATZBAhvVY5ZSiokbDl8NAgcDGEOxMCUhPCCDbxoLAhkaICQBAQFAsTMlITwbhEkVJRVLxjoiGwwMkxwBOgj+S21gQT0MMTIkZFQAAP//ACL/+AK1A1EAAgCVAAAAAQBB//sCvwNQADgAfEuwLFBYQDAAAgMEAwIEgAgBBwUGBQcGgAADAwFhAAEBOU0ABQUEXwAEBDZNAAYGAGEAAAA0AE4bQC4AAgMEAwIEgAgBBwUGBQcGgAAEAAUHBAVnAAMDAWEAAQE5TQAGBgBhAAAANABOWUAQAAAAOAA3I0QzKCQmJwkJHSskFhUUBgcGBiMiJiY1NDY2MzIWFRQGIyImNTQ3NjY1NCMiBgYHMjcyFhUUBiMmIyMVFBYzMjY3NjMCrxANDjuSTGCVVXG/cWxwLCccIAUBBGE3Zk0QUJ4VGBYUhkUwaWI8bDgSEOsaFBIkDj8/UKBzkeR9b1s9SxsZEBcGGwlbPHRRAiMXFR8CBIN3MTQR//8ALP/7AuADUAACA24AAP//AE7/+wFFA1AAAgERAAD//wBO//sBzAQxACIBEQAAAQcFvQI4AXwACbEBArgBfLA1KwD//wBK//gC1ANPAAIBIAAAAAEAQ//7Az0DTwBDADZAMxgFAgABAUwFAQMDBF8ABAQzTQABAQZhBwEGBjZNAgEAADQATgAAAEMAQkY3GycoJwgJHCsAFhUUBwcGBiMiJjc2Njc2NTQjIgYGDwIGBiMiJjU0Njc2NzY2NzcGBwY1NDY3NjMzMhcWFhUUBiMiJycGBwYVNjYzAuBdCQYCJiYiIgEBBgEHUSdjUQ0DBwIsHyEkDwoLBgscDhBYXk0fH2yYgmAiMC8jKSpcQisZAjJ1VgHcXk04Y1QkIyIiH0ULRClCKVdAGkwdHyAaGG89PS1Mk0NQAwcGOhojBA8DBCIiHBUCAdiZCAZDQgAAAAIAM//7BHwDUAA3AEUAprUoAQgFAUxLsB1QWEAlAAgIBWEKBwIFBTlNAwEBAQRhBgEEBDZNCwEJCQBhAgEAADQAThtLsC5QWEAjBgEEAwEBCQQBagAICAVhCgcCBQU5TQsBCQkAYQIBAAA0AE4bQCgAAQMEAVgGAQQAAwkEA2oACAgFYQoHAgUFOU0LAQkJAGECAQAANABOWVlAGDg4AAA4RThEPz0ANwA2JSYjJiYlJgwJHSsAFhYVFAYGIyImJjU0NyIHBwYGBwYGIyI1NDY/AgciNTQ2MzM1NjY3NjYzMhUUBgcHFTc+AjMCNjY1NCYjIgYGFRQWMwOZj1Rvv3RZj1QBXywCCxcEAyYiRRMTBAIgNSYuFgwXAwMoJj8REQmGGXSlYA53QGRPTXZCZE8DUFCbbJjoflCbbBULAQxDsTAlITwgg28aCgEvJCUCQ7IvJSE8HXRkNwIDbqJX/SFgq2x3e1+rbXd7AAACAE3/9gMaA0gANwBGAIJAEDQCAgcFPQEIBygVAgQIA0xLsA5QWEAiCgEIAAQCCARpAAcHBWEJBgIFBTNNAwECAgBhAQEAADQAThtAKQACBAMEAgOACgEIAAQCCARpAAcHBWEJBgIFBTNNAAMDAGEBAQAANABOWUAXODgAADhGOEVBPwA3ADYmIyImKS0LCRwrABYVFAcHBgcGFRQXFgYjIiYmNTQ2NwcGBiMiJyYmNTQ2MzIXFjMyNjcGIyImJjU0NjYzMhc2NjMCNzY3NjcmJiMiBhUUFhcC9SUBBioMBgQBKx4cGwgJCQJexW83JBYUHxUKCB4aQZdDGBZOdD5GflNoZwggFMkUCxQwFzVPKkxOS1UDRR8YBgMj55xORz5cHxsWKygyfTgBqaQMBxsVGikEDnFgAztsSVOCSSAOD/5cAxUqbHQNC1hSTEMBAAACAEP+OQM7A08AQgBLAElARhoBAgFFAQcCAkwFAQMDBF8ABAQzTQABAQZhCAEGBjZNAAICNE0JAQcHAGEAAAA4AE5DQwAAQ0tDSgBCAEFGNxgnKyYKCRwrABYVFAcGAiMiJjU0NjY3NzY1NCYjIgYGDwIGBiMiJjU0Njc3NjcGBwY1NDY3NjMzMhcWFhUUBiMiJycGBwYVNjYzAjY3BgYVFBYzAuFaICiScDdBLHhwBRotJSdjUQ0DBwIuIR0hExMEGSlbWk0fH2yYgmAiMC8jKSlcRCsZAjJ2VnE6HEg/DAwB3GRaMrnl/us/MzlpflAhqjUeJClXQBpMHR8hGyCDbxqb1wMHBjoaIwQPAwQiIhwVAgHYmQgGQ0L8zGd5PF4fERb//wAc//sCxwNQAAIDdgAAAAIADP/4BKMDSwBmAHkBoUuwDlBYQA1NMiQGBAALLQECAAJMG0uwElBYQA1NMiQGBAULLQECAAJMG0uwF1BYQA1NMiQGBAULLQECBgJMG0uwIVBYQA1NMiQGBAELLQECBgJMG0ANTTIkBgQFCy0BAgYCTFlZWVlLsA5QWEAiCgwJAwcHCF8ACAgzTQALCzZNBgUBAwAAAmEEAwICAjQCThtLsBJQWEApAAULAAsFAIAKDAkDBwcIXwAICDNNAAsLNk0GAQIAAAJhBAMCAgI0Ak4bS7AXUFhANAAFCwALBQCACgwJAwcHCF8ACAgzTQALCzZNAQEAAAJhBAMCAgI0TQAGBgJhBAMCAgI0Ak4bS7AhUFhAOwUBAQsACwEAgAoMCQMHBwhfAAgIM00ACwsCYQQDAgICNE0AAAACYQQDAgICNE0ABgYCYQQDAgICNAJOG0BBAAULAQsFAYAAAQALAQB+CgwJAwcHCF8ACAgzTQALCwJhBAMCAgI0TQAAAAJhBAMCAgI0TQAGBgJhBAMCAgI0Ak5ZWVlZQBYAAHh0bWwAZgBkU00kJC4tJyMsDQkfKwAGBw4CBx4CFxcWMzI3NjYzMhYVFAYHBgYjIiYnJicuAicHBgYHBiMiJjU3NzY3Nw4CBw4CIyImNTQ2MzIWFxYWMzI2Nz4CNy4CJycmJicGIyImNTQ3NiEFMhYVFAYjIwQ2Njc2NwUWFxYXHgIXFjMyNwQeHRQWLVhGJzQfFBI4RAsWBBMHERcRFhI6G0peKQ0UERYjHQQLFwQFQyIkAQcUDwQrQi8fIzdSOTJBGhYLDQcKERAbIhocMVdAIysWDgYSJiASJiQbYi4BMgIpGiQoJR7+tUUrGhMG/hkICgYLDBMnISgSKiQC1yctM0lEEgstNy8oeQYBBBkTFR4MCg1XXB00LCwfBxhDsTBGHBcJNpZgGQg3RzlBTjYrLBobBwcJCDA5PFNMEwssNS0VPC0CARcVRAUCARkSICfdN0MzJgoBExwRKy0yIgICCAAAAAMAQP/7Ax4DUAAPACQAOACMQAwhEgIDAjQnAgUGAkxLsBtQWEAqAAIABgUCBmkJAQQEAWEIAQEBOU0ABQUDYQADAzZNCgEHBwBhAAAANABOG0AoAAIABgUCBmkAAwAFBwMFaQkBBAQBYQgBAQE5TQoBBwcAYQAAADQATllAHiUlEBAAACU4JTcxLyspECQQIx0bFxUADwAOJgsJFysAFhYVFAYGIyImJjU0NjYzBgYHPgIzMhYXFhYzMjY2NzU0JiMSNjcGBiMiJicmJiMiBgYHFRQWMwI7j1Rvv3RZj1Rvv3RkgxoGJigVGSsdITAeHS0iBWRPCoIZHjIfHi4gHikZGiojCGRPA1BQm2yY6H5Qm2yY6H52g3ACDQcPDhAPCQoBE3d7/ZeEcAkJDxAPDgkMAhV3ewAAAAEAe//7A94DUAAuACpAJxgBAAIBTAAAAgMCAAOABAECAjlNAAMDAWIAAQE0AU5VKCYmJAUJGysAFhUUBiMiJyYnBgIGIyImNTQ3NjYzMhYVFAcGFRQWMzI2Ejc2Njc7AhYXFhYXA8oUIRYNCSdFOJmsV2ltGAgmJR8jAhs3LSxtaCQIKSQCBgxDFyMmGAMtGhgYGwQRCP3+sZ781I2fMSgbIwYUuIaTpJMBIcgsIwICAgMJCgAAAAABAJX/+wNZA1kAOADWS7AuUFhACiwBBgAVAQMCAkwbQAosAQYAFQEDBAJMWUuwLFBYQCUABgABAAYBgAAAAAdfCAEHBzNNBAECAgFhBQEBATZNAAMDNANOG0uwLlBYQBwAAAYAhQAGAQaFBAECAgFhBQEBATZNAAMDNANOG0uwMFBYQCQAAAYAhQAGAQaFAAICAWEAAQE2TQAEBAVhAAUFNk0AAwM0A04bQCIAAAYAhQAGAQaFAAUABAMFBGkAAgIBYQABATZNAAMDNANOWVlZQBAAAAA4ADUkMygmJCI0CQkdKwAWFRQGBwYHBgc3MhYVFAYjIwcGBgcGBiMiJjU0Njc2NzcHBiY1NDMyNzY3NwcHIiY1NDY3Njc2NwM+GyIoxnccFUQeHCIwOwMMFwQCLB8hJA8KCwYDNhoeUxUUERULKA8fHx8fZKmuWgNZGBsgIQIKCIZ9ARUNGRwTSbE0HR8gGhhvPT0tEgIBExIyAV1qNQQBHBkaJAMKBwkGAAACAM3+OQNZA1kAQwBMAIFADy8BBAYhAgIDAkYBBwMDTEuwLFBYQC0ABAYABgQAgAAGBgVfAAUFM00AAgIAYQAAADZNAAMDNE0IAQcHAWEAAQE4AU4bQCUABgQGhQAEAASFAAICAGEAAAA2TQADAzRNCAEHBwFhAAEBOAFOWUAQRERETERLNEYrJywmJAkJHSsABwc2NjMyFhUUBwYCIyImNTQ2Njc2NzY1NCYjIgYGBwYHBgYjIiY1NDY3Njc2NzcHByImNTQ2NzY3Njc2FhUUBgcGBxI2NwYGFRQWMwGtHgMzd1ZWWiAnk3A3QSx4cAEEGi0lKmhRCAIGAiwfISQPCgsGEiQMKA8fHx8fZKmuWh4bIijGd0k6HEg/DAwCGbQQRENkWjK55P7qPzM5aH5QCRmqNR4kLmBHEUAdHyAaGG89PS17rTsEARwZGiQDCgcJBgIYGyAhAgoI+9dneDpeIBEWAAIADP6tBLUDVwCQAJgCO0uwHVBYQBeIAQwAW0AyEAQCDDspHwMFCJIBDwUETBtAF4gBDABbQDIQBAMMOykfAwUIkgEPBQRMWUuwCVBYQDMHAwICDAgMAgiAEQEPAAQPBGUKCQEDAAALYRAODQMLCzlNAAwMNk0ACAgFYQYBBQU0BU4bS7AXUFhAPwcDAgIMCAwCCIARAQ8ABA8EZQABAQthEA4NAwsLOU0KCQIAAAthEA4NAwsLOU0ADAw2TQAICAVhBgEFBTQFThtLsBlQWEBFBwMCAgwIDAIIgBEBDwAEDwRlAAEBC2EQDg0DCws5TQoJAgAAC2EQDg0DCws5TQAMDAVhBgEFBTRNAAgIBWEGAQUFNAVOG0uwHVBYQEwKAQAJDAkADIAHAwICDAgMAgiAEQEPAAQPBGUAAQELYRAODQMLCzlNAAkJC2EQDg0DCws5TQAMDAVhBgEFBTRNAAgIBWEGAQUFNAVOG0uwJlBYQFIKAQAJDAkADIAAAwwCDAMCgAcBAggMAgh+EQEPAAQPBGUAAQELYRAODQMLCzlNAAkJC2EQDg0DCws5TQAMDAVhBgEFBTRNAAgIBWEGAQUFNAVOG0BVCgEACQwJAAyAAAMMAgwDAoAHAQIIDAIIfhEBDwAEDwRlAA0NOU0AAQELYRAOAgsLOU0ACQkLYRAOAgsLOU0ADAwFYQYBBQU0TQAICAVhBgEFBTQFTllZWVlZQCaRkQAAkZiRlwCQAI+CgHt6cnBpaGVjVVNPTUlHOTckIx0iJBIJGysAFhUUBiMiJyYjIgYHDgIHHgIXFxYWMzI3NjMyFgcGBiMiJjU0NjY3JiYnJicuAicHBgYHBiMiJjU3NzY3Nw4CBw4CIyImNTQ2MzIWFxYWMzI2Nz4CNy4CJycuAiMiBwYjIiY1NDY3NjYzMhYWFxYXHgIzNjY3NjYzMhUUBgcGBz4CNz4CMwI3BgYVFBYzBHRBHRYLEhYTHCAUFyxYRSc0HxQSGzIkAhINERMPAhBvb0JJL1lVKlkgDRQRFiMdBAsXBAVDIiQBBxQPBCtCLx8jN1I5MkEaFgsNBwoREBsiGhwxV0AiKhcNCBAdJB0VJAMGERUQFBI6GzNFLxYLCAwTJiALFgQDKCY8Fw4BBDJFKhscK0k2ciI9Ow4MA1cfKxchCQwsMTdNRhILLTcvKDsuAwUeH9TMPjYySkExC05GHTQsLB8HGEOxMEYcFwk2lmAZCDdHOUFONissGhsHBwkIMDk8U0wTCyw0KxgyMhEIARsTFB0KCg0lSz4fJC0wH0GwMCUhPB2WUgoWDDhENzlDLfvBniI7JQ0PAAIAOv6tArQDUABHAE8AnUAPMQEHBkQgAgQFSgEJAQNMS7AsUFhANwAHBgUGBwWAAAIEAwQCA4AKAQkAAAkAZQAGBghhAAgIOU0ABAQFYQAFBTZNAAMDAWEAAQE0AU4bQDUABwYFBgcFgAACBAMEAgOAAAUABAIFBGkKAQkAAAkAZQAGBghhAAgIOU0AAwMBYQABATQBTllAEkhISE9ITiUoJBQnJSQVJQsJHyskBgcOAiMiJjU0NjcmJjU0NjMyFhUUFhYzMjY2NTQmJwYjIiY1NDY3NjU0JiMiBgYVFBYVFAYjIiY1NDY2MzIWFRQGBxYWFQA2NwYVFBYzArRWTBA0XElCSU5ZfY4lJhwhGz03PF81KCBNTyEcTVNmMjIvSCgEHxomIkmIWXNqNTNES/6iMRF7DgzVhCiCpFY+NkBhOQJsYjIwHx00Oxs2WDIqOQUsFhkkJgRAaCwxHTEcCBoHGRk3LjddN1xQPGsnE11D/fVXYlFMDQ8AAAAAAgBG/q0C/gNQAE0AVQDBQA8CAQMGGhACBABPAQoEA0xLsB1QWEAnAQEAAwQDAASACAEGBQEDAAYDagsBCgACCgJlCQEHBzlNAAQENAROG0uwJlBYQC0AAQMAAwEAgAAABAMABH4IAQYFAQMBBgNqCwEKAAIKAmUJAQcHOU0ABAQ0BE4bQDEAAQMAAwEAgAAABAMABH4IAQYFAQMBBgNqCwEKAAIKAmUABwc5TQAJCTNNAAQENAROWVlAFE5OTlVOVElHFiYkJCUrJCMYDAkfKwAGBxYWFx4CMzI3NjMyFgcGBiMiJjU0NjY3JicuAicjBgYHBgYjIjU0NjcjIiY1NDYzMzc2Njc2NjMyFRQGDwI2Njc2NjMyFhUUBwI3BgYVFBYzAsm6bjg8HBMYEAoCEg0REw8CEG9vQkkvWVVAPyEpKiIPCxQEAyYiRRMUBRcaGxQZCAsXBAMoJj8REQkIgqA0CSgkGiAD1yI9Ow4MAl7DHw1DRC0sDQMFHh/UzD42MkpCMRaIR0IYAUCgLyUhPB+BeBoXGh8tQLEzJSE8HXRkNy8CtKEdHRsWCgz8FZ4iOyUNDwAAAAABAEb/+wMMA1AAYADVS7AmUFhAEklHRQMGB1cBAwYXFg8DAAMDTBtAEklHRQMGCVcBAwYXFg8DAAMDTFlLsBlQWEAlAAIAAQACAYAIAQYFAQMABgNqCQEHBzlNCgEAAAFhBAEBATQBThtLsCZQWEArAAADAgMAAoAAAgoDAgp+CAEGBQEDAAYDagkBBwc5TQAKCgFhBAEBATQBThtALwAAAwIDAAKAAAIKAwIKfggBBgUBAwAGA2oABwc5TQAJCTNNAAoKAWEEAQEBNAFOWVlAEF9dUE4WJiQkJSQnJyALCR8rJDMyFhUUBgcGBiMiJicmJwcGBiMiNTc3JiMjBgYHBgYjIjU0NjcjIiY1NDYzMzc2Njc2NjMyFRQGDwIyNzY3NjYXFhYVFAcGBzY2NzY2MzIWFRQHBgYHHgIXFhYzMjcC4AQSFhQTEjobSl4pHQkIAhMRLgEQEhMPCxQEAyYiRRMUBRcaGxQZCAsXBAMoJj8REQkIFxsNAgMYDRUZAgEFRF8kCSgkGiADMrpuJjEiFh83Hw8kfBsTESALCg1XXD0SURgcRRN7BUCgLyUhPB+BeBoXGh8tQLEzJSE8HXRkNy8FWBoeGgIDGiEHEhMdKJtuHR0bFgoMpcIgCSQ1L0I3CAAAAQBG//sDDANQAFoA+7VRAQIFAUxLsBlQWEAnCQEHCgEGBQcGagsBBQQBAgAFAmkMAQgIOU0NAQAAAWEDAQEBNAFOG0uwJlBYQC4AAAINAgANgAkBBwoBBgUHBmoLAQUEAQIABQJpDAEICDlNAA0NAWEDAQEBNAFOG0uwLlBYQDIAAAINAgANgAkBBwoBBgUHBmoLAQUEAQIABQJpAAgIOU0ADAwzTQANDQFhAwEBATQBThtANwAAAg0CAA2AAAkHBglXAAcKAQYFBwZpCwEFBAECAAUCaQAICDlNAAwMM00ADQ0BYQMBAQE0AU5ZWVlAFllXSkhEQ0A9OTckEyMkJCUlJyAOCR8rJDMyFhUUBgcGBiMiJicuAicjBgYHBgYjIjU0NjcjIiY1NDYzMzc2NwciJjU0MzM3NjYzMhUUBzcyFhUUBiMiDwM2Njc2NjMyFhUUBwYGBx4CFxYWMzI3AuAEEhYUExI6G0peKSApKiMPCxQEAyYiRRMUBRcaGxQZCAYMGxgcUwcJAygmPwpTHhwiMDAYDAgIgqA0CSgkGiADMrpuJjEiFh83Hw8kfBsTESALCg1XXEdCGAFAoC8lITwfgXgaFxofLSJSARISMlslITwbRgIVDRkcAUUwLwK0oR0dGxYKDKXCIAkkNS9CNwgAAAABAHP/+wPFA1gAWAGBQAooAQYHTwECBQJMS7AJUFhAIwkBBQQBAgAFAmoABgYHYQoIAgcHM00LAQAAAWEDAQEBNAFOG0uwDFBYQCcJAQUEAQIABQJqAAgIOU0ABgYHYQoBBwczTQsBAAABYQMBAQE0AU4bS7AOUFhAJwkBBQQBAgAFAmoACAgzTQAGBgdhCgEHBzNNCwEAAAFhAwEBATQBThtLsBlQWEAnCQEFBAECAAUCagAICDlNAAYGB2EKAQcHM00LAQAAAWEDAQEBNAFOG0uwIVBYQC4AAAILAgALgAkBBQQBAgAFAmoACAg5TQAGBgdhCgEHBzNNAAsLAWEDAQEBNAFOG0uwKlBYQDIAAAILAgALgAkBBQQBAgAFAmoACAg5TQAKCjNNAAYGB2EABwczTQALCwFhAwEBATQBThtAMAAAAgsCAAuAAAcABgUHBmkJAQUEAQIABQJqAAgIOU0ACgozTQALCwFhAwEBATQBTllZWVlZWUASV1VIRkJBIigkJCQlJScgDAkfKyQzMhYVFAYHBgYjIiYnLgInIwYGBwYGIyI1NDY3IyImNTQ2MzM3NjcGIyInJiY1NDYXFjMyNzYzMhUUBgcGDwI2Njc2NjMyFhUUBwYGBx4CFxYWMzI3A5kEEhYUExI6G0peKSApKiMPCxQEAyYiRRMUBRcaGxQZCBEQOiswMx8WHRgyKleFDgU1ERUFFwwIgqA0CSgkGiADMrpuJjEiFh83Hw8kfBsTESALCg1XXEdCGAFAoC8lITwfgXgaFxofLWWLBQYEHR4WHwMFEwI8FxgELohLLwK0oR0dGxYKDKXCIAkkNS9CNwgAAAIAM/6tA0sDUABZAGEBKkuwIVBYQAo5AQcIWwENBQJMG0AKOQELCFsBDQUCTFlLsB1QWEAyAQEABAMEAAOAAAMFBAMFfg4BDQACDQJlCgEICDlNDAYCBAQHYQsJAgcHNk0ABQU0BU4bS7AhUFhAMAEBAAQDBAADgAADBQQDBX4LCQIHDAYCBAAHBGoOAQ0AAg0CZQoBCAg5TQAFBTQFThtLsC5QWEA1AQEABAMEAAOAAAMFBAMFfgALBwQLWQkBBwwGAgQABwRqDgENAAINAmUKAQgIOU0ABQU0BU4bQDoBAQAGAwYAA4AAAwUGAwV+AAsHBAtZDAEEBgcEWgkBBwAGAAcGag4BDQACDQJlCgEICDlNAAUFNAVOWVlZQBpaWlphWmBZV1NRTEpFQiYjJiYnJiQSFQ8JHysBBwYVFBY3NjMyBw4CIyImNTQ2Njc1IiY1NDY/AiMHBwYGBwYGIyI1NDY/AgciNTQ2MzM1NjY3NjYzMhUUBg8CNzc2Njc2NjMyFRQGBwczMhYVFAYjIwI3BgYVFBYzAtsEEhskAwgiBQs3YUtCSTdkbUJJCgkKA7OJAgsXBAMmIkUTEwQCIDUmLhYMFwMDKCY/EREJAYi3CxcEAygmPxQNCh0gHSQxGVUhPDsODAFlGmoeHxMCAT2Su10+NjdORD4BMi8VSjdDDwILQ7EwJSE8IINvGgoBLyQlAkOyLyUhPB10ZDcDAQNArzIlITwciEs6HBciJP2mniI7JQ0PAAABADP/+wQ6A1AAUQEaS7ASUFi1PAEACQFMG7U8AQEJAUxZS7ASUFhAIQEBAAAJYQsBCQk5TQcFAgMDAmEKCAICAjZNBgEEBDQEThtLsBVQWEAoAAABAgEAAoAAAQEJYQsBCQk5TQcFAgMDAmEKCAICAjZNBgEEBDQEThtLsCFQWEAmAAABAgEAAoAKCAICBwUCAwQCA2oAAQEJYQsBCQk5TQYBBAQ0BE4bS7AmUFhAKwAAAQIBAAKAAAIIAwJZCgEIBwUCAwQIA2oAAQEJYQsBCQk5TQYBBAQ0BE4bQDAAAAECAQACgAACCAMCWQUBAwcIA1oKAQgABwQIB2oAAQEJYQsBCQk5TQYBBAQ0BE5ZWVlZQBJQTUhFQD4jJiYmJiQjEiMMCR8rABYVFCMiJyYnBgcHMzIWFRQGIyMHBgYHBgYjIjU0Nj8CIwcHBgYHBgYjIjU0Nj8CByI1NDYzMzU2Njc2NjMyFRQGDwI3NzY2NzY2MzIWFwQbHz0KBnBmBRcKHSAdJDEZAgsXBAMmIkUTEwQDtYkCCxcEAyYiRRMTBAIgNSYuFgwXAwMoJj8REQkBiLcLFwQDKCZ+bTQDOR4UPQELAjOAOhwXIiQNQ7EwJSE8IINvGg8CC0OxMCUhPCCDbxoKAS8kJQJDsi8lITwddGQ3AwEDQK8yJSEHCgAAAAIAX/6tA3cDVABHAFAAhLVKAQgFAUxLsCZQWEAqAAEAAwABA4AAAwUAAwV+CgEIAAIIAmUGBAIAAAdfCQEHBzNNAAUFNAVOG0AvAAYAAQAGcgABAwABA34AAwUAAwV+CgEIAAIIAmUEAQAAB18JAQcHM00ABQU0BU5ZQBZISAAASFBITwBHAEAoKSgXJDckCwkdKwAWFRQGIyMGBwMGFRQWMzMyBw4CIyImNTQ2Njc3IjU0PwI2NjcjBwYPAgYGBwYGIyI1NDY/AjY3ByI1NDYzMjc2MzYzAjY3BgYVFBYzA1odJDEaAxM9CisoASIFCzdhS0JJN2RsAYsYJQgDFAK1dgUVDBYLFwQDJiJFExMEFxIOLjUmLp6KZjWHPeEuETs7DgwDVBwXIiRJWP7iMiAaEj2Xv14+NjZPRD4LgjV2tycOayQBMHxGg0OxMCUhPCCDbxqDYJABLyQlAgID+8RKUyE7JQ0P//8AQf/6BGMDUwACA4UAAAACAEH+OQK/A1AAOABAAFBATQQBBgAUAQIGOwEHAgNMAAQFAAUEAIAAAAYFAAZ+AAUFA2EAAwM5TQAGBgJhAAICNE0IAQcHAWEAAQE4AU45OTlAOT8lKCQmKSggCQkdKyQzMhYVFAcGBwICIyImNTQ2Njc2NwYjIiYmNTQ2NjMyFhUUBiMiJjU0NzY2NTQjIgYGFRQWMzI2NwI2NwYGFRQzApEPDxACAwYmg2wzQCpzaQICUFtglVVxv3FscCwnHCAFAQRhQnhKaWI8bDi7PhtMQxzrGhQFDB4o/v/+1D8zL2B+URIKKlCgc5HkfW9bPUsbGRAXBhsJW1ancoN3MTT9wHaDQWkoJwACAJj+rQM9A08ALwA3ADVAMjIaDAMFAQFMAAEABQABBYAGAQUAAgUCZQMBAAAEXwAEBDMATjAwMDcwNjceJCVEBwkbKwAWFRQGIyInJwYHBgc2MzIHDgIjIiY1NDY3JiY1NDY3NzY3BgcGNTQ2NzYzMzIXADY3BhUUFjMDDi8jKSlcRCsZFg0eEDEGDzVcSkJJUF0RExMTBBkpW1pNHx92joJgIv5/MRF7DgwDSCIiHBUCAdiZingHNYWqWT42QWI7Bh4UIINvGpvXAwcGOhojBA8D+8xXYlFMDQ///wCL//sC5ANPAAIDiAAA//8Ai//7AuQDTwACA4kAAAAC/9X+rQLnA08ANwA/AJNLsB1QWEASMykfBQQABBsRAgMAOQEGAwNMG0ASMykfBQQBBBsRAgMAOQEGAwNMWUuwHVBYQB4BAQAEAwQAA4AIAQYAAgYCZQcFAgQEM00AAwM0A04bQCQAAQQABAEAgAAAAwQAA34IAQYAAgYCZQcFAgQEM00AAwM0A05ZQBQ4OAAAOD84PgA3ADYqLSQjGQkJGysAFhUUBwEXHgIzMjc2MzIWBwYGIyImNTQ2NjcmJicnAwYGIyImNTQ3AQMmNTQ2MzIWFxc3NjYzAjcGBhUUFjMCyB8b/u9lExsNCgISDRETDwIQb29CSS9ZVBw3IUbwFCocHCUdATeVCyUgHyMKbMsUKh6aIj07DgwDTxQSGB/+xtAoMQ0DBR4f1Mw+NjFLQTEJTEqf/tYZDxUTGSABYwEzGBEZGxUX9vYYFPvJniI7JQ0PAAAAAAIAQ/6tA6wDVABPAFgAmEAKEQEIA1IBCgICTEuwLlBYQDQLCQIIAwYDCAaADAEKAAAKAGUFAQMDBGEHAQQEM00AAQEEYQcBBAQzTQAGBgJhAAICNAJOG0AyCwkCCAMGAwgGgAwBCgAACgBlBQEDAwRfAAQEM00AAQEHYQAHBzlNAAYGAmEAAgI0Ak5ZQBhQUAAAUFhQVwBPAE8cJSZGNxgkFyQNCR8rJAcOAiMiJjU0NjY3NyI1NDcCIyImNTQ2Nzc2NwYHBjU0Njc2MzMyFxYWFRQGIycmIwYHBwYVFDMyNhI3NjYzMhYVFAYHBgcHBhUUFjc2MwI2NwYGFRQWMwOsBQs3YUtCSTdjbQF/Em/FVFUODBYREFZXTR8fbJhlNyIwLyMpThInCB4YFT5DhWkXBCAmICEMDh4MBAUaJQMIpi4RPDoODJ49l79ePjY3TkM+DGEhTP7+XU4jXkR7Y4gDBwY6GiMEDwMEIiIcFQEBQ6SFeCtIlQEo0iAnJywbW1K9YCUgDxoSAQH+ektTIjslDQ8AAgBw/q0DCwNUAEQATQCsQAs4FAIEA0cBCAECTEuwCVBYQCYJBwIGAgECBgGAAAQAAgYEAmoKAQgAAAgAZQABAQNhBQEDAzkBThtLsAxQWEAmCQcCBgIBAgYBgAAEAAIGBAJqCgEIAAAIAGUAAQEDYQUBAwMzAU4bQCYJBwIGAgECBgGAAAQAAgYEAmoKAQgAAAgAZQABAQNhBQEDAzkBTllZQBZFRQAARU1FTABEAEQaJCsqKBckCwkdKyQHDgIjIiY1NDY2NzciNTQ2NzY3BgYjIiY1NDY3NjYnJjYzMhcWFRQGBwYGFRQWMzI2Njc2MzIHBgYPAgYVFBY3NjMCNjcGBhUUFjMDCwULN2FLQkk3Y20BfwgJEAQqelRmbQkKDQ0BASglPQYCDw0HCjAtRG1DCAZCRwYEGAwTAwUaJQMIpi4RPDoODJ49l79ePjY3TkM/C2EiOylHNVdVZFwdOTE/aDweIkAcDjJbOh03EygrY7h7VVM8wVeRHCYSGhIBAf56SlMiOiUNDwD//wBw//sC6ANUAAIDjQAAAAEATv/7ArEDUAAzAC1AKgUBAAEBTAADAzlNAAEBBGEFAQQENk0CAQAANABOAAAAMwAyKyYoJwYJGisAFhUUBwcGBiMiJjc2Njc2NTQjIgYGBwcGBiMiNTQ2PwI2Njc2NjMyFRQGDwIGFTY2MwJUXQkGAiYmIiIBAQYBB1EnYlAOCgMmIkUTEwQXCxcEAygmPxERCRYCMnVWAdxeTThjVCQjIiIfRQtEKUIoVD9hJSE8IINvGoNAsTMlITwddGQ3gwgGQ0IAAAAAAgBO/q0DFgNQAEoAUwD2QA9FAQYCHgsCAQZNAQcDA0xLsBVQWEArCAEGAgECBgGACQEHAAAHAGUABAQ5TQACAgVhAAUFNk0AAQE0TQADAzQDThtLsBZQWEAtCAEGAgECBgGAAAEDAgEDfgkBBwAABwBlAAQEOU0AAgIFYQAFBTZNAAMDNANOG0uwF1BYQCsIAQYCAQIGAYAJAQcAAAcAZQAEBDlNAAICBWEABQU2TQABATRNAAMDNANOG0AtCAEGAgECBgGAAAEDAgEDfgkBBwAABwBlAAQEOU0AAgIFYQAFBTZNAAMDNANOWVlZQBVLSwAAS1NLUgBKAEgqLicoKCMKCRwrJAcGBiMiJjU0NjY3NQYjIiY1NDc2NTQmIyIGBg8CBgYjIiY1NDY3Njc2Njc3PgIzMhYVFAcGBwYVNjYzMhYVFAcGBgcGFhY3MwI2NwYGFRQWMwMWAghwdkJJN2RsPRgaIAoHLSUnY1ENAwcCLB8hJA8KCwYPIhIICA0cGiAoAy0fAjJ1VlVdBQEEAQIJGx0Ppi4ROzsODJ40y/I+NjZPRD0CFy4vJkAuGB4kKVdAGkwdHyAaGG89PS1gtVUlJSQVICEKDti6CAZDQl5NFxwGHQ8UFAcB/npKUyE7JQ0PAAH/Tf6tA0sDUABXAS5LsCFQWLU+AQcIAUwbtT4BCwgBTFlLsBBQWEApAAQBBQUEcgAFAAMFA2YKAQgIOU0GAgIAAAdhDAsJAwcHNk0AAQE0AU4bS7AdUFhAKgAEAQUBBAWAAAUAAwUDZgoBCAg5TQYCAgAAB2EMCwkDBwc2TQABATQBThtLsCFQWEAoAAQBBQEEBYAMCwkDBwYCAgABBwBqAAUAAwUDZgoBCAg5TQABATQBThtLsCZQWEAtAAQBBQEEBYAMAQsHAAtZCQEHBgICAAEHAGoABQADBQNmCgEICDlNAAEBNAFOG0AyAAQBBQEEBYAMAQsHAAtZAgEABgcAWgkBBwAGAQcGagAFAAMFA2YKAQgIOU0AAQE0AU5ZWVlZQBYAAABXAFZRT0pHJiMoJCQnJiYkDQkfKwAWFRQGIyMHBgYHBgYjIjU0Nj8CIwcHBgcHDgIjIiY1NDYzMhYVFBYzMjY2NzY3Njc3ByI1NDYzMzU2Njc2NjMyFRQGDwI3NzY2NzY2MzIVFAYHBzMDLh0kMRkCCxcEAyYiRRMTBAO1iQINCQ4ZSGlMQkktHRceDgwUIigcBQkPCQIgNSYuFgwXAwMoJj8REQkBiLcLFwQDKCY/FA0KHQHrHBciJA1DsTAlITwgg28aDwILVkdknr9aPjYgJRoYDQ8xi4YXSHA6CgEvJCUCQ7IvJSE8HXRkNwMBA0CvMiUhPByISzoAAAAAAv/h/q0CwANQAC8AOAB9QA8SAQUDDAICAQIyAQYBA0xLsBJQWEAiBwEFAwIDBQKACAEGAAAGAGUAAwM5TQQBAgIBYQABATQBThtAKAcBBQMEAwUEgAAEAgMEAn4IAQYAAAYAZQADAzlNAAICAWEAAQE0AU5ZQBQwMAAAMDgwNwAvAC4mJyIvJAkJGyskFgcGBiMiJjU0NjY3IyYmNTQ3DgIjIjU0MzI2Njc2NzY2MzIWBwYVFBYzMjc2MwI2NwYGFRQWMwKxDwIQb29CSS9aVgZFQgkvZIpbRzohO0IpTkoNNSkpIAMPIiMNDhQOoy8SPDwODIoeH9TMPjYyS0EyBsWST1Wo6Io6PCpnXK72KiclKsx8hbkHCP6OR1ciPCQNDwAAAAIAN//7AzcDUAA0AD4AhrUfAQcDAUxLsCpQWEAxAAMIBwgDB4AAAAIGAgAGgAkBCAgEYQAEBDlNBQECAgdfAAcHNk0ABgYBYQABATQBThtALwADCAcIAweAAAACBgIABoAABwUBAgAHAmkJAQgIBGEABAQ5TQAGBgFhAAEBNAFOWUARNTU1PjU9FiMnKyYUJiAKCR4rJDMyFhUUBwYGIyImJjU1JicmJjU0NjMyFxYWFxYXFhc+AjMyFhUUBgcGBiMhFRQWMzI2NwIGBgchNjU0JiMDAwoREEgjaDBup1wsIBYhHxgRCggLBggNBAwWcKNhdHIUDA0zKP6egHU0UizjYUcRAUMXMTqdFxM5Hg4TV6BqFgMLBywbKSYFBA8KDgQCAm6kWYByJ3gZHBkDd4QREwJHO3NRLk5CQQACADf/AgM3A1AATABWAPFACzcBCgYiCwIBCQJMS7ASUFhAOQAGCwoLBgqAAAAFCQUACYADAQIABAIEZQwBCwsHYQAHBzlNCAEFBQpfAAoKNk0ACQkBYQABATQBThtLsCpQWEBAAAYLCgsGCoAAAAUJBQAJgAADAQIBAwKAAAIABAIEZQwBCwsHYQAHBzlNCAEFBQpfAAoKNk0ACQkBYQABATQBThtAPgAGCwoLBgqAAAAFCQUACYAAAwECAQMCgAAKCAEFAAoFaQACAAQCBGUMAQsLB2EABwc5TQAJCQFhAAEBNAFOWVlAFk1NTVZNVVFQSkgnKyYYJyIlJiANCR8rJDMyFhUUBwYGIyInBhUUFjMyNzYzMhYVFAYHBgYjIiY1NDcmJjU1JicmJjU0NjMyFxYWFxYXFhc+AjMyFhUUBgcGBiMhFRQWMzI2NwIGBgchNjU0JiMDAwoREEgjaDAjJjckGhoVEAsODBYZDCcQRlRGYG0sIBYhHxgRCggLBggNBAwWcKNhdHIUDA0zKP6egHU0UizjYUcRAUMXMTqdFxM5Hg4TBSw5HR4HBhMTFR0JBAZJP1I9J6lzFgMLBywbKSYFBA8KDgQCAm6kWYByJ3gZHBkDd4QREwJHO3NRLk5CQQD//wBO//sBRQNQAAIBEQAA//8ADP/4BLUEZgAiA8QAAAEHBeQD0wF8AAmxAQG4AXywNSsA//8ARv6tAv4DUAACA/QAAAAB/+H/IwLNA1AALwB0S7AJUFhACy0VAgIDEAEBAgJMG0AOFQEEAy0BAgQQAQECA0xZS7AJUFhAFwUEAgICAWEAAQE0TQAAAANhAAMDOQBOG0AeBQEEAwIDBAKAAAICAWEAAQE0TQAAAANhAAMDOQBOWUANAAAALwAuJyIuKAYJGiskFhUUBwYHBgYjIiY1NDc2NyYmNTQ3DgIjIjU0MzI2Njc2NzY2MzIWBwYVEBc2MwKyGxRYNB4fGBghCz4kPTgJL2SKW0c6ITtCKU5KDTUpKSADDkAgHIIVEhUZblAuHiAVEg5dPSW1gk9VqOiKOjwqZ1yu9ionJSq7h/7uMAX//wAz/q0DSwNQAAID+AAAAAEAM/8jA0sDUABYAPpLsCFQWEAKOAEGBwIBAgACTBtACjgBCgcCAQIAAkxZS7AdUFhAKAAAAwIDAAKAAAECAYYJAQcHOU0LBQIDAwZhCggCBgY2TQQBAgI0Ak4bS7AhUFhAJgAAAwIDAAKAAAECAYYKCAIGCwUCAwAGA2oJAQcHOU0EAQICNAJOG0uwLlBYQCsAAAMCAwACgAABAgGGAAoGAwpZCAEGCwUCAwAGA2oJAQcHOU0EAQICNAJOG0AwAAAFAgUAAoAAAQIBhgAKBgMKWQsBAwUGA1oIAQYABQAGBWoJAQcHOU0EAQICNAJOWVlZQBJYVlJQS0k1JiMmJiYXKCMMCR8rAQYHNjMyFhUUBwYHBgYjIiY1NDc3NjcmNTQ2PwIjBwcGBgcGBiMiNTQ2PwIHIjU0NjMzNTY2NzY2MzIVFAYPAjc3NjY3NjYzMhUUBgcHMzIWFRQGIyMC2xIOLBwZGxRYNB4fGBghCxEpGkMTEwQDtYkCCxcEAyYiRRMTBAIgNSYuFgwXAwMoJj8REQkBiLcLFwQDKCY/FA0KHSAdJDEZAWVvewcVEhUZblAuHiAVEg4ZPS0BOyCDbxoPAgtDsTAlITwgg28aCgEvJCUCQ7IvJSE8HXRkNwMBA0CvMiUhPByISzocFyIkAP//AHD+rQLoA1QAAgOYAAAAAf///yMD0wNQAFEAPUA6SD0iFQQFAxABAQUCTAYBBQMBAwUBgAIBAQE0TQAAAANhBAEDAzkATgAAAFEAUEZEODYoJhwaKAcJFyskFhUUBwYHBgYjIiY1NDc2NyYmNTQ3IwIDBgYjIicmJjU0NyMOAiMiJjU0Njc2Njc2Njc3NjYzMgcGFRQXMzYSNz4CMzIWFQcGBhUUFhc2MwO4GxRYNB4fGBghCzssKCwXAmRcCh4cMA4ZHAQCJURjSCgoGBUiLhwTIBw0Cy8wUgYFGAIabj4RFx0bLCgBCgwVGBcSghUSFRluUC4eIBUSDldMJI1hmpn+7f7dHxgwUN9yQjHC8o4oGRQcBQc7SzKAe9otJFdVRaLabwEqhCMgDSEiDGbYUmlzFgMAAP//ADj/+wM9BGYAIgO6AAABBwXkA4IBfAAJsQEBuAF8sDUrAP//ADj/+wM9BDEAIgO6AAABBwW9A4IBfAAJsQECuAF8sDUrAP//ADj/+wQ4A1EAAgDlAAD//wAr//sCygRmACIDwQAAAQcF5AL8AXwACbEBAbgBfLA1KwD//wA7//sDBQNQAAIAnAAA//8AO//7AwUEMQAiA54AAAEHBb0C8QF8AAmxAgK4AXywNSsA//8ADP/4BLUEMQAiA8QAAAEHBb0D0wF8AAmxAQK4AXywNSsA//8AOv/7ArQEMQAiA08AAAEHBb0C7wF8AAmxAQK4AXywNSsAAAEAOv/7AwADTgBFAFBATS4BAAYkCQIEBQJMAAAGBwYAB4AABwUGBwV+AAIEAwQCA4AABgYIYQAICDNNAAQEBWEABQU2TQADAwFhAAEBNAFOJikjFCclJCkkCQkfKwAWFRQGIyMGBgcWFhUUBgYjIiY1NDYzMhYVFBYWMzI2NjU0JicGIyImNTQ2NzY3JiMiBhUUFhcWFRQGIyInJiY1NDYzMhcC5xkcGQkpRS9ES1qla3+RJSYcIRs9NzxfNSggTU8hHEVIZ0dSYUlACQEIIhkZEBIYm4ibhwMfHBcbHlJoIxNdQ0+IUW5iMjAfHTQ7GzZYMio5BSwWGSImBUugECshDxgCEggUFg8RNhleYCb//wBd//sDAwPyACIDxgAAAQcFxwMTAXwACbEBAbgBfLA1KwD//wBd//sDAwQxACIDxgAAAQcFvQMUAXwACbEBArgBfLA1KwD//wBA//sDHgQsACIDWQAAAQcFvQMUAXcACbECArgBd7A1KwD//wBA//sDHgNQAAIDpgAA//8AQP/7Ax4ELAAiA6YAAAEHBb0DFAF3AAmxAwK4AXewNSsA//8ALP/7AuAEMQAiA24AAAEHBb0C7AF8AAmxAQK4AXywNSsA//8AXP/5AuoD8gAiA9QAAAEHBccC+AF8AAmxAQG4AXywNSsA//8AXP/5AuoEMQAiA9QAAAEHBb0C+QF8AAmxAQK4AXywNSsA//8AXP/5AuoEfAAiA9QAAAEHBcEC+QF8AAmxAQK4AXywNSsA//8AcP/7AugEMQAiA2IAAAEHBb0C8AF8AAmxAQK4AXywNSsAAAIATP6tA1kDWQAwADgAdEAMJAEDADMZCwMFAQJMS7AsUFhAIwADAAEAAwGAAAEFAAEFfgcBBQACBQJlAAAABF8GAQQEMwBOG0AhAAADAIUAAwEDhQABBQGFBwEFAgIFWQcBBQUCYQACBQJRWUAUMTEAADE4MTcAMAAtJyUkJTQICRkrABYVFAYHBgcGBwYHNjMyBw4CIyImNTQ2NyYmNTQ2NzY3Njc3BwciJjU0Njc2NzY3ADY3BhUUFjMDPhsiKMZ3JR4XDBgSMQYPNVxKQklSXRITDwoLBhIkDCgPHx8fH2Sprlr95DERew4MA1kYGyAhAgoIuLSMdQY1hapZPjZBZDoHGxMYbz09LXutOwQBHBkaJAMKBwkG+8FXYlFMDQ8AAP//ABz/+wQWBDEAIgPfAAABBwW9A6sBfAAJsQMCuAF8sDUrAAAB/8L+rQNZA1kASQEgtTwBCAABTEuwEFBYQC4ACAABAAgBgAAEAgUFBHIABQADBQNmAAAACV8KAQkJM00GAQICAWEHAQEBNgJOG0uwLFBYQC8ACAABAAgBgAAEAgUCBAWAAAUAAwUDZgAAAAlfCgEJCTNNBgECAgFhBwEBATYCThtLsC5QWEAmAAAIAIUACAEIhQAEAgUCBAWAAAUAAwUDZgYBAgIBYQcBAQE2Ak4bS7AwUFhAMAAACACFAAgBCIUABAIFAgQFgAAFAAMFA2YGAQICAV8AAQE2TQYBAgIHYQAHBzYCThtAKwAACACFAAgBCIUABAIFAgQFgAAHAgIHWQAFAAMFA2YGAQICAV8AAQE2AU5ZWVlZQBIAAABJAEYlMzkkJCgkIjQLCR8rABYVFAYHBgcGBzcyFhUUBiMjBwYHBgcOAiMiJjU0NjMyFhUUFjMyNjY3Njc2Njc3BiMiJjU0MzI3Njc3BgcHIiY1NDY3Njc2NwM+GyIoxXkcFUgeHCIwPwMHDA0JHUhnTEJJLR0XHg4MFCImFw0VAwcFAywKGBxTExIRFQsNGg8fHx8fZKmuWgNZGBsgIQIKCIZ9ARUNGRwTKVpmLJa2Vz42ICUaGA0PK3dvQJMWMx4SAhISMgFdajUCAgEcGRokAwoHCQYA//8AM/6tA0sDUAACBA4AAAAB/9X/+wLnA08AOQBfQAo1AQAGGAECAQJMS7AuUFhAGAUBAAQBAQIAAWgIBwIGBjNNAwECAjQCThtAHQAABQEAWQAFBAEBAgUBaAgHAgYGM00DAQICNAJOWUAQAAAAOQA4JUMlJiUkNQkJHSsAFhUUBwM2MzIWFRQGIyMTFhUUBiMiJicDAwYGIyImNTQ3AQciJjU0MzI2MwMmNTQ2MzIWFxc3NjYzAsgfG+MgIh4cIjBHlwwmIBolDH7wFCocHCUdARFiGBxTBSYqgQslIB8jCmzLFCoeA08UEhgf/voBFQ0ZHP7GGRQaGhYbASH+1hkPFRMZIAE3AhISMgEBChgRGRsVF/b2GBQAAAD//wAx//sCowNQAAIDsgAA////4f6tAsADUAACBAcAAP//AED+7gMeA1AAAgE4AAD//wB6//sE5QNQAAIBWgAA//8AHP/7AscDUAACA7YAAAACAC//+wLdA04AOQBOALtLsCFQWEAUJQEFCEY+OzcJAQYAB04XAgEDA0wbQBQlAQUIRj47NwkBBgAHThcCAQQDTFlLsCFQWEA0AAUIBwgFB4AABwAIBwB+AAADCAADfgABAwIDAQKAAAgIBmEABgYzTQQBAwMCYQACAjQCThtAOgAFCAcIBQeAAAcACAcAfgAAAwgAA34AAwQIAwR+AAEEAgQBAoAACAgGYQAGBjNNAAQEAmEAAgI0Ak5ZQAwXLyYmExskFCUJCR8rABUUBwYGIyInJwYGBwYHBgYjIjU0Njc3JyYmNTQ2MzIXFhc3NjcGBwYjIiY1NDc2NjMyFhYVFAcWFwQ3JyY1NDc2MzIXFhc2NTQmJwYHBwLdAgcTEBYhHTGpdBYHBR4mRQ8JBSEeExkVBQwVDxQVDxwWDAoQFSolcj5qkEYUGxL++TkxJgMMHBchCgkEU1wNGxQBvhoEBg4QEA09SgWOPicfPBdpOyAFBRwUFxgCBAFyeXIJDAYXESQaFxtCckk3NgoJUU0VEBoHBxoQBQMUG0hNBFqidQAAAP//ACP/+wJXAdQAAgFtAAAAAgAn//wCXwOMADwATACIQAoTAQYCPwEABAJMS7AqUFhALAADAgOFCAEFBgQGBQSAAAQAAAcEAGoABgYCYQACAhlNCQEHBwFhAAEBGAFOG0AqAAMCA4UIAQUGBAYFBIAAAgAGBQIGaQAEAAAHBABqCQEHBwFhAAEBGAFOWUAYPT0AAD1MPUtGRAA8ADw5OCQiJSIWCgcZKwAWFRQGBwYjBgYjIiY1NDY2MzIXJiYnLgI1NDY2NzY2NzYzMhYVFAYHBgYHBgYVFBYXHgIVFAc2NzYzBDY3JiY1NDcnIgYGFRQWMwJRDg4PSFAab0xSXDdeOR4WDiMcJCgcNExAIEIWBgYOEQoJGj0rLysfISw8LQI3RAYI/rA1EBMTAhMZKxoXGgEzGhQZGwUZWV5hZEt3QwsXKh8oMj0hLjccDwgTCwMkGBEbBhEPBgcRGBApJDBNZzoRIAMSAs5FNxU2HQkSASpLLywwAAD//wA3//sCXwOsAAIBiAAAAAEAJf/xAf4B2wA0AGNLsDBQWEAlAAQDAQMEAYAAAQADAQB+AAMDBWEGAQUFGU0AAAACYQACAhgCThtAIgAEAwEDBAGAAAEAAwEAfgAAAAIAAmUAAwMFYQYBBQUZA05ZQA4AAAA0ADMkKyYjKwcHGysAFhUUBgYHBgYVFBYzMjY3NjMyFhUUBwYGIyImNTQ2Njc2NjU0JiMiBgcGBiMiJjU0NzY2MwEmTSQyKCsoICg7dS0LEA0PEzCKVFhgJTUoKSYWFRMeEgoVCRMVGRROKAHbNTIrOiIUFiAbFhI7Ng4YFSUZQEM9RCs9JxUWIRcNDwsKBQkZFBsTDxQA//8AJf/xAf4DQgAiBDMAAAADBacCAgAAAAEAMv/7AasCYwAkACVAIgQBAwIDhQAAAAJhAAICGU0AAQEYAU4AAAAkACM2KRYFBxkrABYHBgYHBiMiBwYGBxUOAiMiJjU0NzY2NzMyNzY2NzY3NzYzAZUWAgQ1ND8zBgMIEQEBBBQXJh8lCCUgBT86Cw0DBAcDBSYCYyciVkkEBQkbgDcVPjIXUFiCdRsbAgcCCQwSJxcjAAAA/////v45AkwB1AACAaoAAP//ACH/+wIKAdIAAgGUAAD//wAh//sCCgNDACIENwAAAAMFpgI1AAD//wAh//sCCgKxACIENwAAAAMFpAI1AAAAAQAR//sDTgHWAGwBXUAUPwEGBVkBCgYWAQMKSyMLAwQDBExLsAlQWEAwAAYFCgUGcgAKAwUKcA4NAgMEBANwCwEFBQdhCQgCBwcZTQwBBAQAYgIBAgAAGABOG0uwDFBYQDEABgUKBQZyAAoDBQpwDg0CAwQFAwR+CwEFBQdhCQgCBwcZTQwBBAQAYgIBAgAAGABOG0uwFVBYQDIABgUKBQZyAAoDBQoDfg4NAgMEBQMEfgsBBQUHYQkIAgcHGU0MAQQEAGICAQIAABgAThtLsBdQWEAzAAYFCgUGCoAACgMFCgN+Dg0CAwQFAwR+CwEFBQdhCQgCBwcZTQwBBAQAYgIBAgAAGABOG0A+AAYFCgUGCoAACgMFCgN+Dg0CAwQFAwR+AAsLB2EJCAIHBxlNAAUFB2EJCAIHBxlNDAEEBABiAgECAAAYAE5ZWVlZQBoAAABsAGtoZmFfV1VRTyYkJCUmJCknJg8HHyskFhUUBwYGIyImJicGBwYGIyImNTQ2NyMOAiMiJjU0NjMyFRQHBhUUMzI2NjU0JiMiBgcGBiMiJjU0NjMyFhc2NzY2MzIWFRQHBgczPgIzMhYVFAYjIiY1NDY3NjU0IyIGBhUUFjMyNjc2MwM/DxMtWjkwTC4HDBQKFRQYFA0JAh0xTzo3QC4qJAIDGhMjFxINCwoFBhQZFhpBMS9DFwgJCSIiFBAPDwoCGz5NMzQ7JR4TFwQBBRoUJhcyLyU6MwwP3xgVKBY2QzBJJVQoEhAiJSBjLVBiREA1Mj4bBxIkBR4tTi8kMQsNEBMfIDI7S01HHhsUDA4OOD9lYXEyQTMqOhIQBxIEDw0bKUUoNkExPQ4AAv/W/jkCIAHbADwARQBDQEA9ODYSBAUEAUwAAgEEAQIEgAYBBAUBBAV+AAEBA2EAAwMZTQAFBQBhAAAAGwBOAABCQAA8ADsxLyspJSMrBwcXKyQWFRQHBgcWFRQGBiMiJjU0NjcmJicmJjU0NzY2Nz4CNTQmIyIGBwYGIyI1NDY2MzIWFRQGBxYXNjc2MwEGFRQzMjY2NQIRDxxyWAdFc0A3PGaACR8aJCAUCi8FMEExGBwZIxYSFQ0nLVQ4R0V/ZEYjWYANCv7MmBwYOyndGBQrEEI8HCZcsXA9OFWgZA0UDBAmFyIQCBECER80JRUWDQ0JCSYZLBpEN1RqHRcnP08I/suAaShZfjAA//8AMP/7Ak8B0gACAgwAAP//ADD/+wJPAvQAIgQ8AAAAAwXjAlEAAP//ADD/+wJPA0MAIgQ8AAAAAwWmAlEAAAACADD/SwJPAvQAGQBeAG1AahQBAQA/AQoGMAEJBy4BBQkETAACAAKFAAABAIUMAQoGBwYKB4AACQcFBwkFgAAEBQSGAAELAQMGAQNpCAEGBhlNAAcHBWIABQUYBU4aGgAAGl4aXVpYUE5JRz07NDIoJgAZABgkIyUNBxkrEiYmNTQ2MzIWFxYzMjY3NjYzMhYVBw4CIwAWFRQHBgcOAgcGBiMiJjU0NzY3JjUGBiMiJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMhYVFAcGFRQWMzI2NzYz1EYmIBkaGAcKLS9EDwgUEA8VAgo2XkEBPg8THx8tLxwEGyQZFBkQICI9EUQnLTkUFwokJxYRCwoGFAoLDy0zGAghIRcSGRwQDRQ3LgwPAhQmPiMZHxgdKjUmFBEXEQwpTjX+yxgVKBYmGi4/KwcrHxgSFRYrNRdxRElTPkt9Rh4aDg4ILiUeaSMVETx6WR4aCw8ZcIAeExUxNw4AAAD//wAy//sCUgHSAAIBxwAA//8AMv/7AlIDQgAiBEAAAAADBacCTQAAAAEAAf/7ApoB0AA1ALu1DQECBAFMS7AJUFhAGwcGAgIEAwMCcgAEBBlNBQEDAwBiAQEAABgAThtLsBBQWEAcBwYCAgQDBAIDgAAEBBlNBQEDAwBiAQEAABgAThtLsCZQWEAiAAIEBgQCBoAHAQYDBAYDfgAEBBlNBQEDAwBiAQEAABgAThtALAACBAYEAgaABwEGAwQGA34ABAQZTQADAwBiAQEAABhNAAUFAGIBAQAAGABOWVlZQA8AAAA1ADQmJyUkJycIBxwrJBYVFAcOAiMiJjU0NyMGBiMiJjU0NjMyFgcGFRQzMjY3NjY3NjYzMhYVBwYVFDMyNjc3NjMCiw8TITFHLTsyBAIodUszOi4qExMCCBIKGR4XMRAQKicmJAIEKxIjJRkMD98YFSgWJy8jXV4vLIWQSjgyPhAOMBIkHjosbisqHx4iSlQlaSItHg4AAAABAAH/+wNfAdMAUgC7S7AJUFhADBwMAgMFPCkCBAMCTBtADBwMAgMFPCkCBAgCTFlLsAlQWEAdCQgCAwUEBANyBgEFBRlNBwEEBABiAgECAAAYAE4bS7AmUFhAJAADBQgFAwiACQEIBAUIBH4GAQUFGU0HAQQEAGICAQIAABgAThtALwADBQgFAwiACQEIBAUIBH4GAQUFGU0ABAQAYgIBAgAAGE0ABwcAYgIBAgAAGABOWVlAEQAAAFIAUSkqJiYkKysmCgceKyQWFRQHBgYjIiY1NDcjBgYHBwYGIyImJyYmNTQ3Iw4CIyImNTQ2MzIVFAcGFRQzMjY3Njc2NjMyFhUUFzM2Njc2NjMyFhUUBgcGFRQWMzI3NjMDUA8TLlc0NS4QAhksGxELHhUWFAgJDAMCGTBSPzU5LiooAQgPDhwZIh4KJyEcJQcCEUgVEycYJBoCAQQQFig9CxDfGBUpFjZCUExCYytsSi0eFRgaHmk2IR5hfU9KODJDGwUDMBQiKUVdYR8dFhmRTDmUFxQVHyoXLRNKJDkoaRIAAQAy//sCXAHSADkANkAzCAEHBAEEBwGAAAQAAQYEAWgFAQMDGU0ABgYAYQIBAAAYAE4AAAA5ADgoJBYmJiQmCQcdKyQWFRQHBgYjIiY1NDciJwYVFQ4CIyImNTQ3NjYzMhYVFAcGBzM2NzY2MzIWFRQHBhUUFjMyNjc2MwJNDxMuYT40KgVYIgIBBBQXJh8lCSgmFBAPCAeAChMIISEXEhkcEA0UNy4MD98YFSgWNURAQBsmAhwLFT4yF1BYgnUdGwoOEDghLy9JHhoLDxlwgB4TFTE3DgD//wAh//sCSQHTAAIB2AAA//8AMv/7AnEB0gACAdAAAP///4n+NwJiAdgAAgH3AAD//wAg//sB8QHSAAIBiQAA//8AMv/7A2kB0gACAc8AAP////z+OQJMAdIAAgIoAAD////8/jkCTAL0ACIESgAAAAMF4wJRAAAAAwAj/rEDUgMQAEUAUABbAdpLsA5QWEAQNQEJBD4BBwgZDQkDAAcDTBtLsBtQWEAQNQEJBD4BBwgZDQkDAAwDTBtLsB1QWEAQNQEJBD4BBwgZDQkDAAoDTBtAEDUBCQQ+AQcIGQ0JAwAMA0xZWVlLsA5QWEAvAAUEBYUNAQgJBwkIB4AAAgAChgsBCQkEYQYBBAQZTQ4MCgMHBwBiAwECAAAYAE4bS7AbUFhAOgAFBAWFDQEICQcJCAeAAAIAAoYLAQkJBGEGAQQEGU0KAQcHAGEDAQIAABhNDgEMDABiAwECAAAYAE4bS7AdUFhAOgAFBAWFDQEICQcJCAeAAAIAAoYLAQkJBGEGAQQEGU0ABwcAYQMBAgAAGE0ODAIKCgBiAwECAAAYAE4bS7AhUFhARQAFBAWFDQEICQcJCAeAAAIAAoYLAQkJBGEGAQQEGU0ABwcAYQMBAgAAGE0ACgoAYQMBAgAAGE0OAQwMAGIDAQIAABgAThtATwAFBAWFDQEICwcLCAeAAAIAAoYACQkEYQYBBAQZTQALCwRhBgEEBBlNAAcHAGEDAQIAABhNAAoKAGEDAQIAABhNDgEMDABiAwECAAAYAE5ZWVlZQB1RUQAAUVtRW1hWTkxHRgBFAEQmKSclKSUiJg8HHiskFhUUBwYGIyInBiMiJwYVFxQjIiY1NDc2NyMGBiMiJjU0NjYzMhc2Njc3NjYzMhYVFAcGBgczNjMyFhUUBgcWMzI2NzYzJQ4CFRQWMzI2NxY2NjU0JiMiBgcHA0MPEy5hPjYhOz4PCgUBOxsfBwgKAh87Ij5KSntFEAoJFQwGCCUcHRkEFSgRAjdJPkYhHhUPITwvDA/+AylGKhkWFyoJpEYqGRYXKgkg3xgVKBY1RCYmBUZmbDcaG4hYXjIxKlpJUI9XBTluNhwoIBIVDg9VpVlbWUo0ZSkGMDgOmAE9ZDgfHjkzcz1kOB8eOTOrAAD//wAR//sCkgHWAAICJwAAAAH/9f/xAq0CDQBAAH+2Eg0CAQQBTEuwMFBYQC4AAwUDhQgBBwEGAQcGgAACBgAGAgCAAAQAAQcEAWkABQUZTQAGBgBhAAAAGABOG0ArAAMFA4UIAQcBBgEHBoAAAgYABgIAgAAEAAEHBAFpAAYAAAYAZQAFBRkFTllAEAAAAEAAPygkIysoJiYJBx0rJBYVFAcGBiMiJjU0NjcGIyImJwYHBgYHBiMiJjU0Nzc2NzY2NzYzMhcWFjMyNjY3NjMyFhUUBwYGFRQzMjY3NjMCng8TL45HVVlZVBIbIC8NGSgkPykSFBAUDhoxGBYnFRM/LRILISMRIhsEHQ0RFCRhTz4veioLEN8YFSUZPkVHRkRnOgciInBAOkkoEhcRFBEfNyklW0tDKRgXCAoBDBQULhxLWSwyPTQOAAIAMP7QAlwB0gBKAFEAmkuwDlBYQBAgAQcCQBENAwEDTQEIAQNMG0ATIAEHAhEBBQNADQIBBU0BCAEETFlLsA5QWEAjAAcCAwIHA4AJAQgAAAgAZQQBAgIZTQYFAgMDAWIAAQEYAU4bQCoABwIDAgcDgAYBBQMBAwUBgAkBCAAACABlBAECAhlNAAMDAWIAAQEYAU5ZQBFLS0tRS1AlIhkkKicsJQoHHiskBwYHBgYjIiY1NDY2NzUmJjUGBiMiJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjc2NjMyFhUUBwYGFRQWMzI2MzIWBzY3NjMyFhUUBgcANjcGFRQzAhJjDQwZYj8qNyNdVR0hEEMpLDoUFwolJhUSCwoGFAoLG0wgCCIgFxIZCxIKCgQKBQcHAUA0CwwNDwwR/swwCWgVLTs8LFpgOCokQVAzAgU5LkFMUj9KfUcfGQ0PCC4lHmoiFBKYdx8ZCw8YbC1YExMPAg4VKCcIGBQVFwz+4kw/PjcWAAEAMP/7AzYB0gBPAJ9LsC5QWEAOIAEJAxEBBAkKAQgEA0wbQA4gAQkFEQEECQoBCAQDTFlLsC5QWEAqCgEJAwQDCQSABwUCAwMZTQYBBAQAYgIBAgAAGE0ACAgAYQIBAgAAGABOG0AuCgEJBQQFCQSABwEDAxlNAAUFGU0GAQQEAGICAQIAABhNAAgIAGECAQIAABgATllAEgAAAE8ATiglKCQqJyUkJgsHHyskFhUUBwYGIyImNwYGIyI1NDcGBiMiJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjc2NjMyFhUUBwYVFBYzMjY2NzY2MzIWFRQHBhUUFjMyNjc2MwMnDxMuYT4wLgERRCdbAx5ELS05FBcKJCcWEQsKBhQKCyE/JQkYIBoUDhQKCw8tMxgIISEXEhkcEA0UNy4MD98YFSgWNURLQkRJbBMVSExTPkt9Rh4aDg4ILiUeaSMVEZV6HhURFRRNdCEVETx6WR4aCw8ZcIAeExUxNw4AAAAAAgAw/tADQwHSAGIAaQEHS7AOUFhAFBUBCQIGAQMJYl5GAwADZQELAARMG0uwLlBYQBcVAQkCBgEDCWIBBwNeRgIAB2UBCwAFTBtAFxUBCQQGAQMJYgEHA15GAgAHZQELAAVMWVlLsA5QWEAmAAkCAwIJA4AMAQsACgsKZQYEAgICGU0IBwUDAwMAYgEBAAAYAE4bS7AuUFhALQAJAgMCCQOACAEHAwADBwCADAELAAoLCmUGBAICAhlNBQEDAwBiAQEAABgAThtAMQAJBAMECQOACAEHAwADBwCADAELAAoLCmUGAQICGU0ABAQZTQUBAwMAYgEBAAAYAE5ZWUAWY2NjaWNoWFZLSSIZJSgkKiclIQ0HHyskBiMiNTQ3BgYjIiY1NDY3NjYzMhYVFAcGBwYVFBYzMjY3NjYzMhYVFAcGFRQWMzI2Njc2NjMyFhUUBwYGFRQWMzI2MzIWBzY3NjMyFhUUBgcGBwYHBgYjIiY1NDY2NzUmJjUCNjcGFRQzAehEJ1sDHkQtLTkUFwokJxYRCwoGFAoLIT8lCRggGhQOFAoLDy0zGAghIRcSGQsSCgoECgUHBwFANAsMDQ8MES1jDQwZYj8qNyNdVR0hCS0OaBVESWwTFUhMUz5LfUYeGg4OCC4lHmkjFRGVeh4VERUUTXQhFRE8elkeGgsPGGwtWBMTDwIOFSgnCBgUFRcMIDo8LFpgOCokQVAzAgU5Lv6mRkU+NxYAAQAw/4cCTwHSAEAARkBDIQEGAgoBBQMVAQAFA0wHAQYCAwIGA4AAAwUCAwV+AAUFAGIAAAAYTQABAQJhBAECAhkBTgAAAEAAPyglKiwnJggHHCskFhUUBwYGIyImNQYHDgIjIiY1NDcmJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMhYVFAcGFRQWMzI2NzYzAkAPEytjPzAtFC0JERcTFRcFGR0UFwokJxYRCwoGFAoLDy0zGAghIRcSGRwQDRQ3LgwP3xgVKBY1REpDUSU6ORgnJR0aEkUrS31GHhoODgguJR5pIxURPHpZHhoLDxlwgB4TFTE3DgAAAgA0//sChgHSACkANABMQEkaAQYDMSICBAUJAQAEA0wIAQUGBAYFBIAAAwAGBQMGaQACAhlNCQcCBAQAYgEBAAAYAE4qKgAAKjQqMy8tACkAKBYnJyImCgcbKyQWFRQHBgYjIicGIyImNTQ2NzY2MzIVFA8CNjYzMhYVFAcWMzI2NzYzBDY1NCMiBgcWFjMCdw8TLmE+KR8uOltnEhMJKSctDwcOG0snPUcXBQkhPC8MD/65LDkhMxAEIiPfGBUoFjVEGBhnUzxsPR0bGAo+HjwbI1A+MC4BMDgOeiwnNSYYJCYAAgAp//sCnwHoADkARADGQBMRAQUDKgEIBUEyAgYHCQEABgRMS7AXUFhAKgoBBwgGCAcGgAAFAAgHBQhqAAICGU0EAQMDGU0LCQIGBgBiAQEAABgAThtLsCZQWEAqAAIDAoUKAQcIBggHBoAABQAIBwUIagQBAwMZTQsJAgYGAGIBAQAAGABOG0AuAAIEAoUKAQcIBggHBoAABQAIBwUIagAEBBlNAAMDGU0LCQIGBgBiAQEAABgATllZQBg6OgAAOkQ6Qz89ADkAOBYpMSMsIiYMBx0rJBYVFAcGBiMiJwYjIiY1NDY3JicmJjU0NjMyFxYWMzI3NjMyFhUUBgcGBzY2MzIWFRQHFjMyNjc2MwQ2NTQjIgYHFhYzApAPEy5hPigdL0BdYR4qKSYPDh8TCggcLhkfJwYKExEcISEPGkYkPUcTBAYhPC8MD/65LDkhMg8CISTfGBUoFjVEFhZmVDhgKwMPBhgNFB8EDgsGAQ4QGxkIMCcXHlA+NSkBMDgOeiwnNSQYJiYAAAAAAgA0//sDPwHSADYAQQBKQEccAQcDOwoCBQYCTCIBBwFLCQEGBwUHBgWAAAMABwYDB2kEAQICGU0IAQUFAGIBAQAAGABOAAA/PTk3ADYANScnJyclJQoHHCskFhUUBwYjIiY1NQYGIyImNTQ2NzY2MzIVFA8CNjYzMhYXNjY3NjYzMhUUBwYVFBYzMjY3NjMkIyIGBxYWMzI2NQMwDxNjVkE7N4VJV2cSEwkpJy0PBw4bSycuPAQnMhIJHSEzExgQExI2LQwP/iw5IjMPBCIjKCzfGBUoFnlcTA9TZGhSPGw9HRsYCj4ePBsjNzIvUy0eGCIZW24nHiAyNg4OJhklJCwnAAACAAH/+wObAdAAPgBJAT1LsBBQWEAULxACAwZGAQQJCQEABANMNwEEAUsbS7AuUFhAFC8QAgMGRgEECAkBAAQDTDcBBAFLG0AULxACAwZGAQQICQEACgNMNwEEAUtZWUuwCVBYQCYLCAIDBgkEA3IABgAJBAYJaQAFBRlNDAoHAwQEAGICAQIAABgAThtLsBBQWEAnCwgCAwYJBgMJgAAGAAkEBglpAAUFGU0MCgcDBAQAYgIBAgAAGABOG0uwLlBYQC4AAwYJBgMJgAsBCAkECQgEgAAGAAkIBglpAAUFGU0MCgcDBAQAYgIBAgAAGABOG0A5AAMGCQYDCYALAQgJBAkIBIAABgAJCAYJaQAFBRlNBwEEBABiAgECAAAYTQwBCgoAYgIBAgAAGABOWVlZQBk/PwAAP0k/SERCAD4APRYmJyUkJyImDQceKyQWFRQHBgYjIicGIyImNTQ3IwYGIyImNTQ2MzIWBwYVFDMyNjc2Njc2NjMyFhUHBzY2MzIWFRQHFjMyNjc2MwQ2NTQjIgYHFhYzA4wPEy5hPisdMj1gTwMCKHVLMzouKhMTAggSChkeFzEQEConJyUCAxtQKj1HFgUIITwvDA/+uSw5IjMQAyIl3xgVKBY1RBgYaGogJIWQSjgyPhAOMBIkHjosbisqHx4iLFQdKVA+MysBMDgOeiwnNSYZJCUAAAIAMv/7A3AB0gBDAE4AX0BcNAEKBRIBAglLPA4DCAIJAQAIBEwMAQkKAgoJAoAABwAKCQcKaQAFAAIIBQJqBgEEBBlNDQsCCAgAYQMBAgAAGABOREQAAERORE1JRwBDAEIWJyQWJicUIiYOBx8rJBYVFAcGBiMiJwYjIiY1NSMiJwYVFQ4CIyImNTQ3NjYzMhYVFAcGBzM2NzY2MzIVFA8CNjYzMhYVFAcWMzI2NzYzBDY1NCMiBgcWFjMDYQ8TLmE+KR8uOlpeODIVAgEEFBcmHyUJKSUUEA8IB3wIFQofJi0PBw4bSyc9RxcFCSE8LwwP/rksOSEzEAQiI98YFSgWNUQYGGZUBwIcCxU+MhdQWIJ1HRsKDhA4IS80RB8ZGAo+HjwbI1A+MC4BMDgOei0mNSYYJCYA////9f/lAiwB3QACAgAAAAABACH/+wH8AdIALgCAtRcBAgMBTEuwFVBYQC0AAgMEAwJyCAEHBAUEBwWAAAQABQYEBWcAAwMBYQABARlNAAYGAGEAAAAYAE4bQC4AAgMEAwIEgAgBBwQFBAcFgAAEAAUGBAVnAAMDAWEAAQEZTQAGBgBhAAAAGABOWUAQAAAALgAtITQyJCQlJgkHHSskFhUUBwYGIyImNTQ2NjMyFhUUBiMiJicmJiMiBgcWMzIWFRQGBwcnFjMyNjc2MwHtDxMvgz1kdTVlREtHGh4WEgEBFBckLwolPRUWFRwzLwtjKV8uDA/fGBUmGDo/c19Ld0M8LhsZDQ0SEDEqARUVFRUBAQFcNzcOAAABACP/+wJYAdMAOQDPS7AJUFhAMQsBCgYFBgoFgAACBQAFAgCACQEFBAEAAwUAaQcBBgYIYQAICBlNAAMDAWEAAQEYAU4bS7AuUFhANwAHBgoGBwqACwEKBQYKBX4AAgUABQIAgAkBBQQBAAMFAGkABgYIYQAICBlNAAMDAWEAAQEYAU4bQDwABwYKBgcKgAsBCgkGCgl+AAIFAAUCAIAACQUACVkABQQBAAMFAGkABgYIYQAICBlNAAMDAWEAAQEYAU5ZWUAUAAAAOQA4NjUmIiE0MiUkIhYMBx8rABYVFAcGBiMGBiMiJjU0NjMyFhUUFhYzMjY3IicmJjU0NjMyNyYjIgcGIyImNTQ3NjYzMhYXNjc2MwJKDh0ZNygNeGtKZiQgDhMKJSYqOQhCHhwVFhVAJxBXMS8JCxAQIhVIKV1pCTsvCAYBMxoUMAkJBVlqSUEzKA0LJy4bMzMBARUVFRUBTxEEFhIsFAwQYlkDFgIAAP//AC//+wF3ArAAAgGzAAD//wAB//sBdwKxACIBtAAAAAMFpAHSAAD///8d/jkBawKwAAIBwgAA//8ANf/7AncDPAACAbEAAAACADL/+wMqAdMALgA9AMRLsCFQWLUxAQAFAUwbtTEBAgUBTFlLsA5QWEAkCwgHAwUCAQAKBQBqAAkJBGEGAQQEGU0MAQoKAWEDAQEBGAFOG0uwIVBYQCsLAQgJBQkIBYAHAQUCAQAKBQBqAAkJBGEGAQQEGU0MAQoKAWEDAQEBGAFOG0AwCwEICQUJCAWAAAIABQJYBwEFAAAKBQBqAAkJBGEGAQQEGU0MAQoKAWEDAQEBGAFOWVlAGS8vAAAvPS88ODYALgAtEiIWJiUTIhUNBx4rABYVFAcGBwYGIyImJicjBxUOAiMiJjU0NzY2MzIWFRQHBgczNjYzMhYXNjc2MwQ2NyYmNTQ3IyIGFRQWMwMcDh08SBNwRzlTLQNbAQEEFBcmHyUJKSUUEA8IB1kVckxMXQgvQQgG/tgvCB8hAwUoNSsdATMaFDAJFQNUZTVXNSUVPjIXUFiCdR0bCg4QOCEvUWBpTQMRAs40MRVEJhAQTUY3OgAAAgAB//sCoAHTADwASAFRS7AQUFhAEioBCQU+AQIJFwEEAgwBAwQETBtLsBtQWEASKgEJBT4BAgkXAQQIDAEDBARMG0uwHVBYQBIqAQkFPgEKCRcBBAgMAQMEBEwbQBIqAQkFPgEKCRcBBAgMAQcEBExZWVlLsBBQWEAjCgsIAwIABAMCBGkACQkFYQYBBQUZTQcBAwMAYgEBAAAYAE4bS7AbUFhAKgsBCAIEAggEgAoBAgAEAwIEaQAJCQVhBgEFBRlNBwEDAwBiAQEAABgAThtLsB1QWEAwAAIKCAoCCIALAQgECggEfgAKAAQDCgRpAAkJBWEGAQUFGU0HAQMDAGIBAQAAGABOG0A6AAIKCAoCCIALAQgECggEfgAKAAQHCgRpAAkJBWEGAQUFGU0ABwcAYgEBAAAYTQADAwBiAQEAABgATllZWUAVAABHRUE/ADwAOykiJCInJCYmDAceKyQWFRQHBgYjIiY1NDcjBiMiJjU0NjMyFRQHBhUUFjMyNjcjIiY1NDYzMhc2MzIWBwYHBgYVFBYzMjY3NjMkNyYjIgYVFBYzMjcCkQ8TNGAvKSwGAl2QPk0vKSQCAhwYH0AfDTxHVk02OQsjFBcCAhAPEA8OEzYwCxD+/hQkHCgsJRwNEN8YFSgWPTw6Nh0ir0g7NDwdBAoQCCAqJyRMQEpREQ8TEBlAQFwoExUuOg5VQwsmIxwmAgACACH+OQJvAzwAVABcAKlAFCYBBgNEJBQDCAFQAQIIVwEJAgRMS7AZUFhANwABBwgHAQiACgEIAgcIAn4ABgcDBlgABAQXTQAHBxlNBQEDAwJiAAICGE0LAQkJAGEAAAAbAE4bQDcABAMEhQABBwgHAQiACgEIAgcIAn4ABgcDBlgABwcZTQUBAwMCYgACAhhNCwEJCQBhAAAAGwBOWUAXVVUAAFVcVVsAVABTJSRUJSolKisMBx4rJBYVFAYHBgcGBwYGIyImNTQ2PwI2NTQjIgYGBwYGIyImNTQ3NjcmJjU0MzIXNjc2NjMyFRQHBzI3NjMyFhUUBiMjBgc+AjMyFRQHBgcGBzY3NjMANjcGBhUUMwJgDw4PN2MWCyd8YDNAbpgHHAELDTAwDwsdHyQgBQkqIBwmIAwJDgwlHzsEGQ4gMh8eFCMfhyYeIVFPIUEOAgUMCFJADQr+Zj4bTEMc3RkTFxoKI0UQB9DuPzNHoXYz2gcMEENuPS8hQU0mRoXHBhcSMQEmLikfKg0NWwICHBcaGZfAVWsuQRtcDCBIOEAnCP29doNBaSgnAAIAD//7AoYCgQBBAEwAXkBbEgEGAjIBCgdJOgIICQkBAAgETAADAgOFDAEJCggKCQiABQQCAgAGBwIGaAAHAAoJBwppDQsCCAgAYQEBAAAYAE5CQgAAQkxCS0dFAEEAQBYmJCEUJioiJg4HHyskFhUUBwYGIyInBiMiJjUjJjY3JiY1NDMyFzA3NzY2MzIVFAcHNzYzMhYVFAYjIw4CBzY2MzIWFRQHFjMyNjc2MwQ2NTQjIgYHFhYzAncPEy5hPikfLjpbZwEBCQ8fHCYfDQ4IDCUfOwQYLBQNHhQjH1gHCAMBHEwoPUcXBQkhPC8MD/65LDkhMxAEIiPfGBUoFjVEGBhnUkFQSwYXEjEBMRkpHykODVECAhwXGhkZMSEJHCRQPjAuATA4DnosJzUmGCQmAAAAAgAR//sDlgNQAEwAWgDsS7AmUFhAGFMBBgc6LgIFBk5EJAMDBVkcEgkEBAMETBtAGFMBBgc6LgIFBk5EJAMDCVkcEgkEBAMETFlLsAlQWEAoDAsCAwUEBANyAAcHF00JAQUFBmEIAQYGGU0KAQQEAGICAQIAABgAThtLsCZQWEApDAsCAwUEBQMEgAAHBxdNCQEFBQZhCAEGBhlNCgEEBABiAgECAAAYAE4bQDMMCwIDCQQJAwSAAAcHF00ABQUGYQgBBgYZTQAJCQZhCAEGBhlNCgEEBABiAgECAAAYAE5ZWUAWAAAATABLSEZCQCYmJBMmJCQlJg0HHyskFhUUBwYGIyInBgcGBiMiJyYnBiMiJjU0NjMyFRQHBhUUMzI3JiYnJjU0NjMyFzY3NzY2MzIVFAcGBzYzMhUUBicmBgcWFjMyNjc2MwQ3JjU0NjcjBgcWFRUzA4cPFjRPNX0qFAsPJyo5AwEEYnc3QC4qJAIDGkJoCCYpFh8aPyMcLB0NNSk9ARMGNDZEHRQrOBoGOCsjNjALEP5pJwIOFQUwQgcH3xgVJhtCNJQnICwgSBwukkA1Mj4bBxIkBR7eHBUCAiEZHRpPmGIqJz4LBqO5KzAVHAEBIyxkWy8/DgRGMhsrjZbuoDdaIwADACH/+wJJAdMAGAAqADsAqUAQFAEEAycbAgUEOC0CBwADTEuwLlBYQDEKAQMGBAYDBIAABAgBAAcEAGkABQAHCQUHaQsBBgYCYQACAhlNDAEJCQFhAAEBGAFOG0A4CgEDBgQGAwSAAAAIBwgAB4AABAAIAAQIaQAFAAcJBQdpCwEGBgJhAAICGU0MAQkJAWEAAQEYAU5ZQCArKxkZAAArOys6NzUxLxkqGSklIx4cABgAFyYiFQ0HGSsAFhUUBwYHBgYjIiYmNTQ2NjMyFhc2NzYzJAYHNjMyFhYXFhYzMjY3JiYjEjY3BwYjIiYnJiYjIgcWFjMCOw4dQUMTcEc8VSw6Zj5MXQgxPwgG/q0vCg8ICREJAgwRCxEXEwMpGgUqCxUUDQwPCwkNCQ0MBicYATMaFDAJFQNUZTpgOEx3Q2lNBBACNjIuBQcGAQcICQoxNP78JCEGBgcIBwYGJygAAQAy//sCJwHUACUAKEAlCAEAAhsBAQACTAAAAgECAAGAAwECAhlNAAEBGAFOKicnIwQHGisAFRQGIyInJicGBwYGIyImJyY1NTY2MzIWFRQXNjY3Njc2MzIWFwInHxMKCBQXS0YjQCYqMAYMASIiGhkOKz8lDx8RFyQvGgG2GxQfBAoHsG85Kj9GjGkjIRoXG3O4SntlKAgECAoAAQAO//EB/gHbAEkAkEANMxcCBwE/NwwDBQcCTEuwMFBYQDMAAwIBAgMBgAABBwIBB34IAQcFAgcFfgAFBgIFBn4AAgIEYQAEBBlNAAYGAGEAAAAYAE4bQDAAAwIBAgMBgAABBwIBB34IAQcFAgcFfgAFBgIFBn4ABgAABgBlAAICBGEABAQZAk5ZQBAAAABJAEgnLCYkKiomCQcdKyQWFRQHBgYjIiY1NDcnJiY1NDYzMhcWFzY3NjY1NCYjIgYHBgYjIiY1NDc2NjMyFhUUBgcXFhYVFAcGIyInJicGFRQWMzI2NzYzAe8PEzCKVFhgIBIWDw8OFSwKEBsFKiYWFRMeEgoVCRMVGRROKEtNOzUPFxIBAyIYJAMpCyAoO3UtCxDfGBUlGUBDPUQ2JwgKExILDRIEBA8CFyEXDQ8LCgUJGRQbEw8UNTI5QBsGCxMLBQMRBwEJEBEWEjs2DgAAAAIAJf7QAiAB2wBGAE0AUkBPGgMCAwdJAQgDAkwABQQBBAUBgAABAAQBAH4AAAcEAAd+CQEIAAIIAmUABAQGYQAGBhlNAAcHA2EAAwMYA05HR0dNR0wrJiQrJiskIAoHHiskMzIHNjc2MzIWFRQGBwYHBgcGBiMiJjU0NjcGIyImNTQ2Njc2NjU0JiMiBgcGBiMiJjU0NzY2MzIWFRQGBgcGBhUUFjMyNwI2NwYVFDMBXwsQAUA0CwwNDwwRLWMNDBliPyo3TWksJzdGJTUoKSYWFRMeEgoVCRMVGRROKEtNJDIoKyggKDYxgjAJaBV+JSgnCBgUFRcMHzs8LFpgOCoxYj8NRTYrPScVFiEXDQ8LCgUJGRQbEw8UNTIrOiIUFiAbFhIX/rdMPz43FgAAAAACABH+0AOKAdYAfwCGAmtLsB1QWEAgNwEFBFEBCQUOAQIJQxsCDQIDAQwNfWYCAAOCARAAB0wbQCA3AQUEUQEJBQ4BAglDGwINAgMBDA19ZgIPA4IBEAAHTFlLsAlQWEBFAAUECQQFcgAJAgQJcAACDQMCcAANDAQNDH4ADAMEDAN+EgEQAA4QDmUKAQQEBmEIBwIGBhlNCwEDAwBiEQ8BAwAAGABOG0uwDFBYQEYABQQJBAVyAAkCBAlwAAINBAINfgANDAQNDH4ADAMEDAN+EgEQAA4QDmUKAQQEBmEIBwIGBhlNCwEDAwBiEQ8BAwAAGABOG0uwFVBYQEcABQQJBAVyAAkCBAkCfgACDQQCDX4ADQwEDQx+AAwDBAwDfhIBEAAOEA5lCgEEBAZhCAcCBgYZTQsBAwMAYhEPAQMAABgAThtLsBdQWEBIAAUECQQFCYAACQIECQJ+AAINBAINfgANDAQNDH4ADAMEDAN+EgEQAA4QDmUKAQQEBmEIBwIGBhlNCwEDAwBiEQ8BAwAAGABOG0uwHVBYQFMABQQJBAUJgAAJAgQJAn4AAg0EAg1+AA0MBA0MfgAMAwQMA34SARAADhAOZQAKCgZhCAcCBgYZTQAEBAZhCAcCBgYZTQsBAwMAYhEPAQMAABgAThtAXQAFBAkEBQmAAAkCBAkCfgACDQQCDX4ADQwEDQx+AAwDBAwDfhIBEAAOEA5lAAoKBmEIBwIGBhlNAAQEBmEIBwIGBhlNCwEDAw9iEQEPDxhNCwEDAwBiAQEAABgATllZWVlZQCSAgAAAgIaAhQB/AH54dmtpZGJgXllXT00qJiQkJSYkKScTBx8rJCYmJwYHBgYjIiY1NDY3Iw4CIyImNTQ2MzIVFAcGFRQzMjY2NTQmIyIGBwYGIyImNTQ2MzIWFzY3NjYzMhYVFAcGBzM+AjMyFhUUBiMiJjU0Njc2NTQjIgYGFRQWMzI3NjMyFgc2NzYzMhYVFAYHBgcGBwYGIyImNTQ2NwYjBjY3BhUUMwI3PSsFDBQKFRQYFA0JAh0xTzo3QC4qJAIDGhMjFxINCwoFBhQZFhpBMS9DFwgJCSIiFBAPDwoCGz5NMzQ7JR4TFwQBBRoUJhcyLxkXEQoKCgFANAsMDQ8MES1jDQwZYj8qN1NzEAsdMQpqFQMsRiRUKBIQIiUgYy1QYkRANTI+GwcSJAUeLU4vJDELDRATHyAyO0tNRx4bFAwODjg/ZWFxMkEzKjoSEAcSBA8NGylFKDZCEAwQFSgnCBgUFRcMHzs8LFpgOCoyZEAF1Uw/PjcWAAAAAAIAHv7QAikB2wBSAFkAqkAPRwEEBk0TAgEDVQEJAQNMS7AsUFhAOwAGBQQFBgSAAAQIBQQIfgoBCAIFCAJ+AAIDBQIDfgsBCQAACQBlAAUFB2EABwcZTQADAwFhAAEBGAFOG0A5AAYFBAUGBIAABAgFBAh+CgEIAgUIAn4AAgMFAgN+AAMAAQkDAWkLAQkAAAkAZQAFBQdhAAcHGQVOWUAXU1MAAFNZU1gAUgBRJSMqFSQkKCwMBx4rJBYVFAYHBgcHBgcGBiMiJjU0Njc1BgYjIiY1NDYzMhYXFhYzMjY1NCYnJiY1NDY3NjY1NCYjIgcGBiMiJjU0NjYzMhYVFAYHFhYVFAYHFzY3NjMANjcGFRQzAhoPDBEsViEHDhlTPyo3TG8WHxhHURoXExEJByQmHy4qKxESDhIyLx0cRA4HFhMXGC5XOVBVPTEqNQ8QAVQzDQr+yh4IVBWwGBQVFwwdNRQ1MVtVOCoxXTgCBgRBLhsfEhgTFhoZHBoEARcPFBIDCS8hExYyFxMaFiE8JT49KEURBDIjFSUMBEYjCP5+P0A4MRYAAAACADL+0AJ6AdIAUQBYAKRAFyQBAwQYAQcDAgEFBlE6AgAFVAEJAAVMS7AJUFhANQADBAcEA3IABwYEBwZ+AAYFBAYFfgAFAAQFAH4KAQkACAkIZQAEBAFhAgEBARlNAAAAGABOG0A2AAMEBwQDB4AABwYEBwZ+AAYFBAYFfgAFAAQFAH4KAQkACAkIZQAEBAFhAgEBARlNAAAAGABOWUASUlJSWFJXKyUjJSgkKiYmCwcfKyQmJwYHBgYjIiY1NDc2NjMyFhUUBw4CBzY2MzIWFRQGIyImNTQ2NzY1NCMiBgYVFBYzMjY3NjMyFgc2NzYzMhYVFAYHBgcGBwYGIyImNTQ2NwY2NwYVFDMBJE4KAg0LHR4mHyUJKSUUEA8CDQsCJG5ONDslHhMXBAEFGhQmFzAlChIMDwwKCgFANAsMDQ8MES1jDQwZYj8qN1FvMDAJaBULRCoIMCgeUFiCdR0bCg4QOAcyQyiMeEEzKjoSEAcSBA8NGylFKDREBwkMEBUoJwgYFBUXDCA6PCxaYDgqMmQ+2Ew/PjcWAAAAAQAy//sCZgHSAFEAhkANMgEFA1AkGwUEBwgCTEuwCVBYQC0ABQMIBgVyAAgHAwgHfgADAAABAwBpAAYGAmEEAQICGU0ABwcBYQkBAQEYAU4bQC4ABQMIAwUIgAAIBwMIB34AAwAAAQMAaQAGBgJhBAECAhlNAAcHAWEJAQEBGAFOWUAOTkwjJSgkKCsmJiEKBx8rNgYjIiYnIw4CIyImNTQ3NjYzMhYVFAcOAgczNjYzMhYVFAczPgIzMhYVFAYjIiY1NDY3NjU0IyIGBhUUFjMyNjc2MzIWFRQHBgYjIiYnJ+QNCwoLBQMDCxYUJh8lCSklFBAPAg0LAgMOEw0JBgQDFDI7KjhBJR4TFwQBBRoUJBYwLiU6MwwPDQ8TL1g5RE4ZAkMaGiouMBRQWIJ1HRsKDhA4CC89JEQqCxMcM2hrJEEzKjoSEAcSBA8NGyhFKTZBMT0OGBUoFjhBMzcBAAEANf/7AloDPABZANdADxgBBQJGAQcIOgsCCQoDTEuwCVBYQDMABwgKCAdyCwEKCQgKCX4EAQIABQYCBWgAAwMXTQAICAZhAAYGGU0ACQkAYQEBAAAYAE4bS7AZUFhANAAHCAoIBwqACwEKCQgKCX4EAQIABQYCBWgAAwMXTQAICAZhAAYGGU0ACQkAYQEBAAAYAE4bQDQAAwIDhQAHCAoIBwqACwEKCQgKCX4EAQIABQYCBWgACAgGYQAGBhlNAAkJAGEBAQAAGABOWVlAFAAAAFkAWFVTKCQpJDUlKycmDAcfKyQWFRQHBgYjIiYmJwYHBgYjIiY1NDc2NjcmJjU0MzIXNjc2NjMyFhUUBwc2MzIWFRQGIyMGBgcHBgYHNjYzMhYVFAYjIiY1NDY3NjU0IyIGBhUUFjMyNjc2MwJLDxMtWjkvTTAHAg0LHR4mHwQFGxMgHCYgDAkODCUfHhwDFUwvHhQjH4YKGwcGBwwBJG5ONDslHhMXBAEFGhQmFzIvJTozDA/fGBUoFjZDKTobCDAoHlBYLydCr1cGFxIxASYuKR8VFgsOWwQcFxoZJXQiHihMIIx4QTMqOhIQBxIEDw0bKUUoNkExPQ4AAAAAAQAp//sCrAHoAFABVUuwG1BYQAs9AQcCMQsCCQoCTBtACz0BBwgxCwIJCgJMWUuwCVBYQC0ABwIKAgdyCwEKCQIKCX4AAwMZTQgBAgIEYQYFAgQEGU0ACQkAYQEBAAAYAE4bS7AXUFhALgAHAgoCBwqACwEKCQIKCX4AAwMZTQgBAgIEYQYFAgQEGU0ACQkAYQEBAAAYAE4bS7AbUFhALgADBAOFAAcCCgIHCoALAQoJAgoJfggBAgIEYQYFAgQEGU0ACQkAYQEBAAAYAE4bS7AmUFhANQADBAOFAAIECAQCCIAABwgKCAcKgAsBCgkICgl+AAgIBGEGBQIEBBlNAAkJAGEBAQAAGABOG0A5AAMFA4UAAgQIBAIIgAAHCAoIBwqACwEKCQgKCX4ABAQZTQAICAVhBgEFBRlNAAkJAGEBAQAAGABOWVlZWUAUAAAAUABPTEooJCojIycUJyYMBx8rJBYVFAcGBiMiJiYnBgcGBiMiJjU0NyYmJyYmNTQ2MzIXFhYzMjc2NjMyFhUUBw4CBzY2MzIWFRQGIyImNTQ2NzY1NCMiBgYVFBYzMjY3NjMCnQ8TLVo5L00wBwINCx0eJh8bISkXDw4fEwoIGisXEAkHGQgUDg8CDQsCJG5ONDslHhMXBAEFGhQmFzIvJTozDA/fGBUoFjZDKTobCDAoHlBYb2YCBwkGGA0UHwQOCgEBBAoOEDgHMkMojHhBMyo6EhAHEgQPDRspRSg2QTE9DgAAAgAy/tACagHSAE4AVQBSQE9KEwICBlEBCQICTAoBCAEGAQgGgAcBBgIBBgJ+AAQAAQgEAWgLAQkAAAkAZQUBAwMZTQACAhgCTk9PAABPVU9UAE4ATSIaJRYmJiwrDAceKyQWFRQGBwYHBgcGBiMiJjU0NjY3NSYmJzQ3IicGFRUOAiMiJjU0NzY2MzIWFRQHBgczNjc3NjYzMhYVFAYHBgYVFBYzMjYzMhYHNjc2MwA2NwYVFDMCWw8MES1jDQwZYj8qNyNdVR0iAgNWIQIBBBQXJh8lCSgmFBAPCAd/AxALCCEhFxISCwkPCgoECgUHBwFANAsM/sswCWgVsBgUFRcMIDo8LFpgOCokQVAzAgQ5LyISAhwLFT4yF1BYgnUdGwoOEDghLw4+LB4aCw8RXDApSwsTDwIOFSgnCP5+TD8+NxYAAQAy//sCXAHsAEEAPEA5AAYDBoUJAQgEAQQIAYAABAABBwQBaAUBAwMZTQAHBwBhAgEAABgATgAAAEEAQCwjFBYmJiQmCgceKyQWFRQHBgYjIiY1NDciJwYVFQ4CIyImNTQ3NjYzMhYVFAcGBzM2NzY2NzY3NjMyFhUUBwYHBwYGFRQWMzI2NzYzAk0PEy5hPjQqBVgiAgEEFBcmHyUJKCYUEA8IB4AKEwceHSkeCAoUHh0fJRELEhANFDcuDA/fGBUoFjVEQEAbJgIcCxU+MhdQWIJ1HRsKDhA4IS8vSRwbAQcPBB4VGwwNA1IwXBMTFTE3DgAAAAACADL+0AJ/AdIATgBVAE5ASx0BBgBKMgIBBFEBCAEDTAAAAgYCAAaAAAYEAgYEfgUBBAECBAF+CQEIAAcIB2UDAQICGU0AAQEYAU5PT09VT1QrJSIZKiYlJQoHHiskNjc2NTQjIgYGBwYGIyImNTQ3NjYzMhYVFAcGBgc+AjMyFRQGBwYGFRQWMzI2MzIWBzY3NjMyFhUUBgcGBwYHBgYjIiY1NDY2NzUmJjUSNjcGFRQzASsMAQ0LDS8xDwsdHyYfJQkpJRQQDwoMBCFSTyFBCwwBEQoKBAoFBwcBQDQLDA0PDBEtYw0MGWI/KjcjXVUfKQIwCWgVjj4IOxoQQ249LyFQWIJ1HRsKDhA4KDwsVmwuQRg/NQZNFhMPAg4VKCcIGBQVFwwgOjwsWmA4KiRBUDMCBTEp/rNMPz43FgAAAAIAIf/7Ar8B0gA1AEEAQUA+ODAkAwMFCQEAAwJMBwEFBgMGBQOAAAQABgUEBmkAAgIZTQADAwBiAQEAABgATgAAPz0ANQA0Ji4lIiYIBxsrJBYVFAcGBiMiJwYjJiY1NDY2MzIWFRQGBwYGBw4CFRQWMzI3JjU0NjYzMhYVFAYHNjY3NjMEFhc2NjU0JiMiBhUCsA8TJYdNNSk3OFxpO2U7FhkNEQYVCxIiFistEAgRLFA1OkIqJSxeJAwP/sAGCCgwFRMcIt8YFSgWLUwTEwFyYUh3RBkVFhgEAQECBClCKEA5ASk+NmM8TjgwXSYJOiwOLCgOFkUsGhs+KAAAAAACACD+0AIWAdIAPgBFAJVADwwBAQI4IQIHA0EBCAcDTEuwCVBYQDIAAQIFAgFyAAUEAgUEfgAEAwIEA34JAQgABggGZQACAgBhAAAAGU0AAwMHYQAHBxgHThtAMwABAgUCAQWAAAUEAgUEfgAEAwIEA34JAQgABggGZQACAgBhAAAAGU0AAwMHYQAHBxgHTllAET8/P0U/RCYrJCMkKSQiCgceKxI2NjMyFhUUBiMiJjU0Njc2NTQmIyIGBhUUMzI2NzYzMgc2NzYzMhYVFAYHBgcGBwYGIyImNTQ2NwYjIiYmNRI2NwYVFDMgQGY4Nz0lHhMXBAEFDQwXKBhlDh0YDgsQAUA0CwwNDwwRLWMNDBliPyo3TWkUEi9MKqUwCWgVARZ6QkEzKjoSEAcSBA8NDQ4pRip0CAwHJSgnCBgUFRcMHzs8LFpgOCoxYj8ENls0/mlMPz43FgAAAAACADL+0AN3AdIAZQBsAFdAVDgtAgkAYUkCAQdoAQsBA0wCAQAECQQACYAACQcECQd+CAEHAQQHAX4MAQsACgsKZQYFAgQEGU0DAQEBGAFOZmZmbGZrW1lOTCIWKComJSclJQ0HHyskNzY2NTQjIgYGBwYGIyImNTQ3NjU0IyIGBgcGBiMiJjU0NzY2MzIWFRQHBgYHPgIzMhYVFAcGBzY2MzIVFAcGFRQzMjYzMhYHNjc2MzIWFRQGBwYHBgcGBiMiJjU0NjY3NSYmNRI2NwYVFDMCJAwBDAsNMDAPCx0gISEKCAsPLisNCx0fJh8lCSklFBAPCgwEG0tPIyMdEwgDMno1QRcSFAQKBQcHAUA0CwwNDwwRLWMNDBliPyo3I11VHygBMAloFYxACEITEENuPTAgPy0mSEAUEEhwNi8hUFiCdR0bCg4QOCg7LE5sNSAhIFQkEntwQSdrTBofAg4VKCcIGBQVFwwgOjwsWmA4KiRBUDMCBTEp/rNMPz43FgABADT+sQJfAdMAOgBxS7AJUFhADx8BAAMsCwIBACoBAgEDTBtADx8BAAMsCwIBBSoBAgEDTFlLsAlQWEAVAAIBAoYFAQAAAQIAAWoEAQMDGQNOG0AcAAADBQMABYAAAgEChgAFAAECBQFqBAEDAxkDTllACRQsLCsmEQYHHCsAMzIWFRQGBwYjIicGBwcGBgcWFxYGIyImJyYnJyYnJyY1NDYzMhYXFhYXNjcmNTQ2NjMyFhUUBzY3NwI5Bw8QGBguNC8jHx4MFiQWDAUBJh0bHgEIFAMHFgYBICAaGwUNDgYiOhEeNCEdJBgmPxsBMRQRHyMIDww2KxEfLBN1jSEbFhuI5SNOpSkGCx0XHCdXf142bx8pIkAoKSctOgINBQABAA/+sQJfAdMASgDlS7AJUFhAFC8BAAc8CwIBADoBAgErEAIDAgRMG0uwJlBYQBQvAQAHPAsCAQk6AQIBKxACAwIETBtAFC8BAAc8CwIBCToBAgErEAIFAgRMWVlLsAlQWEAfAAQDBIYJAQAAAQIAAWoGAQIFAQMEAgNqCAEHBxkHThtLsCZQWEAmAAAHCQcACYAABAMEhgAJAAECCQFqBgECBQEDBAIDaggBBwcZB04bQCsAAAcJBwAJgAAEAwSGAAkAAQIJAWoABQMCBVoGAQIAAwQCA2oIAQcHGQdOWVlADkhHLCkjJCQkJyYRCgcfKwAzMhYVFAYHBiMiJwYHBgYHNjMyFhUUBiMjFhcWBiMiJicmJycmJjU0MzIXJyYnJyY1NDYzMhYXFhYXNjcmNTQ2NjMyFhUUBzY3NwI5Bw8QGBguNC8jHx4GJBMdFR4UIx87BwQBJh0bHgEGCR4fHCYfDAgHFgYBICAaGwUNDgYiOhEeNCEdJBgmPxsBMRQRHyMIDww2Kwg0FQMcFxoZYlshGxYbbl8BARsTMQFjTqUpBgsdFxwnV39eNm8fKSJAKCknLToCDQUAAAACABH+0ALAAdYAXQBkATlLsCZQWEAUPAEFByABDQNZFhIDAQRgAQ4BBEwbQBQ8AQUHIAENA1kWEgMBBGABDgIETFlLsAlQWEBDAAMGDQQDcg8BDQwGDQx+AAwEBgwEfhABDgAADgBlCgEFBQdhCAEHBxlNCQEGBgdiCAEHBxlNCwEEBAFiAgEBARgBThtLsCZQWEBEAAMGDQYDDYAPAQ0MBg0MfgAMBAYMBH4QAQ4AAA4AZQoBBQUHYQgBBwcZTQkBBgYHYggBBwcZTQsBBAQBYgIBAQEYAU4bQEgAAwYNBgMNgA8BDQwGDQx+AAwEBgwEfhABDgAADgBlCgEFBQdhCAEHBxlNCQEGBgdiCAEHBxlNAAEBGE0LAQQEAmIAAgIYAk5ZWUAgXl4AAF5kXmMAXQBcV1VTUUxKRkQkJCQlJiQiJisRBx8rJBYVFAYHBgcGBwYGIyImNTQ2NwYjIicGIyImNTQ2MzIVFAcGFRQzMjY2NTQmIyIGBwYGIyImNTQ2MzIWFzY2MzIWFRQGIyImJyYmIyIGBhUUFjMyNzYzMhYHNjc2MwA2NwYVFDMCsQ8MES1jDQwZYj8qN1JxHhg+IzhLN0AuKiQCAxoTIxcSDQsKBQYUGRYaPjEqRBIeSyQnKSIYFhAEAggKDBsTLiAZFxEKCgoBQDQLDP7LMQpqFbAYFBUXDB87PCxaYDgqMmVABz1DQDUyPhsHEiQFHi1OLyQxCw0QEx8gMzopJygoJCgtMxIRDAwtSigtNxAMEBUoJwj+fkw/PjcWAAADADD+0AJcAoMAEABbAGIAu0uwDlBYQBAxAQkEUSIeAwMFXgEKAwNMG0ATMQEJBCIBBwVRHgIDB14BCgMETFlLsA5QWEAsAAkEBQQJBYAAAAsBAQQAAWcMAQoAAgoCZQYBBAQZTQgHAgUFA2IAAwMYA04bQDMACQQFBAkFgAgBBwUDBQcDgAAACwEBBAABZwwBCgACCgJlBgEEBBlNAAUFA2IAAwMYA05ZQCBcXAAAXGJcYVZUT01LSkE/OzkvLSYkGBYAEAAMUw0HFysSJjU0Mzc2MzIWFRQGIyIHBwAHBgcGBiMiJjU0NjY3NSYmNQYGIyImNTQ2NzY2MzIWFRQHBgcGFRQWMzI2NzY2MzIWFRQHBgYVFBYzMjYzMhYHNjc2MzIWFRQGBwA2NwYVFDOzHlNHUh4eHCIwRVQhAUVjDQwZYj8qNyNdVR0hEEMpLDoUFwolJhUSCwoGFAoLG0wgCCIgFxIZCxIKCgQKBQcHAUA0CwwNDwwR/swwCWgVAiYTEjICBBUNGRwEAf4GOzwsWmA4KiRBUDMCBTkuQUxSP0p9Rx8ZDQ8ILiUeaiIUEph3HxkLDxhsLVgTEw8CDhUoJwgYFBUXDP7iTD8+NxYAAAL/9f7QAt4CDQBSAFkAa0BoCgUCAAM5AQEFUAEJAVUBCgkETAACBAKFAAcABgAHBoAABgUABgV+AAEFCQUBCYAAAwAABwMAaQwBCgAICghlAAQEGU0ABQUJYgsBCQkYCU5TUwAAU1lTWABSAFErJCIoJCMrKCYNBx8rBCY1NDY3BiMiJicGBwYGBwYjIiY1NDc3Njc2Njc2MzIXFhYzMjY2NzYzMhYVFAcGBhUUMzI3NjMyBzY3NjMyFhUUBgcGBwYHBgYjIiY1NDY3BiMWNjcGFRQzASxEWVQSGyAvDRkoJD8pEhQQFA4aMRgWJxUTPy0SCyEjESIbBB0NERQkYU8+Pi4OCxABQDQLDA0PDBEtYw0MGWI/KjdNaSslKjAJaBUJTDtEZzoHIiJwQDpJKBIXERQRHzcpJVtLQykYFwgKAQwUFC4cS1ksMhcHJSgnCBgUFRcMIDo8LFpgOCoxYj8NyUw/PjcWAAH/9f/xAsECKQBTAKVADDMBBgcbGQ0DAQYCTEuwMFBYQD0ABQQFhQAGBwEHBgGAAAECBwECfgoBCQIIAgkIgAADCAAIAwCAAAQAAgkEAmkABwcZTQAICABiAAAAGABOG0A6AAUEBYUABgcBBwYBgAABAgcBAn4KAQkCCAIJCIAAAwgACAMAgAAEAAIJBAJpAAgAAAgAZgAHBxkHTllAEgAAAFMAUigiGBcrKyQXJgsHHyskFhUUBwYGIyImNTQ2NwYGIyMHBgYjIjU0NyYnBgcGBgcGIyImNTQ3NzY3NjY3NjMyFxYXNjc2NjMyFxYVFAcGFTY3NjMyFhUUBwYGFRQzMjY3NjMCsg8TL45HVVlcUQkrDQUHChQNHBIODRkoJD8pEhQQFA4aMRgWJxUTPy0SBgQQDQ0TCgQIDBQCKzobDBEUJGFPPi96KgsQ3xgVJRk+RUdGPW46AwQLEg8WESESFnBAOkkoEhcRFBEfNyklW0tDKQ4FIRQUDwIDFBk7BAMBFAoUFC4cS1ksMj00DgADADX+0AKFA6wATwBZAGAAbUBqUzQCAQQ2AQcBSxMCAgVcAQkCBEwAAQQHBAEHgAoBBwUEBwV+BgEFAgQFAn4AAwsBCAQDCGkMAQkAAAkAZQAEBBlNAAICGAJOWlpQUAAAWmBaX1BZUFgATwBOSUdFRDs5Ly0lIx8dKw0HFyskFhUUBgcGBwYHBgYjIiY1NDY2NzUmJjU0Njc2NTQjIgYGBwYjIiY1NDc3NBI2MzIWFRQGBwYVPgIzMhUUBgcGBhUUFjMyNjMyFgc2NzYzAAYGBzY2NTQmIxI2NwYVFDMCdg8MES1jDQwZYj8qNyNdVR8pCwINCw0wMA8TSx4TAQE/e1YuOXaFAyFRTyFBDAsBEQoKBAoFBwcBQDQLDP63LCkNPlEODQEwCWgVsBgUFRcMHzs8LFpgOCokQVAzAgUxKRI+CDsbEENuPVArOCATUJoBTuNPP2XZkTQ3VWsuQRlANAdMFRMPAg4VKCcIAplnr2dJrEYgIvvlTD8+NxYAAP//ADX/+wJ3A6wAAgGwAAAAAgAJ//sCZAHSACsANQBEQEEuJBkDAwQBTAABBQQFAQSABgEEAwUEA34HAQUFAmEAAgIZTQADAwBhAAAAGABOLCwAACw1LDQAKwAqJiopJggHGiskFhUUBwYGIyImJyYnJiY1NDYzMhcWFhcWFxc+AjMyFhUUBgcWMzI2NzYzJAYVFTY2NTQmIwJVDxMlh01VbRIwFxgcFhARCgkMAwQRBAM6Zj86RmN2GUYtcyoMD/7fMztEFRLfGBUoFi1MS0QFCAgkGBodBQUNDQ4EAUNxQ0U7RWMdLj8zDpFWPQIOOCUTFwAAAgAJ/wYCZAHSAEAASgCiS7ASUFhADEM5LgMFBhwBAAUCTBtADEM5LgMFBhwBAQUCTFlLsBJQWEArAAMHBgcDBoAIAQYFBwYFfgAFAAcFAH4BAQAAAgACZgkBBwcEYQAEBBkHThtAMQADBwYHAwaACAEGBQcGBX4ABQEHBQF+AAEABwEAfgAAAAIAAmYJAQcHBGEABAQZB05ZQBVBQQAAQUpBSQBAAD8mKi4lIisKBxwrJBYVFAcGBgcGFRQWMzI3NjMyFRQHBgYjIiY1NDcmJicmJyYmNTQ2MzIXFhYXFhcXPgIzMhYVFAYHFjMyNjc2MyQGFRU2NjU0JiMCVQ8THWc9NyQaGhURChovDCcQRVEqPE8OMBcYHBYQEQoJDAMEEQQDOmY/OkZjdhlGLXMqDA/+3zM7RBUS3xgVKBYkQwwsOh0eBwYlKBAEBkc9QTUMRzcFCAgkGBodBQUNDQ4EAUNxQ0U7RWMdLj8zDpFWPQIOOCUTFwAAAAEAIv/7ARgDHAAUACBAHQwCAgEAAUwAAAEAhQIBAQEYAU4AAAAUABMpAwcXKxYmNTQ3NhI3NjYzMhUUBwYCBwYGIzoYAgdXFQglKSsCGVYFAiIkBRocCBRRAe9XHxkjBQ52/g1IIBr//wAR//sDTgL0ACIEOgAAAAMF4wLdAAD//wAy/tACegHSAAIEagAAAAEAAf9LApoB0ABAAOBLsCZQWEAKGAECBBMBAQMCTBtAChgBAgQTAQEFAkxZS7AJUFhAHwcGAgIEAwMCcgUBAwMBYgABARhNAAAABGEABAQZAE4bS7AQUFhAIAcGAgIEAwQCA4AFAQMDAWIAAQEYTQAAAARhAAQEGQBOG0uwJlBYQCYAAgQGBAIGgAcBBgMEBgN+BQEDAwFiAAEBGE0AAAAEYQAEBBkAThtALQACBAYEAgaABwEGAwQGA34ABQMBAwUBgAADAwFiAAEBGE0AAAAEYQAEBBkATllZWUAPAAAAQAA/JiclJC4rCAccKyQWFRQHBgcGBgcGBiMiJjU0NzY3JiY1NDcjBgYjIiY1NDYzMhYHBhUUMzI2NzY2NzY2MzIWFQcGFRQzMjY3NzYzAosPEyAVNTAdGyQZFBkQICInIgQCKHVLMzouKhMTAggSChkeFzEQEConJiQCBCsSIyUZDA/fGBUoFiYUNkAvKx8YEhUWKzUOW08uK4WQSjgyPhAOMBIkHjosbisqHx4iSlQlaSItHg4A//8AMv7QAmoB0gACBG4AAAABADL/SwJcAdIARQBDQEATAQIGAUwIAQcEAQQHAYAABgECAQYCgAAAAgCGAAQAAQYEAWgFAQMDGU0AAgIYAk4AAABFAEQoJBYmJisrCQcdKyQWFRQHBgcGBgcGBiMiJjU0NzY3JiY1NDciJwYVFQ4CIyImNTQ3NjYzMhYVFAcGBzM2NzY2MzIWFRQHBhUUFjMyNjc2MwJNDxMdGzUwHRskGRQZECEgIRwFWCICAQQUFyYfJQkoJhQQDwgHgAoTCCEhFxIZHBANFDcuDA/fGBUoFiMYNUAvKx8YEhUWLDMKPTUbJgIcCxU+MhdQWIJ1HRsKDhA4IS8vSR4aCw8ZcIAeExUxNw4AAAAB//X/hwKtAg0ASgCQQAscFwICBQ8BAQMCTEuwMFBYQDMABAYEhQkBCAIHAggHgAADBwEHAwGAAAABAIYABQACCAUCaQAGBhlNAAcHAWEAAQEYAU4bQDEABAYEhQkBCAIHAggHgAADBwEHAwGAAAABAIYABQACCAUCaQAHAAEABwFpAAYGGQZOWUARAAAASgBJKCQjKygmJSkKBx4rJBYVFAcGBw4CIyImNTQ3BiMiJjU0NjcGIyImJwYHBgYHBiMiJjU0Nzc2NzY2NzYzMhcWFjMyNjY3NjMyFhUUBwYGFRQzMjY3NjMCng8TKUALEBcUFRcCFhVVWVlUEhsgLw0ZKCQ/KRIUEBQOGjEYFicVEz8tEgshIxEiGwQdDREUJGFPPi96KgsQ3xgVJRk2JD48GSYlFgwDR0ZEZzoHIiJwQDpJKBIXERQRHzcpJVtLQykYFwgKAQwUFC4cS1ksMj00DgAAAAEAAf9LA18B0wBeAOtLsAlQWEAQKBgCAwVINQIEAxQBAQQDTBtLsCZQWEAQKBgCAwVINQIECBQBAQQDTBtAECgYAgMFSDUCBAgUAQEHA0xZWUuwCVBYQCEJCAIDBQQEA3IHAQQEAWICAQEBGE0AAAAFYQYBBQUZAE4bS7AmUFhAKAADBQgFAwiACQEIBAUIBH4HAQQEAWICAQEBGE0AAAAFYQYBBQUZAE4bQC8AAwUIBQMIgAkBCAQFCAR+AAcEAQQHAYAABAQBYgIBAQEYTQAAAAVhBgEFBRkATllZQBgAAABeAF1bWVBOREI8OjQyLiwhHywKBxcrJBYVFAcGBw4CBwYGIyImNTQ3NjcmNTQ3IwYGBwcGBiMiJicmJjU0NyMOAiMiJjU0NjMyFRQHBhUUMzI2NzY3NjYzMhYVFBczNjY3NjYzMhYVFAYHBhUUFjMyNzYzA1APExsZLzIdBRskGRQZECUgNRACGSwbEQseFRYUCAkMAwIZMFI/NTkuKigBCA8OHBkiHgonIRwlBwIRSBUTJxgkGgIBBBAWKD0LEN8YFSkWIBgvQS4IKx8YEhUWMjMddENjK2xKLR4VGBoeaTYhHmF9T0o4MkMbBQMwFCIpRV1hHx0WGZFMOZQXFBUfKhctE0okOShpEgAAAP//ACP/+wJXAvQAIgQwAAAAAwXjAl8AAP//ACP/+wJXArEAIgQwAAAAAwWkAl8AAP//ACT/+wMOAdQAAgGGAAD//wAh//sCCgL0ACIENwAAAAMF4wI1AAAAAgAY//sCTQHTACkAMwC+S7AJUFhAKgoBBwMCAwcCgAYBAggBAAkCAGkEAQMDBWEABQUZTQsBCQkBYQABARgBThtLsC5QWEAwAAQDBwMEB4AKAQcCAwcCfgYBAggBAAkCAGkAAwMFYQAFBRlNCwEJCQFhAAEBGAFOG0A1AAQDBwMEB4AKAQcGAwcGfgAGAgAGWQACCAEACQIAaQADAwVhAAUFGU0LAQkJAWEAAQEYAU5ZWUAYKioAACozKjIuLAApACgSJiIhNiIWDAcdKwAWFRQHBgYjBgYjIiY1NDc2NjMyNyYjIgcGIyImNTQ3NjYzMhYXNjc2MwQ2NwcnBhUUFjMCPw4dGTcoDXhrSmYPCCMioigQVzEvCQsQECIVSCldaQk7LwgG/so5CDODBSUrATMaFDAJCQVZaklBOCoXFgFPEQQWEiwUDBBiWQMWAtszNAECGQ8gIP//ABj/+wJNArEAIgSKAAAAAwWkAjIAAP//ABH/+wNOArEAIgQ6AAAAAwWkAt0AAP///9b+OQIgArEAIgQ7AAAAAwWkAhIAAAAC/9b+OQIgAdcAPABFAG1ACT04NhIEBgUBTEuwF1BYQCAHAQUBBgEFBoAAAQECYQQDAgICGU0ABgYAYQAAABsAThtAJAcBBQEGAQUGgAADAxlNAAEBAmEEAQICGU0ABgYAYQAAABsATllAEAAAQkAAPAA7I0EkLysIBxsrJBYVFAcGBxYVFAYGIyImNTQ2NyYmJyYmNTQ2NjcHBiY1NDYzMhcWFjMyNzY2MzIWFRQGBwYGBxYXNjc2MwEGFRQzMjY2NQIRDxxrXwdFc0A3PGaACR8aJCA5YjqqFhcXFC5NEFUdChwFHQoQFR4gX3EcRSVdfQ0K/syYHBg7Kd0YFCsQPUEcJlyxcD04VaBkDRQMECYXHFRVHgQBIRcYJQcBBggBCBwdICQOKGI9FihBTQj+y4BpKFl+MP//ADD/+wJPAnIAIgQ8AAAAAwWvAlAAAP//ADD/+wJPArEAIgQ8AAAAAwWkAlEAAP//ACH/+wJJArEAIgRFAAAAAwWkAjEAAAADACH/+wJJAdMAGAAfACYAirUUAQQDAUxLsC5QWEApCAEDBQQFAwSAAAQGAQAHBABpCQEFBQJhAAICGU0KAQcHAWEAAQEYAU4bQDAIAQMFBAUDBIAAAAQGBAAGgAAEAAYHBAZnCQEFBQJhAAICGU0KAQcHAWEAAQEYAU5ZQBwgIBkZAAAgJiAlIyIZHxkeHBsAGAAXJiIVCwcZKwAWFRQHBgcGBiMiJiY1NDY2MzIWFzY3NjMkBgc3JiYjEjY3IxYWMwI7Dh1BQxNwRzxVLDpmPkxdCDE/CAb+ry4KmQYmFwYrC5YHJxcBMxoUMAkVA1RlOmA4THdDaU0EEAI2LCgFJin+/CYlJCcAAAD//wAh//sCSQKxACIEkgAAAAMFpAIwAAD//wAj//sCWAKxACIEWgAAAAMFpAJBAAD////8/jkCTAJyACIESgAAAAMFrwJQAAD////8/jkCTAKxACIESgAAAAMFpAJRAAD////8/jkCTANEACIESgAAAAMFqAJRAAD////1//ECrQLFACIETgAAAQcFpALZABQACLEBArAUsDUrAAD//wAl/tACIAHbAAIEZwAA//8ANP/7Az8CsQAiBFUAAAADBaQCzAAAAAIADv7QAiAB2wBbAGIAc0BwREAkGQQJAkwBBglXEgIBB14BCgEETAAEAwIDBAKAAAIJAwIJfgsBCQYDCQZ+AAYIAwYIfgAIBwMIB34MAQoAAAoAZQADAwVhAAUFGU0ABwcBYQABARgBTlxcAABcYlxhAFsAWiInLCYkKiomKw0HHyskFhUUBgcGBwYHBgYjIiY1NDY3BiMiJjU0NycmJjU0NjMyFxYXNjc2NjU0JiMiBgcGBiMiJjU0NzY2MzIWFRQGBxcWFhUUBwYjIicmJwYVFBYzMjc2MzIHNjc2MwA2NwYVFDMCEQ8MES1jDQwZYj8qN01pLCc3RiASFg8PDhUsChAbBSomFhUTHhIKFQkTFRkUTihLTTs1DxcSAQMiGCQDKQsgKDYxDgsQAUA0Cwz+yzAJaBWwGBQVFwwfOzwsWmA4KjFiPw1FNjYnCAoTEgsNEgQEDwIXIRcNDwsKBQkZFBsTDxQ1MjlAGwYLEwsFAxEHAQkQERYSFwclKCcI/n5MPz43FgD//wAR/tACwAHWAAIEdgAAAAEAEf/7ApIB1gBXAVNLsCZQWEAONQEGCBQBBAIKAQADA0wbQA41AQYIFAENAgoBAAMDTFlLsAlQWEA4EA8CAgUEAwJyDAEFDQEEAwUEaQsBBgYIYQkBCAgZTQoBBwcIYgkBCAgZTQ4BAwMAYgEBAAAYAE4bS7AdUFhAORAPAgIFBAUCBIAMAQUNAQQDBQRpCwEGBghhCQEICBlNCgEHBwhiCQEICBlNDgEDAwBiAQEAABgAThtLsCZQWEA+EA8CAgUEBQIEgAAMBQQMWQAFDQEEAwUEaQsBBgYIYQkBCAgZTQoBBwcIYgkBCAgZTQ4BAwMAYgEBAAAYAE4bQD8QDwICBQ0FAg2AAAwADQQMDWkABQAEAwUEaQsBBgYIYQkBCAgZTQoBBwcIYgkBCAgZTQ4BAwMAYgEBAAAYAE5ZWVlAHgAAAFcAVlNRTk1JR0VDPz05NyQkIhMiJiQjJhEHHyskFhUUBwYGIyImJwYjIiY1NDYzMhUUBwYVFDMyNjcjBiY1NDcmJiMiBgcGBiMiJjU0NjMyFhc2NjMyFhUUBiMiJicmJiMiBgczMhYVFAYjIxYWMzI2NzYzAoMPEyxpQjNPFzlON0AuKiQCAxoUJQoEGh5GARENCwoFBhQZFho+MSpEEh5LJCcpIhgWEAQCCAoLGwkTHhwiMAYBLSYnRS4MD98YFSgWNEUmI0hANTI+GwcSJAUeMSgBExIuBCIuCw0QEx8gMzopJygoJCgtMxIRDAwpIRUNGRwuMjU4DgAAAAEAFf/7Af0B2wA4AEdARA0BBwQBTAACAwQDAgSACAEHBAUEBwWAAAQABQYEBWkAAwMBYQABARlNAAYGAGEAAAAYAE4AAAA4ADckJCQkJSsmCQcdKyQWFRQHBgYjIiY1NDY3JiY1NDY2MzIWFhUUBiMiJicmJiMiBhUUFjMyFhUUBiMiBhUUFjMyNjc2MwHuDxMoj2BmWDEyGhwoTTYmPyMYFQ0QDQ0ZFR8gJCUWFBIRMjAjKUF7LAwP3xgVKBYvSkVBJjsNDTwfIz0kGiwZExYJCw0NHRceGBQXERQeGhgYPTUOAAIAAf7QAt4B0ABOAFUBZ0uwCVBYQBBHKAIFBx8HAgMIUQEJAwNMG0uwHVBYQBBHKAIFBx8HAgMGUQEJAwNMG0uwJlBYQBBHKAIFBx8HAgMGUQEJBANMG0AQRygCBQcfBwIDCFEBCQQDTFlZWUuwCVBYQDEABQcBAAVyAAEABwEAfgoBCAADAAgDgAsBCQACCQJlAAcHGU0GAQAAA2IEAQMDGANOG0uwHVBYQDEABQcBBwUBgAABAAcBAH4AAAYHAAZ+CwEJAAIJAmUABwcZTQoIAgYGA2IEAQMDGANOG0uwJlBYQDUABQcBBwUBgAABAAcBAH4AAAYHAAZ+CwEJAAIJAmUABwcZTQADAxhNCggCBgYEYgAEBBgEThtAPAAFBwEHBQGAAAEABwEAfgAABgcABn4KAQgGAwYIA4ALAQkAAgkCZQAHBxlNAAMDGE0ABgYEYgAEBBgETllZWUAXT08AAE9VT1QATgBNJyUkKSYrJiMMBx4rJDc2NjMyFgc3Njc2MzIWFRQGBwYHBgcGBiMiJjU0NjcGIyImJyY1NDcjBgYjIiY1NDYzMhYHBhUUMzI2NzY2NzY2MzIWFRQHBgcHFBcWMwI2NwYVFDMB/BAJDgYKCQEiLiALDA0PDBEtYw0MGWI/KjdScRESDxsHHQkCKHVLMzouKhMTAggSChkeFzEQEConJiQEBAIBCwgVZTEKahVkDAcHDxYYHxgIGBQVFwwgOjwsWmA4KjJlQAUOCidYM0OFkEo4Mj4QDjASJB46LG4rKh8eIg1ILTUfMhMR/spMPz43FgAAAP//ACP+ZwJ4AfoAAgH5AAD//wAy//sDQwHTAAICIgAAAAIAD//7AoYCgQBBAEwAXkBbEgEGAjIBCgdJOgIICQkBAAgETAADAgOFDAEJCggKCQiABQQCAgAGBwIGaAAHAAoJBwppDQsCCAgAYQEBAAAYAE5CQgAAQkxCS0dFAEEAQBYmJCEUJioiJg4HHyskFhUUBwYGIyInBiMiJjUjJjY3JiY1NDMyFzA3NzY2MzIVFAcHNzYzMhYVFAYjIw4CBzY2MzIWFRQHFjMyNjc2MwQ2NTQjIgYHFhYzAncPEy5hPikfLjpbZwEBCQ8fHCYfDQ4IDCUfOwQYLBQNHhQjH1gHCAMBHEwoPUcXBQkhPC8MD/65LDkhMxAEIiPfGBUoFjVEGBhnUkFQSwYXEjEBMRkpHykODVECAhwXGhkZMSEJHCRQPjAuATA4DnosJzUmGCQmAAAAA/+J/jcCYgHYAC4ARgBPAGJAXx4BCANEAQYIPTInFAQFBkkwCQMABQRMAAgIA2EEAQMDGU0HCgIGBgBhAQEAABhNAAUFAGEBAQAAGE0LAQkJAmEAAgIbAk5HRwAAR09HTkNBOjgALgAtJiYpIhImDAccKyQWFRQHBgYjIicGBwYCIyImNTQSNzQnJjYzMhYXFBc2NjMyFhUUBgcWMzI2NzYzBAc2NycmJjU0NjMyFxYXNjU0JiMiBwYVAjY3BgYVFBYzAlMPEytjPzUhOT4NXFk2NFpeAgEwJBUTAQEgPiM4RyIeFQ4hPC8MD/51ARsVAwoGDg4PDAoLHBgUJDMBpSQFKzIPCt8YFSgWNUQmJQHB/v1ORWIBBZ2SOR0iERkZDCgjWkk1ZCkGMDgOaxkGEQQMGxEXHA4LDzhBHh9MLFX99+uvZLY+ICIAAAAB/5X+0QJcAdIATABMQEkoAQAIAUwKAQkGAQYJAYAAAwAEAAMEgAAGAAEIBgFoAAQAAgQCZQcBBQUZTQAICABhAAAAGABOAAAATABLKCQWKyQkKCQmCwcfKyQWFRQHBgYjIiY1NDciJwYVFBcWFRQGIyImNTQ2MzIWFRQWMzI2NTQnJjU0Njc2NjMyFhUUBwYHMzY3NjYzMhYVFAcGFRQWMzI2NzYzAk0PEy5hPjQqBVgiAgQETEk7Sh0WFh8QDBQPBAUSEgkoJhQQDwgHgAoTCCEhFxIZHBANFDcuDA/fGBUoFjVEQEAbJgIcKRY6QB+EdTMzHCMYFA0PQFMiSD43NY04HRsKDhA4IS8vSR4aCw8ZcIAeExUxNw4A//8AAf7QAt4B0AACBJ8AAP//ACP/+wGzAdQAAgI1AAAAAgAn//wB1wOMAC8APABlQAofAQMBMwEEAwJMS7AmUFhAHAUBAgEChQADAwFhAAEBNk0GAQQEAGEAAAA0AE4bQBoFAQIBAoUAAQADBAEDaQYBBAQAYQAAADQATllAFTAwAAAwPDA7NjQALwAuHhwXFQcJFisAFhUUBgcGBgcGBhUUFhceAhUUBgYjIiY1NDY2MzIXJiYnLgI1NDY2NzY2NzYzAjY2NyYjIgYGFRQWMwHGEQoJGj0rLysfISw8LTppRVJcN145HhYOIxwkKBw0TEAgQhYGBsUyIAIcKRkrGhcaA4wkGBEbBhEPBgcRGBApJDBNZzpsl05hZEt3QwsXKh8oMj0hLjccDwgTCwP82T1kOSYqSy8sMAAAAP//ADf/+wHIA6wAAgJQAAAAAQAl//EBjwHbADQAY0uwMFBYQCUAAwIAAgMAgAAABQIABX4AAgIEYQAEBDZNBgEFBQFhAAEBNAFOG0AiAAMCAAIDAIAAAAUCAAV+BgEFAAEFAWUAAgIEYQAEBDYCTllADgAAADQAMyYkKyYjBwkbKzY2NzYzMhYVFAcGBiMiJjU0NjY3NjY1NCYjIgYHBgYjIiY1NDc2NjMyFhUUBgYHBgYVFBYz/kEZChENDxEgXztEWyU1KCkmFhUTHhIKFQkTFRkUTihLTSQyKCsoHB5cKSMPGBUoFioxP0IrPScVFiEXDQ8LCgUJGRQcEg8UNTIrOiIUFiAbFxUAAAD//wAl//EBkANCACIEqQAAAAMFpwICAAD//wAy//sBqwJjAAIENQAA/////v45AbEB1AACAm8AAP//ACH/+wGyAdIAAgJbAAD//wAh//sBsgNDACIErQAAAAMFpgI1AAD//wAh//sBxwKxACIErQAAAAMFpAI1AAAAAQAR//sDIgHWAGsBfkAXNwEFBFEBCQUOAQIJQxsCDAIDAQMMBUxLsAlQWEA2AAUECQQFcgAJAgQJcAACDAMCcAAMAwQMA34KAQQEBmEIBwIGBjZNCwEDAwBiDg0BAwAANABOG0uwDFBYQDcABQQJBAVyAAkCBAlwAAIMBAIMfgAMAwQMA34KAQQEBmEIBwIGBjZNCwEDAwBiDg0BAwAANABOG0uwFVBYQDgABQQJBAVyAAkCBAkCfgACDAQCDH4ADAMEDAN+CgEEBAZhCAcCBgY2TQsBAwMAYg4NAQMAADQAThtLsBdQWEA5AAUECQQFCYAACQIECQJ+AAIMBAIMfgAMAwQMA34KAQQEBmEIBwIGBjZNCwEDAwBiDg0BAwAANABOG0BEAAUECQQFCYAACQIECQJ+AAIMBAIMfgAMAwQMA34ACgoGYQgHAgYGNk0ABAQGYQgHAgYGNk0LAQMDAGIODQEDAAA0AE5ZWVlZQBoAAABrAGplY2BeWVdPTSomJCQlJiQpJw8JHysEJiYnBgcGBiMiJjU0NjcjDgIjIiY1NDYzMhUUBwYVFDMyNjY1NCYjIgYHBgYjIiY1NDYzMhYXNjc2NjMyFhUUBwYHMz4CMzIWFRQGIyImNTQ2NzY1NCMiBgYVFBYzMjY3NjMyFhUUBwYjAj5EKQcMFAoVFBgUDQkCHTFPOjdALiokAgMaEyMXEg0LCgUGFBkWGkExL0MXCAkJIiIUEA8PCgIbPk0zNDslHhMXBAEFGhQmFyolIzYfDA8NDxE7bAUxSCVUKBIQIiUgYy1QYkRANTI+GwcSJAUeLU4vJDELDRATHyAyO0tNRx4bFAwODjg/ZWFxMkEzKjoSEAcSBA8NGylFKDo9JygPGBUkGlsAAAAC/9b+OQGOAdsAMAA6ADlANjUPAgMEAgFMAAIBBAECBIAAAQEDYQADAzZNBQEEBABhAAAAOABOMTExOjE5LiwoJiIgKAYJFysABgcWFhUUBgYjIiY1NDY3JiYnJiY1NDc2Njc+AjU0JiMiBgcGBiMiNTQ2NjMyFhUANjY1NQYGFRQzAY5/ZFBGRXNANzxmgAkfGiQgFAovBTBBMRgcGSMWEhUNJy1UOEdF/t47KU9JHAEMah0ZY1NcsXA9OFWgZA0UDBAmFyIQCBECER80JRUWDQ0JCSYZLBpEN/03WX4wCkJzNCgAAAD//wAw//sBtwHSAAIC2QAA//8AMP/7AeMC9AAiBLIAAAADBeMCUQAA//8AMP/7AbcDQwAiBLIAAAADBaYCUQAAAAIAMP9LAeMC9AAZAFkAYEBdAgECAT8BBwZXLAIFCQNMMAEHAUsKAQMBA4UAAQIBhQAJBwUHCQWAAAQFBIYAAgAABgIAaQgBBgY2TQAHBwViAAUFNAVOAABZWFBOSUc9OzQyJiQAGQAYIyUmCwkZKwAWFQcOAiMiJiY1NDYzMhYXFjMyNjc2NjMCFhUUBw4CBwYGIyImNTQ3NjcmNTQ3BgYjIiY1NDY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzIWFRQHBgYHNjMBzhUCCjZeQS5GJiAZGhgHCi0vRA8IFBAGDgsqLBsFGyQZFBkQKyENAhFDJi85FBcKJCcWEQsKBhQKCw8uMxcIISEWEw0KCwEJEAL0FxEMKU41Jj4jGR8YHSo1JhQR/W4PCwwNLDosCCsfGBIVFjo3FDMNJkZKTURLfUYeGg4OCC4lHmkjFRE9e1ceGhcXJFI6WjgB//8AMv/7AjAB0gACAo0AAP//ADL/+wIwA0IAIgS2AAAAAwWnAk0AAAAB/+X//AG9AdAAIwBUthsEAgECAUxLsCFQWEATAAICNk0DAQEBAGIFBAIAADQAThtAHgACAjZNAAEBAGEFBAIAADRNAAMDAGIFBAIAADQATllADQAAACMAIhgmIyYGCRorBCY1NDcjAiMiNTQ2FxY2NzY3NjYzMhYHBhUUFxYWFxYVFAYjAT0+AwJThEQZFBksGzgcDywrKyICBAQFEhkWHxoEYWsiJ/7rMBYbAQEwN3FRKyEjJWIfKTovHwECIRkdAAAAAf/y//sCjAHTAEAAYEuwIVBYtzMdDQMABQFMG7czHQ0DBAUBTFlLsCFQWEAUBgEFBTZNBAEAAAFhAwICAQE0AU4bQBsAAAQBBAABgAYBBQU2TQAEBAFhAwICAQE0AU5ZQAopJiMqKyQSBwkdKyQWFxYWFRQGIyImNTQ3IwYGBwcGBiMiJicmJjU0NyMGBiMiNTQ2MzI2PwI2NjMyFhUUFzM2Njc2MzIWFRQHBhUCRREWEQ8kIDY6EAIXKBsXCh0XFBYICQwDAh9iPkAaFBYmGBMrCichHyIHAhBIFiYsJBoDBHwkAgESERkdRzxLcilgSD0cFxYcIGsyIR6TmjAVGzRIOoQfHRkWm0I1lhkpHyoiNlooAAAAAAEAMv/7AckB0gAsACdAJAAEAAEABAFoBgUCAwM2TQIBAAA0AE4AAAAsACsWJiYkJwcJGysABwcGBhUUBiMiJjU0NyInBhUVDgIjIiY1NDc2NjMyFhUUBwYHMzY3NzY2MwHJBQoSFR8jIR4MVSACAQQUFyYfJQkpJRQQDwgHfwkMCQghIQHSIDlelEUmISIiOkMCHAsVPjIXUFiCdR0bCg4QOCEvKS4hHhoAAP//ACH/+wGyAdMAAgKeAAD//wAy//sBzQHSAAIClgAA////if43AbwB2AACAr0AAP//ACD/+wGnAdIAAgJRAAD//wAy//sCxQHSAAIClQAA/////P45AbcB0gACAvUAAP////z+OQHjAvQAIgTAAAAAAwXjAlEAAAADACP+sQKqAxAAMwA+AEkA4EuwHVBYQAswAQYDFAgCAAcCTBtACzABBgMUCAIACQJMWUuwHVBYQCUABAMEhQABAAGGCAEGBgNhCgUCAwM2TQsJAgcHAGICAQAANABOG0uwIVBYQC8ABAMEhQABAAGGCAEGBgNhCgUCAwM2TQAHBwBhAgEAADRNCwEJCQBiAgEAADQAThtAOgAEAwSFAAEAAYYABgYDYQoFAgMDNk0ACAgDYQoFAgMDNk0ABwcAYQIBAAA0TQsBCQkAYgIBAAA0AE5ZWUAaPz8AAD9JP0lGRDw6NTQAMwAyJyUpJSUMCRsrABYVFAYGIyInBhUXFCMiJjU0NzY3IwYGIyImNTQ2NjMyFzY2Nzc2NjMyFhUUBwYGBzM2MwcOAhUUFjMyNjcWNjY1NCYjIgYHBwJkRkp6RA8KBQE7Gx8HCAoCHzsiPkpKe0UQCgkVDAYIJRwdGQQVKBECN0ntKUYqGRYXKgmkRioZFhcqCSAB1FlKT5BXBUZmbDcaG4hYXjIxKlpJUI9XBTluNhwoIBIVDg9VpVlbXQE9ZDgfHjkzcz1kOB8eOTOrAAD//wAR//sCVwHWAAIC9AAAAAEAPv/xAbcB7AAxAMRLsAxQWEAkAAIDAoUHAQYBBQEGBYAAAQEDYQQBAwM2TQAFBQBhAAAANABOG0uwF1BYQCgAAgQChQcBBgEFAQYFgAAEBDZNAAEBA2EAAwM2TQAFBQBhAAAANABOG0uwMFBYQCYAAgQChQcBBgEFAQYFgAADAAEGAwFpAAQENk0ABQUAYQAAADQAThtAIwACBAKFBwEGAQUBBgWAAAMAAQYDAWkABQAABQBlAAQENgROWVlZQA8AAAAxADApIyMmNSYICRwrJBYVFAcGBiMiJjU0NjcGIyImJyY1NDYzMhcWFjMyNjc2MzIVFAYHDgIVFDMyNjc2MwGoDxEiXUVQVFpTBw4hNRwZHRIKFxorHBYwBBoLIRQMRkQnPiNLGQwPtxgVKBYrMEZHRWs5AQwODR4XKg4PEQsBBygYIwo7PzoeMichDwAAAAACADD+0AG3AdIAPgBFAIdLsA5QWEAPHAEDAg0JAgEDQQEHAQNMG0ASHAEDAg0BBQMJAQEFQQEHAQRMWUuwDlBYQBsIAQcAAAcAZQQBAgI2TQYFAgMDAWIAAQE0AU4bQCIGAQUDAQMFAYAIAQcAAAcAZQQBAgI2TQADAwFiAAEBNAFOWUAQPz8/RT9EIhkkKicsIQkJHSsEBiMiJjU0NjY3NSYmNQYGIyImNTQ2NzY2MzIWFRQHBgcGFRQWMzI2NzY2MzIWFRQHBgYVFBYzMjYzMhYVFAcGNjcGFRQzAXtgPyo3I11VHSEQQyksOhQXCiUmFRILCgYUCgsbTCAIIiAXEhkLEgoKBAoFBwYfizAJaBXRXzgqJEFQMwIFOS5BTFI/Sn1HHxkNDwguJR5qIhQSmHcfGQsPGGwtWBMTDwILEWxqXEw/PjcWAAAAAAEAMP/7Ap4B0gBGAGpLsC5QWEAMFQYCAwIBTEYBAwFLG0AMFQYCAwQBTEYBAwFLWUuwLlBYQBUGBAICAjZNBQEDAwBiBwECAAA0AE4bQBkGAQICNk0ABAQ2TQUBAwMAYgcBAgAANABOWUALKiUoJConJSEICR4rJAYjIjU0NwYGIyImNTQ2NzY2MzIWFRQHBgcGFRQWMzI2NzY2MzIWFRQHBhUUFjMyNjY3NjYzMhYVFAYHBgYVFAYjIiY1NDcB6EMoWwMeRC0tORQXCiQnFhELCgYUCgshPyUJGCAaFA4UCgsPLTMYCCEhFhMIBQoMHyMlHQJFSmwTFUhMUz5LfUYeGg4OCC4lHmkjFRGVeh4VERUUTXQhFRE8elkeGhcXGT0gQGlDJiEnOAsmAAIAMP7QAp4B0gBWAF0A4UuwDlBYQBAjFAIEAw0JAgEEWQEKAQNMG0uwLlBYQBMjFAIEAw0BCAQJAQEIWQEKAQRMG0ATIxQCBAUNAQgECQEBCFkBCgEETFlZS7AOUFhAHgsBCgAACgBlBwUCAwM2TQkIBgMEBAFiAgEBATQBThtLsC5QWEAlCQEIBAEECAGACwEKAAAKAGUHBQIDAzZNBgEEBAFiAgEBATQBThtAKQkBCAQBBAgBgAsBCgAACgBlBwEDAzZNAAUFNk0GAQQEAWICAQEBNAFOWVlAFFdXV11XXFJQGSUoJConJSwhDAkfKwQGIyImNTQ2Njc1JiY1BgYjIjU0NwYGIyImNTQ2NzY2MzIWFRQHBgcGFRQWMzI2NzY2MzIWFRQHBhUUFjMyNjY3NjYzMhYVFAcGBhUUFjMyNjMyFhUUBwY2NwYVFDMCZGI/KjcjXVUdIRFEJ1sDHkQtLTkUFwokJxYRCwoGFAoLIT8lCRggGhQOFAoLDy0zGAghIRcSGQsSCgoECgUHBh+NLQ5oFdBgOCokQVAzAgU5LkRJbBMVSExTPkt9Rh4aDg4ILiUeaSMVEZV6HhURFRRNdCEVETx6WR4aCw8YbC1YExMPAgsRbGpcRkU+NxYAAAEAMP+HAbcB0gA3ADlANicBAwIbAQADAkwQAQMBSwADAgACAwCAAAAANE0AAQECYQUEAgICNgFOAAAANwA2KiwpKgYJGisAFhUUBgcGBhUUBiMiJjU0NwYHDgIjIiY1NDcmJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzAaQTCAUKDB8jJR0CFC0JERcTFRcFGhwUFwokJxYRCwoGFAoLDy4zFwghIQHSFxcZPSBAaUMmISc4CyZTJjo5GCYlHRoQQzBLfUYeGg4OCC4lHmkjFRE9e1ceGgAAAAACADT/+wHMAdIAGAAjADVAMhUBAwIdAQQDAkwFAQIAAwQCA2kAAQE2TQAEBABiAAAANABOAAAhHxsZABgAFyclBgkYKwAWFRQGBiMiJjU0Njc2NjMyFRQPAjY2MxYjIgYHFhYzMjY1AYVHMmFDW2cSEwkpJy0PBw4bSycHOSA1DwQiIygsAVZQPjNePGdTPGw9HRsYCj4ePBsjaScYJCUtJgAAAAIAKf/7AeUB6AAoADMAmUAODAEEAiUBBQQtAQYFA0xLsBdQWEAfBwEEAAUGBAVqAAEBNk0DAQICNk0ABgYAYgAAADQAThtLsCZQWEAfAAECAYUHAQQABQYEBWoDAQICNk0ABgYAYgAAADQAThtAIwABAwGFBwEEAAUGBAVqAAMDNk0AAgI2TQAGBgBiAAAANABOWVlAEQAAMS8rKQAoACcxIywlCAkaKwAWFRQGBiMiJjU0NjcmJyYmNTQ2MzIXFhYzMjc2MzIWFRQGBwYHNjYzFiMiBgcWFjMyNjUBnkcvYkldYR4qKSYPDh8TCggcLhkfJwYKExEcISEPGkYkBzkhMg8CISQoLAFWUD44XThmVDhgKwMPBhgNFB8EDgsGAQ4QGxkIMCcXHmkkGCYmLCcAAAAAAwA0//sCpwHSABgAKwA2AEhARRoBAgEVAQUCMAEGBSQBAAYETAcBAgAFBgIFaQgEAgEBNk0ABgYAYgMBAAA0AE4ZGQAANDIuLBkrGSoiIAAYABcnJQkJGCsAFhUUBgYjIiY1NDY3NjYzMhUUDwI2NjMkFRQHBgcGBiMiJjU0NzY3NjYzBCMiBgcWFjMyNjUBhUcyYUNbZxITCSknLQ8HDhtLJwFfAi0JAiIkIBgCECUIJSn+0zkhMxAEIiMoLAFWUD4zXjxnUzxsPR0bGAo+HjwbI3wjBQ7WkSAaGhwIFLeWHxnlJhgkJiwnAAAC/+X/+wKMAdAAIwAuAIBLsBtQWEALIAsCBQQoAQIFAkwbQAsgCwIFBCgBBgUCTFlLsBtQWEAbBwEEAAUCBAVpAAMDNk0GAQICAGIBAQAANABOG0AlBwEEAAUGBAVpAAMDNk0ABgYAYgEBAAA0TQACAgBhAQEAADQATllAEQAALComJAAjACImIyYlCAkaKwAWFRQGBiMiJjU0NyMCIyI1NDYXFjY3Njc2NjMyFhUHBzY2MxYjIgYHFhYzMjY1AkVHNGRFYE8DA1OERBkUGSwbNCAPMScnJAIDG1AqBzkiMxADIiUoLAFWUD43XjhoaiAk/uswFhsBATA3alspIB0jLFQdKWkmGSQlLCcAAgAy//sCtgHSADIAPQBIQEUvAQcEDQEBBzcJAggBA0wJAQYABwEGB2kABAABCAQBagUBAwM2TQAICABhAgEAADQATgAAOzk1MwAyADEkFiYnFCUKCRwrABYVFAYGIyImNTUjIicGFRUOAiMiJjU0NzY2MzIWFRQHBgczNjc2NjMyFRQPAjY2MxYjIgYHFhYzMjY1Am9HMmFDWl44MhUCAQQUFyYfJQkpJRQQDwgHfAgVCh8mLQ8HDhtLJwc5ITMQBCIjKCwBVlA+M148ZlQHAhwLFT4yF1BYgnUdGwoOEDghLzREHxkYCj4ePBsjaSYYJCYtJgAAAP////X/5QGEAd0AAgLGAAAAAQAh//sBvQHSAC4AgLUXAQIDAUxLsBVQWEAtAAIDBAMCcggBBwQFBAcFgAAEAAUGBAVnAAMDAWEAAQE2TQAGBgBhAAAANABOG0AuAAIDBAMCBIAIAQcEBQQHBYAABAAFBgQFZwADAwFhAAEBNk0ABgYAYQAAADQATllAEAAAAC4ALSE0MiQkJSYJCR0rJBYVFAcGBiMiJjU0NjYzMhYVFAYjIiYnJiYjIgYHFjMyFhUUBgcHJxYzMjY3NjMBrg8RG1w3Znc1ZURLRxoeFhIBARQXJC8KJT0VFhUcMy8LYyI2HwwPwRgVJBopMnNfS3dDPC4bGQ0NEhAxKgEVFRUVAQEBXCcoDwAAAQAj//sBxwHTAC0Ac0uwCVBYQCcAAQQDBAEDgAAEAAMCBANnBgEFBQdhCAEHBzZNAAICAGEAAAA0AE4bQC4ABgUEBQYEgAABBAMEAQOAAAQAAwIEA2cABQUHYQgBBwc2TQACAgBhAAAANABOWUAQAAAALQAsIiE0MiUkJAkJHSsAFhUUBiMiJjU0NjMyFhUUFhYzMjY3IicmJjU0NjMyNyYjIgcGIyImNTQ3NjYzAV5pe3lKZiQgDhMKJSYqOQhCHhwVFhVAJxBXMS8JCxAQIhVIKQHTd2tuiElBMygNCycuGzMzAQEVFRUVAU8RBBYSLBQMEAAAAP//ACL/+wEZArAAAgJ4AAD//wAH//sBagKxACICeQAAAAMFpAHYAAD///8d/jkA/wKwAAICiAAA//8ANf/7AdMDPAACAnYAAAACADL/+wKSAdMAJQAxADpANwAEAAEHBAFoAAYGA2EIBQIDAzZNCQEHBwBhAgEAADQATiYmAAAmMSYwLCoAJQAkFiYlEyYKCRsrABYWFRQGBiMiJiYnIwcVDgIjIiY1NDc2NjMyFhUUBwYHMzY2MxI2NTQmIyIGFRQWMwIYUSk5YTk5Uy0DWwEBBBQXJh8lCSklFBAPCAdZFXJMDjQqHCg1Kx0B0ztgN0t4QzVXNSUVPjIXUFiCdR0bCg4QOCEvUWD+kk1GNjtNRjc6AAAC//j/+wHJAdEALgA6AI9LsA5QWEASKQEHBTABCAcNAQIEBQEAAgRMG0ASKQEHBTABCAcNAQIEBQEAAwRMWUuwDlBYQCAACAAEAggEaQAHBwVhBgEFBTZNAwECAgBhAQEAADQAThtAJgACBAMDAnIACAAEAggEaQAHBwVhBgEFBTZNAAMDAGIBAQAANABOWUAMJCUiJCIjJiYnCQkfKwAGBwYXFxQGIyImNTQ3IwYjIicmJjU0NjMyFxYWMzI2NyMiJjU0NjMyFzYzMhYHBjcmIyIGFRQWMzI3AbIRAQIJARobIxsFAlyFLCALCBgVCwsJFRMdQB8OPEdWTTc4DCMXGgSIFSQcKCwlHA4QAVZnLU5EChQXKjAeN64VBxcUFB0HBQYnI0xASVARDxkRdEQLJiEcJgIAAAACACH+OQHTAzwAQwBLAI9AEB8BBgM9HQ0DAgFGAQgCA0xLsBtQWEAvAAEHAgcBAoAABgcDBlgABAQzTQAHBzZNBQEDAwJiAAICNE0JAQgIAGEAAAA4AE4bQC8ABAMEhQABBwIHAQKAAAYHAwZYAAcHNk0FAQMDAmIAAgI0TQkBCAgAYQAAADgATllAEUREREtESiUkVCUqJSokCgkeKwAHDgIjIiY1NDY/AjY1NCMiBgYHBgYjIiY1NDc2NyYmNTQzMhc2NzY2MzIVFAcHMjc2MzIWFRQGIyMGBz4CMzIVADY3BgYVFDMB0yofRWhJM0BumAccAQsNMDAPCx0fJCAFCSogHCYgDAkODCUfOwQZDiAyHx4UIx+HJh4hUU8hQf7mPhtMQxwBUuyu7pE/M0ehdjPaBwwQQ249LyFBTSZGhccGFxIxASYuKR8qDQ1bAgIcFxoZl8BVay5B/Ql2g0FpKCcAAAIAD//7AcwCgQAwADsATEBJBgEEACYBBwU4AQgHA0wAAQABhQMCAgAABAUABGgABQAHCAUHaQoBCAgGYQkBBgY0Bk4xMQAAMTsxOjY0ADAALyYkIRQmKgsJHCsWJjUjJjY3JiY1NDMyFzA3NzY2MzIVFAcHNzYzMhYVFAYjIw4CBzY2MzIWFRQGBiM2NjU0IyIGBxYWM5tnAQEJDx8cJh8NDggMJR87BBgsFA0eFCMfWAcIAwEcTCg9RzJhQy0sOSEzEAQiIwVnUkFQSwYXEjEBMRkpHykODVECAhwXGhkZMSEJHCRQPjNePGosJzUmGCQmAAACABH/+wOBA1AASwBZAQRLsCZQWEAbUgEGBzktAgUGTUMjAwMFGwELA1gRCAMECwVMG0AbUgEGBzktAgUGTUMjAwMJGwELA1gRCAMECwVMWUuwCVBYQC4AAwULBANyDAELBAULBH4ABwc5TQkBBQUGYQgBBgY2TQoBBAQAYgIBAgAANABOG0uwJlBYQC8AAwULBQMLgAwBCwQFCwR+AAcHOU0JAQUFBmEIAQYGNk0KAQQEAGICAQIAADQAThtAOQADCQsJAwuADAELBAkLBH4ABwc5TQAFBQZhCAEGBjZNAAkJBmEIAQYGNk0KAQQEAGICAQIAADQATllZQBYAAABLAEpHRUE/JiYkEyYkJCUlDQkfKyQWFRQHBiMiJwYHBgYjIicmJwYjIiY1NDYzMhUUBwYVFDMyNyYmJyY1NDYzMhc2Nzc2NjMyFRQHBgc2MzIVFAYnJgYHFhYXMjY3NjMkNyY1NDY3IwYHFhUVMwNyDxE7bX0qFAsPJyo5AwEEYnc3QC4qJAIDGkJoCCYpFh8aPyMcLB0NNSk9ARMGNDZEHRQrOBoGNSgjOR4MD/5+JwIOFQUwQgcHwRgVJBpblCcgLCBIHC6SQDUyPhsHEiQFHt4cFQICIRkdGk+YYionPgsGo7krMBUcAQEjLGBdAicoDxpGMhsrjZbuoDdaIwAAAAMAIf/7AbIB0wAPACAAMQBVQFIdEgIDAi4jAgUGAkwAAgAGBQIGaQADAAUHAwVpCQEEBAFhCAEBATZNCgEHBwBhAAAANABOISEQEAAAITEhMC0rJyUQIBAfHBoVEwAPAA4mCwkXKwAWFhUUBgYjIiYmNTQ2NjMGBgc2MzIWFhcWFjMyNyYmIxI2NwYGIyImJyYmIyIHFhYzATRUKjpjPDtTKjliPSQrCA8ICREJAgwRCxcYASgbCSULBBgPDA8LCQ0JDQ0GJRkB0ztgN0x3QztgN0x3Q2wvLwUHBgEHCA01NP8AICABCAcIBwYGKCUAAAEAMv/7AicB1AAlAChAJQgBAAIbAQEAAkwAAAIBAgABgAMBAgI2TQABATQBTionJyMECRorABUUBiMiJyYnBgcGBiMiJicmNTU2NjMyFhUUFzY2NzY3NjMyFhcCJx8TCggUF0tGI0AmKjAGDAEiIhoZDis/JQ8fERckLxoBthsUHwQKB7BvOSo/RoxpIyEaFxtzuEp7ZSgIBAgKAAEAJ//xAagB2wBJAJBADTMXDAMHAT83AgUHAkxLsDBQWEAzAAMCAQIDAYAAAQcCAQd+CAEHBQIHBX4ABQYCBQZ+AAICBGEABAQ2TQAGBgBhAAAANABOG0AwAAMCAQIDAYAAAQcCAQd+CAEHBQIHBX4ABQYCBQZ+AAYAAAYAZQACAgRhAAQENgJOWUAQAAAASQBIJywmJCoqJgkJHSskFhUUBwYGIyImNTQ3JyYmNTQ2MzIXFhc2NzY2NTQmIyIGBwYGIyImNTQ3NjYzMhYVFAYHFxYWFRQHBiMiJyYnBhUUFjMyNjc2MwGZDxEgXztEWyASFg8PDhYrChAbBSomFhUTHhIKFQkTFRkUTihLTTs1DxcSAQMiGCQDKQscHiJBGQoRtxgVKBYqMT9CNicIChMSCw0SBAQPAhchFw0PCwoFCRkUHBIPFDUyOUAbBgsTCwUDEQcBCRARFxUpIw8AAAACACX+0AF5AdsAOgBBAElARggBAQU9AQcBAkwAAwIGAgMGgAAGBQIGBX4IAQcAAAcAZQACAgRhAAQENk0ABQUBYQABATQBTjs7O0E7QCIrJiQrJiEJCR0rBAYjIiY1NDY3BiMiJjU0NjY3NjY1NCYjIgYHBgYjIiY1NDc2NjMyFhUUBgYHBgYVFBYzMjc2MzIVFAcGNjcGFRQzAUFiPyo3TWksJzdGJTUoKSYWFRMeEgoVCRMVGRROKEtNJDIoKyggKDYxDgsPH4swCWgV0GA4KjFiPw1FNis9JxUWIRcNDwsKBQkZFBsTDxQ1Mis6IhQWIBsWEhcHIGxoXEw/PjcWAAAAAAIAEf7QAvIB1gBzAHoCLUuwHVBYQBxCAQcGXAELBxkBBAtOJg4DDgQIAQEFdgEPAQZMG0AcQgEHBlwBCwcZAQQLTiYOAw4ECAEBBXYBDwIGTFlLsAlQWEA9AAcGCwYHcgALBAYLcAAEDgUEcAAOBQYOBX4QAQ8AAA8AZQwBBgYIYQoJAggINk0NAQUFAWIDAgIBATQBThtLsAxQWEA+AAcGCwYHcgALBAYLcAAEDgYEDn4ADgUGDgV+EAEPAAAPAGUMAQYGCGEKCQIICDZNDQEFBQFiAwICAQE0AU4bS7AVUFhAPwAHBgsGB3IACwQGCwR+AAQOBgQOfgAOBQYOBX4QAQ8AAA8AZQwBBgYIYQoJAggINk0NAQUFAWIDAgIBATQBThtLsBdQWEBAAAcGCwYHC4AACwQGCwR+AAQOBgQOfgAOBQYOBX4QAQ8AAA8AZQwBBgYIYQoJAggINk0NAQUFAWIDAgIBATQBThtLsB1QWEBLAAcGCwYHC4AACwQGCwR+AAQOBgQOfgAOBQYOBX4QAQ8AAA8AZQAMDAhhCgkCCAg2TQAGBghhCgkCCAg2TQ0BBQUBYgMCAgEBNAFOG0BVAAcGCwYHC4AACwQGCwR+AAQOBgQOfgAOBQYOBX4QAQ8AAA8AZQAMDAhhCgkCCAg2TQAGBghhCgkCCAg2TQ0BBQUBYgABATRNDQEFBQJiAwECAjQCTllZWVlZQB50dHR6dHlvbWtpZGJaWFRSSEYkJCUmJCknJiERCR8rBAYjIiY1NDY3BiMiJiYnBgcGBiMiJjU0NjcjDgIjIiY1NDYzMhUUBwYVFDMyNjY1NCYjIgYHBgYjIiY1NDYzMhYXNjc2NjMyFhUUBwYHMz4CMzIWFRQGIyImNTQ2NzY1NCMiBgYVFBYzMjc2MzIWFRQHBjY3BhUUMwKrYj8qN1NzEAsdPSsFDBQKFRQYFA0JAh0xTzo3QC4qJAIDGhMjFxINCwoFBhQZFhpBMS9DFwgJCSIiFBAPDwoCGz5NMzQ7JR4TFwQBBRoUJhcyLxkXEQoKCR+NMQpqFdBgOCoyZEAFLEYkVCgSECIlIGMtUGJEQDUyPhsHEiQFHi1OLyQxCw0QEx8gMjtLTUceGxQMDg44P2VhcTJBMyo6EhAHEgQPDRspRSg2QhAMDhJsaFxMPz43FgAC/+/+rQGcAdsAPwBIAE5ASz8BAwVCDwIHAgJMAAUEAwQFA4AAAwEEAwF+AAECBAECfgACBwQCB34IAQcAAAcAZgAEBAZhAAYGNgROQEBASEBHJSMqFSQqKAkJHSskFhUUBgcOAiMiJjU0NjcmJjU0NjMyFhcWFjMyNjU0JicmJjU0Njc2NjU0JiMiBwYGIyImNTQ2NjMyFhUUBgcCNjcGBhUUFjMBWDsjIBAwVUZBRVBeQz8aFxYVCQcgJh8uKisREg4SMi8dHEQOBxYTFxguVzlQVT0xjDIUP0AODNw6LSI2EXmXTz42QWU2BzUmGx8TFxQVGhkcGgQBFw8UEgMJLyETFjIXExoWITwlPj0oRRH+NllnLVAnDQ8AAAIAMv7QAfYB0gBFAEwAlEAWLQEEBSEBBwQLAQYHCAEBBkgBCAEFTEuwCVBYQC4ABAUHBQRyAAcGBQcGfgAGAQUGAX4JAQgAAAgAZQAFBQJhAwECAjZNAAEBNAFOG0AvAAQFBwUEB4AABwYFBwZ+AAYBBQYBfgkBCAAACABlAAUFAmEDAQICNk0AAQE0AU5ZQBFGRkZMRksjJSgkKiYsIQoJHisEBiMiJjU0NjcmJicGBwYGIyImNTQ3NjYzMhYVFAcOAgc2NjMyFhUUBiMiJjU0Njc2NTQjIgYGFRQWMzI2NzYzMhYVFAcGNjcGFRQzAZtiPyo3UW81TgoCDQsdHiYfJQkpJRQQDwINCwIkbk40OyUeExcEAQUaFCYXMCUKEgwPDAoJH4swCWgV0GA4KjJkPgVEKggwKB5QWIJ1HRsKDhA4BzJDKIx4QTMqOhIQBxIEDw0bKUUoNEQHCQwOEmxoXEw/PjcWAAEAMv/7AkoB0gBRAI9AEEMBBwU1LAIABxYPAgkAA0xLsAlQWEAuAAcFAAgHcgAACQUACX4ABQACAQUCaQAICARhBgEEBDZNCgEJCQFhAwEBATQBThtALwAHBQAFBwCAAAAJBQAJfgAFAAIBBQJpAAgIBGEGAQQENk0KAQkJAWEDAQEBNAFOWUASAAAAUQBQKCQoKyYmJSYjCwkfKyQ2NzYzMhYVFAcGBiMiJicnBgYjIiYnIw4CIyImNTQ3NjYzMhYVFAcOAgczNjYzMhYVFAczPgIzMhYVFAYjIiY1NDY3NjU0IyIGBhUUFjMBvTgeDA8NDxEbVzREThkCAg0LCgsFAwMLFhQmHyUJKSUUEA8CDQsCAw4TDQkGBAMUMjsqOEElHhMXBAEFGhQkFi4uYygnDxgVJBoqMTM3ASMaGiouMBRQWIJ1HRsKDhA4CC89JEQqCxMcM2hrJEEzKjoSEAcSBA8NGyhFKTZBAAABAA3/+wIwAg4ATQEiQBIkAQMEOgEHCC4BCgcLAQkKBExLsAlQWEA4AAcICggHcgsBCgkICgl+AAQDAgRZBQECAgNhBgEDAzZNAAgIA2EGAQMDNk0ACQkAYQEBAAA0AE4bS7AZUFhANwAHCAoIBwqACwEKCQgKCX4ABAMCBFkFAQICA2EAAwM2TQAICAZhAAYGNk0ACQkAYQEBAAA0AE4bS7AhUFhANQAHCAoIBwqACwEKCQgKCX4ABAMCBFkAAwUBAggDAmkACAgGYQAGBjZNAAkJAGEBAQAANABOG0A2AAcICggHCoALAQoJCAoJfgAEAAUCBAVpAAMAAggDAmkACAgGYQAGBjZNAAkJAGEBAQAANABOWVlZQBQAAABNAExJRygkJBkiIzUnJgwJHyskFhUUBwYGIyImJicGBwYGIyImNTQ2NwYjIiY1NDMzNjYzMhYVFAcWFhUUBgcGBzY2MzIWFRQGIyImNTQ2NzY1NCMiBgYVFBYzMjY3NjMCIQ8RG1c2LEguCQINCx0eJh8TDgUNGBxTDAslIBQQARgVGyYgBCN0STQ7JR4TFwQBBRoUJhcvKyI2HwwPwRgVJBoqMSY6HggwKB5QWC2FPQESEjIUEwoOBgQCEwwXGwJ5UIp6QTMqOhIQBxIEDw0bKUUoOzwnKA8AAAABACn/+wKSAegAUAFbS7AbUFhADkIBCAM2AQAIEAEKAANMG0AOQgEICTYBAAgQAQoAA0xZS7AJUFhALQAIAwADCHIAAAoDAAp+AAQENk0JAQMDBWEHBgIFBTZNCwEKCgFhAgEBATQBThtLsBdQWEAuAAgDAAMIAIAAAAoDAAp+AAQENk0JAQMDBWEHBgIFBTZNCwEKCgFhAgEBATQBThtLsBtQWEAuAAQFBIUACAMAAwgAgAAACgMACn4JAQMDBWEHBgIFBTZNCwEKCgFhAgEBATQBThtLsCZQWEA1AAQFBIUAAwUJBQMJgAAICQAJCACAAAAKCQAKfgAJCQVhBwYCBQU2TQsBCgoBYQIBAQE0AU4bQDkABAYEhQADBQkFAwmAAAgJAAkIAIAAAAoJAAp+AAUFNk0ACQkGYQcBBgY2TQsBCgoBYQIBAQE0AU5ZWVlZQBQAAABQAE9KSCQqIyMnFCcmIwwJHyskNjc2MzIWFRQHBgYjIiYmJwYHBgYjIiY1NDcmJicmJjU0NjMyFxYWMzI3NjYzMhYVFAcOAgc2NjMyFhUUBiMiJjU0Njc2NTQjIgYGFRQWMwIGNh8MDw0PERtXNi9NMAcCDQsdHiYfGyEpFw8OHxMKCBorFxAJBxkIFA4PAg0LAiRuTjQ7JR4TFwQBBRoUJhczL2MnKA8YFSQaKjEpOhsIMCgeUFhvZgIHCQYYDRQfBA4KAQEECg4QOAcyQyiMeEEzKjoSEAcSBA8NGylFKDVCAAAAAAIAMv7QAcQB0gBCAEkASUBGDgECBkUBCAICTAkHAgYBAgEGAoAABAABBgQBaAoBCAAACABlBQEDAzZNAAICNAJOQ0MAAENJQ0gAQgBBGiUWJiYsJgsJHSskFhUUBwYGIyImNTQ2Njc1JiYnNDciJwYVFQ4CIyImNTQ3NjYzMhYVFAcGBzM2Nzc2NjMyFhUUBgcGBhUUFjMyNjMCNjcGFRQzAb0GHxliPyo3I11VHSICA1YhAgEEFBcmHyUJKCYUEA8IB38DEAsIISEXEhILCQ8KCgQKBZ0wCWgVfAsRbGpaYDgqJEFQMwIEOS8iEgIcCxU+MhdQWIJ1HRsKDhA4IS8OPiweGgsPEVwwKUsLEw8C/rJMPz43FgABADL/+wIeAewANQAnQCQABgMGhQAEAAEABAFoBQEDAzZNAgEAADQATiMVFiYmJCkHCR0rAAcGBwcGBhUUBiMiJjU0NyInBhUVDgIjIiY1NDc2NjMyFhUUBwYHMzY3NzY2NzY3NjMyFhUCHh0fJwUQEx8jIR4MVSACAQQUFyYfJQkpJRQQDwgHfwkMCQceHSkeCAoTHwGeDA0DG1uKQCYhIiI6QwIcCxU+MhdQWIJ1HRsKDhA4IS8pLiEcGwEHDwQfFAAAAgAy/tAB2AHSAEIASQBLQEgrAQUBCQECBUUBBwIDTAABAwUDAQWABgEFAgMFAn4IAQcAAAcAZQQBAwM2TQACAjQCTkNDQ0lDSD48OjkwLiQiHBoVEyEJCRcrBAYjIiY1NDY2NzUmJjU0Njc2NTQjIgYGBwYGIyImNTQ3NjYzMhYVFAcGBgc+AjMyFRQGBwYGFRQWMzI2MzIWFRQHBjY3BhUUMwGfYT8qNyNdVR8pDAENCw0vMQ8LHR8mHyUJKSUUEA8KDAQhUk8hQQsMAREKCgQKBQcGH4wwCWgV0GA4KiRBUDMCBTEpEz4IOxoQQ249LyFQWIJ1HRsKDhA4KDwsVmwuQRg/NQZNFhMPAgsRbGpcTD8+NxYAAAIAIf/7AqEB0gA1AEEAQUA+ODAkAwMFCQEAAwJMBwEFBgMGBQOAAAQABgUEBmkAAgI2TQADAwBiAQEAADQATgAAPz0ANQA0Ji4lIiYICRsrJBYVFAcGBiMiJwYjJiY1NDY2MzIWFRQGBwYGBw4CFRQWMzI3JjU0NjYzMhYVFAYHNjY3NjMEFhc2NjU0JiMiBhUCkg8WIYA3NSk3OFxpO2U7FhkNEQYVCxIiFistEAgRLFA1OkIqJiZMHg0P/t4GCCgwFRMcIsAYFSYYJDYTEwFyYUh3RBkVFhgEAQECBClCKEA5ASk+NmM8TjgwXScGKyENDSgOFkUsGhs+KAAAAAACACD+0AFyAdIAMgA5AIVADhsBAwQIAQEFNQEHAQNMS7AJUFhAKwADBAYEA3IABgUEBgV+CAEHAAAHAGUABAQCYQACAjZNAAUFAWEAAQE0AU4bQCwAAwQGBAMGgAAGBQQGBX4IAQcAAAcAZQAEBAJhAAICNk0ABQUBYQABATQBTllAEDMzMzkzOCMkKSQmJiEJCR0rBAYjIiY1NDY3BiMiJiY1NDY2MzIWFRQGIyImNTQ2NzY1NCYjIgYGFRQzMjY3NjMyFRQHBjY3BhUUMwE3Yj8qN01pFBIvTCpAZjg3PSUeExcEAQUNDBcoGGUOHRgOCw8fizAJaBXQYDgqMWI/BDZbNFF6QkEzKjoSEAcSBA8NDQ4pRip0CAwHIGxoXEw/PjcWAAAAAAIAMv7QAtAB0gBZAGAAVUBSRjsCCAEJAQIIXAEKAgNMAwEBBQgFAQiACQEIAgUIAn4LAQoAAAoAZQcGAgUFNk0EAQICNAJOWlpaYFpfVVNRUEpIQD40MiwqJSMcGhUTIQwJFysEBiMiJjU0NjY3NSYmNTQ3NjY1NCMiBgYHBgYjIiY1NDc2NTQjIgYGBwYGIyImNTQ3NjYzMhYVFAcGBgc+AjMyFhUUBwYHNjYzMhUUBwYVFDMyNjMyFhUUBwY2NwYVFDMCmGI/KjcjXVUfKAwBDAsNMDAPCx0gISEKCAsPLisNCx0fJh8lCSklFBAPCgwEG0tPIyMdEwgDMno1QRcSFAQKBQcGH4wwCWgV0GA4KiRBUDMCBTEpEUAIQhMQQ249MCA/LSZIQBQQSHA2LyFQWIJ1HRsKDhA4KDssTmw1ICEgVCQSe3BBJ2tMGh8CCxFsalxMPz43FgAAAAEANP6xAeYB0wApACFAHiEBAAEBTAAAAQCGAwICAQE2AU4AAAApACgrLQQJGCsAFRQHBgYHBgYHFhcWBiMiJicmJicmJyY1NDYzMhYXFhYXNjc2Njc2NjMB5ggxQiYbKRYMBQEmHRseAQUNDQckAiEfGhoHEBIGAwgmOyILJBsB0yMMFXOJNScvE3iQIRsWG1Wok1PJEAQbFhsnVH5cBw5KgV0eFQAAAAEAD/6xAeYB0wA6AFO1LgEABgFMS7AuUFhAFwACAQKGBQQCAAMBAQIAAWoHAQYGNgZOG0AcAAIBAoYAAwEAA1oFBAIAAAECAAFqBwEGBjYGTllACywnESMkJCQ0CAkeKwAGBwYHNjMyFhUUBiMjFhcWBiMiJicmJycmJjU0MzIXMycmJyY1NDYzMhYXFhYXNjc2Njc2NjMyFRQHAa1CJiYaIgweFCMfMgcEASYdGx4BBggoHxwmHw0JCQckAiEfGhoHEBIGAwgmOyILJBs3CAEciTU1GwIcFxoZYlshGxYba2ECARsTMQFjU8kQBBsWGydUflwHDkqBXR4VIwwVAAACABH+0AIfAdYAUQBYASBLsCZQWEATNwEFBxsBDAMRDQIBBFQBDQEETBtAEzcBBQcbAQwDEQ0CAQRUAQ0CBExZS7AJUFhAPAADBgwEA3IOAQwEBgwEfg8BDQAADQBlCgEFBQdhCAEHBzZNCQEGBgdiCAEHBzZNCwEEBAFiAgEBATQBThtLsCZQWEA9AAMGDAYDDIAOAQwEBgwEfg8BDQAADQBlCgEFBQdhCAEHBzZNCQEGBgdiCAEHBzZNCwEEBAFiAgEBATQBThtAQQADBgwGAwyADgEMBAYMBH4PAQ0AAA0AZQoBBQUHYQgBBwc2TQkBBgYHYggBBwc2TQABATRNCwEEBAJiAAICNAJOWVlAHlJSAABSWFJXAFEAUE5MR0VBPyQkJCUmJCImJhAJHyskFhUGBwYGIyImNTQ2NwYjIicGIyImNTQ2MzIVFAcGFRQzMjY2NTQmIyIGBwYGIyImNTQ2MzIWFzY2MzIWFRQGIyImJyYmIyIGBhUUFjMyNzYzAjY3BhUUMwIQCQQbGWI/KjdScR4YPiM4SzdALiokAgMaEyMXEg0LCgUGFBkWGj4xKkQSHkskJykiGBYQBAIICgwbEy4gGRcRCpcxCmoVfg8WcV5aYDgqMmVABz1DQDUyPhsHEiQFHi1OLyQxCw0QEx8gMzopJygoJCgtMxIRDAwtSigtNxAM/rBMPz43FgADADD+0AHZAoMAEABPAFYAp0uwDlBYQA8tAQUEHhoCAwVSAQkDA0wbQBItAQUEHgEHBRoBAwdSAQkDBExZS7AOUFhAJAAACgEBBAABZwsBCQACCQJlBgEEBDZNCAcCBQUDYgADAzQDThtAKwgBBwUDBQcDgAAACgEBBAABZwsBCQACCQJlBgEEBDZNAAUFA2IAAwM0A05ZQB5QUAAAUFZQVUtJR0Y9Ozc1KykiIBQSABAADFMMCRcrEiY1NDM3NjMyFhUUBiMiBwcSBiMiJjU0NjY3NSYmNQYGIyImNTQ2NzY2MzIWFRQHBgcGFRQWMzI2NzY2MzIWFRQHBgYVFBYzMjYzMhYVFAcGNjcGFRQzsx5TR1IeHhwiMEVUIa5gPyo3I11VHSEQQyksOhQXCiUmFRILCgYUCgsbTCAIIiAXEhkLEgoKBAoFBwYfizAJaBUCJhMSMgIEFQ0ZHAQB/QhfOCokQVAzAgU5LkFMUj9KfUcfGQ0PCC4lHmoiFBKYdx8ZCw8YbC1YExMPAgsRbGpcTD8+NxYAAAACAD7+0AGNAewANwA+AMNACgwBAQY6AQgBAkxLsAxQWEAsAAMEA4UJAQcCBgIHBoAKAQgAAAgAZQACAgRhBQEEBDZNAAYGAWEAAQE0AU4bS7AXUFhAMAADBQOFCQEHAgYCBwaACgEIAAAIAGUABQU2TQACAgRhAAQENk0ABgYBYQABATQBThtALgADBQOFCQEHAgYCBwaAAAQAAgcEAmkKAQgAAAgAZQAFBTZNAAYGAWEAAQE0AU5ZWUAWODgAADg+OD0ANwA2KSMjJjUmJQsJHSskFRQHBgYjIiY1NDY3BiMmJjU0NjcGIyImJyY1NDYzMhcWFjMyNjc2MzIVFAYHDgIVFDMyNzYzAjY3BhUUMwGNHxliPyo3TWkrJTZFWlMHDiE1HBkdEgoXGiscFjAEGgshFAxGRCc+Pi4OC5swCWgVfiBsaFpgOCoxYj8NAkJDRWs5AQwODR4XKg4PEQsBBygYIwo7PzoeMhcH/rBMPz43FgABAEz/8QHqAikARQEqS7AMUFhADC4kAgUDGhECAQUCTBtADyQBBgMuAQUGGhECAQUDTFlLsAxQWEAxAAMEBQQDBYAAAgEIAQIIgAkBCAcBCAd+AAQAAQIEAWkGAQUFNk0ABwcAYgAAADQAThtLsBdQWEA1AAMEBgQDBoAAAgEIAQIIgAkBCAcBCAd+AAQAAQIEAWkABgY2TQAFBTZNAAcHAGIAAAA0AE4bS7AwUFhAOAADBAYEAwaAAAUGAQYFAYAAAgEIAQIIgAkBCAcBCAd+AAQAAQIEAWkABgY2TQAHBwBiAAAANABOG0A1AAMEBgQDBoAABQYBBgUBgAACAQgBAgiACQEIBwEIB34ABAABAgQBaQAHAAAHAGYABgY2Bk5ZWVlAEQAAAEUARCkjJScZJTUmCgkeKyQWFRQHBgYjIiY1NDY3BiMiJwYHBgYjIjU0NyYnJjU0NjMyFxc2NzY2MzIWFRQHFjMyNjc2MzIVFAYHDgIVFDMyNjc2MwHbDxEiXUVQVFpTBw4SHAoKChQNHBQhDhkdEggmGwwLDRMKDAwSFg4WMAQaCyEUDEZEJz4jSxkMD7cYFSgWKzBGR0VrOQEFChASDxYUIgsHDR4XKhIMGREUDwsOGjMFCwEHKBgjCjs/Oh4yJyEPAAADADf+0AHoA6wAQQBLAFIAYEBdRS0CAQQvAQUBDgECBU4BCAIETAABBAUEAQWACQYCBQIEBQJ+CwEIAAAIAGUKAQcHA2EAAwM1TQAEBDZNAAICNAJOTExCQgAATFJMUUJLQkoAQQBAGSomJS8mDAkcKyQWFRQHBgYjIiY1NDY2NzUmJjU0NzY1NCMiBgYHBgYjIiYmNTQSNjMyFhUUBgcGFT4CMzIWFRQHBgYVFBYzMjYzAgYGBzY2NTQmIxI2NwYVFDMB4gYfG2A/KjcjXVUfKwoICw0wMA8LHR8fHQo/e1YuOXaFAyFRTyEgIRACDQoKBAoFuywpDT5RDg0LMAloFXwLEWxqW184KiRBUDMCBTEpIjw4GBBDbj0vIS1eW5oBTuNPP2XZkTQ3VWsuISAkWgpSGxMPAgLNZ69nSaxGICL75Uw/PjcWAAAA//8AN//7AdMDrAACAnUAAAAB/5X+0QHJAdIAPwA9QDopAQABAUwAAwAEAAMEgAAGAAEABgFoAAQAAgQCZQgHAgUFNk0AAAA0AE4AAAA/AD4WKyQkKCQnCQkdKwAHBwYGFRQGIyImNTQ3IicGFRQXFhUUBiMiJjU0NjMyFhUUFjMyNjU0JyY1NDY3NjYzMhYVFAcGBzM2Nzc2NjMByQUKEhUfIyEeDFQhAgQETEk7Sh0WFh8QDBQPBAUSEgkoJhQQDwgHfwkMCQghIQHSIDlelEUmISIiOkMCHicWOkAfhHUzMxwjGBQND0BTIkg+NzWNOB0bCg4QOCEvKS4hHhoAAAAC/+X+0AHmAdAAOAA/AJxLsB1QWEAPKAQCAQYfAQMAOwEHAwNMG0APKAQCAQYfAQMFOwEHBANMWUuwHVBYQCMAAQYABgEAgAkBBwACBwJlCAEGBjZNBQEAAANhBAEDAzQDThtALQABBgAGAQCAAAAFBgAFfgkBBwACBwJlCAEGBjZNAAMDNE0ABQUEYQAEBDQETllAFTk5AAA5Pzk+ADgANyMoJicjKgoJHCsAFhUUBwYHBxQXFjMyNzY2MzIWFRQGBwYGIyImNTQ2NwYjIiYnJjU0NyMCIyI1NDYXFjY3Njc2NjMSNjcGFRQzAVIkBAQCAQsIFRQQCQ4GCggQExliPyo3UnEREg8bBx0JA1OERBkUGSwbOBwPLCsCMQpqFQHQHiINSC01HzITEQwHBw0SNV5CWmA4KjJlQAUOCidYM0P+6zAWGwEBMDdxUSsh/V5MPz43FgAAAAIACf/7AgwB0gArADUAR0BELhkCBAEkAQMEAkwAAQUEBQEEgAYBBAMFBAN+BwEFBQJhAAICNk0AAwMAYQAAADQATiwsAAAsNSw0ACsAKiYqKSYICRorJBYVFAcGBiMiJicmJyYmNTQ2MzIXFhYXFhcXPgIzMhYVFAYHFjMyNjc2MyYGFRU2NjU0JiMB/Q8RHFs/TWQRMRUYHBYQEQoJDAMEEQQDOmY/OkZjdxg5KTUjDA/JMztEFRLBGBUkGiswTEMFCAgkGBodBQUNDQ4EAUNxQ0U7RWMdLiYtD69WPQIOOCUTFwAAAAACAAn/BgIMAdIAQABKAKhLsBJQWEAPQy4CBgM5AQUGHAEABQNMG0APQy4CBgM5AQUGHAEBBQNMWUuwElBYQCsAAwcGBwMGgAgBBgUHBgV+AAUABwUAfgEBAAACAAJmCQEHBwRhAAQENgdOG0AxAAMHBgcDBoAIAQYFBwYFfgAFAQcFAX4AAQAHAQB+AAAAAgACZgkBBwcEYQAEBDYHTllAFUFBAABBSkFJAEAAPyYqLiUiKwoJHCskFhUUBwYHBgYVFBYzMjc2MzIVFAcGBiMiJjU0NyYmJyYnJiY1NDYzMhcWFhcWFxc+AjMyFhUUBgcWMzI2NzYzJgYVFTY2NTQmIwH9DxEzZRoYJBoaFREKGi8MJxBFUS8uPQwxFRgcFhARCgkMAwQRBAM6Zj86RmN3GDkpNSMMD8kzO0QVEsEYFSQaTwoWMxkdHgcGJSgQBAZHPUU3D0QxBQgIJBgaHQUFDQ0OBAFDcUNFO0VjHS4mLQ+vVj0CDjglExcA//8AIv/7ARgDHAACBH4AAP//ABH/+wMiAvQAIgSwAAAAAwXjAtMAAP//ADL+0AH2AdIAAgTgAAAAAf/l/0sB2wHQADMAa0uwHVBYQAwuFwICAzESAgECAkwbQAwuFwIEAzESAgECAkxZS7AdUFhAFgQBAgIBYQABATRNAAAAA2EAAwM2AE4bQB0ABAMCAwQCgAACAgFhAAEBNE0AAAADYQADAzYATlm3GiYjLSoFCRsrJBYVFAcOAgcGBiMiJjU0NzY3JiY1NDcjAiMiNTQ2FxY2NzY3NjYzMhYHBhUUFxYWFzYXAc0OCyosGwUbJBkUGRAmKRsaAwJThEQZFBksGzgcDywrKyICBAQDCwwQIGIPCwwNLDosCCsfGBIVFjNBFlhGIif+6zAWGwEBMDdxUSshIyViHyk6IyAHCwIAAAD//wAy/tABxAHSAAIE5AAAAAEAMv9LAckB0gA+ADVAMjwSAgIGAUwABgECAQYCgAAAAgCGAAQAAQYEAWgFAQMDNk0AAgI0Ak4XJRYmJioqBwkdKyQWFRQHDgIHBgYjIiY1NDc2NyY1NDciJwYVFQ4CIyImNTQ3NjYzMhYVFAcGBzM2Nzc2NjMyBwYHBgYHNjMBuw4LKiwbBRskGRQZECMoDAxVIAIBBBQXJh8lCSklFBAPCAd/CQwJCCEhLgUDCA8TAwkSYg8LDA0sOiwIKx8YEhUWL0ARHzpDAhwLFT4yF1BYgnUdGwoOEDghLykuIR4aIBQnVYE/AQABAD7/hwG3AewAOwDitQ8BAQYBTEuwDFBYQCoAAwQDhQgBBwIGAgcGgAAAAQEAcQACAgRhBQEEBDZNAAYGAWEAAQE0AU4bS7AXUFhALQADBQOFCAEHAgYCBwaAAAABAIYABQU2TQACAgRhAAQENk0ABgYBYQABATQBThtLsDBQWEArAAMFA4UIAQcCBgIHBoAAAAEAhgAEAAIHBAJpAAUFNk0ABgYBYQABATQBThtAKQADBQOFCAEHAgYCBwaAAAABAIYABAACBwQCaQAGAAEABgFpAAUFNgVOWVlZQBAAAAA7ADopIyMmNSUpCQkdKyQWFRQHBgcOAiMiJjU0NwYjIiY1NDY3BiMiJicmNTQ2MzIXFhYzMjY3NjMyFRQGBw4CFRQzMjY3NjMBqA8RHCMJERcTFRcCCA9QVFpTBw4hNRwZHRIKFxorHBYwBBoLIRQMRkQnPiNLGQwPtxgVKBYkFTo6GCUlFQwBRkdFazkBDA4NHhcqDg8RCwEHKBgjCjs/Oh4yJyEPAAH/8v9LAqgB0wBPAHpLsB1QWEANPScXAwMETRICAQMCTBtADT0nFwMGBE0SAgEDAkxZS7AdUFhAGAYBAwMBYQIBAQE0TQAAAARhBQEEBDYAThtAHwAGBAMEBgOAAAMDAWECAQEBNE0AAAAEYQUBBAQ2AE5ZQBBPTkRCOTcxLywqIB4qBwkXKyQWFRQHDgIHBgYjIiY1NDc2NyYmNTQ3IwYGBwcGBiMiJicmJjU0NyMGBiMiNTQ2MzI2PwI2NjMyFhUUFzM2Njc2MzIWFRQHBhUUFhc2FwKaDgsqLBsFGyQZFBkQHy8TFRACFygbFwodFxQWCAkMAwIfYj5AGhQWJhgTKwonIR8iBwIQSBYmLCQaAwQLDBIgYg8LDA0sOiwIKx8YEhUWKkoQOCNLcilgSD0cFxYcIGsyIR6TmjAVGzRIOoQfHRkWm0I1lhkpHyoiNlooKiYGCwL//wAj//sB8QL0ACIEpgAAAAMF4wJfAAD//wAj//sB8QKxACIEpgAAAAMFpAJfAAD//wAk//sCtgHUAAICTgAA//8AIf/7AccC9AAiBK0AAAADBeMCNQAA//8AKP/7AbUB0wACAagAAP//ACj/+wHEArEAIgGoAAAAAwWkAjIAAP//ABH/+wMiArEAIgSwAAAAAwWkAtMAAP///9b+OQHMArEAIgSxAAAAAwWkAjoAAAAC/9b+OQHTAdcAMAA6AIi3NRUIAwUBAUxLsBdQWEAZAAEBAmEGBAMDAgI2TQcBBQUAYQAAADgAThtLsDBQWEAdAAMDNk0AAQECYQYEAgICNk0HAQUFAGEAAAA4AE4bQB8AAwIBAgNyAAEBAmEGBAICAjZNBwEFBQBhAAAAOABOWVlAEzExAAAxOjE5ADAAL0EkLy4ICRorABYVFAYHBgYHFhYVFAYGIyImNTQ2NyYmJyYmNTQ2NjcHBiY1NDYzMhcWFjMyNzY2MwA2NjU1BgYVFDMBvhUeIF9xHFBIRXNANzxmgAkfGiQgOWI6qhYXFxQuTRBVHQocBR0K/r47KU9JHAHXHB0gJA4oYj0ZY1NcsXA9OFWfZQ0UDBAmFxxUVR4EASEXGCUHAQYIAQj8wFl+MApCczQoAP//ADD/+wHJAnIAIgSyAAAAAwWvAlAAAP//ADD/+wHjArEAIgSyAAAAAwWkAlEAAP//ACH/+wHDArEAIgS7AAAAAwWkAjEAAAADACH/+wGyAdMADwAYAB8APUA6AAIABAUCBGcHAQMDAWEGAQEBNk0IAQUFAGEAAAA0AE4ZGRAQAAAZHxkeHBsQGBAXFRIADwAOJgkJFysAFhYVFAYGIyImJjU0NjYzBgYHMjc3JiYjEjY3IxYWMwE0VCo6Yzw7Uyo5Yj0jKQkMJF8GJRcLJwqMBiUYAdM7YDdMd0M7YDdMd0NsKikCAycn/wAlJCYjAP//ACH/+wHCArEAIwWkAjAAAAACBQoAAP//ACP/+wHTArEAIgTQAAAAAwWkAkEAAP////z+OQHJAnIAIgTAAAAAAwWvAlAAAP////z+OQHjArEAIgTAAAAAAwWkAlEAAP////z+OQIcA0QAIgTAAAAAAwWoAlEAAP//AD7/8QHHArEAIgTEAAAAAwWkAjUAAP//ACX+0AF5AdsAAgTdAAD//wA0//sCpwKxACIEywAAAAMFpAKuAAAAAgAO/tABeQHbAE8AVgBnQGRGPjoeEwUGAgwBAQdSAQkBA0wABAMCAwQCgAACBgMCBn4ABggDBgh+CgEIBwMIB34LAQkAAAkAZQADAwVhAAUFNk0ABwcBYQABATQBTlBQAABQVlBVAE8ATicsJiQqKiYlDAkeKyQVFAcGBiMiJjU0NjcGIyImNTQ3JyYmNTQ2MzIXFhc2NzY2NTQmIyIGBwYGIyImNTQ3NjYzMhYVFAYHFxYWFRQHBiMiJyYnBhUUFjMyNzYzAjY3BhUUMwF5HxliPyo3TWksJzdGIBIWDw8OFSwKEBsFKiYWFRMeEgoVCRMVGRROKEtNOzUPFxIBAyIYJAMpCyAoNjEOC5swCWgVfiBsaFpgOCoxYj8NRTY2JwgKExILDRIEBA8CFyEXDQ8LCgUJGRQbEw8UNTI5QBsGCxMLBQMRBwEJEBEWEhcH/rBMPz43Fv//ABH+0AIfAdYAAgTsAAAAAQAR//sCVwHWAFQBdEuwJlBYQBIzAQYIEwEPAhYBAwQJAQADBEwbQBIzAQYIEwENAhYBAwQJAQADBExZS7AJUFhAPgACBQ8DAnIQAQ8EBQ8EfgwBBQ0BBAMFBGkLAQYGCGEJAQgINk0KAQcHCGIJAQgINk0OAQMDAGIBAQAANABOG0uwHVBYQD8AAgUPBQIPgBABDwQFDwR+DAEFDQEEAwUEaQsBBgYIYQkBCAg2TQoBBwcIYgkBCAg2TQ4BAwMAYgEBAAA0AE4bS7AmUFhARAACBQ8FAg+AEAEPBAUPBH4ADAUEDFkABQ0BBAMFBGkLAQYGCGEJAQgINk0KAQcHCGIJAQgINk0OAQMDAGIBAQAANABOG0BGAAIFDQUCDYAQAQ8NBA0PBIAADAANDwwNaQAFAAQDBQRpCwEGBghhCQEICDZNCgEHBwhiCQEICDZNDgEDAwBiAQEAADQATllZWUAeAAAAVABTUU9MS0dFQ0E9Ozc1JCQiEyIlJCMlEQkfKyQWFRQHBiMiJicGIyImNTQ2MzIVFAcHFDMyNjcjBiY1NDcmJiMiBgcGBiMiJjU0NjMyFhc2NjMyFhUUBiMiJicmJiMiBgczMhYVFAYjIxYWMzI3NjMCSA8RO20vSRc6TTdALiokAgMaFCUKBBoeRgERDQsKBQYUGRYaPjEqRBIeSyQnKSIYFhAEAggKCxsJEx4cIjAGASkcNzYKEcEYFSQaWyUjR0A1Mj4bCBQmHjEoARMSLgQiLgsNEBMfIDM6KScoKCQoLTMSEQwMKSEVDRkcLTRPDwAAAQAV//sBlgHbADcAR0BEBAEEAwFMAAECAwIBA4AABgQFBAYFgAADAAQGAwRpAAICAGEAAAA2TQAFBQdhCAEHBzQHTgAAADcANiMkJCQkJSoJCR0rFjU0NjcmJjU0NjYzMhYWFRQGIyImJyYmIyIGFRQWMzIWFRQGIyIGFRQWMzI2NzYzMhYVFAcGBiMVMTIaHChNNiY/IxgVDRANDRkVHyAkJRYUEhEyMCMpKTUjDA8NDxEbYUIFhiY7DQ08HyM9JBosGRMWCQsNDR0XHhgUFxEUHhoYGCYtDxgVJBoqMf///+X+0AHmAdAAAgTzAAD//wAj/rEB0QH6AAICvwAA//8AM//7Ar4B0wACAu8AAP//AA//+wHMAoEAAgTYAAAAA/+J/jcB2wHYACgAPgBHAFVAUh8BBgM6AQUGMyonFQIFAAVBPgIBAARMAAUGAAYFAIAAAAEGAAF+AAYGA2EEAQMDNk0AAQE0TQgBBwcCYQACAjgCTj8/P0c/RiUtJikiFCUJCR0rJBYVFAcGIyInJwYGBwYCIyImNTQSNzQnJjYzMhYXFBc2NjMyFhUUBxcGNycmJjU0NjMyFzY1NCYjIgcGFRQHAjY3BgYVFBYzAckSAQMiGCQFJWQ2DVxZNjRaXgIBMCQVEwEBID4jOEcfFcwjBBYPDg4RHxMYFCQzAQGkJAUrMg8KkxMLBQMRBwEvOQHB/v1ORWIBBZ2SOR0iERkZDCgjWklJQQk6KwIKExILDQsxNB4fTCxVLhn+PuuvZLY+ICIAAAABADf/+wG+AdIAKQAlQCIMAQMCAUwAAwABAAMBagQBAgI2TQAAADQATiMoJiYmBQkbKwAHBgYVFAYjIiY1NDcGBiMiJjU0NzY2MzIWBwYHBgYVFDMyNjc2MzIWFQG+DxASHyMgFRYfTScuNCUKJiYUEgMGAgsTFxxLFhJAFxIBoUlZgTwmIR8lSWdAPD02SWseGhIOFA8rVREcckY4Cw8AAQA3//sCVgHSADMAqEuwCVBYtRcBAQQBTBtLsApQWLUXAQUEAUwbtRcBAQQBTFlZS7AJUFhAHwYBBAEEhQUBAQADAAEDaQAAAgIAWQAAAAJhAAIAAlEbS7AKUFhAJgYBBAUEhQABBQMFAQOAAAUAAwAFA2kAAAICAFkAAAACYQACAAJRG0AfBgEEAQSFBQEBAAMAAQNpAAACAgBZAAAAAmEAAgACUVlZQAojJyYlJiMlBwYdKwAHBhUUFjMyNjc2MzIWFRQHBgYjIjU0NwYGIyImNTQ3NjYzMhYHBwYGFRQzMjY3NjMyFhUBvhwZDg8UOisMDw0PEy5iP10VH00nLjQlCiYmFBIDDQkQFxxLFhJAFxIBlXpsHBgSMzUOGBUoFjZDZDNdQDw9NklrHhoSDjclSQ8cckY4Cw8AAAIAMP/7Ak8CgwAQAEkAWkBXHAEGAkYBBQMCTAQBAgEGAQIGgAAGAwEGA34AAAkBAQIAAWcAAwUHA1kABQcHBVkABQUHYQoIAgcFB1EREQAAEUkRSERCPDo3NS0rJiQaGAAQAAxTCwYXKxImNTQzNzYzMhYVFAYjIgcHAiY1NDY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzIWFRQHBhUUFjMyNjc2MzIWFRQHBgYjIiY1BgYjsx5TR1IeHhwiMEVUIWQ5FBcKJCcWEQsKBhQKCw8tMxgIISEXEhkcEA0UNy4MDw0PEytjPzAtEUQnAiYTEjICBBUNGRwEAf3UUz5LfUYeGg4OCC4lHmkjFRE8elkeGgsPGXCAHhMVMTcOGBUoFjVESkNESQAAAgAw//sDNgKDAA8AXwBtQGowAQsHIQEGCxoBCgYDTAkBBQEHAQUHgAAHCwEHC34NAQsGAQsGfgAADAEBBQABZwgBBgoCBlkACgICClkACgoCYQQDAgIKAlEQEAAAEF8QXltZUU9KSEA+OjguLCUjHhwYFgAPAAtDDgYXKxImNTQzNzcyFhUUBiMiBgcAFhUUBwYGIyImNwYGIyI1NDcGBiMiJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjc2NjMyFhUUBwYVFBYzMjY2NzY2MzIWFRQHBhUUFjMyNjc2M7MeU5nmHhwiMFjjRwJaDxMuYT4wLgERRCdbAx5ELS05FBcKJCcWEQsKBhQKCyE/JQkYIBoUDhQKCw8tMxgIISEXEhkcEA0UNy4MDwImExIyAgQVDRkcAwL+uBgVKBY1REtCRElsExVITFM+S31GHhoODgguJR5pIxURlXoeFREVFE10IRURPHpZHhoLDxlwgB4TFTE3DgAAAgAw//sB2QKDABAAQABCQD8cAQMCAUw9AQMBSwAABwEBAgABZwQBAgI2TQADAwViCAYCBQU0BU4REQAAEUARPzk3LSsmJBoYABAADFMJCRcrEiY1NDM3NjMyFhUUBiMiBwcCJjU0Njc2NjMyFhUUBwYHBhUUFjMyNjY3NjYzMhYVFAYHBgYVFAYjIiY1NDcGBiOzHlNHUh4eHCIwRVQhZDkUFwokJxYRCwoGFAoLDy4zFwghIRYTCAUKDB8jJR0CEUMmAiYTEjICBBUNGRwEAf3UTURLfUYeGg4OCC4lHmkjFRE9e1ceGhcXGT0gQGlDJiEnOAsmRkoAAAAAAgAw//sCoQKDAA8AVgCLS7AuUFhADCUWAgUEAUxWAQUBSxtADCUWAgUGAUxWAQUBS1lLsC5QWEAeAAAKAQEEAAFnCAYCBAQ2TQcBBQUCYgkDAgICNAJOG0AiAAAKAQEEAAFnCAEEBDZNAAYGNk0HAQUFAmIJAwICAjQCTllAGgAAUlBGRD89NTMvLSMhGhgTEQAPAAtDCwkXKxImNTQzNzcyFhUUBiMiBgcABiMiNTQ3BgYjIiY1NDY3NjYzMhYVFAcGBwYVFBYzMjY3NjYzMhYVFAcGFRQWMzI2Njc2NjMyFhUUBgcGBhUUBiMiJjU0N7MeU5nmHhwiMFjjRwEbQyhbAx5ELS05FBcKJCcWEQsKBhQKCyE/JQkYIBoUDhQKCw8tMxgIISEWEwgFCgwfIyUdAgImExIyAgQVDRkcAwL+HkpsExVITFM+S31GHhoODgguJR5pIxURlXoeFREVFE10IRURPHpZHhoXFxk9IEBpQyYhJzgLJgAAAAABABH+mANOAzwAeQGjQBQ5AQUEWgEJBRABAgl5TR0DAwIETEuwCVBYQEEABwYHhQAFBAkEBXIACQIKCXAMAQIDAwJwAAABAIYACAAKBAgKaQAGAAQFBgRpCwEDAQEDWQsBAwMBYg0BAQMBUhtLsApQWEBFAAcGB4UABQQJBAVyAAkCCglwDAECAwMCcAAAAQCGAAgACgQICmkABgAEBQYEaQADCwEDWQALAQELWQALCwFhDQEBCwFRG0uwC1BYQEAABwYHhQAFBAkEBXIACQIKCXAMAQIDAwJwAAABAIYACgQGClkIAQYABAUGBGkLAQMBAQNZCwEDAwFiDQEBAwFSG0uwFlBYQEMABwYHhQAFBAkEBXIACQIECQJ+DAECAwQCA34AAAEAhgAIAAoECAppAAYABAUGBGkLAQMBAQNZCwEDAwFiDQEBAwFSG0BEAAcGB4UABQQJBAUJgAAJAgQJAn4MAQIDBAIDfgAAAQCGAAgACgQICmkABgAEBQYEaQsBAwEBA1kLAQMDAWINAQEDAVJZWVlZQBd2dG5saWdiYFhWUlAnJCQlJiQuJA4GHiskAgcGBiMiJjU0NzY3Njc2NyMOAiMiJjU0NjMyFRQHBhUUMzI2NjU0JiMiBgcGBiMiJjU0NjMyFhc2Ejc2NjMyFhUUBwYHBgYHBgcGBzM2NjMyFhUUBiMiJjU0Njc2NTQjIgYGFRQWMzI2NzYzMhYVFAcGBiMiJiYnAbg5GgwjHx4cAwoOLh8UCAIdMU86N0AuKiQCAxoTIxcSDQsKBQYUGRYaQTEwQhcKNRoMJR8eHAMKDhckAwYIEQ0CJGRNNDslHhMXBAEFGhQmFzIvJTozDA8NDxMtWjk1Ti8HSv7tVykfFRYLDi4tkoVUUFBiREA1Mj4bBxIkBR4tTi8kMQsNEBMfIDI7S0xTAQ1VKR8VFgsOLi1OlQ0eHUZejnZBMyo6EhAHEgQPDRspRSg2QTE9DhgVKBY2QzBJJQAAAQA6//sCWgM8AEQAhkALMgEEBSgLAgYHAkxLsA9QWEAtAAIDAoUABAUHBQRyCAEHBgUHBn4AAwAFBAMFaQAGAAAGWQAGBgBhAQEABgBRG0AuAAIDAoUABAUHBQQHgAgBBwYFBwZ+AAMABQQDBWkABgAABlkABgYAYQEBAAYAUVlAEAAAAEQAQyUmIy4pJyYJBh0rJBYVFAcGBiMiJiYnBgcGBiMiJjU0NzYSNzY2MzIWFRQHBgcGBwcGBgc2NjMyFhUUIyI1NDY1NCYjIgYGFRQWMzI2NzYzAksPEy1aOS9NMAcCDQsdHiYfBAg7HQwlHx4cAxAFNxAGBwwBJG5ONDs8KgMODBQmFzIvJTozDA/fGBUoFjZDKTobCDAoHlBYLydlAT5YKR8VFgsOSBPDWh4oTCCMeEEzRh4HEQoLDSlFKDZBMT0OAAEAEf6YAyIDPAB2AflAF0gBBwZoAQsHHwEEC1ssAgAEDgEFAAVMS7AJUFhAPgAHBgsGB3IACwQGC3AABAAFBHAAAAUGAAV+AAIBAoYACQkzTQwBBgYIYQoBCAg2TQ4NAgUFAWIDAQEBNAFOG0uwDFBYQD8ABwYLBgdyAAsEBgtwAAQABgQAfgAABQYABX4AAgEChgAJCTNNDAEGBghhCgEICDZNDg0CBQUBYgMBAQE0AU4bS7AVUFhAQAAHBgsGB3IACwQGCwR+AAQABgQAfgAABQYABX4AAgEChgAJCTNNDAEGBghhCgEICDZNDg0CBQUBYgMBAQE0AU4bS7AXUFhAQQAHBgsGBwuAAAsEBgsEfgAEAAYEAH4AAAUGAAV+AAIBAoYACQkzTQwBBgYIYQoBCAg2TQ4NAgUFAWIDAQEBNAFOG0uwG1BYQEsABwYLBgcLgAALBAYLBH4ABAAGBAB+AAAFBgAFfgACAQKGAAkJM00ADAwIYQoBCAg2TQAGBghhCgEICDZNDg0CBQUBYgMBAQE0AU4bQEsACQgJhQAHBgsGBwuAAAsEBgsEfgAEAAYEAH4AAAUGAAV+AAIBAoYADAwIYQoBCAg2TQAGBghhCgEICDZNDg0CBQUBYgMBAQE0AU5ZWVlZWUAaAAAAdgB1cG5mZGBeT00kJCUmJC4nJSMPCR8rJDY3NjMyFhUUBwYjIiYnBgIHBgYjIiY1NDc2NzY3NjcjDgIjIiY1NDYzMhUUBwYVFDMyNjY1NCYjIgYHBgYjIiY1NDYzMhYXNhI3NjYzMhYVFAcGBwYHBgcGBzM2NjMyFhUUBiMiJjU0Njc2NTQjIgYGFRQWMwKWNh8MDw0PETttRlUMCjkaDCMfHhwDCg4uHxQIAh0xTzo3QC4qJAIDGhMjFxINCwoFBhQZFhpBMTBCFwo1GgwlHx4cAwoOHyQEBRENAiRkTTQ7JR4TFwQBBRoUJhcoJ2MnKA8YFSQaW2E9T/7tVykfFRYLDi4tkoVUUFBiREA1Mj4bBxIkBR4tTi8kMQsNEBMfIDI7S0xTAQ1VKR8VFgsOLi1lnhYSRl6OdkEzKjoSEAcSBA8NGylFKDZBAAAAAAEAOv/7AjkDPABEALhADyoBAwQgDQIGAwMBBQYDTEuwDlBYQCoAAwQGBANyAAYFBAYFfgABATNNAAQEAmEAAgI2TQAFBQBhCAcCAAA0AE4bS7AbUFhAKwADBAYEAwaAAAYFBAYFfgABATNNAAQEAmEAAgI2TQAFBQBhCAcCAAA0AE4bQCsAAQIBhQADBAYEAwaAAAYFBAYFfgAEBAJhAAICNk0ABQUAYQgHAgAANABOWVlAEAAAAEQAQyMlJiMuKScJCR0rBCYmJwYHBgYjIiY1NDc2Ejc2NjMyFhUUBwYHBgcHBgYHNjYzMhYVFCMiNTQ2NTQmIyIGBhUUFjMyNjc2MzIWFRQHBgYjAVFJLQcCDQwcHiYfBAc9HAwlHx4cAxAFNxAGBwwBJG5ONDs8KgMODBQmFy0uIjYfDA8NDxEbVzYFKTobCDApHVBYHDpfAT5eKR8VFgsOSBPDWh4oTCCMeEEzRh4HEQoLDSlFKDdAJygPGBUkGioxAAAAAgAgAAACcgNPABEAFAArQCgTAQIAAUwAAAAlTQQBAgIBXwMBAQEmAU4SEgAAEhQSFAARAA8nBQgXKzImNTQ3ATY2MzIWFxMWFRQjISUDAz4eBgFDCSMUFB4EkAM8/h0BmlbkGxYMDwLZFBYWFP0oDQ0zcgIY/egAAf/r//4DHgNQADsALkArAAUFAmEAAgIlTQMBAQEAXwQGAgAAJgBOBgAwLiYeGhgSEAsJADsGOgcIFisWJycjBiMiNTQ2MzMmNTQ2NjMyFhYVFAYHFzIWFRQGIyInJyMGIyI1NDc2NjU0JiMiBgYVFBcWFhUUBiP0KEEnEjUyO0AhR2+/dFmPVExGJEAtGiUbKEEnEjUyEllmZE9NdkJmDAkaJQICAQEuKSNQkpPkfVCbbHrFQQEaHR8kAgEBLiASRreLd3tfq22kVQoRDh8kAAEAHP73Ak8B0gA/AEVAQgwBBAA2AQMBAkwCAQAEAIUABAEEhQABAQVhBgEFBShNAAMDBWEGAQUFKE0IAQcHKQdOAAAAPwA+FCYjKCUqKAkIHSsSJjU0NzY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzIWFRQHBhUUFjMyNjc2MzIWFRQHBgYjIiY1BgYHBhUXFAYjOh4RDx8KJCcWEQsKBhQKCw8tMxgIISEXEhkcEA0UNy4MDw0PEytjPzAtEEIpAgEmGv73FhveoJZeHhoODgguJR5pIxURPHpZHhoLDxlwgB4TFTE3DhgVKBY1REpDQ0gCNUlMIBoAAQAX//sCcQHtADUAOkA3FgEABgFMCAEHAQYBBwaABQMCAQEEXwAEBCdNAAYGAGECAQAAKABOAAAANQA0JhRTJiQVJgkIHSskFhUUBwYGIyImNTQ2NyMGBwYGIyImNTQ3NjcjIiY1NDsDMhYVFAYjIwcGFRQWMzI2NzYzAmIPEy1bMUE7FBB5KAoCIiQgGAIOIgoeFS1u528QDjMqAQ4YEBMSNi0MD98YFSgWNURcTCl/PL2VIBoaHAgUppQWGDgOEyEkS24nHiAyNg4AAgAz//sB+wJIAA0AGQAqQCcAAAACAwACaQUBAwMBYQQBAQE0AU4ODgAADhkOGBQSAA0ADCUGCRcrFiY1NDY2MzIWFRQGBiM2NjU0JiMiBhUUFjOeaz9xS2JrP3FLQD4uLDY+LS0FgHdlm1aAd2WbVnB4Z0VJeWdFSAAAAAEAOP/7AUsCSAAcACpAJwsGAgABAgECAAJMAAEAAYUAAAIAhQMBAgI0Ak4AAAAcABspGAQJGCsWJjU3NjY3BwciJjU3PgI3NzYzMhYVFAcGAwYjqyYBCx8LTgwTFgECFDk5KhcPHR0DEC0IPwUeIAtn3zwWAh4TCRMYGA4KBR4bDA5O/pI+AAABAC7/+AIHAkgALwCKS7AZUFhAHgAEAwYDBAaAAAUAAwQFA2kHAQYGAGECAQIAADQAThtLsCxQWEAiAAQDBgMEBoAABQADBAUDaQABATRNBwEGBgBhAgEAADQAThtAJAAEAwYDBAaAAAEGAAABcgAFAAMEBQNpBwEGBgBhAgEAADQATllZQA8AAAAvAC4lIysjQSQICRwrJBYVFAYjIicmJiMiBwYGIyImNTQ2Nz4CNTQmIyIGFRQjIiY1NDY2MzIWFRQGBzcB8RYhHDBfE2YdDRkFHQoQFR4gRHlJIyYsNTscHzRoS1pmhX3lcBwVGikHAQYJAQgdHSAjDh5dbDEnJTArOyAeMlQzWlBMpkAEAAEAHP/7AeYCSAA1ADxAOTUBAwUBTAAFBAMEBQOAAAMBBAMBfgABAgQBAn4ABgAEBQYEaQACAgBhAAAANABOJSMpJCQkJQcJHSsAFhUUBgYjIiY1NDYzMhYXFhYzMjY1NCYnJiY1NDY3NjY1NCMiBwYGIyImNTQ2NjMyFhUUBgcBlkU+aT5tbSAbFxcIBywuLDk2ORUVERVCO0xUDwcbGBsdOGdFYGZJOgEWRjUzSCVMOSElFxwbHCEiIyECARsTGBUECjkoN0IbFx8aKEgsSkkwUxUAAQAw//ECKAJIAC4AWrUGAQEAAUxLsDBQWEAbAAMFA4UHBgIEAgEAAQQAagAFBTZNAAEBNAFOG0AbAAMFA4UAAQABhgcGAgQCAQABBABqAAUFNgVOWUAPAAAALgAtJBYoNCMjCAkcKyQVFAYjIwcGBiMiNTQ3NyInIiY1NDc2NzY2MzIWFRQHBgczNjc2NjMyFRQHBgczAigoKxUEAyElNQEFkUsWIgcsWBMnKRYXCmIomgwVCCQgMwISDiThLSQcNS4gQQsGMQEoIBMVgKMjHRQQERGzbl1UHyEsDQdVXAABAC7/+wH0AkgANwA4QDUAAgQDBAIDgAAGCAcCBQAGBWkAAAAEAgAEaQADAwFhAAEBNAFOAAAANwAyNScjIyQlEwkJHSsABwYHFhYVFAYGIyImNTQ2MzIWFxYzMjY1NCcmJjU0Nzc2NyMiJjU0NzYzMhYXFhYVFAYjIicmIwD/DQ0QgYY1ZkVdcR8cFhgIEVYlMLsoIwMLBg4CFBgwLXVUTBUUEBsgEC5UCwHdASxMB1xPNFMwSD0hJRccPS0hWAYBGBkMDTAdPBMRMQ8OBQUFEREiHQIDAAACADL/+wIDAkgAIQAtAEdARBgBAwQCAQYAAkwAAwQABAMAgAACBwEEAwIEaQAACAEGBQAGaQAFBQFhAAEBNAFOIiIAACItIiwoJgAhACAlJSYkCQkaKwAGBzY2MzIWFhUUBgYjIiY1NDY2MzIWFxcUBiMiJicmJiMGBhUUFjMyNjU0JiMBBkkJGkIoMk8sNWVFZ21Ff1VNYwcBIR4WGwoIJRxRMCgkKDEoIgHlW1oeGSpLLjlbNYFyZp1XRzoLGh0XHBUY4jAoJCozKSIoAAAAAQAt//sCBgJGACQAQkuwF1BYQBEFBAMDAgABAAIBZwAAADQAThtAFgUEAgIDAwJwAAMAAQADAWgAAAA0AE5ZQA0AAAAkACNBJCYrBgkaKwAWFRQGBgcGBgcGBiMiJjU0NjY3ByImNTQ2MzIXFhYzMjc2NjMB8RUWIQdqUwkEJRwcJitfSfYVFiEcMV4TZh0NGQUdCgJGHR0bGxYFSbxrKiYnMTmJiDUEHBUaKQcBBgkBCAAAAwAo//sB6AJIABcAIQAtADJALyccFwsEAwIBTAABBAECAwECaQUBAwMAYQAAADQATiIiGBgiLSIsGCEYICokBgkYKyQVFAYGIyImNTQ2NyYmNTQ2MzIWFRQGByYGFRQXNjY1NCMSNjU0JicGBhUUFjMB3DloRWFtNDokJXhnVWc0OoAyTDMpTAY2Lz8uJDEq91QyTCpMRCtIHxhDJVBbSj8uSR++IyEtIxksGDf+dSAcFigcFSwaHB8AAAACACj/+wH5AkgAIQAtAEdARBYBAwYKAQIBAkwAAQMCAwECgAcBBAAFBgQFaQgBBgADAQYDaQACAgBhAAAANABOIiIAACItIiwoJgAhACAkJCUlCQkaKwAWFRQGBiMiJicnNDYzMhYXFhYzMjY3BgYjIiYmNTQ2NjMSNjU0JiMiBhUUFjMBjG1Ff1VNYwcBIR4WGwoIJRw6SQkaQigyTyw1ZUUXMCgkKDEoIgJIgXJmnVdHOgsaHRccFRhbWh4ZKksuOVs1/vgwKCQqMykiKAAAAQBnAWEBfANNABoAKUAmFAUCAAEBTAAAAQIBAAKAAAEBQ00DAQICRAJOAAAAGgAZKCcEChgrEiY3NjY3BwYjIiY3PgI3NzYzMhUUBwYDBiPuIAMJGglpCAMQEgICFEBDIxEUMgINJgY8AWEdIFa6Mh8CHxIPFRkSCQUxBRBA/s40AAAAAQA6AV8BxQNNAC8ANEAxAAMCBQIDBYAAAgIEYQAEBENNBgEFBQBfAAAARE0AAQFEAU4AAAAvAC4lIyskZAcKGysAFhUUBiMiJicmIyIGBwYjIiY1NDY3PgI1NCYjIgYVFCMiJjU0NjYzMhYVFAYHNwGyExwXFE4VXh8HFgQYDA0SGho5YDobGiUsMRgaLFc+S1VpY7QByRkSFyQEAQYGAQgZGBodDBlOWikcHiYhMRoaKUcqTEI+hzQDAAABAEYBYgHEA00ANQA+QDs1AQMFAUwABQQDBAUDgAADAQQDAX4AAQIEAQJ+AAQEBmEABgZDTQACAgBhAAAARABOJSMqFSQkJAcKHSsAFhUUBiMiJjU0NjMyFhcWFjMyNjU0JicmJjU0Njc2NjU0JiMiBwYGIyImNTQ2NjMyFhUUBgcBgDtuUVtbGhcTEQkHJCYfLiorERIOEjMuHRxEDgcWExcYLlc5UFU9MQJOOi0/Rj8wGx8SGBMWGhkcGgQBFw8UEgMJLyETFjIXExoWITwlPj0oRREAAAABAFYBWgHVA00AMQA6QDcsAQQFDQEBAAJMAAUDBAMFBIAHBgIEAgEAAQQAaQADA0NNAAEBRAFOAAAAMQAwJBgoMyQkCAocKwAWFRQGIyMGBwYGIyI1NzcmIyImNTQ3Njc2NjMyFhUUBwcGBgczNjc2NjMyFRQHBgczAcEUISQMAgICHiIsAQQsYxMfBSJMDyIlEhMIEiQrEVgMDwceGy8CDwsaAicUFB8ZDh4mGzYOKQEjGxEOZI8dGBAODBAhRVguVjgbGyUFDEVJAAAB/6gAZAFMAtgADwAXQBQAAAEAhQIBAQF2AAAADwAOJgMJFysmJjU0NwE2MzIWFRQHAQYjNiIMAS0WIBUgCf7IEBtkIBgRFQHxJSIXEA/9/hoAAP//AGf/8gPXA00AIgU0AAAAIwU4AXIAAAEHBTUCEv6TAAmxAgG4/pOwNSsA//8AZ//tA6EDTQAiBTQAAAAjBTgBcgAAAQcFNwHM/pMACbECAbj+k7A1KwD//wBG/+0D8QNNACIFNgAAACMFOAHCAAABBwU3Ahz+kwAJsQIBuP6TsDUrAAABAHIB9wIOA6QAQQBcQAs5LyQYDgMGAgUBTEuwF1BYQB0AAQABhgADAAIAAwJpAAQENU0AAAAFYQAFBTMAThtAGwABAAGGAAMAAgADAmkABQAAAQUAaQAEBDUETllACSclLyclKgYJHCsABgcHFxYWFRQHBiMiJycXFgYjIiY1NDc3BwYjIiYnJjU0Njc3JyYmNTQ3NjMyFxcnJjYzMhYVFAcHNzYzMhYXFhUCDh0YXFIREg0QFxsUOgMBHRkVHgYiUBQQERkFAxsZX1UQEg0OGRoVOgMBHRkWHQYjURUQEBkFAwLwHQMNLAkaDxMPExpJXRwjHhYNEFYxCxIQCQoWHAMNLAgaDxQPExtIWx0jHhYMEVYxDBMPCQoAAAEAbP/7AcsDpgARABlAFgAAADVNAgEBATQBTgAAABEAECcDCRcrBCYnAyY1NDYzMhYXExYVFAYjAXUfCN4EKRoSHQfjAykaBRsbAwoPDyIrGBn85gwLHisAAAD//wAvAJMA6QFNAQcFRgATAJgACLEAAbCYsDUrAAEAZgBUAZ0BigALAB5AGwAAAQEAWQAAAAFhAgEBAAFRAAAACwAKJAMJFys2JjU0NjMyFhUUBiOyTFVNSktWTFRQQUxZSUVNWwAAAP//ABz/+wD5AdIAIgVGAAABBwVGACMBHQAJsQEBuAEdsDUrAAABABD/YgDGALUAEwAXQBQAAAEAhQIBAQF2AAAAEwASKQMJFysWJjU0NzY2NTQ2MzIWFRQGBwYGIyoaAwsLLyUkJSoeFBcTnhQWCQwuTjAyNichI3Q3JRj//wAc//sC3gC1ACMFRgEEAAAAIwVGAggAAAACBUYAAAACACH/+wFuA00AEQAdADVAMgIBAQABTAQBAQACAAECgAAAADNNAAICA2EFAQMDNANOEhIAABIdEhwYFgARABAnBgkXKzYmNTc2Ejc2MzIVFAcGAgcGIwYmNTQ2MzIWFRQGI4waARE6GRBHQAMaVicLKVItMy4sLTQt6hITCHABHmhAKQkLav7TbyDvMCctNisqLjcAAv/m/n4BMwHQAAsAHwA0QDEYAQMCAUwAAgEDAQIDgAUBAwOEBAEBAQBhAAAANgFODAwAAAwfDB4WFAALAAokBgkXKxImNTQ2MzIWFRQGIwImNTQ3NhI3NjMyFhUHBgIHBgYjpi00LSwtMy7PHQMaVicLKRQaARE6GQgrJAEWKyouNzAnLTb9aBQUCQxqAS1vIBITCG/+4WghHwAAAgAi//gCqQJIAEkATQB9S7AJUFhAKQsBCQgICXAPBgIABQMCAQIAAWcOEA0DBwcIXwwKAggINk0EAQICNAJOG0AoCwEJCAmFDwYCAAUDAgECAAFnDhANAwcHCF8MCgIICDZNBAECAjQCTllAHgAATUxLSgBJAEhFQz48OTgzMSQhJCUjFSMjIREJHysBBzMyFRQGIyMHBgYjIiY1NDc3IwcGBiMiJjU0NzcjIiY1NDYzMzcjIiY1NDYzMzc2NjMyFhUUBwczNzY2MzIWFRQHBzMyFRQGKwIHMwIlIUk0GxlqEwkpFxUeAw91EwkpFxUeAw8dGRwcGT4iOBkcHBlZEwgpFxcfAxF1EwgpFxcfAxEuNBsZzHYhdQFadDccH0AdHxsYCgwzQB0fGxgKDDMfHBscdB8cGxxCHR0ZFQkJPEIdHRkVCQk8NxwfdAABABz/+wDWALUACwAZQBYAAAABYQIBAQE0AU4AAAALAAokAwkXKxYmNTQ2MzIWFRQGI0ktMy4sLTQtBTAnLTYrKi43AAIAQP/7AggDTQAlADEAPUA6AAEAAwABA4AGAQMEAAMEfgAAAAJhAAICM00ABAQFYQcBBQU0BU4mJgAAJjEmMCwqACUAJCUlKQgJGSs2Jjc2Njc2NjU0IyIGFRcUBiMiJjU0NjYzMhYVFAYHDgIHBgYjBiY1NDYzMhYVFAYjrRYBBDQ9OTJNLjABGRsfITFkSWNtQEA2OBkIBx8UUi0zLiwtNC3qFRg/Yj04TipFKR8pERklIjJTMlVQP2Y3LjorHBoZ7zAnLTYrKi43AAL/1P5/AZwB0QALADEAPEA5AAIBBAECBIAABAMBBAN+AAMHAQUDBWUGAQEBAGEAAAA2AU4MDAAADDEMMCspJCIZFwALAAokCAkXKwAmNTQ2MzIWFRQGIwImNTQ2Nz4CNzY2MzIWBwYGBwYGFRQzMjY1JzQ2MzIWFRQGBiMBDy00LSwtMy76bUBANjgZCAcfFBIWAQQ0PTkyTS4wARkbHyExZEkBFysqLjcwJy02/WhVUD9mNy46KxwaGRUYP2I9OE4qRSkfKREZJSIyUzIAAP//AG8B9gH7A0wAIgVKAAAAAwVKANwAAAABAG8B9gEfA0wADQAZQBYCAQEBAGEAAAAzAU4AAAANAAwkAwkXKxImNzc2MzIVFAcHBgYjkCEDFApNQgUoBygaAfYbIL9cPg4XuCAbAAAA//8AEP9iAPkB0gAiBUEAAAEHBUYAIwEdAAmxAQG4AR2wNSsAAAEACf/7Ai0DpwARABlAFgAAADVNAgEBATQBTgAAABEAECcDCRcrFiY1NDcBNjYzMhYVFAcBBgYjLCMOAaMMHxAXIQv+VAkbDwUhGxYaAxMXFiUbFhP83RAQAAAAAf/o/44BSAAAAAwAJrEGZERAGwAAAQEAVwAAAAFfAgEBAAFPAAAADAAKNAMJFyuxBgBEFiY1NDYzMzIVFAYjIwQcHBn3NBsZ93IfHBscNxwfAAAAAQAy/6ECQwOiADwAaUALDgEDBCkVAgEDAkxLsDBQWEAbAAQAAwEEA2kAAQACAQJlAAAABWEGAQUFNQBOG0AhBgEFAAAEBQBpAAQAAwEEA2kAAQICAVkAAQECYQACAQJRWUASAAAAPAA7NDIvLSEfGxkkBwkXKwAWFRQGIyIGBgcGBwcGBxYVFAcHBgcGFRQWMzIWFRQGIyImNTQ3NjY3NzY1NCYjIiY3NjMyNjc2Nzc2NjMCFS4hHTE4GQMDDQMMWEACCQwCATA+HCIyPGRfAgMHAgkBKy4bHAMHNjc4BwEOBgx1YAOiGiUUHBMoIilgG10lHlUKGD5YFgcMKSAeFh8fXlYbDhsvFEgGCyIfJxs1JzEFcjVZWAAAAAAB/9X/oQHqA6IAPQBrQA84JAIFAxwBAAUXAQIAA0xLsDBQWEAbBgEFAAACBQBpAAIAAQIBZQADAwRhAAQENQNOG0AhAAQAAwUEA2kGAQUAAAIFAGkAAgEBAlkAAgIBYQABAgFRWUAQAAAAPQA8MC4qKCQnIwcJGSsAFgcGIyIGBwYHBwYGIyImNTQ2MzI2Njc2Nzc2NyY1NDc2NzY3NjU0JiMiJjU0NjMyFhUUBwYHBgcGFRQWMwHOHAMHNjc4BwYNBgx1YDcuIR0xOBkDBA8EDFhAAgcBCAMBMD4cIjI8ZF8CAgcBBwErLgHsJxs1JzEubTBZWBolFBwTKCI5aCJdJR5VChg0AzYgBwwpIB4WHx9eVhsOFTUJNAYLIh8AAAABAEP/ogHyA6IAHQBQtQIBAAMBTEuwMFBYQBMAAwQBAAMAYwACAgFfAAEBNQJOG0AZAAEAAgMBAmcAAwAAA1cAAwMAXwQBAAMAT1lADwEAGBYRDwsIAB0BHAUJFisXIjU0NxITNjYzMzIWFRQGIyMGBgcCBzMyFhUUBiObWAIrRgguOowiHh8jeAohBygNaSciJCpdSwYQAV8B5jMmHRgiHlXwOP7pgRkcHyIAAf/Q/6IBfwOiAB0ATbUVAQECAUxLsCxQWEATAAAEAQMAA2MAAQECXwACAjUBThtAGQACAAEAAgFnAAADAwBXAAAAA18EAQMAA09ZQAwAAAAdABs0JSQFCRkrBiY1NDYzMzY2NxI3IyImNTQ2MxcyFRQHAgMGBiMjEh4fI3gKIQcoDWknIiQqmlgCK0YILjqMXh0YIh5V8DgBF4EZHB8iAUsGEP6h/hozJgAAAAEAW/97AuMDugArAGZLsCRQWEAiAAECBAIBBIAABAMCBAN+AAMGAQUDBWUAAgIAYQAAADUCThtAKAABAgQCAQSAAAQDAgQDfgAAAAIBAAJpAAMFBQNZAAMDBWEGAQUDBVFZQA4AAAArACoiKSImJwcJGysWJjU0NjY3NjMyFhcWFRQGIyInJiMiBgcOAhUUFhYzMjc2MzIWFRQHBgYj1XosVTpyoy9aHhEjFQoNQTYpSh81TCgVLiZIUxARExsUK3Y4hZqTbvDZSpEfHBAZGSwILSwnQ8fZXkpVJFMQIhccFzA7AAH/rv97AjYDugArAGZLsCRQWEAiAAMCAAIDAIAAAAECAAF+AAEGAQUBBWUAAgIEYQAEBDUCThtAKAADAgACAwCAAAABAgABfgAEAAIDBAJpAAEFBQFZAAEBBWEGAQUBBVFZQA4AAAArAComIikiJgcJGysWJicmNTQ2MzIXFjMyNjc+AjU0JiYjIgcGIyImNTQ3NjYzMhYVFAYGBwYjN1oeESMVCg1BNilKHzVMKBUuJkhTEBETGxQrdjhzeixVOnKjhR8cEBkZLAgtLCdDx9leSlUkUxAiFxwXMDuak27w2UqRAAEANwD2AkcBaAAMAB5AGwAAAQEAVwAAAAFfAgEBAAFPAAAADAAKNAMJFys2JjU0NjMhMhUUBiMhUxwcGQGnNBsZ/ln2HxwbHDccHwABADcA9gG/AWgADAAeQBsAAAEBAFcAAAABXwIBAQABTwAAAAwACjQDCRcrNiY1NDYzITIVFAYjIVMcHBkBHzQbGf7h9h8cGxw3HB8AAQA5APQBbwF+AAwABrMHAAEyKzYmNTQ2Nzc2FhUUBwdWHRsazRkbNM30IB0bGgIUAh0cNgUUAP//ADkA9AFvAX4AAgVWAAAAAgAbACoCPAGnABYALQAkQCElDgIBAAFMAgEAAQEAWQIBAAABYQMBAQABUSopKicECRorNyY1NDY3NzYzMhYVFAcHFxYVFAYjIic3JjU0Njc3NjMyFhUUBwcXFhUUBiMiJ0AlDg6fEhIXIReBgg8pGBILfSYODqASEhchGIGCDykYEgurHyMVJAlsDCEVGBBZbwwSFSQKdyAiFSQJbAwgFRkQWW8MEhUkCgAAAAIALAAqAk0BpwAWAC0AJEAhHgcCAAEBTAMBAQAAAVkDAQEBAGECAQABAFEqKSogBAkaKzYjIiY1NDc3JyY1NDYzMhcXFhUUBgcHFiMiJjU0NzcnJjU0NjMyFxcWFRQGBwd2EhchGIGCDykYEguMJg4OoPgSFyEXgYIPKRgSC40lDg6fKiAVGRBZbwwSFSQKdyAiFSQJbAwhFRgQWW8MEhUkCncfIxUkCWwAAAABABsAKgEyAacAFgAeQBsOAQEAAUwAAAEBAFkAAAABYQABAAFRKicCCRgrNyY1NDY3NzYzMhYVFAcHFxYVFAYjIidAJQ4OnxISFyEXgYIPKRgSC6sfIxUkCWwMIRUYEFlvDBIVJAoAAAEALQAqAUQBpwAWAB5AGwcBAAEBTAABAAABWQABAQBhAAABAFEqIAIJGCs2IyImNTQ3NycmNTQ2MzIXFxYVFAYHB3cSFyEXgYIPKRgSC40lDg6fKiEVGBBZbwwSFSQKdx8jFSQJbAD//wAQ/2IBogC1ACIFYQAAAAMFYQDcAAD//wBnAlMB+QOmACIFXwAAAAMFXwDcAAD//wBxAlMCAwOmACIFYAAAAAMFYADcAAAAAQBnAlMBHQOmABMAGUAWAgEBAAGGAAAANQBOAAAAEwASJwMJFysSJjU0Njc2NjMyFhUUBwYGFRQGI4wlKh4UFxMWGgMLCy8lAlMnISN0NyUYFBYJDC5OMDI2AAABAHECUwEnA6YAEwAZQBYCAQEAAYYAAAA1AE4AAAATABIpAwkXKxImNTQ3NjY1NDYzMhYVFAYHBgYjixoDCwsvJSQlKh4UFxMCUxQWCQwuTjAyNichI3Q3JRgAAAEAEP9iAMYAtQATABdAFAAAAQCFAgEBAXYAAAATABIpAwkXKxYmNTQ3NjY1NDYzMhYVFAYHBgYjKhoDCwsvJSQlKh4UFxOeFBYJDC5OMDI2JyEjdDclGAACADP/egH8AsoAMwA6ADlANjcoIBkEBAM1MREDAQACTAAEAwADBACAAAABAwABfgACAQKGAAMDAWEAAQE0AU4nLSMWIAUJGyskMzIWFRQHBgYHBwYGIyImNzcmJjU0NjY3NzY2MzIWBwcWFhUUIyImNTQ2NzY1NCcHBzY3BBc3NwYGFQHKCQoMECBeNQwCGRAPEwIOTlxAb0YNARgPDxUCDkZFQxkYAgEEKxkYTED+7j8YFzY4tBkTIBYqKwJhDxERD2gUe2NdkVgLZg8QEQ5lCFU2aBUZCA0FFggrB7rGBkAYIbK7FXlMAAAAAAIALP96AbMCQAA1ADwAM0AwOS4mHRYFAgE3MA4DAAMCTAABAgGFAAIDAoUEAQMAA4UAAAB2AAAANQA0KC0pBQkZKyQWFRQHBgcHBgYjIiY3NyYmNTQ2Njc3NjYzMhYHBxYWFRQGIyImNTQ2NzY1NCYnBwc2Njc2MwYXNzcGBhUBpA8RNW8LAhgODhICDkBPM1o5DAEXDg8TAg48OiUeExcEAQUNEhIPIjMeDA/3KQ8PJCO9FxIkGlIIYg8REQ9mEG1IQmtCCGUPEBEOZQc9Lio6EhAHEgQPDQ0OA4GBAyYoDzgbdHwNSzgAAAAAAwAQ/40COwKUAEcATgBXAFhAVUEFAgcAT0tGRAgFAQdJAQMBVlQCAgMyKScDBAIvJAIFBAZMCAEABwCFAAcBB4UAAQMBhQADAgOFBgEFBAWGAAICBGIABAQ0BE4kKikjJiIUGCEJCR8rADYzMhYVFAcHFhUUIyInBwc2NzYzMhYVFAcGBiMiJwcGIyImNTQ3NyYnBwYjIiY1NDc3JjU0NjYzMhc3NjYzMhYVFAcHFhc3ABc3NwYGFTc1NCcHBxYXNwH+EQoOFANECEMIDCpNUEELCQoMECFjNgwYLgsYDRUELRAUQAsYDRUETzBNg1AMBR0FEQoOFAMaEhIv/rQCMVJBROIYXFALFlcCigoQDAYIhBsYaAJRmQVBCxkTIBYrLAJbFQ8MCAdXBg1/FQ8MCAeZQmJmmlQBOQoKEAwGCDIGD13+dhRfogyAVKsDIQuynhANqAAAAAACAHoANQJQAgsAMwA/AEpARxgUAgYCJSELBwQHBjIuAgUHA0wDAQECAAFZAAIABgcCBmkIAQcABQAHBWkDAQEBAGEEAQABAFE0NDQ/ND4nIy4jIy4gCQkdKzYjIiY1NDc3JjU0NycmNTQ2MzIXFzYzMhc3NjMyFhUUBwcWFRQHFxYVFAYjIicnBiMiJwc2NjU0JiMiBhUUFjO2DxEcDDMiITMLGxEODDMzPz01MwsPERsLMyEiMwwcEQ8LNDI+PjI02T4+NTU+PjU1GxEPDDM1PT4yMwsPERwMMyMiMgscEQ4LMzI+PTUzDA8RGws0ISE0a0UxMUVFMTFFAAADACf/egHkAsoANgA9AEQATUBKIwECAzo1MwMEAkM5NhsEAQREGg4DAAEETCoBAgFLAAMCA4UABAIBAgQBgAABAAIBAH4AAgQAAlkAAgIAYQAAAgBRKCMcKCkFCRsrABYWFRQGBwcGBiMiJjc3JiY1NDYzMhYXFhYXNy4CNTQ2Nzc2NjMyFgcHFhYVFAYjIiYnJicHJhYXNwYGFRI2NTQmJwcBaUEtbVsMAhkQDxMCDUlVJBkZGAUDHRgULkErcFYMARgPDxUCDkBKIxoVGwEDJRZ5HBoRIiV+Jh0cEAEyJD4tRloHYg8REQ9kCkw0IyYcHhcfBpYSJ0EwSlwGZA8QEQ5nCkQzIiEaFioNokkfDooFJh3+uiEaFB4NfwAAAAADAAb/dgIYAvYAMwA9AEsAzEAOLwEFBh0BCAMSAQEJA0xLsAlQWEAvAAYFBQZwDAcCBQQBAAMFAGoNAQsACgsKYwAICANhAAMDNk0ACQkBYQIBAQE0AU4bS7AbUFhALgAGBQaFDAcCBQQBAAMFAGoNAQsACgsKYwAICANhAAMDNk0ACQkBYQIBAQE0AU4bQCwABgUGhQwHAgUEAQADBQBqAAMACAkDCGkNAQsACgsKYwAJCQFhAgEBATQBTllZQBw+PgAAPks+SUVCPDo1NAAzADIjJCQlJCckDgkdKwAWFRQGIyMGBwYGFRQGIyImNTcGIyImNTQ2NjMyFzc2NyMiJjU0NjMzNjc2MzIWFRQHBzMDDgIVFBYzMjcSFhUUBiMhIiY1NDYzIQIKDhQRJBsYBgkfIyIhAR9MOUdIeEMXDAYFBeINDRQQ4wIJCUUdHAIRH8opRikXEzYelQ4UEf6JDQ0UEAF3AmkTDhEcho4mbDMmISElEFZaSUuGURUrHCkSDRIdFTo+FBUFDFP++gE3WzMeH4v+2RMOERwSDRIdAAEAEf/7Ah8CSABNAFZAUyoBBQgBTAAHBQQFBwSAAAACDQIADYAABgAIBQYIaQkBBQoBBAMFBGkLAQMMAQIAAwJpAA0NAWEAAQE0AU5MSkhGQj89Ozc1KSQiJCIkIiYgDgkfKyQzMhYVFAcGBiMiJicjIiY1NDYzMzQ3IyImNTQ2MzM2NjMyFhYVFCMiJjU0Njc2NTQmIyIGBzcyFhUUBiMnBhUVNzIWFRQGJycWFjMyNwHtCQoMECFjNlx+Di4NDhQQIQMgDQ4TECQclWA6TCNDGRgCAQQgIzZJEXUNDxMRegJ4DQ8UEWgMPClURrQZEyAWKyxmXw8LDhgWExALDhdodytEJmgVGQgNBRYIGxlEOAERDA8WARgOAwERDA8XAQEwLUYAAAAAAf+9/tQCFwL2ADQAZbUPAQMBAUxLsBVQWEAdAAYIAQcABgdpAAMAAgMCZQQBAQEAXwUBAAA2AU4bQCMABggBBwAGB2kFAQAEAQEDAAFnAAMCAgNZAAMDAmEAAgMCUVlAEAAAADQAMyYjJSQmJDQJCR0rAAYGBwczMzIWFRQGIyMCNwYxBgYjIiY1NDYzMjY2NxM3IyImNTQ7AjY3NzY2MzIWFRQGIwGoNxkEDhtvEA4zKlcpBBYMd1o3LiEdMTgZAyMUXR4VLW4BAwoFDHdaNy4hHQKLEycjcw4TIST+xBywWFkZIxQcEygiARigFhg4F1EiWFkYIxQcAAAAAQAu//sC5QJWAFQA4EuwEFBYQA4rAQcFSgEAAR8BAgADTBtADisBBwVKAQADHwECAANMWUuwEFBYQCwLAQoIAQgKAYAGAQUABwkFB2cACAMBAQAIAWoAAAAJYQAJCTZNBAECAjQCThtLsBdQWEAyCwEKCAEICgGAAAEDCAEDfgYBBQAHCQUHZwAIAAMACANoAAAACWEACQk2TQQBAgI0Ak4bQDALAQoIAQgKAYAAAQMIAQN+BgEFAAcJBQdnAAgAAwAIA2gACQAAAgkAaQQBAgI0Ak5ZWUAUAAAAVABTT00xRjEtJBQkKCYMCR8rABYVFAcGBiMiJjU0NzY1NCYjIgYHBgYjIiY1NDcHBgcGBiMiJjU0Njc3NjcmJjU0NjMyFxcyNzYWFRQHBgYjIicHNzcyFhUUBwYHPgIzMhYVFAczAsYfBhA4HhUkAgIHBRNHIwwaHiAbCoIWBgIcHx0gExMEDAsTERsnPiksY5wnJj4rkD81GRA9XSMlBAsDIVBJGxkeCwkBNR8XDQ8lMigiExYQBggIi2MjGUBUREMBj08fHSEbIINvGks+BxkVGRQDAQkDGhktCgcGAV8BAhofDxAxLVVsLyIfEzUAAAIAM/96AjwCygBFAEwAoEAUJAEEA0kzAgUGRwEHCBwRAgEHBExLsAlQWEA1AAMEBANwAAUGCQYFcgAAAQIBAAKAAAIChAAEAAYFBAZqCgEJAAgHCQhpAAcHAWEAAQE0AU4bQDUAAwQDhQAFBgkGBQmAAAABAgEAAoAAAgKEAAQABgUEBmoKAQkACAcJCGkABwcBYQABATQBTllAEgAAAEUAQxESGSMTLSMYKQsJHysAFgcGBgcGBwYGIyI1NDc3NjcGBgcHBgYjIiY3NyYmNTQ2Njc3NjYzMhYHBxYWFRQjIiY1NDY3NjU0JicHBzY3IjU0NjMzBBc3NwYGFQIaIgECEwMCAgQbGC4BAwUBG1IxDAIZEA8TAg5OXD9vRw0BGA8PFQINUU1DGRgCAQQdIhkYbSVOJSE7/rU/GBc3NwEOFxsrlhgKECEdLgkFGhcYGhoBYQ8REQ9oFHtjW5BYDWcPEBEOZAVSNWgVGQgMBBQIFhgCvMYFQDEaG30hsrkVdk0AAAACAB//+wIgAkgAKwBVAF5AWxYBAgEBTAACAQABAgCAAAgGBwYIB4AAAwABAgMBaQQBAAwBBQsABWcNAQsKAQYICwZpAAcHCWEACQk0CU4sLAAALFUsUk5MRkQ/PTk3MjAAKwAoJiYjJjQOCRsrEiY1NDYzFzc2NzY1NCYjIgYHBiMiJjU0NzY2MzIWFRQHBgczMhYVFAYjJwcEFhUUBiMnBgYVFBYzMjY3NjYzMhYVFAYGIyImNTQ3NjcjIiY1NDYzFyVNDhQQvT4SBgIsJysoDhAjFR4EDW1TU2gDAwgoDQ8TEdzFAbQPFBHtISEvLSo0DwsXFxQfNmhHWmoEBhQ6DQ4UEIMBPAE9EAwOFgEBDxcMBBsfFBsgFxYGEC45S0EPEg4PEQwPFgIBKBEMDhcCDyIZGhsZGRYVGRYdQCxJPgsWHBUPCw4YAQIAAAEAE//7AmACRABMAGxADTcuKgMEBQFMEQEDAUtLsCFQWEAdBgEFBAWFBwEECAEDAAQDagkBAAABYQIBAQE0AU4bQCQGAQUEBYUAAAMJAwAJgAcBBAgBAwAEA2oACQkBYQIBAQE0AU5ZQA5LSSQnKyUkIyknEQoJHyskMzIWFRQGBwYGIyImJy4CJwYHBiMiNTQ3IyImNTQ2Mxc3Njc2NjMyFhUUDwI2Njc2NjMyFhUUBwYGBzcyFhUUBiMnFhYXFhYzMjcCOAYPExEQEDEXP1AiExsfGBQFBjs6HSoODxMRMA0OAwQhHxocARMNSGM1Dx0cFx8FG1MziQ0OFBGaDxgRECwZFBhoFxAOGwkIDEtNLC0VAoZGPDMupxUPERoBTE8cIBwXEwcDcUoIW1saFxcSBww4XiEDFA4SHQIOKiQjJQYAAAEAFf/7AgwCSABLARpLsBdQWEAyAA0OAA4NAIAADA8BDg0MDmkLAQAKAQECAAFpCQECCAEDBAIDaQAEBAVhBwYCBQU0BU4bS7AZUFhANgANDgAODQCAAAwPAQ4NDA5pCwEACgEBAgABaQkBAggBAwQCA2kABgY0TQAEBAVhBwEFBTQFThtLsBtQWEA5AA0OAA4NAIAABgQFBAYFgAAMDwEODQwOaQsBAAoBAQIAAWkJAQIIAQMEAgNpAAQEBWEHAQUFNAVOG0A9AA0OAA4NAIAABgQFBAYFgAAMDwEODQwOaQsBAAoBAQIAAWkJAQIIAQMEAgNpAAQEBV8ABQU0TQAHBzQHTllZWUAcAAAASwBKSEZBPz07NzU0MiYjIUQhJCEkIhAJHysABgc3MhYVFAYjJwc3MhYVFAYnJwclNhYVFAYjIiYnJiMiBgcGIyImNTQ2NzcjIiY1NDYzMzcjIiY1NDYzMzY2MzIWFhUUBiMiJyYjASlACHwNDxMRegN5DQ8UEXUGAQMVFiEcG2kWYiwPIgMZDxAVHx8GJg0OFBAiAyENDhMQHw+BYzVRLB4cLhEOMgHoPkEBEQwPFgEpAREMDxcBAU0HAR4WGysGAQcKAQkfHSAhBkIPCw4YKRALDhdpdiVAJx0gOTAAAAEAEP/9AcUCSQBIAExASSgBBQQyFwICBQ0BAQcDTAADBAOFAAQFBIUABQIFhQACBwKFCAEHAQeFAAEGAYUABgYAYgAAADQATgAAAEgARyooJSgoJyYJCR0rJBYVFAcGBiMiJjU0NzcHBiMiJjU0PwIHBiMiJjU0PwI2NjMyFgcHNzYzMhYVFA8CNzYzMhYVFA8CBhUUFhc2Njc+AjMBsRQQKotHOjYDBRcHCAwPEToGGQcIDA8RPBQEKhoZIQQMWQcHDBESfgdeBwcMEhODCwMSERkwHgcgGxHFFBASFDFNLzMSFiYOBBYNFwggKw8EFg0XCCGeGBsZF1E2BBUOFQtKLjYEFg4VCkhHEg4ZFQEBGhsGHgoAAAABABH/9wJvAskALQAgQB0tIBcPBAADAUwAAwADhQIBAgAANABOKigqJgQJGisAFhUUBwYGIyImNzY1NCYnAwYGIyImNxMGBgcGBiMiJjU0NzY2Nzc2NjMyFgcHAgplBwMlGiEeAwgnMDECGxEQFQI3O1slBiwcHhgEK65zDgEZDxAVAg8CLc2pME8gHRokWkZheBD+VQ8REBABqxW9vB8aExcHHPXxEG0OEBAObQAAAAQAGP/5ApECRABRAFUAWwBgAFtAWFQBBwhYAQAFFAEBAANMCgEIBwiFDgsJAwcRDwwDBgUHBmoQEg0DBQQCAgABBQBpAwEBATQBTgAAYF9dXFdWU1IAUQBOTUtHRUE/OzklJCIkJCQTJiQTCR8rJBYVFAYnJwYHBgYHBiMiJyYnBwYHBgYjIiY1NDcjIiY1NDYzMzY3IyImNTQ2MzM3Njc2NjMyFxYXFzM3Njc2NjMyFhUUBzMyFhUUBiMjBxQHMyUXJwcXJxczNjUHFyYnBwJ5DxQRLgkCAgsNFBISEBJIoQYEAhwfHSAJHw0OFBAgBQImDQ4TECgGCw8EIhYWDhtiHBJBFAQCHB8dIBkjDQ8TESYGASz+eiMcAeMkGgIB83MVBFPYEQwPGAEBPxcUGQoQEhZ3AiwzHx0hGxVIEAwPGB4LEAwPFyFEZB0cEB+nLwGARx8dIRsrmxEMDxYkAgFpASwHZQErAQICASMIAQAAAgAn/+UEKwJOAGkAdgI+S7AJUFhAFDIBBg5kQAIDCHYVAgQDEgEFAQRMG0uwEFBYQBQyAQYOZEACAwh2FQIEAxIBAgEETBtLsB1QWEAXMgEGDkABDQhkAQMNdhUCBAMSAQIBBUwbQBcyAQYOQAENCGQBAw12FQIEAxIBDAEFTFlZWUuwCVBYQDgABg4IDgYIgAAEAwEDBAGACQEHAA4GBw5pCwEDAwhhDQoCCAg2TQAFBTRNDAEBAQBiAgEAADQAThtLsBBQWEA+AAYOCA4GCIAABAMBAwQBgAkBBwAOBgcOaQsBAwMIYQ0KAggINk0MAQEBAmIFAQICNE0MAQEBAGIAAAA0AE4bS7AXUFhARQAGDggOBgiAAA0IAwgNA4AABAMBAwQBgAkBBwAOBgcOaQsBAwMIYQoBCAg2TQwBAQECYgUBAgI0TQwBAQEAYgAAADQAThtLsBtQWEA9AAYOCA4GCIAADQgDCA0DgAAEAwEDBAGACQEHAA4GBw5pCgEICwEDBAgDagAAAQBWDAEBAQJiBQECAjQCThtLsB1QWEBEAAkHDgcJDoAABg4IDgYIgAANCAMIDQOAAAQDAQMEAYAABwAOBgcOaQoBCAsBAwQIA2oAAAEAVgwBAQECYgUBAgI0Ak4bQEUACQcOBwkOgAAGDggOBgiAAA0IAwgNA4AABAMBAwQBgAAHAA4GBw5pCgEICwEDBAgDagABAAABAGYADAwCYQUBAgI0Ak5ZWVlZWUAYb25iYF1bVlRQTUhGIyYoIxQmJzQoDwkfKwAWFxYWFRQGBiMiJjU0NjMyFxcmJicOAiMiJjU0NzY3IyInDgIHBgcGIyI1NDc3NjcHBiMiJjU0NzY2MzIWFzYzMzc2NjMyFhUUBwczMzIWFRQGIyMGBwYVFDMyNjc2MzIWFRQGBwYVBDY1NCYnBwYGBwcGBwPJFBMcHyNAKTAxIyEIFhYBHx4oQVQ2QUsDBQsiFwsIRnpTCAMGOzokEwMJEgYGDRAeGlAraHIMCRQ5DgcjHRwaAxERZQ4NLidQCgMINjNtMA84GhQIBhD9PUsxPAoCAgETBwQBLiEYJTcgJkQqKxwYIgIDITIkS1w4W18bHDBHCDheOQE8JjwzMc9vEjoHAxIOGhIQE1JJC0YkHRIVCgxKDREfIDIVOiRfrH4oCQoFFw0fGEtVQDc5BD8HDwZvJSUABAAO//sCNwJOAD0AQwBIAE0A2UALQCgCCAlNAQIBAkxLsAlQWEAzAAkIBwlwAAgHCIUAAgEDAQJyDgUCAA8EAgECAAFpDRALAwYGB2EMCgIHBzZNAAMDNANOG0uwIVBYQDMACQgJhQAIBwiFAAIBAwECA4AOBQIADwQCAQIAAWkNEAsDBgYHYQwKAgcHNk0AAwM0A04bQDEACQgJhQAIBwiFAAIBAwECA4AMCgIHDRALAwYABwZqDgUCAA8EAgECAAFpAAMDNANOWVlAHgAAS0pIR0ZFQ0EAPQA8ODY0MiMkIiQjIxIkIhEJHysBBgczMhYVFAYjIwYGBwYHBiMiNTQ3IyImNTQ2MzM2NyMiJjU0NjMzNwcGIyImNTQ3NjYzMhYXMzIWFRQGIyYmJwYHNxY1Jwc3BjcnBgcB6wIDKQ0PFBE5IYNcCAMGOzohPw0OFBBBBANEDQ4TEEYGEgYGDRAeGlArYnAQNw0PExG3LykIAWwKgAiDRyZsBgIBgxoNEQwOFzlHATwmPDMyuw8LDhgcDRALDhclBwMSDhoSEBNJQBEMDxZZGwMwBwFTEwErAWkpASEVAAACAA7/+wHrAk4ANwBDAEZAQykBCApAAQcIAkwACAoHCggHgAAJAAoICQppAAcGAQABBwBpBQEBBAECAwECaQADAzQDTjo5NTMnJCIkIiIkIRILCR8rAAYGBwc3MhYVFAYnJwcGIyI1NyMiJjU0NjMzNjcjIiY1NDYzMzY3NzY3BwYjIiY1NDc2NjMyFhUmJicHBgYPAjY2NQHrQX9aBXsNDxQReQMGOzoCIA0OFBAfBQIlDQ0YEiACBhMDCRIGBg0QHhpQK3ZzejE8CgICARMHTUkBW2I8AikBEQwPFwEBGzwzJA8LDhgeCw4LDxoNJG8SOgcDEg4aEhATZFUuMwQ/Bw8GbzALTDoAAAAAAQAa//sCGQJAAEoAU0BQEwEGBwFMAAQGAwYEA4AMAQsKAQABCwBpCQEBCAECBwECZwAHAAYEBwZpAAMFBQNZAAMDBWEABQMFUQAAAEoAR0NAPjwiNDQnEyckIiQNBh8rABYVFAYjJxYXNzIWFRQGIycGBgcWFhcWMzI3NjMyFhUUBgcGBiMiJicmJiMjIiY1NDYzMzI2NwciJjU0NjMXJiYjIyImNTQ2Mxc3AgoPExGaEgp6DQ8UEWwJW0ctMhUmLxQYBAYPExEQEDEXPUgdHDkoHRESFxIkQ1AIuw0OFBCrCjk4LA0OExC95AJAEQwPFgEQGQERDA4XATVRDAkqKEgGARcQDhsJCAw/ODYsGRIVITUtAQ8LDhgBFxMQCw4XAQIAAAEAFf/7AgwCSAA7APG1AgEACQFMS7AXUFhAKAAJCgAKCQCAAAgLAQoJCAppBwEABgEBAgABaQACAgNhBQQCAwM0A04bS7AZUFhALAAJCgAKCQCAAAgLAQoJCAppBwEABgEBAgABaQAEBDRNAAICA2EFAQMDNANOG0uwG1BYQC8ACQoACgkAgAAEAgMCBAOAAAgLAQoJCAppBwEABgEBAgABaQACAgNhBQEDAzQDThtAMwAJCgAKCQCAAAQCAwIEA4AACAsBCgkICmkHAQAGAQECAAFpAAICA18AAwM0TQAFBTQFTllZWUAUAAAAOwA6ODYjJCYjIUQhJCMMCR8rAAYHBzcyFhUUBiMnByU2FhUUBiMiJicmIyIGBwYjIiY1NDY3NwciJjU0NhcXNzY2MzIWFhUUBiMiJyYjASdDBgGXDQ4UEZMKAQMVFiEcG2kWYiwPIgMZDxAVHx8JIw4PExEiAwqDaDVRLB4cLhEOMgHoUlIQBBQOEh0BdQcBHhYbKwYBBwoBCR8dICEGagEVDxEbAQEfcoIlQCcdIDkwAAAAAgAu//sCDwI/ABQAOgAjQCAAAQAABQEAZwAFBAECAwUCaQADAzQDTjgXKTU4UwYJHCsAFRQGIyInJyIHBiY1NDY3NjMzMhcWFRQGIyInBwYHBgcUBwYGIyImNTQ3NzY3BgcGJjU0Njc2MzMyFwIPFx03HF1WXxkbFRVHalBIGS0XHShYCRUCBAMFAiMXFRsIBwYYPD4ZGxUVR2pQSBkCOCwaEQEBCAIbFREYAwoCpSwaEQIqYBceKQcwFBUXEhcyMyZ8AgUCGxURGAMKAgAAAAEAQ//7AhACQABMAElARgkBAgE0FAIFAigBBAUDTAABAAIAAQKAAAIFAAIFfgAFBAAFBH4ABAMABAN+AAcGAQABBwBpAAMDNANOOBcqJiopJTMICR4rABUUBiMiJzAHBzc2MzIWFRQGDwI3NjMyFhUUBgcHBgcGBiMiJjU0NwcGIyImNTQ2PwMHBiMiJjU0Nj8CBgcGJjU0Njc2MzcyFwIQFx0oWAwGKQgCDBANDEQJVggCDA8NDWwJCgIjFxUbDysIAgwODQtDAgdUCAMLDgwLbRg8PhkbFRVQYWMwHgI4LBoRAjweDgIUDQsTBBY3HAITDQwTBCM+XxQVFxIhWA4CEw0LEwQWCywbAhINCxMEJH4CBQIbFREYAwoBAwAAAAUAG//7AyECRABRAFcAXABiAGkAakBnRgEGB2loYhEOBQEAAkwLCQIHBgUHWQwKCAMGFhIQDQQFBAYFaREPFQ4EBBQTAwMAAQQAZwIBAQE0AU5YWAAAZmVgX1hcWFxaWVdWU1IAUQBQT01JSENBPj06OBMjJCEkJSgkJBcJHysAFhUUBiMnBgcGBiMiJicmNTcOAiMiJicnJhcHIiY1NDYzMycjIiY1NDYzMzU2NjMyFhUVFzc2NjMyFhUVNzc2NjMyFRQHBzMyFhUUBiMjBzMFFzY2Nwc3FTc2Nwc2NyMWFyc2NwcWFxcDCQ8UEUklMiM3HS4pBQMBIjEvICwmCQILAT8NDhQQMwExDQ4TECkBHSEXGIoICx0VFxiYBwsiFi0IASINDxMRLg06/eVoAwcDdv50CQVeJhNcBATdGw9QAgkCAYMRDA8XAWNoRzRKWiooL3l9L0paF5gOARAMDxgpEAwPFw4qHxwiGgIaJhocIhwBGSUbKREbAxEMDxYnAQEJFQ0BASsBFxL1WDSIRUtRMQEshRsAAAEAI//7AhkCRwA8AEJAPzgBAAkcAQQDAkwLCgIJAAmFCAEABwEBAgABaAYBAgUBAwQCA2cABAQ0BE4AAAA8ADs2NCQhJCQiJCEkJQwJHysAFhUUBwc3MhYVFAYjJwc3MhYVFAYnJwcGIyImNTc3ByImNTQ2Mxc3ByImNTQ2FxcnJjU0NjMyFxc3NjYzAfofFK1WDQ8TEW0EcA0PFBFuBgZAHiEBBmgNDhQQZwVrDQ4TEFd4ECMbKxRqkQ4hGgJFEBETG+gBEQwPFgEpAREMDxgBAjczGBgKLwIPDA8ZASsBEAwPGAEC1hsYGBgm0NEUDwAAAAABAQMAkwG9AU0ACwAeQBsAAAEBAFkAAAABYQIBAQABUQAAAAsACiQDBhcrJCY1NDYzMhYVFAYjATAtMy4sLTQtkzAnLTYrKi43AAAAAQBp//sCjQOnABEAF0AUAAABAIUCAQEBdgAAABEAECcDBhcrFiY1NDcBNjYzMhYVFAcBBgYjjCMOAaMMHxAXIQv+VAkbDwUhGxYaAxMXFiUbFhP83RAQAAEAU//6AncCRQAfACdAJAAEAwSFBgUCAwIBAAEDAGgAAQE0AU4AAAAfAB4jJCMjJAcJGysAFhUUBiMjBwYGIyImNzcjIiY1NDYzMzc2NjMyFgcHMwJfGCEcpBYEJRgXHQMWohcYIRyjFgMkFxcgAxajAVkcFBkptxocHBq3HRQZKLcZHBwZtwABAFMA5wJ3AVkADQAeQBsAAAEBAFcAAAABXwIBAQABTwAAAA0ACzQDBhcrNiY1NDYzITIWFRQGIyFrGCEcAbgXGCEc/kjnHRQZKBwUGSkAAAEAbgA9AlwCAgAjAB5AGyIZEAcEAQABTAMBAAEAhQIBAQF2KiQqIAQJGisAMzIWFRQHBxcWFRQGIyInJwcGIyImNTQ3NycmNTQ2MzIXFzcCFBMWHxWScgwrGRQPcpATFBUgFpBxDCoZFQ5ykgICIBYZEoKCDxAZKBCCgRAgFRgTgYEPEBkqEYKDAAAAAwBT//sCdwIrAAoAGAAjADtAOAAABgEBAgABaQACBwEDBAIDZwAEBAVhCAEFBTQFThkZCwsAABkjGSIfHQsYCxYSDwAKAAkkCQkXKwAmNTQ2MzIVFAYjBCY1NDYzITIWFRQGIyEWJjU0NjMyFRQGIwFPJSomSysm/vcYIRwBuBcYIRz+SJslKiZLKyYBkCghJS1HJy24HRQZKBwUGSndKCElLUcnLQAAAgBFAHQChQHMAA0AGwApQCYAAgUBAwIDYwQBAQEAXwAAADYBTg4OAAAOGw4ZFRIADQALNAYJFysSJjU0NjMhMhYVFAYjIQYmNTQ2MyEyFhUUBiMheRghHAG4FxghHP5IMxghHAG4FxghHP5IAVodFBkoHBQZKeYdFBkoHBQZKQABAEX/+gKFAkUANAByS7ALUFhAKgAHBgYHcAACAQECcQgBBgoJAgUABgVoBAEAAQEAVwQBAAABXwMBAQABTxtAKAAHBgeFAAIBAoYIAQYKCQIFAAYFaAQBAAEBAFcEAQAAAV8DAQEAAU9ZQBIAAAA0ADMlIiQhJCUjJCELBh8rAQczMhYVFAYjIwcGBiMiJjU0NzcjIiY1NDYzMzcjIiY1NDYzMzc2MzIWFRQHBzMyFhUUBiMBtDi+FxghHOclCx8QExwHFV8XGCEciTizFxghHNwlFiQUHQUZahcYIRwBWnQcFBkpTBcXHRUODiwdFBkodB0UGShMLR0TCQw0HBQZKQAAAAEAQwBAAnkCBAAZABdAFAgBAAEBTAABAAGFAAAAdiwgAgkYKzYjIiY1NDY3JSUmJjU0NjMyFwUWFhUUBgcFfAwVGBcXAV7+wBESIRkLDQGYERIcF/5CQBwUEyEIdncGGg8XJQWcBh4TGC0ImwAAAAABAFIAPwKIAgMAGQAXQBQQAQEAAUwAAAEAhQABAXYsKAIJGCs3JiY1NDY3JTYzMhYVFAYHBQUWFhUUBiMiJ3UREhwXAb4MDBUYFxf+ogFAERIhGQsN4AYeExgtCJsEHBQTIQh2dwYaDxclBQACAEEAAAKEAj8AGQAnADBALQgBAAEBTAABAAGFAAACAIUAAgMDAlcAAgIDXwQBAwIDTxoaGicaJT4sIAUGGSs2IyImNTQ2NyUlJiY1NDYzMhcFFhYVFAYHBQYmNTQ2MyEyFhUUBiMhhwoWGxkXAV7+wBISIxoLCwGYERIcF/5COhghHAG4FxghHP5IpR0UEyEGYmMGGA8XJgSIBh0TGi0Hh6gdFBkoHBQZKQAAAgBBAAAClAI+ABkAJwAwQC0QAQEAAUwAAAEAhQABAgGFAAIDAwJXAAICA18EAQMCA08aGhonGiU2LCgFBhkrEyYmNTQ2NyU2MzIWFRQGBwUFFhYVFAYjIicEJjU0NjMhMhYVFAYjIX8REhwXAb4MChYbGRf+ogFAEhIjGgsL/kIYIRwBuBcYIRz+SAEwBh0TGi0HhwMdFBMhBmJjBhgPFyYEqB0UGSgcFBkpAAIAXgAAAlkCRQAfAC0APUA6AAQDBIUAAQAHAAEHgAgFAgMCAQABAwBnCQEHBwZgAAYGNAZOICAAACAtICsnJAAfAB4jJCMjJAoJGysAFhUUBiMjBwYGIyImNzcjIiY1NDYzMzc2NjMyFgcHMwIWFRQGIyEiJjU0NjMhAkEYIRx7DQQlGBcdAw17FxghHHoNAyUXGB8EDXwQGCEc/pgXGCEcAWgBqRwUGSlnGhwcGmcdFBkoZxkcHBln/skcFBkpHRQZKAACADwAIwKOAhwAHwA/AFBATRMDAgACMyMCBAYCTAABAgGFAAIAAoUAAAMAhQgBAwUDhQAFBgWFAAYEBoUABAcEhQkBBwd2ICAAACA/ID44NjAuKCYAHwAeJiYmCgYZKwAmJycHBgYjIiY1NDc2NjMyFhcXNzY2MzIWFRQHBgYjAiYnJwcGBiMiJjU0NzY2MzIWFxc3NjYzMhYVFAcGBiMB3B4injcLIRETGiobNyETIiCeNwshERMaKhw4ITQeIp43CyERExoqGzchEyIgnjcLIRETGiocOCEBMA0UXU8PEhcVIUAqJw4TXU8PEhcVIUAqJ/7zDRRdTw8SFxUhQConDhNdTw8SFxUhQConAAAAAAEATAClAn0BkQAfAFmxBmRES7ASUFi2EwMCAAEBTBu2EwMCAAIBTFlLsBJQWEAMAgEBAAGFBAMCAAB2G0AUAAECAYUAAgAChQAAAwCFBAEDA3ZZQAwAAAAfAB4mJiYFCRkrsQYARCQmJycHBgYjIiY1NDc2NjMyFhcXNzY2MzIWFRQHBgYjAcseIp43CyERExoqGzchEyIgnjcLIRETGiocOCGlDRRdTw8SFxUhQConDhNdTw8SFxUhQConAAAAAAEAUwAfAnUBWQAUAB5AGwAAAQCGAAIBAQJXAAICAV8AAQIBTzQjIQMJGSskBiMiJjc3ISImNTQ2MyEyFhUUBwcCWCQXGiUEFP6MFxghHAGlHyEBGTcYHhmRHRQZKCIbCQXAAAADACAAXQKqAeYAGQAlADAA5kuwClBYQA8XAQQDLhwCBQQKAQEFA0wbS7ALUFhADxcBBAIuHAIFBAoBAAUDTBtADxcBBAMuHAIFBAoBAQUDTFlZS7AKUFhAKAACAwQCWQgBAwYBBAUDBGkKBwkDBQABAAUBaQoHCQMFBQBhAAAFAFEbS7ALUFhAIggDAgIGAQQFAgRpCgcJAwUAAAVZCgcJAwUFAGEBAQAFAFEbQCgAAgMEAlkIAQMGAQQFAwRpCgcJAwUAAQAFAWkKBwkDBQUAYQAABQBRWVlAHCYmGhoAACYwJi8sKholGiQgHgAZABgmIyYLBhkrABYWFRQGBiMiJicGIyImJjU0NjYzMhYXNjMANjcmJiMiBhUUFjMENjU0JiMiBgcWMwIzSi0yVjQrThk5XSxMLjNWNCtHHThl/uYtFxgqFiElIR8BOyUgHRc1FScxAeIsUzdAXjEuK1UsUzdBXjAoMFT+7CApNikxKSklATEpJSklJF8AAAEAMf7UAqADpgAfAChAJQABAAIAAQJpAAADAwBZAAAAA2EEAQMAA1EAAAAfAB4kKCQFBhkrEiY1NDYzMjY2NzYSNzY2MzIWFRQGIyIGBgcGAgcGBiNfLiEdMTgZAxBHEwx3WjcuIR0xNxkEEEYUDHda/tQZIxQcEygiiAI6llhZGCMUHBMnI4v9y5lYWQAAAAEAPv/5AqwDSAAcADFALgwBAgAUAgIBAgJMBAMCAQIBhgAAAgIAVwAAAAJfAAIAAk8AAAAcABsVJjcFBhkrFiY1NDcTNjYzITIWFQcDBgYjIiY1NDcTIQMGBiNeIAFnBBkYAZwYHQFnBCcbGCABX/71XwQnGwcVFwcEAuEcGxgWCf0fHhkVFwcEAqb9Wh4ZAAEAOQAAArMDSAAhAC5AKwUBAgEBTAAAAAECAAFnAAIDAwJXAAICA18EAQMCA08AAAAhAB8mJDoFBhkrMiY1NDcBASY1NDYzITIWFRQGIyEXFhUUBwEhMhYVFAYjIVohJAFR/vwZIBsBuBcYIRz+zN0UGf7cATQXGCEc/lwfFyQhAS0BKRwgGSIcFBkp/RcaHRb+/RwUGSkAAQAy//kC4wNRABwAKkAnDAEDAAFMAAIBAoUAAwADhgABAAABVwABAQBfAAABAE8nJjQgBAYaKxMjIiY1NDYzMzIWFxcBNjYzMhYVFAcBBgYjIiYnrkkYGx8bWhomBksBIwkdEBUeBv6uCSITEx4HAWgcExUgHxX+ApETExoWDA/9HRQWFhQAAAEAHP73Ak8B0gA/AEhARQwBBAA2AQMBAkwABAABAAQBgAgBBwUHhgIBAAA2TQABAQViBgEFBTRNAAMDBWEGAQUFNAVOAAAAPwA+FCYjKCUqKAkJHSsSJjU0NzY3NjYzMhYVFAcGBwYVFBYzMjY2NzY2MzIWFRQHBhUUFjMyNjc2MzIWFRQHBgYjIiY1BgYHBhUXFAYjOh4RDx8KJCcWEQsKBhQKCw8tMxgIISEXEhkcEA0UNy4MDw0PEytjPzAtEEIpAgEmGv73FhveoJZeHhoODgguJR5pIxURPHpZHhoLDxlwgB4TFTE3DhgVKBY1REpDQ0gCNUlMIBoAAAIAIf/7AcYDHAAbACcAOUA2EQEDAR4BBAMCTAACAQKFAAEAAwQBA2kFAQQAAARZBQEEBABhAAAEAFEcHBwnHCYnGCYmBgYaKxIWFhUUBgYjIiYmNTQ2NjMyFyYmJyY1NDYzMhcSNjcmJiMiBhUUFjP2ikY1akw8VCo6YzsuHg1tViMdFQQMczoGECQQMDUqGwMDgqRKeLhoO2A3THdDEl6JJQ8ZDxgC/UtycRARS0g2OwAAAAQAMf/8A3IC7gAiADIAQgBOAJ1ACyoBBAYlCgIBBAJMS7AXUFhAMgUBAwAGBAMGaQAEAAEHBAFpDQEJAAoLCQppAAICB2EMAQcHNk0OAQsLAGIIAQAANABOG0AwBQEDAAYEAwZpAAQAAQcEAWkMAQcAAgoHAmkNAQkACgsJCmkOAQsLAGIIAQAANABOWUAgQ0MzMyMjQ05DTUlHM0IzQTs5IzIjMRwjEiYiFiMPCR0rAAcBBiMiJjU0NxMGBwYGIyImJjU0NjYzMhYXNjY3NjMyFhUENjcmJjU0NyYjIgYVFBYzBBYWFRQGBiMiJiY1NDY2MxI2NTQmIyIGFRQWMwK9Df6VEyAVIBDvNTUTWTcySCQxVDRATgZDcR0bIRUd/jEiBxYYAwIGHichGQItSCQxVTQ0RyQwVDULJyEXHichGQKcFv2WICAZFxwBmBQCPUkxUC5AYzhZQAQ7LiwiGfUkIxQ7HRASAT08Li84MVAuP2Q4MVAuQGQ3/tA+Oy4vPTwwLQAGADH//ATvAu4AIgAyAEIAUgBeAGoAuUALKgEEBiUKAgEEAkxLsBdQWEA4BQEDAAYEAwZpAAQAAQcEAWkSCxEDCQ4BDA0JDGkAAgIHYRABBwc2TRQPEwMNDQBiCggCAAA0AE4bQDYFAQMABgQDBmkABAABBwQBaRABBwACDAcCaRILEQMJDgEMDQkMaRQPEwMNDQBiCggCAAA0AE5ZQDBfX1NTQ0MzMyMjX2pfaWVjU15TXVlXQ1JDUUtJM0IzQTs5IzIjMRwjEiYiFiMVCR0rAAcBBiMiJjU0NxMGBwYGIyImJjU0NjYzMhYXNjY3NjMyFhUENjcmJjU0NyYjIgYVFBYzBBYWFRQGBiMiJiY1NDY2MyAWFhUUBgYjIiYmNTQ2NjMANjU0JiMiBhUUFjMgNjU0JiMiBhUUFjMCvQ3+lRMgFSAQ7zU1E1k3MkgkMVQ0QE4GQ3EdGyEVHf4xIgcWGAMCBh4nIRkCLUgkMVU0NEckMFQ1AbFIJDFVNDRHJDBUNf6OJyEXHichGQGZJyEXHichGQKcFv2WICAZFxwBmBQCPUkxUC5AYzhZQAQ7LiwiGfUkIxQ7HRASAT08Li84MVAuP2Q4MVAuQGQ3MVAuP2Q4MVAuQGQ3/tA+Oy4vPTwwLT47Li89PDAtAAACAIf/9AJvA60AFwAbABlAFhsaGQMBAAFMAAABAIUAAQF2KicCBhgrEyY1NDcTNjYzMhYXExYVFAcDBgYjIiYnEwMDE4oDCOYLIxMSHQaBAwjmCyMTEh0G+V21XQG2CQsRDwGaFBUVFP5nCQsRD/5mFBUVFAG/ATX+tP7LAAAAAAIAJ/7gA9cC4wBFAFAAX0BcHgEKBBEBAQUCTAAEAwoDBAqAAAgBBwEIB4AAAAAGAwAGaQAHDAEJBwllAAoKA2EAAwM2TQ0LAgUFAWICAQEBNAFORkYAAEZQRk9KSQBFAEQjJSUnIyUjJiYOCR8rACYmNTQSJDMyFhYVFAYGIyInBgYjIiY1NDY2MzIWFzYzMhUUBwYVFBYzMjY2NTQmIyIGBhUUFjMyNjc2MzIWFRQGBwYGIwI2NzcOAhUUFjMBY9FrgQEBtW+qYE9/RWYeE0EpQ0tKe0UWDwUVFzEPFxYZIUYvk4CJwGCpqk6ZUg0MFBoQEUi9XgEoCSUqRyoZFv7gccJ4nAESqlKhc3OwX1QnLVlKUI9XERYEIxVPcy0RFkuDTnh+ht2Ck7EpKwcfFhAdCiwvAYA0K7gBPWQ4Hx4AAwAt/7cDPgNuACoANQA+AEtASC8fEwMDBDk3IQEEBQMKAQEFA0wAAwQFBAMFgAAAAQCGAAIGAQQDAgRpBwEFBQFhAAEBNAFONjYrKzY+Nj0rNSs0KysjJggJGiskBxcWFRQGIyInJwYjIiYmNTQ2NyY1NDY2MzIWFRQGBxYXNjc2NjMyFRQHAAYVFBc2NjU0JiMCNyYnBhUUFjMC6FtXFyghLhhUdmxQeEFbZzo8a0VYYVVsQGlCQQseFjoW/kM2Kk44JiUQR2o9cUY9zktgGBoZIRxjOzJYNkl/PmpRSG48ZVhJgUNXdjtaEA0hFSMB1Uc1P0suVjMlKv1kIn9aSlAuMwABAGT/+wK9A1IANgB5tSoBAAMBTEuwDFBYQBoAAAMCAwACgAADAwFhAAEBOU0FBAICAjQCThtLsA5QWEAaAAADAgMAAoAAAwMBYQABATNNBQQCAgI0Ak4bQBoAAAMCAwACgAADAwFhAAEBOU0FBAICAjQCTllZQA0AAAA2ADUrLCUaBgkaKwQmNTQ2Nzc2NzY3IiYmNTQ2MzIWFhUUDwIGBgcGBiMiNTQ2PwI2NzY1NCMjBgcHBgYHBgYjAQwfExMEAwgBBCZcQbKYW3NBGA4WCxcEAyQiQxMTBBcJEQEhKxAaFgsXBAMkIgUfHSCDbxoZJAsUKlQ7anASNTITjFKDQ7EwJSE8IINvGoM2fwQIJUWfg0OxMCUhAAAAAAIARv/7AjADTABBAFAAR0BETkY1FQQCBSQBAwICTAYBBQACAAUCgAACAwACA34AAAAEYQAEBDNNAAMDAWEAAQE0AU4AAABBAEA8OiooIR8bGScHCRcrACY1NDc2NTQjIgYVFBYWFxYWFRQGBxYVFAYjIiY1NDYzMhYVBwYVFBYzMjY1NCYmJyYmNTQ3JjU0NjYzMhYVFAYjBiYnJicGFRQWFxcWFzY1AdUaAgJNLjQgMTVIOychInllXnEkIxQaAQI6Ki8yGCgoS1hIIDZkQltfISZBMjczEhgxLxQYGCICXBgRCRAQDTcrJhsmGxcgRjkqQxgnOlNbSk4pKxUQGhALHBwjIBgfFA8cT0hYNig6NlMuS0YxLsIlGhkKGCciKhUJCQwXKAAAAwBTAWECmQOnAA8AHwBGALSxBmREtS4BBQYBTEuwEFBYQDoABQYIBgVyAAgHBggHfgAAAAIEAAJpAAQABgUEBmkABwwBCQMHCWkLAQMBAQNZCwEDAwFhCgEBAwFRG0A7AAUGCAYFCIAACAcGCAd+AAAAAgQAAmkABAAGBQQGaQAHDAEJAwcJaQsBAwEBA1kLAQMDAWEKAQEDAVFZQCIgIBAQAAAgRiBFQD47OTUzLConJRAfEB4YFgAPAA4mDQkXK7EGAEQAJiY1NDY2MzIWFhUUBgYjPgI1NCYmIyIGBhUUFhYzJiY1NDY2MzIWFRQjIiY1NDY1NCYjIgYVFBYzMjY3NjMyFhUUBwYjASKES0uEVFSES0uEVEJiNDRiQkJiNDRiQkZQL08wLzAsDA0FEA8sPCsnGiwXCAQHBwstSAFhToVQUIVOToVQUIVOQj1nPT1nPT1nPT1nPTlTRzZYMi0lNwsKBBgFDA9KNy44FBUGDgoRDjMAAAQAUwFhApkDpwAPAB8AUQBaAHKxBmREQGc3NQIJCEYBBAkCTAwHAgUEAwQFA4AAAAACBgACaQAGAAgJBghpDQEJAAQFCQRpCwEDAQEDWQsBAwMBYQoBAQMBUVJSICAQEAAAUlpSWldWIFEgUEE/LComJRAfEB4YFgAPAA4mDgkXK7EGAEQAJiY1NDY2MzIWFhUUBgYjPgI1NCYmIyIGBhUUFhYzNiYmJyYmJwYHBgYjIiY1ND8CNjY3BjcHBiY1NDc2NjMyFhUUBgcWFhcXFhcWFRQGIyY2NTQmIwYHBwEihEtLhFRUhEtLhFRCYjQ0YkJCYjQ0YkI6Ew8REBMPCgUCDRAOEwsHCQMDAgEIDwgNDg4yGj9HNTcUFg0LDQgHFgtCLSEkDQMDAWFOhVBQhU5OhVBQhU5CPWc9PWc9PWc9PWc9OwwZJSEYATUxEA0OCxA+LDUMGAsLOgYECwkNCgkLNSokPAoFFhYUFwsKCgoOsyghGBdLFhgAAAAAAgBkAbcETwNUAEQAZABXQFQ1AQgLUEE/OSwHBgABAkwJBAIDAAEAhgwHBgMFCwEFWQ0BCwoBCAELCGkMBwYDBQUBYQMBAQUBUUVFAABFZEVhWllTUUtIAEQAQygnJCgkJykOBh0rABYXFAcHBgcGBiMiNSY3NzY1NCMiBgcGBiMiJjU0NzY1NCYjIgYHBgYjIiY3NjY3NjYzMhYVFAcGBzY2MzIWFxYHNjYzBBcUBiMiJwYHBgYHBiMiJzQ2NzY3IgcGNSY2NzYzMhcEHTACDAsKCAEWGzIBFQsGHzRNDwIWHRwTEhEQEzpQDQIXGRoXAQMcDwIZGhcSAQIOHEw4LC4CAgUZTTr96wIUGCJECxMHCgEDMywCCQsIFSE0LQESEUZIYiwDUisoHUE8LWASDx0adUEeEi2YixcQERUdYV4ZGRabjREREBEq02MODgoNBwQSSkE7LCkSFUA8BicPDQI4biRVGB0dDD5GNXEFBSMQFAIJAwAAAAIAYQIYAZEDTQAPABsAOLEGZERALQAAAAIDAAJpBQEDAQEDWQUBAwMBYQQBAQMBURAQAAAQGxAaFhQADwAOJgYJFyuxBgBEEiYmNTQ2NjMyFhYVFAYGIzY2NTQmIyIGFRQWM8xCKS1IKSZDKS1JKR8lIxgaJiQXAhgiQi4xSyciQy0ySidVKSEdJCghHiQAAAEAHP7NAUIDpwAWABlAFgIBAQABhgAAADUATgAAABYAFSoDCRcrEiY3NhM+Ajc2NjMyBw4CBwIHBgYjOx8DFjoEJhwKAygbPQYNIB8EOhYDKBv+zRkevQF6HPPRVx0YNXHjxxz+hr0eGQAAAAIAHv7NAT0DpwAQACEAPEA5CgICAQAbEwIDAgJMBAEBAAIAAQKAAAIDAAIDfgUBAwOEAAAANQBOEREAABEhESAaGAAQAA8nBgkXKxImNTQ3EzY2MzIVFAcDBgYjAiY1NDcTNjYzMhUUBwMGBiOhIAE9BCcbOAE9BCcbeyABPQQnGzgBPQQnGwGKFRcHBAGxHRgrBgT+Tx4Z/UMUGAcEAbEdGCsGBP5PHhkAAAABAIMA+QJDA6gAIgAxQC4eAQMEDQEBAAJMAAEAAYYGBQIDAgEAAQMAaAAEBDUETgAAACIAISMkJCMkBwkbKwAWFRQGJycDBgYjIiY1NxMHIiY1NDYXFzc2NjMyFhUUBwc3AisYIRx1MAQlGBUdATVyFxghHHINAyUYFR4BEXQDCRsTGCcBAv6QGhwXFgkBcAIbFBgmAQJsGRwXFAcDbAIAAQBiAPkCQwOoADUAP0A8KwEGBxABAgECTAACAQKGCAEGCgkCBQAGBWgEAQADAQECAAFnAAcHNQdOAAAANQA0JSMkISQlIyQhCwkfKwEHNzIWFRQGJycHBgYjIiY1NDc3ByImNTQ2Fxc3ByImNTQ2Fxc3NjYzMhYVFAcHNzIWFRQGJwGQFXgXGCEcdwwDJhgVHQEScRcYIRxzFXUXGCEcdAwDJRgVHgESdBcYIRwCn50CGxQYJgECaxkdFxUGBGsCGxMYJwECnQIbFBgmAQJsGRwXFAcDbAIbExgnAQAAAAAEAEv/+wShA1QALwA/AEsAWgEtS7AhUFhACgoBBwAOAQgDAkwbQAoKAQcFDgEIAwJMWUuwCVBYQDMNAQgMAQYJCAZpAAkOAQoCCQpnAAcHAGEFAQIAADlNAAMDAGEFAQIAADlNCwQCAgI0Ak4bS7AMUFhAMw0BCAwBBgkIBmkACQ4BCgIJCmcABwcAYQUBAgAAM00AAwMAYQUBAgAAM00LBAICAjQCThtLsCFQWEAzDQEIDAEGCQgGaQAJDgEKAgkKZwAHBwBhBQECAAA5TQADAwBhBQECAAA5TQsEAgICNAJOG0AwDQEIDAEGCQgGaQAJDgEKAgkKZwAHBwVhAAUFM00AAwMAYQEBAAA5TQsEAgICNAJOWVlZQCVMTEBAMDAAAExaTFhUT0BLQEpGRDA/MD44NgAvAC4pKycmDwkaKxYmNzYTNjYzMhYVFAcGBxIzMhYVFAYHBwYGBwYGIyImNTQ2Nzc2NTQjIgYCBwYGIwAmJjU0NjYzMhYWFRQGBiM2NjU0JiMiBhUUFjMGJjU0OwMyFhUUBiMjbiMDDlYFKh0iGAIGHG/FVFUODBYMFwQDKCYhIBcVGBU+Q4RpGAQlIgMjRyQwVDU0SCQxVTQlJyEXHichGcIVLW44bxAOMyrQBR8mqQIxIBoUFwcUPYMBAl1OI15Ee0GyMSUhIBwik3WFeCtIkv7Z1iEmAcgxUC5AZDcxUC4/ZDhaPjsuLz08MC36Fhg4DhMhJAAAAQBYAC8CQQI7ABkAIbEGZERAFhgBAAEBTAABAAGFAgEAAHYnJyEDCRkrsQYARDYGIyImNTQ3EzY2MzIWFxMWFRQGIyImJwMDuh4RFR4J5gsjExIdBoEDIRUPGQZktUESGBMOEAGaFBUVFP5nCgsYHRISAUz+tAAAAv4vAhT/kgKxAAsAFwAysQZkREAnAgEAAQEAWQIBAAABYQUDBAMBAAFRDAwAAAwXDBYSEAALAAokBgkXK7EGAEQAJjU0NjMyFhUUBiMyJjU0NjMyFhUUBiP+UyQrJCAkKySwJCskICQrJAIUIyUoLSMlKC0jJSgtIyUoLQAAAAAB/oUCFP84ArAACwAmsQZkREAbAAABAQBZAAAAAWECAQEAAVEAAAALAAokAwkXK7EGAEQAJjU0NjMyFhUUBiP+ryo3KSUuNCsCFCcjIy8kISgvAAAB/iECFP76A0MAEAAfsQZkREAUAAABAIUCAQEBdgAAABAADyYDCRcrsQYARAAnJyY1NDYzMhYXFxYVFAYj/sUNgRYnGREeCV0EFQ4CFBGmHBwcJBQU0AkKDxUAAAH+tAIU/44DQgAQACWxBmREQBoCAQEAAUwAAAEAhQIBAQF2AAAAEAAPJwMJFyuxBgBEACY1NDc3NjYzMhYVFAcHBiP+yRUFXQkdEhknFoENEwIUFQ8HDNAUEyQbHBymEQAAAAAC/lkCE//LA0QAEQAjADGxBmREQCYUAgIBAAFMAgEAAQCFBQMEAwEBdhISAAASIxIiGxkAEQAQJwYJFyuxBgBEACY1NDc3NjYzMhYVFAcHBgYjMiY1NDc3NjYzMhYVFAcHBgYj/m4VA0AGHxMaKA9nBhMKphUDQAYfExooD2cGEwoCExUQBwnRFRYjHBcZrAsLFRAHCdEVFiMcFxmsCwsAAf7CAOX/QgHRAA4AHkAbAAABAQBZAAAAAWECAQEAAVEAAAAOAA0lAwYXKyQmNzc2NjMyFhUUBwcGI/7YFgEGAScaGB8FJwsi5RUUhCEeHRsSDnMhAAAAAAH+LQIT/34DXAAZACexBmREQBwDAQABAUwAAQABhQMCAgAAdgAAABkAGCcmBAkYK7EGAEQCJicnBwYGIyImNTQ3NzY2MzIWFxcWFRQGI9EcBBdXDyIVFRkLcBItHx4iCSwDIRcCExcfsbEfFhMSERPBHx8kJ7QMChkbAAAB/lkCE/+qA1wAGQAnsQZkREAcDAECAAFMAQEAAgCFAwECAnYAAAAZABgmJwQJGCuxBgBEACYnJyY1NDYzMhYXFzc2NjMyFhUUBwcGBiP+syIJLAMhFxccBBdXDyIVFRkLcBItHwITJCe0DAoZGxcfsbEfFhMSERPBHx8AAf4WAhT/sQL0ABcALrEGZERAIwIBAAEAhQABAwMBWQABAQNhBAEDAQNRAAAAFwAWIyMlBQkZK7EGAEQAJiY1NDYzMhcWFjMyNjc2MzIWFRQGBiP+nlouIBkoCwwyJCgvFBIjFhczYUECFDJOKRkeKCouMSolGRYnUjgAAAL+YAIU/24DLAANABkAOLEGZERALQAAAAIDAAJpBQEDAQEDWQUBAwMBYQQBAQMBUQ4OAAAOGQ4YFBIADQAMJQYJFyuxBgBEACY1NDY2MzIWFRQGBiM2NjU0JiMiBhUUFjP+rEwnQSU1TCdBJRgcGhIUHBoSAhRHPS1DJEc9LUMkWB4ZFhseGRYbAAAAAf4KAhT/vQLXAB4AWbEGZERLsBBQWLYSAwIAAQFMG7YSAwIAAgFMWUuwEFBYQAwCAQEAAYUEAwIAAHYbQBQAAQIBhQACAAKFAAADAIUEAQMDdllADAAAAB4AHSUmJQUJGSuxBgBEAiYnJwcGIyImNTQ3NjYzMhYXFzc2MzIWFRQGBwYGI9UcFmssEB0SGSUXLBoRGxZrLBAdEhkTEhcsGgIUCw9KPxYVEhc2IR8KEEo/FhUSDiMcIR8AAAAB/jgCFP95AnIADQAmsQZkREAbAAABAQBXAAAAAV8CAQEAAU8AAAANAAs0AwkXK7EGAEQAJjU0NjMzMhYVFAYjI/5PFxwZ3xYXHBnfAhQWFBgcFRIaHQAAAf6AAhT/bAMrAB0AXrEGZERLsC5QWEAaAAMCAQEAAwFpAAAEBABZAAAABGEFAQQABFEbQCEAAgEAAQIAgAADAAECAwFpAAAEBABZAAAABGEFAQQABFFZQA0AAAAdABsmISMkBgkaK7EGAEQAJjU0NjMyNTQmIyIGIyImNTQ2NzYzMhYVFAYGIyP+tBIaFj8eGxApBBALFhYXIkBHKUMmEQIUEhIZEkgZGAUOExUUBQVFOSxGJwAAAAL95QIT/1cDRAARACMAKrEGZERAHwIBAAEAhQUDBAMBAXYSEgAAEiMSIhsZABEAECcGCRcrsQYARAAmJycmNTQ2MzIWFxcWFRQGIzImJycmNTQ2MzIWFxcWFRQGI/50EwZnDygaEx8GQAMVD6sTBmcPKBoTHwZAAxUPAhMLC6wZFxwjFhXRCQcQFQsLrBkXHCMWFdEJBxAVAAAAAAH+FgIU/7EC9AAXAC6xBmREQCMEAwIBAgGGAAACAgBZAAAAAmEAAgACUQAAABcAFiMlJQUJGSuxBgBEACY1NDY2MzIWFhUUBiMiJyYmIyIGBwYj/i0XM2FBPlouIBkoCwwyJCgvFBIjAhQZFidSODJOKRkeKCouMSolAAAB/rECFP8xAwAADgAmsQZkREAbAAABAQBZAAAAAWECAQEAAVEAAAAOAA0lAwkXK7EGAEQAJjc3NjYzMhYVFAcHBiP+xxYBBgEnGhgfBScLIgIUFRSEIR4dGxIOcyEAAAAB/rwBbP96AlEACwAmsQZkREAbAAEAAYUAAAICAFkAAAACYQACAAJRFCMQAwkZK7EGAEQBMjY3NjMyFgcGBiP+zx8iCQcmGhoDB2NRAcwvLychIUtYAAAAAf4q/xz+3f+4AAsAJrEGZERAGwAAAQEAWQAAAAFhAgEBAAFRAAAACwAKJAMJFyuxBgBEBCY1NDYzMhYVFAYj/lQqNyklLjQr5CcjIy8kISgvAAAAAv3S/xv/Nf+4AAsAFwAysQZkREAnAgEAAQEAWQIBAAABYQUDBAMBAAFRDAwAAAwXDBYSEAALAAokBgkXK7EGAEQEJjU0NjMyFhUUBiMyJjU0NjMyFhUUBiP99iQrJCAkKySwJCskICQrJOUjJSgtIyUoLSMlKC0jJSgtAAH+Rf7M/sX/uAAOACaxBmREQBsAAAEBAFkAAAABYQIBAQABUQAAAA4ADSUDCRcrsQYARAAmNzc2NjMyFhUUBwcGI/5bFgEGAScaGB8FJwsi/swVFIQhHh0bEg5zIQAAAAH94v8G/wIAJwAfAGaxBmREtRIBAgMBTEuwLlBYQBsAAwACAAMCaQEBAAQEAFkBAQAABGEFAQQABFEbQCEAAAIBAgABgAADAAIAAwJpAAEEBAFZAAEBBGEFAQQBBFFZQA0AAAAfAB42JCMUBgkaK7EGAEQEJyY1NDMyFxYzMjY1NCYjIiY1NDc2NjMzMhYVFAYGI/4hGCcoCAUbGigtKyUaHAEEGBkaRVItVTn6BQclLQEEISIZHQ4RBgMUE0I7L0sqAAAB/i//Bv83AEQAFwBdsQZkREuwElBYtAYFAgBKG7QGBQIBSllLsBJQWEATAQEAAgIAWQEBAAACYQMBAgACURtAFgABAAGFAAACAgBZAAAAAmEDAQIAAlFZQAsAAAAXABYiKwQJGCuxBgBEBCY1NDY3FwYGFRQWMzI3NjMyFRQHBgYj/oBRQEAqIyEkGhoVEQoaLwwnEPpHPTlfIjoYOh0dHgcGJSgQBAYAAAAAAf2v/tj/Sv+4ABcALrEGZERAIwIBAAEAhQABAwMBWQABAQNhBAEDAQNRAAAAFwAWIyMlBQkZK7EGAEQAJiY1NDYzMhcWFjMyNjc2MzIWFRQGBiP+N1ouIBkoCwwxJSgvFBIjFhczYUH+2DJOKRkeKCouMSolGRYnUjgAAAH95/9a/yj/uAANACaxBmREQBsAAAEBAFcAAAABXwIBAQABTwAAAA0ACzQDCRcrsQYARAQmNTQ2MzMyFhUUBiMj/f4XHBnfFhccGd+mFhQYHBUSGh0AAAAB/qACFP8gAwAADgAeQBsAAAEBAFkAAAABYQIBAQABUQAAAA4ADSYDBhcrACY1NDc3NjMyFgcHBgYj/r8fBScLIhEWAQYBJxoCFB0bEg5zIRUUhCEeAAAAAv4tAhT/lAK1AAsAFwAqQCcCAQABAQBZAgEAAAFhBQMEAwEAAVEMDAAADBcMFhIQAAsACiQGCRcrACY1NDYzMhYVFAYjMiY1NDYzMhYVFAYj/lMmLCUgJiwlsCYsJSAmLCUCFCUlKS4lJSkuJSUpLiUlKS4AAAAAAf6DAhT/OgK0AAsAHkAbAAABAQBZAAAAAWECAQEAAVEAAAALAAokAwkXKwAmNTQ2MzIWFRQGI/6vLDkpJi82KwIUKSMkMCUiKTAAAAH9xAIU/u8DAAAPABdAFAAAAQCFAgEBAXYAAAAPAA4mAwkXKwAnJyY1NDYzMhcXFhUUBiP+vQm7NSYaGBSsExYQAhQFYRwrGiURkxAUDxUAAf6wAhT/2wMAAA8AF0AUAAABAIUCAQEBdgAAAA8ADiYDCRcrACY1NDc3NjMyFhUUBwcGI/7GFhOsFBgaJjW7CQwCFBUPFBCTESUaKxxhBQAC/lcCFP+qAwAAEAAhAClAJhMCAgEAAUwCAQABAIUFAwQDAQF2EREAABEhESAaGAAQAA8nBgkXKwAmNTQ3NzY2MzIWFRQHBwYjMiY1NDc3NjYzMhYVFAcHBiP+bxgCKQYdEhgmEEAOGKUYAikGHRIYJhBADhgCFBURBAqOFRUiGxcaaBYVEQQKjhUVIhsXGmgWAAAAAf4pAhP/gwMjABgAE0AQAAEAAYUCAQAAdicmIwMJGSsBBwYGIyImNTQ3NzYzMhYXFxYVFAYjIiYn/u5QCyQTFR4NXCVEHyUPLwYiFxEdBQLJjhQUFxMRFIk4ICV5Dw0YHRMRAAH+SAIU/5oDDQAZAB9AHAwBAgABTAEBAAIAhQMBAgJ2AAAAGQAYJicECRgrACYnJyY1NDYzMhYXFzc2NjMyFhUUBwcGBiP+uyQTMgocFRUaBzBODhwXExkRVBUsHQIUICVjFBEVFxAUfnsWERMRExdzHRsAAf4UAhT/swLNABgAJkAjAgEAAQCFAAEDAwFZAAEBA2EEAQMBA1EAAAAYABcjJCUFCRkrACYmNTQ2MzIWFxYWMzI2NzYzMhYVFAYGI/6eWy8iGRQXCA8sJycwFBQlExg0YkECFClBIhUYDxIgGB0eHhQSIEUuAAAAAv5gAhT/bgMsAA0AGQAwQC0AAAACAwACaQUBAwEBA1kFAQMDAWEEAQEDAVEODgAADhkOGBQSAA0ADCUGCRcrACY1NDY2MzIWFRQGBiM2NjU0JiMiBhUUFjP+rEwnQSU1TCdBJRgcGhIUHBoSAhRHPS1DJEc9LUMkWB4ZFhseGRYbAAAAAf4GAhT/wQLbAB8AUUuwEFBYthIDAgABAUwbthIDAgACAUxZS7AQUFhADAIBAQABhQQDAgAAdhtAFAABAgGFAAIAAoUAAAMAhQQBAwN2WUAMAAAAHwAeJiUmBQkZKwImJycHBgYjIiY1NDc2MzIWFxc3NjYzMhYVFAYHBgYj1RwWaywIGQ0TGyUsNREbFmssCBkNExsQFRQyGwIUCw9KPwsLFBMbNkAKEEo/CwsUEw0hIyEfAAAAAAH+OAIU/3kCdgAMAB5AGwAAAQEAVwAAAAFfAgEBAAFPAAAADAAKMwMJFysANTQ2MzMyFhUUBiMj/jgcGd8WFxwZ3wIULBkdFRQbHgAB/oACFP9uAwkAHABWS7AuUFhAGgADAgEBAAMBaQAABAQAWQAAAARhBQEEAARRG0AhAAIBAAECAIAAAwABAgMBaQAABAQAWQAAAARhBQEEAARRWUANAAAAHAAaJiEkJAYJGisAJjU0NjMyNjU0JiMiBiMiJjU0Njc2MzIVFAYjI/61EhoWHR4XGBIsBRAMFxcYHIxPRQ8CFBISGxQYEhEUBRAVFRQFBW0/SQAAAv4HAhT/WgMAABAAIQAiQB8CAQABAIUFAwQDAQF2EREAABEhESAZFwAQAA8mBgkXKwAnJyY1NDYzMhYXFxYVFAYjMicnJjU0NjMyFhcXFhUUBiP+ZQ5AECYYEh0GKQIYEJ0OQBAmGBIdBikCGBACFBZoGhcbIhUVjgoEERUWaBoXGyIVFY4KBBEVAAAB/hYCFP+1As0AGAAmQCMEAwIBAgGGAAACAgBZAAAAAmEAAgACUQAAABgAFyQlJQUJGSsAJjU0NjYzMhYWFRQGIyImJyYmIyIGBwYj/i4YNGJBPlsvIhkUFwgPLCcnMBQUJQIUFBIgRS4pQSIVGA8SIBgdHh4AAAAB/q4CFP8sAuAADwAeQBsAAAEBAFkAAAABYQIBAQABUQAAAA8ADiUDCRcrACY3NzY2MzIWFRQHBwYGI/7IGgEDASMYGSUGHQUbDwIUFhNmHx4dGw0RVRARAAAAAAH+uQFa/5gCaQANABlAFgABAAGFAAICAGEAAAA2Ak4WIxADCRkrATI2NzYzMhYVFAcGBiP+zyUpCgguGyABCnRgAcw3OC4gHwoFWGkAAAAAAf4n/xj+3v+4AAsAHkAbAAABAQBZAAAAAWECAQEAAVEAAAALAAokAwkXKwQmNTQ2MzIWFRQGI/5TLDkpJi82K+gpIyQwJSIpMAAAAAL90P8X/zf/uAALABcAKkAnAgEAAQEAWQIBAAABYQUDBAMBAAFRDAwAAAwXDBYSEAALAAokBgkXKwQmNTQ2MzIWFRQGIzImNTQ2MzIWFRQGI/32JiwlICYsJbAmLCUgJiwl6SUlKS4lJSkuJSUpLiUlKS4AAf5I/uz+xv+4AA8AHkAbAAABAQBZAAAAAWECAQEAAVEAAAAPAA4lAwkXKwAmNzc2NjMyFhUUBwcGBiP+YhoBAwEjGBklBh0FGw/+7BYTZh8eHRsOEFUQEQAAAAAB/eL/Av8GACcAIABetRQBAgMBTEuwLlBYQBsAAwACAAMCaQEBAAQEAFkBAQAABGEFAQQABFEbQCEAAAIBAgABgAADAAIAAwJpAAEEBAFZAAEBBGEFAQQBBFFZQA0AAAAgAB82JCMWBgkaKwQnJiY1NDYzMhcWMzI2NTQmIyImNTQ3NjYzMzIWFRQGI/4hGBQTFBQIBRsaKC0rJRocAQQYGRpHVGdY/gUEFhUYFgEEISIZHQ4RBgMUE0I7S10AAAAB/iv/Av83AEQAGQBVS7ASUFi0BgUCAEobtAYFAgFKWUuwElBYQBMBAQACAgBZAQEAAAJhAwECAAJRG0AWAAEAAYUAAAICAFkAAAACYQMBAgACUVlACwAAABkAGCIrBAkYKwQmNTQ2NxcGBhUUFjMyNzYzMhYVFAYHBgYj/n9UREAqIyEkGhoVEQoODBYZDCcQ/kk/OGAiOhg6HR0eBwYTExUdCQQGAAAB/bH+//9Q/7gAGAAmQCMCAQABAIUAAQMDAVkAAQEDYQQBAwEDUQAAABgAFyMkJQUJGSsAJiY1NDYzMhYXFhYzMjY3NjMyFhUUBgYj/jtbLyIZFBcIDywnJzAUFCUTGDRiQf7/KUEiFRgPEiAYHR4eFBIgRS4AAAAB/ef/Vv8o/7gADAAeQBsAAAEBAFcAAAABXwIBAQABTwAAAAwACjMDCRcrBDU0NjMzMhYVFAYjI/3nHBnfFhccGd+qLBkdFRQbHgAAAQEJAhQBiQMAAA4AJrEGZERAGwAAAQEAWQAAAAFhAgEBAAFRAAAADgANJQMJFyuxBgBEACY3NzY2MzIWFRQHBwYjAR8WAQYBJxoYHwUnCyICFBUUhCEeHRsSDnMhAAD//wCQAhQB0QJyAAMFrwJYAAAAAP//AQwCFAHmA0IAAwWnAlgAAAAA//8AbgIUAgkC9AADBawCWAAAAAD//wCxAhMCAgNcAAMFqwJYAAAAAP//ADr/BgFaACcAAwW4AlgAAAAA//8AhQITAdYDXAADBaoCWAAAAAD//wCHAhQB6gKxAAMFpAJYAAAAAP//AN0CFAGQArAAAwWlAlgAAAAA//8AeQIUAVIDQwADBaYCWAAAAAD//wCxAhMCIwNEAAMFqAJYAAAAAP//AJACFAHRAnIAAwWvAlgAAAAA//8Ah/8GAY8ARAADBbkCWAAAAAD//wC4AhQBxgMsAAMFrQJYAAAAAP//AGICFAIVAtcAAwWuAlgAAAAAAAH+FwIU/5IC9AAZADBALRQBAQABTAACAAKFAAABAIUAAQMDAVkAAQEDYQQBAwEDUQAAABkAGCQjJQUHGSsAJiY1NDYzMhYXFjMyNjc2NjMyFhUHDgIj/oNGJiAZGhgHCi0vRA8IFBAPFQIKNl5BAhQmPiMZHxgdKjUmFBEXEQwpTjUAAAH+MgIU/68C6gAXACpAJwACAAKFAAABAIUAAQMDAVkAAQEDYQQBAwEDUQAAABcAFiMjJQUGGSsAJiY1NDYzMhcWFjMyNjc2MzIWFRQGBiP+okwkHRwpDAwgHyRACQgmExYuYUcCFCU7IhkeISAYNSIfFBIjUjsAAAL+FAIU/7MDXQAQACkAtUuwDVBYQB8EAQIAAQACAYAGAQEDAAEDfgADBwEFAwVlAAAAOQBOG0uwDlBYQB8EAQIAAQACAYAGAQEDAAEDfgADBwEFAwVlAAAAMwBOG0uwJlBYQB8EAQIAAQACAYAGAQEDAAEDfgADBwEFAwVlAAAAOQBOG0AiAAACAIUEAQIBAoUGAQEDAYUAAwUFA1kAAwMFYQcBBQMFUVlZWUAWEREAABEpESgjIR4cGBYAEAAPJggJFysAJjU0Nzc2MzIWFRQGBwcGIwYmJjU0NjMyFhcWFjMyNjc2MzIWFRQGBiP+3RIQTxAVFiEVGFwMBk1bLyIZFBcIDywnJzAUFCUTGDRiQQLBEg0OEE8QIRYSIAolBK0pQSIVGA8SIBgdHh4UEiBFLgAAAv4UAhT/swNdABAAKQCpS7ANUFhAHgQBAgABAAIBgAABAwABA34AAwYBBQMFZgAAADkAThtLsA5QWEAeBAECAAEAAgGAAAEDAAEDfgADBgEFAwVmAAAAMwBOG0uwJlBYQB4EAQIAAQACAYAAAQMAAQN+AAMGAQUDBWYAAAA5AE4bQCEAAAIAhQQBAgEChQABAwGFAAMFBQNZAAMDBWIGAQUDBVJZWVlADhERESkRKCMkJhYnBwkbKwAnJyYmNTQ2MzIXFxYVFAYjBiYmNTQ2MzIWFxYWMzI2NzYzMhYVFAYGI/7uDFwYFSEWFRBPEBIOVlsvIhkUFwgPLCcnMBQUJRMYNGJBAsEEJQogEhYhEE8QDg0SrSlBIhUYDxIgGB0eHhQSIEUuAAAC/hQCFP+zA4gAGgAzAEhARQcBBQAEAAUEgAADAgEBAAMBaQAACQEEBgAEaQAGCAgGWQAGBghhCgEIBghRGxsAABszGzItKygmIiAAGgAYJiEjIwsJGisAJjc0MzI2NTQjIgYjIiY1NDY3NjMyFRQGIyMGJiY1NDYzMhYXFhYzMjY3NjMyFhUUBgYj/rYQASgZGigQJQQOChMUEBx3QzsMK1svIhkUFwgPLCcnMBQUJRMYNGJBArgQESYUDyAEDRISEQQEXDY+pClBIhUYDxIgGB0eHhQSIEUuAAAAAv4UAhT/wAOOABwANQCNS7ASUFi2EQMCAAEBTBu2EQMCAAIBTFlLsBJQWEAkAgEBAAGFCAMCAAQAhQYBBAUEhQAFBwcFWQAFBQdiCQEHBQdSG0AsAAECAYUAAgAChQAAAwCFCAEDBAOFBgEEBQSFAAUHBwVZAAUFB2IJAQcFB1JZQBgdHQAAHTUdNC8tKigkIgAcABslJSUKCRkrAiYnJwcGIyImNTQ3NjMyFhcXNzYzMhYVFAYHBiMGJiY1NDYzMhYXFhYzMjY3NjMyFhUUBgYjyBkTYCgPGxEYIScxDxgUYCgPGxEYDhMkNKlbLyIZFBcIDywnJzAUFCUTGDRiQQLbCg1DORQTEBkwOgkOQzkUExEMHSA5xylBIhUYDxIgGB0eHhQSIEUuAAAAAv4tAhQADwNwABAAKAAzQDAlAQMBAUwAAAIAhQACAQKFBQEBAwGFBgQCAwN2EREAABEoESciIBkXABAADyYHCRcrAiY1NDc3NjMyFhUUBgcHBiMEJjU0Nzc2MzIWFxcWFRQGIyImJycHBiOaEhBPEBUWIRUYXAwG/tQbE1IoQR8lDycJIhYRFQYxThQrAtQSDQ4QTxAhFhIgCiUEwBAOEBZeLRodTRIOFRYKDWhmGQAC/dQCFP9+A3AAEAAoACtAKCUBAwEBTAAAAgCFAAIBAoUAAQMBhQUEAgMDdhERESgRJycnFicGCRorACcnJiY1NDYzMhcXFhUUBiMGJjU0Nzc2MzIWFxcWFRQGIyImJycHBiP+aQxcGBUhFhUQTxASDicbE1IoQR8lDycJIhYRFQYxThQrAtQEJQogEhYhEE8QDg0SwBAOEBZeLRodTRIOFRYKDWhmGQAC/i0CFAAXA2YAGgAyAJ61LwEGBAFMS7AXUFhAHQkHAgYEBoYFAQAIAQQGAARpAgEBAQNhAAMDOQFOG0uwJlBYQCMJBwIGBAaGAAMCAQEAAwFpBQEABAQAWQUBAAAEYQgBBAAEURtAKQAFAQABBQCACQcCBgQGhgADAgEBBQMBaQAABAQAWQAAAARhCAEEAARRWVlAFxsbAAAbMhsxLCojIQAaABgmISMjCgkaKwImNTQzMjY1NCMiBiMiJjU0Njc2MzIVFAYjIwQmNTQ3NzYzMhYXFxYVFAYjIiYnJwcGI4YPKBkaKBAlBA4KExQQHHdDOwz+uxsTUihBHyUPJwkiFhEVBjFOFCsClhARJhQPIAQNEhIQBQRcNj6CEA4QFl4tGh1NEg4VFgoNaGYZAAAAAv4tAhT/twOHAB0ANQDNS7AVUFhACxEDAgABMgEFBAJMG0ALEQMCAAIyAQUEAkxZS7AVUFhAJQcDAgABBAEABIAABAUBBAV+AgEBAAUBWQIBAQEFYQgGAgUBBVEbS7AXUFhAKgACAQABAgCABwMCAAQBAAR+AAQFAQQFfgABAgUBWQABAQVhCAYCBQEFURtAMAACAQABAgCAAAADAQADfgcBAwQBAwR+AAQFAQQFfgABAgUBWQABAQVhCAYCBQEFUVlZQBYeHgAAHjUeNC8tJiQAHQAcJiUlCQkZKwImJycHBiMiJjU0NzYzMhYXFzc2NjMyFhUUBgcGIwYmNTQ3NzYzMhYXFxYVFAYjIiYnJwcGI8oXElsmDhkQFyAkLg8XElsmBxUMEBYOEiEx/RsTUihBHyUPJwkiFhEVBjFOFCsC6AgMPDMSEQ8ULTMIDTsyCQkQDwsZHTPUEA4QFl4tGh1NEg4VFgoNaGYZAAL+FAIU/7MDXQAQACkAtUuwDVBYQB8EAQIAAQACAYAGAQEDAAEDfgADBwEFAwVlAAAAOQBOG0uwDlBYQB8EAQIAAQACAYAGAQEDAAEDfgADBwEFAwVlAAAAMwBOG0uwJlBYQB8EAQIAAQACAYAGAQEDAAEDfgADBwEFAwVlAAAAOQBOG0AiAAACAIUEAQIBAoUGAQEDAYUAAwUFA1kAAwMFYQcBBQMFUVlZWUAWEREAABEpESgjIR4cGBYAEAAPJggJFysAJjU0Nzc2MzIWFRQGBwcGIwYmJjU0NjMyFhcWFjMyNjc2MzIWFRQGBiP+3RIQTxAVFiEVGFwMBk1bLyIZFBcIDywnJzAUFCUTGDRiQQLBEg0OEE8QIRYSIAolBK0pQSIVGA8SIBgdHh4UEiBFLgAAAv4UAhT/swNdABAAKQCpS7ANUFhAHgQBAgABAAIBgAABAwABA34AAwYBBQMFZgAAADkAThtLsA5QWEAeBAECAAEAAgGAAAEDAAEDfgADBgEFAwVmAAAAMwBOG0uwJlBYQB4EAQIAAQACAYAAAQMAAQN+AAMGAQUDBWYAAAA5AE4bQCEAAAIAhQQBAgEChQABAwGFAAMFBQNZAAMDBWIGAQUDBVJZWVlADhERESkRKCMkJhYnBwkbKwAnJyYmNTQ2MzIXFxYVFAYjBiYmNTQ2MzIWFxYWMzI2NzYzMhYVFAYGI/7uDFwYFSEWFRBPEBIOVlsvIhkUFwgPLCcnMBQUJRMYNGJBAsEEJQogEhYhEE8QDg0SrSlBIhUYDxIgGB0eHhQSIEUuAAAC/hQCFP+zA4gAGgAzAEhARQcBBQAEAAUEgAADAgEBAAMBaQAACQEEBgAEaQAGCAgGWQAGBghhCgEIBghRGxsAABszGzItKygmIiAAGgAYJiEjIwsJGisAJjc0MzI2NTQjIgYjIiY1NDY3NjMyFRQGIyMGJiY1NDYzMhYXFhYzMjY3NjMyFhUUBgYj/rYQASgZGigQJQQOChMUEBx3QzsMK1svIhkUFwgPLCcnMBQUJRMYNGJBArgQESYUDyAEDRISEQQEXDY+pClBIhUYDxIgGB0eHhQSIEUuAAAAAv4UAhT/wAOOABwANQCNS7ASUFi2EQMCAAEBTBu2EQMCAAIBTFlLsBJQWEAkAgEBAAGFCAMCAAQAhQYBBAUEhQAFBwcFWQAFBQdiCQEHBQdSG0AsAAECAYUAAgAChQAAAwCFCAEDBAOFBgEEBQSFAAUHBwVZAAUFB2IJAQcFB1JZQBgdHQAAHTUdNC8tKigkIgAcABslJSUKCRkrAiYnJwcGIyImNTQ3NjMyFhcXNzYzMhYVFAYHBiMGJiY1NDYzMhYXFhYzMjY3NjMyFhUUBgYjyBkTYCgPGxEYIScxDxgUYCgPGxEYDhMkNKlbLyIZFBcIDywnJzAUFCUTGDRiQQLbCg1DORQTEBkwOgkOQzkUExEMHSA5xylBIhUYDxIgGB0eHhQSIEUuAAAAAv4tAhQADwNwABAAKAAzQDAlAQMBAUwAAAIAhQACAQKFBQEBAwGFBgQCAwN2EREAABEoESciIBkXABAADyYHCRcrAiY1NDc3NjMyFhUUBgcHBiMEJjU0Nzc2MzIWFxcWFRQGIyImJycHBiOaEhBPEBUWIRUYXAwG/tQbE1IoQR8lDycJIhYRFQYxThQrAtQSDQ4QTxAhFhIgCiUEwBAOEBZeLRodTRIOFRYKDWhmGQAC/dQCFP9+A3AAEAAoACtAKCUBAwEBTAAAAgCFAAIBAoUAAQMBhQUEAgMDdhERESgRJycnFicGCRorACcnJiY1NDYzMhcXFhUUBiMGJjU0Nzc2MzIWFxcWFRQGIyImJycHBiP+aQxcGBUhFhUQTxASDicbE1IoQR8lDycJIhYRFQYxThQrAtQEJQogEhYhEE8QDg0SwBAOEBZeLRodTRIOFRYKDWhmGQAC/i0CFAAXA2YAGgAyAJ61LwEGBAFMS7AXUFhAHQkHAgYEBoYFAQAIAQQGAARpAgEBAQNhAAMDOQFOG0uwJlBYQCMJBwIGBAaGAAMCAQEAAwFpBQEABAQAWQUBAAAEYQgBBAAEURtAKQAFAQABBQCACQcCBgQGhgADAgEBBQMBaQAABAQAWQAAAARhCAEEAARRWVlAFxsbAAAbMhsxLCojIQAaABgmISMjCgkaKwImNTQzMjY1NCMiBiMiJjU0Njc2MzIVFAYjIwQmNTQ3NzYzMhYXFxYVFAYjIiYnJwcGI4YPKBkaKBAlBA4KExQQHHdDOwz+uxsTUihBHyUPJwkiFhEVBjFOFCsClhARJhQPIAQNEhIQBQRcNj6CEA4QFl4tGh1NEg4VFgoNaGYZAAAAAv4tAhT/twOHAB0ANQDNS7AVUFhACxEDAgABMgEFBAJMG0ALEQMCAAIyAQUEAkxZS7AVUFhAJQcDAgABBAEABIAABAUBBAV+AgEBAAUBWQIBAQEFYQgGAgUBBVEbS7AXUFhAKgACAQABAgCABwMCAAQBAAR+AAQFAQQFfgABAgUBWQABAQVhCAYCBQEFURtAMAACAQABAgCAAAADAQADfgcBAwQBAwR+AAQFAQQFfgABAgUBWQABAQVhCAYCBQEFUVlZQBYeHgAAHjUeNC8tJiQAHQAcJiUlCQkZKwImJycHBiMiJjU0NzYzMhYXFzc2NjMyFhUUBgcGIwYmNTQ3NzYzMhYXFxYVFAYjIiYnJwcGI8oXElsmDhkQFyAkLg8XElsmBxUMEBYOEiEx/RsTUihBHyUPJwkiFhEVBjFOFCsC6AgMPDMSEQ8ULTMIDTsyCQkQDwsZHTPUEA4QFl4tGh1NEg4VFgoNaGYZAAEAjf8jAbgAWwAOABBADQ4NAgBKAAAAdiQBBhcrJAYHBgYjIiY1NDc2NzcXAX5HHBkiGhciC0QnXlcFYjQtHx4WEg9lRjgcAAIAYv6tAd0AagAPABcAK0AoEgECAAFMAAACAIUDAQIBAQJZAwECAgFhAAECAVEQEBAXEBYkIAQGGCskMzIHDgIjIiY1NDY2NzcCNjcGFRQWMwGZEzEGDzVcSkJJOG1kCVoxEXsODGo1hapZPjY3VU85K/64V2JRTA0PAAABAAz+rQHLADMAGABEtAkIAgJKS7AQUFhAFgACAAACcAAAAQEAWQAAAAFiAAEAAVIbQBUAAgAChQAAAQEAWQAAAAFiAAEAAVJZtSQrIQMGGSsWFjMyNjc2NjcXBgYHBgYjIiY1NDYzMhYVhw4MFBsSIDUqajc4HhpPOkNMJxsXItkPHidEXjQTQ2RLQz48NSAoGhgAAQD+/0sCCgBbAA4AEEANDg0CAEoAAAB2JAEGFyskBgcGBiMiJjU0NzY3NxcB0zAgGyQZFBkQJTNNVwhAMysfGBIVFjJROBwAAgCQ/tABywBjABMAGgAsQCkWBQICAAFMAAACAIUDAQIBAQJZAwECAgFhAAECAVEUFBQaFBknIQQGGCslNjMyFgcGBgcGBiMiJjU0NjY3NwI2NwYVFDMBiS0HCAYBBQ0PHF4+KjcjXVUNVC0OaBVaCQ4VQEYwXF44KiRBUDM7/tlGRT43FgAAAAEAi/7RAeoAMwAZACNAIAkIAgJKAAIAAoUAAAEBAFkAAAABYQABAAFRJSshAwYZKxYWMzI2NzY2NxcGBgcGBiMiJiY1NDYzMhYV8wsJEBoOEigeUyAjFhVLPBcxIh0WFh/DDyMqN1YrEjJQSENDFy4hHCMYFAAAAAEAuv8jAegAggAUABFADgABAAGFAAAAdikjAgkYKwQHBgYjIiY1NDc2Nzc2NjMyFhUUBwF8NB4fGBghC0QnOBEsDxkbFEFQLh4gFRIOZUZXAwUVEhUZAAABAMH/SwHHAGUAFQARQA4AAQABhQAAAHYYJQIJGCskBgYHBgYjIiY1NDc2Nzc2FxYWFRQHAZIsGwUbJBkUGRAlM00PKAwOCwM6LAgrHxgSFRYyUTIQAgEPCwwNAAAAGgE+AAEAAAAAAAAAVQAAAAEAAAAAAAEACABVAAEAAAAAAAIABwBdAAEAAAAAAAMAGwBkAAEAAAAAAAQAEAB/AAEAAAAAAAUADQCPAAEAAAAAAAYAEACcAAEAAAAAAAgADACsAAEAAAAAAAkADAC4AAEAAAAAAAsAGQDEAAEAAAAAAAwAGQDdAAEAAAAAAA0AkAD2AAEAAAAAAA4AGgGGAAMAAQQJAAAAqgGgAAMAAQQJAAEAEAJKAAMAAQQJAAIADgJaAAMAAQQJAAMANgJoAAMAAQQJAAQAIAKeAAMAAQQJAAUAGgK+AAMAAQQJAAYAIALYAAMAAQQJAAgAGAL4AAMAAQQJAAkAGAMQAAMAAQQJAAsAMgMoAAMAAQQJAAwAMgNaAAMAAQQJAA0BIAOMAAMAAQQJAA4ANASsQ29weXJpZ2h0IDIwMTggVGhlIFBhY2lmaWNvIFByb2plY3QgQXV0aG9ycyAoaHR0cHM6Ly9naXRodWIuY29tL2dvb2dsZWZvbnRzL1BhY2lmaWNvKVBhY2lmaWNvUmVndWxhcjMuMDAxO25ld3Q7UGFjaWZpY28tUmVndWxhclBhY2lmaWNvIFJlZ3VsYXJWZXJzaW9uIDMuMDAxUGFjaWZpY28tUmVndWxhclZlcm5vbiBBZGFtc1Zlcm5vbiBBZGFtc2h0dHA6Ly93d3cuc2Fuc294eWdlbi5jb21odHRwOi8vd3d3LnNhbnNveHlnZW4uY29tVGhpcyBGb250IFNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBTSUwgT3BlbiBGb250IExpY2Vuc2UsIFZlcnNpb24gMS4xLiBUaGlzIGxpY2Vuc2UgaXMgYXZhaWxhYmxlIHdpdGggYSBGQVEgYXQ6IGh0dHA6Ly9zY3JpcHRzLnNpbC5vcmcvT0ZMaHR0cDovL3NjcmlwdHMuc2lsLm9yZy9PRkwAQwBvAHAAeQByAGkAZwBoAHQAIAAyADAAMQA4ACAAVABoAGUAIABQAGEAYwBpAGYAaQBjAG8AIABQAHIAbwBqAGUAYwB0ACAAQQB1AHQAaABvAHIAcwAgACgAaAB0AHQAcABzADoALwAvAGcAaQB0AGgAdQBiAC4AYwBvAG0ALwBnAG8AbwBnAGwAZQBmAG8AbgB0AHMALwBQAGEAYwBpAGYAaQBjAG8AKQBQAGEAYwBpAGYAaQBjAG8AUgBlAGcAdQBsAGEAcgAzAC4AMAAwADEAOwBuAGUAdwB0ADsAUABhAGMAaQBmAGkAYwBvAC0AUgBlAGcAdQBsAGEAcgBQAGEAYwBpAGYAaQBjAG8AIABSAGUAZwB1AGwAYQByAFYAZQByAHMAaQBvAG4AIAAzAC4AMAAwADEAUABhAGMAaQBmAGkAYwBvAC0AUgBlAGcAdQBsAGEAcgBWAGUAcgBuAG8AbgAgAEEAZABhAG0AcwBWAGUAcgBuAG8AbgAgAEEAZABhAG0AcwBoAHQAdABwADoALwAvAHcAdwB3AC4AcwBhAG4AcwBvAHgAeQBnAGUAbgAuAGMAbwBtAGgAdAB0AHAAOgAvAC8AdwB3AHcALgBzAGEAbgBzAG8AeAB5AGcAZQBuAC4AYwBvAG0AVABoAGkAcwAgAEYAbwBuAHQAIABTAG8AZgB0AHcAYQByAGUAIABpAHMAIABsAGkAYwBlAG4AcwBlAGQAIAB1AG4AZABlAHIAIAB0AGgAZQAgAFMASQBMACAATwBwAGUAbgAgAEYAbwBuAHQAIABMAGkAYwBlAG4AcwBlACwAIABWAGUAcgBzAGkAbwBuACAAMQAuADEALgAgAFQAaABpAHMAIABsAGkAYwBlAG4AcwBlACAAaQBzACAAYQB2AGEAaQBsAGEAYgBsAGUAIAB3AGkAdABoACAAYQAgAEYAQQBRACAAYQB0ADoAIABoAHQAdABwADoALwAvAHMAYwByAGkAcAB0AHMALgBzAGkAbAAuAG8AcgBnAC8ATwBGAEwAaAB0AHQAcAA6AC8ALwBzAGMAcgBpAHAAdABzAC4AcwBpAGwALgBvAHIAZwAvAE8ARgBMAAAAAgAAAAAAAP+1ADIAAAAAAAAAAAAAAAAAAAAAAAAAAAX9AAABAgACAAMAJADJAQMBBAEFAQYBBwEIAMcBCQEKAQsBDAENAQ4AYgEPAK0BEAERARIBEwBjARQArgCQARUAJQAmAP0A/wBkARYBFwAnARgA6QEZARoBGwAoAGUBHAEdAMgBHgEfASABIQEiASMAygEkASUAywEmAScBKAEpASoAKQAqAPgBKwEsAS0BLgArAS8BMAAsAMwBMQDNATIAzgD6ATMAzwE0ATUBNgE3ATgALQE5AC4BOgAvATsBPAE9AT4BPwFAAOIAMAAxAUEBQgFDAUQBRQFGAGYAMgDQAUcA0QFIAUkBSgFLAUwBTQBnAU4BTwFQANMBUQFSAVMBVAFVAVYBVwFYAVkBWgFbAJEBXACvAV0AsAAzAO0ANAA1AV4BXwFgAWEBYgA2AWMA5AD7AWQBZQFmAWcANwFoAWkBagFrADgA1AFsANUBbQBoAW4A1gFvAXABcQFyAXMBdAF1AXYBdwF4AXkBegF7ADkAOgF8AX0BfgF/ADsAPADrAYAAuwGBAYIBgwGEAYUAPQGGAOYBhwGIAYkBigGLAYwBjQGOAY8BkAGRAZIBkwGUAZUBlgGXAZgBmQGaAZsBnAGdAZ4BnwGgAaEBogGjAaQBpQGmAacBqAGpAaoBqwGsAa0BrgGvAbABsQGyAbMBtAG1AbYBtwG4AbkBugG7AbwBvQG+Ab8BwAHBAcIBwwHEAcUBxgHHAcgByQHKAcsBzAHNAc4BzwHQAdEB0gHTAdQB1QHWAdcB2AHZAdoB2wHcAd0B3gHfAeAB4QHiAeMB5AHlAeYB5wHoAekB6gHrAewB7QHuAe8B8AHxAfIB8wH0AfUB9gH3AfgB+QH6AfsB/AH9Af4B/wIAAgECAgIDAgQCBQIGAgcCCAIJAgoCCwIMAg0CDgIPAhACEQISAhMCFAIVAhYCFwIYAhkCGgIbAhwCHQIeAh8CIAIhAiICIwIkAiUCJgInAigCKQBEAGkCKgIrAiwCLQIuAi8AawIwAjECMgIzAjQCNQBsAjYAagI3AjgCOQI6AG4COwBtAKACPABFAEYA/gEAAG8CPQI+AEcA6gI/AQECQABIAHACQQJCAHICQwJEAkUCRgJHAkgAcwJJAkoAcQJLAkwCTQJOAk8CUABJAEoA+QJRAlICUwJUAEsCVQJWAEwA1wB0AlcAdgJYAHcCWQJaAHUCWwJcAl0CXgJfAE0CYAJhAE4CYgJjAE8CZAJlAmYCZwJoAOMAUABRAmkCagJrAmwCbQJuAHgAUgB5Am8AewJwAnECcgJzAnQCdQB8AnYCdwJ4AHoCeQJ6AnsCfAJ9An4CfwKAAoECggKDAKEChAB9AoUAsQBTAO4AVABVAoYChwKIAokCigBWAosA5QD8AowCjQCJAFcCjgKPApACkQBYAH4CkgCAApMAgQKUAH8ClQKWApcCmAKZApoCmwKcAp0CngKfAqACoQBZAFoCogKjAqQCpQBbAFwA7AKmALoCpwKoAqkCqgKrAF0CrADnAq0CrgKvArACsQKyArMCtAK1ArYCtwK4ArkCugK7ArwCvQK+Ar8CwALBAsICwwLEAsUCxgLHAsgCyQLKAssCzALNAs4CzwLQAtEC0gLTAtQC1QLWAtcC2ALZAtoC2wLcAt0C3gLfAuAC4QLiAuMC5ALlAuYC5wLoAukC6gLrAuwC7QLuAu8C8ALxAvIC8wL0AvUC9gL3AvgC+QL6AvsC/AL9Av4C/wMAAwEDAgMDAwQDBQMGAwcDCAMJAwoDCwMMAw0DDgMPAxADEQMSAxMDFAMVAxYDFwMYAxkDGgMbAxwDHQMeAx8DIAMhAyIDIwMkAyUDJgMnAygDKQMqAysDLAMtAy4DLwMwAzEDMgMzAzQDNQM2AzcDOAM5AzoDOwM8Az0DPgM/A0ADQQNCA0MDRANFA0YDRwNIA0kDSgNLA0wDTQNOA08DUANRA1IDUwNUA1UDVgNXA1gDWQNaA1sDXANdA14DXwNgA2EDYgNjA2QDZQNmA2cDaANpA2oDawNsA20DbgNvA3ADcQNyA3MDdAN1A3YDdwN4A3kDegN7A3wDfQN+A38DgAOBA4IDgwOEA4UDhgOHA4gDiQOKA4sDjAONA44DjwOQA5EDkgOTA5QDlQOWA5cDmAOZA5oDmwOcA50DngOfA6ADoQOiA6MDpAOlA6YDpwOoA6kDqgOrA6wAwADBA60DrgOvA7ADsQOyA7MDtAO1A7YDtwO4AJ0AngO5A7oDuwO8A70DvgO/A8ADwQPCA8MDxAPFA8YDxwPIA8kDygPLA8wDzQPOA88D0APRA9ID0wPUA9UD1gPXA9gD2QPaA9sD3APdA94D3wPgA+ED4gPjA+QD5QPmA+cD6APpA+oD6wPsA+0D7gPvA/AD8QPyA/MD9AP1A/YD9wP4A/kD+gP7A/wD/QP+A/8EAAQBBAIEAwQEBAUEBgQHBAgECQQKBAsEDAQNBA4EDwQQBBEEEgQTBBQEFQQWBBcEGAQZBBoEGwQcBB0EHgQfBCAEIQQiBCMEJAQlBCYEJwQoBCkEKgQrBCwELQQuBC8EMAQxBDIEMwQ0BDUENgQ3BDgEOQQ6BDsEPAQ9BD4EPwRABEEEQgRDBEQERQRGBEcESARJBEoESwRMBE0ETgRPBFAEUQRSBFMEVARVBFYEVwRYBFkEWgRbBFwEXQReBF8EYARhBGIEYwRkBGUEZgRnBGgEaQRqBGsEbARtBG4EbwRwBHEEcgRzBHQEdQR2BHcEeAR5BHoEewR8BH0EfgR/BIAEgQSCBIMEhASFBIYEhwSIBIkEigSLBIwEjQSOBI8EkASRBJIEkwSUBJUElgSXBJgEmQSaBJsEnASdBJ4EnwSgBKEEogSjBKQEpQSmBKcEqASpBKoEqwSsBK0ErgSvBLAEsQSyBLMEtAS1BLYEtwS4BLkEugS7BLwEvQS+BL8EwATBBMIEwwTEBMUExgTHBMgEyQTKBMsEzATNBM4EzwTQBNEE0gTTBNQE1QTWBNcE2ATZBNoE2wTcBN0E3gTfBOAE4QTiBOME5ATlBOYE5wToBOkE6gTrBOwE7QTuBO8E8ATxBPIE8wT0BPUE9gT3BPgE+QT6BPsE/AT9BP4E/wUABQEFAgUDBQQFBQUGBQcFCAUJBQoFCwUMBQ0FDgUPBRAFEQUSBRMFFAUVBRYFFwUYBRkFGgUbBRwFHQUeBR8FIAUhBSIFIwUkBSUFJgUnBSgFKQUqBSsFLAUtBS4FLwUwBTEFMgUzBTQFNQU2BTcFOAU5BToFOwU8BT0FPgU/BUAFQQVCBUMFRAVFBUYFRwVIBUkFSgVLBUwFTQVOBU8FUAVRBVIFUwVUBVUFVgVXBVgFWQVaBVsFXAVdBV4FXwVgBWEFYgVjBWQFZQVmBWcFaAVpBWoFawVsBW0FbgVvBXAFcQVyBXMFdAV1BXYFdwV4BXkFegV7BXwFfQV+BX8FgAWBBYIFgwWEBYUFhgWHBYgFiQWKBYsFjAWNBY4FjwWQBZEFkgWTBZQFlQWWBZcFmAWZBZoFmwWcBZ0AmwATABQAFQAWABcAGAAZABoAGwAcBZ4FnwWgBaEAvAD0APUA9gANAD8AwwCHAB0ADwCrAAQAowAGABEAIgCiAAUACgAeABIAQgBeAGAAPgBAAAsADACzALIAEAWiAKkAqgC+AL8AxQC0ALUAtgC3AMQFowWkAIQFpQC9AAcFpgWnAKYA9wWoBakFqgWrBawFrQWuBa8FsAWxBbIAhQWzBbQFtQCWBbYFtwAOAO8A8AC4ACAAjwAhAB8AlQCUAJMApwBhAKQAkgCcAJoAmQClBbgAmAAIAMYAuQAjAAkAiACGAIsAigCMAIMAXwDoAIIAwgW5AEEFugW7BbwFvQW+Bb8FwAXBBcIFwwXEBcUFxgXHBcgFyQXKBcsFzAXNBc4FzwXQBdEF0gXTBdQF1QXWBdcF2AXZBdoF2wXcBd0F3gXfBeAF4QXiBeMF5AXlBeYF5wXoBekF6gXrAI0A2wDhAN4A2ACOANwAQwDfANoA4ADdANkF7AXtBe4F7wXwBfEF8gXzBfQF9QX2BfcF+AX5BfoF+wX8Bf0F/gX/BgAGAQYCBgMGBAYFBE5VTEwGQWJyZXZlB3VuaTFFQUUHdW5pMUVCNgd1bmkxRUIwB3VuaTFFQjIHdW5pMUVCNAd1bmkxRUE0B3VuaTFFQUMHdW5pMUVBNgd1bmkxRUE4B3VuaTFFQUEHdW5pMDIwMAd1bmkxRUEwB3VuaTFFQTIHdW5pMDIwMgdBbWFjcm9uB0FvZ29uZWsKQXJpbmdhY3V0ZQdBRWFjdXRlC0NjaXJjdW1mbGV4CkNkb3RhY2NlbnQHdW5pMDFDNAZEY2Fyb24GRGNyb2F0B3VuaTAxQzUGRWJyZXZlBkVjYXJvbgd1bmkxRUJFB3VuaTFFQzYHdW5pMUVDMAd1bmkxRUMyB3VuaTFFQzQHdW5pMDIwNApFZG90YWNjZW50B3VuaTFFQjgHdW5pMUVCQQd1bmkwMjA2B0VtYWNyb24HRW9nb25lawd1bmkxRUJDBkdjYXJvbgtHY2lyY3VtZmxleAd1bmkwMTIyCkdkb3RhY2NlbnQESGJhcgtIY2lyY3VtZmxleAZJYnJldmUHdW5pMDIwOAd1bmkxRUNBB3VuaTFFQzgHdW5pMDIwQQdJbWFjcm9uB0lvZ29uZWsGSXRpbGRlC0pjaXJjdW1mbGV4B3VuaTAxMzYHdW5pMDFDNwZMYWN1dGUGTGNhcm9uB3VuaTAxM0IETGRvdAd1bmkwMUM4B3VuaTAxQ0EGTmFjdXRlBk5jYXJvbgd1bmkwMTQ1A0VuZwd1bmkwMUNCBk9icmV2ZQd1bmkxRUQwB3VuaTFFRDgHdW5pMUVEMgd1bmkxRUQ0B3VuaTFFRDYHdW5pMDIwQwd1bmkwMjJBB3VuaTAyMzAHdW5pMUVDQwd1bmkxRUNFBU9ob3JuB3VuaTFFREEHdW5pMUVFMgd1bmkxRURDB3VuaTFFREUHdW5pMUVFMA1PaHVuZ2FydW1sYXV0B3VuaTAyMEUHT21hY3Jvbgd1bmkwMUVBC09zbGFzaGFjdXRlB3VuaTAyMkMGUmFjdXRlBlJjYXJvbgd1bmkwMTU2B3VuaTAyMTAHdW5pMDIxMgZTYWN1dGULU2NpcmN1bWZsZXgHdW5pMDIxOAd1bmkxRTlFB3VuaTAxOEYEVGJhcgZUY2Fyb24HdW5pMDE2Mgd1bmkwMjFBBlVicmV2ZQd1bmkwMjE0B3VuaTFFRTQHdW5pMUVFNgVVaG9ybgd1bmkxRUU4B3VuaTFFRjAHdW5pMUVFQQd1bmkxRUVDB3VuaTFFRUUNVWh1bmdhcnVtbGF1dAd1bmkwMjE2B1VtYWNyb24HVW9nb25lawVVcmluZwZVdGlsZGUGV2FjdXRlC1djaXJjdW1mbGV4CVdkaWVyZXNpcwZXZ3JhdmULWWNpcmN1bWZsZXgHdW5pMUVGNAZZZ3JhdmUHdW5pMUVGNgd1bmkwMjMyB3VuaTFFRjgGWmFjdXRlClpkb3RhY2NlbnQQSWFjdXRlX0oubG9jbE5MRAZBLnNzMDELQWFjdXRlLnNzMDELQWJyZXZlLnNzMDEMdW5pMUVBRS5zczAxDHVuaTFFQjYuc3MwMQx1bmkxRUIwLnNzMDEMdW5pMUVCMi5zczAxDHVuaTFFQjQuc3MwMRBBY2lyY3VtZmxleC5zczAxDHVuaTFFQTQuc3MwMQx1bmkxRUFDLnNzMDEMdW5pMUVBNi5zczAxDHVuaTFFQTguc3MwMQx1bmkxRUFBLnNzMDEMdW5pMDIwMC5zczAxDkFkaWVyZXNpcy5zczAxDHVuaTFFQTAuc3MwMQtBZ3JhdmUuc3MwMQx1bmkxRUEyLnNzMDEMdW5pMDIwMi5zczAxDEFtYWNyb24uc3MwMQxBb2dvbmVrLnNzMDEKQXJpbmcuc3MwMQ9BcmluZ2FjdXRlLnNzMDELQXRpbGRlLnNzMDEHQUUuc3MwMQxBRWFjdXRlLnNzMDEGQi5zczAxBkMuc3MwMQtDYWN1dGUuc3MwMQtDY2Fyb24uc3MwMQ1DY2VkaWxsYS5zczAxEENjaXJjdW1mbGV4LnNzMDEPQ2RvdGFjY2VudC5zczAxBkQuc3MwMQx1bmkwMUM0LnNzMDEIRXRoLnNzMDELRGNhcm9uLnNzMDELRGNyb2F0LnNzMDEGRS5zczAxC0VhY3V0ZS5zczAxC0VicmV2ZS5zczAxC0VjYXJvbi5zczAxEEVjaXJjdW1mbGV4LnNzMDEMdW5pMUVCRS5zczAxDHVuaTFFQzYuc3MwMQx1bmkxRUMwLnNzMDEMdW5pMUVDMi5zczAxDHVuaTFFQzQuc3MwMQx1bmkwMjA0LnNzMDEORWRpZXJlc2lzLnNzMDEPRWRvdGFjY2VudC5zczAxDHVuaTFFQjguc3MwMQtFZ3JhdmUuc3MwMQx1bmkxRUJBLnNzMDEMdW5pMDIwNi5zczAxDEVtYWNyb24uc3MwMQxFb2dvbmVrLnNzMDEMdW5pMUVCQy5zczAxBkYuc3MwMQZHLnNzMDELR2JyZXZlLnNzMDELR2Nhcm9uLnNzMDEQR2NpcmN1bWZsZXguc3MwMQx1bmkwMTIyLnNzMDEPR2RvdGFjY2VudC5zczAxBkguc3MwMQlIYmFyLnNzMDEQSGNpcmN1bWZsZXguc3MwMQZJLnNzMDELSWFjdXRlLnNzMDEVSWFjdXRlX0oubG9jbE5MRC5zczAxC0licmV2ZS5zczAxEEljaXJjdW1mbGV4LnNzMDEMdW5pMDIwOC5zczAxDklkaWVyZXNpcy5zczAxD0lkb3RhY2NlbnQuc3MwMQx1bmkxRUNBLnNzMDELSWdyYXZlLnNzMDEMdW5pMUVDOC5zczAxDHVuaTAyMEEuc3MwMQxJbWFjcm9uLnNzMDEMSW9nb25lay5zczAxC0l0aWxkZS5zczAxBkouc3MwMRBKY2lyY3VtZmxleC5zczAxBksuc3MwMQx1bmkwMTM2LnNzMDEGTC5zczAxDHVuaTAxQzcuc3MwMQtMYWN1dGUuc3MwMQtMY2Fyb24uc3MwMQx1bmkwMTNCLnNzMDEJTGRvdC5zczAxDHVuaTAxQzguc3MwMQtMc2xhc2guc3MwMQZNLnNzMDEGTi5zczAxDHVuaTAxQ0Euc3MwMQtOYWN1dGUuc3MwMQtOY2Fyb24uc3MwMQx1bmkwMTQ1LnNzMDEIRW5nLnNzMDEMdW5pMDFDQi5zczAxC050aWxkZS5zczAxB09FLnNzMDEGUC5zczAxClRob3JuLnNzMDEGUS5zczAxBlIuc3MwMQtSYWN1dGUuc3MwMQtSY2Fyb24uc3MwMQx1bmkwMTU2LnNzMDEMdW5pMDIxMC5zczAxDHVuaTAyMTIuc3MwMQZULnNzMDEJVGJhci5zczAxC1RjYXJvbi5zczAxDHVuaTAxNjIuc3MwMQx1bmkwMjFBLnNzMDEGVS5zczAxC1VhY3V0ZS5zczAxC1VicmV2ZS5zczAxEFVjaXJjdW1mbGV4LnNzMDEMdW5pMDIxNC5zczAxDlVkaWVyZXNpcy5zczAxDHVuaTFFRTQuc3MwMQtVZ3JhdmUuc3MwMQx1bmkxRUU2LnNzMDEKVWhvcm4uc3MwMQx1bmkxRUU4LnNzMDEMdW5pMUVGMC5zczAxDHVuaTFFRUEuc3MwMQx1bmkxRUVDLnNzMDEMdW5pMUVFRS5zczAxElVodW5nYXJ1bWxhdXQuc3MwMQx1bmkwMjE2LnNzMDEMVW1hY3Jvbi5zczAxDFVvZ29uZWsuc3MwMQpVcmluZy5zczAxC1V0aWxkZS5zczAxBlYuc3MwMQZXLnNzMDELV2FjdXRlLnNzMDEQV2NpcmN1bWZsZXguc3MwMQ5XZGllcmVzaXMuc3MwMQtXZ3JhdmUuc3MwMQZYLnNzMDEGWS5zczAxC1lhY3V0ZS5zczAxEFljaXJjdW1mbGV4LnNzMDEOWWRpZXJlc2lzLnNzMDEMdW5pMUVGNC5zczAxC1lncmF2ZS5zczAxDHVuaTFFRjYuc3MwMQx1bmkwMjMyLnNzMDEMdW5pMUVGOC5zczAxBlouc3MwMQtaYWN1dGUuc3MwMQtaY2Fyb24uc3MwMQ9aZG90YWNjZW50LnNzMDEGYWJyZXZlB3VuaTFFQUYHdW5pMUVCNwd1bmkxRUIxB3VuaTFFQjMHdW5pMUVCNQd1bmkxRUE1B3VuaTFFQUQHdW5pMUVBNwd1bmkxRUE5B3VuaTFFQUIHdW5pMDIwMQd1bmkxRUExB3VuaTFFQTMHdW5pMDIwMwdhbWFjcm9uB2FvZ29uZWsKYXJpbmdhY3V0ZQdhZWFjdXRlC2NjaXJjdW1mbGV4CmNkb3RhY2NlbnQGZGNhcm9uB3VuaTAxQzYGZWJyZXZlBmVjYXJvbgd1bmkxRUJGB3VuaTFFQzcHdW5pMUVDMQd1bmkxRUMzB3VuaTFFQzUHdW5pMDIwNQplZG90YWNjZW50B3VuaTFFQjkHdW5pMUVCQgd1bmkwMjA3B2VtYWNyb24HZW9nb25lawd1bmkxRUJEB3VuaTAyNTkGZ2Nhcm9uC2djaXJjdW1mbGV4B3VuaTAxMjMKZ2RvdGFjY2VudARoYmFyC2hjaXJjdW1mbGV4BmlicmV2ZQd1bmkwMjA5CWkubG9jbFRSSwd1bmkxRUNCB3VuaTFFQzkHdW5pMDIwQgdpbWFjcm9uB2lvZ29uZWsGaXRpbGRlB3VuaTAyMzcLamNpcmN1bWZsZXgHdW5pMDEzNwxrZ3JlZW5sYW5kaWMGbGFjdXRlBmxjYXJvbgd1bmkwMTNDBGxkb3QHdW5pMDFDOQZuYWN1dGULbmFwb3N0cm9waGUGbmNhcm9uB3VuaTAxNDYDZW5nB3VuaTAxQ0MGb2JyZXZlB3VuaTFFRDEHdW5pMUVEOQd1bmkxRUQzB3VuaTFFRDUHdW5pMUVENwd1bmkwMjBEB3VuaTAyMkIHdW5pMDIzMQd1bmkxRUNEB3VuaTFFQ0YFb2hvcm4HdW5pMUVEQgd1bmkxRUUzB3VuaTFFREQHdW5pMUVERgd1bmkxRUUxDW9odW5nYXJ1bWxhdXQHdW5pMDIwRgdvbWFjcm9uB3VuaTAxRUILb3NsYXNoYWN1dGUHdW5pMDIyRAZyYWN1dGUGcmNhcm9uB3VuaTAxNTcHdW5pMDIxMQd1bmkwMjEzBnNhY3V0ZQtzY2lyY3VtZmxleAd1bmkwMjE5BHRiYXIGdGNhcm9uB3VuaTAxNjMHdW5pMDIxQgZ1YnJldmUHdW5pMDIxNQd1bmkxRUU1B3VuaTFFRTcFdWhvcm4HdW5pMUVFOQd1bmkxRUYxB3VuaTFFRUIHdW5pMUVFRAd1bmkxRUVGDXVodW5nYXJ1bWxhdXQHdW5pMDIxNwd1bWFjcm9uB3VvZ29uZWsFdXJpbmcGdXRpbGRlBndhY3V0ZQt3Y2lyY3VtZmxleAl3ZGllcmVzaXMGd2dyYXZlC3ljaXJjdW1mbGV4B3VuaTFFRjUGeWdyYXZlB3VuaTFFRjcHdW5pMDIzMwd1bmkxRUY5BnphY3V0ZQp6ZG90YWNjZW50BmEuZmluYQthYWN1dGUuZmluYQthYnJldmUuZmluYQx1bmkxRUFGLmZpbmEMdW5pMUVCNy5maW5hDHVuaTFFQjEuZmluYQx1bmkxRUIzLmZpbmEMdW5pMUVCNS5maW5hEGFjaXJjdW1mbGV4LmZpbmEMdW5pMUVBNS5maW5hDHVuaTFFQUQuZmluYQx1bmkxRUE3LmZpbmEMdW5pMUVBOS5maW5hDHVuaTFFQUIuZmluYQx1bmkwMjAxLmZpbmEOYWRpZXJlc2lzLmZpbmEMdW5pMUVBMS5maW5hC2FncmF2ZS5maW5hDHVuaTFFQTMuZmluYQx1bmkwMjAzLmZpbmEMYW1hY3Jvbi5maW5hDGFvZ29uZWsuZmluYQphcmluZy5maW5hD2FyaW5nYWN1dGUuZmluYQthdGlsZGUuZmluYQdhZS5maW5hDGFlYWN1dGUuZmluYQZiLmZpbmEGYy5maW5hC2NhY3V0ZS5maW5hC2NjYXJvbi5maW5hDWNjZWRpbGxhLmZpbmEQY2NpcmN1bWZsZXguZmluYQ9jZG90YWNjZW50LmZpbmEGZC5maW5hC2RjYXJvbi5maW5hC2Rjcm9hdC5maW5hDHVuaTAxQzYuZmluYQZlLmZpbmELZWFjdXRlLmZpbmELZWJyZXZlLmZpbmELZWNhcm9uLmZpbmEQZWNpcmN1bWZsZXguZmluYQx1bmkxRUJGLmZpbmEMdW5pMUVDNy5maW5hDHVuaTFFQzEuZmluYQx1bmkxRUMzLmZpbmEMdW5pMUVDNS5maW5hDHVuaTAyMDUuZmluYQ5lZGllcmVzaXMuZmluYQ9lZG90YWNjZW50LmZpbmEMdW5pMUVCOS5maW5hC2VncmF2ZS5maW5hDHVuaTFFQkIuZmluYQx1bmkwMjA3LmZpbmEMZW1hY3Jvbi5maW5hDGVvZ29uZWsuZmluYQx1bmkxRUJELmZpbmEGZy5maW5hC2dicmV2ZS5maW5hC2djYXJvbi5maW5hEGdjaXJjdW1mbGV4LmZpbmEMdW5pMDEyMy5maW5hD2dkb3RhY2NlbnQuZmluYQZoLmZpbmEJaGJhci5maW5hEGhjaXJjdW1mbGV4LmZpbmEGaS5maW5hDWRvdGxlc3NpLmZpbmELaWFjdXRlLmZpbmEVaWFjdXRlX2oubG9jbE5MRC5maW5hC2licmV2ZS5maW5hEGljaXJjdW1mbGV4LmZpbmEMdW5pMDIwOS5maW5hDmlkaWVyZXNpcy5maW5hDmkubG9jbFRSSy5maW5hDHVuaTFFQ0IuZmluYQtpZ3JhdmUuZmluYQx1bmkxRUM5LmZpbmEMdW5pMDIwQi5maW5hDGltYWNyb24uZmluYQxpb2dvbmVrLmZpbmELaXRpbGRlLmZpbmEGai5maW5hDHVuaTAyMzcuZmluYRBqY2lyY3VtZmxleC5maW5hBmsuZmluYQx1bmkwMTM3LmZpbmERa2dyZWVubGFuZGljLmZpbmEGbC5maW5hC2xhY3V0ZS5maW5hC2xjYXJvbi5maW5hDHVuaTAxM0MuZmluYQlsZG90LmZpbmEMdW5pMDFDOS5maW5hC2xzbGFzaC5maW5hBm0uZmluYQZuLmZpbmELbmFjdXRlLmZpbmEQbmFwb3N0cm9waGUuZmluYQtuY2Fyb24uZmluYQx1bmkwMTQ2LmZpbmEIZW5nLmZpbmEMdW5pMDFDQy5maW5hC250aWxkZS5maW5hBm8uZmluYQtvYWN1dGUuZmluYQtvYnJldmUuZmluYRBvY2lyY3VtZmxleC5maW5hDHVuaTFFRDEuZmluYQx1bmkxRUQ5LmZpbmEMdW5pMUVEMy5maW5hDHVuaTFFRDUuZmluYQx1bmkxRUQ3LmZpbmEMdW5pMDIwRC5maW5hDm9kaWVyZXNpcy5maW5hDHVuaTAyMkIuZmluYQx1bmkwMjMxLmZpbmEMdW5pMUVDRC5maW5hC29ncmF2ZS5maW5hDHVuaTFFQ0YuZmluYQpvaG9ybi5maW5hDHVuaTFFREIuZmluYQx1bmkxRUUzLmZpbmEMdW5pMUVERC5maW5hDHVuaTFFREYuZmluYQx1bmkxRUUxLmZpbmESb2h1bmdhcnVtbGF1dC5maW5hDHVuaTAyMEYuZmluYQxvbWFjcm9uLmZpbmEMdW5pMDFFQi5maW5hC29zbGFzaC5maW5hEG9zbGFzaGFjdXRlLmZpbmELb3RpbGRlLmZpbmEMdW5pMDIyRC5maW5hB29lLmZpbmEGcC5maW5hCnRob3JuLmZpbmEGcS5maW5hBnIuZmluYQtyYWN1dGUuZmluYQtyY2Fyb24uZmluYQx1bmkwMTU3LmZpbmEMdW5pMDIxMS5maW5hDHVuaTAyMTMuZmluYQZzLmZpbmELc2FjdXRlLmZpbmELc2Nhcm9uLmZpbmENc2NlZGlsbGEuZmluYRBzY2lyY3VtZmxleC5maW5hDHVuaTAyMTkuZmluYQ9nZXJtYW5kYmxzLmZpbmERdW5pMDFDOS5zczAxLmZpbmENZW5nLnNzMDEuZmluYQtwLnNzMDEuZmluYQt6LnNzMDEuZmluYRB6YWN1dGUuc3MwMS5maW5hEHpjYXJvbi5zczAxLmZpbmEUemRvdGFjY2VudC5zczAxLmZpbmEGdC5maW5hCXRiYXIuZmluYQt0Y2Fyb24uZmluYQx1bmkwMTYzLmZpbmEMdW5pMDIxQi5maW5hBnUuZmluYQt1YWN1dGUuZmluYQt1YnJldmUuZmluYRB1Y2lyY3VtZmxleC5maW5hDHVuaTAyMTUuZmluYQ51ZGllcmVzaXMuZmluYQx1bmkxRUU1LmZpbmELdWdyYXZlLmZpbmEMdW5pMUVFNy5maW5hCnVob3JuLmZpbmEMdW5pMUVFOS5maW5hDHVuaTFFRjEuZmluYQx1bmkxRUVCLmZpbmEMdW5pMUVFRC5maW5hDHVuaTFFRUYuZmluYRJ1aHVuZ2FydW1sYXV0LmZpbmEMdW5pMDIxNy5maW5hDHVtYWNyb24uZmluYQx1b2dvbmVrLmZpbmEKdXJpbmcuZmluYQt1dGlsZGUuZmluYQZ2LmZpbmEGdy5maW5hC3dhY3V0ZS5maW5hEHdjaXJjdW1mbGV4LmZpbmEOd2RpZXJlc2lzLmZpbmELd2dyYXZlLmZpbmEGeC5maW5hBnkuZmluYQt5YWN1dGUuZmluYRB5Y2lyY3VtZmxleC5maW5hDnlkaWVyZXNpcy5maW5hDHVuaTFFRjUuZmluYQt5Z3JhdmUuZmluYQx1bmkxRUY3LmZpbmEMdW5pMDIzMy5maW5hDHVuaTFFRjkuZmluYQZ6LmZpbmELemFjdXRlLmZpbmELemNhcm9uLmZpbmEPemRvdGFjY2VudC5maW5hEGlhY3V0ZV9qLmxvY2xOTEQGYi5zczAxBmQuc3MwMQZmLnNzMDEGbC5zczAxC2xhY3V0ZS5zczAxDHVuaTAxM0Muc3MwMQx1bmkwMUM5LnNzMDELbHNsYXNoLnNzMDEIZW5nLnNzMDEGby5zczAxC29hY3V0ZS5zczAxC29icmV2ZS5zczAxEG9jaXJjdW1mbGV4LnNzMDEMdW5pMUVEMS5zczAxDHVuaTFFRDkuc3MwMQx1bmkxRUQzLnNzMDEMdW5pMUVENS5zczAxDHVuaTFFRDcuc3MwMQx1bmkwMjBELnNzMDEOb2RpZXJlc2lzLnNzMDEMdW5pMDIyQi5zczAxDHVuaTAyMzEuc3MwMQx1bmkxRUNELnNzMDELb2dyYXZlLnNzMDEMdW5pMUVDRi5zczAxCm9ob3JuLnNzMDEMdW5pMUVEQi5zczAxDHVuaTFFRTMuc3MwMQx1bmkxRURELnNzMDEMdW5pMUVERi5zczAxDHVuaTFFRTEuc3MwMRJvaHVuZ2FydW1sYXV0LnNzMDEMdW5pMDIwRi5zczAxDG9tYWNyb24uc3MwMQx1bmkwMUVCLnNzMDELb3NsYXNoLnNzMDEQb3NsYXNoYWN1dGUuc3MwMQtvdGlsZGUuc3MwMQx1bmkwMjJELnNzMDEGcC5zczAxBnQuc3MwMQx1bmkwMTYzLnNzMDEMdW5pMDIxQi5zczAxBnouc3MwMQt6YWN1dGUuc3MwMQt6Y2Fyb24uc3MwMQ96ZG90YWNjZW50LnNzMDEDZl9mA2Zfag1sc2xhc2hfbHNsYXNoA3RfdAhmX2ouZmluYQdmaS5maW5hB2ZsLmZpbmERZl9pai5sb2NsTkxELmZpbmEQaV9qLmxvY2xOTEQuZmluYQ10X3Quc3MwMS5maW5hC0lfSi5sb2NsTkxEDGZfaWoubG9jbE5MRAtpX2oubG9jbE5MRAh0X3Quc3MwMQd1bmkwNDEwB3VuaTA0MTEHdW5pMDQxMgd1bmkwNDEzB3VuaTA0MDMHdW5pMDQ5MAd1bmkwNDE0B3VuaTA0MTUHdW5pMDQwMAd1bmkwNDAxB3VuaTA0MTYHdW5pMDQxNwd1bmkwNDE4B3VuaTA0MTkHdW5pMDQwRAd1bmkwNDhBB3VuaTA0MUEHdW5pMDQwQwd1bmkwNDFCB3VuaTA0MUMHdW5pMDQxRAd1bmkwNDFFB3VuaTA0MUYHdW5pMDQyMAd1bmkwNDIxB3VuaTA0MjIHdW5pMDQyMwd1bmkwNDBFB3VuaTA0MjQHdW5pMDQyNQd1bmkwNDI3B3VuaTA0MjYHdW5pMDQyOAd1bmkwNDI5B3VuaTA0MEYHdW5pMDQyQwd1bmkwNDJBB3VuaTA0MkIHdW5pMDQwOQd1bmkwNDBBB3VuaTA0MDUHdW5pMDQwNAd1bmkwNDJEB3VuaTA0MDYHdW5pMDQwNwd1bmkwNDA4B3VuaTA0MEIHdW5pMDQyRQd1bmkwNDJGB3VuaTA0MDIHdW5pMDQ2Mgd1bmkwNDZBB3VuaTA0NzIHdW5pMDQ3NAd1bmkwNDkyB3VuaTA0OTQHdW5pMDQ5Ngd1bmkwNDk4B3VuaTA0OUEHdW5pMDQ5Qwd1bmkwNDlFB3VuaTA0QTAHdW5pMDRBMgd1bmkwNEE0B3VuaTA1MjQHdW5pMDRBOAd1bmkwNEFBB3VuaTA0QUMHdW5pMDRBRQd1bmkwNEIwB3VuaTA0QjIHdW5pMDRCNAd1bmkwNEI2B3VuaTA0QjgHdW5pMDRCQQd1bmkwNTI2B3VuaTA0QkMHdW5pMDRCRQd1bmkwNEMwB3VuaTA0QzEHdW5pMDRDMwd1bmkwNEM1B3VuaTA0QzcHdW5pMDRDOQd1bmkwNENCB3VuaTA0Q0QHdW5pMDREMAd1bmkwNEQyB3VuaTA0RDQHdW5pMDRENgd1bmkwNEQ4B3VuaTA0REEHdW5pMDREQwd1bmkwNERFB3VuaTA0RTAHdW5pMDRFMgd1bmkwNEU0B3VuaTA0RTYHdW5pMDRFOAd1bmkwNEVBB3VuaTA0RUMHdW5pMDRFRQd1bmkwNEYwB3VuaTA0RjIHdW5pMDRGNAd1bmkwNEY2B3VuaTA0RjgHdW5pMDRGQQd1bmkwNEZDB3VuaTA0RkUHdW5pMDUxMAd1bmkwNTEyB3VuaTA1MUEHdW5pMDUxQwd1bmkwNDhDB3VuaTA0OEUHdW5pMDUyOAd1bmkwNTJFDHVuaTA0MTAuc3MwMQx1bmkwNDExLnNzMDEMdW5pMDQxMi5zczAxDHVuaTA0MTMuc3MwMQx1bmkwNDAzLnNzMDEMdW5pMDQ5MC5zczAxDHVuaTA0MTQuc3MwMQx1bmkwNDE1LnNzMDEMdW5pMDQwMC5zczAxDHVuaTA0MDEuc3MwMQx1bmkwNDE2LnNzMDEMdW5pMDQxNy5zczAxDHVuaTA0MTguc3MwMQx1bmkwNDE5LnNzMDEMdW5pMDQwRC5zczAxDHVuaTA0OEEuc3MwMQx1bmkwNDFBLnNzMDEMdW5pMDQwQy5zczAxDHVuaTA0MUIuc3MwMQx1bmkwNDFDLnNzMDEMdW5pMDQxRC5zczAxDHVuaTA0MUUuc3MwMQx1bmkwNDFGLnNzMDEMdW5pMDQyMC5zczAxDHVuaTA0MjEuc3MwMQx1bmkwNDIyLnNzMDEMdW5pMDQyMy5zczAxDHVuaTA0MEUuc3MwMQx1bmkwNDI0LnNzMDEMdW5pMDQyNS5zczAxDHVuaTA0Mjcuc3MwMQx1bmkwNDI2LnNzMDEMdW5pMDQyOC5zczAxDHVuaTA0Mjkuc3MwMQx1bmkwNDBGLnNzMDEMdW5pMDQyQy5zczAxDHVuaTA0MkEuc3MwMQx1bmkwNDJCLnNzMDEMdW5pMDQwOS5zczAxDHVuaTA0MEEuc3MwMQx1bmkwNDA1LnNzMDEMdW5pMDQwNC5zczAxDHVuaTA0MkQuc3MwMQx1bmkwNDA2LnNzMDEMdW5pMDQwNy5zczAxDHVuaTA0MDguc3MwMQx1bmkwNDBCLnNzMDEMdW5pMDQyRS5zczAxDHVuaTA0MkYuc3MwMQx1bmkwNDAyLnNzMDEMdW5pMDQ2Mi5zczAxDHVuaTA0NkEuc3MwMQx1bmkwNDcyLnNzMDEMdW5pMDQ3NC5zczAxDHVuaTA0OTIuc3MwMQx1bmkwNDk0LnNzMDEMdW5pMDQ5Ni5zczAxDHVuaTA0OTguc3MwMQx1bmkwNDlBLnNzMDEMdW5pMDQ5Qy5zczAxDHVuaTA0OUUuc3MwMQx1bmkwNEEwLnNzMDEMdW5pMDRBMi5zczAxDHVuaTA0QTQuc3MwMQx1bmkwNTI0LnNzMDEMdW5pMDRBOC5zczAxDHVuaTA0QUEuc3MwMQx1bmkwNEFDLnNzMDEMdW5pMDRBRS5zczAxDHVuaTA0QjAuc3MwMQx1bmkwNEIyLnNzMDEMdW5pMDRCNC5zczAxDHVuaTA0QjYuc3MwMQx1bmkwNEI4LnNzMDEMdW5pMDRCQS5zczAxDHVuaTA1MjYuc3MwMQx1bmkwNTI4LnNzMDEMdW5pMDUyRS5zczAxDHVuaTA0QkMuc3MwMQx1bmkwNEJFLnNzMDEMdW5pMDRDMC5zczAxDHVuaTA0QzEuc3MwMQx1bmkwNEMzLnNzMDEMdW5pMDRDNS5zczAxDHVuaTA0Qzcuc3MwMQx1bmkwNEM5LnNzMDEMdW5pMDRDQi5zczAxDHVuaTA0Q0Quc3MwMQx1bmkwNEQwLnNzMDEMdW5pMDREMi5zczAxDHVuaTA0RDQuc3MwMQx1bmkwNEQ2LnNzMDEMdW5pMDREOC5zczAxDHVuaTA0REEuc3MwMQx1bmkwNERDLnNzMDEMdW5pMDRERS5zczAxDHVuaTA0RTAuc3MwMQx1bmkwNEUyLnNzMDEMdW5pMDRFNC5zczAxDHVuaTA0RTYuc3MwMQx1bmkwNEU4LnNzMDEMdW5pMDRFQS5zczAxDHVuaTA0RUMuc3MwMQx1bmkwNEVFLnNzMDEMdW5pMDRGMC5zczAxDHVuaTA0RjIuc3MwMQx1bmkwNEY0LnNzMDEMdW5pMDRGNi5zczAxDHVuaTA0Rjguc3MwMQx1bmkwNEZBLnNzMDEMdW5pMDRGQy5zczAxDHVuaTA0RkUuc3MwMQx1bmkwNTEwLnNzMDEMdW5pMDUxMi5zczAxDHVuaTA1MUEuc3MwMQx1bmkwNTFDLnNzMDEMdW5pMDQ4Qy5zczAxDHVuaTA0OEUuc3MwMQd1bmkwNDMwB3VuaTA0MzEHdW5pMDQzMgd1bmkwNDMzB3VuaTA0NTMHdW5pMDQ5MQd1bmkwNDM0B3VuaTA0MzUHdW5pMDQ1MAd1bmkwNDUxB3VuaTA0MzYHdW5pMDQzNwd1bmkwNDM4B3VuaTA0MzkHdW5pMDQ1RAd1bmkwNDhCB3VuaTA0M0EHdW5pMDQ1Qwd1bmkwNDNCB3VuaTA0M0MHdW5pMDQzRAd1bmkwNDNFB3VuaTA0M0YHdW5pMDQ0MAd1bmkwNDQxB3VuaTA0NDIHdW5pMDQ0Mwd1bmkwNDVFB3VuaTA0NDQHdW5pMDQ0NQd1bmkwNDQ3B3VuaTA0NDYHdW5pMDQ0OAd1bmkwNDQ5B3VuaTA0NUYHdW5pMDQ0Qwd1bmkwNDRBB3VuaTA0NEIHdW5pMDQ1OQd1bmkwNDVBB3VuaTA0NTUHdW5pMDQ1NAd1bmkwNDREB3VuaTA0NTYHdW5pMDQ1Nwd1bmkwNDU4B3VuaTA0NUIHdW5pMDQ0RQd1bmkwNDRGB3VuaTA0NTIHdW5pMDQ2Mwd1bmkwNDZCB3VuaTA0NzMHdW5pMDQ3NQd1bmkwNDkzB3VuaTA0OTUHdW5pMDQ5Nwd1bmkwNDk5B3VuaTA0OUIHdW5pMDQ5RAd1bmkwNDlGB3VuaTA0QTEHdW5pMDRBMwd1bmkwNEE1B3VuaTA1MjUHdW5pMDRBOQd1bmkwNEFCB3VuaTA0QUQHdW5pMDRBRgd1bmkwNEIxB3VuaTA0QjMHdW5pMDRCNQd1bmkwNEI3B3VuaTA0QjkHdW5pMDUyNwd1bmkwNEJCB3VuaTA0QkQHdW5pMDRCRgd1bmkwNENGB3VuaTA0QzIHdW5pMDRDNAd1bmkwNEM2B3VuaTA0QzgHdW5pMDRDQQd1bmkwNENDB3VuaTA0Q0UHdW5pMDREMQd1bmkwNEQzB3VuaTA0RDUHdW5pMDRENwd1bmkwNEQ5B3VuaTA0REIHdW5pMDRERAd1bmkwNERGB3VuaTA0RTEHdW5pMDRFMwd1bmkwNEU1B3VuaTA0RTcHdW5pMDRFOQd1bmkwNEVCB3VuaTA0RUQHdW5pMDRFRgd1bmkwNEYxB3VuaTA0RjMHdW5pMDRGNQd1bmkwNEY3B3VuaTA0RjkHdW5pMDRGQgd1bmkwNEZEB3VuaTA0RkYHdW5pMDUxMQd1bmkwNTEzB3VuaTA1MUIHdW5pMDUxRAd1bmkwNDhEB3VuaTA0OEYHdW5pMDUyOQd1bmkwNTJGDHVuaTA0MzAuZmluYQx1bmkwNDMxLmZpbmEMdW5pMDQzMi5maW5hDHVuaTA0MzMuZmluYQx1bmkwNDUzLmZpbmEMdW5pMDQ5MS5maW5hDHVuaTA0MzQuZmluYQx1bmkwNDM1LmZpbmEMdW5pMDQ1MC5maW5hDHVuaTA0NTEuZmluYQx1bmkwNDM2LmZpbmEMdW5pMDQzNy5maW5hDHVuaTA0MzguZmluYQx1bmkwNDM5LmZpbmEMdW5pMDQ1RC5maW5hDHVuaTA0OEIuZmluYQx1bmkwNDNBLmZpbmEMdW5pMDQ1Qy5maW5hDHVuaTA0M0IuZmluYQx1bmkwNDNDLmZpbmEMdW5pMDQzRC5maW5hDHVuaTA0M0UuZmluYQx1bmkwNDNGLmZpbmEMdW5pMDQ0MC5maW5hDHVuaTA0NDEuZmluYQx1bmkwNDQyLmZpbmEMdW5pMDQ0My5maW5hDHVuaTA0NUUuZmluYQx1bmkwNDQ0LmZpbmEMdW5pMDQ0NS5maW5hDHVuaTA0NDcuZmluYQx1bmkwNDQ2LmZpbmEMdW5pMDQ0OC5maW5hDHVuaTA0NDkuZmluYQx1bmkwNDVGLmZpbmEMdW5pMDQ0Qy5maW5hDHVuaTA0NEEuZmluYQx1bmkwNDRCLmZpbmEMdW5pMDQ1OS5maW5hDHVuaTA0NUEuZmluYQx1bmkwNDU1LmZpbmEMdW5pMDQ1NC5maW5hDHVuaTA0NEQuZmluYQx1bmkwNDU2LmZpbmEMdW5pMDQ1Ny5maW5hDHVuaTA0NTguZmluYQx1bmkwNDVCLmZpbmEMdW5pMDQ0RS5maW5hDHVuaTA0NEYuZmluYQx1bmkwNDUyLmZpbmEMdW5pMDQ2My5maW5hDHVuaTA0NkIuZmluYQx1bmkwNDczLmZpbmEMdW5pMDQ3NS5maW5hDHVuaTA0OTMuZmluYQx1bmkwNDk1LmZpbmEMdW5pMDQ5Ny5maW5hDHVuaTA0OTkuZmluYQx1bmkwNDlCLmZpbmEMdW5pMDQ5RC5maW5hDHVuaTA0OUYuZmluYQx1bmkwNEExLmZpbmEMdW5pMDRBMy5maW5hDHVuaTA0QTUuZmluYQx1bmkwNTI1LmZpbmEMdW5pMDRBOS5maW5hDHVuaTA0QUIuZmluYQx1bmkwNEFELmZpbmEMdW5pMDRBRi5maW5hDHVuaTA0QjEuZmluYQx1bmkwNEIzLmZpbmEMdW5pMDRCNS5maW5hDHVuaTA0QjcuZmluYQx1bmkwNEI5LmZpbmEMdW5pMDUyNy5maW5hDHVuaTA0QkIuZmluYQx1bmkwNTI5LmZpbmEMdW5pMDUyRi5maW5hDHVuaTA0QkQuZmluYQx1bmkwNEJGLmZpbmEMdW5pMDRDRi5maW5hDHVuaTA0QzIuZmluYQx1bmkwNEM0LmZpbmEMdW5pMDRDNi5maW5hDHVuaTA0QzguZmluYQx1bmkwNENBLmZpbmEMdW5pMDRDQy5maW5hDHVuaTA0Q0UuZmluYQx1bmkwNEQxLmZpbmEMdW5pMDREMy5maW5hDHVuaTA0RDUuZmluYQx1bmkwNEQ3LmZpbmEMdW5pMDREOS5maW5hDHVuaTA0REIuZmluYQx1bmkwNERELmZpbmEMdW5pMDRERi5maW5hDHVuaTA0RTEuZmluYQx1bmkwNEUzLmZpbmEMdW5pMDRFNS5maW5hDHVuaTA0RTcuZmluYQx1bmkwNEU5LmZpbmEMdW5pMDRFQi5maW5hDHVuaTA0RUQuZmluYQx1bmkwNEVGLmZpbmEMdW5pMDRGMS5maW5hDHVuaTA0RjMuZmluYQx1bmkwNEY1LmZpbmEMdW5pMDRGNy5maW5hDHVuaTA0RjkuZmluYQx1bmkwNEZCLmZpbmEMdW5pMDRGRC5maW5hDHVuaTA0RkYuZmluYQx1bmkwNTExLmZpbmEMdW5pMDUxMy5maW5hDHVuaTA1MUIuZmluYQx1bmkwNTFELmZpbmEMdW5pMDQ4RC5maW5hDHVuaTA0OEYuZmluYRF1bmkwNDQ3LnNzMDMuZmluYQx1bmkwNDQ3LnNzMDMMdW5pMDQzRi5zczA0DHVuaTA0NDIuc3MwNBF1bmkwNDNGLmZpbmEuc3MwNBF1bmkwNDQyLmZpbmEuc3MwNAx1bmkwNDM2LnNzMDUMdW5pMDQzQS5zczA1EXVuaTA0MzYuZmluYS5zczA1EXVuaTA0M0EuZmluYS5zczA1B3VuaTAzOTQHdW5pMDNBOQd1bmkwM0JDB3VuaTAwQjkHdW5pMDBCMgd1bmkwMEIzB3VuaTIwNzQHdW5pMDBBRAd1bmkwMEEwB3VuaTIwQjUNY29sb25tb25ldGFyeQRkb25nBEV1cm8HdW5pMjBCMgd1bmkyMEI0B3VuaTIwQUQEbGlyYQd1bmkyMEJBB3VuaTIwQkMHdW5pMjBBNgZwZXNldGEHdW5pMjBCMQd1bmkyMEJEB3VuaTIwQjkHdW5pMjBCOAd1bmkyMEFFB3VuaTIwQTkHdW5pMjIxOQd1bmkyMjE1B3VuaTAwQjUHdW5pMjExNgd1bmkwMzA4B3VuaTAzMDcJZ3JhdmVjb21iCWFjdXRlY29tYgd1bmkwMzBCC3VuaTAzMEMuYWx0B3VuaTAzMDIHdW5pMDMwQwd1bmkwMzA2B3VuaTAzMEEJdGlsZGVjb21iB3VuaTAzMDQNaG9va2Fib3ZlY29tYgd1bmkwMzBGB3VuaTAzMTEHdW5pMDMxMgd1bmkwMzFCDGRvdGJlbG93Y29tYgd1bmkwMzI0B3VuaTAzMjYHdW5pMDMyNwd1bmkwMzI4B3VuaTAzMkUHdW5pMDMzMQt1bmkwMzI2LmFsdAx1bmkwMzA4LmNhc2UMdW5pMDMwNy5jYXNlDmdyYXZlY29tYi5jYXNlDmFjdXRlY29tYi5jYXNlDHVuaTAzMEIuY2FzZQx1bmkwMzAyLmNhc2UMdW5pMDMwQy5jYXNlDHVuaTAzMDYuY2FzZQx1bmkwMzBBLmNhc2UOdGlsZGVjb21iLmNhc2UMdW5pMDMwNC5jYXNlEmhvb2thYm92ZWNvbWIuY2FzZQx1bmkwMzBGLmNhc2UMdW5pMDMxMS5jYXNlDHVuaTAzMTIuY2FzZQx1bmkwMzFCLmNhc2URZG90YmVsb3djb21iLmNhc2UMdW5pMDMyNC5jYXNlDHVuaTAzMjYuY2FzZQx1bmkwMzI3LmNhc2UMdW5pMDMyOC5jYXNlDHVuaTAzMkUuY2FzZQx1bmkwMzMxLmNhc2UHdW5pMDJCQwd1bmkwMkM5C2JyZXZlY29tYmN5EGJyZXZlY29tYmN5LmNhc2ULdW5pMDMwNjAzMDELdW5pMDMwNjAzMDALdW5pMDMwNjAzMDkLdW5pMDMwNjAzMDMLdW5pMDMwMjAzMDELdW5pMDMwMjAzMDALdW5pMDMwMjAzMDkLdW5pMDMwMjAzMDMQdW5pMDMwNjAzMDEuY2FzZRB1bmkwMzA2MDMwMC5jYXNlEHVuaTAzMDYwMzA5LmNhc2UQdW5pMDMwNjAzMDMuY2FzZRB1bmkwMzAyMDMwMS5jYXNlEHVuaTAzMDIwMzAwLmNhc2UQdW5pMDMwMjAzMDkuY2FzZRB1bmkwMzAyMDMwMy5jYXNlD3RhaWxjb21iY3kuY2FzZRRkZXNjZW5kZXJjb21iY3kuY2FzZQ9ob29rY29tYmN5LmNhc2UKdGFpbGNvbWJjeQ9kZXNjZW5kZXJjb21iY3kKaG9va2NvbWJjeRR0YWlsY29tYmN5LmNhc2Uuc3MwMQ90YWlsY29tYmN5LmZpbmEAAAEAAf//AA8AAQAAAAwAAAAAA74AAgCdAAQAHgABACAAJwABACkAKQABACsAPwABAEEARwABAEkAXAABAF4AYgABAGQAaQABAGsAiwABAI8AmgABAJwAtgABALgAvAABAL8A5gABAOgA7wABAPEA8QABAPMBBgABAQgBDgABARABKgABASwBMQABATMBNQABATkBWAABAVoBXgABAWABgQABAYMBhwABAYkBjwABAZEBkQABAZMBpQABAacBpwABAaoBsAABAbIBvwABAcEBwQABAcMBywABAc0BzQABAc8B1AABAdYB8AABAfIB9gABAfoCBQABAgcCBwABAgkCHQABAh8CIAABAiICJgABAigCSQABAksCTwABAlECWAABAloCbAABAm4CdQABAncChwABAokCkQABApMCkwABApUCmgABApwCtgABArgCvAABAsACywABAs0CzQABAtAC1AABAtYC6gABAuwC7QABAu8C8wABAvUDAgABAwQDBAABAwYDCQABAwwDJAABAyYDKQABAysDMQABAzIDQQACA0QDRAABA0cDSAABA0oDVgABA1gDWgABA1wDXwABA2IDYgABA2YDZgABA2kDaQABA2wDcQABA3cDeAABA3oDegABA30DfQABA38DgQABA4MDhAABA4YDhwABA40DjQABA5ADkwABA5UDlQABA5cDmAABA5oDoQABA6MDrwABA7MDswABA7UDtQABA7gDugABA70DvgABA8ADywABA84DzwABA9ID1QABA9gD2AABA9wD3AABA98D3wABA+ID5wABA+4D7gABA/AD8QABA/MD8wABA/UD9wABA/kD+QABA/wD/QABBAMEAwABBAgECwABBA8EEAABBBIEGQABBBsEJgABBC0ELQABBDAEMAABBDMENAABBDYEQQABBEUERgABBEgESwABBE4ETgABBFIEUgABBFUEVQABBFgEWAABBFoEXAABBF8EXwABBGYEZgABBGkEaQABBHIEcgABBHsEfQABBH8EfwABBIQEhAABBIYEjQABBI8EmAABBJoEmgABBKEEoQABBKYEpgABBKkEqgABBKwEtwABBLsEvAABBL4EwQABBMQExAABBMgEyAABBMsEywABBM4EzgABBNEE0gABBNoE2gABBNwE3AABBO8E7wABBPEE8QABBPQE9QABBPcE9wABBPwE/AABBP4FAQABBQMFBQABBQcFEAABBRIFEgABBRkFGQABBR4FHgABBSAFIAABBaIFogABBaQF0wADBeMF9AADAAIACwWkBagAAgWpBakAAwWqBbMAAgW0BbQAAwW1BbgAAQW6BbsAAQW8BcsAAgXMBcwAAwXNBdAAAQXSBdMAAQXjBfQAAgABAAAACgDaAwIAAkRGTFQADmxhdG4AHgAEAAAAAP//AAMAAAALABYAOgAJQVpFIABGQ0FUIABSQ1JUIABeS0FaIABqTU9MIAB2TkxEIACCUk9NIACOVEFUIACaVFJLIACmAAD//wADAAEADAAXAAD//wADAAIADQAYAAD//wADAAMADgAZAAD//wADAAQADwAaAAD//wADAAUAEAAbAAD//wADAAYAEQAcAAD//wADAAcAEgAdAAD//wADAAgAEwAeAAD//wADAAkAFAAfAAD//wADAAoAFQAgACFrZXJuAMhrZXJuANBrZXJuANhrZXJuAOBrZXJuAOhrZXJuAPBrZXJuAPhrZXJuAQBrZXJuAQhrZXJuARBrZXJuARhtYXJrASBtYXJrASptYXJrATRtYXJrAT5tYXJrAUhtYXJrAVJtYXJrAVxtYXJrAWZtYXJrAXBtYXJrAXptYXJrAYRta21rAY5ta21rAZxta21rAapta21rAbhta21rAcZta21rAdRta21rAeJta21rAfBta21rAf5ta21rAgxta21rAhoAAAACAAAAAQAAAAIAAAABAAAAAgAAAAEAAAACAAAAAQAAAAIAAAABAAAAAgAAAAEAAAACAAAAAQAAAAIAAAABAAAAAgAAAAEAAAACAAAAAQAAAAIAAAABAAAAAwACAAMABAAAAAMAAgADAAQAAAADAAIAAwAEAAAAAwACAAMABAAAAAMAAgADAAQAAAADAAIAAwAEAAAAAwACAAMABAAAAAMAAgADAAQAAAADAAIAAwAEAAAAAwACAAMABAAAAAMAAgADAAQAAAAFAAUABgAHAAgACQAAAAUABQAGAAcACAAJAAAABQAFAAYABwAIAAkAAAAFAAUABgAHAAgACQAAAAUABQAGAAcACAAJAAAABQAFAAYABwAIAAkAAAAFAAUABgAHAAgACQAAAAUABQAGAAcACAAJAAAABQAFAAYABwAIAAkAAAAFAAUABgAHAAgACQAAAAUABQAGAAcACAAJAAoAFgAkADgAQABIAFAAWABgAGgAcAACAAgABABiAOADlAOyAAIACAAHBHweZivmLFIxKjZwNrwABAAAAAE2xAAEAAAAATfuAAQAAAABRkYABgEAAAFp5AAGAgAAAWqEAAYDAAABbGwABgIAAAFslgAGAgAAAW2EAAFuoAAEAAAACgAeACQAKgAwADYAPABCAEgATgBUAAEFUwAKAAEFUwAeAAEFUwA8AAEFUwAUAAEFUwAUAAEFUwAUAAEFUwAUAAEFUwAeAAEFU//2AAoFKv/sBSv/4gUs//YFLf/2BS7/zgUv/+wFMP/YBTH/7AUy/+IFM//sAAJuOAAEAAB5Nnm4AA0AGgAAADwAFP/2//YAZP/2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU/+wACgAAAEYACgAK/+wAHv+cAAoACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/OAAAAAAAAAAAAAAAUAAAAAAAAAAD/7P/Y/7D/7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAAAAAP/iAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/7P/sAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAoAAP/sADIAAAAAAAoAAAAA/7AAAAAK/+L/7P/xAAAAAAAAAAAAAAAAAAoAAAAA/+wAMv/2/7D/xAAUAAAAAP/2AAAAAAAAAAAAAP/Y/+IAAP/YAAAAAAAAAAAAAAAA/2oAAAAAAAAAAAAAABT/xAAAAAAAAP/iAAD/dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/2AAoAAAAAAAAAAAAA/+wAAAAKAAAAAAAAAAAAAAAAAAAAAAAAACj/xAAAAAAACgAAAAAAPAAAAAAAAAAAABQAAP/sAAr/7AAAAAAAAAAAAB4AAAAAAAAAAAAAAAD/4v/OAAD/4gAAAAAAAAAA/+z/4gAAAAD/7AAAAAAAAAAA/+IAAAAA//v/7AAAAAAAFP8u/3n/YAAA/3n/kgAA/0wAAP9+/3T/nP+w/5z/kv/s/4j/pv95AAAAAP9+/3n/fgAAAGQAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmuyAAQAAHfOd9IAAQAHAAD/7P/i//v/4v/7//YAAmuaAAQAAHfOd+gACgAKAAD/pv/EAAr/4gAAAAAAAAAAAAAAAP/Y/+wAAP/2//YAAAAAAAAAAAAA/6b/sAAK/8T/9gAAAAAAAAAAAAD/pv/E//b/2AAAAAAAAAAAAAAAAP/Y/9gAAP/iAAAAAAAAAAAAAAAA/+IAAP+mAAD/2P/2//b/9v/nAAD/xP/OAAD/7AAAAAAAAAAAAAAAAP+6/84AAP/iAAAAAAAAAAAAAAAA/7r/xAAK/+L/9gAeAAAAAAAKAAD/pv/E//b/4gAAAAAAAAAAAAAAAWrMAAQAAAD0AfICAAIOAhwCKgI4AkYCVAJiAnACfgKMApoCqAK2AsQC0gLgAu4C/AMKAxgDJgM0A0IDUANaA4QDigOQA5YDnAPyA/gD/gQEBBIEIAQuBDwESgRYBGYEkAS6BOQFDgU4BUYFVAViBXAFfgWMBZoFqAW2BcQF0gXgBe4F/AYKBhgGJgY0BkIGUAZeBmwGegaIBpYGpAayBsAGygbUBt4G6Ab2BwQHEgcgBy4HPAdKB1gHZgd0B4IHkAeeB6wHugfIB9YH5AfyCAAIDggcCCoIOAhGCHgIggiMCJYIoAiqCLQIvgjICNII3AjmCPAI+gkECRoJXAlmCXAJegmECY4JmAmiCfQKRgqYCuoLPAtGC1ALWgtkC24LeAuCC4wLlgukC7ILwAvOC9wL6gv0C/4MCAwSDBwMJgxIDGoMjAyuDNAM8g0QDZoN/A5CDngOlg68DyYPOA9eD3wPmg+oD8YP5A/2EDwQghC4EP4RRBGiEcQR5hHwEfoSJBJSElwSihKQEqoS2BL6EwwTNhNgE34ToBPCE+QUBhQoFE4UZBSKFKAUphSsFM4U1BTaFPgVBhUwFVoVaBV2FYQVihWgFcIVyBXOFeAWBhYkFkIWaBauFwwXEhckF4IX4BfmGAQYIhgsGFIYuBkeGYQAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAACAXgAFAHeAEYACgFyAHMBcwBfAXQAfQF4AM0BegBpAX8AIwHeAQQB4ACWAecAWgHsAG4AAQHhACgAAQHhACgAAQU8AAoAAQU8AAoAFQIHAFoCCABaAgkAWgIKAFoCCwBaAtQAWgLVAFoC1gBaAtcAWgLYAFoDKwBaAywAWgMtAFoDNwBaAz0AWgNBAFoFPAAKBV0AtAVeALQFXwC0BWAAtAABBTwACgABBTwACgABBTwACgADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAoBdABVAXgA4QF6AEEBfwAPAd4BBAHgAG4B4wBkAeQAbgHnADwB7ABGAAoBdABVAXgA4QF6AEEBfwAPAd4BBAHgAG4B4wBkAeQAbgHnADwB7ABGAAoBdABVAXgA4QF6AEEBfwAPAd4BBAHgAG4B4wBkAeQAbgHnADwB7ABGAAoBdABVAXgA4QF6AEEBfwAPAd4BBAHgAG4B4wBkAeQAbgHnADwB7ABGAAoBdABVAXgA4QF6AEEBfwAPAd4BBAHgAG4B4wBkAeQAbgHnADwB7ABGAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeAAyAZsAUAHeAFAAAwF4ADIBmwBQAd4AUAADAXgAMgGbAFAB3gBQAAMBeP/2AZsAHgHeAB4AAwF4//YBmwAeAd4AHgADAXj/9gGbAB4B3gAeAAMBeP/2AZsAHgHeAB4AAwF4//YBmwAeAd4AHgADAXj/9gGbAB4B3gAeAAMBeAAoAZsARgHeAEYAAgF4ABQB3gBGAAIBeAAUAd4ARgACAXgAFAHeAEYAAgF4ABQB3gBGAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4AAwF4ADwBmwBuAd4AbgADAXgAPAGbAG4B3gBuAAMBeAA8AZsAbgHeAG4ADAF0/84BeAAyAZsAjAGd/+IBo/+6AbgAKAG8//YBvQAUAd4AZAHg/+wB5/+6Aez/ugACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAUBP//OAUD/zgFB/84BQv/OAUP/zgAQAgcAAAIIAAACCQAAAgoAAAILAAAC1AAAAtUAAALWAAAC1wAAAtgAAAMrAAADLAAAAy0AAAM3AAADPQAAA0EAAAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAFAFy/9gBc/+wAXT/9gF4AHgBev/sAZsAoAGd/+wBo//OAbX/zgG3//YBuAA8AbwAFAG9AEYB3gCgAeD/7AHjAAoB5AAKAef/4gHs/+IB9QAKABQBcv/YAXP/sAF0//YBeAB4AXr/7AGbAKABnf/sAaP/zgG1/84Bt//2AbgAPAG8ABQBvQBGAd4AoAHg/+wB4wAKAeQACgHn/+IB7P/iAfUACgAUAXL/2AFz/7ABdP/2AXgAeAF6/+wBmwCgAZ3/7AGj/84Btf/OAbf/9gG4ADwBvAAUAb0ARgHeAKAB4P/sAeMACgHkAAoB5//iAez/4gH1AAoAFAFy/9gBc/+wAXT/9gF4AHgBev/sAZsAoAGd/+wBo//OAbX/zgG3//YBuAA8AbwAFAG9AEYB3gCgAeD/7AHjAAoB5AAKAef/4gHs/+IB9QAKABQBcv/YAXP/sAF0//YBeAB4AXr/7AGbAKABnf/sAaP/zgG1/84Bt//2AbgAPAG8ABQBvQBGAd4AoAHg/+wB4wAKAeQACgHn/+IB7P/iAfUACgACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAADAXgAbgGbAB4B3gAUAAMBeABuAZsAHgHeABQAAwF4AG4BmwAeAd4AFAADAXgAbgGbAB4B3gAUAAMBeABuAZsAHgHeABQAAwF4AG4BmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAACAZsAHgHeABQAAgGbAB4B3gAUAAIBmwAeAd4AFAAIAXgAKAGbAFABtwAUAbgACgG5/9gBvP/YAb3/zgHeAFAACAF4ACgBmwBQAbcAFAG4AAoBuf/YAbz/2AG9/84B3gBQAAgBeAAoAZsAUAG3ABQBuAAKAbn/2AG8/9gBvf/OAd4AUAAIAXgAKAGbAFABtwAUAbgACgG5/9gBvP/YAb3/zgHeAFAACAF4ACgBmwBQAbcAFAG4AAoBuf/YAbz/2AG9/84B3gBQAAgBeAAoAZsAUAG3ABQBuAAKAbn/2AG8/9gBvf/OAd4AUAAHA0IAPANDADwFPAA8BV0AKAVeACgFXwAoBWAAKAAiAYgAAAGwADIBsQAAAbIAAAHFADIBxgAAAcgAPAHJAAABywAAAcwAAAHNAAABzgAAAlAAAAJ1AAACdgAAAncAAAKLAAACjAAAAo4AAAKPAAACkAAAApEAAAKSAAACkwAAApQAAAMDAAADNgAAA0IAPANDADwFPAA8BV0APAVeADwFXwA8BWAAPAAYAYgAAAHIACgByQAAAcsAAAHMAAABzQAAAc4AAAJQAAACjgAAAo8AAAKQAAACkQAAApIAAAKTAAAClAAAAwMAAAM2AAADQgBGA0MARgU8AEYFXQAyBV4AMgVfADIFYAAyABEBmwAAAbYAPAG3ADIBuAB4AbkAMgG6ABQBuwAUAbwAMgG9AB4BvgA8Ab8AKAHAAB4BwQAoAcIAHgHEABQB3gAyAeEAKAANAakAFAMyABQDNQAUAzoAFANCAFoDQwBaBTwAWgVPAKoFUQCqBV0AZAVeAGQFXwBkBWAAZAAHA0IAHgNDAB4FPAAeBV0AHgVeAB4FXwAeBWAAHgAJA0IAWgNDAFoFPABaBU8AqgVRAKoFXQBQBV4AUAVfAFAFYABQABoBiAA8AcgAPAHJADwBywA8AcwAPAHNADwBzgA8AlAAPAKOADwCjwA8ApAAPAKRADwCkgA8ApMAPAKUADwDAwA8AzYAPANCAFoDQwBaBTwAWgVPAKAFUQCgBV0AWgVeAFoFXwBaBWAAWgAEBV0AKAVeACgFXwAoBWAAKAAJAXgAIwF7ABkBtgAeAbcAFAG4AEYBuQAUAbwAKAG9AB4BwQAUAAcDQgB4A0MAeAU8AHgFXQA8BV4APAVfADwFYAA8AAcDQgBuA0MAbgU8AG4FXQBGBV4ARgVfAEYFYABGAAMDQgAAA0MAAAU8AAAABwNCAGQDQwBkBTwAZAVdAFAFXgBQBV8AUAVgAFAABwNCADwDQwA8BTwAPAVdAG4FXgBuBV8AbgVgAG4ABAVdABQFXgAUBV8AFAVgABQAEQGbADwBtgA8AbcAMgG4AHgBuQAyAboAFAG7ABQBvAAyAb0AHgG+ADwBvwAoAcAAHgHBACgBwgAeAcQAFAHeADIB4QAoABEBmwAAAbYAPAG3ADIBuAB4AbkAMgG6ABQBuwAUAbwAMgG9AB4BvgA8Ab8AKAHAAB4BwQAoAcIAHgHEABQB3gAyAeEAKAANAakAFAMyABQDNQAUAzoAFANCAFoDQwBaBTwAWgVPAKoFUQCqBV0AbgVeAG4FXwBuBWAAbgARAZsAAAG2ADwBtwAyAbgAeAG5ADIBugAUAbsAFAG8ADIBvQAeAb4APAG/ACgBwAAeAcEAKAHCAB4BxAAUAd4AMgHhACgAEQGbAAABtgA8AbcAMgG4AHgBuQAyAboAFAG7ABQBvAAyAb0AHgG+ADwBvwAoAcAAHgHBACgBwgAeAcQAFAHeADIB4QAoABcBmwAAAbYAPAG3ADIBuAB4AbkAMgG6ABQBuwAUAbwAMgG9AB4BvgA8Ab8AKAHAAB4BwQAoAcIAHgHEABQB3gAyAeEAKAVPAMgFUQDIBV0AZAVeAGQFXwBkBWAAZAAIA0IAHgNDAB4FPAAeBVMAUAVdAAoFXgAKBV8ACgVgAAoACANCAEYDQwBGBTwARgVTAFAFXQAeBV4AHgVfAB4FYAAeAAIFTwA8BVEAPAACBU8APAVRADwACgNCAEYDQwBGBTwARgVPAJYFUQCWBVMAeAVdAEYFXgBGBV8ARgVgAEYACwNCADwDQwA8BTwAPAVHAGQFTwCMBVEAjAVTAG4FXQBGBV4ARgVfAEYFYABGAAIFTwA8BVEAPAALA0IAUANDAFAFPABQBUcAWgVPAKAFUQCgBVMAggVdADwFXgA8BV8APAVgADwAAQVHACgABgU8ADIFRwA8BV0AMgVeADIFXwAyBWAAMgALA0IAZANDAGQFPABkBUcAeAVPAL4FUQC+BVMAjAVdAG4FXgBuBV8AbgVgAG4ACANCAB4DQwAeBTwAHgVHADIFXQAeBV4AHgVfAB4FYAAeAAQFXQAABV4AAAVfAAAFYAAAAAoDQgBQA0MAUAU8AFAFRwBGBU8AlgVRAJYFXQAyBV4AMgVfADIFYAAyAAoDQgA8A0MAPAU8ADwFRwBkBU8AlgVRAJYFXQBQBV4AUAVfAFAFYABQAAcDQgAAA0MAAAU8AAAFXQAKBV4ACgVfAAoFYAAKAAgDQgAUA0MAFAU8ABQFRwA8BV0AKAVeACgFXwAoBWAAKAAIA0IAUANDAFAFPABQBUcAbgVdAFoFXgBaBV8AWgVgAFoACANCABQDQwAUBTwAFAVHADwFXQAUBV4AFAVfABQFYAAUAAgDQgAyA0MAMgU8ADIFRwBaBV0APAVeADwFXwA8BWAAPAAIA0IAFANDABQFPAAUBUcAMgVdAB4FXgAeBV8AHgVgAB4ACQNCAEYDQwBGBTwARgVDACgFRwBuBV0AUAVeAFAFXwBQBWAAUAAFBUcAMgVdABQFXgAUBV8AFAVgABQACQNCAFoDQwBaBTwAWgVDACgFRwCCBV0AZAVeAGQFXwBkBWAAZAAFBUcAKAVdAAoFXgAKBV8ACgVgAAoAAQU8AAoAAQU8AAoACAU8AFoFRwBuBU8AtAVRALQFXQBkBV4AZAVfAGQFYABkAAEFPAAKAAEFPAAKAAcFPAAKBU8AjAVRAIwFXQAeBV4AHgVfAB4FYAAeAAMDQv/EA0P/xAU8/8QACgNCAB4DQwAeBTwAHgVPAGQFUQBkBVMARgVdAAoFXgAKBV8ACgVgAAoACgNCABQDQwAUBTwAFAVPAG4FUQBuBVMARgVdABQFXgAUBV8AFAVgABQAAwNC/84DQ//OBTz/zgADA0L/zgND/84FPP/OAAMDQv/OA0P/zgU8/84AAQU8AAoABQU8AAoFXf/OBV7/zgVf/84FYP/OAAgFPABuBUcAeAVPALQFUQC0BV0AjAVeAIwFXwCMBWAAjAABBTwACgABBTwACgAEAfcAKAK9ACgCzwAoAyoAKAAJAXgAIwF7ABkBtgAeAbcAFAG4AEYBuQAUAbwAKAG9AB4BwQAUAAcDQgAeA0MAHgU8AB4FXQAUBV4AFAVfABQFYAAUAAcDQgAUA0MAFAU8ABQFXQAoBV4AKAVfACgFYAAoAAkBeAAjAXsAGQG2AB4BtwAUAbgARgG5ABQBvAAoAb0AHgHBABQAEQGbAAABtgA8AbcAMgG4AHgBuQAyAboAFAG7ABQBvAAyAb0AHgG+ADwBvwAoAcAAHgHBACgBwgAeAcQAFAHeADIB4QAoABcBmwAAAbYAPAG3ADIBuAB4AbkAMgG6ABQBuwAUAbwAMgG9AB4BvgA8Ab8AKAHAAB4BwQAoAcIAHgHEABQB3gAyAeEAKAVPAOYFUQDmBV0AZAVeAGQFXwBkBWAAZAABBTwACgAEBV3/4gVe/+IFX//iBWD/4gAXAXgAAAGbADwBngAAAbYAKAG4AGQBuQAUAbwAMgG+AB4BwQAyAd4APAHhAAoCQAAKAmIAMgJlAAACfAAeAn4AZAKCACgChAAUAocAHgKkADICpwAKAxIAKAMVABQAFwF4AAABmwA8AZ4AAAG2ACgBuABkAbkAFAG8ADIBvgAeAcEAMgHeADwB4QAKAkAACgJiADICZQAAAnwAHgJ+AGQCggAoAoQAFAKHAB4CpAAyAqcACgMSACgDFQAUAAEBkP+6AAcBeABuAZsAoAHeAJYCYgCWAoYAKAKkAKADEgCWAAcBeABuAZsAoAHeAJYCYgCWAoYAKAKkAKADEgCWAAIBmwAeAd4AFAAJAXIAKAF4AJYBmwDIAd4AvgHgABQB5gBaAkAAjAJiAMgCpADIABkBeAA8AZsAZAGeACgBtgBQAbgAggG5AB4BvABGAb4AKAHBADIBxAAUAd4AbgHhACgCQAA8AmIAbgJlACgCfABGAn4AggJ/AB4CggBGAoQAKAKHADICpABuAqcAKAMSAGQDFQAoABkBeAA8AZsAZAGeACgBtgBQAbgAggG5AB4BvABGAb4AKAHBADIBxAAUAd4AbgHhACgCQAA8AmIAbgJlACgCfABGAn4AggJ/AB4CggBGAoQAKAKHADICpABuAqcAKAMSAGQDFQAoABkBeAA8AZsAZAGeACgBtgBQAbgAggG5AB4BvABGAb4AKAHBADIBxAAUAd4AbgHhACgCQAA8AmIAbgJlACgCfABGAn4AggJ/AB4CggBGAoQAKAKHADICpABuAqcAKAMSAGQDFQAoABkBeAA8AZsAZAGeACgBtgBQAbgAggG5AB4BvABGAb4AKAHBADIBxAAUAd4AbgHhACgCQAA8AmIAbgJlACgCfABGAn4AggJ/AB4CggBGAoQAKAKHADICpABuAqcAKAMSAGQDFQAoAAJSugAEAABdomNwACsAKAAA//EAHgCCAKoAqgCMADL/9gC0AIwAFAAUADwAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKABQAHgAUAAD/9gAAAEYACgAAACj/9gBQ//v/+//2//b/9v/2//b/7P/2AB7/8f/2//EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/iACgACv/xAAD/9v/s/+wAAAAAABT/7P/2AAD/9gAAABT/+//s/+z/7P/s/+wAAP/n/+L/2P/7/+z/7P/YAAAAAAAAAAAAAAAAAAAAAAAA/9gAFAAAAAAACgAAAAr/3f/2ACgAHv/sAAAAAAAAAAAAAAAAAAAAAAAA/+wAAAAAAAD/7P/mAAAAAAAA/9gACgAeAAAAAAAAAAAAAAAAAAD/2AAAAAD/7P/2AAD/9v/s/+z/9v/2/+L/9v/2//v/+//i//b/7P/s/+z/3f/sAAD/5//i/9j/8QAA/+z/2AAAAAD/+//2/+z/9gAAAAAAAAAAABQAeACqAKoAjAAy//YAtACMAAoAFP/2AIIAAAAAAAAAAAAAAAAAAAAAAAAAjAAA//b/9gAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAoACgAUAAAAAAA8AAAACgAK/+wAAP/2//b/5//2//b/7P/2//b/9gAU//b/7P/sAAUAAAAKAAAAAAAA//sAAAAA//EAAAAAAAD/7AAeAHgAqgCqAIwAMv/sALQAjAAZABQAAACCAAAAAAAAAAAAAAAAAAAAAAAAAIwAAP/2/+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAoAAAAA//YAMgAAAAUAAP/dAAD/9v/x/+L/7P/s/+z/7P/s/+wAFP/i/+L/2P/s/+wAAP/xAAAAAAAA//b/+//iAAAAAAAA/90AqgCqAB4AWgBGACj/9gAAAKAAlv/iAEYAtAAAAAAAAAAAAAAAAAAAAAAAAAAUAAD/ugAAAAAAAAAA/+wAAACgAAAAAAAAAAAAAAAAAAD/pgAKABT/2P/i/87/5/+c/8kACgAe/37/4gAU/+z/4gAe/+z/v//O/87/zv+m/7D/xP+6/7r/3QAA/6b/kgAAABT/7P/sAAr/2AAAAAoAAAAA/9gACgAKAAAAAAAUAAAAHgAA/8kAAAAAADz/5wAA/9j/4v/2/+z/7P/7AAoAFP/2//b/5wAAAAAACv/2AAD/ugAAAAD/+//2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/2//YAAAAAAAAAAP/sAAD/7P/2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/+//2AAAAAAAAAAAAAABGAIIAqgCqAIwAMgCCALQAjABGAAAAAACCAAAAAAAAAAAAAAAAAAAAAAAAAIwAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAP/i//YAAAAAAAoAAAAAAAD/9gAAAAr/4gAUAAAAAAAAAAAAAAAA//b/9v/2//YAAP/2//b/9gAAAAD/+//iAAAAAAAAAAAAAAAAAAAAAAAAAAD/7AAeABQAWgAA/+IAAAAKAEYAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/2AAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAD/7AAAAAAAAAAAAAD/9v/sAAAAAAAA/+L/8QAAAAAAAAAAAAD/7P/s/+L/2P/nAAD/5//i/9MAAP/n/+z/2AAAAAAAAAAAAAD/7AAAAAAAAP+/AAAAAP/sAAD/7P/s/9P/0wAKABT/xP/xAAD/7AAA//b/9v/s/+z/2P/Y/9j/4v/i/+L/3f/2AAD/4v/TAAAAAP/7//b/9v/sAAAAAAAA/+wAAAB4AKoAqgCMADL/7AC0AIwAAAAA//YAggAAAAAAAAAAAAAAAAAAAAAAAACMAAD/7P/sAAAAAAAA//YAAAAAAAAAAAAAAAAAAAAAAAD/9gAAAAoAFAAUAAD/0//iADIAAP/2/9j/0wA8/+L/7P/i/9j/4v/d/+z/3f/OAB4AAP/d/9j/zgAA//YAAAAA//b/8f/sAAr/zgAAAAAAAAAAAEYAggCqAKoAjAAyAFAAtACMAFAAAAAAAIIAAAAAAAAAAAAAAAAAbgAAAAAAjAAAAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAB4AAAAAAAA/+z/ugAyABQAFAAA/+L/7AAyAAD/ugAU/84ARv/O/9j/pv+6AAD/4v/s/+wAHgAeAAD/4v/Y/5wAAAAAAAAAAP+6/+z/5wAK/9gAAAAAAAAAAAAKAHgAqgCqAIwAMgAAALQAjP/2AAAAAACC/+wAAAAAAAAAAAAAAAAAAAAAAIwAAAAAAAAAAAAAAAAAAAAA//YAAAAAAAAAAAAUAAAAAP/s/+wAAP/2AAAAAAAKAAD/yQAA/+z/7AAKAAAAAAAA/+wAAAAAAAAAAP/2AAAAAP/7AAD/7P/2//YAAP/iAAD/9gAAAAD/7AAAAAAAAAAA/6sAAAAA//YAAP/i//b/zv+/AB4ACv+/ABQAAAAAAAAAAAAAAAAAAAAA/8QAAP/sAAD/7P/iAAAAAAAA/8kAAAAUAAAAAAAAAAAAAAAAAAD/xAAAAAD/9v/s/+z/7P/O/8QAAP/s/7AAAAAA//YACv+1AAD/7P/s/+z/4v/O//b/8f/n/87/yQAA/+L/xAAAAAAAAP/7/+L/7AAAAAAAAP/s/+IAbgCqAJYAjABG/+wAtACM/9gAAP/sAIIAAAAAAAAAAAAAAAAAAAAAAAAAjAAA/+z/4gAAAAAAAAAAAAD/2AAAAAAAAAAAAAAAAAAA//b/sAAUABQAFAAA/7r/7ABGAAD/uv/Y/8QARv/O/+f/v//T/+z/4v/s/+L/zgAe//b/4v/Y/6YAAP/2AAAAAP+6/+z/5wAU/84AAAAAAAAAAAAAAAAAAAAUAAAAAAAAABQAAAAAAAD/9gAAAAAAAP/2AAAAAP/2/+z/+wAAAAr/9v/7/+IAAAAAAAD/+wAAAAAAAAAA//YAAAAAAAAAAP+hAKoAlv/sAEb/7P/i/6b/7ACMAIz/oQAAAJYAAAAAAAAAAAAAAAAAAP/iAAAAAAAA/6b/ugAAAAAAAP+hAAAAjAAAAAAAAAAAAAAAAAAA/5wAMgAy/9j/7P/O/87/nP/YADIAMv+S/9gAMgAU//EARgAK/9j/7P/2/6b/nP/OAAD/sP+wAAAAAP+w/5wAAAA8//YAAABB//YAAAAyAAD/xAAAAAAAAAAAAAAAAP/Y/8QAAAAA/9gAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//YAAAAAAAD/2AAAAAAAAAAAAAAAAAAAAAAAAP/sAAAAWgAAAAAAAAAA/+wAAAAAAAD/4v/xADIAAAAAAAAAAP/s/+z/4v/Y/+cAAP/n/+L/0wAA/+f/7P/YAAAAHgAAAAAAAP/sAAAAAAAA/9gAMgBkAKAAeACMAKoAAAAAAEYAHgAUABQAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAAAAD/sAAAAAD/7P/x/+f/2P+6/84ACgAU/7X/7AAA//v/+wAA//b/zv/Y/9j/sP/O/+L/3f/O/7r/7AAA/9j/qwAAAAr/9v/2//b/5wAAAAAAAP/2AAoAeACqAKoAjAAyAAAAtACMAAAAAP/sAIIAAAAAAAAAAAAAAAAAAAAAAAAAjAAA/+z/7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//YAFAAe//b/+//s/+L/7AAAABQACv/s/84AKAAA//YACv/2/+L/4v/n/+IAAAAK/+z/5//TAAAAAP/s/+wAAAAe//v/9gAK/+IAAAAAAAD/3f/2AAAAAAAAAAAAAP/Y/90AAAAA/+L/8QAA//YAAP/2//b/4v/n/+L/2P/nAAD/3f/n/+L/9gAA/+f/vwAAAAAAAP/2//b/7AAAAAAAAP/2AB4AeACqAKoAjAAyADwAtACMACgAAP/2AIIAAAAAAAAAAAAAAAAAAAAAAAAAjAAA/+z/7AAAAAAAAAAAAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAFAAA/9j/7AAoABQACgAA/90ARv/2/+wAAP/2/+z/4v/s/+IAFAAe//b/5//O//YAAP/2//YAAAAA//v/+wAA/+wAAAAAAAD/9v/sAFoAbgBuAIIAMgAAAG4AUAAA/+z/9gBk/+IAAAAAAAD/7AAAAAD/9QAKAIwAAP/x/+IAAAAAABT/8QAAAAAAAAAAAAAAAAAAAAAAAAAA/+IAKAAAABQAAAAAAAAAAAAK//b/+wAAAEYAAAAAAAAAAAAAAAAAAAAAADIAFAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaACgAPAAjAB4AAAA8AB4AAAAAAB4AjAAAAAAAAAAAAAAAAAAAAB4AAABQAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJHxgAEAABPbl2AAAEALgAA/+wAKAAe//YACgAKAFAACv/sABQACv/EAFD/7AAKAB4AHgBQAFD/4gBQAB4ACv/Y/+z/9v/Y/+wAHv/2/+z/4v/E/+z/fv/s//YAHv/2ABT/9gAU//YABf/2AAJHYgAEAABj0mROAAwAMwAAAAoAKAAeACgAFAAUABQAMgAeABQAHgAeAAoAZABaAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIAFAAUAFD/2P/2/9gAFAAy/9gAFAAU/9gAAAAAAAoAFAAUAAoAFAAKAAr/7AAUAA8AHgAeAAoACv/2ABQACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAP/sAB7/9v/Y//YAAAAA/+wACv/7/+IAHgBGAB4AFAAUAAoAAAAKAAX/7AAAABQAHgAeAAr/7P/s//sAFP/2//b/9v/s//b/9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT/2AAUAEb/tf/O/7UAFAAe/7UACgAA/7oAAAAAAAAAAAAAAAAAAAAAAAD/ugAKAAAAAAAAAAD/uv/iABQAAP/sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/iAAD/uv/Y/7r/2P/s/7r/4gAA/7oAAAAAAAAAAAAeABQAAAAUAAr/uv/YAAoAHgAUAAr/xP/2//YAFP/YAAAAAAAA//v/9v/2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADL/4gAyAGT/zv/2/7oALQBa/6YAPAAy/5wAAAAAAB4AAAAAAAAAAP/2AAD/zgAo//EAFAAKABT/sP/OABT/zgAK//b/zv/s/+L/+wAF/+z/9v/s//b/7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/4v/iAAD/zv+6/84AAP/s/8T/9v/s/+wAbgCWADwAAAAA/+wAAAAA//b/ugAA/+wAAAAA//b/xP/Y/+z/9v/Y/+L/9v/i/+wAAP/sAAAAAP/2AAD/9v/2/+z/9gAAAAAAAAAAABQAbgAA/90AbgAjAG4AbgAAAG4APAAoABQAAAAAAAD/9gAAAB4AAAAoAAAAHgAo//YAAAAKAAoAMgAoAAAAAAAy/+wAAP/s//YAAP/2AAAAAAAAAAAAAABGAEYAAP/2AAAAAAAAAAAAFAAA/84AAAAAAAAAFP/iAAAAAAAAAAr/zv9+/37/zv/O/9gAAAAAAAAAAAAA/87/7AAA/+IAAP/2/37/zgAA/37/zv9+/37/fv9+/8T/uv/O/37/fgAAAAD/zv/E/87/fgAAAAAAMgAeACgAMgA8ADIAPAAeACgACgA8AB4AHgAUAB4AAAAAAAAAAAA8AAD/9gAKAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAAA/+wAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAACQr4ABAAAaMJsCAAXAB0AAP/2//YAggCMAIwAggAyABQAjAB4AIwABQAK//sAjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/YADwAHgAtAAoAAAAoAC0AHgBG//YAAAAAAGT/4gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//sAAACCAIwAjACCADIAFACMAHgAjAAAAAX/+wCMAAD/9v/2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAACgAKAAD/7AAAAAAAFAAAAAAAAAAAAAAAAP/7AAAAAAAAAAAAAAAAAAAAAAAAAAD/8QAyAGQAWgBkAHgAbgAZADwAeABa//b/7P/YAFoAMv/s/84APABa/+z/7AAAAAAAAAAAAAAAAAAAAAD/7ABuAGQAjACCAGQAAACMAG4AjP/sAAAAAAAyAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+wAKAAUAB4ACv/2AAAAFAAAADIAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/sAIIAjACMAIIAMgAAAIwAeACCACgAFAAAAIwAAAAA//YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/7AAeABQAFAAAABQAAAAUAAoARgAAAAAAAABu/+IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/2ABQAggCMAIwAggAyAAAAjAB4AIwAAAAAAAAAjAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAFoAFAAUAAoAAAAAACgAKABGAAAAAAAAAG4AFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/7ACCAIwAjACCADIAAACMAHgAjAAAAAoAAACMAAD/9v/sAAAAAAAAAAAAMv/sAAAAAAAAAAAAAAAA/+wAbgBuAG4AggCWAAAAPABkAIwAGQAKABQAHgAAAAAARgBGAAAAAAAAAAAAFACgAAAAAAAAAAAAAP+mAAAAAAAAAAAAAAAAAAAAMgAU//sAAP/sACj/4gAA/+L/+wAAAAAAAAAAAAAAAP/2/+f/7AAAAAAAAABaAFAARgBkAG4AAAAAADIAZAAAAAAAAABGAAAAAABGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+wAbgCCAIwAeAAeAIIAlgB4AKAAAAAAAAAAjAAAAAD/9gAeAKoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQAbgCMAIwAtAAAAEYAbgBuAB4AKAA8AAAAAAAAAEYAWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/4gAUAAAAAAAKAB4AAP/sAAAAFAAAAAD/4gAA/+wAAP/s/+cAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+wAMgAUAB4ACgAAAAAAHgAUAEYAAAAAAAAARv/iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAIIAjACMAIIAMgAKAJYAeACM/9gAHgAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAFAAoAAP/OAAAAFAAAAAD/7AAAAAAAAAAF/90AAAAAAAAAAAAAAAAAAAAAAAAAAP/2AAAAggCMAIwAggAyAAoAjAB4AIIAAAAdAAAAjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/4gAAAAAAAAAAADIAAAAAAAAAAAAA/9gAAAAUAAAAAAAAAEYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACPw4ABAAAbDBsOAACAA8AAAAyAB4APAAK/8QAWv/2ABQARgBQ/+IAZAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+wAAj7KAAQAAG2UbaQAAgADAAAAjAAAAAAAAP/YAAE+wD7uAAIADAECAD0AAQEIAAEBCAABAQgAAQEIAAEBCAABAQ4AAQEIAAEBCAABAQgAAQEIAAEBDgABAQ4AAQEIAAEBCAABAQgAAAD8AAABAgAAAQIAAAECAAABAgAAAQIAAQEIAAEBCAABAQgAAQEIAAEBCAABAQgAAQEIAAEBCAABAQgAAQEIAAEBCAABAQ4AAQEOAAEBCAABAQgAAQEIAAAA/AAAAQIAAAECAAABAgAAAQIAAAECAAEBCAABAQgAAQEIAAEBCAABAQgAAQEIAAEBFAABARQAAQEUAAEBFAABAQgAAQEIAAEBCAABAQgAAQEUAAEBFAABARQAAQEUAAEAJAAqAAH+lwAAAAH+lgAAAAH+zgHMAAH+zwHMAAH+zgHRAAEBbQAAAAEB3wNIAAE9wj3SAAQADAEWAEIAAgkmAAIJJgACCSYAAgkmAAIJJgADCSwAAgksAAIJJgACCSYAAgkmAAIJJgACCSwAAgksAAIJJgACCSYAAgkmAAMJLAAACRQAAAkaAAAJGgAACRoAAQkgAAAJGgAACRoAAgkmAAIJJgACCSYAAgkmAAIJJgACCSYAAgkmAAIJJgACCSYAAgkmAAIJJgACCSwAAgksAAIJJgACCSYAAgkmAAMJLAAACRQAAAkaAAAJGgAACRoAAQkgAAAJGgAACRoAAgkmAAIJJgACCSYAAgkmAAIJJgACCSYAAgkyAAIJMgACCTIAAgkyAAIJJgACCSYAAgkmAAIJJgACCTIAAgkyAAIJMgACCTIBAQguCDQIOgAACEAAAAhGAAAIQAAACEwAAAhSAAAIWAAACF4IZAhqAAAIXghkCHAAAAheCGQIdgAAAAAAAAh8AAAIggAACIgAAAiOCJQImgigCI4IlAimCKAIjgiUCKwIoAiOCJQIpgigCLIAAAi4AAAIsgAACL4AAAjEAAAIygAACNAAAAjWAAAI3AjiCOgI7gj0AAAAAAAACC4AAAj6AAAJAAAACQYAAAAAAAAJDAAAAAAAAAkSAAAAAAAACRgAAAiOCJQJHgigCSQJKgkwAAAJNgAACTwAAAlCAAAJSAAAAAAAAAlOAAAJVAlaCWAAAAlUCVoJZgAACWwAAAlyAAAAAAAACHwAAAjcCOII6AjuCEAAAAhGAAAIggAACIgAAAiyAAAIuAAACLIAAAi4AAAIsgAACLgAAAjQAAAI1gAACPQAAAAAAAAJQgAACUgAAAkAAAAJBgAAAAAAAAkYAAAJeAAACX4AAAl4AAAJfgAACVQJWglgAAAAAAAACYQAAAjEAAAIygAACNAAAAjWAAAAAAAACRgAAAguCDQJigAACC4INAmQAAAJlgAACZwAAAheCGQJogAACQAAAAmoAAAJAAAACa4AAAAAAAAJtAAACIIAAAm6AAAIjgiUCcAIoAiOCJQJxgigCNwI4gnMCO4I3AjiCOgI7gjcCOIJzAjuAAAAAAnSAAAAAAAACdgAAAAAAAAJ3gAAAAAAAAnkAAAAAAAACeoAAAhAAAAIRgAACSQJKgnwAAAAAAAACEYAAAjEAAAIygAACfYAAAn8AAAI0AAACNYAAAjEAAAIygAACC4KAgg6AAAAAAAACggAAAAAAAAKDgAAChQAAAlOAAAKGgogCiYAAAoaCiAKLAAAChoKIAoyAAAAAAAACjgAAAiCAAAIiAAACj4KRApKClAKPgpEClYKUAo+CkQKXApQCj4KRApKClAKYgAACmgAAApiAAAKbgAACnQAAAp6AAAI3AjiCOgI7glCAAAJSAAACoAAAAqGAAAKjAAACpIAAAqMAAAKmAAAAAAAAAkYAAAKPgpECkoKUAkkCSoJMAAACTYAAAk8AAAJQgAACUgAAAAAAAAJTgAACp4KpAqqAAAKngqkCrAAAAq2AAAJqAAACNwI4gjoCO4AAAAACggAAAAAAAAKCAAACIIAAAiIAAAKYgAACmgAAApiAAAKaAAACrwAAArCAAAKdAAACnoAAAlCAAAJSAAACsgAAArOAAAAAAAACRgAAArUAAAK2gAACtQAAAraAAAKngqkCqoAAAAAAAAK4AAACnQAAAp6AAAAAAAACRgAAAguCgIJigAACC4KAgmQAAAJlgAACZwAAAoaCiAK5gAACQAAAAmoAAAJAAAACa4AAAAAAAAK7AAACIIAAAm6AAAKPgpECvIKUAo+CkQK+ApQCNwI4gnMCO4I3AjiCOgI7gjcCOIJzAjuAAAAAAnSAAAKjAAACv4AAAqMAAALBAAACowAAAsKAAAAAAAACeoAAAAAAAAKCAAACSQJKgnwAAALEAAACxYAAAscCyILKAAACy4AAAs0AAALLgAACzoAAAtAAAALKAAAC0YLTAtSAAALRgtMC1gAAAtGC0wLXgAAAAAAAAtkAAALagAAC3AAAAt2C3wLgguIC3YLfAuOC4gLdgt8C5QLiAt2C3wLjguIC5oAAAugAAALmgAAC6YAAAusC7ILuAu+C5oAAAvEAAALygAAC9AAAAvWAAAL3AAAC+IAAAuCAAAL4gAAC44AAAAAAAAL6AAAC3YLfAuCC4gL7gv0C/oAAAwAAAAMBgAAAAAAAAwMAAAMEgAAAAAAAAwYDB4MJAAADCoMMAw2DDwLLgAACzQAAAxCAAAMSAAAAAAAAAvQAAALrAAADE4AAAxUDFoMYAAADFQMWgxgAAAAAAAADGYAAAAAAAAL6AAACxwLIgxsAAALHAsiDHIAAAx4AAAMfgAAC0YLTAyEAAAAAAAADIoAAAAAAAAMkAAAAAAAAAyWAAALagAADJwAAAt2C3wMoguIC3YLfAyoC4gLrAuyDK4LvgAAAAAL0AAAAAAAAAy0AAAAAAAADLoAAAviAAAMogAAC+IAAAyoAAAL4gAAC5QAAAAAAAAMwAAAC+4L9AzGAAAMzAAADNIAAAscDNgLKAAACy4AAAs0AAALLgAACzoAAAtAAAALKAAAC0YLTAtSAAALRgtMC1gAAAtGC0wLXgAAAAAAAAzeAAALagAADOQAAAt2DOoLggzwC3YM6guODPALdgzqC5QM8At2DOoLjgzwC5oAAAugAAALmgAAC6YAAAusDPYLuAu+C5oAAAvEAAALygAAC9AAAAvWAAAL3AAAC+IAAAuCAAAL4gAAC44AAAAAAAALUgAAC3YM6guCDPAAAAAADPwAAAwAAAAMBgAADQIAAAAAAAANAg0IDQ4AAAusDPYLuAu+DRQAAA0aAAAAAAAADSAAAAusAAAMTgAADFQMWgxgAAAMVAxaDGAAAAAAAAANJgAAAAAAAAtSAAALHAzYDGwAAAscDNgMcgAADHgAAAx+AAALRgtMDIQAAAAAAAAMkAAAAAAAAA0sAAALagAADTIAAAt2DOoMogzwC3YM6gyoDPALrAz2DK4LvgusDPYL0Au+C6wM9gvQC74AAAAADLoAAAviAAAMogAAC+IAAAyoAAAL4gAAC5QAAAAAAAALXgAAAAAAAA04AAANPgAADUQAAAt2C3wLgguIC3YM6guCDPAAAf6XAAAAAf6WAAAAAf7ZAAoAAf7OAcwAAf7PAcwAAf7OAdEAAQGAAAAAAQLSAAoAAQJQA0gAAQEYAAAAAQGdA0gAAQHDBHwAAQHGAAAAAQI0A0gAAQF0AAAAAQH6AAoAAQHSA0gAAQH4BHwAAQHuBDEAAQLmA0gAAQF+AAAAAQG9A0gAAQG2AAAAAQNkAAoAAQIQA0gAAQMXA0gAAQJFBEkAAQI2BHwAAQICAAAAAQKEA0gAAQKqBHwAAQHyAAAAAQKDA0gAAQHEAAAAAQIRA0gAAQF8//sAAQHmAAoAAQHiA0MAAQKUA0gAAQEiAAAAAQHgA0gAAQFyAAAAAQH3A0gAAQIFA0gAAQI6BEkAAQG+A0gAAQIVA0gAAQNiAAAAAQOXAAoAAQJ5A0gAAQFJAAAAAQGpA0gAAQGBAAAAAQHhA0gAAQG6A0gAAQDdAAAAAQESAAoAAQFSA0gAAQFuBDEAAQFC/5UAAQG3A0gAAQIW//sAAQJsA0MAAQMbBEkAAQKFBEkAAQJsBDEAAQJAAAAAAQK/A0gAAQIHBEkAAQG/A0gAAQHbBDEAAQMCBDEAAQHZBDEAAQIpA/IAAQIsBDEAAQH+BCwAAQHWBDEAAQIeA/IAAQIhBDEAAQIrBHwAAQHaBDEAAQKVBDEAAQIqAAAAAQK7A0gAAQJbAAoAAQHcA0gAAQICBHwAAQFMAAAAAQFfAAAAAQHlAAoAAQHKA0gAAQHwBHwAAQHmBDEAAQKhA0gAAQGDAAAAAQKEAAoAAQHiA0gAAQLQA0gAAQIXBEkAAQIIBHwAAQFtAAAAAQHpA0gAAQIPBHwAAQGGAAAAAQH5A0gAAQEjAAAAAQGZA0gAAQFZAAAAAQHHA0gAAQH8BEkAAQCRAAAAAQDGAAoAAQEGA0gAAQEiBDEAAQE2AAAAAQImAAAAAQKiA0gAAQF4AAAAAQHuA0gAAQIC//sAAQJYA0MAAQLWBEkAAQH/BEkAAQK9BDEAAQH7A/IAAQH+BDEAAQHgA/IAAQHjBDEAAQHtBHwAAQIrAAAAAQK8A0gAAQDSAAAAAQGkAAoAAQEtAcwAAQD4AAAAAQDQAcwAAQD5Ax4AAQDmAAAAAQDrAAAAAQFDAAoAAQEDAcwAAQEsAx4AAQEfArEAAQGrAcwAAQBt/nAAAQDgAcwAAQDnAAAAAQG6AAoAAQEfAcwAAQGOAcwAAQE+AsQAAQFIAx4AAQDzAAAAAQEbAcwAAQFEAx4AAQDfAAAAAQEmAAoAAQD/AcwAAQFMAcwAAQEzAcwAAQDuAAAAAQD+AcwAAQFvAAAAAQGZAcwAAQGQ/x0AAQGnAeAAAQJEAAAAAQKwAAoAAQGaAcwAAQDtAAAAAQEBAcwAAQEPAcwAAQByAAAAAQB8AAAAAQDoAAoAAQC8ArEAAQHAAAAAAQIHAAoAAQHgAcwAAQItAcwAAQB3/nAAAQDqAcwAAQFIA6IAAQFFAAAAAQGdAAoAAQFdAcwAAQHKAsQAAQFMAsQAAQFJArEAAQFcAAAAAQGsAcwAAQEiAsQAAQEAAcwAAQEcArEAAQHHArEAAQD8ArEAAQE3AnIAAQE7ArEAAQEbArEAAQEaArEAAQErArEAAQHDAsUAAQG2ArEAAQEbAAAAAQF0AcwAAQGBAAoAAQGhAcwAAQEIAcwAAQGDAAoAAQGnAcwAAQEkAAoAAQF8AcwAAQBbAAAAAQCRAAoAAQDCArEAAQERAAAAAQDpAcwAAQE2AcwAAQHAAsQAAQG9ArEAAQEkArEAAQGYArEAAQEcAAAAAQF1AcwAAS9iMXgABAAMARYAQgACGDYAAhg2AAIYNgACGDYAAhg2AAMYPAACGDwAAhg2AAIYNgACGDYAAhg2AAIYPAACGDwAAhg2AAIYNgACGDYAAxg8AAAYJAAAGCoAABgqAAAYKgABGDAAABgqAAAYKgACGDYAAhg2AAIYNgACGDYAAhg2AAIYNgACGDYAAhg2AAIYNgACGDYAAhg2AAIYPAACGDwAAhg2AAIYNgACGDYAAxg8AAAYJAAAGCoAABgqAAAYKgABGDAAABgqAAAYKgACGDYAAhg2AAIYNgACGDYAAhg2AAIYNgACGEIAAhhCAAIYQgACGEIAAhg2AAIYNgACGDYAAhg2AAIYQgACGEIAAhhCAAIYQgLjFz4XRBdKAAAXPhdEF1AAABc+F0QXVgAAFz4XRBdcAAAXYhdEF1YAABc+F0QXaAAAFz4XRBduAAAXPhdEF3QAABc+F0QXegAAFz4XRBeAAAAXYhdEF3oAABc+F0QXgAAAFz4XRBeGAAAXPhdEF4wAABc+F0QXkgAAFz4XRBeYAAAXYhdEF0oAABc+F0QXUAAAFz4XRBeeAAAXPhdEF1YAABc+F0QXpAAAFz4XRBdKAAAXPhdEF6oAABc+F0QXSgAAFz4XRBewAAAXtgAAF7wAABe2AAAXwgAAFz4AABfIAAAXPgAAF84AABc+AAAXzgAAF9QAAAAAAAAXPgAAF9oAABc+AAAX4AAAF+YAABfsAAAX8gAAF/gAABfmAAAX/gAAGAQAABgKAAAYEBgWGBwAABgQGBYYIgAAGBAYFhgoAAAYEBgWGCIAABgQGBYYLgAAGBAYFhg0AAAYOhgWGC4AABgQGBYYNAAAGBAYFhg0AAAYEBgWGDQAABgQGBYYQAAAGBAYFhhGAAAYEBgWGEwAABg6GBYYHAAAGBAYFhgiAAAYEBgWGFIAABgQGBYYKAAAGBAYFhhYAAAYEBgWGBwAABgQGBYYXgAAGGQAABhqAAAYZAAAGHAAABhkAAAYdgAAGGQAABh8AAAYggAAGGoAABhkAAAYiAAAGI4AABiUAAAYjgAAGJoAABigGKYYrAAAGKAYphiyAAAYoBimGLgAABigGKYYvgAAGKAYphjEAAAYoBimGMoAABigGKYY0AAAGNYYphisAAAYoBimGLIAABigGKYY3AAAGKAYphi4AAAYoBimGOIAABigGKYYrAAAGKAYphjoAAAY7gAAGPQAABjuAAAY+gAAGQAAABkGAAAZDAAAGQYAABkSAAAZGBkeGRIAABkkGR4ZEgAAGRgZHhkqAAAZGBkeGRIAABkwGR4ZEgAAGRgZHhk2AAAZPAAAGUIAABlIAAAZQgAAGUgAABlCAAAZTgAAGUIAABlOAAAZVAAAGUgAABlCAAAZSAAAGUIAABlaAAAZYBlmGWwZchlgGWYZeBlyGWAZZhl+GXIZYBlmGYQZchlgGWYZihlyGZAZZhmEGXIZYBlmGYoZchlgGWYZihlyGWAZZhmKGXIZYBlmGZYZchlgGWYZnBlyGWAZZhmiGXIZYBlmGagZchmQGWYZbBlyGWAZZhl4GXIZYBlmGa4Zchm0GWYZuhnAGbQZZhnGGcAZzBlmGboZwBm0GWYZxhnAGbQZZhnSGcAZtBlmGdgZwBlgGWYZeBlyGWAZZhl+GXIZYBlmGd4ZchlgGWYZbBlyGeQAABnqAAAZ5AAAGfAAABlgGWYZ9hlyGWAZZhn8GXIaAgAAGggAABoOAAAaFAAAGg4AABoaAAAaDgAAGhoAABogAAAaFAAAGg4AABomAAAaDgAAGiwAABkSAAAaMgAAGRIAABo4AAAZEgAAGjgAABo+AAAAAAAAGRIAABpEAAAZKgAAGjIAABpKAAAaUAAAGkoAABkYAAAaSgAAGRgAABpKAAAZJAAAGlYAAAAAAAAaXAAAGRgAABpiGmgabhp0GmIaaBp6GnQaYhpoGoAadBpiGmgahhp0GmIaaBqMGnQaYhpoGpIadBqYGmgabhp0GmIaaBp6GnQaYhpoGp4adBpiGmgabhqkGmIaaBp6GqQamBpoGm4apBpiGmgaehqkGmIaaBqeGqQaYhpoGqoapBpiGmgaehp0GmIaaBqAGnQaYhpoGrAadBpiGmgabhp0GmIaaBq2GnQaYhpoGqoadBq8AAAawgAAGrwAABrIAAAavAAAGs4AABq8AAAa1AAAGrwAABrIAAAAAAAAGtoAAAAAAAAa4AAAAAAAABrmAAAa7AAAAAAAAAAAAAAa2gAAAAAAABryAAAAAAAAGvgAAAAAAAAa/gAAGwQAABsKAAAbBAAAGxAAABsEAAAbEAAAGwQAABsWAAAbHAAAGyIAABc+GygXSgAAFz4bKBdQAAAXPhsoF1YAABc+GygXXAAAF2IbKBdWAAAXPhsoF2gAABc+GygXbgAAFz4bKBd0AAAXPhsoF3oAABc+GygbLgAAF2IbKBd6AAAXPhsoGy4AABc+GygbLgAAFz4bKBsuAAAXPhsoF5IAABc+GygXmAAAF2IbKBdKAAAXPhsoF1AAABc+GygXngAAFz4bKBdWAAAXPhsoF6QAABc+GygXSgAAFz4bKBeqAAAXPhsoF0oAABc+GygXsAAAF7YAABe8AAAXtgAAF8IAABs0AAAbOgAAGzQAABtAAAAbNAAAG0AAABtGAAAAAAAAGzQAABtMAAAbNAAAG1IAABtYAAAbXgAAG2QAABtqAAAbWAAAG3AAABt2G3wbggAAG3YbfBuIAAAbdht8G44AABt2G3wbiAAAG3YbfBuUAAAbdht8G5oAABugG3wblAAAG3YbfBuaAAAbdht8G5oAABt2G3wbmgAAG3YbfBumAAAbdht8G6wAABt2G3wbsgAAG6AbfBuCAAAbdht8G4gAABt2G3wbuAAAG3YbfBuOAAAbdht8G74AABt2G3wbggAAG3YbfBvEAAAbygAAG9AAABvKAAAb1gAAG8oAABvcAAAbygAAG+IAABvoAAAb0AAAG8oAABvuAAAb9AAAG/oAABv0AAAcAAAAHAYcDBwSAAAcBhwMHBgAABscAAAbIgAAHAYcDBweAAAcBhwMHCQAABwGHAwcKgAAHAYcDBwwAAAcBhwMHDYAABw8HAwcEgAAHAYcDBwYAAAcBhwMHEIAABwGHAwcHgAAHAYcDBxIAAAcBhwMHBIAABwGHAwcTgAAHFQAABpQAAAcVAAAHFoAABxgAAAcZgAAHGwAABxmAAAccgAAHHgcfhyEAAAcihx+HHIAAByQHH4ccgAAHHgcfhyWAAAceBx+HHIAABycHH4ccgAAHHgcfhyiAAAcqAAAHGAAAByuAAActAAAHLoAABxgAAAcwAAAHGAAABzAAAAcbAAAHK4AABxgAAAcrgAAHGAAABzGAAAaAgAAGggAABzMAAAc0gAAHMwAABzYAAAczAAAHNgAABzeAAAc0gAAHMwAABzkAAAczAAAHOoAABzwAAAc9gAAHPAAABz2AAAc8AAAHPwAAB0CAAAAAAAAHQgAABz2AAAdDh0UHRodIB0OHRQdJh0gHQ4dFB0sHSAdDh0UHTIdIB0OHRQZxh0gHQ4dFB04HSAdPh0UHRodIB0OHRQdJh0gHQ4dFB1EHSAdDh0UHRodSh0OHRQdJh1KHT4dFB0aHUodDh0UHSYdSh0OHRQdRB1KHQ4dFB1QHUodDh0UHSYdIB0OHRQdLB0gHQ4dFB1WHSAdDh0UHRodIB0OHRQdXB0gHQ4dFB1QHSAdYgAAHWgAAB1iAAAdbgAAHWIAAB10AAAdYgAAHXoAAB1iAAAdbgAAGxwAAB2AAAAbHAAAHYYAABscAAAdjAAAGxwAAB2SAAAdmAAAHYAAABscAAAdhgAAGxwAAB2eAAAbHAAAHaQAABscAAAdqgAAHbAAAB22AAAdsAAAHbwAAB2wAAAdvAAAHbAAAB3CAAAdyB3OHdQAAB3IHc4d2gAAHcgdzh3gAAAdyB3OHeYAAB3sHc4d4AAAHcgdzh3yAAAdyB3OHfgAAB3IHc4d/gAAHcgdzh4EAAAdyB3OHgoAAB3sHc4eBAAAHcgdzh4KAAAdyB3OHgoAAB3IHc4eCgAAHcgdzh3aAAAdyB3OHhAAAB3sHc4d1AAAHcgdzh3aAAAdyB3OHhYAAB3IHc4eHAAAHcgdzh4iAAAdyB3OHigAAB3IHc4d1AAAHcgdzh4uAAAeNAAAHjoAAB40AAAeQAAAHkYAAB5MAAAeRgAAHlIAAB5GAAAeWAAAHl4AAAAAAAAeRgAAHmQAAB5GAAAeagAAHnAAAB52HnweggAAHogejh6UAAAemh6OHqAeph6sAAAeoB6mHrIAAB6gHqYeuAAAHqAeph6+AAAeoB6mHsQAAB6gHqYeygAAHtAeph7EAAAeoB6mHsoAAB6gHqYeygAAHqAeph7KAAAeoB6mHrIAAB6gHqYe1gAAHqAeph7cAAAe0B6mHqwAAB6gHqYesgAAHqAeph7iAAAeoB6mHugAAB6gHqYe7gAAHqAeph70AAAe+gAAHdQAAB76AAAd4AAAHvoAAB8AAAAe+gAAHgQAAB76AAAfBgAAHvoAAB8MAAAfEgAAHxgAAB8SAAAfHgAAHyQAAAAAAAAfKh8wHzYAAB8qHzAfPAAAHyofMB9CAAAfKh8wH0gAAB8qHzAfPAAAHyofMB9OAAAfKh8wH1QAAB9aAAAAAAAAHyofMB88AAAfKh8wH2AAAB8qHzAfZgAAHyofMB9sAAAfKh8wH3IAAB94AAAffgAAH3gAAB+EAAAfigAAH5AAAB+WAAAfkAAAH4oAAB+cAAAfogAAH6gfrh+iAAAftB+uH7oAAB/AH8YfzAAAH6gfrh+iAAAfqB+uH9IAAB/YAAAfigAAH94AAB+KAAAf5AAAH4oAAB/eAAAfigAAH+oAAB+WAAAf3gAAH4oAAB/eAAAfigAAH/AAAB8SH/Yf/CACHxIf9iAIIAIfEh/2IA4gAh8SH/YgFCACHxIf9iAaIAIgIB/2IBQgAh8SH/YgGiACHxIf9iAaIAIfEh/2IBogAh8SH/YgCCACHxIf9iAmIAIfEh/2ICwgAh8SH/YgMiACICAf9h/8IAIfEh/2IAggAh8SH/YgOCACHxIf9iA+IEQfEh/2IEogRCAgH/YgPiBEHxIf9iBKIEQfEh/2IFAgRAAAH/YgViBEHxIf9iAIIAIfEh/2IFwgAh8SH/YgYiACAAAAACBoAAAAAAAAIG4AAB8SH/YgdCACHxIf9iB6IAIggAAAIIYAACCMAAAgkgAAIIwAACCYAAAgjAAAIJ4AACCkAAAgkgAAIIwAACCYAAAgjAAAIKoAACCwAAAgtgAAILAAACC8AAAgsAAAIMIAACDIAAAAAAAAILAAACDOAAAg1AAAILYAACDaAAAg4CDmIOwAACDyIPgg/gAAAAAg5iEEAAAg4CDmIQohECEWIRwhCiEQISIhHCEKIRAhKCEcIQohECEuIRwhCiEQISIhHCEKIRAhNCEcITohECEWIRwhCiEQISIhHCEKIRAhQCEcIQoAACEWIRwhCgAAISIhHCE6AAAhFiEcIQoAACEiIRwhCgAAIUAhHAAAAAAhRiEcIQohECEiIRwhCiEQIUwhHCEKIRAhUiEcIQohECFYIRwhCiEQIV4hHCFkAAAhagAAIWQAACFwAAAhZAAAIXYAACFkAAAhfAAAIWQAACFwAAAhggAAIRYAACGCAAAhIgAAIYIAACEuAAAhggAAITQAACGIAAAhFgAAIYIAACEiAAAhggAAIUAAACGCAAAhUgAAIYIAACFeAAAhZAAAIY4AACFkAAAhlAAAIWQAACGaAAAhZAAAIaAAAB3IIaYd1AAAHcghph3aAAAdyCGmHeAAAB3IIaYd5gAAHewhph3gAAAdyCGmHfIAAB3IIaYd+AAAHcghph3+AAAdyCGmHgQAAB3IIaYeCgAAHewhph4EAAAdyCGmHgoAAB3IIaYeCgAAHcghph4KAAAdyCGmHdoAAB3IIaYeEAAAHewhph3UAAAdyCGmHdoAAB3IIaYeFgAAHcghph4cAAAdyCGmHiIAAB3IIaYeKAAAHcghph3UAAAdyCGmHi4AAB40AAAeOgAAHjQAAB5AAAAeRgAAHkwAAB5GAAAeUgAAHkYAAB5YAAAeXgAAAAAAAB5GAAAeZAAAHkYAAB5qAAAecAAAHnYefB6CAAAeiB6OIawAACGyHo4eoB6mHqwAAB6gHqYesgAAHqAeph64AAAeoB6mHr4AAB6gHqYexAAAHqAeph7KAAAe0B6mHsQAAB6gHqYeygAAHqAeph7KAAAeoB6mHsoAAB6gHqYesgAAHqAeph7WAAAeoB6mHtwAAB7QHqYerAAAHqAeph6yAAAeoB6mHuIAAB6gHqYe6AAAHqAeph7uAAAeoB6mHvQAAB76AAAd1AAAHvoAAB3gAAAe+gAAHwAAAB76AAAeBAAAHvoAAB8GAAAe+gAAHwwAAB8SAAAfGAAAHxIAAB8eAAAhuAAAAAAAACG4Ib4hxAAAIbghviHKAAAhggAAIdAAACG4Ib4h1gAAIbghviHcAAAhuCG+IcoAACG4Ib4h4gAAIbghviHoAAAh7gAAAAAAACG4Ib4hygAAIbghviH0AAAhuCG+IfoAACG4Ib4iAAAAIbghviHoAAAhuCG+IgYAAB94AAAffgAAH3gAAB+EAAAfigAAH5AAAB+WAAAfkAAAH4oAAB+cAAAfogAAH6gfrh+iAAAftB+uH6IAAB+oH64fzAAAH6gfrh+iAAAfqB+uH9IAAB/YAAAfigAAH94AAB+KAAAf5AAAH4oAAB/eAAAfigAAH+oAAB+WAAAf3gAAH4oAAB/eAAAfigAAH/AAAB8SIgwf/CACHxIiDCAIIAIfEiIMIA4gAh8SIgwgFCACHxIiDCAaIAIgICIMIBQgAh8SIgwgGiACHxIiDCAaIAIfEiIMIBogAh8SIgwgCCACHxIiDCAmIAIfEiIMICwgAh8SIgwgMiACICAiDB/8IAIfEiIMIAggAh8SIgwgOCACHxIiDCA+IEQfEiIMIEogRCAgIgwgPiBEHxIiDCBKIEQfEiIMIFAgRAAAIgwgViBEHxIiDCAIIAIfEiIMIFwgAh8SIgwgYiACAAAAACBoAAAAAAAAIG4AAB8SIgwgdCACHxIiDCB6IAIggAAAIIYAACCMAAAgkgAAIIwAACCYAAAgjAAAIJ4AACCkAAAgkgAAIIwAACCYAAAgjAAAIKoAACCwAAAgtgAAILAAACC8AAAgsAAAIMIAACDIAAAAAAAAILAAACDOAAAg1AAAILYAAB+6AAAfwB/GIIAAACISAAAggAAAIhgAACCAAAAiHgAAIIAAACIkAAAg2gAAIOAg5iDaAAAg4CDmIP4AAAAAIOYhBAAAIOAg5iEKIiohFiIwIQoiKiEiIjAhCiIqISgiMCEKIiohLiIwIQoiKiEiIjAhCiIqITQiMCE6IiohFiIwIQoiKiEiIjAhCiIqIUAiMCEKAAAhFiEcIQoAACEiIRwhOgAAIRYhHCEKAAAhIiEcIQoAACFAIRwAAAAAIUYhHCEKIiohIiIwIQoiKiFMIjAhCiIqIVIiMCEKIiohWCIwIQoiKiFeIjAiNgAAIjwAACI2AAAiQgAAIjYAACJIAAAiNgAAIk4AACI2AAAiQgAAIYIAACEWAAAhggAAISIAACGCAAAhLgAAIYIAACE0AAAhiAAAIRYAACGCAAAhIgAAIYIAACFAAAAhggAAIVIAACGCAAAhXgAAIlQAACJaAAAiVAAAImAAACJUAAAiZgAAIlQAACJsAAAhggAAIdAAAB6CAAAeiB6OH7oAAB/AH8YfugAAInIfxiJ4AAAfwB/GH7oAAB/AH8YfEiJ+H/wgAh8SIn4gCCACHxIifiAOIAIfEiJ+IBQgAh8SIn4gGiACICAifiAUIAIfEiJ+IBogAh8SIn4gGiACHxIifiAaIAIfEiJ+IAggAh8SIn4gJiACHxIifiAsIAIfEiJ+IDIgAiAgIn4f/CACHxIifiAIIAIfEiJ+IDggAh8SIn4gPiBEHxIifiBKIEQgICJ+ID4gRB8SIn4gSiBEHxIifiBQIEQAACJ+IFYgRB8SIn4gCCACHxIifiBcIAIfEiJ+IGIgAh8SIn4gaCACHxIifiBuIAIfEiJ+IHQgAh8SIn4geiACIOwAACDyIPgihAAAAAAg+CKKAAAg8iD4IIAAACISAAAggAAAIhgAACCAAAAiHgAAIIAAACIkAAAAAf6XAAAAAf6WAAAAAf7ZAAoAAf7OAcwAAf7PAcwAAf7OAdEAAQGAAAAAAQLSAAoAAQJQA0gAAQJ2BHwAAQJxBEkAAQKGBQcAAQFj/xgAAQKaBQcAAQJvBQQAAQKGBQoAAQJ4BIkAAQKeBb0AAQKfBcYAAQKaBZgAAQJ3BHwAAQJsBDEAAQJ3BIUAAQJpA/IAAQJ7BKgAAQJyBFcAAQJAAAAAAQK/A0gAAQLlBHwAAQHgA0gAAQIGBHwAAQFh/wYAAQIIBIkAAQH9BDAAAQFMAAAAAQG6A0gAAQSSAAAAAQUSBHwAAQHgBHwAAQPsAAAAAQQ+AzIAAQF0AAAAAQH6AAoAAQHSA0gAAQH4BHwAAQHzBEkAAQH6BIkAAQH6BGkAAQFX/xgAAQH5BHwAAQHuBDEAAQHvBDAAAQH5BIUAAQHrA/IAAQH0BFcAAQEYABYAAQHvA0gAAQIQBEkAAQIVBHwAAQIXBIkAAQD2/wIAAQIMBDAAAQHEAAAAAQIRA0gAAQI5BIkAAQDdAAAAAQESAAoAAQFSA0gAAQF4BHwAAQFzBEkAAQF6BIkAAQF5BHwAAQFuBDEAAQFvBDAAAQDA/xgAAQF5BIUAAQFrA/IAAQF0BFcAAQFC/5UAAQG3A0gAAQHfBIkAAQICAAAAAQKEA0gAAQHg/uwAAQFJAAAAAQH3A0gAAQMKA0gAAQIdBHwAAQEn/uwAAQHsAdMAAQJ0AAAAAQLcA0gAAQG1AAAAAQInA0gAAQJNBHwAAQGT/uwAAQJJBFcAAQF8//sAAQHmAAoAAQHiA0MAAQKUA0gAAQIIBHcAAQIDBEQAAQIKBIQAAQIKBGQAAQFf/xMAAQIJBHcAAQH+BCwAAQIXBNYAAQIYBNUAAQIJBIAAAQF9AAAAAQHjA0gAAQKdA5AAAQIJBHwAAQFg/xgAAQIKBIUAAQIFBFcAAQH7A+0AAQGJ/5wAAQGHA0gAAQGtBHwAAQIEBFIAAQIdBPwAAQKOAAAAAQLSA0gAAQH2AAAAAQIAA0gAAQImBHwAAQHU/uwAAQInBHwAAQIhBEkAAQGpA0gAAQHPBHwAAQEq/wYAAQHRBIkAAQFyAAAAAQG/A0gAAQFT/wYAAQFQ/uwAAQG2AAAAAQNkAAoAAQIVA0gAAQMXA0gAAQI7BHwAAQI2BEkAAQI9BIkAAQI8BHwAAQIxBDEAAQGZ/xgAAQI8BIUAAQMgA5AAAQI3BFcAAQIuA/IAAQJABKgAAQIqAAAAAQK7A0gAAQLhBHwAAQLjBIkAAQLXBDEAAQJIBHwAAQJKBIkAAQI+BDEAAQLr/rkAAQJJBIUAAQI7A/IAAQJEBFcAAQFoAAAAAQHCA0gAAQHoBHwAAQHfBDAAAQFZAAAAAQLTBHwAAQJbAAoAAQJ4BGkAAQGBAAAAAQHhA0gAAQIHBHwAAQFi/wYAAQIJBIkAAQH+BDAAAQFVAAAAAQHDA0gAAQRaAAAAAQTiBHwAAQHpBHwAAQFfAAAAAQHlAAoAAQHKA0gAAQHwBHwAAQHrBEkAAQHyBIkAAQHyBGkAAQFC/xgAAQHxBHwAAQHmBDEAAQHnBDAAAQHxBIUAAQHjA/IAAQHsBFcAAQGbAAAAAQHwA0gAAQIRBEkAAQIWBHwAAQIYBIkAAQF5/uwAAQINBDAAAQGGAAAAAQH5A0gAAQIhBIkAAQCRAAAAAQDGAAoAAQEGA0gAAQEsBHwAAQEnBEkAAQEuBIkAAQEtBHwAAQEiBDEAAQEjBDAAAQB0/xgAAQEtBIUAAQEfA/IAAQEoBFcAAQE2AAAAAQHnBIkAAQFtAAAAAQHpA0gAAQFL/uwAAQFYAAAAAQEDA0gAAQHrA0gAAQN1AAAAAQP+A0gAAQEpBHwAAQE2/uwAAQH2AfEAAQIjAAAAAQKLA0gAAQHfA0gAAQRVAAAAAQTeA0gAAQIFBHwAAQIBBFcAAQFnAAAAAQGjA0gAAQHJBHwAAQFF/uwAAQHKBHwAAQHEBEkAAQEjAAAAAQGZA0gAAQG/BHwAAQEE/wYAAQEB/uwAAQGDAAAAAQKEAAoAAQHiA0gAAQLQA0gAAQIIBHwAAQIDBEkAAQIKBIkAAQH+BDEAAQFm/xgAAQIJBIUAAQLZA5AAAQIEBFcAAQH7A/IAAQINBKgAAQIrAAAAAQK8A0gAAQLiBHwAAQLkBIkAAQLYBDEAAQHHA0gAAQHtBHwAAQHvBIkAAQHjBDEAAQE8/xgAAQHuBIUAAQHgA/IAAQHpBFcAAQFEAAAAAQGmA0gAAQHMBHwAAQHDBDAAAQDSAAAAAQGkAAoAAQEtAcwAAQFWAx4AAQFMAsQAAQFjA4sAAQC2/xwAAQF3A4sAAQFMA4gAAQFjA44AAQFaAzwAAQFVAu0AAQFJArEAAQFYAysAAQFSAvQAAQFFAnIAAQFYAywAAQFOAtcAAQFcAAAAAQGsAcwAAQHVAx4AAQDuAAAAAQD+AcwAAQEnAx4AAQEqAzIAAQDP/wYAAQErAzwAAQEaArAAAQEzAAAAAQIMA6IAAQKLA6IAAQEgAAAAAQHIAzwAAQIoA6IAAQLdAAAAAQMFAzIAAQDrAAAAAQFDAAoAAQEDAcwAAQEsAx4AAQEiAsQAAQEvAzIAAQEwAzwAAQErAu0AAQDP/xwAAQEfArEAAQEfArAAAQEuAysAAQEoAvQAAQEbAnIAAQEkAtcAAQDmAAAAAQFZAzIAAQFUAwAAAQFJArAAAQDfAAAAAQFIA6IAAQFwBOMAAQByAAAAAQB8AAAAAQDoAAoAAQCgAcwAAQDJAx4AAQC/AsQAAQDNAzwAAQC8ArEAAQC8ArAAAQBW/xwAAQDLAysAAQDFAvQAAQC4AnIAAQDBAtcAAQDGAAAAAQCfAcwAAQDMAzwAAQDzAAAAAQFHA6IAAQDX/xsAAQEbAcwAAQC8AAAAAQFGA6IAAQHSA6IAAQFsBNYAAQCNAAAAAQDjAzwAAQFBA6IAAQCg/xsAAQFvAAAAAQGZAcwAAQEzAcwAAQFcAx4AAQFfAzIAAQFUAtcAAQEmAAoAAQD/AcwAAQFMAcwAAQEoAx4AAQEeAsQAAQEsAzwAAQEnAu0AAQDD/xwAAQEbArEAAQEzA1cAAQEzA1YAAQEqAysAAQDrAcwAAQFyAwAAAQEUAx4AAQEWAysAAQEHAtcAAQEkAvQAAQEXAnIAAQClAcwAAQDOAx4AAQEgAtcAAQE4A30AAQFLAAAAAQGGAcwAAQB3AAAAAQEdAcwAAQFGAx4AAQFJAzIAAQBb/xsAAQFCAvQAAQDtAAAAAQEBAcwAAQEqAx4AAQEtAzIAAQDO/wYAAQEuAzwAAQDR/xsAAQD2AAAAAQFaA2kAAQH+A6IAAQDxAAAAAQD1Av0AAQFfA6IAAQDX/wYAAQDa/xsAAQDnAAAAAQG6AAoAAQEfAcwAAQGOAcwAAQFIAx4AAQE+AsQAAQFMAzwAAQE7ArEAAQDL/xwAAQFKAysAAQE7AtcAAQFEAvQAAQE3AnIAAQFKAywAAQFAAtcAAQEbAAAAAQF0AcwAAQGdAx4AAQGhAzwAAQGQArEAAQGQ/x0AAQF0/jkAAQEXAcwAAQFAAx4AAQFDAzIAAQEzArAAAQGBAAoAAQMhAAAAAQL9AzIAAQBbAAAAAQCRAAoAAQCmAcwAAQDPAx4AAQG2Ax4AAQDFAsQAAQDTAzwAAQDCArEAAQDCArAAAQA//xwAAQDRAysAAQDLAvQAAQC+AnIAAQDHAtcAAQEkAAoAAQD7AcwAAQEkAx4AAQEnAzIAAQEXArAAAQGDAAoAAQGnAcwAAQEcAAAAAQF1AcwAAQGeAx4AAQGiAzwAAQGRArEAAQDhAAAAAQEHAcwAAQEwAx4AAQEzAzIAAQEjArAAAQEJBHAAAQBx/xsAAQEjAAoAAQDS/wYAAQDV/xsAAQ9WD3IAAQAMAD4ADAAAAE4AAABUAAAAVAAAAFQAAABUAAAAVAAAAE4AAABUAAAAVAAAAFQAAABUAAAAVAANACgALgAuADQAOgBAAEYATABSADQAWABeAGQAAf6XAAAAAf6WAAAAAf57/xwAAf56/xsAAf53/wYAAf50/tgAAf6C/1oAAf56/xgAAf56/xcAAf50/uwAAf55/v8AAf6B/1YAAQDP/wYAAQ7oDwQAAQAMANIAMQAAAR4AAAEeAAABHgAAAR4AAAEeAAABJAAAAR4AAAEeAAABHgAAAR4AAAEkAAABJAAAAR4AAAEeAAABHgAAAR4AAAEeAAABHgAAAR4AAAEeAAABHgAAAR4AAAEeAAABHgAAAR4AAAEeAAABJAAAASQAAAEeAAABHgAAAR4AAAEeAAABHgAAAR4AAAEeAAABHgAAAR4AAAEqAAABKgAAASoAAAEqAAABHgAAAR4AAAEeAAABHgAAASoAAAEqAAABKgAAASoAKwBqAHAAdgB2AHYAfACCAIgAjgCUAJoAoAB2AKYArACsALIAuAC+AL4AvgDEAL4AygCOANAA1gDcAKwAygDiAOgA7gD0APoBAAEGAQwA7gDuAOgBEgEYAAH+zgHMAAH+zwHMAAH+zgHRAAH+6gKxAAH+6gKwAAH+9wMeAAH+/AM8AAH++gMyAAH+7QLEAAH++QMsAAH+7wLXAAH+5wJyAAH++gMrAAH+8wL0AAH+9QMAAAH+6gK1AAH+6wK0AAH+9AMAAAH+9gMNAAH+7wLNAAH+8ALbAAH+6AJ2AAH+9gMJAAH+8QLgAAEBPwJyAAEBTwMeAAEBRQLEAAEBUgMyAAEBVAM8AAEBQgKxAAEBQgKwAAEBUQMsAAEBRwLXAAENPA1GAAEADAAaAAMAAAAUAAAAFAAAABQAAgAMABIAAf7PAcwAAf71AwAAAf7YAhQAAQzGDRwAAQAMANIAMQAAAMwAAADMAAAAzAAAAMwAAADMAAAA0gAAAMwAAADMAAAAzAAAAMwAAADSAAAA0gAAAMwAAADMAAAAzAAAAMwAAADMAAAAzAAAAMwAAADMAAAAzAAAAMwAAADMAAAAzAAAAMwAAADMAAAA0gAAANIAAADMAAAAzAAAAMwAAADMAAAAzAAAAMwAAADMAAAAzAAAAMwAAADYAAAA2AAAANgAAADYAAAAzAAAAMwAAADMAAAAzAAAANgAAADYAAAA2AAAANgAAgAYAB4AAf7OAcwAAf7PAcwAAf7OAdEAAf7tAsQAAf8DAs0AAQvQDC4AAQAMANIAMQAAAOgAAADoAAAA6AAAAOgAAADoAAAA7gAAAOgAAADoAAAA6AAAAOgAAADuAAAA7gAAAOgAAADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADoAAAA7gAAAO4AAADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAAD0AAAA9AAAAPQAAAD0AAAA6AAAAOgAAADoAAAA6AAAAPQAAAD0AAAA9AAAAPQAEAA0ADoAQABGAEwATABMAEwANAA6AEAARgBMAEwATABMAAH+zgHMAAH+zwHMAAH+zgHRAAH/BAOLAAH/GAOLAAH+7QOIAAH/BAOOAAH+9gLyAAIAAwUqBTAAAAUyBTMABwVSBVIACQACAAcFPgU+AAAFQAVEAAEFRgVQAAYFUgVSABEFVAVhABIFfgV/ACAFgQWBACIAAQABBZ0AAgABBSoFMwAAAAIATgAEABwAAAAnACcAGQBAAEAAGgBHAEcAGwBJAEkAHABcAFwAHQBeAGEAHgBjAGUAIgBnAGoAJQBsAGwAKQCdAL0AKgDHAMoASwDMAOQATwEHAQcAaAERARIAaQEUAR8AawEnAScAdwEpASkAeAEsAS0AeQEvATIAewE0ATQAfwE/AV4AgAF2AXYAoAF5AXkAoQGEAYQAogGPAY8AowGRAZIApAGZAZkApgGcAZwApwGnAacAqAGpAakAqQG2AbYAqgG5AbkAqwG9Ab4ArAHBAcEArgHEAcQArwHIAcwAsAHOAc4AtQHcAdwAtgHfAd8AtwI4AjgAuAI8AjwAuQI+Aj4AugJBAkIAuwJMAk0AvQJXAlkAvwJdAl0AwgJgAmAAwwJjAmMAxAJuAm4AxQJ6AnoAxgJ8An0AxwJ/An8AyQKDAoUAygKHAocAzQKKAooAzgKOApIAzwKUApQA1AKgAqAA1QKiAqIA1gKlAqUA1wK0ArQA2AK6ArsA2QLUAtgA2wLrAusA4AMFAwUA4QMQAxAA4gMTAxMA4wMyAzIA5AM1AzYA5QM6AzoA5wM9Az0A6ANDA0MA6QU8BTwA6gVMBUwA6wVOBU4A7AVQBVIA7QVdBWAA8AACAGwABAFsAAABqgGvAWkBwgHEAW8BzQHNAXIB1gHWAXMCKAIwAXQCNQJNAX0CWAJZAZYCbwKKAZgCkwKTAbQClQKdAbUCvwK/Ab4CzQLPAb8C2QLtAcIC9QMCAdcDCQMJAeUDCwMLAeYDLgMxAecDOAM5AesDOwM8Ae0DPgNAAe8DRANEAfIDRgNGAfMDSgNNAfQDUANVAfgDWANdAf4DYQNhAgQDYwNmAgUDaQNpAgkDbANxAgoDcwN1AhADeAN5AhMDewN7AhUDfgOMAhYDjwOSAiUDlAOUAikDlgOXAioDmgOfAiwDowOoAjIDrgOuAjgDsAOxAjkDtAO1AjsDtwO4Aj0DugO6Aj8DvAO9AkADwAPDAkIDxgPLAkYDzgPTAkwD1gPXAlID2gPaAlQD3wPfAlUD4gPnAlYD6QPrAlwD7gPvAl8D8QPxAmED9AP3AmID+wQAAmYECAQKAmwEDAQMAm8EDwQPAnAEEgQXAnEEGwQgAncEJQQnAn0EKQQpAoAELAQtAoEELwQvAoMENgQ2AoQEOwQ7AoUESgRLAoYETwRPAogEUQRRAokEXQRdAooEYQRhAosEaQRpAowEcARwAo0EcwRzAo4EdwR3Ao8EegR6ApAEjQSOApEElQSXApMEpgSmApYErASsApcEsQS1ApgEugS6Ap0EvAS8Ap4EvwTBAp8ExQTIAqIEywTLAqYE0QTUAqcE1gTXAqsE3QTdAq0E3wTfAq4E5ATmAq8E6QTpArIE7QTtArME8ATyArQE+gT7ArcE/gT/ArkFBQUIArsFDQUPAr8FEQUTAsIFGAUYAsUFHAUdAsYFIAUhAsgFJwUnAsoFUQVRAssFUwVTAswFlgWWAs0AAQACA0MFPAACAAgFPgU+AAAFQAVEAAEFRgVIAAYFSwVQAAkFUgVSAA8FVAVhABAFfgV/AB4FgQWBACAAAgBDAW0BqQAAAbABwQA9AcUBzABPAc4B1QBXAdcCJwBfAjECNACwAk4CVwC0AloCbgC+AosCkgDTApQClADbAp4CvgDcAsACzAD9AtAC2AEKAu4C9AETAwMDCAEaAwoDCgEgAwwDLQEhAzIDNwFDAzoDOgFJAz0DPQFKA0EDQQFLBDAEMgFMBDcEOgFPBDwESQFTBEwETgFhBFAEUAFkBFIEVgFlBFgEXAFqBF4EYAFvBGIEZQFyBGoEbwF2BHEEcgF8BHQEdQF+BHgEeQGABHsEfQGCBH8EiQGFBIwEjAGQBI8EkwGRBJgEmAGWBJoEmgGXBJ0EpQGYBKgEqgGhBK0EsAGkBLYEtwGoBLsEuwGqBL0EvgGrBMIExAGtBM4E0AGwBNUE1QGzBNkE2wG0BN4E3gG3BOAE4wG4BOcE6AG8BOoE7AG+BO4E7wHBBPQE9QHDBPcE+AHFBPwE/AHHBQAFBAHIBQkFDAHNBRAFEAHRBRQFFgHSBRkFGQHVBRsFGwHWBR4FHwHXBSIFJQHZBSgFKQHdAAEAAgWdBaIAAQAHBDMENAQ1BGcEmQSbBKsAAgAHBaQFqAAABaoFswAFBbUFuAAPBboFywATBc0F0AAlBdIF0wApBeMF9AArAAEAAQWiAAIAAgWkBdMAAAXjBfQAMAABAQEDRANHA0gDSgNLA0wDTQNOA08DUANRA1IDUwNUA1UDVgNYA1kDWgNcA10DXgNfA2IDZgNpA2wDbQNuA28DcANxA3cDeAN6A30DfwOAA4EDgwOEA4YDhwONA5ADkQOSA5MDlQOXA5gDmgObA5wDnQOeA58DoAOhA6MDpAOlA6YDpwOoA6kDqgOrA6wDrQOuA68DswO1A7gDuQO6A70DvgPAA8EDwgPDA8QDxQPGA8cDyAPJA8oDywPOA88D0gPTA9QD1QPYA9wD3wPiA+MD5APlA+YD5wPuA/AD8QPzA/UD9gP3A/kD/AP9BAMECAQJBAoECwQPBBAEEgQTBBQEFQQWBBcEGAQZBBsEHAQdBB4EHwQgBCEEIgQjBCQEJQQmBC0EMAQzBDQENgQ3BDgEOQQ6BDsEPAQ9BD4EPwRABEEERQRGBEgESQRKBEsETgRSBFUEWARaBFsEXARfBGYEaQRyBHsEfAR9BH8EhASGBIcEiASJBIoEiwSMBI0EjwSQBJEEkgSTBJQElQSWBJcEmASaBKEEpgSpBKoErAStBK4ErwSwBLEEsgSzBLQEtQS2BLcEuwS8BL4EvwTABMEExATIBMsEzgTRBNIE2gTcBO8E8QT0BPUE9wT8BP4E/wUABQEFAwUEBQUFBwUIBQkFCgULBQwFDQUOBQ8FEAUSBRkFHgUgAAIAQAAEAB4AAAAgACcAGwApACkAIwArAD8AJABBAEcAOQBJAFwAQABeAGIAVABkAGkAWQBrAIsAXwCPAJoAgACcALYAjAC4ALwApwC/AOYArADoAO8A1ADxAPEA3ADzAQYA3QEIAQ4A8QEQASoA+AEsATEBEwEzATUBGQE5AVgBHAFaAV4BPAFgAYEBQQGDAYcBYwGJAY8BaAGRAZEBbwGTAaUBcAGnAacBgwGqAbABhAGyAb8BiwHBAcEBmQHDAcsBmgHNAc0BowHPAdQBpAHWAfABqgHyAfYBxQH6AgUBygIHAgcB1gIJAh0B1wIfAiAB7AIiAiYB7gIoAkkB8wJLAk8CFQJRAlgCGgJaAmwCIgJuAnUCNQJ3AocCPQKJApECTgKTApMCVwKVApoCWAKcArYCXgK4ArwCeQLAAssCfgLNAs0CigLQAtQCiwLWAuoCkALsAu0CpQLvAvMCpwL1AwICrAMEAwQCugMGAwkCuwMMAyQCvwMmAykC2AMrAzEC3AACAAQFtQW4AAAFugW7AAQFzQXQAAYF0gXTAAoAAQANBbUFtgW3BbgFugW7Bc0FzgXPBdAF0gXTBdkAAgAEBaQFqAAABaoFswAFBbwFywAPBeMF9AAfAAIABgWkBagAAAWqBbMABQW8BcsADwXVBdgAHwXaBd8AIwXhBeIAKQABAAMFqQW0BcwAAQACBbQFzAABAAIF4wXkAAIAAQXlBfQAAAACABUFPgU+AAUFQAVAAAEFQQVCAAYFQwVDAAIFRAVEAAMFRgVGAAYFRwVHAAcFSAVIAAgFSQVKAAoFSwVLAAEFTAVMAAsFTQVNAAYFTwVPAAUFUgVSAAwFVAVXAAUFWAVbAAQFXAVcAAYFXQVgAAkFYQVhAAYFfgV/AAUFgQWBAAUAAQUqAGIABgASABQAGAAEABcADAATAAMACwAAAAAAAAAAAAAAAAAAAAAAAAAKABAAGQANAA8ADwARAA4AAAAPABYAAgAVABUADQAJAA8ABwABAAAAAQAAAAUABwAHAAcABwAAAAAAAAAAAA8ACAAIAAgACAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAHAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAHAAIAAAABBSoACgAGAAAABQAAAAIAAAAEAAAAAQADAAEFKgAKAAkABAAIAAcAAgABAAYABQAAAAMAAgAUA0IDQwABBTwFPAABBUAFQAAHBUEFQgADBUYFRgADBUkFSgAEBUsFSwAHBUwFTAAJBU0FTQADBU4FTgAFBU8FTwAGBVEFUQAGBVQFVwAFBVgFWwAIBVwFXAADBWEFYQADBX4FfwAFBYEFgQAFBYsFiwAFBZ0FnQACAAIA9wAEABwAFgAfAB8AAwAgACUABQAmACYAFwAnACcAJgAoACoAFwArACsAKgAsAD8ABwBAAEAACQBBAEYAKABHAEcADQBIAEgADgBJAEkADQBKAFcADwBYAFkAEQBaAFsAEgBcAFwAFABdAF0AEQBeAGEAFABiAGIAKABjAGMAFABkAGUAFgBmAGYAEQBnAGoAFgBrAGsAKABsAGwAFgBtAIoAFwCMAIwAGACNAI0AHwCOAI4AFwCPAJQAGgCVAJoAHACbAJsADACcAJwAFwCdAKEAHQCiALYAFgC3ALwAIQC9AL0AIwC+AMYAKADHAMoAJgDLAMsAJQDMAOQAAgDlAOYAAQDnAOcABADoAO0ABgDuAO4AFwDvAO8AJwDwAPIAFwDzAQYACAEHAQcACgEIAQ0ACwEOARAADgERARIAEAETARMAJQEUAR8AEAEgASEAEQEiASMAEwEkASQAFQElASUAEQEmASkAFQEqASoAKQErASsAFQEsAS0AEAEuAS4AEQEvATIAEAEzATMAKQE0ATQAEAE1ATUAAQE2ATcAGQE4ATgAFwE5AT4AGwE/AUMAHgFEAUwAEAFNAVIAIAFTAVgAEAFZAV4AIgFfAV8AJAFgAWgAJQFpAWwAJwGqAa8AKAHCAcQAKAHNAc0AKAHWAdYAKAIoAjAAKAI1Ak0AKQJYAlkAKQJvAnoAKQJ7AnsAKAJ8AooAKQKTApMAKQKVAp0AKQK/Ar8AKQLNAs8AKQLZAu0AKQL1Av0AKQL+AwEAKgMCAwIAKAMJAwkAKAMLAwsAKAMuAzEAKAM4AzkAKQM7AzwAKQM+Az4AJQM/A0AAKANEA0QAFgNGA0YAAwNKA0oAFwNLA00ABwNQA1MAFgNUA1UAEgNYA1gADQNZA1kAFwNaA1oAFgNbA1sAGANcA1wABQNdA10AHQNhA2EAIwNjA2YAFgNpA2kADwNsA2wAHANtA20ABQNuA24AFwNvA3AADwNxA3EAEQNzA3MAFwN0A3QAFgN1A3UAKAN4A3gAFwN5A3kAIQN7A3sAKAN+A4EAEgOCA4MADQOEA4QAFgOFA4YABQOHA4cAHQOIA4kAIgOKA4oAIwOLA4wAFgOPA48AFgOQA5EABQOSA5IADwOUA5QAEgOWA5cADQOaA5sAFgOdA50ABwOeA58AFwOjA6QAFgOlA6gAFwOuA64ADwOwA7EAIwO0A7QAFwO1A7UAIQO3A7cAGAO4A7gADQO6A7oAAgO8A7wABAO9A70AHgPAA8AAFwPBA8MACAPGA8kAEAPKA8sAEwPOA84ADgPPA88AFwPQA9AADgPRA9EAGQPSA9IABgPTA9MAHgPWA9YAFwPXA9cAJAPaA9oAEAPfA98AEAPiA+IAHAPjA+MABgPkA+QAFwPlA+YAEAPnA+cAEQPpA+kAFwPqA+oAEAPrA+sAKAPuA+4AFwPvA+8AIgPxA/EADgP0A/cAEwP7A/sABQP8A/wABgP9A/0AHgP+A/8AIgQABAAAJAQIBAkABgQKBAoAEAQMBAwAEwQPBA8ADgQSBBMAAgQUBBQAAQQVBBUACAQWBBcAFwQbBBwAEAQdBCAAFwQlBCUAHgQmBCYAEAQnBCcAHgQpBCkAJAQsBCwAFwQtBC0AIgQvBC8AGQQ2BDYAKAQ7BDsAKARKBEsAKARPBE8AKARRBFEAKARdBF0AKARhBGEAKARpBGkAKARwBHAAKARzBHMAKAR3BHcAKAR6BHoAKASNBI4AKASVBJcAKASmBKYAKQSsBKwAKQSxBLUAKQS6BLoAKQS8BLwAKQS/BMEAKQTFBMgAKQTLBMsAKQTRBNQAKQTWBNcAKQTdBN0AKQTfBN8AKQTkBOYAKQTpBOkAKQTtBO0AKQTwBPIAKQT6BPsAKQT+BP8AKQUFBQgAKQUNBQ8AKQURBRMAKQUYBRgAKQUcBR0AKQUgBSEAKQUnBScAFwVRBVEAEAVTBVMAFwWWBZYAFwACAUIAHwAfACYAIAAlABAAQQBGABAASABIACcAWABZACAAbQCLABAAjgCOABAAlQCaACMAnACcABAAtwC8ABIAzADmABAA6ADtABAA8wEGACIBBwEHACcBCAENABABDgEQACcBIAEhAA8BIgEjACcBNQE1ABABNgE2ACcBOAE4ABABOQE+ACcBPwFDABEBWQFeABIBXwFfABwBaQFsACQBbQGHAAEBiAGIACUBiQGOAAgBjwGPAAEBkAGQAAgBkQGTAAEBlAGoAAgBqQGpABMBqgGvAAEBsAGyABQBswHBABYBwgHEAB4BxQHGABQBxwHHABYByAHJACUBygHKABUBywHOACUBzwHXABYB2AH2AAgB9wH3ABcB+AH4ABkB+QH5AAEB+gH/ABYCAAIFAAwCBgIGAB0CBwILAA0CDAIgABYCIQImABoCJwInAB8CKAIwABYCMQI0ABsCNQJPAAECUAJQACUCUQJWAAgCVwJaAAECWwJuAAgCbwJ0AAECdQJ3ABQCeAKHABYCiAKKAB4CiwKMABQCjQKNABYCjgKUACUClQKdABYCngK8AAgCvQK9ABcCvgK+ABkCvwK/AAECwALFABYCxgLLAAwCzALMAB0CzQLNABUCzgLOABYCzwLPABcC1ALYAA0C2QLtABYC7gLzABoC9AL0AB8C9QL9ABYDAgMCABYDAwMDACUDBAMEAAEDBgMKABUDCwMLABYDDAMpAAgDKgMqABcDKwMtAA0DMgMyABMDNQM1ABMDNgM2ACUDNwM3AA0DOgM6ABMDPAM8ABYDPQM9AA0DQANAABYDQQNBAA0DQgNDAAIDRgNGACYDWQNZABADXANcABADbANsACMDbQNtABADcQNxACADeAN4ABADeQN5ABIDhQOGABADiAOJABIDngOfABADpQOnABADtAO0ABADtQO1ABIDugO6ABADuwO7ACcDvQO/ACcDwQPDACIDygPLACcDzgPOACcDzwPPABAD0APRACcD0gPSABAD0wPTABED1gPWABAD1wPXABwD3QPdACcD3wPfACcD4QPhACcD4gPiACMD4wPjABAD5wPnAA8D6APoABED6QPpACcD6wPrABED7gPuABAD7wPvABID8QPxACcD9AP2ACcD+AP6ACcD+wP8ABAD/QP9ABED/gP/ABIEAAQAABwEBgQGACcEDAQMACcEDgQPACcEEgQUABAEFQQVACIEFgQXABAEHQQfABAEJQQoACcEKQQpABwELAQsABAELQQtABIELwQvACcEMAQxAAEEMgQyACUEMwQ0ABsENQQ1ABYENgQ2AAEENwQ5AAgEOgQ6AB8EPARBABYERAREABYERQRFAAgERgRGABYERwRHABcESARIAAgESQRLABYETARMAAEETQRNAB8ETgROAAwETwRTABYEVQRVABYEVwRXABYEWARYAAwEWQRZAAgEWgRaAB8EWwRcABYEXQRdAB4EXgReABQEXwRfABYEYQRhABQEYgRiAA0EYwRjAB8EZARkAAgEZQRlABoEZgRnABsEaARoAB8EagRrABYEbARsABQEbgRwABYEcQRyAAgEcwRzABYEdAR1ABoEdgR2AB8EdwR3ABYEeAR5AAwEegR7ABQEfwR/AB8EgASAABYEggSDABYEhASEAAwEhgSIAAEEiQSJAAgEjASMAB8EjwSQABYEkQSTAAgElQSXABYEmASYAAwEmQSZABsEmgSaABYEmwSbABsEnASdAB8EngSeAAgEoASgAAEEoQShABoEogSiAA0EowSjABcEpASkABYEpgSnAAEEqASoACUEqQSqABsEqwSrABYErASsAAEErQSvAAgEsASwAB8EsgS3ABYEugS6ABYEuwS7AAgEvAS8ABYEvQS9ABcEvgS+AAgEvwTBABYEwgTCAAEEwwTDAB8ExATEABsExQTJABYEywTLABYEzQTNABYEzgTOAAwEzwTPAAgE0ATQAB8E0QTSABYE0wTTAB4E1ATUABQE1QTVABYE1wTXABQE2ATYAA0E2QTZAB8E2gTaAAgE2wTbABoE3ATdABsE3gTeAB8E4ATiABYE5ATmABYE5wToAAgE6QTpABYE6gTrABoE7ATsAB8E7QTtABYE7gTvABsE8ATxABQE8gTyABYE9wT3AB8E+AT4ABYE+gT7ABYE/AT8ABsE/gUAAAEFAQUBAAgFBAUEAB8FBwUIABYFCQULAAgFDAUMAB8FDQUPABYFEAUQAAwFEQURABsFEgUSABYFEwUTABsFFAUVAB8FFgUWAAgFGAUYAAEFGQUZABoFGgUaAA0FGwUbABcFHAUhABYFIgUiAB8FIwUjABYFJAUkAB8FJQUlABYFJwUnABAFKAUpABYFPAU8AAIFQAVAAAQFQQVCAAkFQwVDAAUFRgVGAAkFRwVHAAoFSwVLAAQFTAVMABgFTQVNAAkFTgVOAAcFTwVPAAMFUQVRAAMFUgVSABAFUwVTAA4FVAVXAAcFWAVbAAYFXAVcAAkFXQVgAAsFYQVhAAkFfgV/AAcFgQWBAAcFiwWLAAcFkgWSAAgFlgWWABAFnQWdACEF+QX5ABsAAgEfAAQAHgABAB8AHwACACAAJQAOACYAJgADACkAKQADACwAPwAEAEAAQAAGAEEARgAOAEcARwAHAEgASAAIAEkASQAHAEoAVwAJAFoAWwALAFwAYwAMAGQAbAANAG0AiwAOAI4AjgAOAJUAmgAPAJwAnAAOAJ0AoQAQAKIAtgASAL0AvQATAL4AxgAVAMcAygAWAMwA5gAOAOgA7QAOAPMBBgAFAQcBBwAIAQgBDQAOAQ4BEAAIASABIQAKASIBIwAIATUBNQAOATYBNgAIATgBOAAOATkBPgAIAT8BQwARAV8BXwAUAWkBbAAXAW0BhwAYAYkBjgAfAY8BjwAYAZABkAAfAZEBkwAYAZQBqAAfAaoBrwAYAbMBwQAeAccBxwAeAc8B1wAeAdgB9gAfAfkB+QAYAfoB/wAeAgACBQAiAgwCIAAeAigCMAAeAjECNAAkAjUCTwAYAlECVgAfAlcCWgAYAlsCbgAfAm8CdAAYAngChwAeAo0CjQAeApUCnQAeAp4CvAAfAr8CvwAYAsACxQAeAsYCywAiAs4CzgAeAtkC7QAeAvUC/QAeAwIDAgAeAwQDBAAYAwsDCwAeAwwDKQAfAzwDPAAeA0ADQAAeA0IDQwAZA0QDRAABA0UDRQAQA0YDRgACA0cDSQAQA0oDSgADA0sDTQAEA1ADUwASA1QDVQALA1gDWAAHA1kDWQAOA1oDWgAQA1wDXAAOA10DXQAQA2EDYQATA2MDZgASA2cDZwAJA2kDaQAJA2sDawAHA2wDbAAPA20DbQAOA28DcAAJA3IDcgAQA3MDcwAHA3UDdQAQA3YDdgAJA3gDeAAOA3oDewAQA34DgQALA4IDgwAHA4QDhAAQA4UDhgAOA4cDhwAQA4oDigATA4sDiwAQA5IDkgAJA5QDlAALA5YDlwAHA5oDnAABA50DnQAEA54DnwAOA6MDpAASA6UDpwAOA60DrQAQA64DrgAJA68DrwAQA7ADsQATA7QDtAAOA7YDtgAJA7gDuAAHA7oDugAOA7sDuwAIA70DvwAIA8ADwAADA8EDwwAFA8oDywAIA84DzgAIA88DzwAOA9AD0QAIA9ID0gAOA9MD0wARA9YD1gAOA9cD1wAUA90D3QAIA98D3wAIA+ED4QAIA+ID4gAPA+MD4wAOA+cD5wAKA+gD6AARA+kD6QAIA+sD6wARA+wD7AAJA+4D7gAOA/AD8AAHA/ED8QAIA/QD9gAIA/gD+gAIA/sD/AAOA/0D/QARBAAEAAAUBAYEBgAIBAwEDAAIBA4EDwAIBBIEFAAOBBUEFQAFBBYEFwAOBB0EHwAOBCUEKAAIBCkEKQAUBCwELAAOBC4ELgAJBC8ELwAIBDAEMQAYBDMENAAkBDUENQAeBDYENgAYBDcEOQAfBDwEQQAeBEQERAAeBEUERQAfBEYERgAeBEgESAAfBEkESwAeBEwETAAYBE4ETgAiBE8EUwAeBFUEVQAeBFcEVwAeBFgEWAAiBFkEWQAfBFsEXAAeBF8EXwAeBGQEZAAfBGYEZwAkBGoEawAeBG4EcAAeBHEEcgAfBHMEcwAeBHcEdwAeBHgEeQAiBIAEgAAeBIIEgwAeBIQEhAAiBIYEiAAYBIkEiQAfBI8EkAAeBJEEkwAfBJUElwAeBJgEmAAiBJkEmQAkBJoEmgAeBJsEmwAkBJ4EngAfBKAEoAAYBKQEpAAeBKYEpwAYBKkEqgAkBKsEqwAeBKwErAAYBK0ErwAfBLIEtwAeBLoEugAeBLsEuwAfBLwEvAAeBL4EvgAfBL8EwQAeBMIEwgAYBMQExAAkBMUEyQAeBMsEywAeBM0EzQAeBM4EzgAiBM8EzwAfBNEE0gAeBNUE1QAeBNoE2gAfBNwE3QAkBOAE4gAeBOQE5gAeBOcE6AAfBOkE6QAeBO0E7QAeBO4E7wAkBPIE8gAeBPgE+AAeBPoE+wAeBPwE/AAkBP4FAAAYBQEFAQAfBQcFCAAeBQkFCwAfBQ0FDwAeBRAFEAAiBREFEQAkBRIFEgAeBRMFEwAkBRYFFgAfBRgFGAAYBRwFIQAeBSMFIwAeBSUFJQAeBScFJwAOBSgFKQAeBSoFKgAtBSsFKwAoBS0FLQAsBS8FLwAmBTAFMAArBTEFMQAqBTIFMgAlBTMFMwAnBTwFPAAZBT4FPgApBUAFQAAaBUEFQgAgBUMFQwAbBUQFRAAcBUYFRgAgBUgFSAAhBUsFSwAaBUwFTAAjBU0FTQAgBVIFUgAOBVgFWwAdBVwFXAAgBWEFYQAgBZIFkgAfBZYFlgAOBfkF+QAkAAIAFAU+BT4ABQVABUAAAQVBBUIABgVDBUMAAgVEBUQAAwVGBUYABgVHBUcABwVIBUgACAVLBUsAAQVMBUwACgVNBU0ABgVPBU8ABQVSBVIACwVUBVcABQVYBVsABAVcBVwABgVdBWAACQVhBWEABgV+BX8ABQWBBYEABQACAYwABAAeABEAHwAfAC0AIAAlABkAJgAmAC4AJwAnABYAKAAoABQAKQApAC4AKgAqABQAKwArABYALAA/ABIAQABAAAEAQQBGABkARwBHAAIASABIABUASQBJAAIASgBXAAMAWABZABcAWgBbABgAXABjAAQAZABsAAUAbQCLABkAjACMABoAjQCNABsAjgCOABkAjwCUABsAlQCaABwAmwCbABYAnACcABkAnQChAB0AogC2AAcAtwC8AB4AvQC9AAgAvgDGAAoAxwDKAAsAywDLABYAzADmABkA5wDnABYA6ADtABkA7gDyABYA8wEGABMBBwEHABUBCAENABkBDgEQABUBEQEfABYBIAEhACEBIgEjABUBJAE0ABYBNQE1ABkBNgE2ABUBOAE4ABkBOQE+ABUBPwFDAAYBRAFYABYBWQFeAB4BXwFfAAkBYAFoABYBaQFsAAwBbQGHACIBiAGIACMBiQGOACQBjwGPACIBkAGQACQBkQGTACIBlAGoACQBqQGpACgBqgGvACIBsAGyACoBswHBACsBwgHEAA8BxQHGACoBxwHHACsByAHJACMBygHKADEBywHOACMBzwHXACsB2AH2ACQB9wH3ABAB+AH4AC8B+QH5ACIB+gH/ACsCAAIFAB8CBgIGACkCBwILACACDAIgACsCIQImACwCJwInACcCKAIwACsCMQI0ACUCNQJPACICUAJQACMCUQJWACQCVwJaACICWwJuACQCbwJ0ACICdQJ3ACoCeAKHACsCiAKKAA8CiwKMACoCjQKNACsCjgKUACMClQKdACsCngK8ACQCvQK9ABACvgK+AC8CvwK/ACICwALFACsCxgLLAB8CzALMACkCzQLNADECzgLOACsCzwLPABAC0ALTADIC1ALYACAC2QLtACsC7gLzACwC9AL0ACcC9QL9ACsC/gMBACYDAgMCACsDAwMDACMDBAMEACIDBQMFAA4DBgMKADEDCwMLACsDDAMpACQDKgMqABADKwMtACADLgMxADIDMgMyACgDMwM0ADADNQM1ACgDNgM2ACMDNwM3ACADOAM5ADADOgM6ACgDOwM7ADADPAM8ACsDPQM9ACADPgM+ABYDPwM/ADADQANAACsDQQNBACADQgNDAA0DRANEABEDRQNFAB0DRgNGAC0DRwNJAB0DSgNKAC4DSwNNABIDUANTAAcDVANVABgDWANYAAIDWQNZABkDWgNaAB0DWwNbABoDXANcABkDXQNdAB0DYQNhAAgDYwNmAAcDZwNnAAMDaQNpAAMDawNrAAIDbANsABwDbQNtABkDbwNwAAMDcQNxABcDcgNyAB0DcwNzAAIDdQN1AB0DdgN2AAMDeAN4ABkDeQN5AB4DegN7AB0DfgOBABgDggODAAIDhAOEAB0DhQOGABkDhwOHAB0DiAOJAB4DigOKAAgDiwOLAB0DjgOPABYDkgOSAAMDlAOUABgDlgOXAAIDmgOcABEDnQOdABIDngOfABkDowOkAAcDpQOnABkDrQOtAB0DrgOuAAMDrwOvAB0DsAOxAAgDtAO0ABkDtQO1AB4DtgO2AAMDtwO3ABoDuAO4AAIDugO6ABkDuwO7ABUDvAO8ABYDvQO/ABUDwAPAAC4DwQPDABMDxgPJABYDygPLABUDzgPOABUDzwPPABkD0APRABUD0gPSABkD0wPTAAYD1gPWABkD1wPXAAkD2QPcABYD3QPdABUD3wPfABUD4QPhABUD4gPiABwD4wPjABkD5QPmABYD5wPnACED6APoAAYD6QPpABUD6wPrAAYD7APsAAMD7gPuABkD7wPvAB4D8APwAAID8QPxABUD9AP2ABUD+AP6ABUD+wP8ABkD/QP9AAYD/gP/AB4EAAQAAAkEBAQFABYEBgQGABUECgQKABYEDAQMABUEDgQPABUEEgQUABkEFQQVABMEFgQXABkEGwQcABYEHQQfABkEJQQoABUEKQQpAAkELAQsABkELQQtAB4ELgQuAAMELwQvABUEMAQxACIEMgQyACMEMwQ0ACUENQQ1ACsENgQ2ACIENwQ5ACQEOgQ6ACcEPARBACsERAREACsERQRFACQERgRGACsERwRHABAESARIACQESQRLACsETARMACIETQRNACcETgROAB8ETwRTACsEVQRVACsEVwRXACsEWARYAB8EWQRZACQEWgRaACcEWwRcACsEXQRdAA8EXgReACoEXwRfACsEYQRhACoEYgRiACAEYwRjACcEZARkACQEZQRlACwEZgRnACUEaARoACcEagRrACsEbARsACoEbgRwACsEcQRyACQEcwRzACsEdAR1ACwEdgR2ACcEdwR3ACsEeAR5AB8EegR7ACoEfwR/ACcEgASAACsEggSDACsEhASEAB8EhgSIACIEiQSJACQEjASMACcEjwSQACsEkQSTACQElQSXACsEmASYAB8EmQSZACUEmgSaACsEmwSbACUEnASdACcEngSeACQEoASgACIEoQShACwEogSiACAEowSjABAEpASkACsEpgSnACIEqASoACMEqQSqACUEqwSrACsErASsACIErQSvACQEsASwACcEsgS3ACsEugS6ACsEuwS7ACQEvAS8ACsEvQS9ABAEvgS+ACQEvwTBACsEwgTCACIEwwTDACcExATEACUExQTJACsEywTLACsEzQTNACsEzgTOAB8EzwTPACQE0ATQACcE0QTSACsE0wTTAA8E1ATUACoE1QTVACsE1wTXACoE2ATYACAE2QTZACcE2gTaACQE2wTbACwE3ATdACUE3gTeACcE4ATiACsE5ATmACsE5wToACQE6QTpACsE6gTrACwE7ATsACcE7QTtACsE7gTvACUE8ATxACoE8gTyACsE9wT3ACcE+AT4ACsE+gT7ACsE/AT8ACUE/gUAACIFAQUBACQFBAUEACcFBwUIACsFCQULACQFDAUMACcFDQUPACsFEAUQAB8FEQURACUFEgUSACsFEwUTACUFFAUVACcFFgUWACQFGAUYACIFGQUZACwFGgUaACAFGwUbABAFHAUhACsFIgUiACcFIwUjACsFJAUkACcFJQUlACsFJwUnABkFKAUpACsFPAU8AA0FUAVQABYFUgVSABkFkgWSACQFlgWWABkFogWiABYF+QX5ACUAAgCLAW0BhQALAYYBhwACAYgBiAAMAY8BjwAJAZABkAADAZEBkgALAZMBkwAVAZQBpwACAagBqAANAakBqQAEAbABwQALAcUBxwAHAcgByQAJAcoBygALAcsBzAAJAc4BzgAJAc8B1QALAdcB1wALAdgB9QAMAfYB9gACAfcB+AALAfkB+QAPAfoB/wAQAgACBQALAgYCBgAFAgcCCwATAgwCIAALAiECJgAMAjECNAAVAk4CTwABAlACUAANAlECVgABAlcCVwAKAloCWgAWAlsCbgABAosCjAAIAo0CjQABAo4CkgAKApQClAAKAp4CuwANArwCvAABAr0CvgANAsACxQARAsYCywASAswCzAAGAtAC0wAWAtQC2AAKAu4C8wAUAvQC9AABAwMDAwAMAwQDBAALAwUDBQAEAwYDCAALAwoDCgALAwwDKQAOAyoDKgALAysDLQATAzIDMgAEAzMDNAALAzUDNgAJAzcDNwATAzoDOgAKAz0DPQATA0EDQQATBDAEMAALBDEEMgAMBDcEOQACBDwEPwALBEAEQQAHBEQERAALBEUERQAMBEYERwALBEkESQALBEwETAALBE4ETgAVBFAEUAALBFIEVgALBFgEWAALBFoEWgAMBFsEXAALBF4EXgALBF8EXwAMBGAEYAALBGQEZQAMBGoEbQAHBG4EbwALBHQEdQAMBHgEeQAVBHsEewALBHwEfQACBIAEgAAHBIIEgwALBIQEhAAVBIYEiAALBIkEiQACBI8EkAALBJEEkwAMBJgEmAAVBJoEmgALBKAEoAAPBKEEoQAMBKMEpAALBKgEqAANBKkEqgABBK0EsAABBLYEtwABBLsEuwANBL0EvQANBL4EvgABBMIEwgANBMMExAABBM4EzgASBM8EzwABBNAE0AANBNUE1QANBNkE2QABBNoE2gANBNsE2wAUBN4E3gABBOAE4wABBOcE6AABBOoE6wAUBOwE7AABBO4E7wABBPQE9QABBPcE+AABBPwE/AABBQAFAQABBQIFAwANBQQFBAABBQkFDAANBRAFEAAVBRQFFgABBRkFGQAUBRsFGwANBR4FHwALBSMFIwAHBSQFJQABBSgFKQALAAIA5wFtAYcAAQGIAYgAGgGJAY4AFgGPAY8AAQGQAZAAFgGRAZMAAQGUAagAFgGpAakAEQGqAa8AAQGzAcEAFQHCAcQAFAHHAccAFQHIAckAGgHLAc4AGgHPAdcAFQHYAfYAFgH3AfcACAH4AfgAFwH5AfkAAQH6Af8AFQIAAgUAEwIHAgsADAIMAiAAFQIhAiYADQInAicADgIoAjAAFQIxAjQAEgI1Ak8AAQJQAlAAGgJRAlYAFgJXAloAAQJbAm4AFgJvAnQAAQJ4AocAFQKIAooAFAKNAo0AFQKOApQAGgKVAp0AFQKeArwAFgK9Ar0ACAK+Ar4AFwK/Ar8AAQLAAsUAFQLGAssAEwLOAs4AFQLPAs8ACALQAtMAHALUAtgADALZAu0AFQLuAvMADQL0AvQADgL1Av0AFQL+AwEAGwMCAwIAFQMDAwMAGgMEAwQAAQMLAwsAFQMMAykAFgMqAyoACAMrAy0ADAMuAzEAHAMyAzIAEQM1AzUAEQM2AzYAGgM3AzcADAM6AzoAEQM8AzwAFQM9Az0ADANAA0AAFQNBA0EADANCA0MAAgQwBDEAAQQyBDIAGgQzBDQAEgQ1BDUAFQQ2BDYAAQQ3BDkAFgQ6BDoADgQ7BDsAGAQ8BEEAFQREBEQAFQRFBEUAFgRGBEYAFQRHBEcACARIBEgAFgRJBEsAFQRMBEwAAQRNBE0ADgROBE4AEwRPBFMAFQRVBFUAFQRXBFcAFQRYBFgAEwRZBFkAFgRaBFoADgRbBFwAFQRdBF0AFARfBF8AFQRiBGIADARjBGMADgRkBGQAFgRlBGUADQRmBGcAEgRoBGgADgRpBGkAGARqBGsAFQRuBHAAFQRxBHIAFgRzBHMAFQR0BHUADQR2BHYADgR3BHcAFQR4BHkAEwR8BH0AGQR/BH8ADgSABIAAFQSCBIMAFQSEBIQAEwSGBIgAAQSJBIkAFgSMBIwADgSNBI4AGASPBJAAFQSRBJMAFgSVBJcAFQSYBJgAEwSZBJkAEgSaBJoAFQSbBJsAEgScBJ0ADgSeBJ4AFgSgBKAAAQShBKEADQSiBKIADASjBKMACASkBKQAFQSmBKcAAQSoBKgAGgSpBKoAEgSrBKsAFQSsBKwAAQStBK8AFgSwBLAADgSxBLEAGASyBLcAFQS6BLoAFQS7BLsAFgS8BLwAFQS9BL0ACAS+BL4AFgS/BMEAFQTCBMIAAQTDBMMADgTEBMQAEgTFBMkAFQTLBMsAFQTNBM0AFQTOBM4AEwTPBM8AFgTQBNAADgTRBNIAFQTTBNMAFATVBNUAFQTYBNgADATZBNkADgTaBNoAFgTbBNsADQTcBN0AEgTeBN4ADgTfBN8AGATgBOIAFQTkBOYAFQTnBOgAFgTpBOkAFQTqBOsADQTsBOwADgTtBO0AFQTuBO8AEgTyBPIAFQT0BPUAGQT3BPcADgT4BPgAFQT6BPsAFQT8BPwAEgT+BQAAAQUBBQEAFgUEBQQADgUFBQYAGAUHBQgAFQUJBQsAFgUMBQwADgUNBQ8AFQUQBRAAEwURBREAEgUSBRIAFQUTBRMAEgUUBRUADgUWBRYAFgUYBRgAAQUZBRkADQUaBRoADAUbBRsACAUcBSEAFQUiBSIADgUjBSMAFQUkBSQADgUlBSUAFQUoBSkAFQU8BTwAAgVABUAABAVBBUIACQVDBUMABQVGBUYACQVHBUcACgVLBUsABAVMBUwACwVNBU0ACQVOBU4ABwVPBU8AAwVRBVEAAwVTBVMADwVUBVcABwVYBVsABgVcBVwACQVdBWAAEAVhBWEACQV+BX8ABwWBBYEABwWLBYsABwWSBZIAFgX5BfkAEgABBaIAAQABAAIARgAfAB8AAQAmACYAAgAnACcADgApACkAAgArACsADgBHAEcAAwBJAEkAAwBcAGMABQBkAGwABgCMAIwABwCbAJsADgCdAKEACACiALYACQC9AL0ACgC+AMYADADHAMoADQDLAMsADgDnAOcADgDuAPIADgERAR8ADgEgASEABAEkATQADgFEAVgADgFfAV8ACwFgAWgADgM+Az4ADgNFA0UACANGA0YAAQNHA0kACANKA0oAAgNQA1MACQNYA1gAAwNaA1oACANbA1sABwNdA10ACANhA2EACgNjA2YACQNrA2sAAwNyA3IACANzA3MAAwN1A3UACAN6A3sACAOCA4MAAwOEA4QACAOHA4cACAOKA4oACgOLA4sACAOOA48ADgOWA5cAAwOjA6QACQOtA60ACAOvA68ACAOwA7EACgO3A7cABwO4A7gAAwO8A7wADgPAA8AAAgPGA8kADgPXA9cACwPZA9wADgPlA+YADgPnA+cABAPwA/AAAwQABAAACwQEBAUADgQKBAoADgQbBBwADgQpBCkACwVQBVAADgWiBaIADgACAAIENQQ1AAEEqwSrAAEAAgAgAYkBjgACAZABkAACAZQBqAACAdgB9gACAlECVgACAlsCbgACAp4CvAACAwwDKQACBDcEOQACBEUERQACBEgESAACBFkEWQACBGQEZAACBHEEcgACBIkEiQACBJEEkwACBJ4EngACBK0ErwACBLsEuwACBL4EvgACBM8EzwACBNoE2gACBOcE6AACBQEFAQACBQkFCwACBRYFFgACBUEFQgABBUYFRgABBU0FTQABBVwFXAABBWEFYQABBZIFkgACAAAAAQAAAAoByAlEAAJERkxUAA5sYXRuADIABAAAAAD//wANAAAACwAWACEALAA3AEIATQBhAGwAdwCCAI0AOgAJQVpFIABaQ0FUIAB8Q1JUIACeS0FaIADATU9MIADiTkxEIAEEUk9NIAEmVEFUIAFIVFJLIAFqAAD//wANAAEADAAXACIALQA4AEMATgBiAG0AeACDAI4AAP//AA4AAgANABgAIwAuADkARABPAFgAYwBuAHkAhACPAAD//wAOAAMADgAZACQALwA6AEUAUABZAGQAbwB6AIUAkAAA//8ADgAEAA8AGgAlADAAOwBGAFEAWgBlAHAAewCGAJEAAP//AA4ABQAQABsAJgAxADwARwBSAFsAZgBxAHwAhwCSAAD//wAOAAYAEQAcACcAMgA9AEgAUwBcAGcAcgB9AIgAkwAA//8ADgAHABIAHQAoADMAPgBJAFQAXQBoAHMAfgCJAJQAAP//AA4ACAATAB4AKQA0AD8ASgBVAF4AaQB0AH8AigCVAAD//wAOAAkAFAAfACoANQBAAEsAVgBfAGoAdQCAAIsAlgAA//8ADgAKABUAIAArADYAQQBMAFcAYABrAHYAgQCMAJcAmGFhbHQDkmFhbHQDmmFhbHQDomFhbHQDqmFhbHQDsmFhbHQDumFhbHQDwmFhbHQDymFhbHQD0mFhbHQD2mFhbHQD4mNhbHQD6mNhbHQD8mNhbHQD+mNhbHQEAmNhbHQECmNhbHQEEmNhbHQEGmNhbHQEImNhbHQEKmNhbHQEMmNhbHQEOmNhc2UEQmNhc2UESGNhc2UETmNhc2UEVGNhc2UEWmNhc2UEYGNhc2UEZmNhc2UEbGNhc2UEcmNhc2UEeGNhc2UEfmNjbXAEhGNjbXAEjGNjbXAElmNjbXAEnmNjbXAEpmNjbXAErmNjbXAEtmNjbXAEvmNjbXAExmNjbXAEzmNjbXAE1mRsaWcE3mRsaWcE5GRsaWcE6mRsaWcE8GRsaWcE9mRsaWcE/GRsaWcFAmRsaWcFCGRsaWcFDmRsaWcFFGRsaWcFGmZpbmEFIGZpbmEFJmZpbmEFLGZpbmEFMmZpbmEFOGZpbmEFPmZpbmEFRGZpbmEFSmZpbmEFUGZpbmEFVmZpbmEFXGZyYWMFYmZyYWMFaGZyYWMFbmZyYWMFdGZyYWMFemZyYWMFgGZyYWMFhmZyYWMFjGZyYWMFkmZyYWMFmGZyYWMFnmxpZ2EFpGxpZ2EFqmxpZ2EFsGxpZ2EFtmxpZ2EFvGxpZ2EFwmxpZ2EFyGxpZ2EFzmxpZ2EF1GxpZ2EF2mxpZ2EF4GxvY2wF5mxvY2wF7GxvY2wF8mxvY2wF+GxvY2wF/mxvY2wGBGxvY2wGCmxvY2wGEGxvY2wGFm9yZG4GHG9yZG4GJG9yZG4GLG9yZG4GNG9yZG4GPG9yZG4GRG9yZG4GTG9yZG4GVG9yZG4GXG9yZG4GZG9yZG4GbHNhbHQGdHNhbHQGenNhbHQGgHNhbHQGhnNhbHQGjHNhbHQGknNhbHQGmHNhbHQGnnNhbHQGpHNhbHQGqnNhbHQGsHNzMDEGtnNzMDEGvHNzMDEGwnNzMDEGyHNzMDEGznNzMDEG1HNzMDEG2nNzMDEG4HNzMDEG5nNzMDEG7HNzMDEG8nNzMDIG+HNzMDIG/nNzMDIHBHNzMDIHCnNzMDIHEHNzMDIHFnNzMDIHHHNzMDIHInNzMDIHKHNzMDIHLnNzMDIHNHN1cHMHOnN1cHMHQHN1cHMHRnN1cHMHTHN1cHMHUnN1cHMHWHN1cHMHXnN1cHMHZHN1cHMHanN1cHMHcHN1cHMHdgAAAAIAAAABAAAAAgAAAAEAAAACAAAAAQAAAAIAAAABAAAAAgAAAAEAAAACAAAAAQAAAAIAAAABAAAAAgAAAAEAAAACAAAAAQAAAAIAAAABAAAAAgAAAAEAAAACABAAEQAAAAIAEAARAAAAAgAQABEAAAACABAAEQAAAAIAEAARAAAAAgAQABEAAAACABAAEQAAAAIAEAARAAAAAgAQABEAAAACABAAEQAAAAIAEAARAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAQAVAAAAAgACAAMAAAADAAIAAwAEAAAAAgACAAMAAAACAAIAAwAAAAIAAgADAAAAAgACAAMAAAACAAIAAwAAAAIAAgADAAAAAgACAAMAAAACAAIAAwAAAAIAAgADAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAaAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQAPAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQASAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQAWAAAAAQANAAAAAQAGAAAAAQAMAAAAAQAJAAAAAQAIAAAAAQAFAAAAAQAHAAAAAQAKAAAAAQALAAAAAgATABQAAAACABMAFAAAAAIAEwAUAAAAAgATABQAAAACABMAFAAAAAIAEwAUAAAAAgATABQAAAACABMAFAAAAAIAEwAUAAAAAgATABQAAAACABMAFAAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAFwAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGAAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEAGQAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAAAAEADgAfAEAASABQAF4AaABwAHgAggCKAJIAmgCiAKoAsgC6AMIAygDUAQQBDAEWAR4BJgEuATYBPgFGAU4BVgFeAWYAAQAAAAEPDAADAAAAARO+AAYAAAAEAR4BMAFEAVYABgAAAAIBWgFsAAQAAAABAXQABAAAAAECAgAGAAAAAgIwAkQAAQAAAAECTgABAAAAAQJUAAEAAAABAloAAQAAAAECWAABAAAAAQJWAAEAAAABAlQAAQAAAAECUgABAAAAAQJQAAEAAAABAk4ABgAAAAIE6gT4AAYAAAAVBP4FEAUiBTQFRgVYBWoFfAWOBaAFsgXEBdYF6AX6BgwGHgYwBkIGVAZmAAQAAAABBkgABgAAAAIGbAZ+AAQAAAABBoYAAQAAAAEGkgAEAAAAAQgOAAEAAAABCFAAAQAAAAEJ8AABAAAAAQx+AAQAAAABDbwAAQAAAAEUZAAEAAAAARSkAAEAAAABFLoAAQAAAAEWXgADAAAAARZkAAEWbAABAAAAGwADAAAAARZSAAIWahZaAAEAAAAbAAMAARZmAAEWZgAAAAEAAAAbAAMAARZqAAEWVAAAAAEAAAAbAAMAAAABFkIAARZoAAEAAAAbAAMAARZWAAEWMAAAAAEAAAAbAAEWVAAEAA4AMABSAHQABAAKABAAFgAcBeoAAgWmBekAAgWnBewAAgWuBesAAgWwAAQACgAQABYAHAXmAAIFpgXlAAIFpwXoAAIFrgXnAAIFsAAEAAoAEAAWABwF8gACBb8F8QACBcAF9AACBcYF8wACBcgABAAKABAAFgAcBe4AAgW/Be0AAgXABfAAAgXGBe8AAgXIAAEVygAEAA4AGAAiACwAAQAEAz4AAgBYAAEABADLAAIAWAABAAQDQAACAcIAAQAEAwIAAgHCAAMAAAACFaAVpgABFaAAAQAAABwAAwAAAAIVmBWSAAEVmAABAAAAHAACFYoABACaAKECBQILAAIVfAAEAJoAoQIFAgsAARV6AAcAARV0AAcAARVuAAcAARVoAAcAARViAAcAARViAAkAAhVmAU8CNQI2AjcCOAI5AjoCOwI8Aj0CPgI/AkACQQJCAkMCRAJFAkYCRwJIAkkCSgJLAkwCTQJOAk8CUAJRAlICUwJUAlUCVgJXAlgCWQJaAlsCXAJdAl4CXwJgAmECYgJjAmQCZQJmAmcCaAJpAmoCawJsAm0CbgJvAnACcQJyAnMCdAJ1AnYCdwJ4AnkCegJ8An0CfgJ/AoACgQKCAoMChAKFAoYChwKIAokCigKLAowCjQKOAo8CkAKRApICkwKUApUClgKXApgCmQKaApsCnAKdAp4CnwKgAqECogKjAqQCpQKmAqcCqAKpAqoCqwKsAq0CrgKvArACsQKyArMCtAK1ArYCtwK4ArkCugK7ArwCvQK+Ar8CwALBAsICwwLEAsUCxgLHAsgCyQLKAssCzALUAtUC1gLXAtgC2QLaAtsC3ALdAt4C3wLgAuEC4gLjAuQC5QLmAucC6ALpAuoC6wLsAu0C7gLvAvAC8QLyAvMC9AL1AvYC9wL4AvkC+gL7AvwC/QL+Av8DAAMBAnsCzQLOAs8C0ALRAtIC0wM4AzkDOgM7AzwDPQSmBKcEqASpBKoEqwSsBK0ErgSvBLAEsQSyBLMEtAS1BLYEtwS4BLkEugS7BLwEvQS+BL8EwATBBMIEwwTEBMUExgTHBMgEyQTKBMsEzATNBM4EzwTQBNEE0gTTBNQE1QTWBNcE2ATZBNoE2wTcBN0E3gTfBOAE4QTiBOME5ATlBOYE5wToBOkE6gTrBOwE7QTuBO8E8ATxBPQE9QT2BPcE+AT5BPoE+wT8BP0E/gT/BQAFAQUCBQMFBAUFBQYFBwUIBQkFCgULBQwFDQUOBQ8FEAURBRIFEwUUBRUFFgUXBRgFGQUaBRsE8gTzBRwFIAUhBSQFJQX8AAMAAAABExoAARNOAAAAAwAAAAETDAAAAAEAAAAPAAMAAAABEvwAARNAAAEAAAAdAAMAAAABEzgAARNsAAEAAAAdAAMAAAABE2oAARNaAAEAAAAdAAMAAAABE24AARNIAAEAAAAdAAMAAAABE2YAARM2AAEAAAAdAAMAAAABEzQAARNeAAEAAAAdAAMAAAABE1QAARNaAAEAAAAdAAMAAAABE1AAARNIAAEAAAAdAAMAAAABE0QAARM2AAEAAAAdAAMAAAABEzgAARMkAAEAAAAdAAMAAAABEywAARMSAAEAAAAdAAMAAAABEyAAARK4AAEAAAAdAAMAAAABEw4AARMUAAEAAAAdAAMAAAABEqQAARMSAAEAAAAdAAMAAAABEqgAARMAAAEAAAAdAAMAAAABEqAAARLuAAEAAAAdAAMAAAABEoQAARLkAAEAAAAdAAMAAAABElwAARL0AAEAAAAdAAMAAAABEmAAARLiAAEAAAAdAAMAAAABElgAARLQAAEAAAAdAAMAAAABEtoAARKcAAEAAAAdAAES0gACAAoAIAACAAYADgU5AAMFTAUsBToAAwVMBS4AAQAEBTsAAwVMBS4AAwABEq4AARK4AAAAAQAAAB4AAwABEpwAARKuAAAAAQAAAB4AARKkAAEACAABAAQFogADAdgFRgACEpYAvwDMAM0AzgDPANAA0QDSANMA1ADVANYA1wDYANkA2gDbANwA3QDeAN8A4ADhAOIA4wDkAOUA5gDnAOgA6QDqAOsA7ADtAO4A7wDwAPEA8gDzAPQA9QD2APcA+AD5APoA+wD8AP0A/gD/AQABAQECAQMBBAEFAQYBBwEIAQkBCgELAQwBDQEOAQ8BEAERARIBFAEVARYBFwEYARkBGgEbARwBHQEeAR8BIAEhASIBIwEkASUBJgEnASgBKQEqASsBLAEtAS4BLwEwATEBMgEzATQBNQE2ATcBOAE5AToBOwE8AT0BPgE/AUABQQFCAUMBRAFFAUYBRwFIAUkBSgFLAUwBTQFOAU8BUAFRAVIBUwFUAVUBVgFXAVgBWQFaAVsBXAFdAV4BXwFgAWEBYgFjAWQBZQFmAWcBaAFpAWoBawFsBb0FvgW/BcAFwQXCBcMFxAXFBcYFxwXIBckFygXLBcwFzQXOBc8F0AXRBdIF0wXtBe4F7wXwBfEF8gXzBfQAARFAAAMADAA2AEAABQAMABIAGAAeACQDMgACAakDNAACAbMDMwACAcIDNQACAcgDPwACA0AAAQAEAzYAAgHOAAEABAM3AAICBwACEQAA0QDMAM0AzgDPANAA0QDSANMA1ADVANYA1wDYANkA2gDbANwA3QDeAN8A4ADhAOIA4wDkAOUA5gDnAOgA6QDqAOsA7ADtAO4A7wDwAPEA8gDzAPQA9QD2APcA+AD5APoA+wD8AP0A/gD/AQABAQECAQMBBAEFAQYBBwEIAQkBCgELAQwBDQEOAQ8BEAERARIBFAEVARYBFwEYARkBGgEbARwBHQEeAR8BIAEhASIBIwEkASUBJgEnASgBKQEqASsBLAEtAS4BLwEwATEBMgEzATQBNQE2ATcBOAE5AToBOwE8AT0BPgE/AUABQQFCAUMBRAFFAUYBRwFIAUkBSgFLAUwBTQFOAU8BUAFRAVIBUwFUAVUBVgFXAVgBWQFaAVsBXAFdAV4BXwFgAWEBYgFjAWQBZQFmAWcBaAFpAWoBawFsARMDAwMEAwUDBgMHAwgDCQMKAwsDDAMNAw4DDwMQAxEDEgMTAxQDFQMWAxcDGAMZAxoDGwMcAx0DHgMfAyADIQMiAyMDJAMlAyYDJwMoAykDKgMrAywDLQMuAy8DMAMxA0EAAg/CAUgAzADNAM4AzwDQANEA0gDTANQA1QDWANcA2ADZANoA2wDcAN0A3gDfAOAA4QDiAOMA5ADlAOYA5wDoAOkA6gDrAOwA7QDuAO8A8ADxAPIA8wD0APUA9gD3APgA+QD6APsA/AD9AP4A/wEAAQEBAgEDAQQBBQEGAQcBCAEJAQoBCwEMAQ0BDgEPARABEQESARQBFQEWARcBGAEZARoBGwEcAR0BHgEfASABIQEiASMBJAElASYBJwEoASkBKgErASwBLQEuAS8BMAExATIBMwE0ATUBNgE3ATgBOQE6ATsBPAE9AT4BPwFAAUEBQgFDAUQBRQFGAUcBSAFJAUoBSwFMAU0BTgFPAVABUQFSAVMBVAFVAVYBVwFYAVkBWgFbAVwBXQFeAV8BYAFhAWIBYwFkAWUBZgFnAWgBaQFqAWsBbAETAwMDBAMFAwYDBwMIAwkDCgMLAwwDDQMOAw8DEAMRAxIDEwMUAxUDFgMXAxgDGQMaAxsDHAMdAx4DHwMgAyEDIgMjAyQDJQMmAycDKAMpAyoDKwMsAy0DLgMvAzADMQNBA7oDuwO8A70DvgO/A8ADwQPCA8MDxAPFA8YDxwPIA8kDygPLA8wDzQPOA88D0APRA9ID0wPUA9UD1gPXA9gD2QPaA9sD3APdA94D3wPgA+ED4gPjA+QD5QPmA+cD6APpA+oD6wPsA+0D7gPvA/AD8QPyA/MD9AP1A/YD9wP4A/kD+gP7A/wD/QP+A/8EAAQBBAIEAwQEBAUECAQJBAoECwQMBA0EDgQPBBAEEQQSBBMEFAQVBBYEFwQYBBkEGgQbBBwEHQQeBB8EIAQhBCIEIwQkBCUEJgQnBCgEKQQqBCsELAQtBC4ELwQGBAcF+wACDaIAoADMAM0AzgDPANAA0QDSANMA1ADVANYA1wDYANkA2gDbANwA3QDeAN8A4ADhAOIA4wDkAOUA5gDnAOgA6QDqAOsA7ADtAO4A7wDwAPEA8gDzAPQA9QD2APcA+AD5APoA+wD8AP0A/gD/AQABAQECAQMBBAEFAQYBBwEIAQkBCgELAQwBDQEOAQ8BEAERARIBFAEVARYBFwEYARkBGgEbARwBHQEeAR8BIAEhASIBIwEkASUBJgEnASgBKQEqASsBLAEtAS4BLwEwATEBMgEzATQBNQE2ATcBOAE5AToBOwE8AT0BPgE/AUABQQFCAUMBRAFFAUYBRwFIAUkBSgFLAUwBTQFOAU8BUAFRAVIBUwFUAVUBVgFXAVgBWQFaAVsBXAFdAV4BXwFgAWEBYgFjAWQBZQFmAWcBaAFpAWoBawFsAAELcgADAAwANgBAAAUADAASABgAHgAkAzIAAgGpAzQAAgGzAzMAAgHCAzUAAgHIAz8AAgNAAAEABAM2AAIBzgABAAQDNwACAgcAAgwuAloAzQDOAM8A0ADRANIA0wDUANUA1gDXANgA2QDaANsA3ADdAN4A3wDgAOEA4gDjAOQA5QDmAOcA6ADpAOoA6wDsAO0A7gDvAPAA8QDyAPMA9AD1APYA9wD4APkA+gD7APwA/QD+AP8BAAEBAQIBAwEEAQUBBgEHAQgBCQEKAQsBDAENAQ4BDwEQAREBEgEUARUBFgEXARgBGQEaARsBHAEdAR4BHwEgASEBIgEjASQBJQEmAScBKAEpASoBKwEsAS0BLgEvATABMQEyATMBNANDATUBNgE3ATgBOQE6ATsBPAE9AT4AmgE/AUABQQFDAUQBRQFGAUcBSAFJAUoBSwFMAU0BTgFPAVABUQFSAVMBVAFVAVYBVwFYAVkBWgFbAVwBXQFeAV8BYAFhAWIBYwFkAWUBZgFnAWgBaQFqAWsBbAETAjYCNwI4AjkCOgI7AjwCPQI+Aj8CQAJBAkICQwJEAkUCRgJHAkgCSQJKAksCTAJNAk4CTwJRAlICUwJUAlUCVgJYAlkCWgJbAlwCXQJeAl8CYAJhAmICYwJkAmUCZgJnAmgCaQJqAmsCbAJtAm4DBQJvAnACcQJyAnMCdAJ1AnYCdwJ5AnoCfAJ9An4CfwKAAoECggKDAoQChQKGAocCiQKKAosCjAKNApACkgKVApYClwKYApkCmgKcAp0CvAK+Ar8CwALBAsICwwLEAsUCxgLHAsgCygLLAswC1QLWAtkC2gLbAtwC3QLeAt8C4ALhAuIC4wLkAuUC5gLnAugC6QLqAusC7ALtAu4C7wLwAvEC8gLzAvQC9QL2AvcC+AL5AvoC+wL8Av0CewLNAs4CzwLQAtEC0gLTAzgDOQM6A0EDOwM8Az0DugO7A7wDvQO+A78DwAPBA8IDwwPEA8UDxgPHA8gDyQPKA8sDzAPNA84DzwPQA9ED0gPTA9QD1QPWA9cD2APZA9oD2wPcA90D3gPfA+AD4QPiA+MD5APlA+YD5wPoA+kD6gPrA+wD7QPuA+8D8APxA/ID8wP0A/UD9gP3A/gD+QP6A/sD/AP9A/4D/wQABAEEAgQDBAQEBQQIBAkECgQLBAwEDQQOBA8EEAQRBBIEEwQUBBUEFgQXBBgEGQQaBBsEHAQdBB4EHwQgBCEEIgQjBCQEJQQmBCcEKAQpBCoEKwQsBC0ELgQvBAYEBwSmBKcEqASpBKoEqwSsBK0ErgSvBLAEsQSyBLMEtAS1BLYEtwS4BLkEugS7BLwEvQS+BL8EwATBBMIEwwTEBMUExgTHBMgEyQTKBMsEzATNBM4EzwTQBNEE0gTTBNQE1QTWBNcE2ATZBNoE2wTcBN0E3gTfBOAE4QTiBOME5ATlBOYE5wToBOkE6gTrBOwE7QTuBO8E8ATxBPQE9QT2BPcE+AT5BPoE+wT8BP0E/gT/BQAFAQUCBQMFBAUFBQYFBwUIBQkFCgULBQwFDQUOBQ8FEAURBRIFEwUUBRUFFgUXBRgFGQUaBRsE8gTzBRwFIAUhBSQFJQU0BTUFNgU3Bb0FvgW/BcAFwQXCBcMFxAXFBcYFxwXIBckFygXLBcwFzQXOBc8F0AXRBdIF0wXtBe4F7wXwBfEF8gXzBfQF+wX8AAEIYgA0AG4AdAB6AIAAhgCMAJQAmgCgAKYArACyALgAvgDGAMwA0gDYAN4A5ADqAPAA9gD8AQIBCAEOARQBGgEgASYBLAEyATgBPgFEAUoBUAFWAVwBYgFoAW4BdAF6AYABhgGOAZQBmgGgAaYAAgNCAMwAAgChAUIAAgI1A0IAAgJQAwMAAgJXAwQAAwG0AboCeAACAcMCiAACAo4DBgACAo8DBwACApEDCAACApMDCQACApQDCgACApsDCwADAp4DQwMMAAICnwMNAAICoAMOAAICoQMPAAICogMQAAICowMRAAICpAMSAAICpQMTAAICpgMUAAICpwMVAAICqAMWAAICqQMXAAICqgMYAAICqwMZAAICrAMaAAICrQMbAAICrgMcAAICrwMdAAICsAMeAAICsQMfAAICsgMgAAICswMhAAICtAMiAAICtQMjAAICtgMkAAICtwMlAAICuAMmAAICuQMnAAICugMoAAICuwMpAAICvQMqAAICBQLJAAIC1AMrAAMCCwLXAywAAgLYAy0AAgL+Ay4AAgL/Ay8AAgMAAzAAAgMBAzEAAgcgACEBtAHDBb0FvgW/BcAFwQXCBcMFxAXFBcYFxwXIBckFygXLBcwFzQXOBc8F0AXRBdIF0wXtBe4F7wXwBfEF8gXzBfQAAQb6AAIACgAUAAEABABhAAIFPgABAAQBzAACBT4AAgbkANMBWQFaAVsBXAFdAV4CNQI2AjcCOAI5AjoCOwI8Aj0CPgI/AkACQQJCAkMCRAJFAkYCRwJIAkkCSgJLAkwCTQJOAk8CUAJRAlICUwJUAlUCVgJXAlgCWQJaAlsCXAJdAl4CXwJgAmECYgJjAmQCZQJmAmcCaAJpAmoCawJsAm0CbgJvAnACcQJyAnMCdAJ1AnYCdwJ4AnkCegJ8An0CfgJ/AoACgQKCAoMChAKFAoYChwKIAokCigKLAowCjQKOAo8CkAKRApICkwKUApUClgKXApgCmQKaApsCnAKdAp4CnwKgAqECogKjAqQCpQKmAqcCqAKpAqoCqwKsAq0CrgKvArACsQKyArMCtAK1ArYCtwK4ArkCugK7ArwCvQK+Ar8CwALBAsICwwLEAsUCxgLHAsgCyQLKAssCzALUAtUC1gLXAtgC2QLaAtsC3ALdAt4C3wLgAuEC4gLjAuQC5QLmAucC6ALpAuoC6wLsAu0C7gLvAvAC8QLyAvMC9AL1AvYC9wL4AvkC+gL7AvwC/QL+Av8DAAMBAs0CzgLPAtAC0QLSAtMDPAACBXIABANCA0MDQgNDAAEAAgGzAcIAAgACBaQFqAAABaoFswAFAAIAAgW0BbYAAAW4BbsAAwACAAMFpAWoAAAFqgW7AAUF5QXsABcAAgACAAQBbAAABSYFJwFpAAIAAgW9BdMAAAXtBfQAFwABAAQFqgWsBcIFxAABAAQASgBLAbMBtQABAAEByAABAAEFPgABAAEAXAABAAQAmACgAgMCCgABAAEBswACAAEFKwUuAAAAAgAOAW0BjwAAAZEBpwAjAaoCNAA6AwIDAgDFAwkDCQDGAwsDCwDHAyoDKgDIAy4DMQDJAzMDNQDNAz8DQQDQBDAEpQDTBR0FHwFJBSIFIwFMBfgF+AFOAAIACAFtAY8AAAGRAacAIwGqAjQAOgMJAwkAxQMLAwsAxgMqAyoAxwMuAzEAyANAA0AAzAACAAIABANDAAAFJgUpA0AAAgABBTwFYQAAAAIACAGqAa8AAAHCAcQABgHNAc0ACQIoAjAACgMJAwkAEwMLAwsAFAMuAzEAFQNAA0AAGQACAAICAAIFAAACxgLLAAYAAgADAYgBiAAAAdgB9QABAfcB+AAfAAIAAQH6Af8AAAACAAECIQImAAAAAQACAggC1QABAAEBggABAAIB9wK9AAEAAQGMAAEAAQGmAAEAAQHAAAEAAQIeAAEAAQH5AAIAAgHCAcQAAAKIAooAAwABAAICJwL0AAIABQIHAgsAAALUAtgABQMrAy0ACgM9Az0ADQNBA0EADgACAAQCMQI0AAAC0ALTAAQC/gMBAAgDLgMxAAwAAgABALcAvAAAAAEAAgUrBS0AAgABBSoFMwAAAAEAAgAEAW0AAQACAG0B2AABAAEAZQACAAcABAAqAAAALABsACcAiwCUAGgAnQDKAHIFpAWoAKAFqgW7AKUF5QXsALcAAQADAakBzgIHAAIAEQAEACoAAAAsAGwAJwCLAJQAaACdAMsAcgGIAYgAoQGPAY8AogGpAakAowHIAckApAHLAcsApgHNAc4ApwHVAdUAqQHYAfUAqgH3AfcAyAIHAgcAyQIKAgsAygIxAjQAzAM3AzcA0AACABMABAAqAAAALABsACcAiwCUAGgAnQDLAHIBiAGIAKEBjwGPAKIBqQGpAKMByAHJAKQBywHLAKYBzQHOAKcB1QHVAKkB2AH1AKoB9wH3AMgCBwIHAMkCCgILAMoCMQI0AMwDNwM3ANADRAO5ANEF9QX1AUcAAgAEAAQAKgAAACwAbAAnAIsAlABoAJ0AygByAAIAJwAFACoAAAAsAG0AJgCLAJQAaACYAJgAcgCdAJ8AcwChAMsAdgFuAYcAoQGJAY4AuwGRAacAwQGpAbIA2AG0AcEA4gHDAccA8AHKAcoA9QHMAcwA9gHPAdQA9wHWAdcA/QH2AfYA/wH4AgIBAAIEAgYBCwIIAgkBDgIMAjABEAMCAwIBNQMJAwkBNgMLAwsBNwMqAyoBOAMuAzEBOQMzAzUBPQM3AzcBQAM/A0EBQQNEA7kBRAQwBKUBugUdBR8CMAUiBSMCMwUrBS4CNQWkBagCOQWqBbsCPgXlBewCUAX1BfUCWAX4BfgCWQACABEABAAEAAAAoACgAAEBbQFtAAIBiAGIAAMBjwGPAAQBswGzAAUBwgHCAAYByAHJAAcBywHLAAkBzQHOAAoB1QHVAAwB2AH1AA0B9wH3ACsCAwIDACwCBwIHAC0CCgILAC4CMQI0ADAAAgAFAbMBswAAAcIBwgABBaQFqAACBaoFuwAHBeUF7AAZAAEAAgBcAcgAAgAJALcAvAAAAW0BjwAGAZEBpwApAaoCNABAAwkDCQDLAwsDCwDMAyoDKgDNAy4DMQDOA0ADQADSAAEABAAEAG0BbQHYAAAAAAABAAAAAA==", + "weight": 400 + } + ], + "screens": [ + { + "id": "hero", + "name": "Hero", + "platform": "apple", + "device": "iphone", + "locale": "en", + "artboard": { + "width": 660, + "height": 1434 + }, + "background": { + "type": "solid", + "color": "#0B1020" + }, + "elements": [ + { + "id": "accent", + "type": "shape", + "kind": "rect", + "x": 60, + "y": 300, + "width": 540, + "height": 220, + "rotation": 0, + "opacity": 1, + "locked": false, + "visible": true, + "fill": "#5B8CFF", + "radius": 24 + }, + { + "id": "headline", + "type": "text", + "x": 60, + "y": 330, + "width": 540, + "height": 160, + "rotation": 0, + "opacity": 1, + "locked": false, + "visible": true, + "content": "Ship it", + "fontFamily": "Pacifico", + "size": 120, + "weight": 400, + "lineHeight": 1.1, + "letterSpacing": 0, + "align": "center", + "color": "#FFFFFF" + } + ] + } + ] +} diff --git a/fixtures/phase-0-sample/assets/fonts/OFL.txt b/fixtures/phase-0-sample/assets/fonts/OFL.txt new file mode 100644 index 00000000..33864cc8 --- /dev/null +++ b/fixtures/phase-0-sample/assets/fonts/OFL.txt @@ -0,0 +1,93 @@ +Copyright 2018 The Pacifico Project Authors (https://github.com/googlefonts/Pacifico) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/fixtures/phase-0-sample/assets/fonts/Pacifico-Regular.ttf b/fixtures/phase-0-sample/assets/fonts/Pacifico-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..27765d02ac13f241b1e207dbda7b2dd1b68280da GIT binary patch literal 329380 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 DD2WNO literal 0 HcmV?d00001 From aca6053db5f246192774ce2e5dfada7b4e3440c5 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Fri, 3 Jul 2026 23:56:03 +0300 Subject: [PATCH 016/368] docs: document phase 0 install and usage --- README.md | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index d6bd8437..5db53a53 100644 --- a/README.md +++ b/README.md @@ -15,8 +15,56 @@ reproducible, automatable in CI, and give an AI agent a clean contract to work a ## Status -Planning. The first milestone is a Phase 0 spike proving that one JSON renders to a -pixel-correct PNG from both the web UI and the CLI. See [docs/roadmap.md](docs/roadmap.md). +**Phase 0 (render/export parity spike) — done.** One project JSON renders to a pixel-correct +PNG from the same web renderer used by both the browser and the CLI, verified on the hardest +case (an embedded custom font). The canvas editor is Phase 1 and not built yet — see +[docs/roadmap.md](docs/roadmap.md). + +## Requirements + +- **Node.js 20+** and **pnpm**. +- A one-time Playwright browser download (the CLI renders through a headless browser): + +```bash +pnpm exec playwright install chromium chromium-headless-shell +``` + +Both browser builds are needed: the parity check compares a headed (`chromium`) render against +a headless (`chromium-headless-shell`) one. + +## Install + +```bash +git clone && cd AppReviewPlatform +pnpm install +pnpm exec playwright install chromium chromium-headless-shell +``` + +## Usage (Phase 0 CLI) + +```bash +# Scaffold a project (writes app-store-screenshots.json + standard directories) +pnpm screenshots init --dir ./my-app-screenshots + +# Export a screen to an exact store size (PNG, 24-bit RGB, no alpha) +pnpm screenshots export --project ./my-app-screenshots/app-store-screenshots.json +``` + +`export` flags: `--screen ` (defaults to the first screen), `--size ` (defaults to +`6.9`, from [store-specs.json](store-specs.json)), `--out

` (defaults to `/export`). + +The `dev` command (the canvas editor) arrives in Phase 1. + +## Development + +```bash +pnpm test # unit tests (schema, store-specs, export helpers) +pnpm test:e2e # Phase 0 parity gate: headed-vs-headless render + font fidelity +pnpm typecheck # all packages +``` + +`pnpm test:e2e` starts the `apps/web` render host and drives Chromium, so it requires the +Playwright browsers from **Requirements** above. ## License From bdda8bc78cfbd1d5f1431d477b6a52cb4ad78baa Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Sat, 4 Jul 2026 01:07:31 +0300 Subject: [PATCH 017/368] docs: record phase 1 execution slices in roadmap --- docs/roadmap.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/docs/roadmap.md b/docs/roadmap.md index a87690c5..4014c951 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -81,6 +81,26 @@ polish (README GIF, `CONTRIBUTING.md`, example projects). --- +## 3a. Phase 1 execution slices + +Phase 1 (the web editor) is 6–7 subsystems — too large for one spec. It is sliced by **risk**, +not by UI panel, and each slice is its own spec → plan → implementation cycle. Order is fixed; +a later slice may not start before the one it depends on lands. + +| Slice | Delivers | Risk it retires | +|-------|----------|-----------------| +| **1 — Interactive canvas + render-reuse** | Konva editor stage (pan/zoom, select/move/resize/rotate, inline text edit) over a Zustand+Immer patch store; save/load via a disk-backed API route; export still passes parity. Only `text` + `shape` (schema unchanged). | **Highest.** Proves the interactive editor shares the *single* render path instead of forking a second react-konva tree — the Phase 0 parity thesis applied to an interactive surface. | +| **2 — Schema widening** | `screenshot` + `device-frame` element types: Zod contract, `v1→v2` migration, asset loading, iPhone bezel mockup. | Touches the validator (escalation-sensitive per RULES.md); adds asset-loading + bezel fidelity as new parity surfaces. | +| **3 — Left panel** | Screens section (dnd-kit reorder = export order) + Layers section (z-order, lock, hide, rename). No grouping. | Medium — multi-screen state, reorder as the shared UI/CLI ordering source. | +| **4 — Inspector + toolbar** | Full per-type inspector, no-selection artboard/background editor, toolbar element tools (insert-on-click) + zoom controls. | Low — sits on the store and mapper the earlier slices established. | + +**The single source of truth for element rendering is `core/engine`'s `elementToNodeConfig`** +(introduced in Slice 1): a pure `element → Konva props` map consumed by both the static +`renderScreen` (export) and the interactive editor stage. Deferred to their own later phases, +not slices: snapping/guides, undo/redo *UI*, grouping, themes, templates, locales/RTL. + +--- + ## 4. Technical risks 1. **Render/export parity (highest).** UI (browser Konva) vs CLI (headless) must produce the From ceae64a36e56652929303fd932c9b2b21856df90 Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Sat, 4 Jul 2026 01:07:50 +0300 Subject: [PATCH 018/368] docs: add phase 1 slice 1 interactive-canvas design spec --- ...phase1-slice1-interactive-canvas-design.md | 166 ++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 docs/specs/2026-07-04-phase1-slice1-interactive-canvas-design.md diff --git a/docs/specs/2026-07-04-phase1-slice1-interactive-canvas-design.md b/docs/specs/2026-07-04-phase1-slice1-interactive-canvas-design.md new file mode 100644 index 00000000..86acf823 --- /dev/null +++ b/docs/specs/2026-07-04-phase1-slice1-interactive-canvas-design.md @@ -0,0 +1,166 @@ +# Phase 1 · Slice 1 — Interactive canvas + render-reuse + +Design spec. Version 1.0, 4 July 2026. + +This is **slice 1 of 4** in the Phase 1 decomposition (`docs/roadmap.md` §3a). It is scoped to +retire the single highest Phase 1 risk and nothing else. Read `docs/architecture.md` §2 (parity) +and `docs/editor.md` before implementing; where this spec and those disagree, they win. + +--- + +## 1. Goal — the thesis this slice retires + +Phase 0 proved *"one JSON → identical pixels in the UI `/render` route and the CLI export."* +Phase 1's unproven equivalent, and the thing this slice exists to prove: + +> **An interactive editor can share the single render path without forking it.** + +`renderScreen` today builds one static, non-interactive layer (`Konva.Layer({ listening: false })`) +purpose-built for export. The editor needs the opposite: a listening stage, a `Transformer`, +drag/resize/rotate, inline text editing, pan/zoom. The failure mode this slice must prevent is a +**second react-konva tree** growing beside the export renderer — `docs/editor.md` §5 is explicit: +"the Phase 1 export button must later reuse ``, never a parallel react-konva tree." + +The slice succeeds when interactive editing and static export are provably driven by **one** +element-rendering source of truth, and the Phase 0 parity gate still passes unchanged. + +--- + +## 2. Scope + +**In (only what proves the thesis):** + +- An infinite pan/zoom canvas showing one **active screen** (the project's first screen). +- Selection → Konva `Transformer` with move / resize / rotate. **Single-select** only. +- Inline `text` editing on double-click. +- Only the element types already in the schema: `text` and `shape`. **The Zod schema is not + touched.** +- A Zustand + Immer **patch store**. This is the day-0 immutable-state requirement + (`roadmap.md` §1); it makes undo/redo possible later. **No undo/redo buttons ship in this slice.** +- Save / load through a disk-backed **Next API route** (§5) reading and writing the same + `app-store-screenshots.json` the CLI and `/render` use. +- The export path continues to run through the existing `/render` + `renderScreen` route; its + pixels do not change. + +**Out (later slices / phases — listed so the canvas choice does not quietly drag them in):** + +- Left panel (Screens + Layers) — Slice 3. +- Full per-type inspector, no-selection background editor, toolbar element tools — Slice 4. +- `screenshot` / `device-frame` types and the `v1→v2` schema migration — Slice 2. +- Marquee multi-select, snapping / smart guides, element grouping — later phases. +- Undo/redo **UI**, themes, templates, locales / RTL — later phases. + +**Chosen defaults** (decided during brainstorming; documented so they can be revisited): + +- **No inspector or toolbar in this slice.** Two-way store↔canvas binding is proven by the + Transformer (geometry) and inline text edit (content) alone — a dedicated properties panel is + not needed to retire the thesis. Editing color/font/etc. arrives with the Slice 4 inspector. +- **Single-select, not marquee.** `editor.md` §2 lists marquee as "in (simple)", but a single + selection is sufficient to exercise the Transformer→store loop; marquee is deferred. +- **No `packages/ui` yet.** Editor components live in `apps/web` until a second consumer exists + (Slice 3/4). Creating the package now is premature (YAGNI); `architecture.md` reserves it. + +--- + +## 3. Architecture & components + +Isolated units, each with one purpose and a defined interface. + +1. **`core/engine` · `elementToNodeConfig(element)` — the single source of truth.** + A pure function mapping an `Element`'s props to the Konva node config object. `renderScreen` + is refactored to build nodes from it (`new Konva.Text(elementToNodeConfig(el))`); the editor + stage feeds the *same* config into react-konva (``). One + map, two thin construction sites. `renderScreen`'s output pixels are unchanged — guaranteed by + the Phase 0 parity gate (§7). This lives in `core` (framework-agnostic) so both the imperative + export renderer and the React editor depend on it, not on each other. + +2. **UI stack scaffold (`apps/web`, greenfield).** Tailwind CSS, Zustand + Immer, react-konva. + This is prerequisite plumbing — `apps/web` is currently only the `/render` host (next + konva + + react). Kept in `apps/web`, not a new package (see §2 defaults). **shadcn/ui is deferred** to the + first slice that renders a panel/dialog/select (Slice 3): this slice has no such component, and + installing it now is scaffolding with zero consumers (YAGNI). + +3. **`editorStore` (Zustand + Immer).** Holds `{ project, activeScreenId, selectedId }`. Actions: + `load(project)`, `select(id | null)`, `patchElement(id, partial)`, `save()`. Every mutation is + an Immer producer, so each change is a discrete patch — the structural basis for undo/redo + without a rewrite. The store is the only writer of project state; the canvas dispatches actions, + it never mutates the project directly. + +4. **`EditorStage` (react-konva).** Renders the active screen's background and elements via + `elementToNodeConfig`, overlays a `Transformer` bound to `selectedId`, and wires interaction: + `onClick` → `select`; Transformer `transformend` / `dragend` → `patchElement` with the new + geometry; double-click on a `text` node → inline edit → `patchElement({ content })`. Pan/zoom is + stage-level (scale + position), not persisted to the project (it is view state, not document + state). + +5. **API route `app/api/project/route.ts` (GET / PUT).** Wraps `LocalFileStorageAdapter` server-side + (it is `node:fs` and cannot run in the browser). GET returns the parsed project; PUT validates + the incoming body with the same strict `core` loader before writing — an invalid project is + rejected, never written. The project path resolves the same way `/render` resolves `?project=` + (query/env), consistent with the existing dev-only, self-hosted local-file model. + +--- + +## 4. Data flow + +``` +canvas interaction → store action → Immer patch → react-konva re-render (elementToNodeConfig) + → PUT /api/project → disk JSON +``` + +Export is unchanged and shares the same map: + +``` +disk JSON → /render → renderScreen (elementToNodeConfig) → Stage.toDataURL → PNG +``` + +One `elementToNodeConfig`, two constructors (`new Konva.*` for export, JSX for the editor). That +shared map *is* the thesis. + +--- + +## 5. Error handling & states (`editor.md` §7) + +- **Invalid JSON on load** (GET parse fail, or PUT rejected by the validator) → a blocking error + surfacing the validator message. Never render or persist an invalid project. +- **Empty project / missing asset** — out of this slice (there is no `screenshot` type yet, and + the sample fixture already ships `text` + `shape` elements to edit). + +--- + +## 6. Interfaces (contracts between units) + +- `elementToNodeConfig(element: Element): KonvaConfig` — pure, no side effects, deterministic. +- `editorStore` actions as in §3 — the canvas depends on these, not on store internals. +- `GET /api/project → Project` · `PUT /api/project(Project) → 200 | 4xx{message}` — the browser's + only persistence channel; it depends on this shape, not on `LocalFileStorageAdapter`. + +Someone can understand each unit without reading the others' internals; the mapper's callers can +change (add a new construction site) without changing the mapper. + +--- + +## 7. Testing + +- **Parity regression (non-negotiable gate).** The existing Phase 0 parity e2e + (`e2e/parity.test.ts`) must pass **unchanged** after `renderScreen` is refactored onto + `elementToNodeConfig` — this is the proof that export pixels did not shift. Any drift here blocks + the slice. +- **Unit — `elementToNodeConfig`.** Prop mapping for `text` and `shape` (weight→fontStyle, + radius→cornerRadius, opacity/rotation, etc.). +- **Unit — `editorStore`.** `patchElement` and `select` produce the expected next state; mutations + are patches, not in-place edits. +- **e2e (Playwright, already in the stack).** load → drag an element → save → reload preserves the + new position. Light; proves the full store↔canvas↔disk loop end to end. + +--- + +## 8. Definition of done + +- `elementToNodeConfig` exists in `core/engine`; `renderScreen` uses it; parity e2e passes + unchanged. +- The editor stage renders the sample project, supports select/move/resize/rotate + inline text + edit, all mutations flow through the Immer patch store, and save/load round-trips through the API + route to the same on-disk JSON. +- No second react-konva rendering path exists; export still goes through `/render`. +- Unit + e2e tests above are green. Out-of-scope items (§2) are absent, not half-built. From f68b270656c00e3d8742068402be5a6005c51d0b Mon Sep 17 00:00:00 2001 From: Vitalii Lavreniuk Date: Sat, 4 Jul 2026 15:25:03 +0300 Subject: [PATCH 019/368] docs: add phase 1 slice 1 implementation plan --- ...-07-04-phase1-slice1-interactive-canvas.md | 1001 +++++++++++++++++ 1 file changed, 1001 insertions(+) create mode 100644 docs/plans/2026-07-04-phase1-slice1-interactive-canvas.md diff --git a/docs/plans/2026-07-04-phase1-slice1-interactive-canvas.md b/docs/plans/2026-07-04-phase1-slice1-interactive-canvas.md new file mode 100644 index 00000000..7b68f693 --- /dev/null +++ b/docs/plans/2026-07-04-phase1-slice1-interactive-canvas.md @@ -0,0 +1,1001 @@ +# Phase 1 · Slice 1 — Interactive Canvas + Render-Reuse Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build an interactive Konva editor for one screen that shares the single element-render source of truth with the export path, proving Phase 1's core thesis without forking a second renderer. + +**Architecture:** A pure `elementToNodeConfig(element)` map in `core/engine` becomes the one place element props turn into Konva props; the existing static `renderScreen` (export) and a new react-konva `EditorStage` (editor) both consume it. Editor state is a framework-agnostic Zustand+Immer store (vanilla store + React binding); persistence is a disk-backed Next API route wrapping `LocalFileStorageAdapter`. + +**Tech Stack:** TypeScript, Konva 9 + react-konva 19, Zustand + Immer, Next.js 15 (App Router) + React 19, Tailwind CSS v4, Zod (via `core`), Vitest (unit) + Playwright (e2e). + +## Global Constraints + +- **Node.js ≥ 20**; package manager is **pnpm 9** (`packageManager: pnpm@9.15.9`). +- **Render/export parity is rule #1.** There must be exactly one element-rendering source of truth (`elementToNodeConfig`) and one export path (`/render` → `renderScreen`). Never add a second react-konva tree for export. +- **The Zod schema is not modified in this slice.** Only existing element types `text` and `shape` are used. Schema widening is Slice 2. +- **`core` stays framework-agnostic** — it may depend on Konva + Zod, never on React/Next. The editor store and API route live in `apps/web`, not `core`. +- **Strict validation on every load/save.** Invalid project JSON must fail loudly with the validator message (`ProjectValidationError`), never be rendered or written. +- **Commit prefixes:** `feat` / `fix` / `refactor` / `chore` / `test` / `docs`. Imperative mood, no trailing period. **Never** add a `Co-Authored-By` trailer. +- **Unit tests:** `pnpm test` (Vitest, node env). **Parity/e2e:** `pnpm test:e2e`. Typecheck: `pnpm typecheck`. +- Existing `apps/web/next.config.mjs` already stubs `canvas: false` and sets `extensionAlias` for `.js`→`.ts`; keep both — react-konva relies on the `canvas` stub. + +--- + +### Task 1: `elementToNodeConfig` — the single render source of truth + +**Files:** +- Create: `packages/core/src/engine/node-config.ts` +- Test: `packages/core/src/engine/node-config.test.ts` +- Modify: `packages/core/src/engine/render.ts` (drawElement → use the map) +- Modify: `packages/core/src/engine/index.ts` (re-export) + +**Interfaces:** +- Consumes: `Element`, `TextElement`, `ShapeElement` from `../model/schema.js`. +- Produces: + - `type NodeConfig = { konva: "Text"; config: Konva.TextConfig } | { konva: "Rect"; config: Konva.RectConfig }` + - `function elementToNodeConfig(element: Element): NodeConfig` + Both `render.ts` (Task 1) and `EditorStage` (Task 5) rely on these exact names/shapes. + +- [ ] **Step 1: Write the failing test** + +Create `packages/core/src/engine/node-config.test.ts`: + +```ts +import { describe, it, expect } from "vitest"; +import { elementToNodeConfig } from "./node-config.js"; +import type { TextElement, ShapeElement } from "../model/schema.js"; + +const baseText: TextElement = { + id: "t1", type: "text", x: 10, y: 20, width: 300, height: 100, + rotation: 5, opacity: 0.8, locked: false, visible: true, + content: "Hi", fontFamily: "Pacifico", size: 96, weight: 600, + lineHeight: 1.2, letterSpacing: 2, align: "center", color: "#FFFFFF", +}; + +const baseShape: ShapeElement = { + id: "s1", type: "shape", x: 0, y: 0, width: 50, height: 40, + rotation: 0, opacity: 1, locked: false, visible: true, + kind: "rect", fill: "#FF0000", radius: 8, +}; + +describe("elementToNodeConfig", () => { + it("maps a text element to a Konva Text config", () => { + const result = elementToNodeConfig(baseText); + expect(result.konva).toBe("Text"); + expect(result.config).toMatchObject({ + id: "t1", x: 10, y: 20, width: 300, height: 100, + rotation: 5, opacity: 0.8, text: "Hi", fontFamily: "Pacifico", + fontSize: 96, fontStyle: "600", lineHeight: 1.2, + letterSpacing: 2, align: "center", fill: "#FFFFFF", + }); + }); + + it("maps a shape element to a Konva Rect config", () => { + const result = elementToNodeConfig(baseShape); + expect(result.konva).toBe("Rect"); + expect(result.config).toMatchObject({ + id: "s1", x: 0, y: 0, width: 50, height: 40, + rotation: 0, opacity: 1, fill: "#FF0000", cornerRadius: 8, + }); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pnpm test -- node-config` +Expected: FAIL — `Cannot find module './node-config.js'`. + +- [ ] **Step 3: Write the implementation** + +Create `packages/core/src/engine/node-config.ts`: + +```ts +import type Konva from "konva"; +import type { Element } from "../model/schema.js"; + +/** + * The single element→Konva-props map (docs/specs/2026-07-04-phase1-slice1-...): both the static + * export renderer (`renderScreen`) and the interactive editor stage build nodes from this exact + * output, so UI and CLI can never render an element two different ways. Pure and side-effect free + * — it maps document props to visual props only. Interaction props (draggable, listeners) are the + * editor's concern and are added by the caller, never here, so the export config stays identical. + */ +export type NodeConfig = + | { konva: "Text"; config: Konva.TextConfig } + | { konva: "Rect"; config: Konva.RectConfig }; + +export function elementToNodeConfig(element: Element): NodeConfig { + const common = { + id: element.id, + x: element.x, + y: element.y, + rotation: element.rotation, + opacity: element.opacity, + }; + + if (element.type === "text") { + return { + konva: "Text", + config: { + ...common, + width: element.width, + height: element.height, + text: element.content, + fontFamily: element.fontFamily, + fontSize: element.size, + // Konva folds fontStyle into the canvas font shorthand; a numeric weight string + // ("600 96px Family") is valid CSS, so this maps custom weights directly. + fontStyle: String(element.weight), + lineHeight: element.lineHeight, + letterSpacing: element.letterSpacing, + align: element.align, + fill: element.color, + }, + }; + } + + return { + konva: "Rect", + config: { + ...common, + width: element.width, + height: element.height, + fill: element.fill, + cornerRadius: element.radius, + }, + }; +} +``` + +- [ ] **Step 4: Run the test to verify it passes** + +Run: `pnpm test -- node-config` +Expected: PASS (2 tests). + +- [ ] **Step 5: Refactor `renderScreen` onto the map** + +In `packages/core/src/engine/render.ts`, replace the body of `drawElement` (the `if (element.type === "shape")` / `if (element.type === "text")` blocks) with: + +```ts +import Konva from "konva"; +import type { Project, Screen, Element } from "../model/schema.js"; +import { getScreen } from "../model/index.js"; +import { elementToNodeConfig } from "./node-config.js"; + +// ... renderScreen and drawBackground unchanged ... + +function drawElement(layer: Konva.Layer, element: Element): void { + const { konva, config } = elementToNodeConfig(element); + layer.add(konva === "Text" ? new Konva.Text(config) : new Konva.Rect(config)); +} +``` + +(Keep the file's existing header comment, imports for `renderScreen`/`drawBackground`, and their bodies as-is.) + +- [ ] **Step 6: Re-export from the engine barrel** + +In `packages/core/src/engine/index.ts`, add: + +```ts +export { renderScreen } from "./render.js"; +export { elementToNodeConfig, type NodeConfig } from "./node-config.js"; +``` + +- [ ] **Step 7: Run unit tests + typecheck** + +Run: `pnpm test` then `pnpm typecheck` +Expected: all unit tests PASS; typecheck clean. + +- [ ] **Step 8: Run the parity gate (proves export pixels did not shift)** + +Run: `pnpm test:e2e` +Expected: `e2e/parity.test.ts` PASSES unchanged — the refactor did not move export output. **If this fails, stop and fix before continuing; this is the slice's non-negotiable gate.** + +- [ ] **Step 9: Commit** + +```bash +git add packages/core/src/engine/node-config.ts packages/core/src/engine/node-config.test.ts packages/core/src/engine/render.ts packages/core/src/engine/index.ts +git commit -m "refactor: extract elementToNodeConfig as the single render source of truth" +``` + +--- + +### Task 2: Editor store (Zustand + Immer) + +**Files:** +- Create: `apps/web/lib/editor-store.ts` +- Test: `apps/web/lib/editor-store.test.ts` +- Modify: `apps/web/package.json` (add `zustand`, `immer`) +- Modify: `vitest.config.ts` (include `apps/**` unit tests) + +**Interfaces:** +- Consumes: `Project`, `Element`, `TextElement` from `@screenshot-studio/core/model`. +- Produces: + - `type ElementPatch = Partial>` + - `editorStore` — a Zustand **vanilla** store (`createStore`) with state `{ project: Project | null; activeScreenId: string | null; selectedId: string | null }` and actions `load(project)`, `select(id | null)`, `patchElement(id, patch)`. + `EditorStage` (Task 5) and the editor page (Task 4) consume these exact names. + +- [ ] **Step 1: Add dependencies** + +Run: `pnpm --filter @screenshot-studio/web add zustand immer` +Expected: `zustand` and `immer` appear under `apps/web/package.json` dependencies. + +- [ ] **Step 2: Broaden the unit test glob to cover `apps/web`** + +In `vitest.config.ts`, change the `include` line to: + +```ts + include: ["packages/**/*.test.ts", "apps/**/*.test.ts"], +``` + +Leave the existing `exclude` (`**/node_modules/**`, `**/dist/**`, `e2e/**`) as-is, and add `**/.next/**` to it: + +```ts + exclude: ["**/node_modules/**", "**/dist/**", "**/.next/**", "e2e/**"], +``` + +- [ ] **Step 3: Write the failing test** + +Create `apps/web/lib/editor-store.test.ts`: + +```ts +import { describe, it, expect, beforeEach } from "vitest"; +import { editorStore } from "./editor-store.js"; +import type { Project } from "@screenshot-studio/core/model"; + +function project(): Project { + return { + meta: { name: "T", schemaVersion: 1 }, + platforms: ["apple"], + locales: ["en"], + fonts: [], + screens: [{ + id: "hero", name: "Hero", platform: "apple", device: "iphone", locale: "en", + artboard: { width: 660, height: 1434 }, + background: { type: "solid", color: "#000000" }, + elements: [{ + id: "headline", type: "text", x: 40, y: 100, width: 580, height: 200, + rotation: 0, opacity: 1, locked: false, visible: true, + content: "Hello", fontFamily: "Pacifico", size: 72, weight: 400, + lineHeight: 1.2, letterSpacing: 0, align: "left", color: "#FFFFFF", + }], + }], + }; +} + +describe("editorStore", () => { + beforeEach(() => { + editorStore.setState({ project: null, activeScreenId: null, selectedId: null }); + }); + + it("load sets the project and the first screen as active", () => { + editorStore.getState().load(project()); + const s = editorStore.getState(); + expect(s.project?.meta.name).toBe("T"); + expect(s.activeScreenId).toBe("hero"); + expect(s.selectedId).toBeNull(); + }); + + it("select sets the selected id", () => { + editorStore.getState().load(project()); + editorStore.getState().select("headline"); + expect(editorStore.getState().selectedId).toBe("headline"); + }); + + it("patchElement updates geometry immutably (new project reference)", () => { + editorStore.getState().load(project()); + const before = editorStore.getState().project!; + editorStore.getState().patchElement("headline", { x: 123, y: 456 }); + const after = editorStore.getState().project!; + expect(after).not.toBe(before); // new reference — patch, not in-place mutation + expect(after.screens[0]!.elements[0]!).toMatchObject({ x: 123, y: 456 }); + expect(before.screens[0]!.elements[0]!.x).toBe(40); // original untouched + }); +}); +``` + +- [ ] **Step 4: Run test to verify it fails** + +Run: `pnpm test -- editor-store` +Expected: FAIL — `Cannot find module './editor-store.js'`. + +- [ ] **Step 5: Write the implementation** + +Create `apps/web/lib/editor-store.ts`: + +```ts +import { createStore } from "zustand/vanilla"; +import { produce } from "immer"; +import type { Project, TextElement } from "@screenshot-studio/core/model"; + +/** + * Editor state as a framework-agnostic Zustand vanilla store, bound to React via `useStore` in + * components. Every mutation goes through Immer, so each change is a discrete immutable patch — + * the day-0 requirement (roadmap.md §1) that lets undo/redo be added later without a rewrite. + * The store is the only writer of project state; the canvas dispatches actions, never mutates. + */ +export type ElementPatch = Partial< + Pick +>; + +export interface EditorState { + project: Project | null; + activeScreenId: string | null; + selectedId: string | null; + load: (project: Project) => void; + select: (id: string | null) => void; + patchElement: (id: string, patch: ElementPatch) => void; +} + +export const editorStore = createStore((set) => ({ + project: null, + activeScreenId: null, + selectedId: null, + load: (project) => + set({ project, activeScreenId: project.screens[0]?.id ?? null, selectedId: null }), + select: (id) => set({ selectedId: id }), + patchElement: (id, patch) => + set((state) => { + if (!state.project) return state; + const project = produce(state.project, (draft) => { + for (const screen of draft.screens) { + const el = screen.elements.find((e) => e.id === id); + if (el) Object.assign(el, patch); + } + }); + return { project }; + }), +})); +``` + +- [ ] **Step 6: Run the test to verify it passes** + +Run: `pnpm test -- editor-store` +Expected: PASS (3 tests). + +- [ ] **Step 7: Commit** + +```bash +git add apps/web/lib/editor-store.ts apps/web/lib/editor-store.test.ts apps/web/package.json pnpm-lock.yaml vitest.config.ts +git commit -m "feat: add zustand+immer editor store with patch-based mutations" +``` + +--- + +### Task 3: Disk-backed project API route + +**Files:** +- Create: `apps/web/lib/project-path.ts` +- Create: `apps/web/app/api/project/route.ts` +- Test: `apps/web/app/api/project/route.test.ts` + +**Interfaces:** +- Consumes: `LocalFileStorageAdapter` from `@screenshot-studio/core/storage`; `parseProject`, `ProjectValidationError` from `@screenshot-studio/core/model`; `resolveProjectPath` from `./project-path` (Task 3). +- Produces: Next route handlers `GET(): Promise` and `PUT(req: Request): Promise` at `/api/project`. `GET` → `200 {project}` or `4xx {error}`; `PUT` validates the body and → `200 {ok:true}` or `400 {error}`. The editor page (Task 4) and save wiring (Task 5) consume this contract. + +- [ ] **Step 1: Write the path resolver** + +Create `apps/web/lib/project-path.ts`: + +```ts +import { resolve } from "node:path"; + +/** + * Resolves the on-disk project JSON the editor reads and writes. Same local-file, self-hosted + * model as the /render route: the path comes from PROJECT_PATH (env), defaulting to the + * repo-relative sample so the editor is runnable out of the box. Server-only (uses node:path). + */ +export function resolveProjectPath(): string { + return resolve(process.env.PROJECT_PATH ?? "fixtures/phase-0-sample/app-store-screenshots.json"); +} +``` + +- [ ] **Step 2: Write the failing test** + +Create `apps/web/app/api/project/route.test.ts`: + +```ts +import { describe, it, expect, beforeEach, afterEach } from "vitest"; +import { writeFileSync, mkdtempSync, rmSync, readFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { GET, PUT } from "./route.js"; + +const validProject = { + meta: { name: "T", schemaVersion: 1 }, + platforms: ["apple"], locales: ["en"], fonts: [], + screens: [{ + id: "hero", name: "Hero", platform: "apple", device: "iphone", locale: "en", + artboard: { width: 660, height: 1434 }, + background: { type: "solid", color: "#000000" }, + elements: [], + }], +}; + +let dir: string; +let file: string; + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), "proj-")); + file = join(dir, "app-store-screenshots.json"); + writeFileSync(file, JSON.stringify(validProject)); + process.env.PROJECT_PATH = file; +}); + +afterEach(() => { + delete process.env.PROJECT_PATH; + rmSync(dir, { recursive: true, force: true }); +}); + +describe("GET /api/project", () => { + it("returns the parsed project", async () => { + const res = await GET(); + expect(res.status).toBe(200); + const body = await res.json(); + expect(body.meta.name).toBe("T"); + }); +}); + +describe("PUT /api/project", () => { + it("validates and writes a valid project to disk", async () => { + const next = structuredClone(validProject); + next.meta.name = "Renamed"; + const res = await PUT(new Request("http://x/api/project", { + method: "PUT", body: JSON.stringify(next), + })); + expect(res.status).toBe(200); + expect(JSON.parse(readFileSync(file, "utf8")).meta.name).toBe("Renamed"); + }); + + it("rejects an invalid project with 400 and does not write", async () => { + const res = await PUT(new Request("http://x/api/project", { + method: "PUT", body: JSON.stringify({ meta: { name: "" } }), + })); + expect(res.status).toBe(400); + // original file untouched + expect(JSON.parse(readFileSync(file, "utf8")).meta.name).toBe("T"); + }); +}); +``` + +- [ ] **Step 3: Run test to verify it fails** + +Run: `pnpm test -- api/project` +Expected: FAIL — `Cannot find module './route.js'`. + +- [ ] **Step 4: Write the route handlers** + +Create `apps/web/app/api/project/route.ts`: + +```ts +import { LocalFileStorageAdapter } from "@screenshot-studio/core/storage"; +import { parseProject, ProjectValidationError } from "@screenshot-studio/core/model"; +import { dirname } from "node:path"; +import { resolveProjectPath } from "../../../lib/project-path.js"; + +/** + * The editor's only persistence channel (spec §5): the browser reads/writes the same on-disk + * app-store-screenshots.json the CLI and /render use, via LocalFileStorageAdapter. PUT validates + * with the same strict core loader before writing — an invalid project is rejected, never saved. + * Dev-only, local, self-hosted; arbitrary local file read is acceptable here (same as /render). + */ +export const dynamic = "force-dynamic"; + +function adapter(path: string): LocalFileStorageAdapter { + return new LocalFileStorageAdapter(dirname(path)); +} + +export async function GET(): Promise { + const path = resolveProjectPath(); + try { + const project = await adapter(path).load(path); + return Response.json(project); + } catch (err) { + const status = err instanceof ProjectValidationError ? 422 : 404; + return Response.json({ error: (err as Error).message }, { status }); + } +} + +export async function PUT(req: Request): Promise { + const path = resolveProjectPath(); + let project; + try { + project = parseProject(await req.json()); + } catch (err) { + return Response.json({ error: (err as Error).message }, { status: 400 }); + } + await adapter(path).save(project, path); + return Response.json({ ok: true }); +} +``` + +- [ ] **Step 5: Run the test to verify it passes** + +Run: `pnpm test -- api/project` +Expected: PASS (3 tests). + +- [ ] **Step 6: Commit** + +```bash +git add apps/web/lib/project-path.ts apps/web/app/api/project/route.ts apps/web/app/api/project/route.test.ts +git commit -m "feat: add disk-backed project API route with strict validation" +``` + +--- + +### Task 4: Tailwind scaffold + static editor page + +**Files:** +- Modify: `apps/web/package.json` (add `react-konva`, `tailwindcss`, `@tailwindcss/postcss`, `postcss`) +- Create: `apps/web/postcss.config.mjs` +- Create: `apps/web/app/globals.css` +- Modify: `apps/web/app/layout.tsx` (import globals) +- Create: `apps/web/components/EditorStage.tsx` (static render only) +- Create: `apps/web/app/editor/page.tsx` + +**Interfaces:** +- Consumes: `elementToNodeConfig` from `@screenshot-studio/core/engine`; `registerProjectFonts` from `@screenshot-studio/core/fonts`; `editorStore` from `../lib/editor-store.js`; `GET /api/project` (Task 3). +- Produces: `EditorStage` React component (client, react-konva) rendering the active screen; `/editor` page that loads the project into the store and mounts `EditorStage` client-side. Task 5 extends `EditorStage` with interaction. + +- [ ] **Step 1: Add dependencies** + +Run: `pnpm --filter @screenshot-studio/web add react-konva && pnpm --filter @screenshot-studio/web add -D tailwindcss @tailwindcss/postcss postcss` +Expected: `react-konva` in dependencies; `tailwindcss`, `@tailwindcss/postcss`, `postcss` in devDependencies. + +- [ ] **Step 2: Configure PostCSS + Tailwind entry** + +Create `apps/web/postcss.config.mjs`: + +```js +const config = { + plugins: { + "@tailwindcss/postcss": {}, + }, +}; + +export default config; +``` + +Create `apps/web/app/globals.css`: + +```css +@import "tailwindcss"; +``` + +- [ ] **Step 3: Import globals in the root layout** + +In `apps/web/app/layout.tsx`, add the stylesheet import at the top (keep the rest of the file unchanged): + +```tsx +import type { ReactNode } from "react"; +import "./globals.css"; + +export const metadata = { + title: "Screenshot Studio", + description: "Phase 0 render host", +}; + +export default function RootLayout({ children }: { children: ReactNode }) { + return ( + + {children} + + ); +} +``` + +- [ ] **Step 4: Write the static `EditorStage` component** + +Create `apps/web/components/EditorStage.tsx`. Lives outside `app/` per react-konva's Next.js guidance; it is dynamically imported with `ssr:false` in Step 5. + +```tsx +"use client"; + +import { Stage, Layer, Text, Rect } from "react-konva"; +import { useStore } from "zustand"; +import { getScreen } from "@screenshot-studio/core/model"; +import { elementToNodeConfig } from "@screenshot-studio/core/engine"; +import { editorStore } from "../lib/editor-store"; + +/** + * Interactive editor canvas. Renders the active screen's elements through the SAME + * elementToNodeConfig map the export renderer uses (spec §1) — never a parallel react-konva tree + * with its own prop logic. Interaction (selection, transform, inline edit) is layered on in a + * later task; this version is the static read-only render. + */ +export function EditorStage() { + const project = useStore(editorStore, (s) => s.project); + const activeScreenId = useStore(editorStore, (s) => s.activeScreenId); + if (!project || !activeScreenId) return null; + + const screen = getScreen(project, activeScreenId); + const { width, height } = screen.artboard; + + return ( + + + {screen.background.type === "solid" && ( + + )} + {screen.elements.map((element) => { + if (!element.visible) return null; + const { konva, config } = elementToNodeConfig(element); + return konva === "Text" ? ( + + ) : ( + + ); + })} + + + ); +} +``` + +- [ ] **Step 5: Write the `/editor` page** + +Create `apps/web/app/editor/page.tsx`: + +```tsx +"use client"; + +import { useEffect, useState } from "react"; +import dynamic from "next/dynamic"; +import { parseProject } from "@screenshot-studio/core/model"; +import { registerProjectFonts } from "@screenshot-studio/core/fonts"; +import { editorStore } from "../../lib/editor-store"; + +// react-konva needs the DOM; load the stage client-only (no SSR). +const EditorStage = dynamic( + () => import("../../components/EditorStage").then((m) => m.EditorStage), + { ssr: false }, +); + +export default function EditorPage() { + const [error, setError] = useState(null); + const [ready, setReady] = useState(false); + + useEffect(() => { + (async () => { + try { + const res = await fetch("/api/project"); + const body = await res.json(); + if (!res.ok) throw new Error(body.error ?? "Failed to load project"); + const project = parseProject(body); + await registerProjectFonts(project.fonts); // fonts before first paint (parity) + editorStore.getState().load(project); + setReady(true); + } catch (err) { + setError((err as Error).message); + } + })(); + }, []); + + if (error) return
{error}
; + if (!ready) return
Loading…
; + return ( +
+ +
+ ); +} +``` + +- [ ] **Step 6: Typecheck and build** + +Run: `pnpm --filter @screenshot-studio/web typecheck && pnpm --filter @screenshot-studio/web build` +Expected: both succeed with no errors. + +- [ ] **Step 7: Manual smoke check** + +Run: `pnpm --filter @screenshot-studio/web dev` then open `http://localhost:3000/editor`. +Expected: the Phase 0 sample screen renders (dark artboard, "accent" rectangle, "headline" text in Pacifico). Stop the dev server after confirming. + +- [ ] **Step 8: Commit** + +```bash +git add apps/web/package.json pnpm-lock.yaml apps/web/postcss.config.mjs apps/web/app/globals.css apps/web/app/layout.tsx apps/web/components/EditorStage.tsx apps/web/app/editor/page.tsx +git commit -m "feat: add tailwind scaffold and static editor canvas over the shared render map" +``` + +--- + +### Task 5: Selection, transform, inline text edit, and save + +**Files:** +- Modify: `apps/web/components/EditorStage.tsx` (add interaction + Transformer + inline edit) +- Create: `apps/web/lib/save-project.ts` + +**Interfaces:** +- Consumes: `editorStore` actions `select`, `patchElement` (Task 2); `PUT /api/project` (Task 3). +- Produces: `saveProject(project: Project): Promise` in `save-project.ts`; an `EditorStage` that selects on click, moves/resizes/rotates the selected element via a Konva `Transformer`, edits `text` inline on double-click, and persists each committed change. + +- [ ] **Step 1: Write the save helper** + +Create `apps/web/lib/save-project.ts`: + +```ts +import type { Project } from "@screenshot-studio/core/model"; + +/** Persist the project to disk through the API route (spec §4). Throws on a validation reject. */ +export async function saveProject(project: Project): Promise { + const res = await fetch("/api/project", { + method: "PUT", + headers: { "content-type": "application/json" }, + body: JSON.stringify(project), + }); + if (!res.ok) { + const body = await res.json().catch(() => ({})); + throw new Error(body.error ?? `Save failed (${res.status})`); + } +} +``` + +- [ ] **Step 2: Rewrite `EditorStage` with interaction** + +Replace the contents of `apps/web/components/EditorStage.tsx` with: + +```tsx +"use client"; + +import { useEffect, useRef, useState } from "react"; +import Konva from "konva"; +import { Stage, Layer, Text, Rect, Transformer } from "react-konva"; +import { useStore } from "zustand"; +import { getScreen } from "@screenshot-studio/core/model"; +import { elementToNodeConfig } from "@screenshot-studio/core/engine"; +import { editorStore, type ElementPatch } from "../lib/editor-store"; +import { saveProject } from "../lib/save-project"; + +/** + * Interactive editor canvas. Elements are rendered through the SAME elementToNodeConfig map the + * export renderer uses (spec §1). Interaction props (draggable, listeners) and the Transformer + * are layered on here only — they never touch the shared map, so export output is unaffected. + * Each committed change flows through the store (Immer patch) and is persisted via saveProject. + */ +export function EditorStage() { + const project = useStore(editorStore, (s) => s.project); + const activeScreenId = useStore(editorStore, (s) => s.activeScreenId); + const selectedId = useStore(editorStore, (s) => s.selectedId); + + const trRef = useRef(null); + const nodeRefs = useRef(new Map()); + const [editing, setEditing] = useState<{ id: string; value: string } | null>(null); + + // Keep the Transformer attached to whatever node is selected. + useEffect(() => { + const tr = trRef.current; + if (!tr) return; + const node = selectedId ? nodeRefs.current.get(selectedId) : undefined; + tr.nodes(node ? [node] : []); + tr.getLayer()?.batchDraw(); + }, [selectedId, project]); + + if (!project || !activeScreenId) return null; + const screen = getScreen(project, activeScreenId); + const { width, height } = screen.artboard; + + const commit = (id: string, patch: ElementPatch) => { + editorStore.getState().patchElement(id, patch); + const next = editorStore.getState().project; + if (next) void saveProject(next); + }; + + const onDragEnd = (id: string) => (e: Konva.KonvaEventObject) => { + commit(id, { x: e.target.x(), y: e.target.y() }); + }; + + // Konva applies scale on transform; bake it into width/height and reset scale to 1. + const onTransformEnd = (id: string) => (e: Konva.KonvaEventObject) => { + const node = e.target; + const scaleX = node.scaleX(); + const scaleY = node.scaleY(); + node.scaleX(1); + node.scaleY(1); + commit(id, { + x: node.x(), + y: node.y(), + rotation: node.rotation(), + width: Math.max(5, node.width() * scaleX), + height: Math.max(5, node.height() * scaleY), + }); + }; + + return ( +
+ { + // Click on empty stage clears the selection. + if (e.target === e.target.getStage()) editorStore.getState().select(null); + }} + > + + {screen.background.type === "solid" && ( + + )} + {screen.elements.map((element) => { + if (!element.visible) return null; + const { konva, config } = elementToNodeConfig(element); + const interaction = { + draggable: !element.locked, + ref: (n: Konva.Node | null) => { + if (n) nodeRefs.current.set(element.id, n); + else nodeRefs.current.delete(element.id); + }, + onClick: () => editorStore.getState().select(element.id), + onTap: () => editorStore.getState().select(element.id), + onDragEnd: onDragEnd(element.id), + onTransformEnd: onTransformEnd(element.id), + }; + return konva === "Text" ? ( + setEditing({ id: element.id, value: (config as Konva.TextConfig).text ?? "" })} + /> + ) : ( + + ); + })} + + + + + {editing && ( +