From 941d7101dd3c8b7cdd790724c55ff00a90f42270 Mon Sep 17 00:00:00 2001 From: N0zoM1z0 <1705004398@qq.com> Date: Wed, 15 Jul 2026 21:06:06 +0800 Subject: [PATCH] feat(session): add explicit provider registry and target binding Introduce deterministic deep-provider discovery and immutable per-target routing while retaining disjoint artifact and native capability families. Expose provider selection consistently through MCP, CLI, environment configuration, session status, prompt completion, typed diagnostics, and generated documentation. Preserve exact provider/profile provenance without request racing or transparent fallback. Cover overlapping providers, ambiguity, rejection details, cancellation, restoration, package installation, and real Hopper target switching. --- AGENTS.md | 3 +- README.md | 51 +- ...rovider-selection-and-analysis-profiles.md | 29 +- docs/api/assets/hierarchy.js | 2 +- docs/api/assets/navigation.js | 2 +- docs/api/assets/search.js | 2 +- ...iderRegistry.AnalysisProviderRegistry.html | 162 +++++++ ...plication_BinarySession.BinarySession.html | 66 +-- ...n_CompositeProvider.CompositeProvider.html | 19 +- ...rmissionAuthority.PermissionPathError.html | 2 +- ...ocessCaptureError.ProcessCaptureError.html | 2 +- ...sionStore.ProjectPermissionStoreError.html | 2 +- ...nProviderRouter.SessionProviderRouter.html | 176 +++++++ ...CdpBrowserProvider.CdpBrowserProvider.html | 12 +- ...ser_CdpCaptureEvents.CdpCaptureEvents.html | 2 +- .../domain_errors.AnalysisCancelledError.html | 2 +- ...rs.AnalysisCapabilityUnavailableError.html | 2 +- .../classes/domain_errors.AnalysisError.html | 2 +- .../domain_errors.AnalysisInputError.html | 2 +- .../domain_errors.AnalysisOutputError.html | 2 +- .../domain_errors.AnalysisProtocolError.html | 2 +- .../domain_errors.AnalysisTimeoutError.html | 2 +- .../domain_errors.ArtifactOperationError.html | 14 +- .../domain_errors.BinaryTargetError.html | 10 +- ...domain_errors.BrowserObservationError.html | 12 +- .../domain_errors.ConfigurationError.html | 6 +- .../domain_errors.EvidenceFileError.html | 12 +- .../domain_errors.EvidenceIntegrityError.html | 6 +- .../domain_errors.EvidenceLimitError.html | 12 +- .../domain_errors.HopperCancelledError.html | 8 +- .../classes/domain_errors.HopperError.html | 2 +- .../domain_errors.HopperProcessError.html | 14 +- .../domain_errors.HopperProtocolError.html | 6 +- .../domain_errors.HopperRemoteError.html | 14 +- .../domain_errors.HopperStartError.html | 8 +- .../domain_errors.HopperTimeoutError.html | 10 +- ...in_errors.InvestigationWorkspaceError.html | 12 +- .../domain_errors.NoBinaryOpenError.html | 8 +- ...domain_errors.PermissionRequiredError.html | 18 +- .../domain_errors.ProviderAdapterError.html | 12 +- .../domain_errors.ProviderSelectionError.html | 52 +- .../domain_errors.UnknownRegistryError.html | 10 +- ...permissionPolicy.PermissionGrantError.html | 2 +- .../hopper_HopperProvider.HopperProvider.html | 57 ++- ...ion_AbortablePromise.waitForAbortable.html | 51 ++ ...lysisProvider.createAnalysisExecution.html | 2 +- ...ion.evaluateAnalysisProviderCandidate.html | 47 ++ ...tionService.compareWebCaptureEvidence.html | 4 +- ...ityInventory.buildCapabilityInventory.html | 4 +- ...iteProvider.compositeProviderIdentity.html | 44 ++ ...tion_DirectAnalysis.runDirectAnalysis.html | 6 +- ...on_DirectAnalysis.runProviderAnalysis.html | 2 +- ...ation_DirectAnalysis.runSessionStatus.html | 2 +- .../application_Doctor.runDoctor.html | 4 +- ...plication_runtime.createBinarySession.html | 2 +- ...rowser_CdpCaptureDocuments.captureDom.html | 4 +- ...pObservationSession.observeCdpSession.html | 4 +- ..._CdpSafeMetadata.safeResponseMetadata.html | 4 +- docs/api/functions/cli.createCli.html | 2 +- docs/api/functions/config.parseConfig.html | 2 +- ...toolOutputSchemas.requireOutputSchema.html | 2 +- .../domain_errors.projectAnalysisError.html | 2 +- ...ndleAnalyzer.analyzeCapturedWebBundle.html | 4 +- ...ain_webCaptureDiff.compareWebCaptures.html | 4 +- ...ysisProfile.hopperLoaderArgsForTarget.html | 2 +- ...sProfile.resolveHopperAnalysisProfile.html | 2 +- ...mpletion.createPromptCompletionSource.html | 2 +- ...sterSessionTools.registerSessionTools.html | 2 +- docs/api/hierarchy.html | 94 ++-- docs/api/index.html | 4 +- ...ation_AnalysisProvider.AnalysisClient.html | 8 +- ...on_AnalysisProvider.AnalysisExecution.html | 16 +- ...nalysisProvider.AnalysisOperationPort.html | 6 +- ...sisProvider.AnalysisProfileResolution.html | 6 +- ...ider.AnalysisProfileResolutionOptions.html | 58 +++ ...ion_AnalysisProvider.AnalysisProvider.html | 26 +- ...sisProvider.AnalysisProviderCandidate.html | 140 ++++++ ...ion_AnalysisProvider.ExecutionOptions.html | 6 +- ...ion_AnalysisProvider.ProviderIdentity.html | 8 +- ...n.AnalysisProviderCandidateEvaluation.html | 76 +++ ...viderRegistry.AnalysisProviderBinding.html | 82 ++++ ...istry.AnalysisProviderCandidateStatus.html | 98 ++++ ...derRegistry.AnalysisProviderSelection.html | 70 +++ ...n_BinarySessionPort.BinarySessionPort.html | 58 +-- ...bservationPort.BrowserObservationPort.html | 14 +- ...onProviderRouter.SessionProviderRoute.html | 110 +++++ .../application_Setup.SetupHost.html | 6 +- .../application_Setup.SetupResult.html | 4 +- .../browser_CdpPageCapture.CapturedPage.html | 4 +- docs/api/interfaces/config.AppConfig.html | 56 ++- ...domain_errors.AnalysisErrorProjection.html | 20 +- ..._errors.ProviderSelectionErrorOptions.html | 82 ++++ ...ain_errors.ProviderSelectionRejection.html | 76 +++ ...main_permissionPolicy.PermissionGrant.html | 2 +- ...in_permissionPolicy.PermissionRequest.html | 2 +- ...main_permissionPolicy.PermissionScope.html | 2 +- ...domain_webInventory.StableWebResource.html | 2 +- ...ebInventory.WebInventoryResourceInput.html | 2 +- ...omptCompletion.PromptCompletionSource.html | 4 +- ...gisterSessionTools.SessionToolOptions.html | 18 +- .../modules/application_AbortablePromise.html | 40 ++ .../modules/application_AnalysisProvider.html | 8 +- ...pplication_AnalysisProviderEvaluation.html | 40 ++ .../application_AnalysisProviderRegistry.html | 40 ++ .../application_CompositeProvider.html | 8 +- .../application_SessionProviderRouter.html | 40 ++ .../modules/contracts_providerSelection.html | 40 ++ docs/api/modules/domain_errors.html | 8 +- ...nalysisProvider.AnalysisClientFactory.html | 2 +- ...on_AnalysisProvider.AnalysisOperation.html | 2 +- ...AnalysisProvider.CapabilityDescriptor.html | 2 +- ...AnalysisProvider.ProviderAvailability.html | 35 ++ ...nalysisProvider.ProviderTargetSupport.html | 35 ++ ...derSelection.AnalysisProviderSelector.html | 33 ++ ...oviderSelection.ProviderRejectionCode.html | 35 ++ ...in_errors.BrowserObservationOperation.html | 2 +- .../domain_errors.HopperDiagnosticType.html | 2 +- ...errors.ProviderSelectionFailureReason.html | 35 ++ .../application_AbortablePromise.ABORTED.html | 35 ++ ...derSelection.PROVIDER_REJECTION_CODES.html | 35 ++ ...derSelection.analysisProviderIdSchema.html | 35 ++ ...ection.analysisProviderSelectorSchema.html | 35 ++ ...ifecycleInputs.closeBinaryInputSchema.html | 2 +- ...LifecycleInputs.openBinaryInputSchema.html | 4 +- ...olOutputSchemas.artifactOutputSchemas.html | 2 +- ...olOutputSchemas.enhancedOutputSchemas.html | 2 +- ...toolOutputSchemas.nativeOutputSchemas.html | 2 +- ...olOutputSchemas.officialOutputSchemas.html | 2 +- ...oolOutputSchemas.sessionOutputSchemas.html | 2 +- ...pperProvider.HOPPER_PROVIDER_IDENTITY.html | 2 +- ...ovider.HOPPER_PROVIDER_TOOL_CONTRACTS.html | 2 +- docs/architecture.mermaid | 16 +- docs/mcp-contracts.md | 11 + docs/mcp-prompts.md | 2 +- docs/product-catalog.json | 4 +- docs/provider-evaluation.md | 17 +- docs/roadmap.md | 9 +- docs/user-visible-errors.csv | 2 +- scripts/lib/product-catalog.d.mts | 4 + scripts/lib/product-catalog.mjs | 17 + scripts/verify-package.mjs | 52 +- scripts/verify-real-hopper.mjs | 83 +++- src/application/AbortablePromise.ts | 25 + src/application/AnalysisProvider.ts | 50 ++ src/application/AnalysisProviderEvaluation.ts | 118 +++++ src/application/AnalysisProviderRegistry.ts | 453 ++++++++++++++++++ src/application/BinarySession.ts | 277 ++++++----- src/application/BinarySessionPort.ts | 2 + src/application/CompositeProvider.ts | 35 +- src/application/DirectAnalysis.ts | 17 +- src/application/SessionProviderRouter.ts | 385 +++++++++++++++ src/application/runtime.ts | 22 +- src/cli.ts | 48 +- src/config.ts | 9 +- src/contracts/providerSelection.ts | 38 ++ src/contracts/sessionLifecycleInputs.ts | 2 + src/contracts/toolContracts.ts | 4 +- src/contracts/toolOutputSchemas.ts | 67 +++ src/domain/errors.ts | 110 ++++- src/hopper/HopperAnalysisProfile.ts | 42 +- src/hopper/HopperProvider.ts | 86 +++- src/server/promptCompletion.ts | 14 +- src/server/registerSessionTools.ts | 3 + tests/analysisProviderRegistry.test.ts | 417 ++++++++++++++++ tests/binarySession.test.ts | 29 ++ tests/compositeProvider.test.ts | 4 + tests/config.test.ts | 18 +- tests/directAnalysisPermissions.test.ts | 30 +- tests/hopperAnalysisProfile.test.ts | 20 + tests/hopperProviderSelection.test.ts | 92 ++++ tests/integration/configIntegration.test.ts | 5 +- tests/productCatalog.test.ts | 16 + tests/providerBinding.test.ts | 356 ++++++++++++++ tests/providerSelectionMcp.test.ts | 225 +++++++++ 174 files changed, 5370 insertions(+), 648 deletions(-) create mode 100644 docs/api/classes/application_AnalysisProviderRegistry.AnalysisProviderRegistry.html create mode 100644 docs/api/classes/application_SessionProviderRouter.SessionProviderRouter.html create mode 100644 docs/api/functions/application_AbortablePromise.waitForAbortable.html create mode 100644 docs/api/functions/application_AnalysisProviderEvaluation.evaluateAnalysisProviderCandidate.html create mode 100644 docs/api/functions/application_CompositeProvider.compositeProviderIdentity.html create mode 100644 docs/api/interfaces/application_AnalysisProvider.AnalysisProfileResolutionOptions.html create mode 100644 docs/api/interfaces/application_AnalysisProvider.AnalysisProviderCandidate.html create mode 100644 docs/api/interfaces/application_AnalysisProviderEvaluation.AnalysisProviderCandidateEvaluation.html create mode 100644 docs/api/interfaces/application_AnalysisProviderRegistry.AnalysisProviderBinding.html create mode 100644 docs/api/interfaces/application_AnalysisProviderRegistry.AnalysisProviderCandidateStatus.html create mode 100644 docs/api/interfaces/application_AnalysisProviderRegistry.AnalysisProviderSelection.html create mode 100644 docs/api/interfaces/application_SessionProviderRouter.SessionProviderRoute.html create mode 100644 docs/api/interfaces/domain_errors.ProviderSelectionErrorOptions.html create mode 100644 docs/api/interfaces/domain_errors.ProviderSelectionRejection.html create mode 100644 docs/api/modules/application_AbortablePromise.html create mode 100644 docs/api/modules/application_AnalysisProviderEvaluation.html create mode 100644 docs/api/modules/application_AnalysisProviderRegistry.html create mode 100644 docs/api/modules/application_SessionProviderRouter.html create mode 100644 docs/api/modules/contracts_providerSelection.html create mode 100644 docs/api/types/application_AnalysisProvider.ProviderAvailability.html create mode 100644 docs/api/types/application_AnalysisProvider.ProviderTargetSupport.html create mode 100644 docs/api/types/contracts_providerSelection.AnalysisProviderSelector.html create mode 100644 docs/api/types/contracts_providerSelection.ProviderRejectionCode.html create mode 100644 docs/api/types/domain_errors.ProviderSelectionFailureReason.html create mode 100644 docs/api/variables/application_AbortablePromise.ABORTED.html create mode 100644 docs/api/variables/contracts_providerSelection.PROVIDER_REJECTION_CODES.html create mode 100644 docs/api/variables/contracts_providerSelection.analysisProviderIdSchema.html create mode 100644 docs/api/variables/contracts_providerSelection.analysisProviderSelectorSchema.html create mode 100644 src/application/AbortablePromise.ts create mode 100644 src/application/AnalysisProviderEvaluation.ts create mode 100644 src/application/AnalysisProviderRegistry.ts create mode 100644 src/application/SessionProviderRouter.ts create mode 100644 src/contracts/providerSelection.ts create mode 100644 tests/analysisProviderRegistry.test.ts create mode 100644 tests/hopperProviderSelection.test.ts create mode 100644 tests/providerBinding.test.ts create mode 100644 tests/providerSelectionMcp.test.ts diff --git a/AGENTS.md b/AGENTS.md index f5fefa2c0..da5418f89 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -30,7 +30,7 @@ See [docs/architecture.mermaid](docs/architecture.mermaid) for a visual architec - `src/browser/`: loopback CDP discovery, bounded WebSocket transport, exact-origin target authorization, and passive browser observation normalization. - `src/hopper/`: Hopper launch and Unix-socket protocol mechanics. `BridgeLauncher.ts` spawns the Hopper app with the in-process bridge, `HopperClient.ts` correlates request/response over the socket with timeouts and cancellation, `protocol.ts` frames bridge messages. - `bridge/hopper_bridge.py`: runs inside Hopper and adapts declared operations to Hopper's public Python API. Hopper's bundled MCP server is not used. -- `src/application/`: shared CLI/MCP session composition, setup and diagnostics, and enhanced workflows. +- `src/application/`: shared CLI/MCP session composition, setup and diagnostics, and enhanced workflows. `AnalysisProviderRegistry` discovers overlapping deep candidates without starting them; `SessionProviderRouter` binds one candidate per target and composes it with disjoint auxiliary providers. - `src/server/`: MCP request translation. `createServer.ts` assembles the MCP server, `registerOfficialTools.ts`/`registerEnhancedTools.ts` register each tool set, `toolResult.ts` maps `Result` values to MCP content. - `docs/product-catalog.json`: generated package, tool-family, provider, setup-client, schema-version, and CLI facts. Regenerate it from source; do not edit it by hand. - `tests/`: Vitest suite. `tests/fixtures/` holds the fake launcher and fake Hopper bridge used as production seams. @@ -63,6 +63,7 @@ Pre-commit hooks via Husky run `oxlint` on staged files before every commit. Use ## Configuration & Environment Variables +- `REA_ANALYSIS_PROVIDER` (optional, default `auto`): require one deep-analysis provider ID for startup and one-shot commands, or use deterministic automatic selection. A request-level `provider_id`/`--provider` takes precedence. - `HOPPER_TARGET_PATH` (optional): absolute initial binary or `.hop` target. Target-free MCP sessions use `open_binary` instead. - `HOPPER_LAUNCHER_PATH` (optional): override the Hopper executable path (defaults to `/Applications/Hopper Disassembler.app/Contents/MacOS/hopper`). - `HOPPER_TARGET_KIND` (optional, default `executable`): startup kind for `HOPPER_TARGET_PATH`; dynamic targets are classified from their paths and headers. diff --git a/README.md b/README.md index 8ed655fa3..d4c141cb3 100644 --- a/README.md +++ b/README.md @@ -153,7 +153,7 @@ Choose either the no-install commands or the global installation. You do not nee - Node.js 22.19+ or 24.11+ (including newer releases) - npm; REA does not require or install a particular npm version -Deep binary analysis currently uses [Hopper](https://www.hopperapp.com/), a separate desktop application with its own license. Setup reuses an existing installation. If Hopper is missing, interactive setup proposes the official package and includes it in the confirmation plan. Unattended installation requires `rea setup --yes --install-hopper`. +Deep binary analysis currently uses [Hopper](https://www.hopperapp.com/), a separate desktop application with its own license. REA discovers it through the provider registry and binds it explicitly to each deep-analysis target; Ghidra is planned but is not shipped yet. Setup reuses an existing Hopper installation. If Hopper is missing, interactive setup proposes the official package and includes it in the confirmation plan. Unattended installation requires `rea setup --yes --install-hopper`. If something is not working, run: @@ -315,6 +315,7 @@ The public interface describes what the agent is trying to learn. Providers deci REA is already useful for native application, browser, and Electron investigation on supported macOS and Linux hosts: - Open Mach-O, ELF, PE, `.app`, ZIP, APK, IPA, ASAR, plist, JavaScript, source-map, and generic analysis-database targets; Hopper remains the only adapter that accepts legacy `.hop` databases. +- Discover deep-analysis candidates without starting them, choose deterministically, and retain one immutable provider/profile binding until an explicit switch or close; provider failures never trigger transparent fallback. - Attach to a user-owned Chrome-family browser over a configured loopback CDP endpoint; capture exact-origin web structure, safe metadata, approved value-free payload shapes, bundle/source-map evidence, WebMCP declarations, user-action timelines, capture diffs, and explicitly approved screenshots without navigation or JavaScript evaluation. - Inspect Electron `file://` renderer pages through a separate canonical-root permission boundary without invoking Electron APIs; script contents remain separately approved and byte bounded. - Traverse content-addressed artifact graphs without extraction; on macOS, read-only DMG traversal additionally requires `native_mount_approved: true` and `REA_ARTIFACT_NATIVE_MOUNT_ENABLED=true`. Materialize only approved occurrences into absent output roots. @@ -361,7 +362,7 @@ REA is growing into a toolkit for understanding software across static artifacts ### Now 1. **Maintain truthful product metadata** — extend the shipped canonical catalog and drift checks whenever versions, tools, providers, schemas, setup clients, or CLI capabilities change. -2. **A second deep-analysis provider** — add explicit target-to-provider binding and a read-only Ghidra provider for free, open-source Linux analysis without pretending Hopper and Ghidra results are textually identical. +2. **A second deep-analysis provider** — build the read-only Ghidra runtime on the shipped explicit registry and target-binding foundation for free, open-source Linux analysis without pretending Hopper and Ghidra results are textually identical. 3. **JavaScript application reconstruction** — connect packages, ASAR entries, main/preload/renderer bundles, source maps, Electron IPC boundaries, service-worker assets, and native add-ons in one evidence-bearing application graph. ### Next @@ -409,13 +410,14 @@ flowchart LR Agent["Agent"] --> REA["REA
CLI + MCP"] Terminal --> REA REA --> Workspace["Investigation workspace
evidence + artifacts + captures"] - Workspace --> Router["Capability router"] - Router --> Hopper["Hopper provider"] - Router --> Native["Native macOS provider"] - Router --> Artifact["Artifact graph provider"] - Router --> Browser["Browser CDP provider"] - Router --> Process["Process capture provider"] - Router -. roadmap .-> More["Dynamic and additional
static providers"] + REA --> Session["Target-bound session router"] + Session --> Registry["Deep-provider registry
deterministic selection"] + Registry --> Hopper["Hopper provider"] + Registry -. planned, not shipped .-> Ghidra["Ghidra provider"] + Session --> Native["Native macOS provider"] + Session --> Artifact["Artifact graph provider"] + REA --> Browser["Browser CDP provider"] + REA --> Process["Process capture provider"] Hopper --> Target["Target software"] Process --> Target Native --> Target @@ -457,6 +459,37 @@ rea mcp REA accepts a Mac `.app` folder directly. If an agent cannot find an app by name, tell it where the app is installed. +### Choosing a deep-analysis provider + +Every deep-analysis open resolves a provider before creating its client. The +same selector and precedence apply to the CLI, MCP, and startup configuration: + +```bash +rea providers --json +rea analyze /absolute/path/to/program --provider hopper +REA_ANALYSIS_PROVIDER=hopper rea decompile /absolute/path/to/program 0x1000 +``` + +For MCP, pass the optional selector on `open_binary`: + +```json +{ + "path": "/absolute/path/to/program", + "provider_id": "hopper" +} +``` + +The request-level `provider_id` or `--provider` wins over +`REA_ANALYSIS_PROVIDER`; all accept a provider ID or `auto`. Automatic selection +binds the sole usable deep candidate, reports `ambiguous` when several are +usable, and can leave an artifact-only target unbound so its disjoint artifact +operations still work. An explicit unknown, unavailable, or unsupported +provider fails with candidate IDs, stable rejection codes, and actionable local +diagnostics. `binary_session`, `rea providers`, and `rea capabilities` expose +the authoritative `analysis_provider_candidates` and +`analysis_provider_binding` fields. Reopening the same target without a selector +keeps its binding; runtime failure never selects another provider silently. + ### CLI exit status | Status | Meaning | diff --git a/docs/adr/0001-provider-selection-and-analysis-profiles.md b/docs/adr/0001-provider-selection-and-analysis-profiles.md index fac331aab..956eb5fad 100644 --- a/docs/adr/0001-provider-selection-and-analysis-profiles.md +++ b/docs/adr/0001-provider-selection-and-analysis-profiles.md @@ -2,24 +2,25 @@ - Status: Accepted - Date: 2026-07-15 -- Implementation status: Planned; this record does not claim Ghidra support is - shipped +- Implementation status: The provider registry, deterministic selection, + target binding, analysis-profile commitment, and snapshot/Evidence migration + are implemented. Ghidra support is not yet shipped. ## Context -REA currently composes the artifact, native macOS, and Hopper providers with -`CompositeProvider`. That class intentionally requires every operation to have -one route. Hopper and Ghidra will both implement the deep static-analysis -operation family, so putting both into the current composite would either fail -at construction or make array order an undeclared selection policy. +Before this decision, REA composed the artifact, native macOS, and Hopper +providers with `CompositeProvider`. That class intentionally requires every +operation to have one route. Hopper and Ghidra will both implement the deep +static-analysis operation family, so putting both into that composite would +either fail at construction or make array order an undeclared selection policy. -The active `BinarySession` also owns one composite client. `open_binary` has no -provider selector, and the domain `BinaryTarget` contains Hopper loader -arguments. Analysis snapshot v1 commits those loader arguments and each cached -entry's provider identity, but it does not commit the selected analysis engine, -engine version, or complete analysis configuration. Two analyses of the same -bytes can therefore disagree because of language, compiler, loader, analyzer, -or provider-version differences while appearing target-compatible. +The active `BinarySession` also owned one composite client. `open_binary` had no +provider selector, and the domain `BinaryTarget` contained Hopper loader +arguments. Analysis snapshot v1 committed those loader arguments and each +cached entry's provider identity, but it did not commit the selected analysis +engine, engine version, or complete analysis configuration. Two analyses of the +same bytes could therefore disagree because of language, compiler, loader, +analyzer, or provider-version differences while appearing target-compatible. These constraints are embodied in the current [`CompositeProvider`](../../src/application/CompositeProvider.ts), diff --git a/docs/api/assets/hierarchy.js b/docs/api/assets/hierarchy.js index 6310c43f1..38d7e32a0 100644 --- a/docs/api/assets/hierarchy.js +++ b/docs/api/assets/hierarchy.js @@ -1 +1 @@ -window.hierarchyData = "eJylmV1P4zgUhv9Lrj3ZJP5I2jsGsbtIo6WCGXGxqpCbmmKR2lnHBVUj/vvKSQGHOMQON6Vx857z+Ng+tg+/IyWlbqLlvwihBciKhECQFWmagAyhpAAQFyQFKEuKBUgTkmCQYgKLNYgUu69YqbkUTbT8HRm9+SvonkXL6EzQ6tjw5kIpqSIQPXKxjZZpVoDooKpoGZUVbRrW/LGVe8rFHTPvNXFPFj/ofRWB7tVoGelm+83Y+dY1gKh84NVWMdHiG0yUQ4BQgQFCCwIQThYA4QwChKH5QBggjM0HMT8UGUAkIQCRtACIwAQggiBABBOAcpgBlCMEUI7Ntzw3L+fJ+gVExpnV179lXTMV2FNLFNRPQgxIS2P6SRYFQHlqCDPYseXQMQ4rJbUsZTVzPHryCd4WosAOiEtRH/RMgnetj/sFcbi/Ouj5/i2xBwBOXIvhnNZ0wyuuj78EfaK8opuKzeQZt+WDl7nmyDkVJasqtp2NZOt9MKAL4yffMzl7nGy1DwKyJ+pKySe+ZeqGnVJbIIRb74OBXRhnW1rr4MziUvsgEHvKflfyuWHqatMw9URnhGLEgA9IkdmzQml+T0t9VTM1h8Ot98AgiZ1DLkxIRckuhWY7xfUxEMOt98FICwfGD77noStkqPVxDxOH+z95cN4aSH2cIzs/XIon1mi+a0fxVqrHpqZlKMYnRnyAsD0nfolHIZ/FNdvxRqvQGeFS+yCQfHD0mJcxh1of9/nQ/dx9w6X2QeidLTojM483DrEPwKIYAFyzvdShk3Eg9XCep5mr9yVrQs/aQ62P+97JoTNxo6maN/nelT6uod3zcynu+e4wa08Yan3cI2S5/0d+54Kq41XNQr0PpD7Osd33Tv+Tqh0LjftA6uO8t+ZXTO1503Aprtl/B66Cl/2IgWmQ9v7pJLkpZc3eCDJMXgm40Ezd0/Idon4TrWTFy2P8wcooxpup/oUsTUgKzdW4u361j6PRYo3+MuXJjgdnh5O5cf5SVHwdprXiiWLqBhbKLduYzVhoqY7XrJEHZU5H9cET6tmSx6O2gkcTE5yuO1ps3/FvtLlf3bLNq/kZlAMbfoFrCzG9oznf7tgPehDlA1MTHA9tnr3ra+IPj4FByhDKsnVHlg13o7O6rnjZ5tYBpCM5uAlHTU2niQzhXqp+2+faW5EHSl8Qf3j08E+S3k61rU+XIR+GTffq3VAVO5qmYfIkJ32YC3M3VVIE0nyUxa62aR5TYXTVZl6vZyuppjIAfZ8Vd1aBqiNwGgye4UVCFgBCmLZJvX10FUwqziaTqBdtZ8kzH5jyrLvE1x/PL/BMDuhI4OACLiBoV6AJHExw7wrXnT5uWLt3fDbvbMieKO4/Tc63dgzHCALn2kAbD1tC42UC1EbK1Nk/rb+EwjoNOMoys9aHSXEtthnv3ql8X8uGa+aTXGzcgTAetkyfVM2/KexyxSk9zY/iiIV4rD00jiY7r7tqU26v6dOt7JzW+qCmr5U2skMau9omovny8j8QpO44" \ No newline at end of file +window.hierarchyData = "eJylmVFvrCgUx7+Lz1xXEVDnrXfS3W1ys23ae9OHTdMwSqekDrjItJnc9Ltv0OlUK1awL7YS/+f8OMABzvwOlJS6CVb/IoQjALM4ap8oBxChBIKERAgDBGGagTgiEIIYE4zvQKDYQ8UKzaVogtXvwOjNX0F3LFgFZ4JWh4Y350pJFYDgiYsyWMUwA8FeVcEqKCraNKz5o5Q7ysU9M9814UAWPupdFYDu02AV6Kb8Zux86xpAUDzyqlRMtPgEAoRSBBDKCEAoTwHCcQQQhgggnJgHzgDCKQQIm09wngNEYAIQSTBABKUAERIBRNIEoBTlAKUkNg/zX47Mxzi/ewWBcdbr69+yrpny7GlP5NVPkhkQQ5NGEKA0xgCl0BCiqGNLkWUcrpTUspDVwvEYyGd4W4iMWCAuRL3XCwnetS7u89Ti/nKvl/vviR0AcGxbDGta0w2vuD78EvSZ8opuKraQZ9qWCx60zZE1FQWrKlYuRurrXTASG8ZPvmNy8Tj11S4IOOshXCn5zEumbtgxtXlC2PUuGCm0YJyVtNbemcWmdkEYLNnvSr40TF1uGqae6YJQTBhwAcnz/qxQmj/QQl/WTC3hsOsdMAhMehjnJqSiYBdCs63i+uCJYde7YCTYgvGD77jvChlrXdyj1OL+T+6dt0ZSF+ekn0UvxDNrNN+2o3gr1VNT08IX4xMjLkBpf078Ek9CvohrtuWNVr4zwqZ2QcjQ6OixLGOOtS7u87H7pfuGTe2AkEbjw9fC441F7AIQ4xHANdtJ7TsZR1IX5zC39b5gje9Ze6x1cY+ikfsbTdWyyfeudHLd7/laige+3S/aE8ZaF/ck7rn/R37ngqrDZc18vY+kTs77fe/0P6naMt+4j6Quzgdr/oqpHW8aLsU1+2/PlfeynzAwD9LeP60kN4Ws2YkAYvJGwIVm6oEW7xD1SXQlK14cwg9WJjFOpoYXsjgiSWSuxt31q32djBZr9Jcpj3YcODscZMf5S1HxdZjWiiOKqRv0UG7ZxmzGQkt1uGaN3CtzOqr3jlAvPXk4act7NDEh2V1HS/o3gxtt7le3bPNmfgHlyIZb4NpCzOBozsst+0H3onhkaobjsc2z90NN+OHVM0gQIUTuOjJERtvBWV1XvGhz6wjSkhzshJOm5tMERHgwdKd9rr0VOaAMBeGHVwf/ZDBe67I+XoZcGDbdp/djVWhpmodJ44gMYc7N3VRJ4UnzURba2uZ5TIXRVpt5u55dSTWXAej7rLjvFag6AqtB7xmexREBSYLybp5nwyCeCh4VZ7NJ1Im2s+SYD0x51l7iG47nF3hmB3QicEmOs7aAnKNj4PKJamRrfk1FyUuq57KpF/PJqH9ew13yT6IUktF564a1W95ny6XPORCFw7fZZdJOvSkCzyUy0objFt9hNgFqI2V+Hvi0bOQLazVgqSYtWtYmM7fYZpoOLhO7WjZcM5ec2McdCcNxy/wB2/y60q+yHLPq8ihOWAin2n3jaDaVu65Ihvup6HiZXNNa79X8bbiPbJGGtraZaL6+/g9PSC5n" \ No newline at end of file diff --git a/docs/api/assets/navigation.js b/docs/api/assets/navigation.js index eef980a1f..9311f0e52 100644 --- a/docs/api/assets/navigation.js +++ b/docs/api/assets/navigation.js @@ -1 +1 @@ -window.navigationData = "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" \ No newline at end of file +window.navigationData = "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" \ No newline at end of file diff --git a/docs/api/assets/search.js b/docs/api/assets/search.js index b76af14fb..d9ee5ba40 100644 --- a/docs/api/assets/search.js +++ b/docs/api/assets/search.js @@ -1 +1 @@ -window.searchData = "eJzMvVt32zjS7/1dottMT9s5zPTcObLS7Xkc21t2Ou+sXs/SoklIxoQiOSTlxL3X/u7v4lE4owAUlLnqmZj1r19BQOFAEPi/r+ryW/PqH3/831dfaZG9+sf561dFsiev/vEqqaqcpklLy+KvF0WSvzS0uavLZ5qR+tXrV4c6f/WPV/syO+Sk+Svz8EZ8+Kendp+/ev0qzZOmIc2rf7x69f9ez/7evZ89TobLnJKinX3QoiX1NkltbnhzhdfXr6qk7pQtwTF0P7/9+4yX5mVDMKgWk5I7myCnQyXfSXpocWCPWkfctsn+Qpu/0OKJ1LQlGQK+oh6ses+0LLzjmBVQasPZz+dvj83j+NyW5v5FzSMuJtlqlg2oJMcC1ASR0z1te5EGKwBeMip8mSKjM4IxwSsxiwZyM3oxsevk25o0h9w/MwvcdfKtngSjguNSnwK5OTz+m6RozEc5ZGhV2r6tSN1L3ZW1fwScCn5nHtpDynjKjtK5kPnCMxf02PWsSVPmYf2kpITfX6blvkpa+khz2r4ggy5E8YAfQC5UfRYP6vg1oaB0/KYgNDUprEcyjPVDR91JlfS/KyX+HT2HtxAkw8rZDF+TpCWB8xkBvpdMJ8mI8DQjRRvYWBlwRi4idN1V+WciNASkEEZx1DG6KiCmhc6d7m3lN9YVBfAze1WXu5o0SGgLRs6jWKXy0g2w6K5IciTkWQwXmK0H0/NXvo1SFMCvBzTDgVr0Qh5FKZWRBrT/Dw7qKBUR9pnUjc/QTs17VMNFPv/5l7+dvTvXLOV9TNK2rI91tn2p3FaiRgGk0YUadR55+2DOxlEQl9OA5eWSNGlNq7asXShV9iig798KQx390t32UKR9gjOjamRwitW4tn1fJFXzVLbLJH06pgfTAjdnYVzlPjv/u1Tf1P5Gc4A/KIWlnHiMI/K7s3Nm7lY0bX1I2WqHAbrghT2h1Q70q/gkwY5ilDwJPynamp0KoURwFD1NDN8rdmkIJ4RJ8yQR0D1+BLPmSSLIy/LrocKNYNY8SQT7pE2fsFvCUfQkMdQkLesMN4RZ8yQRNCRnF6pRIpg1TxNBm+xwO+DFJBmLnxl3CQ8lj8xqh3nMxbtU6OANJmAjr480Z5ozZOTVWxhHXu/Z10BJJgo4FtXgTyXkX1ZD1Erib93LdRRkpRIes+b3rVu6TdJ29b2tk5SbDSh/XOlx+M4RyfSqqA72JVfZo0bJoajkoHXrJZ3wx7LeJ9igi156O0n7QOv0jcHcJe1TlFCqQfgUgfT7F7CDmERPFoB9MdYnAuCwKDiEMk0PdU2KlFxl6JEcxWl2soC224ag16pZ9SQhHNrq0K7LEj+MXrkelCOFwnSqZHhosrF1p7I3QQCpazB3ob/WSfW0nFZLoD2pZAXuUD8d2m4EeDu3FeiPLruUpNwLTI5etylvNNgA3kU4Ai947QB42YFpz0T3Koxkm4b+if4bLGT9k4SVkTRP6lhBieonCYkUaf1SDTthccNhlU8USlu/bPo/4MfCSJ8mmP4FAjcpRguGlT5JME9J87Rp2qQ9gAdF4Gh47ZOE47L52DUc513ICOGUO5om+aZymATB4+HFTxLQcaAcozsV1U8S0qC7iRuZxslJAmzKQ52SzbSTHT02WT9WWOyr5c4F3b5MQsuyaNkNdeaRu+xWo4c7LjXwc8skofCdWDzy4W38NG/Jdsz6rDO4rHUi7psys66JA7E7qcjUijmXH3OsGZdE3C0KIJTxJBONNqM70rTLpCiLrjP1xhV0ovHSIiPfj79i8+ElKHOo5aLR75OW1DTJ6Z/kktak38DV/bz+GUSrGC2GgiQ1adq7QcqXm1OJxlolO3K79YYczKPR1eQreWEqnzenKBSPuCzbo5+PzNYnZ2RRKRpzW972i6nX/DsAV2BeBpfWvM55VTyTgtsralrfnJ92flF4VbRkV9P25a7MaWrfTS051Ai5l9UxYt2aZtV93wlfWYIxLhhZD1idtn5RqRvoY8dwVD1BCPvk+yfaiJuOcALZJ9/3rPYpwmEHbEhRDJJx4NWteLSX9kZ4BCRIRWjJhJs/ISEuJtWwYhcLUvuaf/x9NmlZtHWS0dRpAQ8clcHRSQL1WJwEx+a7OBkaTqRIThbEPinoljTorXzBCJ8kkIKbBmFFMameJIRSMZTHCoTXPkk4/VioSBxedIOj4aRjBaPqHW+Slj6TT+WhaENHuZJUhN6xOPq4CB7yqoEXg499989I41+5kO3hrUIHw/bocEbGpuC4darRcLIDTjyPDiUFnPrFr47QglnIlSeaUFatEjpzkyZFOK9SJQrrvCKKA62Xw6HXrEQc2qeypn+SzHFNQm8H3aDe/1IA95pCNABYlB3K04BnK9kPtEjql3vSNLb9a9yT4A8r1fqq7zl4fZs3TVHw7sI+nLQBOX8oaRAEn0rmBep0FhmMkvtYp9s3+UweknpHzB8dWUkHpXZSikOrOYbED9jj2BEPZv6YS7/aCj7f0oOPdPWrSMmHlyvzh3NWzEnp8QW4QcOHVjhnzA/U4WQxL8buw1Ptd0aeyJ3mVGWbo2bECFZTzTgUWWhjGxTnGjIpRqF/SpoJPQz6KWnIUSgK6/CRMm5dGTRPVVcGb5h1ZVA8TV3pZkpNS3e9wJey/tpUSWi14TS/MZonjMD8GbdnCLDlI48Yctq0n4uvRfmtCATvlA5HpSi0ZXHxnNB8PAJm+ZQUOxLYdZZFwkims2Qc/oqEjecXo0I0uqXycEtvVPfjLD24K92JYkHjfqdT/jyoh8MNcLrLQSt2j8kTf6Ht05g5MOG/0fbpMMtGjAORPTpvm9DiKkJ/OSifttcUPvvw4nb4vMOD8FBlSUtQ6scgFbl+PJOabl9GXsUZyl7kg+hIXrOiWDG8Pfvl7Zuf36pXvbgTt2Era4vH/p+a4Z/AJxBpi9i+9OcGqTn+W/3qS+9H845FdgVxDikT8fxu6yJWIGHgepZa2XVdKziG0CUutzBAN7qA4T1XvdyQlatfoeRhC2GOAcAO3oezB1xPExSGcR0kPCqcJRGfoDRLIzghha6SuAWkWlkLjSNokc0N37LYFhoJ1rqbT1CRKhnOUpxjQOYpRnBISPMMjKCse70Co/KYnLiFpVy4C40lbA3PLQDzWl5oJEjLeo4hsct7wRF4rfS5A6tX/DDoAxf/3ELRLgKGRhK+HugWiGZdMDSM0CXCkCBUS4W48QStGvqEFieck4UAWFAMjwhzbdEtQNjRMuBQfJcb3aDVy46h7IErkG4h2FYiQ4NBW5S0h6Ve/SsPRUayfzZlYT/iV3zY5XRfxtayWVLyIpg7LPqJwelP8h0ffSDfbTukJTzRHoVP82t1N0KTWupKlT8W/yz0txrOe9A50hSJ4Eqp4VAsgnNgqdw+NqR+7v/JvoytNIGvZZs96pKC2imYxVxcIoxpefhP6NzemXgx6rtM712caJeLk6o91OQ+rQkpQCsx7qGNPhrWx6nC6yYeNVmOBDGCGzykRw+nDe34y0WMruGcnCjAjDZp+UzqL+TxU1o9lGUeI8LJyzfyuE+rdvRyohCh11F6xOU2SUUJpmgq0h3etYuRH0f1CnoJBUpI3SrY8EozRtXr1NtZ/UQhlf1jZHrLjR/V6KCZHUQMDDisuSf1M4UN+2Qr6ABw7MC/kEdhjGAc+yn8iUIhI5opcvWQdeizvpBHRffvSq0Si0c+dEtfyOPYs7sNuFX4OsUTxHAsMMQwZNFokZg6atcAFFrRuMcu5Qt55PosV2ReJhpt11uMJmKX5EosS0WjHnuDrkIKPY4rtKSEy6zuS463jMK+mFU8b54cC7eidhWefRm2JkljvL1V5VAtAi8uVdDKH/fxQPPMVETq31jFrJPCotb8vP1NvMuy2NIddw6l8rcVHoav4vU3rLPmD3VSNMN1GYDjLyXHdkWHYhOLAFZma7KjTTvcD3zPr7Hry042Aq8cWb1qBrBaxw5ExpJTIGk+Rk775+MAL2Zxf26tB21A5X6f2K9U8I1oVj9pSF07AJ137x0W6+GEodVkTzLaPxgpNN7DCUPr3spZ1xw8g5q044YjvPTRWVjPmNUymFVRk56m2xia8/0T3a9JlSeWcZT4NLyj0PrR1QvJFcS5rngk75oq+0gLyM2CULjuiwd4SrGLao977EZW9k4XSj3LRYVu60ORJoCLjMDcrGJU9A4XC3rQwsZ1//gADAz/+MAN+T3Xc9StPmVokqzkTS2Dkza06bQqG9qSO/GIG0065Z8GH0Ck96P6lkz2A/GsLxTBddiBRFA454OJAMK2A4rMX0GCyVk5bG7xtfEw2aaWUw7ghc4rxqXv91ks+flYGH2v6DIJ86eXXhoGkTu9JwygHtcsLhxOjwLHMGr7fGnnGJEmF3dTukNNsu66F8tCCP8seHfRdG4g/ZPo3Ok6K96hQcklNfMI1hKqy6b5ndRNf40taCFVZQGeBMwW07uPbmXePmxV+lRrOZSVMnbdmdZka18hcsVcjKqerBpp7ToD3T1FiGGSjRYEW39E6/s0KW6rFnJyutq7QTBSTervmOcTBCrxcIl9XUK3BDl70Qc2nqIfLa6j/gnD6tooaEXAL6pOHr5AgBYU6Ih+35DgB/WjBdRnoYg/U69/+t+pobsisa80+MU0i8cNSJG/p6+Lw2rgrPJf1+crAUN7e6ns8Pt5NXdoD28AF1+zq2pUwaxtKN6zg2tm4bTGYakob47MF58fbj9dPFwtN+vPN5vrq09XDxcPV7c3M/RzUtPuhHwIuE4Mj1z6NMIyJtfMXpT0JsEoEdSH4lpxeY4LMy8RhbI7EV14knqWsFoqNnUwaxzCYY+u/bZENd5sjccGm2TPH1s6TbRnK/gbN53Cqj/GBvK+Wctg1/Yv1WP5aHq4ZLoY4KqfS5HE/gIpNJDF7HOYXg0+A2IDOLaGP38R/KX7Yu+EZTB/JfxtdPxjCsJ/Ku0ee+CsGifccQLc3SFPiwMB3u2DEfzoOR09u1z5E6Moqrrc1aQ5we/OePoxoTawD0LCI3X5MCRKoF5zXY84/ae9nmGCOuXbQ5uW+xhZfFSO2CEzZ5bEhF84nY3i70y/U+/QREm3XJCzlx8R4jfoISOhUbodNIISKD9vtI/KYZOJI4pJFLfxOc4zQMcrWK3dDlyYruzqz66qaaOgcCxf4TQGvQOEslYc1SBFOJ6H9oE8Jc+0hB4tAQ1Pox4nNsf6BNknarZ12TVa5aQlmQnANUUdt6JptRHK2byBsD74D+mg/IvBSXAMRk/xehJwmEh9iVuw7EoZycmQiKxV1TEpTNsYrQ5i1Fd1VrgkW1LXJOsO+JluaLSvZmmtwJmAVejXO9TONZVM79+sCy9XfblYl3EgqzdBATArN+AFG1+Hmo/wJ4DOqFux6w4cnIT4AlA3ET2OXRr3R1RF1S1C3ZF6TyGf0gJC4fVw+TXNmtYknY9/Nrdl7lHw15aHQuNDU0q8F8ncoVB4tzq6aVuhN58ogE44fl8tfGAJxeOsEdg09ajk9nsr60//CDzx948vn0j61ZokB2XGwiHOAVz7jWjSNHQ7PuzJsZBUoFislA4x607ztK6f6dBma0yk/j+eQKMtJk7pW4EWvSUmisNHnzom1686jXByg/utbKy7SDjJzgCtuc37mH8rq4rUkJ1dapjFUeqplwJv4pL0tLW8zMg4oPZk7BSeZwVEtCpP2m1Z7z25GPMwKO6Lg8eafAv+WTsRxB9U+FpO/JbW+qJJV/l6pVpQQkQdbqTpXsZ5EnICiGC0aNokz3ur7mf2LUFWpxp18DFJdv+V5nlYK561mk4Lqz0L594Vh++XZF+uD0VL9/10x7oOpsHttTKyL+tBqx610HG7uk8fQRtOjKi8DiLmPknLJuy37yWi/OT7pDgk+TFf+jakQeeYMpEbUnOo+ttwsuvutxpwPUlnqf5nf5qkEGGfk5xmsCvxNIy9gsP9dyY0YZLMT6A0s7tBbn48YNzFrmO+NC3ZK4Z/RgjRKoBFPaVcdYufNfA1lviw21srrSt1CUjO1CrwEpH8Q8vG5axwjQ14Qm7zqWlJOrdwHEuhIZ/t68Pr9tWuoweE8339YnI84RcpLIczfr3Ccj3lNyAsaNOFnIerN4OmuvH3nIQAZ2wafCrEglqu9ajNyQZ21qaBXCGGTK753YunpEhJxp/Hqvyp2SfBJ4Oo9VXf8fP6Nm+6kuDchZ0EYgNyPgHEIGieUZsPQLByqi6KDWRU1yXuZsvxtBpLpVKagIdJwznGvEizFA4c1LRFtWejpEM9VBeFMgrV3bNBMRgE40Sgutg0KAKDIGIEkFpsv7ZJ8Tz8zNck482diut4fxP/775FZLvFKRhVoYLFav4tr0m2sxx+xT8K79/UHpR5mvdgdWgph9FjYB9nZXLv5UyS+kVukoSTjiKRGIe0Ggo5q0SiZFeRPBGhy0hefE+JZRho5xskIvENXU8o4qwSiVJ5m7Mnq/Mlzl7Ew4WloayzSlRK8U7NIFiXqzQDmFV35gZxu16R68WuvsPUk9v96lIvZtulpZ70IXeVguNgF065h65BZ/AY/QwSCAMZbtPAPvn+4aW1H8sGRVvsk++Po2BgwY5lpgdf9w0JFb2eJbHh1SPofpzdv1OZTkwxjqLlx8EL+ZPBmjSH3Lp+r3DEC8DroSJEzU+65SaDQWSLScuHTxDU4YJPtAYiu51n7YLNvvabngGcWqlwwZkj1QF1y3gq96Tb92NsD9ND0BWBqi4fyW+isjr6WZszgsc8B2CLlPsw4046i1gVt9rEWArsIUbrh6uPF8uHzfL2093F+ur+9mZzt779/epytbYcZKRxbFKEl5imIHQnJGSRWBcU1gJ99Deb7lQr0BZa5KDAW2zxw3oWdtsgR+ayEwclOFVT+nV9cfcbVivixf5rG5ACE6vtCNLRm40qFLQW4xQMTmNRxYPZTmwhMU3kw+eby+sVXl+j1/tvaygW0sC2YlCP1VxsAYW2GO+QghqNLSqEduMSGNN0lhfX15u7i4fQjkXW+W9rKhrCwCaiUI3VNHQBhDYJ5xCCmoIuCoQmAAmErfq/Xdz8urrcfFj9dvH71e06tAXo5P7rGoIRNLQ9aMWjNQtzOMGtwzOgsEZijgmjrcDDYprMx883y+74YLyhlknxv63hWFkD245RP1bzsQcV2oICwgpqRPbIENqRW3BMU1qvLjZfbtf/8/H69ktgG1JK/bc1Hj1kYKtRC8dqLoYwQtuJTyBBDcQQC0LLAIbDNYnl7c39w/rz0KJCG4VS7L+vWegxgxuGWjpe0zCEEt44fIIJbB6GeFAaCDAkponcP0yXOTxcfVoFNhGN2H9bEzFhBjYRnXSsJmIMJbSJ+AUT1ESM8SA0EXBI7Ebnsv66zctvuhso1a9iNQAaMcQmAnhhO5/Lf9+WtflrLoOdy5Z2tYxLEQq+9aKeRSmUiX7LO3ooBlXsWNR1Q/VFvKouMM+Bt/Bcu56wwDqRjOHlwcZk7z68WaDdhVFJezhOkn5NduRjsqe59WtgAOuot530ImHPxyMgILNakXDHXuUKA3fUQq4UUnsabC7Lb0Ve2u+Wkdzw5qht6hGyLxMCtIBvyLTI+R+2BuIEnrwGh9T82lfD4T2QU880vhiF0N9c+lCnOFRIVIujnHepsmWlg+4Pwngg3UcZSf0yHCLJ3i0dGkWv3076GaMfM6wspKfVhOJ8rlEAflhKk9GPejGxx4O17ob+FQt+VK1m1Zgh5MmhSJ9ILZzdGhjCpNpMqjFD6MfRF3X6RJ/RfoNeM5k10fH520VlA2Hnu3y9qNmf6753XbbXYl6rqw2Yk7ePAnqnHEUDCDnDUDT+eJPut1HNutSTR5ZMNkYky48PfKBFUr/cS0N5O6FeJA7pVIW4szqdMFkFbMaxEn1KimRHaukADCCnWgWb9f4pqbvz8R7rpLu09eI5oTl3cieQVqeDyFsldUP0awt2ULUAImG3QBUCqLQPTpDq9Z+yrB6T9Cvg2hz+UfgqkNqDrnPmnVh96oqAd6qZBpLullz7gMeKtJiFXMl+goE+tW31ubaenw4g7ZQOtU8hAlHBX5kBYN2+MPPC/UYemzL9Slqc4p3lsMtYmHWXjX2Ya6eddPAw2S/32qRuNY1fkwJ5JwoBhASgToOfkhSwCD4/BU5+s4XDEs7Ri8oaXgTHmDTVKKkq4ewef6JFUlWPk5gDm1IxcLUJguuy0uQJ268CfSoPRQteYQKR97r7TtdtZSkkDPfFMngongtlfuFk3ZuyIoGskUEi4OVOAL36Thv7kMURnUyi0QIAru2BuF3W9fxwx4k2XnIcBaMnyGnNDXT0PgR8EoSfv+8H3qczDOBJKBZoWZHi4qiCgdxJJpxkLPhDgVbOR6lYsP0p9nhNsJeL3gD7NWPguwAIda/n8hbAAZtfLxUft64+6z25rjyrBqrymqk8RFfPIo5comHg0Fk5cThehDheadiaF1EUz4MPlzT5Up0ypfIF868pFhVA2IGTLojOR08CxbXTo+nCS7wIWMno/P35l+PFir/WCbvSFf5TdNrNoL2btKNHRL5XeULNR6s5hXEUjM7elxIe+SQXnbsm3MA9GHzWOwF5lScpucj2tBiuOCtr7HYw+khYH6drD6P35XyL4F2Z0xSvU5jCO15TWE0OThXbXV3+m6RtpN+tGtRP+Ys9l18RO5RZLwa5euzRvSld1XVQxz5r/PeOPXhE5LHHsQw1ryU2bbLDgx/VolNX7Gv4YGrw3ZmB1DVJGst5rU7cs14Mcva6i6QoC5omOf2THI2WhOa02Nm2Gag8mwWxmqo1gjX5z4FYL3iDBzDqxeDv169N0zIHdp0WFrdt/jqNIvh1LfMclrOBfhPUjf+YIUtA6fHurbo+JcmXirU06zIlTbNMqvZQE+CKgNoGWprdX+v2pmyX3dU83Q2vtuLT+JOFHMpLE7eBeE2SvEtw4F/diC2pYbJDfutlUiWPNHf7sY9G5hfKwlKd1bO8WKf16wAEKj+GRn+irTUASBVgWI2iqJFAqgI/OLbXAt1AWDMQN/hSDl0UvmD+QaUkjk+8BuIOiO4DcZi4/0DcBR4+EA+jHnc3XBXd/WU5sdwY51b+gzRlpU8VT3e7wqFOiWUhwCOcmlGOHg1kwuESg8uEI4z80JB6mbRkx24ACebvVNOj6kmi+ESahn1HhxLEfhaNEQPfi3I9lc/Ib3CpUcLqDiD95TXdkvQlzc2HEWhswDvxRvu7mlTJMJqH7MXTeVWr+ZbasQTCNr550DpthHPTN+8o6y4oiBJPr/5UAo8/wQxp3iTX3TYRL7Z5v1w9uIkYJDtr+5bQ9qGbFxdJvvpOreszGp+SDmajYXgfDzTPxkeFvQxuwLJQJOJ0eGoqm491sifWZTwNtFIrFndfK9eH4lNS0C1g5U7HLOpE4i37a7HJPWnbnOxJ4csr6UTirfrmKcxvPZmVWpG4a5KTpJl8yWN3N3KNWjT2psyfGW/++UMlhTpQMA6xnkj6tSop+/LUNLo6Pu68IKHwZBpUM55Azi3lw3jHWYyw83kvRRiltUMMod2Hss9ykbkz2lTs10qB3Ee5yNzbbkOH5W0mHHtWi0w99klTv4+FP8q2R9nIcbQ13dku0HbgP8rhc7MjoU6cbl+O18ettluSWi+uU7jUSiGlRnOvkVNQb5FT1+n3Mqf9EsHtoa0O4DlSTn9S2ruXRU61S4zislYI08JrOUsnqf18mVv8D+KdpOLB7oUFtyBcn4U2ALA8GRst7lNSJDUtP9rP/mTc6TUCKy7LWe6ZAf10p+tH7mZSO6heBI903Gsn/AZwSLV9IJ8xDU4FAcmF07PGhMicvXy3vl2u7u+hhy6LXkRz52KYY7MfkBlABD0i0yoWfIYyDHcUig4MOycZxuxyMrI7trzbiV/vF5uIsRnPfk1SGFXZ2Kx/S+qCNKD58PgodC+OOuHDymZypdZwLpQpyCPn27Nf3r752XUnBrBwFr3a+DJpDCFl1RDBVW+cPHAZUufRjwxprHE3Zb3vNiUCttYpDKC1rxiN5rqTdC/ogcMA3qNGyrkW8oGDqB/Id+BKmxm504nBW5Ms6UchbZmW+Yo/QciBV6WDxmusjbffClI3T7SC1MT5YfBMr7PIRutf6xL81vLoSVJwLpdjiLqp0/eKpC3JxuPUkBAXk2w6y7ojy9q2IO562Tv7meauYQy8ldsgziOQnCQZqREDGATjg1fMM/ZDxKH0o+qu+5foIdQHwPHnUPL6AD3/3AlYsZA0Gzrs4jg6U4mgJBn+c9XimdZlwb1iDCZc8KoeJa0sQd2BIrRpP5H9Y3fNCF4Inep+Vo0cQkN3RZL79UT6EAbV3agaIwT1nu95I6T5cAadO84eqcYrQfvyvu1fG/CjXjirKIGCy63W92WhH68YR3NHXJ0ONu/4EiaYV6eDzdsfszrN0RWpEIirkcGm7U44Gp9cc10iEFO0x+ZrSE7Sdpz0cr/blfVMYQnWKIaTFkwzkH46SYsdZAIyPQs/b7Y7/Xb5RPOsJi57PGdHkoBzgczx6d7lj+I4ZAtGzhlR1tS+kk2ar2xVC2Pu1Gjm1P2DkNlzg5qrgra0XxTI7lp+V6axocyeVBIYtUF1VvRSrBQwRMkema8/hZVbBgK+s5kJFQooLUqXYXZ1v8+qP3feujLIPezyNlvtRd8oeEcAz/oC4V3rz88oa0juA4AtZjF3PknRUqSfqyxpIa+J1V4Gc5Ti5LcHjF87QabKVrIFqxZQpGNZBb9xtwM7vnD3wa2eEvuh1iDYSSkaaiturwqhdd1U5QVctli0oxImKvNavKF5t5SpS6/a96S8J7UKSlJQvQ9Vs2o7Rx5KrYLTH+h6yH4fxXzEgf0iWLWJyw5hhTno02WVW4OcU7GpSiF477APsM9GYkc/IZ83e4Xk8qUzUiywz2q9onH7wtY/HsVimqmtKtfS4N4RW4u8kGLi1qZGFaReLxZ/d6SaZPErd36jYwR6xTgxDMcQI/4IBkHECNQdVne2y3Aa70V/1kvHbOyuVAbQTRRbWjfDZDXrToPJsprdKqQuM6U/pRC8rJRBa+rrfw509nBR19Z7VpS8CpmItN3FVrRI24ek3pH2t6R5sm5UMVGr5CLSfxwBL8umodYhnwlcUIrIfNeQQ1amZWbLACbcowgaqa7Nb0ndbeq77z/zu9pzixnqRq+wgLZ62j8tSFjLSeVQqeRSWKq4zRunfqNNW9bdsXeD0V33wuRjQvNDDWhUqiBg0nhRiTv8lM/bN/rpq8Cinv40fDY6/ErwbX8oAdxWkK7LLYRy1gwPwqElroq2u93RPZTREL7Q2lW4TJASvWvWM4wAJuHAij3h6XZtnYJ+cfQSFoXRlXY/F93TNuFre5wweU8/INRKmWzjBNv72h59/YBwa5IPpf1Eq9jhir5OE664gcGSexy61QnEIIueeeTvrxSOX8b6GxSUVR09Nof+SjgXH9xdDXYOrwX70zXESiaMXl1aywhgFA4s2LFsdN+B7Yqytr/1CoNfHL0EBWF2Zeyt/JIZPMLZyQ8IsAYcRxUYHvgoKvTgGpLWJPrPd/RymhDl43/MOcUhY48kJlnsjOKQqR+6JW33RN2bgfM0YH7pUo0G53rRwOIcikS7LyGzvjT3h16M8iHkBh+BOxcC4nLZz4AaGvu+DT8s6Eu30JCsjUlc60AKdZSN2qCSPLdv6AoBX8wu8H+oqdy1X4yl+SEj3Un5UX+bxeioGh2dPNBpgS9qkIyTHxbg78JJAjHjdDlpADncgDE6NMrQEbp/cBU/O40RnMO9bcjBeU8+oKGFTT38Axu+AIsa2uziFMExu/AuVx8vPl8/bNarj6v16ma52tzffl4vV5urX29u16vN3cXDw2p9c2/Zl2dggnpA7ukhMV5ffbp6iBHaIBwvoruL9f3q4sP1SuH64ubXzxe/rgLCgqgjx2ZdvFRN3BxmwkNgVmnkqECT4d/T5iJLKtsHDFor81RY2GUmq1wV2+OxNfIuM71btZR3CTLFoN1rJpu41QWGXi2HS6/++etD0dK9eRfu+Az4MKJ+Y/EHWiT1y3gLtKVgJgcKS3gZTJHYIr4n7cF8Akn/BHhNp3/6oo/K1icPwowBPLqBWjMiyEibUOuIQO19MRsDIVgF/XSvJTVgkKJBYswRofp/8gMaTRFh2n7DmCfObBwGJNViyEerjKDbJ6rGGlyUGQHOKFUAi87eZZYoiGgnSHnSbst678XEGIcACfexUFK0N4RkzXzjpBfcIFR0QikjhAc6iS57R36Mk0Y6aaDhZaQdjmHqla3zeyXepJHOGnh4JffJhxNVCf6aAwjz1O+hvGOvWHYBGszBdyoDoWjRtEk+7u/04hoVniYFbLT7rzR36QAlsmYUQAPLu6+1ux3LNX08OI5X2DN0isP3jFdBQ9wnadmEdAS9AE5PwB/m0/0Yfd69Gn4dL7pepU+6dFYJQhR7cODrD0bR+c2GsR9Pqqoun+3bNjQAC8beqVxsi9ae2YJfjQ5JGLY1vf4rvANgw4uOjlMIRJOqlXDskx3N9ZwnW6XKKcmG8atL3WYoFqNIMos4ldFYALpXd86jCJbMc/xgQQK8ntfxQF+9g2GchzMsjt+AxgxU5UlRhNaoUSRKjarJnmQ0ceykWTpeARGtaZP24Ftms3EYkLiQOAzjpxlRb289qW7Q11r65y4Rrv9776He87+oDkqy8IfhbmwYp1P/bMpCmJap1+UGGoUdLs9Duc99eI52KDzDfE6cEZpIOAsUhvpQDH+FuJ8e9vcsfj6UJkVZ9F9daYe75gXTxawQMNQ1AI5aS44TyjYa84goWEOD5auwBabp/qfrwoYNYRjgjj+ZkAEhPMPYdiynerL3SIH6lXexfWmx9M3KnE0uNUs7hpY0udJpODawyTOoPMYfS/wSQlss/PNOr9u42jEKrPmzKzQ9kuBUL+RYUkLwlj50fGzJDm1hwKJ5VExTI3TAVchgYXOne+rroKHFCMAKFbQi1jeduzwxX2oxPwVNIo0kayiDXrgxuDDF2zsBRQns4vrHwMnS3s8bAh9c6TUci2IIUP15vLG7tyIqzQPpNL/Uoeq3Kkq9jvL3Eh52e9UMfKEi+mBsHUpADEu72tB1nKBXBDau8a0P/H2BQVCH272VS8KLcDHrxMHcJ/VX4IsXK+qgFbVU+/8Eg44qaIjMPrX7z3d3t+uH1eVmeX21unnYXK4+Xt1cPVzdWncUys4MWijti+2VdMlFkwBFVtEehU+dB6f7f9ekyEht2UQmPgw+10/rRXX0muQF4FZTHJLfsFP7YGTOh/RZZbVvnQE3ZgOZXW7L9ubd1sme+WYvAHdWikhbk4b+iVK4s1JE2rY+FN1dwhkGMCsWkbk/Kw6DdxJCZlVmzM8FBaywzU+Bx4qzRXeb7n1/kbetcz46URjDs+QxIu3eoMr60YmdZTHKOACptPTNNcm4KwH9QTupdpCKB5tXgHEiDDYHDxM9Yffls3WkCEIdhSKBdi+rEDBHmUiQfa5Cqqi9Fn5NVWUlyFZThQO3Laf2TAR7cW8CcXp9rxHS4VWHekcukzYJAuxVskEFHXFog7A1CSPlIOTwQsQLFLQpD8AJf3UEwFS1jyu//voquKf2+LDAxOHyeYFGJ2S9wYgGXmpwBIPtkDCiOeyTsMMpKxhsS5dC3PVVhLWS0ZbsfUqL3VcyaXgVF8Z+Fwtf2O8pAfI7BuQphHph6KjMGoX9kuwyVd/xq3t4G5DCNrCb10y2vhblt2L1TLPuaznLlIt71jjxYhYZP9/8z83tl5vNevXr1f3D+l+bu/Xt71eXq7VlhVF0p9VxKRc+WuWvduAfuqbFV9sCo4iqkohD+ekwnLkp/YBOoKIKBqumvlW7Osks9Wx4Bjyxv6n243u23t6amEZ5wcwh5jEG3VbKmmzp9xCKxSwBhhF1YEUFmnOoHTgmJKnI+FnH9D4S8mrHBnTccQWftesldci7vHxM8ruQ3/pIPIiF/+p24DXgDBAgLvi0DyAsOyYbLFyqJ2OCVi2pR1YRORaCCLy42EIwA14nLfEvqYkwn1RQEQdV4AdMWsRBxeUrJhsiv01pfOr20FYH094kQXV4Pqy+KUGsm6QEEOcpiAQibfvV9aqagcXIo7RF4urG6MLwwQxzNEAiGAfliuxkBpHsgqrMjPNYl98aUv91mVUfhv95V5fdSEx+yzw+upEfBb9jNniZ3iwZvIAcM2VgiM39HbM7F+gds55RIatLkEmR5C9/kg+HIsvld3Ue5KPg4yQYkT0dri2/T2tCiuaJGVqElPwg2rCiMWMo953geAO7/PLcq+70kulRMj7/8TfADKHhVCNGkdEmLZ9J/YU8fkqrh7LMUcKYZL+Rx31ataNsxDi6aXBL2xcMeEYrJnHRVN1VcOwpvyHQg1xlOtIXhTunzXjJGEpN6eTaWS4id/nYdOd3iudABaCPis2siEvPLOUtL+82H9a3X+5X63n1bXN1ubp5uHr4l2I5zxSMSQphaKAcJY1Jfjne+V2wFwoqRkqKx11GSyZvip9b5Q0MoS4eFUHQ6MmR0XUUBZdnf+n352dvmdlL3X0mkj1w92wjhDLqmm/dDo6FGxm2bZI+XXeH4Sp2nQWEMgjns/AJYulKD/vXOA35eH42JvxR8gT8NWmIcVzuSj8JnoC9KZLKNq1wxWc0TxDBtNETMwJG8wQRHIrkOaF516FjBsHLRorDMAa4LNPDXvlhkhzU/KzTx6WjcbYer4kUVvNMbkRT1w7/GJzmY7f+qYs07YaMjzRnJyzHlSwToUoiDuVlufdjuywtG398iT7yu+ydoAbbOFxTbfFEm82R6fYJLfqwP9eq/RgmMtYUg8qUEFbPwGwwPOgxERA86JPo6AHg0lgCoz+MAb+JyHOQr5HUHnm1I0X7Gw0vwEWv9ERNO1TDafO8/EayL+Txvky/WpYoQNCD4Dfy2MyCkdhTt/mqpWpwWtGIi6YEDU+s9bh0Go44chbJM931r3UuDzUtdqNRKPdRNutl01k2Vhyk/VbWX4O5Z5lInGVNd7T4nZbCK0xP3kHumZGLxF2TpiqLhnwibZKxm909wSe9/VEvEnmT1rQKz3ZHmUicXB4NQo2Ukbkp2CPZ0eLi0D6VNf2TZP2IKJS710xmzW1t2vqNE8HH7jNApJzXC247wRjZTnhBsmN313gCzypRKddjS/9QZsZXUHDiKXc8DoqR6GuGe03+cyBNe5UFt02WvR5UaRaxnbJRfHZaNgGH4bdsAoiD2X03rT7c91lYtWdLHwBnGjxh4XL2U9Io94a6wCxGEdeC40tE99lG86mfNAZD0mY/CUUBzZNid9Dc6uoEygjFASXFTr0h2A1zkokCOQwLgyFnmSiQdfKNXX7xhayTb4favUkDIYdh35XyxG8nzEGIurzbcgPtF8o+JdUap1gHvX1SRS7fCRuVOSLwAYETF8+0gnjfljWbVfVLiOOT8MPplPqmNdTJQ2pzaCyNySMs/t+T/KC4MV6GGx50epkyfme0JmlZH/OD7k3K6IAzco19jEb5g4yrcfdJQdtu9gRd2R65FOaYdI/locgIf1YHgIoxw6TJSJ68fKHt0zIpUqLfTa7lUgpgEtLmt7atHH/D2QiTpDjsH0ndP+HCwphh0tR9u2mccVg7fB5PnAg0/znQ/h0tl5JAQKwlJtPQJ6+G7SVOTLwlPpPwQQuYCPJhiyNP262RO9cixiyYRt2JlkVB+EszVT3o/JTTC0hZW7UWcdS2edLEe3SjPV5GdZwelGExmTuQ/ATiKovLbqd4/5g/XllkrEoEyn54GgJInk2nyQSwNaQw71E0go3W6FTBPynyr8musmUV/2tqJjicam8R1h75A3VJ+1Ra59sahMVs7Vg2Q9y6z+eTOlGffgJBmq0xkcad9faFCR3VKABckDCCKfuOVU7Sti6Lq+HjC0sfIj8NnYiOH3cwGnfWCanCm1oGXK0V0QLLB/J5pPisSz+r9aPIO5IfmG9zkeB8IwlGc936AxEO+bIKDu7ybVUQNezrKgdwt++rQtiBX1jB2R2/sXJkF75TWl2vlg/r2xvXD5Vkr0YxjCaqzllFVpVUcX0Syzo+Az4qh7G5HD+NVB48q/KhsoVHP0Wj6WJboZ75sixc6pdJTQf6rD/Jwg3UdphFKOi3ae9hOOq8xwUTVlMth4TjwTwYolXI4Rsp9e2zcJIFI+NVcmNx6N44h+LBRqTuYC1tre/BbWyTRgy8lyqYbpCIAGd/6WVjA77yckcLySksYHBCkTClj2+yat58LfWk0msj1oVkFpJS2Jd4WTVQf5EKUT1vmtzLhkhE0+EIqsGGGUlhicT0lDRL34JS2oZwKcdlt/3X9v1LKPEbfsUITX4aOtcev+pfZpXoRlkKCkeSArgsFDHaSqW/Mj3Jl+V+nzArgaoi4R8Fl8dk1q2Q8E7UBSK4ke3hxSEEZymLbrInbnNVlAPzGHz8Pu5LuLPv3mLlWTNw1GwYuvGHvN7kAbPgZFy4OC37Zp1hC6htkmFmPW7VOaphIMvbPexLa6wsYxT4Cyvr9H2ylT9HUFRq9jloy26SLVnrPnlQBs55UZmDi4CLy1YG8jFXqhKYn3Lc3qP2oI7/6ENlDI/+6M8S+9CrAjo87kGXdQm1B3UT5Z0AvKrD513qPy4T3516Qy04MTc+STH0bQWE1+nFBRiXrfvdG13tr6+s/LwbpUBwDeDGHaQIAVTZB/Mp2+hwdpq8rqdopcKj0EzFn9JmLgXRBW8LLgExKFMZTEus/aU7aVnph1/Sk9ASOH4xxUoYSkL2pJaAFYgcoaZHGU/Anp7vjn02HQsgU6olwinlX+2u2P1Om0OSX9LtVvuLcU+Be9bhFMO7Yqc6HlEuBt6J0hpWAnxMpujvSdHQlj73N1bZZg2qh6FlMW7v5CQMRaF0pdKAFYgyTM2+uixJ2yBMhQQKpfzr9csM4/TiI2nTJ8O7ZcWz4PERaztOY0y9u8qVQgJWKKoYNUOPjKR5UvP7oQPxFpMmZFETKKzD33YmmOy94AnAh+9d/ocY3+U5kQ+KX4n9Bbk7+nuhxNmnTdlZ5UkWwKjUzI6JnEoNOs0puAOqSdJ2l8Epwupk5r+bqTsKJV1/M7wM2P8zOLlcVN2eI1aIqT2j1vyMBXTQ0b1Ty/a0oE1bJ21Z33X3wvbj2l/rRHPloNL5gpOpZpndJGNCO2ppIbvjsxva3I/nxHWDmLsyp6mycWkIR43prLktzUk1aQTi1S3dJml7VbRkV9P2ZVkWLS0OZFV0WxmUkz4N5KhEJ6V0VCKzEg7qTdJ1qZ/KQ9F6Qxa9xr7TwMIbU8HF8DHObf/5pUMtHM3Hb3nK2RwFinkf4Y6UZhVhjFGAmDcCzr/hKFEeJbB+QjJONPyKa7JGLS/CzH34WReYp8sWdWk6ct0VJuTXmzRi/HzjrWE+KXayRUytT90Bv/V1cii64YDuKio1zmCbj7bGi6ccccokI/VFvXOoSCNMb5kMlhgow2LU/9DCofYMlsOmrK/UsMnfB8XnJxpQUH4gWjx3J4oMR29dFdWhdWzwnADtBHCafV7urskzUc5j1CR5uctHizDXx+HYktCcFi7V9mibHm2xcO7q8t8kbXX3n9mIqsHceOeZN1T3mbXydS6QqhntA7HqsjvMdfWdpIeuQrpm5NGeTPZIWbkmW1J3mX6Yr7lSzebDi1t/KGZWVyV1Q4QpEzOvGzSYhxznTNz8rq2TtG3+Oo2Dl/2aJG3KYvU96c5WVE3+BpuN1sY4M2S2UV+sH64+XiwfNsvbT3cX66v725vN6v+7+HR3vVLsoYY4NihaC8laEtpDZLZtJNzFqO3NbPSw2fSbDHXtgu6eosU1iZ8oMFON7+4CWk7/Cqjt3PNOZ0xcMAo3CXPE3rBf0OZKNHet0Hyg5gb5cHt7vVne3jysL5YP96BaIMCqlSIwT4+uvvdPTUOl+/SJ7BMPcqNeRP6rovsSr6xfcPBVclj0quY0TsKhrUn1OLTbmK71caikSndqHWghKQM2l9E01YUWkvJ5aCnNnxQ5FJPaoUYJWlDqqC0lVTx1h7FkfeU1FhH3oFM6Xo2m1nQs+BDtwOXAx6T80bhnhkbbmH8xnk1lH8wnL1//STbTeBSFbqFQdcNVa5tHOJPT5hvdtv2TOGW9UAvHD+gxadOnTUa6jQXsrpGgYGTREwRCi6R+2XQ7cp4p+YYUiCQaP5AtLbLN95psm01bbgo2ywTFotSNH86OtJs0yfPNrk6qJ5xQJM3ThFE+/jvdTK7QAhFUTxhKVZdtmbLXmuIEw+rGD2fImKg/iygZP4hOiGy2JOH2WgUFIUpGCUIxDpnGOIDpiMYlrxA8FlEOFuu6rMXBkmKoyDwGHURPL9pXne0/m7KAFATrRyMALgc2NDvhuN5LAzlFmUBa1W82DfRc1hu1NtBf8+Pnm+XD1e2N63qj3rFBEVpo+pLwXW/0x4WuN/p5CF1vDIgLut6IFJiqxnMv40ZVU7pSPh9U07uDRW6W5qqu9mqSg9ZzdfxK+qub31f3D1e/XvQ+x1I2r1youdVCWMT8lOVA82wYyFbsa2MU2IWs7gWv82FumWlZ1yRPWrJp2qSl6SYpsk19KFpqmc64x2lxdcKg+xlW+pQUO5JtHslT8kyZQ61wotX5OGGYz6Sm25dNd4bteNKWbU3HPUydj7hhMvnkbn27XN3fb5YXdw+f16vNerW8vbl/WH/uk5pHtGbBCBlRdvhxtfZM5lqtmNwo3ZBBDYtd1XMPe0Ohi/aKp52WpW9me+OitMoNbwotElV4yh/z5uLh6veVy/sEJaRKBYdV9eONu0am6xeskwzl8+B3Lp/uHv61ERsYZIqhdmvUg5aZugR0fX1OkuJQRWFdHMW9mC0uzB0d+U7NswvvqEbl04fUbU1tNsm2JeaBiXdkvIMfFeAj2ZaWdbTACGcPPyjEl6Yl+036RNKvwh5z/GBVvn5o2GS7JekJQj76+QHh8je644Y4aZ8+rH5z5LBHZkP4y8dRQ1T6OX24Od3Tth84RoqTd3D6APdJQbfsp7+o0THqpw+tKOt9ktM/E+v81js+0cXpgxwVN42wuIgapuzkhwTav5SMmnVkJ6cPtCZFRmqSbWL2ILKTHxFoQ7NDkm8Ow51q0UKV3Zw+2KZ/RbYRj3pGjVTy8QPCJG2bkz0pInUonP4PCO+J7qMmIN7B6QNs60ORJi3zMSdqeKz8SYLTLA/tqxayric8CT794K63u6h3h66mTvaaD4w0vtQaDgtAXIza1zxdoeoOovOCW3CajpwaYf3ZMOOtvJj8vGjcAKZr+/DoGUV0dLmKh1TtSFU6Gfl1H4nCmRaslF9hRq7A+BXXBsxtZ/UmBW5e9UMsH/uNTM8InKxUHNimJRVCTZ1k4kBqb15wgzRfvuABKb5Gmx6c+h/uWAHxZZrOC2scnpr496Kf7h6Ab9EkOsE4nOy9OOP89UAzkg3FoP4EWcMmm4fTqcZt48Gx13RL0pc0J9YPhdQG0Bd7/SmwH/oPCKCf52kcqpWghaQJW8ncHQyLgqwUQiNW/bot84IXsFVO9Tj0l+3fQ49Ths3t76v1+urSstdM6U6tAy0lZcDwMoIWjttOhNvtlqY0ya17EXgXoplPGWiq9PAJz3hcMbRW83Q6CUTK1c1vFzfL1aXLTgkeUqOAyHj78ePV8uri2p9Ro4DIeL+6v79y+4CVR1QLIBJ6k+ESvT375e2bn499eNfyLoqiFF9WQZLDovunhDPGxJImiWCm9GiJCWTfEaThIbOhL44tqz9wX6SawfpnwWtSugqiHM7LbgRzn+o7xKafCQ/bRJ/Jb1R9g7Ur3oLRfKKgFWOrsPa1eEb2VdmSokWjP0rGhu8Ge1/KOs/Q2DvFb51ibPSaJNltkb+gkXeCZZG/RAAXWyNs8UztwXXxDNwOk7AUISygefcpsmLwEhoE2G0JzQ+YiJMbb1pGKQ4qVQy3vWl7sWYSiwP8VX+QpAOp7VDJIET7CioEsVP5y1k0yPLQIv7ygxr+Ty8mVHFc5wCs3/Qdlk77Sh8KtJhU/ErOsv0bsLoLQIQu7kIRxYWJ7injeq5a2GUV1/Sj6sbtt0xDsY3buWfBX6OP53KpHelmnbwrpYZLqfDOjacHhHAqNZA5h69JQigVCsiM5biaFkKp1EDmHNd5QzBVEhiU76V37LeqLk31ekOGVChgMKpyyrhHzWEhXGMBzS+fb/7n5vbLzbwwBfv0WudUqwYtL1382u3ZTQvbPuhHvBAdePIb3Nj2SKZlnU0EMSKUPJw6xEOVdR9/RwxR8nDqEMevoUfZTU2aMj9Yd6V7RmtydoLAj6klK/cJLf46HTNzV5dbqlh1HR7bCI+5nbLL23Z3atOW24Q6jBY1rrTm5qyliU+POQi3/Vvy7qqJ+iojRUvbFxim1jwQU3Gy0PiQ9k2bhlBpjkeXigXgyqcRCCRkr/LkH2pW/zkkuWK0ASu/wRyPbrgZ7ELTHq10SvPQJqLLFtNVWbZ0MT3nlS8kJ8r2N7sQzZxin33BsT7QIqPFzpNutI4NuSra2pLAtIi9bWzA4V4XT8LBOBRRkWGnp6ApbCZUC4QSKnLY/zmQ+oW58VubHyS00RKRiU896qpn5zOoILL2l3RoM4ydUmmPyNeQmnbfLIYwajUwOTVZEECHmwEVTKvplrGy7iu7B5woEYHyU3eMM2n8C5AXiEcIHoroCH0GI06EQifiDIjTjyj4vMFwiOTxm3R7i3YEJz3pNoaTzNekOeS6jl52phOAFYkcpnH5/viceQujHteoFJl5KBgUaFYqnJodIvR/J9Ovqrr0Wc8pGoeTaRvGr9wx6po20T/k2xz2ifSaTCkvmDjFPERhx1llO3EPsZGlez4OyHy1DyRNCFCCbRTA/rlP4mkcADrOMArafK+Qe9EJplHwbsrMqY51z0cBuU3TQ91fDOiCc7RCheIu866TjPLHfBrA1JZBcMa7u9x6l4HRrILNKtRiP1SlSNhPrutjZlfTJMPW30gG4G3Fs+U9Ue5zsTpiBZxKQw7S/JG7co+LO96CkfPj5DS1uwSznXqLoAfxpBURlypzBlYAs3oqqkcMSXX0V1gYkLO+UNClQ73CuK2neKFAF2WGVuMnrYi45dxtY0Hzirjo0vqktafQTptkn2ZFtKQudXfDd33CCojQw7HPgDu1Dyph+cfltD+YHckhc/TawyzSJ9qSlLtVyBVkIaiAqTgpLeJzQvNu+HPBeDE1CRvspJcIerjY2+7kPv8fdzHb42LpNrDDoIwb132RuKstnJGMV1f4IjVPyfm79/5Qsz0y1nCbfFB5jVfKI5WaOCkcHrtQZRVuQqjQZo1C8pvYEylzrdT5cECSHSbP6jtJD22XgH4jScYcsw1gEm1DuOTebrh8eDyhhBSkkbeFTmTyo06LiR8Mrvh6onCkMIaVg8KpFfGyLquKZKtu1KD4PMCOKQqcBtW9ODnreJCr72l+aLQLRQbA2fIEcGuSNCGIg3080HtiWGwzAI52CGDsARryg7YFLBWiVgaBln2N06nQ7YspBcmZWMFrEML44TXZ+faxIfUzf+K0OjkzT/rk5qG/uKa6dwUKL5KlSzmwgZkWnZuKpO0X8niX7IZzf8B4Clt8wC5srhwaN0iNPT7ofVLQlv5JstHb5zoHQyps8QHn36n/1WzZjsWTLMPh5HR3keflN5Ld1nRHC2jCYykNOjF4V0XW383hT8orxGAcCsGfkLWPwXfMbP6MogYqJ5VTnAepVgWVNVdnOg9eoxIq8zcxs3jQajTCOZlBDm2uaXe9SX5dltVjkn79rWxa7mAA3RCHqwc6FVTWZuxMFP0QBFI2R+iKNIOv8YQ3y8BrfMrtWLyeg3whj+wpcsYeb3KjNnUphCksY1/MlJRYDCY6pWUYHPshszJ2YKOcYEwiaKTfVOXgCGrQCPy5pfp+KLL+OzXLFkvxObeJhmBs2vwjOVIbw4pBDE7d5QtPwWqWiGlQicgK20VihXXeR2KglTdSDr+gadIt8vGGoURSpe9uwubW1oXKPv3dqZIvRyNDPp91uWdB4c3IdgBT65IIHFqTAoH9opINyVYhZwyFFSILrHVIMM6tQUHDtIL+9vWlWOWkRjBjcM97Vw6pzg8XhX8Q7yIXqz7/mFsL4G2N9VBwozSFxS7Epa4Q/EOwOiog6jWicQLrrxnUvTZrSZlK3V0+v9RUKblqC4QK40AyqbqTnKRtXRaAVVTFo07VfjXaQ9awVL7U9qACUUVpB7Ut+JogHZd83QDH6PkC0famKkydQgTYrgz4UjEtAKtgdQoIsOxxWuODH2lO1mXZWlcwVagakTikbgsvJlzv5RdnZviCoYnXa8kQzEo1jcOH2KyFy51r2okPt1kLI01IPVFdl7V2f8XwV2N/c3b+d+lEgmV3ul2ek2zV2c/io70grjaCxTrAH2HenXFnjQ2nYocQLHgVAI1GTbeVatMmuwC80RyfK81JUhyqq0L6qMCjDActWii/KGib7C+0+QstnkhNhxsTMSNYk2GnWRMeQM1IxecvK1LzI0N3cFYDv44cum0DSUt2JXMwgDtkJ5MeZeKXbOfwE2maZBdSqzuV/awSh1qZW6vkkea0fflczFuI3fKsTuDH5FwjTVD+1RYURi42Y3vlZVde/xxtKXP0fO0ZmXvuBgWGl8dd43LP6eaA/PO7K3k1H8WHhD4JUutG/mD2mt9FGcY9i8Vl9upbzeSo/axPPK59rj0crP4XEo2iL3bpdgN6WN9OKqw/itL1gHsZHD7XDgTaVwTSeTRuSDtGoHJrooDW6MGkaGj9IohLazsa/IhBreA9YBDLBB6eD0Qsj6Rg5/HNDFKZIQ9CweSuOUMDjjXItHO7DipFYN9BpJ3MI8+JcIiDFhivWwZU4eIMStS0itw43LrgkhwZix+RHUX3AemRjT08P0pgHgkSQOSbIeVyQ06RcHbXHKlDx0qSAHLXLCkh+6ZJAJvTBFUC85qRAqg8srfEhpi+gcRu+VsJjJPANbyKDH5Xl22ZlrlLDudsTjutlF37JEo+aORUqUDETpYu/K7pUo+PlTBB9B4JQEGOmALA1G5JQAONkwa0zIpE8ED3pHQby7EmP2IwJ/kPGM1x4YfnKRnNI01BmHyzlKLskJOUA71rjtLCY6UoCLvroE6G9h3VQeja4ZlP/kU6KuxdVx8hdB7ZXQZETO5QZrfcrkbGSe06YjazT2ffTtUMlNuVRifN7noCn/yuLoSADG/Ac8nxTlzTyX2XpE1obm3TBsRJKZuV8Gmd+yTTL47VK/lEAO6X7AEE90xO/OC+yQDu3Ds5EcKWHQx4bisPTmwuvZOBEKN/cuYG9lAW7MA+ykrN9FLsEXOQDkp6/pR9k9q5R7ckR+3fI2mgHDojMI1rZteVF1JSd+WG5nMzdmgqB1Nzh4I6kUKOtnSlcciKGiqEhOhEC8uFBtiwNGhkZTOgdAwHKA+qrU6aDQ0IPjlRUw4BmdEE6JIf3cics6SxHLFypVcM4IwJCCE4b7pFAB0DG9FdB8GOjKBRsBHQaRjsSOeS8U2MGHnfnRyY/W3ggX2AnZvpCZZlsaW7A3y1RjY4zes4jV+XnKqIFSmd6uCwMqkzOTSJWsBD8yec26Hh65gR2rwbL6y5m3DDWrqZlmnk8520FPbtlPT8KYd4aucegzs5av/so4FySD5gGtfcoysvpNTjyg3NPGbs0MQDpoYO2TS4roM1MBdomKaBchqggYkcMrSGCyFBO9HC8rMBNiw9G1kV2Xm+n9ElRfNGpxmKGXz7ZEQhbuS0qILEzo1OEbgmSEMAWFkSxu+RAFTsiFkAzu2WCnTYOPlAT61ICtfd3YIuCeFo8CMGbYL3gFEbE3h4phKxPLKUncc3Q0llhpydwOSumUkDjpWV7Nz9xZuesJMtbh3YJ9/p/rD3ZDpa41J5ZG4RDTFrw3jdMrYKFydbq2mZTP1bd4FT7XQGlMrklNla698jXyvD98/YejSHnO3C5Jq1DWWHlLc96KGZ2wofmrtd2B2ykp4bIS+5MsMykxk5LDfZiKXsBE9KJ5xGig7lFu5aIhEaerT2jd+sY7Vm3EYco+2iNtkILdXeQO/qMiUN6IQV2eD0QwfJu/fAgQs8NJfIWM6DBgiPXyZRlBlqQnEgd8srWnCc9ALhJt9puywz34LuzNPBHLcmbBOaH2oSgDYqRKFzzs0yHlqKhvK6ZGo1rtuxPGY6VZ4Gf7ussDjlwCrsu2VVuNjpMNY3y+7szgkx0vfKDuQ+jTvCt8qOxI7NG/87ZQuv1ODXZF+2oE0T0vOnH5aJzr1HZWzUoXlIgnLOQgAavxwklxdqBoJzu+UfHTZO9oFQQ8c7igrpOM4B0GQ02RVl09L04aXy5DpqtIMGKmGTbIlL5pPwOgGfcQ2AzbkfkeDQehEgbVBJYvUgGlap/7hvkxr0/lZ8/PS9h+Dbu/NgQg7tO0Qk567DzuLXc0hlhdpxgKnd+g0NNE63YWd2zjQiL1qigbG65BkVKkaaUZNKWcbhJB3Z4PSZBuMUHUXgodkm6AQdOI9fxol3eo4zuVvWiXZyDpwbejKNDtj1XBo4mXNOjHImjRuvS16McR6NmZbJjVfFM2lauus3aH8p669NlaSgubzB8pTZ0obhkTZNZeKfP62gDonUg9A1o9rLFSm1+scCzbHQUEKTrUck0E8rrCG4fmThwQr63MIK6vThhQelQ29hZUXoNjwjgPUfoADCOhIgP9Oj3JTDCQu3FQF9LCs9f8reQ+3co8+Qo/bvKTRQDv0DmMa1V9CVF1Jf4MoN7QHM2KF5H0ztkJs0xAgZyYkWlocMsGHZx8jK5Jw7Uu9p09CyWJP/HGgN22KssTpl/jEheGQhXTn45yIjoENGciRLCc1pEQR3lIjB55g3zaRI2dMvBmgOhYQQmkkdIyA5TWnbD03uD1VV1oO4dxSMXsPoRag//bNh9fsoEYGvJv85kCawOFmRKIxNt/I7PRtG2kvVR6kIvA69vxEWYQzgQQ4bCVjBw8YDAG52VDDeJ3qRJVUL2+CvMjnpeEDn32cwoAo/YCSgRXMZBjgwOfex+rLD6mDd6cG9qw0+uGt1YIeuSumhXZejXOjA9w7r8ZxvGnbhc8nzWkKMJO/IDMzwRuTA9G4hVuT2e5KTFHoum9roR+R3BUFAhhcKITzHq/A8sjyMyzfPK8sQOdM7ReCa6w0BYGV7GL9rvleB+2Z8GKFHTlVBImZVOLdbXtVh42RWPTWTWz8XX4vyW7EmO9q0NeioJZXJKfOq1r9HVlWG759T9WgOGdWFyTWfGsoOKZt60ENzqRU+NJO6sIPekOqJnV6NunA5ZE89HULudGWGZU4zcljetBCfv3s/A3OX19/V5b+HRDvD06Il9TZJJX6NIcJ3cKn4m3sxLJS/ur7MdAUB+VDCExD+xYQjXCbc7OTH53irkxviXmgkfohuX044ItZkTzKahDeHBa8UBbWtX5LHPLQ8WR0czPOff/nb2btzdb55YIYh3dc5RtaHZOeXXEQE+Rj1W2kmoaIx2OGADdsfL9UfPamIVAZ+KO+5haruZ+TKfqbYHor+FxZJVEZ+JG/Pfnn75ucjztNxt/yh+jh8Uz/j7MvskEvF0lflwa4Z7LazXRjMbwoY7ogARyB4F8BWm2OeH58YDzTTUox/V/wg6kHBdEIaU9VNiWWSV5jB6sDEr8luyfEG4i015zgbymLSqmYtEJpKUIt7aJ/K7hTQMFBGBR0x7c6X5+uMDyMngw5Jimdal8W+Ewqh5HXwMefjBIuvxiGXHXT8Qz4qoaP2J2MOGwWCQHkdfMwyxYBkVNAR5bVHH0T46qMHYpXUyZ60pA4rRk4GH7ImGe1matxYx4tzUgJ95u2BWiff1qQ55GHJqE6+1ZMKPiICHyacakwxrem6UE42KKMJmnm7XgDevOoEdDj9f7yBRmtcpGdSN46pjac6CgSDqarQ/eGxm2wMlyG6UHKGOEPTOn2iLUlbdlbiRbIQpNxKji8S3ZlmZb1PAgtsMYtEAOTuKPXDA11W6gXXPCXn794H4s0iOIDiCsL0vGbVQJT1bQI6t9fjkAvofnrcF+PNuTQIXxXPJC8rcp8+kX0yczwnNe2WtWQWtSEi0RSkMxFviEi0JmlZZ848rBkijTMHGsG0nQpMwBv4EjBLbWlNkpZIjVZeZJsIeAMEgiqpGxcA7nnv9KFbwPpwKLLcuow1POW8mNVd1nRX5jSFrMuMPmRbp5jHeHSvQJLvH15aApmemXG62yUeRyUHLoWcAfWSVKDO2Y6ajUrRUG/KDKlUi1EpGup9W9Nid02KHVLhNr1gPgnGAa/LskUo4EkGDVI3LhHyinJUIuhrk4xDa1f0dsMz0B5nhFAZh5Fp+yChpLQdwUimMkYj45/52L0B5CZ8NjiNPRof1xc6FpzCFo2rITVNcvqnL5vGPoxP6vMnimW5r5KasjuQhH5fftLY97N1u7cgH6eA9UWg8CEag+JXRKV/myg/fFVUh1bIDrDSWEz/ns7/TjuxZhKLiT2si2JxD0uQCOCAOnfTrWbk9E9+2mpF58wcauMjLciyfCY1u/UFUBl5f4KQZ8XkQ9cRd2/NFNvCfJh5qXjUk9GnpE2f/Ik5mXi0Xb5safuCUciyVkTu5uLQljfs6rU776wRj7MYHyHL7c6flFWJxzruovHHHAXiEdZkS+pxqT64uirE4pE3/Hf2zrCDfUS+fuJ2UWRdc8AoXY0gcgSAPnYYHTTw3nU0AK/wXNI9KYbPqzvDfhBlmJ3qHaqEPMtrClq3Q3fyhMu5YHX9iJXi2p0aZItc0otR8kTwy/Jg3F3kG0E66p4iDNCmHq9A4Nt8sEIxb6HyCwKwmQoHf3o/0FzS7da4w8EnkFk9m9RPEFJNd0/Y7WPSPBV+jDbeC5+wkTdt0h6wm8YseoIAWvK9vSR5myDH0Olmo26cMNj5cFKUBU2T/J+N28hscsUJoI0s3ivGFcJWNQdGQSIGZb9wkef3fKV2YOQEYhA2h/0+qemfTpPbiW42jkF26NbHyvyZZJfSGNKBUSGDRguYEwxrhQ5zgtHAPCcQXv/MkXGrFNzbH70jztizaKYo9YgfNcXpSqvTiQ4uV0JH4tDqJ6Myr91gK+zS+zc9tVHwNBEoF9uDQmAV8SqMLglclk1DSS1tOtGkAOFx8KLAsUXkufWbZp0zWcSpfMRQtV/jCCceBAMulEcfwEkVutrt1C3ZQwamUPJJLzJ2W7ZJjog96cXGrg9F95GDaQ+7MzqjiY+vapP3RVI1TyVkUqbzNUnEaY9THCEVmyNc8JpBxTyXnuWDNDR2RjAqOB3PvOk3vSYh+ZrnZ3SbQTdqGG4LcrAQPJbifPGr7sbszPw9gxs8qxgb/dnybZEz+SQYF7whh6y0nCniiM5KRoVvho8T0MiPetjY4uat6VH7BmidM6UMUp8kjaBdjkJQPes0ebYedcDN85TudBKg8lEGq/wpjcUi/ZLqgoGVljOl5if8PckPRLv4wT4Dnu5cZFlNmoZk3FqH3BQ5cc7IId6RX/dN3KDqD7E4KoBheBnPjy1tXJCvLUFQyl/uznweklr4DroBDPLLPSXNp9LY8VsgFk9Jsy/tHb1exneaaQMDTSvdsQryvb3dbhvjd6g2tk6knETCAdnKdU923ba7+35F2vThC6fMW6FVL1KYpq02gsVgDi8fIXYd1HeSHlrL2Vl2NlYFG9Ela6ngnNMWDKsmSRZabowGNl5/0lII2ySADfatpsH1jdFAwNMu7g9jU9OQb5QWLEJShmLxe1S1rXlzRErbEK730gjnkjZtYpw2cESCFRJLPwNRjyHMOLIhJtFlmR66ymZ4vSvTzEaYJLrKDOBBrNUi1TVthI0pAJ7ZCJOkG5o6/Uq9ASbB3bQ+5IRxtMJkWZO8Wwqf2oUTkWiLyTXmbieeySaEQ5rBUuXVqrq5rPppp4WIZV02ze/DiTLcva78Pl+ub9K4NUuBikkTvh6f87M+aN6Ta4BF49Mg3lb84rUP6ahxGmDhw1AfXodvQ8Nw5SbjjGtqRx64zIArNTYQ2/hLww4RRY+ECr+vJ7taJj7tMETHgmbV4rLPz2KgC2I45NKn72ImuBo/otP3tNp6bpI7Bb2cWwLYkbOMRH5Ndkn6glz6ZlH0SPphFtJPYNBC567JM0UDN4mhk8+HEyDBW/SQBgTiIPrfTVlcd6/0tS+Bjk+AXwH9UxaVV5YY3X+aXMhRMsz+pwTp3YNPBlJKBJwGZEYCnQDkigQ89cdM5nLSjw2Q+667e+ILbZ+oWJukNsXIymb+lUrZXO6fkko7zZwfcGosvQWoxQzagg04wAFdXx3o/rC3nQRmpliMKqBTwLRSFkRI27Yjgtu4DyKkrdsRwW3ehihOBP8p1WNu7qeQ9K5jzAB9/rNtTH70L5h4U7B5pdiSWi4AZU4ZIHgLbwZlNunXuUzZpH/AaZ3qn5Ks9OMOov80yKtDGmS1P+5tv18K8usObkUbLI7+z24YjIk3hfQDF0lLn8lV0VTCxn/hdxafc/q5R7N7uisS7vRn7leXXIhmoKilgPRYN/2jy3K/T4rsqng2nsgr0WmsQyGZepKRfdKNWu6/0a21ykp8CmtENjr8/VOSPpXOaLIxPtldThv3QpON8cnm+uxLJwggEnZhXzBnqzfOiBqF4KYr5q2K1HvadMukwjm1Qt4SnzPmLe768dnw1zopWuMVuZITlTGoCKSwjnCO1+bCmVwu0AWp6gaepqt0HXAhl+oGcfYPFhioR6V4tOYraR1gYZfTurKyE8lPQ3EcLe7T0niVjeRMrRDatHRXaW0K7n1/GN9CJexW1Jrys+7WwwuBk4wJv7ccROKEvYccPhIIXJD2W1l/xUI+ysWELmu6o8ZPr5ygj3IxoW0najshg87Vdgdms56QIF3IBVPUPJcmVfJIc/PdiyCiBSd1hANcwm3Tj5KklTGYs3PMUPzStDoITX6Oil/RmjQb42VJUHpGKmgQooPddX/cGG81g6EyQlFAc7olLTVuZYeBMkJRQJ37aSWl3EFHrLEePbUSWtVFR8SeL8DcUPG9v28ESsko1cRjoKEmVowwIpa581BDCS2PMXCR1YMN6/09Bg8O9/eAhxuE5rTYeZYmexUKo+RbVy2oZdEc9iTbTFkeA1qlGQe/94CAPOvEwazJc/kVt5BVkmjw6la2Jv85kMazBxyN/6uG9SxTnIH9VGRxh/ZcHDEH97ZwQof3fCBRBviWEALGeBw89ijPgh00zuPA8Ud6FnSssR4XBepozxZAyHiPp0Yf8VnQA8Z8HDj2qE/GVvdIzmvqMRfTQ3sjZqVO0xe5FaJ5wRyn50Fd8o+71o++yB9rdR9xWT/eej7qQn68FXzUpftYa/aIi/WGVXphQ9DxyaWct7jdQAYnR9PQTGrAG6bA7myDXTywS5LSRruHykA2GYaisZ/O5CSp78nw3Gxh2KIt4WkUMBmHZYGjuAudaIvJ1X8hpF1MAsApBRAJyXOSHzgXDnSyMSJZv/rghSVYIjLR5i5pn5Zl0Sa0MF3tJTEJlohMNcnLJJOSk0sD1UmgUnZrSl4/p2ganHalTXDdsQ5Ns0yq1nC8If8U+KuP7tbo7tII41yCl55NYJHy9NqhovGgTyPBYg840lOnoAOqEuOXHWag0RgVqHlKzt+990aazXGh2PtAnJEGY1ygl313vdWm5c8/cEYTZVAhu9GSN9poHAok5oDmpWnJfvlE0q9VSc3TNlldtEbMDEm7MR5zCKVZTEKuJSeVjG5yvt2S1Dz9gaIepWLBbqllDQGKOgnFAi0S8/YIKOeoEwsTcgsBmBV8/YAbMNvkrzq6ZDyjmbg0d9ESsalnifEyNAjIYtRwKTapLHR4tKm6m69JtnFMShpUWS8Gdnlo09KlEalpjzIxILu77bvhLFLRynJRoLu1evO1EjDao04MTLfhhhrRY9RhwONeaahnN1ZO3g4xC3XLQcWhCiJZHEVciuwOBEi+U4d8raIbFfDR+tHAJtm2xhsnAIS8UCzQR7I1H+4NJp2VIqH2vfomnbt1hwyphVZpRsV3HiFb0P2GyUDs2vZqEIBag14G+uDRY3LdkGcSXCGUevjYsIuAALwOt/94ge6Tgm4tO77slIwKPmJR1vvunCb+a3YvTlEKH3Y02jRJdwtf4I8vi0UBbsu0zFFalyyGD1yTIiM1yTYYmUsWiwHc0OyQ5JtD8bUov4VmBJUcPnTTf+e+eR7O7gwjlrQi4JK2zcneaYKvRGV1ImA+0T1KQ+OF8EE9lnlUmL4LPFpIxYTqvk+OzpyD2Y9bv5UxvBZu+ULQfgHQn+oSBHfUQMcbNDaV+UM2KyEngw8ZShcJaxwi7OryUFk+BbQzymLowM2w/yQUlZPBgBQySz+McVwx5sx+aGYRMHwzC1MIKCvZCjKPZWwYGK2tV38D6BgVdMQ9aZ9Kt1Yg8s0S6HDOi+kKOr+VdBCe264FBZvHzgUY2PhQGNxRBB3QfS1fAei5kK8DZHPvepyRPXQbh4ok/1g7vRhVmmPm4rQ71GvzeNhuXZZ+9VgLUdGlQNWFhdONmJA9uhMn1LTMD3uXibIB9qgVD/dQN2W9+Y7DexSLDWz8isUV2P4dSwBwTguXpR4D7aQUDbUuv+GQjkLRQN17AgOsZ4/gCDwe2J9tGrednEZwSRQzAO5G1ie6d5xSzCaYXVi9E+7nc8RYsAouhXUsAJwuSsTy6JasSM5rJwKU37qJFct5fC5g+Y3NrVh1eWjJhhYZcegMBTReAxXPPeUJbJ5pzgrWfVNHi91mmHCWxvuazYQqpVBUNol5jsujjcfdMgbSYBbUXbmtjSjIPNZGInX8eB2+DpA5tZm3sB3ZLOirjMOqm/LK0uOD+u9nBDDZNozr7dkvb9/8zLSEQ/tU1vTPycl9SoqkpqXDdzSLWWP8Y3PUwIFMy31ny5eD9iYkFeKoMP4pPSpgAtLuMok2aQ/iieFgwE6h6RWaSQEHMCM1fZ4LUKB14RyEpnIUoPFw6Y407RF3T1vuLS0EtJc4gh4lcBCvV79eLP+1uVvfLlf395vlxd3D5/Vq82l1f3/x68qFNO+voJv+tBkr52ZPmma4nBsHmNvF4l5BOXPk2slmOZ8E1NvHSj7zL3z76e5ifXV/e7O5vPq0urm/ur25d6KcfuC51WwyuidF475Ny1SW3INMU3f+xflkybR15B9fTErdZ7bdZjsf1lkkPYogVYPhwVV/Loj8MTickUwK1aSACjhwSUcQwPkGrOwogIrn1bwjteyKR/LrZwS4CD2NgOndkCdE5Pb7nOQ0644RUI9wAXyTAp9wvAEtX4j/PngDN47j8+Cvxu80AldNc4DPnxjHRkGPCQFTBtrXzNPoIwLswmtsA3WB8vbXLR7398IewbwHtznLrJLxrRbCqlHaljh307YmOD9obHvshfTmmZh2IeDoSK3gVCTH8JSMsBElANUohEkMHFQCkM1KwczvwYsG2jYi1gRRAZMRNi0HoBqFgol17Rg4mJsec+0/dWNtbe6eHakFXMphDk23gpzn5TeSrY5nG+LgLUZhwgm7EGvUjYGsvrekLpL8xn7en3MoozT0CMCgYEjRpR/AazcQ/1EtJvJ80OTadjygC/qsCjsuMCiE8eURJv8oGQdeOrnPOHPmD+9T++JNA/OMBk9KthAwQ+p1QWKGAsB1T91QYAYy6+DxmpY9rZAKYzwy87zeyqY0D6R77/BiSDcqmQF1CniMttcEVkSNAB6hcWXbiqeyRmSzLrzaAXUS6JSGRToopSwRmqjFYXG3Sj7eIkvL4rP44aYwOlY/bRwkc0cystbLPKF7yaFUMhqXBi1QEWniBnDf1eWjaVIGAh5EIpOOz/5GkiyUl5XCobbUxN9JTbc0NS566i2gNfK5s3lZczrQkuL8qYQ8yomLWr9+rTe6KqqDeHu6W6kt+L8/M3+nnThsKd4rrLXWaE2aQ659x+EfUT3pnvI3GoKJ9SMNISH+Sg4NdYgJ2HsoDM2rLcIcYy33AOp5ht2tQiqw8U4l4YQv1PLwIAbBE4dy+9iQ+plkwopgUDS85okDMiSioKBkXfTAmKmbYsCkTETSJM4elkX6dFHdVyQV7PDiUoifLjJbHx8cncbBj4kwTsXUecBPJ3KPuSV1t4f4vjzUKVl2jgCjW4ORY08JcS/kMpNzoyCwOE1I6pdjwzMvgvM79hW5YshuIjVIxooiIy1JW8HhdVLsDuzWBcc4jKKxIqHNPUlr0l7Tr0E/gqiDymtrir/WSfUEbIH9s04N7zfatGVN0yRXeTM1uMGX0t6nfAbHjqB9NxBK24ucAvmTeL6fO/AkgYHL9HNPqnKxd26quqdXwmAWdiIcWqL8Se/5eytszX1AtwtiR9BfZGRugUB0vdJJmKWaHYKNWccZcrFm3nWvAT4mND/U5H+I4QIqUD0X1JDZ+1cWGBVFL3QKYs9qYtRCSdyWLvhqX5V12/3E7M145q6YswHv0VnrRIgwrZc3Ahj923R9SpEvFf15cg3ZbIeGYdrHEI6/kHx5R2N1qD9fNB8+5XmiVeRoRVcnCVZs4UpT45scA4dBEbN+2lq7+RsU5cO+7du6BU/tTaniU0TmHUj75PuHl9al1Vr5Fvvk++Oo6Q6qFjbgX5LKuDvdBz8bNU+AvyramqKXP5lVTxBCN12OUYm6bwNOVZFsNww784M24CGAN/2qxV3SdptFUSMYlKujcoRQFHl6OG17fFWvz9DcY85v7OpstDSuLvA+ZDtgOuYjMoGpY7dQ2UoiBGl8wvwSjQfgTLBxqu6TG/efTrYLBBPeH/DVwr6owtPpFDAZuYfcARXmeHQH6ddxBdQpBDJKayK6FqoYA/OASnM8uiF+bzqleWjTVWR24+YZzRTVmC4NL8F7OaeJr34aROraWJidD1LXwX7Kr1Y35Vc/L/LPcShauie/CxdOiD8L9xR0P1tzqPoZ3U2ZSQ7kwHgXCltYxHw8hsi7E1douh6eX5b1NMnWlYHueafKeq8RMVVirWOzGKi4tIWgzNC6p0HJWhsGQPWEscDe9jsH4/yKHxAN94ZkeIAMdeKiyEZLfYPThqDVwuKWm+LL/rHML4okf2modsMe/xQ0CXX3oOz6ryjuv9Ft+9C1LEOh8D5UxrBS4CPSfHzRpOUzqW8f/50uRzEomMI2Ctd0dLgf2WyNztb/HL6FxhqHkUk1+Rt5/HAospzYKrP0oFM30hv9Sb5MIoY5kOxIaQwqBzk6PeIXbUlY8CTDYDQm6yeq2G3JXmY0yGDSSo+5k2okwn9uc83/kzml31jz/ySq8bL6g7rh+fEYgWwufH37l13pNDzKowvRXB6jl0u63RoKg3nKKQcM34x1dXA6WMGcBVg/GltoKbCBGTOAqgRMXF9sxeGAI51pIoULaE0sjVEFjZV/xhFRZRxGJp8HwsRvbHnmogusaqrWVhYtKdqLuqVbw+F38pNOre4LeXwg32UvUq0WfAh24PCFoHRVhtWG1BmBTqkQzigtnOlKT1l/BEalQjijqipdFd1J3Oxx4HIlmp8BvxC+74+T+EIe16TpX4MY3tJwDiRDaNTHODRvjdKhWDYN/TOQZiFIHdHaJvsLbf5CiydS0+FOShOqrK995Uj3ZNO1u0ByVucE2GVNd9R0PxqEeRY5AXA9/n3zlZj2L0CwBSlw/YXDItSH01WFjjKMdVCIg8rmri+M0fQoP9y08GsFfmguM1Ppc5qtWPXFhZXLLOTqnIaO7ZbLLMyKnIYOjFjE8UvXIT1YWMU0gYGqSw/3aU2r1js5MOZ4qSGrNk9JY9oeBuZZMGJ+BcoWkAaYNpthxIlCzKpFQ87Fr8ZCiBmxeMCk2Bl3DDrgTlLRYMdh0z6pNp5ZQYKWJKPBYxHjYypm91O667+OT2lODd+lit7UtiFpTDxNJ6U5u3g5RGWcRh8B9QLYhN5k2ESNOLw1L1kdiWRDbKIhTuPXSGqi2TCESLXq8SmtLsc3ZKaFD/Yxp6WzyepLr/FQlrllxZrzpLOGlgIXnTEDKMvByPbFWiouSMzKXqYJGrDExwGZdfB4hYdcMZXmoT+woqbfpzUhRfNUmlaJjw+5vZYZkusXVsBczRlHWmNoITCRQd4cHR+3NEWWUWuNCvlF+TMZuL5YfjIkFOvKvw7JdcnaHc34mk2H5fKiTYnEvmfTVV9AImD4LDJotNqK7Ihr0cHi/Sb+bG6YGvModAFkCFSq106GBqwad7E/r14CizIjaZmRZVKURffV84ekIe/fQvmUxmFJ5vghfVlVpP7rh5pmO3KdHIr0SbGxY3hqwz9l7DTPzv9+PDqjt76oqnw8MEXyM0po/GjtzWWgDu2I+O6MzRTjYUslDtSCF3QA1Atrl2irdrweD4H7KIbNfP7z278za0nd33GQZy10Ymb9kzVXLXWoydn/G1ZZ+dXOnCTFoQrgWBwlXEqNKwVddfxWNOOB3Nd0S7gtyh6gndx4vnR+lMOGHj2EgB4lsOGap0Obld+KDy/L8B9+Ent8Qa0CurbCJHkn2NDkbso2PiB+WUaPJxXXPWm4z2eAkKMZYnJh77f3RlmwKu4lNhWGbr/CobhS3mADxqsPBdXfWhOA1pTp1/4rbefqxvENMsY78wIg2/IrCappi0kBA006aU3XNd8KA51hAuw4ZhhFwhoM+0VmQ5prWhy+X5K96t4KNR5nFZjpxLH8GPq4o/uuLrc0ly8bHbmUD0P3aw8a12WSkfqi3jUfy/ohqXdENfMy+9MJgYpGHbDmBUZT5s/EXERAaJMWCrfml13mlCgu4OVYh2ccZ2iCsDAo54QtXnSxjh6852BmBpdJl1ZJN4ZIkzzvltV90ZI8bwdzZK68bIgv1GiLS9S0Se1ZixaTbTgRM8BiHxH7ELnz06q79BwaKmE/hXWADGJZMEJ+5TYVig603O0wMCeZKJBlcUmTXVE2LU2DUcsiY8WiANfkPwfStA90T8pD+ym4Si5GwXYQ3Ftnor7gfRs9VHjgo2AMcDkN3HcXO9RXxbZ04z7aoSWA/j8hEItRwbW0mDLQoD0Lhzl40R1FUAA1w6G7unymmX7Rmn/KcUgkiSu7s1nc6ksX/ewncGhkInEfHmnU9EOkKnmkOW3ZY+48MHmZCJz9+x7IaNfM2cukkww+J81I0dL2JYCRkcDnGydAummUO+0omIyC1SyIws68yvzt9u5ute5uVv396nK13lxdrm4erh7+pXifqaHXCIQ1eQPhw+3t9WZ5e/Owvlg+3Htz8jJhtFI+rsbDIHSZePq7026bwf2aNFVZMBMdbu1nFuYfBoU3QyvXC8ZTbAe9a1oYFglmCMkGgaMe5YRThPQQvIEvwfFn6F4nS79r94/QtaL6oDoaqleoD5b16965TrU7V/WlKqnyutNJ//iQkyfmMKF+RPLXIecPwxOpOIZnNuwz4E9Hl4yRYY6qcqEwNQepikUzDpxS8X2RVN0ego80N5xz7EK3mKSbUbpL9dUkDQZX6WuDGTd1XBUt2dW0fem+GabFgazmW+wDQxod0MlBOjogs4M4gT0nNB/GTC9Yvw4jGfdXeazLb013mlCnw2/F94UfJUtOMgo8yUna1tOFgTj0k+Yp8Ls+vUgJYrOeJOM3Z1o8k6alu+NRcmvd2c5OEXC6/R205iOeA8PQr645UVtW1wIhK1Lvaf/i7mK4sr4NrylHzYTRjIM/7M1AquKjGnrtlnY1CuOM47BGhWsZdoD7f2nMs0+ru7rc1ez+GGHIwzwCHQ8yJmvSHQRqCpTVVxiCwmXDMERb1eW+arst8DlRHhY6IonPgUd6d4LhvfakEJ0ntQKoEKTodEskwxNYWAtGz4lPI2pqNJbyleqW5NIkE1zIYnUbjgS/JDV9Jtlq7Dt1dU75MHgCZvQkFYvaF5RALhS1e2PJ7GjTdvsBhkH18FUKbcqCew0rFZHJCl5WIN+KQjN6d4ZTFaORzKE8+2/EoMXYP+xberwna6ENvqAE9iIa3ANK5sMwbQAVDPusa7ko/WiLhfMEdK8vFM43pEz64xDd2p7KxrmMTH71ZaXy7IhlKDsVE6AMV+OEDlSxuIddS03tSVtcvC8ogb6AePeQkimekiIlGaxk2IfBwy3Wat0r1bZputqhTsithLiAdcs5aUufibCTDgVzMUi3k7Q7s1bftoIovh1Cigf4qgg1JOuM3ScS2PwdJ4BhLCaNAXECGcTJUfxkAYnXoWDGc5i144SjSubK5KhP5pxLaNJ0T1X6ZD7+5PJJHLqELho4d3daj/pSkny60BhKS0JxKDFY98c+7FtS0LrE+YIS2EsHXJc+jmRuA0+1lWtZWXxrC03j3RlOX4waMkB5XrFr2qDqJlu4lqPBp7YMFV6dgPRlp6ABlNtN0g/FIAXGPOpaUiov2iJi/cB86wuFdQwojdvtlqY0yUHlwT0MHq6zVo7Ddd6hTsipfPiAcYbrDphew3WYfvDY1iUMt7FtWADOY1uXQPzGthgBwce27vE4jm2dw1FkPHUm0eY83iU0w7i3a23mGz9odxuOKI1c+wazZ22JqX27kulLUI0FK8l91Vp7j/ExcL/x64FmJBusxmpoetErulGZu5ZHH5bmfdpw8SYG0GKWcuFS6pkrHmsBaKKTI6V5aFHqKtP4MfFwBTGkSUoGrs1R71FbMrJPFxp9Ocko8BIDjeDYZ8ENkTGy72NUepIVfIrFPGTz2dboAhuwuxHoJsImR7cAA/c6hobpsuXRLTDnnY+BoThtwnMKxX0vXmAo7lvynOLx3JkXGJTb3jengDy2wIUGA9wJ5xaGy4a4wAD6j0VJdgGZaoPgR8EEPMGGg+vHD8B5D+cK2C0794zyWOFQjPt0bisiLL+IQwX5UYcPQrRe5AJR+IH5VhSHwrGhNJqh1Gx7s4THoKVAm3uNvlQGogfJFBS9GI7pmBRvNLV9IJ/ul+nqc5/PqP6Vk+JR4y/EfIl3ubr512bVfT53s1xtPl5drzZ3t9dXS9XHggZvWhmXUuFC1dPerW+Xq/t7f05eAIHw7dkvb9/8fKxgF+uHq48Xy4fN8vbT3cX66v72Zv5I0fU3nIeim3Rejeh2dU4fbiNif/h8c3m9QoF+7DcTxUdeXlxfb+4uHn7zR+3Ortl0Z5HFQvzt4ubX1eXmw+q3i9+vbtcBpE9JsSPZ5pE8Jc+0rCMBf/x8s3y4ur1BqQhTMo1fFeZW7Ys6jvMi4a1Xy9ub+4f156FsvSn7u0aGgw5otLK8f7h4uFpu1p9vHq4+rfxhmzZpadqNb7rjT5BgpZ6yO3nqutztaLHTETKPQMcuebnrAFbfSXowD99YcdEK1LuwAVjiZF9CiCtQipgVj0Pjt3lTFoPKH5xDXTIqCGspcR+SKwtG8+W4piyW4wFp2k/UZW3RyCHg3sf/+9/Xr2iRke+v/vF/5yNr/vHq/Kc3P/3y6vWrLSV51rz6xx/TSTtpud8Ph3VkZXro/+f/jo/93p9W2j08PP3Xn1+9/uPn1387/+nn87f/+7+v/5iM+z/0/zBpHP+lNzx79fqPM5XhmWR4xhmev3r9x/nrd+9++uUNZ3cu2Z1zdm9evf7jzet3v/z085szzvCNZPiGM3z76vUfb1WkbyXDt5zhu1ev/3in8vhOMnzHGb5/9fqP96/fnf/07v07zvC9ZPieM/zbq9d//O31+/c//XL2njP8m2T4N87w769e//H31+/f/PTuHY/6d8nw75zhL69e//GLyuMvkuEv/O/fVYezn1U+z+S6cyZUnr72nKn8ninqD1+Bzrp6cXaurHtyJTrja9GZthqdyfXojK9IZ131OHujdCzXpTO+Mp11VeRMWQ/P5Pp0xleos66anL1TGst16oyvVGddVTl7rzSW69UZX7HOuupy9jflzyzXrTO+cp11VeZMWS/P5Pp1xlew876C/aLKFHL9Oufr13lXY86VlfNcrl/nQoLqM5Qyt50rkhRfv867KnN+rqrZ53IFO+cr2HlXZc7fvH5/9tPPb/7OG8sV7JyvYOddlTl/q4xZrmDnfAU776rM+bvXb3/56c2bv/HGcgU75yvYeVdlzt+/fvvupze/CNhyBTvnK9h5V2XO/6b0LFewc76CnXdV5vzvyp9KrmDnfAV709WZ819Uxm/kGvaGr2FvujrzRtlzvpFr2Bu+hr3p6swbZQ17I9ewN0I/2GcwZfp7o+gK+Rr2pqszb5Qp7I1cw97wNexNV2fevP3/Wbvb5ThurUvQ93J+OzwFYH/2Hcw1vDHhoCXaZh+ZVJPU+Xqj732iNpJy5cqFbFIz/xhMCVWsWonMxLMB/DTy54vtsz2OCRv7hI1rZoayE2McEzb2CRvXzAyj//mYsLFP2LhmZtDL6jgmbOwTNq6ZGUH/8zFhY58wuWZm0ITJMWGyT5hcMyM0YXJMmOwTJtfMCL3AyjFhsk+YXDMjNGFyTJjA3VbdbtGECbnh2idMrpkRfrN2TJjsEybXzAi9SMoxYbJPmFwzI/QiKceEyT5hcs2MOP3Px4TJPmFyzYzQPkyOCZN9wvSaGaEJ02PCdJ8wvWZGacL0mDDdJ0yvmVHah+kxYbpPmF4zo/QqqceE6T5hes2M0ns4PSZM4Z6+buppwpTc1u8TptfMKE2YHhOm+4TpNTNKE6bHhOk+YXrNjNKE6TFhuk+YXjOjNGF6TJjuE2bXzChNmB0TZvuE2TUzRhNmx4TZPmF2zYzRhNkxYbZPmF0zY7QPs2PCbJ+w655l/2W0D7NjwmyfMLtmxmjC7JgwgyfHenRUdhNn5OFxnzC7ZsZowuyYMNsnzGL50HoMmO0DZtfIGE2nHQNm+4D5NTJG0+nHgPk+YF4Bo+n0Y8B8HzC/RsZpOv0YMN8HzK+RcZpOPwbM9wHza2ScptOPAfN9wPwaGafp9GPAfB8wv0bGaTr9GDCH4Ykan6D9n5MRin3A/JoZp+n0Y8J8nzC/ZsZpwvyYMN8nLK6ZcZqwOCYs9gmLa2acJiyOCYt9wuKamaAJi2PCYp+wuGYmaMLimLDYJyyumQmasDgmLPYJi2tmgiYsjgmLfcLimpmgCYtjwmKfsLhmJmjC4piwgEGwGgWjCQsyDrZPWFwzE/QpIY4Ji33C8pqZoE8JeUxY7hOW18wETVgeE5b7hOU1M3mhr3xMWO4TltfMJE1YHhOW+4TlNTNJ7+HymLDcJyyvmUmasDwmLPcJy+X4ah4DlvuApS9vHvMYsNwHLK+RSWHjM3kMWMJIaw210gfgJIOtONp6zUzSJ+B5bP/fb363/f9rbJJ2oPMY/n8Yc71UzmgfOo/h/4dh10tFjYZ8HsP/D0Ovlxp7vdCudB7EBmD49VLjrxdOFhcyAnuBIdhLjcFe+LjzhYzCXmAY9lLjsBc+fnwhI7EXGIq91FjshY8hX8ho7AWGYy81Hnvh48gXMiJ7gRRug/58LJkN+x/G/Wvg/8JzSIf+IYdz8P/Cg8iG/3H8fwIAHcRqjADQAGpYnw9pMwRABZgMcEnWhzQGASgBNbhPVaoxCkALqOF9xm+NWQBiwNSARi83jXkAgkCN8XN+YSIAJNCmCSzgiLBAAxdofcITvWo1QgMNbKDVcH9rgzfA+AnyV0P+rQlvgAQQjKDVsH9r9ELSCBM0cIJWQ/+tGc0woYIGVtBq+L81eq/UCBc08IJWBNAWMETIoIEZtD5zSOGyETZo4AatKKB1HmRCBw3soBUHtM6TSPiggR+0IgHONY0IQgNCaGMqaKcdCVGEBozQSgZa50kmktCAElrpQOvCMZUEETihlRC0zpNMRKEBKbRSgtbtJ/Wfh+E7IEEEVmglBa1z3iSy0IAWWmnBdT8d2gAJIvBCGzOIPMlEGBoQQys1aFyiGlGGBszQSg5W74BIQwNqaNJPLmlEGxpwQytB4Jc04g0NwKGVIdBLGgGHBuLQRE8uaQQdGqhDK0jglzTCDg3coYmfXNIIPTSwhyZxckkj/NDAH1qRwuqSRgiigUE0vZxc0ghDNHCIpu3kkkYoooFFNO0nlzTCEQ08ouk4uaQRkmhgEk3l5JJGWKKBSzTVk0saoYkGNtHUTi5phCca+ERTP7mkEaJoYBSt2GFxSSNK0YApmubJJY1IRQOqaHY5uaQRrWjAFc3aySWNiEUDsmjWTy5pRC0asEWzcXJJI3LRgC6ayckljehFA75opieXNCIYDQijlUo0Xt7QiGI0YIxWMtF4iUMjktGAMlrxRONlDo1wRgPPaEUUbfAnbUIaDUyj+bwq8ydtwhoNXKMVVbSxqNoiSQTbaMUVbfAnbcIbDXyjFVk0XvrQCHE0MI7ms1yO92iEORo4R/NZMsd7NEIdDayjFV80XgbRCHc08I5WhNGk03OBkEcD82jFGLSIrRH0aKAerSCjCa0IawQ+GshHK8xoQocsG8GPBvrRCjSa8A6NAEgDAWmFGo1XVjSCIA0UpBVsNF5d0QiENJCQVrjReIVFIxjSQENazBzywUsCIg1EpMUs3+T36ARFGqhIi7McEhhpICOtsKPxco1GcKSBjrQCj+uGdbQBkkQQklbo0ZT3yQRJGihJK/hovHSjEShpICWt8KPx8o1GsKSBlrQCkMZLOBoBkwZi0gpBGi/jaARNGqhJKwhpvJSjEThpICctZxJ5lImeNOCTlrOYmEeZCEoDQmmlIo2XdTSiKA0YpZWMNOPnApGUBpTSi0YaL+/oxFI6WEovG2lGO9VOMKUDpvTCkWY0iZ1oSgdN6aUjjZd6dMIpHTilT07hJRudcEoHTumTU3jZRiec0oFT+uQUXrrRCad04JQ+OcXp3UEnnNKBU/rkFG8/qfxsjl8jqT0GTumTU7yze/VOOKUDp/TSEToXhlhKB0vp01J4IUgnltLBUvq0FF4M0omldLCUXjbSeEFIJ5jSAVN66QjHmE40pYOm9KkpvKikE03poCl9TqygD0udcEoHTulzbgV9VuoEVDqASm/L+8NOOKUDp/TykdU8BxJAnGIxPYXX1XQ2zQLnWUxP4bU1nU21OMy1mBnk3QCdbgEZnJ7Ca2w6m3KBcy6mp0Rjz/ydTbvAeRfTU6LzBkgIce7F9BReb9PZ9AucfzE9JegAXGdTMHAOxvQUXnfT2TQMnIcxPYXX3nQ2FQM8pReP8LqMTjilA6f04pEWPMnEUzp4Si8eWcy9IZzSgVP65JTgZwLhlA6c0sdZDgmndOCUPs5ySDilA6f0ySm8EqkTTunAKX1ySvJzkXBKB07pk1N4RVInnNKBU/rklKSPKZ1wSgdO6ZNTeGVSJ5zSgVP65JTkF1XCKR04pU9OSX4uEk7pwCm9fKQlPxcJqHQAlV5E0nixUCem0sFU+jQVXi3Uial0MJVeSNJ4uVAnqtJBVbqc9YhEVTqoSi8k6bzeqBNV6aAqvZBkMRGQoEoHVOllJJ3XK3WCKh1QpZeRLDo0YiodTKUXkXRe79SJqXQwlV5E0i+Dz0gkOQRT6UUkndc7dWIqHUylF5H0Cx286sRUOphKLyLpvN6pE1PpYCq9iKTzeqdOTKWDqfRpKrzeqRNU6YAqXectIj+VCKp0QJVeRtIbPxMIqnRAlV5G0htPMkGVDqjSbU7I5ecSQZUOqNJtnOSAoEoHVOllJJ1P/e4EVTqgSi8j6Xz6dyeo0gFVehlJ51PAO0GVDqjSy0g6nwbeCap0QJVeRtIbjzJBlQ6o0stIeuNRJqjSAVW6zyTyKBNU6YAqvYykdx5lgiodUKWXkfTF3HCCKh1QpfucHs47VYIqHVCll5H0zpNIUKUDqvQykt55EgmqdECVXkbSO08iQZUOqNLLSHqnWN8JqnRAlV5KsppvToIIqtJ9Xpr5Uz9RlQ6q0qeqLAYAiap0UJUeM4j8VCCq0kFVeswg8lOBqEoHVemFJH3w0TOiKh1Upcdcq4DaWieq0kFVeiFJ58rbiap0UJVeSNK58naiKh1UpReS8Ml2naBKB1TpZSSdK3EnqNIBVXoZSedK3AmqdECVXkbSuRJ3giodUKXnvEnkpwJBlQ6o0nM+NlMl7gRVOqBKzxlEnmSCKh1QpZeRdD5RvhNU6YAqPefCGbxTJ6jSAVV6GUnnE+Y7QZUOqNLLSDqfNN8JqnRAlZ6z8oYnkaBKB1TpZSSdT57vBFU6oMooI+mceQdBlQGoMi6zHpbeXgyCKgNQZUxUYUOpg5DKAFIZk1Q4tQ9CKgNIZUxS4dQ+CKkMIJVxmTmkF4VBSGUAqYzLzOFiRROyyAaQyigh6dypByGVAaQySkg6Z+ZBSGUAqYwSks6ZeRBSGUAqo5BksUYJQZUBqDLKSPgyY4RUBpDKKCHpXLkHIZUBpDJKSDpX7kFIZQCpjCKSzpV7EFMZYCqjiKRz5R7EVAaYymhzLSF+JhNUGYAqY85R4co9iKoMUJXRZgz5iUBcZYCrjOkqXLkHgZUBsDLKSTpX7kFgZQCsjHKSRY6JqwxwlVFMslhuh7DKAFYZpSSLRXOIqgxQlTGXsuILMAyiKgNUZczlrLjSD6IqA1RlFJIsVu4hqDIAVcbZJJVBUGUAqowyEl58NoipDDCVsc1RocWog5jKwPWt5gJXfCmKwZa4wjWuJqrwB6XBlrnCda62SSr8M2RLXR3WuqrukFdKDLrcFeRwzBzSh83BlrzCNa/GzCHvzdiyV7juVSFJ55USgy19hWtfjbm8Gu/N2PJXuP7VmEus0We9wZbAwjWwpqrwSonBlsECVRmFJJ2vljGIqgxQlVFI0vmKGYOoygBVGYUknRdLDKIqA1RlFJJ0XiwxiKoMUJUxp6k475KJqgxQlSG6XKNvEFQZgCpDbDlsMoipDDCVUUTCV+obhFQGkMqYpMKLNQYhlQGkMiapLD4AkkIglTFJhX8ARFQGiMqYosI/ACIqA0RlTFFxflElojJAVMYUFf4BEFAZACpjgsriAyAJBE8Z01MWHwBbARASODnF+TWZcMoAThmTUxYfAIkgaMrQ9cjhIJgyAFPGxJTFB0ASCJYypqU4LYkfxFIGWMqYlsI/AEIpAyhlTErhHwCRlAGSMqak8A+AQMoASBkTUoJfigikDICUYSedIHGUAY4y7KQTJIwygFGGnXSCRFEGKMqYisJX9RlEUQYoyrCTTpAgygBEGX7SCRJDGWAow086QUIoAwhlTEIJinmDEMoAQhl+0gkSQRkgKMNPOkECKAMAZfhJJ0j8ZICfjOknQSepDeInA/xk+EknSPhkAJ+MEz4ZhE8G8Mnwk06Q6MkAPRmFIZ2vEDWIngzQkzH1hFerDaInA/RkTD3h1WqD6MkAPRlTT3i12SB6MkBPxtQTXi02iJ4M0JOx6Ql/NCN6MkBPRqxXfB4ETwbgySgM6bxYbBA9GaAnY+oJLxYbRE8G6MmYesKLxQbRkwF6Mqae8GKxQfRkgJ6MqSe8WGwQPRmgJ2PqyeIBm+jJAD0ZU094tdkgejJAT8bUk1RWwz6IngzQkzH1hK9MNYieDNCTMfWEV5sNoicD9GRMPcnFGs0kiaAnY+oJrzYbRE8G6MkoDBm8WGwQPRmgJ1IYMnixlxA9EdATuczlyPmazURPBPREikMGX5xKiJ8I+IkUhwxerCXETwT8RIpDBl+cSoifCPiJFIcMXqwlxE8E/ESKQwYv1hLiJwJ+IsUhgxdrCfETAT+R4pDBi7WE+ImAn0hxyODFWkL8RMBPZPoJL9YSAigCgCITUPj2HEIIRYBQpM3F8XkSCaEIEIpss1LoM4YQQhEgFJmzUnixlhBCESAU2aal0PEyIYQiQChSIjJ4tZcQQhEgFFku8yXETwT8RIpDBq8VE+InAn4ic5kvXismxE8E/ET6jCE/k4ifCPiJTD/htWJCAEUAUGTuAsIvjEIERUBQZAoKLzYTQigChCKTUPiVVQihCBCKlIgMXq0mhFAECEUmofBqNSGGImAo0k8uzUIMRcBQpExk8HI3IYgigChSJjJ4uZsQRBFAFCkTGZ0uTyQEUQQQReZOIZ2fTARRBBBF5m4hnZ9MBFEEEEW2HUP4yUQQRQBRZO4awqvNhCCKAKLI3DmEL1IlBFEEEEXm7iF8TREhiCKAKDJ3EOHVZkIQRQBRZO4iMmg1uxBEEUAUmTuJUNEVYiiCe4nMzUR4tZmw7URwP5EikcGrzYRtKYJ7ihSJDF5tJmxbEdxXpEhk8DVJhG0tcthbZG5fw5NMtxeBIMoMIk8y22IE9xiZq30ttmVh24zgPiOlIoNXmwnbagT3GikVGYvtWdh2I7jfiMwgLrZoIUkERxFd19gIcRQBRxGdtQ3yk7Sf1RMaIEEESJFykSHK7m+Iowg4iuhcA9Z+0vazqUIDJIcAKaJz3jIPMpEUAUkRnVsp8SATShGgFNGZQx5kQikClCJFI4PXegmxFAFLkbKRwWu9hGCKAKZI4cjgtV5CNEVAU6RwZPBiKyGaIqApUjoyeLGVEE4R4BSxWWWz2HOIJBE8RcpHBi+2EgIqAqAi5SNDqSkKARUBUJECksGLrYSIioCoSAnJUGpaQkhFgFTEfN2dEFIRIBWxOOlOCKkIkIoUkQy7/CT9Z4WnNUIqAqQiRSTDGvv/hFQESEW8nXRHxFQETEWKSIZ1+gZICoFUpIhk2KD/n4QQSEWKSAYvNBJiKgKmImUkg5f5CEEVAVSRMpLBF0QRgioCqCITVRaPe0RVBFRFSkkGrxMSwioCrCI+U8hPROIqAq4iMWPILwnEVQRcRYpJBt8QR4irCLiKFJMMXuYjxFUEXEViVh3ySwJxFQFXkWKSwct8hLiKgKtIMcngZT5CXEXAVaScZPA1UYTAigCsSDnJ4GUyQmBFAFaknGTwRT2EwIoArEg5yeCLegiBFQFYkTy5QSSuIuAqkjOIPMnEVQRcRYpJBi8zEOIqAq4ixSSDM70QVxFwFSkmGXwDHiGuIuAqUkwy+KIgQlxFwFUkZ/0rTzJxFQFXkWKSwZlViKsIuIoUkwzOrEJcRcBVZLoK35RHiKsIuIpOV+HMqsRVFFxFp6tE0s0GiasouIpOV+HKqcRVFFxFp6tw5VTiKgquotNVuHIqcRUFV9HpKlw5lbiKgqvodJWkizEocRUFV9HLuuJBCasosIpe1hUPSlRFQVX0sq54UIIqCqiiE1X4kh5KUEUBVXSiCl/SQwmqKKCKTlThyKoEVRRQRee2Kfw5QwmqKKCKTlThjwlKUEUBVbTNGPJzmaCKAqroRBXOvEpQRQFVtJhEOPMqcRUFV9FiEuHMq8RVFFxFi0mEM68SV1FwFS0mEc68SlxFwVW0mEQ48ypxFQVX0WIS4cyrxFUUXEWLSYQzrxJXUXAVLSYRzrxKXEXBVbSYRC5UNZS4ioKraDGJcOZV4ioKrqLFJMI3LVDiKgquotvclMX2vSSJ4CpaTCKceZW4ioKraDGJcOZV4ioKrqLFJMKVVomrKLiKFpMIR1YlrqLgKlpMIpxJlbiKgqtoMYlwJlXiKgquosUkwplUiasouIoWkwhnUiWuouAqWkwiXDmVuIqCq2gxiXCkVOIqCq6i5STCkVIJrCjAipaTCDdGJbCiACs6d2rnxqgEVhRgRedu7XxJDSWwogAruu3YzpNIYEUBVnTu2s6NUQmsKMCKzp3buTEqgRUFWNG5ezs3RiWwogArOndw58aoBFYUYEXnLu7cGJXAigKs6ISVxcMCgRXFzdznbu4cKZXt544buheUCF8SQ9me7ripe0mJDH6rzvZ1x43dS0qEI6Oyvd1xc/eSEuHIqGx/98MG75VEjoxK93iHJJaUCEdGZfu840bvuh7QVrbVO+71ricD2sq2e8f93qes8AFlZVu+g6yozSDyk5HIioKsaEGJcCZVIisKsqIFJcKZVImsKMiKFpQIZ1IlsqIgK1pQIpxJlciKgqxoQYnwRTmUyIqCrGhBifBFOZTIioKsaEmJ8EU5lNCKAq1oSYlw51RCKwq0okUlwp1Tia0o2IqWlQh3TiW4ooArWlYi3DmV4IoCrmhhiXDnVKIrCrqipSWidMaLEl5R4BUtLRGlM0aU8IoCr2hpiXDnVMIrCryipSXCnVMJryjwipaWDFrKpkRXFHRFC0vols9KbEXBVrSoRDizKrEVBVvRohJZDH8QW1GwFY0ZQ34iEFtRsBWNGUN+IhBbUbAVLSoRvqaFEltRsBUtKhG+poUSW1GwFS0qEb4mhBJbUbAVLSrhi0QroRUFWtGSEjF+IhFaUaAVLSkRDp1KaEWBVrSkRDh0KqEVBVrRohLh0KnEVhRsRbOd9EbEVhRsRYtKxJytc6TEVhRsRTdb4bfJxFYUbEVzBpGfS8RWFGxFU086VGIrCraiRSXCqVWJrSjYihaVCKdWJbaiYCtaVCKcWpXYioKtaFGJcGpVYisKtmKX9YrtRmjFgFaspEQ41RqhFQNasUtfn81GaMWAVuwyl55jQTYiKwayYgUlwq3YiKwYyIoVlAi3YiOyYiArVlAi3IqNyIqBrNhl5pDe4BmhFQNascvMIT0XjdiKga3YZeaQnkpGcMUAV6ysRPgGEEZwxQBXrKxEuPUawRUDXLGyEuHWawRXDHDFykqEW68RXDHAFSsrEW69RnDFAFdsLvrF12Q1gisGuGJlJcKx2AiuGOCKTVyJxTsgSQRcsYkrfE6uEVwxwBWbuMKx2AiuGOCKzUW/+JqqRnDFAFest/WaqkZwxQBXbOIKn5RrBFcMcMUmrnCuNoIrBrhiE1c4VxvBFQNcsYkrSe9PjOCKAa7YxBXO1UZwxQBXbOIK52ojuGKAKzZxhXOvEVwxwBXruZ7cbQRXDHDF5spffPEzI7higCs2cYWDsxFcMcAVm7jCwdkIrhjgipWV8NIPI7ZiYCs2bWXxLRJbMbAVm7bCvdmIrRjYik1b4d5sxFYMbMWKSpR7sxFbMbAVKyrRC+9PiK0Y2IpNW+H3+kZsxcBWbNrK4mwmtmJgK1ZUoly8jdiKga3Y3E6Fr9VtxFYMbMXmdip8R2YjtmJgK1ZUotzcjdiKga1YUYlyczdiKwa2YkUlys3diK0Y2IrJTCLvDoitGNiKyUwi7w6IrRjYihWVKJ9abcRWDGzFikr0QutPjNiKga1YUYlyczdiKwa2YkUl2vjZSGzFwFasqET5PhhGbMXAVqyoRLm5G7EVA1uxohLl5m7EVgxsxYpKlJu7EVsxsBUrK1Fu7kZwxQBXrKxEubkbwRUDXLGykuW3QJIIuGJlJcrR3giuGOCK2Uwiv7AQXDHAFSsrUY72RnDFAFesrEQ52hvBFQNcMZOTs5HgigGumOnJ2UhwxQBXrKxEedmAEVwxwBUzPzmdCa4Y4IqVlSivOzCCKwa4YmUl2oXeJhJcMcAVKytRXndgBFcMcMXmYmC0sNKIrRjYivkMIj+bia0Y2Ir5DCI/m4mtGNiKFZUor1swYisGtmJFJcrrFozYioGt2Jy6QrXYCK0Y0IpNWuG17kZsxcBWrLBEB91F1IiuGOiKFZYoL5wwoisGumJzPxW+XoYRXTHQFSssUV44YURXDHTFCkuUF04Y0RUDXbHCEuWzs43oioGuWGGJ8sIJI7pioCtWWKK8cMKIrhjoim26ws8lwisGvGKlJcoLJ4zwigGvWMwk8nOJ8IoBr1hpifKyAyO8YsArVlqivOzACK8Y8IplO3nkIrxiwCtWWqK8bsEIrxjwipWWKK9bMMIrBrxipSXK6xaM8IoBr1hpifK6BSO8YsArNpcEW4xGEl4x4BWbS4Lx6xLRFQNdsblJ/eKZj+iKga5YziDyk5HoioGu+NQVoUNATnjFgVd8blLP/wQnvOLAK36ZQaRnsxNeceAVv8wg0rPZia84+IoXlygv3XDiKw6+4sUlyks3nPiKg694cYnyKepOfMXBV7y4RPkUdSe+4uArXlyivHTDia84+IoXlygv3XDiKw6+4sUlymsnnPiKg694cYny/UCc+IqDr3hxifLaCSe+4uArXlyivHbCia84+IoXlyivnXDiKw6+4sUlymsnnPiKg694cYny2gknvuLgK15conw/DSe+4uArXlyivPbBia84+IoXlyivfXDiKw6+4sUlymsfnPiKg694cYnyOdpOfMXBV7y4RHnlgRNfcfAVLy5RXjjgxFccfMWLS5QXDjjxFQdf8eIS5YUDTnzFwVe8r59XnPCKA6/43FeF24QTXnHgFZ+b1Q86duCEVxx4xefGKkKfmJzwigOveGlJ41u7OOEVB17xubGKdHp1J7ziwCs+N1Zhm505wRUHXPG5WT3f7MyJrjjois/N6vlmZ050xUFXfG5WL3Q3DCe64qArXliivH7Fia446IpPXeH1J050xUFXfOoKL/9woisOuuInK4I5wRUHXPGyEuXlI05wxQFXfOIKLx9xgisOuOJlJcrLR5zgigOueFmJ8vIRJ7jigCs+cYWXjzjBFQdc8YkrvHzECa444IpPXOHlI05wxQFXfOIKLx9xgisOuOITV3j5iBNcccAVn7jCy0ec4IoDrvjEFV794QRXHHDFJ67wpQKc4IoDrvjEFV794QRXHHDFJ67w6g8nuOKAKz5xhddeOMEVB1zxiSu89sIJrjjgik9c4bUXTnDFAVf8ZOKKE1txsBWftsKXGnBiKw624tNWeO2GE1txsBWftsLXQ3diKw624tNWeO2GE1txsBWftsIrJ5zYioOt+LSVdFZY6cRWHGzFp63wwgUntuJgKz5thRcuOLEVB1vxohLjhQtObMXBVryoxPhEeSe24mArXlRivGzAia042IoXlRhHeye24mArXlRiHO2d2IqDrXhZiXG0d4IrDrjiZSXG0d4JrjjgipeVGEd7J7jigCteVmIc7Z3gigOueFmJ8YnyTnDFAVe8sMT4euhOdMVBV7ywxLjyOdEVB13xOXOFc7ETXXHQFS8ssUYXnnWiKw664oUlxtHeia446IoXlhhHeye64qArXlhiHO2d6IqDrnhhiXG0d6IrDrrihSXNOx0NJbrioCteWGIc7Z3oioOueMwk8igTXXHQFZ+71XO0d6IrDrrihSXG0d6JrjjoiheWGCdzJ7rioCteWGJcvJ3oioOueGGJ8Zn2TnTFQVe8sMS4eDvRFQdd8cIS42LtRFccdMULS4yLtRNdcdAVLywxLtZOdMVBV7ywxLhYO9EVB13x0hLjM+2d8IoDr3hpiXEwdsIrDrzipSXGvdcJrzjwSpSWGPfeILwSwCtRWmLce4PwSgCvRGkJ26EhiK0E2EoUlRjX4iC2EmArUVRiXIuD2EqArURRiXEtDmIrAbYSRSXGtTiIrQTYSlxmDGmOg9hKgK1EUYnxccAgthJgK1FUYlyLg9hKgK1EUYkJvTkIYisBthJFJcaxN4itBNhKFJUYx94gthJgK1FUYhx7g9hKgK1EUYlxKg1iKwG2EnNhMPrUGoRWAmglSkroWGoQWAmAlSgnWYylBoGVAFiJcpLFWGoQWAmAlWgzhvxUJLASACvRZwz5qUhgJQBWos8Y8lORwEoArEQ5iXHqDQIrAbAS5SR8ib4grhLgKlFMYkrv84O4SoCrRDGJcSoO4ioBrhLlJMapOAisBMBK9PUqiUFcJcBVopjElJYTBnGVAFeJYhJTulVKEFcJcJWYrsLv0oO4SoCrRDHJ6lskrhLgKjFmDnlnRGQlQFaioMQ4dgeRlQBZiTGDyM9FIisBshJjBpGfi0RWAmQlCkqMY3cQWQmQlSgoMY7dQWQlQFaioMQ4dgeRlQBZiZIS49gdhFYCaCVKSoxjdxBaCaCVKCkxjt1BaCWAVqKkxDh2B6GVAFqJkhLj2B2EVgJoJUpKjGN3EFoJoJUoKTGO3UFoJYBWoqTEOHYHoZUAWomSEuPYHYRWAmglSkqMK2MQWgmglSgpMa6MQWglgFaipMS4MgahlQBaiZIS40oYhFYCaCW0n9ykEloJoJUoKTHOjEFoJYBWoqTEODMGoZUAWomSEuPMGIRWAmgldCaRR5nQSgCtRFGJcWYMYisBthJFJcaZMYitBNhKFJUYZ8YgthJgK1FUYpwZg9hKgK1EUYlxZgxiKwG2EkUlxpkxiK0E2EoUlRhnxiC2EmArUVRinBmD2EqArURRiXFmDGIrAbYS01Y4MwaxlQBbiWkrnBmD2EqArcS0Fc6MQWwlwFZi2gpnwiC2EmArMW2FM2EQWwmwlZi2wpkwiK0E2EpMW+FMGMRWAmwlpq1wJgxiKwG2EtNW+ATrILYSYCsxbYUzYRBbCbCVmLaSSZ8XiK0E2EoUlfiFTjwJYisBthJFJc6ZMIitBNhKFJU4Z8IgthJgK1FU4pwJg9hKgK1EUYlzJgxiKwG2EkUlzpkwiK0E2EoUlThnwiC2EmArUVTinAmD2EqArURRiV/X0yYDIMRWAmwlikqcM2EQWwmwlSgqcc6EQWwlwFaiqMT5etpBbCXAVqKoxPl62kFsJcBWoqjEORMGsZUAW4miEudMGMRWAmwlikqcM2EQWwmwlSgqcc6EQWwlwFaiqMQ5EwaxlQBbiaISb8E/RJJEsJUoKvFGa1OD2EqArURRiXPlC2IrAbYSRSXOlS+IrQTYShSVOFe+ILYSYCtZVNKisWGgJLaSYCs5p65E5w0ck5hgK1la4twZk/BKAq9kaYlzZ0zCKwm8kqUlzp0xCa8k8EqWljh3xiS8ksArWVri3BmT8EoCr+RlJpHeHyThlQReyctMIu2Vk/BKAq9kaYlzZ0zCKwm8kqUlzp0xCa8k8EqWljh3xiS8ksArWVri3BmT8EoCr2RpiXNnTMIrCbySpSXOpTAJryTwShaXOJfCJL6S4CtZYOJcCpMIS4KwZIGJcylMIiwJwpIFJs6lMImwJAhLFpg4n1eaRFgShCULTJxLYRJhSRCWLDBxPi00ibAkCEsWmDiXwiTCkiAsWWLiXAqTEEsCsWSJiXMpTEIsCcSSJSbOpTAJsSQQS5aYOIeyJMSSQCxZZOIcypIYS4KxZJGJcyhLYiwJxpJFJs6hLImxJBhLjrOrMzGWBGPJcXZ1JsaSYCxZZOJ8VmYSY0kwliwycU5tSYwlwViyyMQ5tSUxlgRjySIT57MykxhLgrFkkYnzWZlJjCXBWLLIxDlUJTGWBGPJIhPnUJXEWBKMJcdMIj8XiLEkGEsWmTiHqiTGkmAsWWTiHKqSGEuCsWSRiXOoSmIsCcaSRSbOoSqJsSQYSxaZOIeqJMaSYCxZZOIcqpIYS4KxZJGJc6hKYiwJxpJFJoudc5MYS4KxZJGJG10cPomxJBhLFpm40bUCkxhLgrFkkYkbnZKYxFgSjCV1JpE+9iUxlgRjySITd1qKlMRYEowl5/QVvohLEmNJMJYsMnGndJ7EWBKMJaexsCX6kwhLgrBkgUnSIpgkwJIALFle4k6VKgmwJABLlpe40+WkkwBLArBkeYk7XXEyCbAkAEuWl7jTOZFJgCUBWLK8xJ2fSQRYEoAlbcaQn0kEWBKAJctL3PmZRIAlAVjSZgz5mUSAJQFYsrxksZZQEmBJAJYsL3EudUmAJQFYsrzEudQlAZYEYMnyEudSlwRYEoAly0s86FhgEmBJAJYsL3EudUmAJQFYsrzEudQlAZYEYMnyEg8eZQIsCcCS5SWrz4AASwKwZHkJX0Mmia8k+EoWlzinwiS+kuAr6TOI/AaL+EqCr+Scu8ILupL4SoKv5PQVbo1JfCXBV3L6CrfGJL6S4Cs5fYVbYxJfSfCVnL7CrTGJryT4Sk5f4daYxFcSfCWnr3BrTOIrCb6S01e4NSbxlQRfyekr3BqT+EqCr+T0FW6NSXwlwVdy+gq3xiS+kuArOX2FT0lM4isJvpLFJcGnJCbxlQRfyeKS4NaYxFcSfCWLS4JbYxJfSfCVLC4Jbo1JfCXBV7K4JC78BoX4SoKvZHFJXPgNCvGVBF/J4pK48F6d+EqCr2RxSXBrTOIrCb6SxSXLz4AkEXwli0uCz2lM4isJvpI5k8ijTHwlwVfapbwkuFZuR/dN3P7yrY1KIwfL7eihjYZt9HUctqOHNjq2UZnk7rkdPbQxsA1ZX+q3o4c2BNuoZPKlkbejhzYU26hwckHdjh7aMGzjZBuM7eihDcc2Ynnnsh08NBHYRIWUW+529NAGxrRd1if7dhTbaBjTNmNKL13b0UMbGNM5xYXfBm1HD21gTNuMKe13tqOHNjCmBSvBp5BuRw9tYEzbjCntPLajhzYwpsUrwYl5O3poA2NawhJcmbejhzYwpoUswaF5O3poA3NazhJcerejhzYwp0UtwbF3O4ptdMxpaUtw792OHtrAnBa4BCff7eihDcxpmUtw9d2OHtrAnBa7BIff7eihDcxpyUtw+92OHtrAnBa+BOff7eihDcxp+UtwAd6OHtrAnBbBBEfg7eihDcxpKUxwB96OHtrAnBbEBKfg7Si2MTCnZTHBNXg7emgDc1ocExyEt6OHNjCnc3cXbsLb0UMbmNNCmeAsvB09tIE5LZcJLsPb0UMbmNOimeA4vB09tIE5LZ0J7sPb0UMbmNMCmuBEvB09tIE5LaMJrsTb0UMbmNNimuBQvB3FNgRzWlIT3Iq3o4c2MKeFNcG5eDt6aANzWl4TXIy3o4c2MKdFNsHReDt6aANzWmoT3I23o4c2MKcFN8HpeDt6aANzWnYT3G63o4c2MKfFN8H5djt6aANzWoITXHC3o4c2MKeFOMERdzuKbSjmtBwnuONuRw9tYE6LcoJT7nb00AbmtDQnuOZuRw9tYE4LdIKD7nb00AbmtFQnuOluRw9tYE5LdoKz7nb00AbmtHAnuOxuRw9tYE7Ld4Lj7nb00AbmtIgnuO9uRw9tYE5LeYIT73YU2zDMaUFPcOXdjh7awJyW9QSfkbgdPbSBOS3uCT4pcTt6aANzWuITfF7idvTQBua00Cf41MTt6KENzGm5T/DZidvRQxuY06Kf4BMUt6OHNjCnpT/hdDHZ7eihDcxpARDfpm07eGgCY1oEFHym43YU23CM6ZyXwwx5O3ZoAUNaDMQZeTt4aAIzWhCUi1EtIke3v3xr4pq3XIx8EDy6/eVbE5VQPu9zO3poAxPqM6GLs54Q0u0v39qYCV2c9USRbn/51sZMKGXl7eihDUxoyVDwKZzb0UMbGNG4rDdM2o5iG4ERLR9aDtARUbr95VsbvVYsUbLkyHbw0ASGtJAonE6+2o4e2sCUlhMFl+7t6KENjGlRUXDs3o4e2sCYlhYF9+7t6KENjGmBUfDJqdvRQxsY0zKj4Oq9HT20gTGdzsThezt6aANjOqmJz1LdjmIbiTGd2sT1eTt6aANjOsGJA/R29NAG5nSaEyfk7eihDczpZCeuyNvRQxuY0ylPHJK3o4c2MKcTn7glb0cPbWBOpz9xTt6OHtrAnE6C4qK8HT20gTmdCsVReTt6aANy2qZDcVfejkIbDR2qTYfitLwdPbTRsI3KKdfl7eihjY5tVE45MG9HD20MbKOu+tyYt6OHNgTb0GqD57Qxh2roUK1QKbk0b0cPbRi24dUGz2ljDtXQoVqpUvK5rdvRQxuBbdSNKZ/euh09tIE5LVVKPsN1O4ptIES1UqXk8LwdPbSBOS1VSk7H29FDG5jTUqXkerwdPbSBOS1VyoUfNwZRDSGqlSrlwo8bg6iGENVKlXJhv41BVEOIaqVKuXDbxiCqIUS1UqVcuG1jENUQolqpUi7AtDGIaghRrVQpF9jZGEQ1hKhWqpQLqGwMohpCVCtVygVUNgZRDSGqlSrlAiobg6iGENVKlXIBlY1BVEOIaqVKuYDKxiCqIUS1UqVcQGVjENUQolqpUi6gsjGIaghRrVQpF1DZGEQ1hKjW54P+IqcMohpCVCtVygVUNgZRDSGqlSrlAiobg6iGENVKlXIBlY1BVEOIaqVKuYDKxiCqIUS1UqVcQGVjENUQolqpUi6gsjGIaghRrVQpF1DZGEQ1hKhWqpQLqGwMohpCVCtVygVUNgZRDSGqlSrlAiobg6iGENVKlXIBlY1BVEOIaqVKuYDKxiCqIUS1UqVcQGVjENUQolqpUi6gsjGIaghRrVQpF1DZGEQ1hKgm68VWt4OHJjCmMjcQk5+k/aye2AaLKTpUK1QadvlJ+s8a2ARLKTJUK1Ma1ngTLKSoUK1IKaX9pJefozdsg4UUFaoVKQ3r9G0whGqIUK1EadjgTbCIokE1ncOmi66DGVRDg2oFSqtoMIJqSFCtPGkZDUZQDQmqlSetosEEqqFAteKkVTQYQDUEqFaatIwGA6iGANVKk1LojKTt6KENjKjOPcbsJ20/myq2wSKKANXsLKLMnxr6U7OziDJ+ashPzWZEF1cVxk8N+anZOMsX46eG/NTKklb5YvrUUJ+a6Um+GD41xKdmdvadsIiiPTXzs++EJRTpqdlM6OIqzeipIT01y5Nug9FTQ3pq5UjLr5XRU0N6at5OvlZmTw3tqZUkrb5WZk8N7alNe1p1GwyfGuJTczmJBsOnhvjUXE+iweypoT01n/M5FzdfzJ4a2lPz9X5k28FDE5jQcqR1NFhCkZ5aOdIyGiyhKE8tLifRYPDUEJ5aKdIyGgyeGsJT2+BpcTVg8tRQnlox0ipeDJ4awlMLOYkXc6eG7tQKkXJRmNWYOzV0pxanN6LMnRq6U4uzG1HGTg3ZqcXZjShTp4bq1CLPvhOWUESnlpeT74SZU0NzajkTunjOYebU0Jxa9pNTnpFTQ3JqeXqRZ+TUkJxanl3kmTg1FKeWZxd5Bk4NwamlnZ3yDJwaglPLeSNKJ1RvRw9tYEIzTuLFvKmhN7XMs3ixhCI39bKjXNQvdsZNHbmplx0t4tWZNnXUpn7pJ/HqTJs6alO/zBITPtrTmTZ11KZ+OYloZ9jUEZv65SSinVlTR2vql7OIdmZNHa2pX/zkqtSZNXW0pn45iWhn1NSRmvrlJKKdSVNHaepTmhalrZ1JU0dp6u0sogyaOkJTb6cRZdDUEZp6GyfxYs7U0Zl6k5N4MWbqyEx929uHVsp0pkwdlam3kyelzpCpIzL1dvKk1JkxdTSmPo1pUbDcmTF1NKbeTp6UOiOmjsTU+9mTUmfE1JGYej95UupMmDoKU+8nT0qdAVNHYOr97EmpM2DqCEy9y1nHw4CpIzD1rifxYr7U0Zd6t5N4MV7qyEt98tKilr0zXurIS72fPSp1xksdean3k0elznSpoy71cfKo1BkudcSlPtrJd8JsqaMt9dFPvhNGSx1pqU9aWswN6IyWOtJSH3JyyjNZ6ihLfejZ18pkqaMs9WEnXyuDpY6w1Ieffa0soOhKfbrS6pRnrtTRlfo4Gw/tzJU6ulKXk/HQzlipIyt1ORkP7UyVOqpSn6q0mDbSmSp1VKUuZ49KnalSR1XqcnYfylCpIyp1ObsPZajUEZW6nF3lmSl1NKUuZ1d5ZkodTanLvMrzUYnOUKkjKnU5u8ozU+poSl1Pr/IMlTqiUtezqzxDpY6o1PXsKs9MqaMp9bmsHZ+X0JkpdTSlXkCUi2lNnZlSR1PqenaRZ6bU0ZS6nl3kmSl1NKU+TWkxuaozU+poSl3jJF2MlDqSUt9IaZUullAkpb6REk8XI6WOpNQ3UuLpYqTUkZS69ZOvlYlSR1HqU5QWXysDpY6g1G1OFlmMazBR6ihK3U4v8oyUOpJSt7OLPCOljqTU7ewiz0ipIyl1O3uQZ6LUUZS6nT3IM1HqKEq9eCgX8wc7E6WOotT97EGeiVJHUep++iDPSKkjKXU/e5BnotRRlLqfPcgzUeooSr18KBeTKTsjpY6k1CcpLSZTdkZKHUmpT1JaxIuRUkdS6pOUFvFiotRRlHr5UC6mdHZGSh1JqcfpRZ6ZUkdT6nF2kWek1JGUepxd5JkodRSlfiZKnYlSR1HqZ6LUmSh1FKU+RWkxRbYzUeooSn0TJX7KM1DqCEp9gtLya2UJRVHqmygtvlaWUBSlvonS4mtlAUVR6uVDcl2WmczF7IyUOpJSn6S0mHPcGSl1JKVeQJSLOcedmVJHU+p5FlFGSh1JqedZRBkpdSSlnjOii1tZZkodTannWUQZKXUkpZ6nEWWk1JGUep5FlJFSR1LqeRZRRkodSWlcTp7kBxOlgaI0LidP8oOJ0kBRGpcZUH5fP5goDRSlcTkpvhsMlAaC0ricFd8NJkoDRWlcTorvBhOlgaI0LifFd4OB0kBQGpcz8xwMlAaC0jgDpcFAaSAojTNQGgyUBoLSmKC0WGNgMFAaCErjDJQGA6WBoDROQWkwUBoISuMMlAYDpYGgNM5AaTBQGghKY85bWowhDiZKA0VpTFFajCEORkoDSWm0k/vQwUhpICmNdnIfOpgoDRSlMWctLZafGIyUBpLS2EiJx4uJ0kBRGlOUVvFipDSQlMZGSjxejJQGktLo4yReTJQGitLoJ7V3g4HSQFAa/aT2bjBQGghKY05Y4ruWb0cPbWBA+0nt3WCgNBCUxikoDQZKA0FpzPlKi1VFBhOlgaI0xslg02CiNFCUxjgZbBpMlAaK0pizlRYLegxGSgNJaUxS4jtEbEcPbWBE52ylxYIeg5nSQFMac7YS35B9O3poA0M6TkbsBzOlgaY0xsmI/WCmNNCUxjSlxbIig5nSQFMa42TEfjBSGkhKQ84e5gczpYGmNOTkYX4wUxpoSkNOHuYHI6WBpDTkzOUHI6WBpDS2iUp84sNgpjTQlIacDNkPZkoDTWnIyZD9YKY00JRGCVH64taeodJAVBpyMmQ/mCkNNKUhZ0P2g6HSQFQaetaLMlMaaEpDz3pRZkoDTWlsE5UW8WKoNBCVhp48zA+GSgNRaejJw/xgpjTQlEYJUS5W3xkMlQai0tCTh/nBUGkgKg09e5gfDJUGotLQk4f5wVBpICoNPXmYH8yUBprSmKa0ui1nqDQQlYadVI4MhkoDUWnYSeXIYKg0EJVGEVEuFlUaTJUGqtKY05SCr7k1mCoNVKVRRLQawRtMlQaq0igjysXiToOx0kBWGpOVItmWk9vRQxuY0VKiZnxluMFgaSAsjblK3mKRqcFkaaAsjSlLi0WmBpOlgbI0yolyscjUYLQ0kJbGXChvscjUYLQ0kJbGnK20WGRqMFsaaEtjLpUXdMew7eihDczpxKVYjPcwXBqIS2Pi0mKRqcFwaSAujaKiXCwyNZguDdSlUVakPOkMlwbi0pi4tFimajBcGohLo6QoF8tUDYZLA3FpzJXyGt3TcDt6aANTWlaUi6WuBuOlgbw0Cov4opKD6dJAXRpzB6bF38ESirg04nTYieHSQFwaMRO6OOuZLg3UpREzoYuznunSQF0aZUWLc43h0kBcGkVFje5VuR08NIEBzRnQRdfDcGkgLo2Soq4/Sf48hmMTLJ9oS6OgaLHVymC0NJCWRkFR98W7YPlEWhoFRblYAG0wWxpoS2MukLdYo3MwWxpoS6OkaLW+5mC4NBCXxoZLtOJ/MFsaaEtjro+3WBtzMFwaiEujqKhf+J5Cg+nSQF2SOWFpsaacMF4S5CUpLLru37RohKRUEJiktOi6gdOiEZJTQWGS8qLrDk6LRkhSBY1JCoyuWzgtGiFRFUQmKTK67uG0aIRkVZCZpNDouonTohESVkFoklKj6y5Oi0ZIXAWlScqNrts4LRoheRW0Jik58kvQ21th2CSITVJy1I0vbSsMmwSxSdqW11g0wvKK3CRtyyu/yAjzJkFvkjbzurj/ECZOguIkbea1Nba79Xb40Ajmtc28Lha6E4ZOgugkbeZ1sdKdMHUSVCdpM6+Lpe6EuZOgO0mbeV2sdSdMngTlSdq8BVgsdieMngTpSQqSrjtL8UYYPgnik/SZ2MVyd8L0SVCfpM/ELta7E+ZPgv4kfSa2LxLLBEpQoKTPxHa6kfd2+NAIJrbPxC6WvBOmUIIKJX0mdrHmnTCGEmQo6TOxi0XvhEGUIERJn4ldrHonTKIEJUr6TOxi2TthFCVIUTJmYhfr3gnDKEGMkjETu1j4ThhHCXKUjJnYxcp3wjxK0KNkzMQulr4TBlKCICVjJnax9p0wkRIUKRkzsYvF74SRlCBJyZiJXax+JwylBFFKxkzsYvk7YSwlyFIyZmIX698JcylBl5JSphaNDiYIgylBmBKZgV0soidMpgRlSmS9rYMwmBKEKZGZ1sU6fMJoSpCmRLa0Ls4bZlOCNiUFTS06/1CZTQnalMgW1sW5x3RKUKekrKl143cmjKcEeUpkZnWxJKAwnxL0KZGZ1cXmZcKESlCoRGbvuliBThhRCRKV6AzrYvsyYUgliFSis3ddLDQmjKkEmUp05nWxMpYwpxJ0KtGZ18UaSsKkSlCqRGfvulgpR5hVCVqV6AzsYmkXYVgliFWis3ddbGImjKsEuUrUT++RmFcJepVonN4jMbESFCvRmdjFeiTCzErQrMRmYhcrgQhDK0G0krm502IDIGFqJahWUgal4os2WF6RraQMSgbdW3s7emgD41oG1bz9pPKzOT7HMrYSZCuxmdbFMhzC3ErQrcRmWhcrNgiDK0G4klKo1SiSMLgShCuZcHVZzO0XJleCciXFUIsrMHMrQbcS35K66NEYXAnClZRCLYYGGFsJspX47FgX056FuZWgW0khVFuc/YytBNlKfHari6m+wtxK0K3Et6AuulUGV4JwJROuFvglDK4E4UomXC0QThhcCcKV+JbTRffO7ErQrsRnp7qYDCkMrwTxSmJGdTF7T5heCeqVFEUtRvaF4ZUgXknMrC4mvQnTK0G9kpg3AYtZb8IASxCwpDxq2bszwhIkLIkZ1sWkNWGGJWhYErNXXcyyEoZYgoglMe8BFrOChCmWoGJJoZTp4hNhYUXGkkKpZURYVJGxJLeoLroR5liCjiU571htcfoyyRKULMktrIvTl1mWoGVJzrAu5isI0yxBzZKcXeuiKl0YZwlyluRM66IGWphnCXqW5EzrovpYGGgJgpbkTOui8FcYaQmSluTsXBdb+QkzLUHTkpyd66L0VxhqCaKWXmZiF7W/ylRLUbV0U61F2a0y1VJULd1Ua1FcqUy1FFVLN9ValOEpUy1F1dJNtRYFW8pUS1G1dFOtRaWUMtVSVC3dVGtRoqRMtRRVSzfVWtQoKVMtRdXSTbUWRUrKVEtRtbSIqjUuUspUS1G1tM3ALiqdlLGWImvpxlqLUidlrKXIWrqx1mJDPWWspchaurHWYkc9ZaylyFq6sdai2kkZaymylm6stSh3UsZaiqylG2stqpWUsZYia+nGWotyJWWspchaurHWotZIGWspspZurLUo0lHGWoqspRtrLap0lLGWImvpxlqLChllrKXIWrqx1kJzlbGWImvpxloLzVXGWoqspRtrLTRXGWspspZurLUolFHGWoqspRtrLco6lLGWImvpZK22KOtQxlqKrKWTtdqirEMZaymylk7WaouyDmWspchaOlmrLco6lLGWImvpZK22KOtQxlqKrKWTtdqirEMZaymylk7WaouyDmWspchaOlmrLco6lLGWImvpZK222DNQGWspspZO1mqLTQOVsZYia+lkrbbYNVAZa9388q2RmdjFtoHKWEuRtXSyVluUUyhzLUXX0ulabVFOocy1FF1LZSZ2UU6hjLYUaUsnbbVFOYUy2lKkLZ201RblFMpoS5G2dNJWW5RTKLMtRdvSaVttUU6hzLYUbUunbbVFOYUy3FLELZ241Rb7ByrDLUXc0rPJV8poS5G29HTylTLZUpQt1cvJxE9lsKUIWzpnXy3mxyhzLUXX0ulabbGfojLXUnQtna7VeqfFaspcS9G1dLpW62PRCAsrupbOdf06L7dXxlqKrKVFVJq+aINFFVVLdYsqn52iTLUUVUs31VrUqilTLUXV0qlabVEqo0y1FFVLp2pdbZreNjLVUlQttXaaEsZaiqyl1k9TwlxL0bXUtrwu+kUGW4qwpbblddEvMtlSlC2dstUWRTvKZEtRtnSu87cKPYMtRdjSUqpl6BlsKcKWTthqY3FLz2BLEbbU8vTMYbalaFu62dbqzGG2pWhb6jOvizImZbylyFs6eastypiU8ZYib+nGW4syJmXApQhcOoGrLcqYlAGXInDpBK62KGNSBlyKwKU+bwYWJUjKhEtRuNT9tEtixKVIXDqJa9klMeJSJC71PO2SGHEpEpfOxf9W5zATLkXh0vKq5TnMiEuRuDT66TnMiEuRuDTG6TnMiEuRuDROK7WVGZeicWlseV309My4FI1Lp3Eto8aMS9G4NPw0asy4FI1LI06jxpRLUbl0rgS4jBqLKzKXFlkto8aUS1G5NNtpSphyKSqXbsq1SglTLkXl0tz618WlnCmXonJpbv3r4lLOlEtRuXQqV1vU7ylTLkXl0qlcbVG/p0y5FJVLp3K1Rf2eMuVSVC6dytUW9XvKlEtRuXQqV1vU7ylTLkXlsqlcbVG/Z0y5DJXLpnK1Rf2eMeUyVC6bytUW9XvGlMtQuWwqV1vU7xlTLkPlsqlcbVG/Z0y5DJXLpnK1RdWcMeUyVC6bm07xa44x4zI0LrucTDM0JlyGwmWXs2mGxoDLELhsA65F/Z8x4TIULpvC1Rb1bsaEy1C4rLTKlHfzxoDLELhsAldb1MwZAy5D4LIJXE2FdtHGgMsQuGwCV1tUqxkDLkPgssKq7oucMd8y9C0rq1rUiBjTLUPdsqlbi5JIY7hliFs2castyuaM4ZYhblnbwsrLiIzhliFuWd/CuuiKGG4Z4pZN3Gq6OPcYbhnilk3caotaM2O4ZYhbNnGrGZ9kYQy3DHHLCqqW5x6zLUPbsmlbbVFsZsy2DG3Lyql6Kj/1GG0Z0pYVU/l1Fik7a5hsGcqWlVK58cnoxmDLELaskMoXRVHGXMvQtayMyo3LpTHWMmQtK6LyVS/CVMtQtayESgdfMcEYahmilhVQufOqV2OmZWhaVj7Fy4iNgZYhaNlcOZDfwxvjLEPOsqIpd74pjDHNMtQsK5ly5yvMGcMsQ8yygil3Xu5uzLIMLcvKpXwxrm+Msgwpy4ql3BcnHJMsQ8kymSFdnHAMsgwhywql3BcnHHMsQ8cymSFdnHCMsQwZy+RsCoExxTJULNsUa1F1a0yxDBXLNsVa3ckwxTJULJuKZXxyhzHEMkQsmzO02qJ01xhjGTKWyVaLtbilYo5l6Fg2Z2i1RemuMcgyhCybM7TaomjWmGQZSpZtkrVYTN+YZBlKlun5vSqTLEPJsk2yVrdVTLIMJct0C+zi4YxRliFlWbmUyeJSxSjLkLJso6zVrRmjLEPKsm2XKv50xiDLELJsg6xFKbIxyDKELNsga3V3xyDLELJsg6xFPbMxyDKELNsga1HPbAyyDCHL7DyuDLIMIcs2yFoURRuDLEPIsg2yFkXRxiDLELJsTtFqi6JoY5JlKFlmM6+LomhjlGVIWbZR1qIo2hhlGVKWbZS1DBtLLFKWTcpqi8pqY5RlSFm2UdaistoYZRlSlhVLeSxuS5hkGUqW+XlgmWQZSpZNyVpdQRlkGUKWbZC16tUYZBlClm2Qtag1NwZZhpBlG2StUsIgyxCybIOsRcG6McgyhCzbIGtRsG4Msgwhy+Jy+g0zyTKULIt2egVllGVIWbZR1uqDZZRlSFm2Udai/t4YZRlSlk3Kaov6e2OUZUhZtlFWLB4tGGUZUpZtlLU6iRllGVKWbZS1WIrWGGUZUpZtlLWYomiMsgwpy2JL7OLxglmWoWXZnLLVVsPPDLMMMcs2zMrF0zjDLEPMsolZLRdPwgyzDDHLNszKxaMwwyxDzLINs3LxLMwwyxCzbMOsXCSWYZYhZlnBlDdesG7MsgwtyzbLykXqmWUZWpZtlpWL1DPLMrQs2ywrF6lnlmVoWb5ZVvLUO7MsR8vyaVn9wlPvzLIcLcunZfVFwbozy3K0LJ+W1RcF684sy9GyfO51tVhR2hllOVKWz72u+EOKM8hyhCyf07XWnyqJqyNl+Zyu1RfF984wyxGz/BJnnbQzzXLULN80a9GXONMsR83yTbMWfYkzzXLULJ/ztVYXLmec5chZvnHW4prjjLMcOcvbFld+MXfGWY6c5UVTq17NmWY5apbP6Vp9MTPCGWc5cpa3LbD8ackZaDmClpdOLT9VFlf0LJ+e1ReTK5x5lqNn+fSsvphc4cyzHD3LN89aXCyceZajZ/nmWYuLhTPPcvQs3zxrcWPizLMcPcs3z1rcmDjzLEfP8i6nVxwGWo6g5f30BtYZaDmClnc7u+NzJlqOouXbZK3FfZYz0nIkLd8may3ubpyZlqNpeT+9H3CGWo6o5XOyVl9MB3KmWo6q5XOyVl9MB3LGWo6s5XOyVl9MB3LmWo6u5XOyVl9MB3IGW46w5XOyVl9MB3JmW4625XOyVl9MB3KmW4665XOyVm+LnDDecuQtn5O1elt0Ssy3HH3L52St3hadEgMuR+DyOVmrL6YDORMuR+HyOVmrL6YDOSMuR+LyOVmrL6YDOTMuR+PyOVmrL+a/OEMuR+RyGaffDlMuR+XyqVx9sUSrM+ZyZC6fzNUXS7Q6Yy5H5nI5TyxjLkfmcvHTsDHncnQun87VF4vFOnMuR+fy6Vx9MQPGmXM5OpdP5+qLxWKdOZejc7luiV3c5DDncnQu1y2xixOQOZejc/l0rr6Yd+LMuRydy6dz9cVisc6cy9G5fDpXX8yycOZcjs7lcyXCvphl4Qy6HKHLJ3T1xSwLZ9DlCF0+52z1xSwLZ9TlSF0+qasvZlk4oy5H6vJJXX0xy8IZdTlSl0/q6ov6eWfU5UhdPqmrL8qrnVGXI3X5pK6+KK92Rl2O1OWTuvqivNoZdTlSl0/q6ovyamfU5UhdPqmrL8qrnVGXI3V5sZXoootl0uUoXT6lqy9KtJ1Jl6N0+ZSuvijRdiZdjtLlpVbeFnf2DLococu9nex44My5HJ3L/XSNDGfQ5QhdPqGrL+rNnUGXI3S5b3FdnMJMuhyly7c1CRczJJxJl6N0uW9xXfQDTLocpcundPVF0boz6XKULvctr4t+gEmXo3T5lK6+KFp3Jl2O0uVTuvqi1NuZdDlKl0/p6otSb2fS5ShdPqWrL8q0nUmXo3T5lK6+WJbUmXQ5SpdP6eqLMm1n0uUoXT6lqy9qm51Jl6N0+ZSuvljP05l0OUqXT+nqi9pmZ9LlKF0+pYuXejpzLkfn8tjyugg9cy5H5/Iyq+vNJ30jjLkcmcsnc/VFibUz5nJkLp/M1RfLeTpjLkfm8slcfVEe7Yy5HJnLJ3P1RVWgM+ZyZC6fzNUXxXjOmMuRuTy3xd8XJw5zLkfn8ulcfVGM58y5HJ3Lp3P1RTGeM+dydC6fztUXxXjOnMvRuWI6V1+UwAVzrkDnis25FmVjwZwr0Llic65FxVcw5wp0rtica1HxFcy5Ap0r5pytvijWCgZdgdAVc85WXxRrBaOuQOqKjboWxVrBqCuQumKjrkWxVjDqCqSumNTVF8VawagrkLpiUldf1FkFo65A6opJXX1RZxWMugKpKyZ19UVVUTDqCqSumNTVFwVBwagrkLpio65FQVAw6gqkrpgzt/qigiaYdQVaV2zWtaigCWZdgdYVm3UtVrAMZl2B1hVz8lZfrD4ZTLsCtSs27VqsPhlMuwK1KzbtWqw+GUy7ArUrpnb1xeqTwbQrULtialdfrD4ZTLsCtSumdvUFVAXTrkDtiqldfSE7wbQrULtizt5qfJH/YNgViF0xsasvVrAMhl2B2BUFV6tpZMGsK9C6YlqXd/r0F4y6AqkrJnX1xUqawagrkLpiUtf6+2VxReqKjbpW3y+jrkDqimKr5ffLpCtQuqLUavnVMOgKhK6Y0LX6aphzBTpXbM61WJ80mHMFOldszrVYnzSYcwU6V2zOtVifNJhzBTpXlFnZYieHYMwVyFxRZGVtFREWVlSu2JRrsbBoMOUKVK6YyrX6fhlyBSJXbMi1WJw0GHIFIldM5BqLxUmDIVcgcsVErrGo9QqGXIHIFRO5xqLWKxhyBSJXTOQai/qoYMgViFwxkWssyniCIVcgcsVErrEowQmGXIHIFRO5xqIEJxhyBSJXTOQai/qZYMgViFwxkWss6meCIVcgcsVErrGoRgiGXIHIFRO5xqIaIRhyBSJXTOQai2qEYMgViFwxkWssqhGCIVcgcsVErrGoRgiGXIHIFRO5xqIaIRhyBSJXTOQai8VJgyFXIHLFRK6xWJw0GHIFIldM5BqLxUmDIVcgcsVErrGoRgiGXIHIFRO5xqIaIRhyBSJXTOQai2qEYMgViFwxkWssqhGCIVcgcsVErrEoJAiGXIHIFabrZVKDEVcgccUkrrGoRQhGXIHEFXM21+i8eDSYcQUaV0zjGosKgGDGFWhcUV61WkohGHEFElfMyVxjUUUQzLgCjSvmZK6xqCIIhlyByBW+xXVx4jDkCkSu8C2uixOHIVcgcoXL6TfMkCsQuWIi11iUIgRDrkDkiolcY1GKEAy5ApErCqzkwgv6ghlXoHHFNK6xKGcIZlyBxhXTuMainCGYcQUaV0zjGotyhmDGFWhcMY1rLMoZghlXoHHFNK6xKGcIZlyBxhXTuMainCGYcQUaV0zjGotyhmDGFWhcEVtgF6cOM65A44ppXGNRzhDMuAKNK8JPenomXIHCFVO4xqIiIphxBRpXzM232NyLYL4V6FvxtvXW4tRjwBUIXDGBayzqMoIBVyBwxQSusaipCAZcgcAVE7iuy4yzpVWCAVcgcMUErrEoQwgGXIHAFRO4xqIMIRhwBQJX5JbVxanHgCsQuGIC11hUEAQDrkDgisKqxQpewXgrkLeiqKr7T5I/j+HYBEsr4lZO3BqLOoZkuJWIWzlxayzqGJLhViJuZUHVogNIRluJtJWTtrgsJ4OtRNjKCVu85iYZayWyVk7WStaFJDOtRNPK8qnOqT6ZaCWKVk7RGouqkGSilShaOUVrLKpCkolWomjlFK2xqApJJlqJopVTtMaiKiSZaCWKVrYtprwXSiZaiaKVU7TGoiokmWglilZO0RqLqpBkopUoWlk61RcDjMlAKxG0coLWWFSWJAOtRNDKCVpjURaSDLQSQSsnaI1FSUcy0EoErSycsuSrKSTzrETPyrIpvyzOPsZZiZyVk7OG8QHkZJyVyFk5OWssSkuScVYiZ+XkrLEoLUnGWYmclUVTfn2YILcAyTQrUbOyz6mGXDuSaVaiZmXXs3uRZJqVqFlZNHV9HuFvhIUVNSv7Flb+sJiMsxI5KydnjUWtTTLOSuSsnJw1FrU2yTgrkbNybHFddEeMsxI5K8cW10VXwjwr0bNybHFddCUMtBJBK0unVvvWJwOtRNDKCVpjUa+TDLQSQSsnaI1FvU4y0EoErZygNRb1OslAKxG0ck7cGot6nWSilShaOSdujUW9TjLSSiStnKQ1FvU6yUgrkbRyktZY1OskM61E08ppWmNRr5PMtBJNKzfTWtTrJDOtRNPKzbQW9TrJTCvRtHIzrUW9TjLTSjSt3ExrUa+TzLQSTSs301rU6yQzrUTTys20FvU6yUwr0bRyM61FvU4y00o0rZymdd1mkl10GGklklYWT3GlT+ZZiZ6Vm2etrn3MsxI9K98mbS3aYGFFzsptzpYs/hiWVdSs3DRrUQKVTLMSNSs3zVqUQCXTrETNyk2zFiVQyTQrUbNy06xFCVQyzUrUrNw0a1EClUyzEjUrN81alEAl06xEzcpNsxYb8CbTrETNyk2zFhvwJtOsRM3KTbMW5UvJNCtRs3LTrEXZUDLNStSs3DRrUeCSTLMSNSvnlK2xKHBJ5lmJnpWbZy0KXJJ5VqJn5fSsVZ/GOCuRs3LjrFWPxDgrkbNym7K16JEYZyVyVk7OWvVITLMSNSs3zVpU2iTTrETNyk2zFlUyyTQrUbNyapYsqmSSaVaiZuXULFlUySTTrETNyqlZsqiSSaZZiZqVU7NkUSWTTLMSNSvnlC1ZVMkk46xEzsrJWbKokknGWYmclZOzZFElk4yzEjkrJ2fJokomGWclclZOzpJFlUwyzkrkrCyaWg6YMM1K1KyMcTZgwjArEbNyw6zVgAnDrETMyoKp5TAFs6xEy8qws2EKRlmJlJWTslYjDMyyEi0rN8tajTAwy0q0rIwtrIv+iHlWomfl9CxZ1EAl86xEz8rpWbKogUrmWYmeldOzZFEDlcyzEj0rp2fJogYqmWclelZOz5JFDVQyz0r0rJyeJYsaqGSelehZOT1LFjVQyTwr0bNyepYsaqCSeVaiZ+WcsCWLGqhkopUoWrmJFl/yIxlpJZBWvxRPdb7nwHZ038btL9/aqAncfM+B7eihjYZt9GqDTiTfjh7a6NjGNXnXOTi8jWNYb3/51katScjXvduOHtoQbKO2LApqDdvRQxuKbZRqBV3Ebzt6aMOwjS2ptEfbDh8acWxkJpXXyG2HD40ENjL7Vl4jtx0+NIJRnawlvEZuO4yNNMzqZC3hBW7b4UMjGNbJWsKXuNkOHxqZv/x/fvrbw+M/7p9f7z//34+f7//1t//xX//1t19e737/20///bdfHuavro8J9Vp/+x///TfR9rf/8d//+6e/icX84bphdP1w3dbu7SeVt59svP3kl+8/ff8f8f1/5Nu/65f+9lP7/lO/fP/p7f/2oW8/yff/q9//nebbT/b93/n39uL7vwt/+ynffhqXt3c/vr+D0dv3n97ewZDL95/eXm3oWys6f/e/f3r7Lubv376EOnb9Vu4+vT784/6XX7/99tv98+3nXkv7f//ga+3+97f3evf8+/3rrrlL3rTW3j4UefsL8/vfcH1efNcrff78fP/ysn8RazevIvNzfm9Lnx9eXu8eP93vW9x9CpL6kRbvP9f/3L/Dy217/s5v6a29r3e/Y3u79xfv/JY+//nw+PDy+nz3+vT89f75z4eXl4enx9+f7x5fd5+oZfzV/LXi8F2t/37/+PrHAzSlefNOfZ62/+emvnx5+uf95/vHfzw8Pz3Wodu//rp46F9/vbd3vr/Z6Mvd48Prw3/uP397/rL7m/vtG413fkOzzX/e//ry9Onv9/inj9s//SMt/uv1/vnx7svj/es/n57/Dn+87f54e1+zj3df/v3y8PLpGvUvX+4/3z8/P+3O/JTbiDaRD7b79e7Xhy8Pr//+9nj3j7uHL3e/frknr9F33cE7Y/v2Gl8eMAk3rf1AU7/dfXp9ev73bYv9Jvj9nd/Y1ib5a+X2r31vV3rb3P98eXp8+fTH/Z93tw27+F8NX7X5w+1+fX76n/efXh+eHndvOG4/0DGvoj/aMHvbcfu239nf37YONwkZtx/w8Hf2+28t/uv+0zf8CG7vOj7U2sPj12+vJAK6i8A7u7+tzaev9893+A77zRV1fOwv/t7e16dn6FFv3uXHYvr07ZX/4be9VPOPZfTr89NvD192l7ybz/HtLqK93cd9vxUb32/yUj/20WyveP3HD694wYlx+/lc+se+xa3p5/uXpy+HvLVxex3/kXaP51mM29Pi8sGQvDV7/7++3X3ZN2u7Zj+Wk6/PT69Pn56+kKT4bVLinRfzv5r9x8NnuIfdXSA/1Nz/+nb//O+Hz7s/e9eLX+Rjn+bL493Xlz+eIE65+yA/9he/tfjrw+Pnh8ff92/1smv4YyfdW8Of7j79sTv1xk1Gx8cy+tbm/ePr/job0nZv9WNf01uz16B+ffry8Onf+7vXvL17feslrqV720/vvV+GlyOnmozdn/GxO4a3do/PTbG7UbqMj/U4rw9/3j/RTjluT7X8wD3Tf+5/+e3b4+GOwcdNv5wf6cD+c//Lyz8ffnv95fXfX+9f9m3abZsfODv+c//rt8fP++tGG7d/s29XCv/I3cd/7j/dfX399lz3+eQVruN+f73EdXmdDzTNm9z1ifGB+7CbBuuOBN7o2L3RD31d+3aPp0KtqXTb+nt7n8en17op2YUgdrck10HKdzX29evxw7zOkP3rpq6/M/Rfv356evzt4fd9x+K3Hcs7P76vX788fKq/8P86u2rddN3vvMSQhtd9+M3HOd79YS7brzuE3X3zzXcv7/zmb9t/fn24Po3d/+v1+e7Qy9x2W+8d4CKN//589/WPT0+PL6/P3w6voTev8d5HdfIa15HNR3yoDL2Nzcfb/vb6x9Pzdcji9FXablTkvb3Qzev8+vB49/zvl/saFILhsNvrxrvPIN7y4eFj7MbGPh7+X5++PX6+/3x9Vj7kso3b+wz7eDJ/fX7658v98/31fMVRwt19tv3ABz7bfvr15f75H/zBbOwHe/5/eInrDw/wh+we1t57c3TzKn+N/vBk6u0H9d7bjtv2a7hmdshf717/2Dd+G878eKc8G3++/32OjF4/ote712/7GOntLXt+PEbXf3n3+Pnlj4c/n++/frnbfz528yf0916W961/fXp5eL2nj0N+8+n39z7e71q/fu7X+5/np6f9EOd1q9m/2u4fP3c/PT+9vPzj/vnaMfDseN6+wg+8e3iFl9eH3w+DKtd9k/56Ffn4BXL5Kqzj6Lf9adePXxGWr3bM1nVrnL9eyz7+DX2+/+3++fn+87VrfbsSHQel2m3G7J337Lev8vB8/+n17TZj3/RtAN47xnfb9NN1lHfXZB+3TX78fLv/cv/p9Xnx5d6OF/R855MbafzkstBvO+xx+fhnQl6DXBf67Y3XuHz8W71//OPqDZ9fn56+7L9Ubbct/8CHtH3y83b/rXfdv8TtsMUPdHv7lzjcWfTb6854L8OQ9r/cf/5932P3Wy0c7eM3FvVm//3yev8nG3+6rm988zDw8Xf+x9Of978+3/9z1+itmA75+DV+14+9Xcf2n/jthWz8QCe9e4krrL18vft0//L69LyP/e39+oiP/ylfHh6//euPp69f4WuN2889Pt7tfHl6+vrr3ae/H3v5cfu4LD9wh/7n3afjG76ucnXT6sdz+Jcxb1eO1/27vn0qlfeOAdL23+5RDlem6yoDN4UkP/Aaz0+f7l9etiEg/nfo7d/xA0+P+9f46256/yK7R+yP92f7FzkMDo7bJ2D5gUv4vv0vD7/df/r3JxiKsdu/4b11BeQ1/rj/9PevT1hrMG7vRiU+flV5a/7Lw67Z2/5A8ocjxO4Wxm2NgP7AJXZr+4+750coixm397T6A33C1vTj0/Ofd1/ITd+4rRLR9w7UHl/g6Z+P988vfzx83Y35XPpt4z98Tr3c/fn1CzjJtZTvr7Z/pN95fvr9WpnzfH+9M9t3mtJvQqjvLaPYN34l9L/6tsMFSsbtS+jHP/jn+7svs7u/e3m5fz6Mvsota6h9/G94vj40XLP+8vTt+dP9w594Bytyc1evP3BXT1/h+hz/gAOTcvtCP/JZkRc6opPc3rPpe4fs/0+vc8ARsduTOv8/f27/+PRy9/nuK2b4VjTsB27Pn789XhFqP4h7c8tvP9Advdy/ftt3ETFuW/z4R14tzuGffeHWrcqbfjz+1fDDdRzpy5ff7h6+fNufv9r0tv2P34BX+1+/3O1HsG8flM1+8AN++fvDlx37a7/93t5bE3Tb7LevdW5+Zp/0bdGd/cDw7Ou1l3y8+/J8//j5/nmfYr0t5rIfeMz/9rh9h7tWbzncfmCw9Nvj3x+vlzxyN6C3N6v+AwOB377+/nz3GdqU2zY/cC7ff54Us//GLjdv0d5/7Xx++sf9vq7i1tK2KmB7L009f/rj4fX+0yucWHF7A9gu36uBxnsLeJ9/r1/sPTpuPfp7Obf5O7/6zWx+uQ7S3j0/vDw9/nL/r+tdye6t++2ZcF137UfbZkPAO5od8lZpnh99mRK0xSvcjkjJO1P21u6+4ub2SvrebuytpetI0y+fnh6LEfdfY78tVXjvubW1uw0w7bK2K+m+vLcX/6vB7QtbcHrortrqvaWyh+af71++fdnXlujOCfVjnzC2zN757iTU957Ss/3P9693D/vBwrwdLGz9vbUAb6T8eV87H7vJApf3jggcgPpQXrG7o33njRlvlZTO9ts+6L2PiYfWSRh2Ewku763PX7RMwnA71tgu732UuBX7P+8eH367f4G3vau7eu+Qy3c+f73//TqIc+0oHh6/3d8/XsvVd6e3317nrmsdvxWRfZ+w8t57fHzR47PD7QXmvaMWWAmwDM5tqfh7a3KwcZabXVXke12JN8xisyuRfO9oFDbPRr/z5vTPj32Fj3fXWU5/Pn17fKWJabeJ+dj3eNP0MR+5O4c+diV4fPoM3d+u9//g9fXp06dvz8942xq2u1a9d2zyrc23qvRjveLt7XDr73Wut3arMn1mC2rLduF678DV1uz1DqP+8+4sk9uz7J2pqqGXx2ux1jYnZz8ce9PDyXvPr2ryOrpzrZJYjFXfTnF479f/+sufe/ffl3RsD9/Xu+Lv0zFNv//u+3RM8+8/vXeS3uvrtZRtf394+9HEe6e/VENfHv58eN23prd3rv5euGIfbd5Odbsuz/aRpv4DJde339J7a6K+14m98S5OorDbMZh478X+rdk5i+Hu8z8fXv94qwr45/PD6x7Pbs2ov3fCy9tL1FXs+hr74ozbSVnyztP1rcm3ceBP9493zw9P+xTfjuw3i7eZJd4/+CLXwpi/Bmz3n8ftm39vkdhbu9+R8vA5t9si9/7eksvv7R6/ttsCmPfOxf32+vTn3evDp1+evz3+UucWqay5rT9573jBnEFYBna8HNa6LzfVWN/naed7TfVtguLtOML+ErEr6b6891T+593D69uI1P2/Hnb3HeP2lua9c5R/vXv99Mcvn//fzr5tx3EdS/Zf+nmANnXX+ZWDgaG0mU5N2ZJbsrOyGph/H1C8eAVJu8L9NDW7q0KyRJHrEhHLEByu0bfcyiZAT/IPPvRpnB77xOcSHWSN7Lq05Ne7gX6a3+x6f4goRbDk+rd80f38bTgpyDNoJZ+/J+U9Fu9p1QhkjztSgfSCLQsqCy4YArRnsbz85HsyUXhNvZViQlX61IY8BC10RrzSQjjYvvOOLFomEgSFoiK/nnFK2KLyKyzIfMgRjFc9rePmc6B/bnisygSOLJE70ARLctNassFjyDi2nxf/3kJSLAp2aS/j8aTPw3064MMrC5B4sPuDgIuoqSUswK4lH90GmPv0SuCSs84FjiT9z8Px6v6YK3HWrSzOF9xRI6A9u2M2pd+bjtv1tRTntORBmcL7v4LYslPWktXZFFt/J8DydG/JTnQKbDrckcVFI+Omll64MfL3cL7j0d7I5n9LyjEk8DxNqXS+kV2hjsxUBaqP2MdpvWbQZT++I3unGfTcsm6kdKcju6gSezpuTBzElP4hJC1cYAItNfnKG1l570j+okS/GuDhnCnqN7Ic2pGySwFtjFpyQZCslnVkOidg1+FTX/RtOA63AXGl0pXMjCTuYdF6iitkTSuzxOrtL8Se4bkXJ7e4jlRyCeDf+uNyuB7H9WAiQ9T8yoC9e3MjkunyepivUc4sVxvZLvDI1+n0Pa734XwcPz8RVT4KsrzjUSEQyS03EJyR5TgPvnnZGGrIZbh+6lt8ZDeSxNqRhVmH/bI7J2NbskvtYJ0Jz7yMpxGb1a1MZzoyi8uiZkrUPVhbkUU/By72zeiG5bJgk0SH+SSw6KDIsSOdjTKguWcAmRPZZXfQx8VErMctqPg1Rs3VDlIIOgxOgKMnAZ1JUojmFYD+fSVPod+BcxLZWvawP4fzPd4ouw7KD/1bX3BAXPSwxrhQ+SbbH6mGMKrGyNysJwXWKWi2pSLPTZKJn0FO00nZPizUW9uNAM4a9PTwvZWkaJPRgsrVS7JPPKzdxTJLV8HSfesDXtNAteuBFEGqMR2ejRvOY9Tq7aHTSAqqEsjcbwczMrYWcB/Px/1hOJ/3ca7dyp5IT9q6bHgGLkbrZSFAKdKwwsH9RY4rN1d2E3DAJtZI28GlzI0r9kPdhFV/5y5JnVXt6FebBy9/kb/SbXoFRl0k3zwGTx9Mr8ADjt1psri5uwaXLTbR+nOLpGxShFCSx2L4BJ68Nal1qpvw1njwiJIsU52aVGD77yrh6vTQAlYF9w0AXOZtFLCZkj0kD5pZOwXEFWTFCfFydwnbHtk+NagmescDCUycOrIifRimeRoPw9mnXYmqvOlk2E6SewLs+G/9UrEu+3FksCKxheZMj0ZZgqIb6dxTkdTxPPyi/3WPaE8lOKGQWW5A/581blTA+6vIumDAi0+sWirIWrLxEdA24vmk9XHNka6lj3DjDZcbkk4WzsNIG6LAZcltUcFVkOVx5OV65ssS6HXjm5R14JLVHfvt+Qsc9XpYxmskZy9BLcxCxkWDUhotVPQhYFWRB9NiH9OnUMtYuCVZkb5Q/rw+JbcHetW68vgF70+SP0gqrIeKXZkbSa3qyCaaB1ucIAfvTlL3yXqZB7QrBVux8vsk9RAObusURz2FVj469mvf0NInJ4tKpGbOYz3nd5TSr6umN6QcbMykKWWiU5OcvEf4vL3q6HHKl0OSpn37JPuZKLCZbB3pvyXdS191ZgRuy+9hBs6TI9LlVMqiM2to7lBNyTL/CMDwkGSH5EBTL71SQafxvfWfYmf89EpISdjK82G46dPG7tjsFRMBoQL3B9WSEhAHi1RCuQNUfZhGwJ7Kx+veF4Z9CrE3mqhbfIjI/b4l+z0G3QeYr+EbGbJ1ZOZn4L+GFdvjRQ8+WmQF4G9dZ/FdsLw0ptssjxay0fW6Eyzvk1TDvGinysIfmzT+rdEpWRqkV6ko1Of7TlL10bHpxAM0Zc80kurS8S98eyX4DOWt7cjt42X7Tr4UNpjzgGFGAv5Y+e2R6j/bCbRg2e6zrG91pE+1S+YgUwa71JIcB5DLCpUCB/GaLN4evobppI/7D/01fI/z8qTSIg3hfZqxzYZ64xr+Ek9LG1BoIi3FI+xchQOqbuwTzsHm7hlcK9nM6Gs8HxeN/qOyZFKTJs+H87Cu46dT5sIbk7+6IK3xHdyfhw7PiFDgacJJQX5KEWpS0pYnL7ljOsi/dSWBLL9jC3oO/GFwpT8/ddRLLmXaVL2JHPkjJPzBAr4EOqU962FC94Kil5rc3oXnVeEK3JUvE/SVrxc0hS9NdCSP1l12nPxbgMckaTRV48M3Fa6n6sekhTBaq1XhT+FfhHFWyv8MVYRxVkXQhhRhnFVRhEFZpf9NRZAlF3X4e6FqUjTh7wUNSdGFv9eFAV190Hzv/N2X4Q5K/3QNUdD/qQpDtsIgr5KURrjna9T8R5cwnpY5cqmQYXzNnkYWOJspAvu9egw4q8KAM19uVyqMIVNBt67CGDIVnprqw7iy8NQKFd5HeGpFeGqOyb+9t/Av6vD3mscbDH+vDXjdYyRaWAeP9GHn774Md1AW4Q2W4W2FIWJl/XiD/HcRmV/JM9T+q5I0G93AXLiUjtIqJXTFFoUEpPABwpACird0RwStrRrZXO3IVnVmDhMKMtiP52Hq64zb0gihloSYhq0MbchbLTl0AuCTlDSIhn7NiU0wbOeSAFqwVRHGehh8Bkj3sZzVimz1N6X79Bu20HueVxQMiV8b9hj3B7+TO57+f/2j8v9TF+YsdiQPabuw1QY8lUWIJ8+O9thgXyc7Molg63GR2LaSxs517357Uz52vXDikEy6w3w+69SVxdgsyFYO6aRzmM/3S7yvQNZDt1jmy8c46S1BToYVApOhYjuOKTtXIdPIP8XmESGxMeprN27ZISQpMe5/zc9VUzupD1YVyeU4bMOobltosaV9uepVV4ITAptCxdC5KVJAG2TTp42zoH0+gSF/Daw2tjlqES0lAn1BoH+n2OKLxfP1bSwX7yC2twgt/0wNMNoGr5llXEieUEky7h26H8ITff1AZ6jYE81CXqfToxgd9eFldEBqxT0quIFGWwywO5swj7cllQ14Cf/AE4fmUpYka7aba7GfPBEMuvxoqZath1js3/ojlFEzUyUqkETR2w8iRzV/GJTYkY4HKWhmpFAHbZD3XmCMnBsqJKkgipWnPPAf7zH7rMFggg3aMuCZJ1MqIMfQEcQz8GyHCPoNbNIaaGU22MwAKyBKNyG/Z+3jtkvcMnwAYMPxqzAuXXQwnnnnp4KrKuSdPVtLduiwQVdyaEzNEgw80l8HMgjw4o1NNdvGkflbS8pIHFg8yk1+aT0p7fzL4BFZ53zj07VDr/drZIohk0xS1GLQ7jf9NZo+9sYy2uopm6/U+jUUdYO7DUz0YadVbzlmsrf0PXQPSC1HbuiYTETYuu4GkzCUlbTNYv108mN3ahnUN/RyEcl+hpUvn35BR8kuw0/LEpUkaTQsyTNwB7XxCsjblsp9rGF5eAH4iVRbSqAKNo/1oIbclz6BWs4Ea0iXkIB5my/nHGYjMem3ZNq82J+UpB+Sfv+kXSx3mo6lcc3TOkdDhmVNvqX3ZjdRLmLlySA/lGFdHTMUV0tfIil9cbzy1YHKl6MrX0OtfLmgrt1/aUIIWoRY1P3z1v8dF+5tJeLwp2DOpB6F//ZRxg8F2l0o5KrHnx7F+1DSrcJ/q0Mpvn2U50Pxvg/F3V0o6QbkMji5lIW/lzIUS8pQ4A58clWH/9aFUncXwpWe7YHO03q/6ON+K9/ux2PcvJU7ec1vwQY07wqkFAx4rdmynm36JSejKkCI14WCfUfnrk6T+c/U5zNrVisVwmy9N7mGIZQ/UYPKkh7/Fh2+F/88h5ceMiwzIsB7kslzfMnI7clJjALfTU2yYT8CyxiNTrYCsDlxM4Z4rWTG9CzlJMD6msTrJSPT2p4lIYZr4Ew1C4+/oQZfx3eXjPVffP5GZezZV++iR6NXMk9HGgT0pJAf8C/XW/7OZYLe03Vhj+wq42GaS2ZNykZ+T0q/HheQjzz7XuWRzBp85eEjXGmfRaf+OdyEY9nJ+X4925kD7BfmlVBEZWlsAdy5z7965B2wcnZ0XfWKrE1ZP27oF7cs+jzc9N7UJsbDfpiO+8wwiVZ6WPcsJdSDW+xhOmaQDdMA+LHk6bDo4ab9/EL9ow/3ZFyOHHlH7iCAel0SGnoHmuAdW/QAWG+SazqR2FqoYB2wvWsLnoYR2UGYstXCpttwAWPvHZ2Rkof6HyDGjrnAlCVX2gb41CGukqWWhtUlWMxX44jl6yJH6ljUiFGXf1UyO2V5FhY95hzAOOx3fn2GeSB3Q5cpFOqRAJDbzob+eqqnrGWxpHkLm3tXOxjWXbHZLwCmo+7NeSBhSXtEC5stkkXlMVhhby2CGD3n6m7YYNBeeWcNm6GUSJOS6gTSjttCBdW8f9JGr4Q5ocy3CpY+H8Af5eH7lGvqGscTmR6yp3x6gWAgG8EDd4itxG/wZ30aDn/IXwFJLulRai+zWaHbqcCx7ETKoiu2qreB5u3LZfGINKu0cH8bbylTnoqVRETIGftbVUE9gk2/LTBmItmJhJKvSDptBvDnY/Hkp12zvX8Pu2U3vmuRCiUV+E+ovnwH3nQfj/fh7CJj3JDAKoO1IXS485zGElJu+s57W+5TbscsZSOsIidSWETjMxO7ccJsADpJF3DWWm+NUOHdvHUm3bQZgzcsf7I7AeitSs9hrVijBLyCeV14fkitPekdZjGhe+vDyqhzC01+ttLs0Y3vWxYXRgwrWsz2dHh9Lo9RMnMuWErms0ukjfMdtPzZmaivL5Dpce+AhMJvdE8uM9/NDhWFzJIkySpE78s6L/ufiJMH0xZYrqCFig4PedopduRebDypFAx5akJLwE1L3CY8cIv6qA/nYcm1e2WSxO1sHuu+gHtEI6OpjjS3N6brRx3sKT6GVTcVfsQFske4F3zUn8P9fNsHocnenmf78TTNizY925teonms8v03ZFLz9EKbUX+EL2s15BfnR0CYmsQ2T8D7yqeCJymBKNglp8/DHzNqwo1HSVAbSapsSR7z0SQep7MVR+eYL8hQIWseRz392ftgam8eyD4Tt1XAV+zJytKG7cK2PCqkwGQ0aNik3yEajBhBERdI4jdBM8IavHjPkoRuIls8vgnZB3HPjl7l622c0tnUskNVkS0NgaV/jGccIspQiyQxG0TTGh6/9VekUu1k7Yt/bWY6HrIG5OAO38JtfM+3IavPubF7cA6X9GdrWBNZ/YFY/Q1JqnrBwah6oAOxq8XgTdeL8xhK1k0tqwYtWfq2qJFy8DxMp3tMhS9Ak8oazhzH4TTN6208mFYDvCMoVhfsJjie9HoLRxt8lvLnc9GjRXtsJZfxdomrdAqMR5sg+2rZ72i8GM/jmFYP9aiKLMMErO1fAp50glCse1fAS9VLagdt/oq08IkQMyEy8NQqcliAzaESJgKM2mPJTNl8zKjzZEREVsu9scIzM3kpG+jI1N5jzh//c9ikvYkLCiRgJBVOol6X+TYf5nOEC4UI1rnC425RSfZ2W3iwJCPCw1rfdCRMSW8IsjSFcKZLGXHj5VoPZCLPxmlJBUnmKhlyNZTPWY/6Z9A5avUOvOHoD3e9molN+rjPjcyDQIo06zSQkfSulC39KqjKyNLl0WgNx48krS9kWl+yYcMc094qWfNtCh+GkDMPLN7hSx9+YZBTySCH3KI2rK8ZK2aF5P4UbI46X4Zx+ufLRiw4oZPc1Qg3N660K6Hfz25/DjjpwgI08G13pJVBBJ10iboaPMbZ8wRRkw4MXAH22B0bmNorPB9aBc1u9uhyoH9z4IcHTfqkIvYT9/UOWOY7NqcE6EyHuscZZmyq52Aj92IAVuBqTRaDHXDWJlvhtLW37jTqewMuSDYVWQt3uL6T/OSl9TD1SpGsDY+9kfgADoz+VPUeXOYD66H7WL73LbzqTsOhWpFiIoebsgyjzrdcBxWbuT3DnublYvx403EHO/BPpksLzy7k3Iui8B4E0yS96eklMiwytZOUT1WR6rToEsd5XccnZJQdSOsqkivgLmAFEqvpcdyvn8N4jgwczKB6iU5HBAL9O5kMZubIA+pb65Npu8OgyZqtcFl8I/BIK7fGOUlislHlA3P9Gq4xO6AHyLeWn4HcHi3GvvDl1+9FMZabm5+MphTILGu2BmCRX7fZoUdXk+IZjwx99qh9Dwn3e6sAcb+H83hMt6gCpnq0bLaIV8hvs4X0Y1EtyZ1H6Owo5mIH0jtSLeiAjc+lE+GM8+Qa+VEGvQM3XFKxncX/1kvW181YXcE13nqzz6+R279hrLRqSU+6cCmoVD53qlOQeCl2cmT+Mhk+GcRBrOlxHn00bfzbdVjWyMVRFejqQBqa5K+S2SaKCh4R6cwW4F9wT8C8uGXT+wAc1yILODPZyZcezzKlXec7KqXB82Vr0BbXUrEduidop1eAyhI5scZf4c/lYz77FDvChWo824OxuL/1hw1x89CgUO9I84ks9L8jlg4MxFHde1H0w3IhnkiowEhUdSQhQuBacdoTXgrU60gm4AM7P8eogK4CO2f0gfpsmKQq4TDq3jv6n7uRlzu09mC/lN/TeR7QQqaX43V6rw9ly07LDNXgGro+pLrJTdm7zTfsINVApyTrfgmLH0RFnlKyIzfXjCeoMbMEwgp3CgQH8ReTK2Xlrye/Go/7fA6k5MiTWnA5xjSZe9NK1XZHMgUTxIzLLrSiFBl//6VAokppVKB6sqqTQc0OFZSe06QwKQMdz+crZPewJDs/wbB8OD3JcHoYaa7IoDKPm3t94MBMxpFBAZud2NdDLVyRNvgpZu5uwYaa3VzO42G82VD6ft2oybAgemDXlaQ2S1+utwcxxx2q+6y2U2rVyLMks247EC3/w7NwuC1fT4flzzX64Q14a5I46Mi3AwJCRQaVXuH8Ylvt5FDVnjSLROV0RugsN6uezDE96HNJJvAAd2Rw42HNI4iZCK0sAPZk9T0GzDhlShFTT1JmJKx0KsX9GjocPZknSmg0U5UzEEpSQG/0i2NslSxgXJBUk4nUJofcx4OJGzB+IYG+x2Wetv8mG6VygEz98LsgW5ICdT/Fw3RMH0TWroLbRx0MsurWE/lq9qNdojwEqqUt+4nGrj+l3NdqkohhKl930MlEJTZgcZJyvXSoiZKdxmLnw2x248jKKKUDU3gvZTAzrUh68ksRIHQoSHUXAn7OS9ojVTsYSVSR00xjR8yUig91s4rdQD3snxHPJJjM5Of6KdJUwaPq6Vuf52v2dmHed8VGesKmMmN9JR9sQXYEJWRamWplD7frvD1OtfNLrQ+u6j0pbPIXHKebPhm5W+aHACGRzCU97tnkgTjdpAHVPLs7SLi0aVLIiKx882FvcJnf3cLvfu/LOI/TL0x/Yeh1ySaAHm5OS7k9NHUqep9FxOzXAENEyWaDB37WIQeBaske2V6umzEj7CW9SZX9e7/fFOeXY/bXw15L1vk8bBYQ9kKyOxQA7x/GfzrduntZMFIlOZg96w4Cm/WOFIvon8P5jlrIWk7ibUnWgsMxLJBIwSKjKZIGY+VtJtFCvqkI8fzg6uApVpHsnQd2OoK4gG5oyx6jATGO9UAOHARYdeNdwOowqqV+6+6RdSi2TB+1uP+rHsGL/UNJWlMFfWFGNyoFHGz952fEgUgyOe2DVVxDlkkNXOzo30MrgqUi6p+rlTGkZuCVLDXXJG3F4xmr4Ol2HSNEKeCmH911XPS6HyLePugValKGp3+u52FEPY5MxSo2LPiJa2zS7saPsChJCwCL9opriVyCYEZIsost/ou4HMLyMAuJDRUy6JnlVMhAsmSr3D9GcYhl/Ep2bBo2JP/ZCjm5FpCMj0ijH0f8ST/BEj5B7tY+9e3wlehCpY0h6WG7AW3zB62NyRUt8yUfsyNNeBLnelARlGXYuMhUbsPbD5+RBUMr2519cOxsSG6jRf0wqWFU35SFyTBDqyGtJzfY23CLvhWgj7GS1MdYuP3GIc80VqTuow+DoxqSDyIukGkytfK19WEaVkMqHx7gj5uPHgqMZiHrgp/jdNzHoyThtmXO1pNiog31Z9Gf6/4279MCpnzMZIBjIF8ycoHpS5bpP8dpxDG9pWThVSSZ4HNcnMbtaObdH828dgxAZcmpJkuDn4ZlitukJNw0wZt3F4a2scqMzMB22UhqfPmvDzWohn2ijv25f1DE9rlSVyuLuKwffxY801OR20PP7jQZ7OxEVamvKf3ow2JHJncPAq4f1RSRTCFfJj2uUlbvU18L6EZUocZTkQPEn1GU8SLATapIkcdT9nPuV8BTKqrwK8i9xFOU88JRoGCy1kwR7RkRQZNC7yqImHsOIPyryLzd416MGC16rlDBZY9+P3UoFzTvaiiBkFtfVJ8AildJtqZO+rY3mpB9Qi1sJeevJ21wDJxRdu4zCsxWDv7pyTpkAMxqRVupl+zJzO90nj+G83XRnyNYxNSyGcOyZy1YbHxUSz5fS6YQm3M6JnzSfo+s7nj/9ShtkntNTTaqN6in7SHgApG10HS2p2FjyFsjp8+d7uNxm7x2ufrZj5GlBxQVe7LI8DVERW5ZsSFlKl/D+reB7VI4TFI7voY1qxGBSmLwrCe1tl8DhnWNJNe1/DP72qemJ7JuRPbjvob1MscqFchUWXs2xocT59Rxyy6Lm5noBeydljza8xN2MvO8QNrUkjEJaR4KLGHyUI+hDYNcu8rDLx3xTcFtmZ0PYuVG//xYxuNJn4f7dPiKffcg2OnIKpvDtf/nhTRZQe1NsWxCgM8Y75agOuzIDiKgZodGgWum6snN2eH6gxYRIW1m5zFYxJAg7LMOpyUE8+woiRj6OQtKlRBc9STZ262J6/XsRB1Plh1w1MmD9Sl21vsRDsiOHILl1pz1/dLHTLNVLpGC3USermQQiHTkLAAJl/3pYIfRkbIIi/rC8AdcC0vSPduips8RlBvFWwvAGSi5nXLRQ6QUq+VswuatV+QXVCz1buUJ/95rMvx5vQzLCSNwyRTpSBpUDJhnykD4q1i+dX4wWCVryg0pxww77DYiNX3z0Okg69QBc9tjM6Awv420j3p1FEARuCeJNhZw0Zf5liHagMVt8daptej1Ok9rdLiCiQbL/3cC580zd5w+52jnABNXspktNNOZXy0Ri/6dX/1chd2DM2DZhhoNSdfI4SfNHpD4lG1gMZFtH3sN+4HGXM5Wtvs6sjMuAZMNSnb42AH3DnC86Pmee3Pw+0l2zdftdo16XaU0tqzIrH6MeouiI+87/X6kXOn7SaUvKJd+AF3pSaeln9FW+sJ26f0eS+8XVfpZcbWnW3YPbix5iI5HY+psxGip6aLsS5C80GzkJ6dhBDK+q6kXnnTo3pcxv3J/cNK3bTYF9xX6qz8dLQ8EfLIUbr1mkTYgK3A1uTFa1S12V0TVwb9l8syyaK879HDEBFozt+ta/MiXXhZYWS99D5SRw1ZS+Mkyjx3eC+oAnFqB4UN+Dhn0LHVAsuXJVrPFjlTS8DzkGV635B2bf/sY1rB+/Em2WpgdSoJ+6iXveKF2YKJB9qrG6RTVIBpJ5mnJqMrC+ODiYz7+QUiYTsE+v6iq08Gk8B1Jz9pgMj1K+UbfQEpGCMsvjzvYNpyUUCfVJ4U/LgqSt/OkkdbBVrMjJ/Q4rZ3RdQoFHrxQ2SjuyB6+g32GWciaSfneraJSMFo3PdTUFOlE9Aw5J+iTaZIi7bbzQslGVm07kmLmoC7D4WvO2oHLjbd+DzR+Szi3xXMywyDctix9jMAuXHuZvFZSKfjma7IF40DX8TQNqXUNUNhqUi0aQ2bvFXiG5FAJB/xbfySPGupyZGiPcOke2oNDIHu0p6CZzwBI34osIz73sBZvqSWpexIsYVcXsoxX8I/TIKbRTCkJy2wL2qEF0+r113hG3wFZzGk8s4udleHg9XHDzcR1MPusIHM7h2pTPCzpSJqPP7EaUtztYO0oS3zzcvghv41saON0/0nvFJx2WTmCg9x21QRQ9pdYbzsHeB0Ov+KjT+paSjZ+t3DJGqrkJ87yIseHa9N6GGKyDxh1kxTTIK/CIEcuQPreHJJrLxzHQ1KpltVFsjIUYA3qON11Rq5eSJUcK4gC4HC7sAuDZ8+O7JXlcVHX0oKuhQ7eb9p0bcaNBBfrR1uZXPaP0Th0ghHAN+woJZTHe0NyLIORTtamB6RcbH3i78MSJZ+uINn6AXaNfXrhHsnuPJgz7vPzw+VnQG/E8aCp1HdFkhy64NvQhySenT0dT1zEF9eBBojOABAy18bagbK/pkMTRM7O34KQj05JI+D75WKG7ObwgTZEJ1qInxNBg5dVTbZkCXtQiNe9c7oKNPKabFznr5RWloGxWJKNizx4xIoCKayvd5Lufk8ukHu/YM9JUt7GdX+Zj/eovAbe96pjg5J1uN/m7Z9hRRZcjkllwbhmivaNLLm3PbmE13Eab6NxL9bH6y0ZbFhJijk74WpcTeXMjOMa8y608LGRbLNxPRsp9XA+z/P1Yzj8Mmb98fPsoTan2HW6pq+5kRlCSzaQtokOXyZsGMZJR8xEMFFuyP7kuK76sBiLo186LokpGE+gWrYstjoP9yzNroJKVk9yiB8F+MNw+NKxSlZWsUhrhfGmcSRGLR2z2l3Q2wXhakW6cz31RoYjhqTYGrB5k1HnChVg4VeTO8WzqjMcraRKKGBlfrACZ4qa1LkGxOzvhcOOlIg8M4GGTYIkjwasbNkIfi8pXYr7wJXk1DRhePxuF/5EevLkRn41ssncPqbikPdqc/xMPaKWZAtWQm6ZNREJDBhazWNsD/fp5ZllUOnsyIPLQxl9VTTxW242ZIvTo6Xs3lJ+JSVZxztrQ/hJpNZyqDWZ2Zz1JwaUHSjdvdyodH/o/b7Yl2GDJAuv5koHM0cdd0Wgg1akiZ7BSk4r+eEU7HvZ5scnxnkXva5xEVfBHIrmYXpHitrPejrhHTeygN0GC6yOtK08j5/aMDXwLsHFmpX+bbs3fNCyb+wb2wUZNW9oQ5K9yX3N/svGy/48y+KhA/QJx671qtiyC+KxKsjVgyaRrVam55RMtX1RxHvYFn6V154IwuozzuOUJCIQn5G1gsSMR+2gS8W6F2wF1cPXeD4ueorHUFWS8s1OLdgQj/oyO7/sZKMs5KddkB43FvXZVDD50918SUPS8XO92I/+UVy2A5iyRpyl3E4rsv4koPNOyVJY9s4jAZ5rMkZMFvBLUu6XwqbSylJqf1hvMQH8jDwLA+0qskCUwc0dp7KdQzLUNmRXzv8cLuMZD3wZGbOmShLyMkzDaRvIZVgu0e12EpveE+4/65eZLX4eP5bBGE0O38N4jtMisPhmJxyZBu4+N7Wig1LCjg0wRsOpPHyNZiqt6bdmI2eIxckMziC7oWG2MIb7ZI2M9/8QMtN4hQoAfRxkgXPNV3CwfuOdoWVx5GAqY0x6lSWYGUYGtIrZNOIJco6RAS4L9Fm33i768qFxMlmlgOLDP9nc6gJPT++HUO5c/ND6eLljc6FxvWUnxcCXEbinPk4pyaTanEMH45x+MrMWHkLU4X77muPeHsiIWIl78OSDdoMIb0MUR8Zp8+mU5HHwzPvgFxmq0w8LlZ5sbp7nk+nf7+MDSvb1SJ//83w662+NA6xlsYtV3Zznk9FgBTsyXHcFmMCy+8M8/7rDlIUSTgYWZKuLLvp6HnDFyLZSRTY3Qj/+SVBTyqVfkSL3GDQT0ki5akWWfS7DYV6zPAw5vzUMvyWr7JfIlkyV4NvJWoIbmM1gJarX17Inwepyc2JWGV32IUPzrZRd+7AWYp/mdB/OD3lRxO6RZHYylr0My680yqxlw6Ihe+ibSwWmblKRR3YoLsNNL67r4YeTT/Mx6vJKBRmL+/Px5xb5c0mqYVkG4YsKFQqSqHsZfo76GlVVdlAnrVSw7A4S+ZbU/V2Gn4wruirA/6Bt2Tf+M17uF1imMFKqoBf8BpQ8VYX8AzZecHDpc1Rgo1CTqaqDS5aOUkDSq+kd5+cyrpkl3oFDFouV3tYOOhLuKNhWC/1azVecvo0CulstWQ++DD/OLBc/GGncSG9aP6YoMZ3SOp7aQeW/ClakNWkdczlcr8t8MsnRolNViCqBZtSzLzstYpbyPdc79y3XXi1Vh5iqDKX3lmTZXfTta46mE0hB6y74BpJeCJfxovex4lhBBUV1QXTTsQ/FBL44k6+HYdtlGd4eKeRxkI+oej3McXMNPBVqspF6ieWHYDPmHydZPbnEpfdSno5VKOfXofRaN4EtEQzfajKRvlhv4IdqBs5lsQhJx7G4Dy91ZkFi4avHZXD+9f6PZUiYav93fFu39L+ybP1f9trR0gPWfvE2vhrd+ApxH4Smu7DCy/7RMn4Yq4ZKdRDddSRB1I6cfTX1SzJte5KvblFdUWqcvjM27QpNcWoyUbDI24IbzMb2HU04kkcEWU4TkBl2J3aayQ3LQr6YowPUPpK+bEGzU3QaGCLH/uxvRz463s3Zk5ngW8t6VNtwO8ukh0WvN+vYDL9abtks1s0wo/CeZObfPDbUsKGE46UOX0hNlsMn/XObPz/XmAgHev+KlIxOs+0AzFc9ZUhp4PtPGrclQZGkcYfJKjsyzjVo2cRTlgF8Z6whs+Sn8+RbqRftvWRaNSSzBHBzdV4YpND4Bo5qyejQ4+vDJ07V3QFRqSLJKwHule0SZoKgEiTznnAZP3E65fuWck+sSZFMjHvTP9jV24E0ktzArpenSh7p5t2S/M8ILy7y1LLi0ZK02+luarsJpaeRQQE7l9dyq8Zv3KslG5h1vLPDQ/TheHX0N7g3aXHC0m0c4vx72gz6zDs+LTPW8SrJ02W1wg44c59oRuj35pbMkQLu7XbWl+hoKaWkgeXSOcSbia0jT/iyk71Jkkfo8IybYObHR9Zc/xli2iSBnFiRVb08bqZFAmMCFKmUfwTmkcGl9GYhK2YPrBHzbCk3Ip37hMwefiQIxn0ysiOrAPPn53gYh/PLAY9SG8O+eof7IoYsIIbkwn0Pm40iJbW5J02iJODzoYlAT+0b7gxKAzF5SJCZ/gzBYyHbzEUQJoecqmXfzuR64uPZSK2slXsUjsh6YZhASK7U6eGLFrWpYAtlN6ZpG/49TRpVUI1UerKT2zMKrUaScToyRTJRMVZfwKItzPEhX/NVT8KpD2sRkmtDhm8Gz0bvT7bGFhsX5LO76im4zuZOcjmevCOLzBuo8Rm/jXY54lOFNCOUWsiP+6qNMuV8TNyFoCi5I4kKs7FTTAagVXDGhGEdKmQIylsnqRA0KOVpfarYhT+Fgl0RBok4dxfzpyrUH4PQqCQzuXDjeW9MBS61dRO+djLLtWq04Xw4Xg+pW00jCzAdSYjN+jTC+KyO3YWX8YStxEYWbtowcasLQr+O/cg26HjGF0gFwiKoAxuzDlzNmuwm2Ot8j3Mm75BnXkv6Qs7322GOubHg1NmEoUfNI9FlY/3txE+9ymVy+AZQzu8F7B3IZGv+3vRLKStO7YADX5GV7deZh+xA1WTlwfBbHGCWvgwHgWJHFj2l7hWy31GS4ZKRDM+f+Dbk182CjNNw017ZHBTEUd1CvmXuY78Optd/i8hNPfiBlKSMd8NCkrbc6jty3dk64v55UgHjAN6BvMb2+1Dla0gh/1bP2ecKOmYorOwrkhvuBmjK0PtgNra3paO9l91EAyEl+Z1/0asf7mOm60V6hB1YBFTkJB4L+sLUroNG646k3FnYeK3nBIBdC05W5Ia74dtgLxVBdx18RvzaX7UlxUHQKGNc1u50w/L/Ndp54fdWbwFGTnYZ9kQF6RapIt3As+LMHchbWT4y4GVHgAMqWUe3qGHM6NcmecLXDh4Z9O7+tLYLx/cbN/l6FA+MuCE7fgCbf1NAFavISsiGy4x0AN0v2VTKgj8ZjtADPnukLqsmnAt2PTQtycL3hv5SfVLKhKrij0YDu+akbyAIqkjp3wY4xePU1K4FdTGZ7W1gYZBcjAikfFL88UBc10y3UoE7omrIMrBE1dP3uMzTJSpwVNLooSbVYBJ3PehpWEZ0v1ZAN2keRSiSeL1dgNnGxbOuSS5gDts6oMYhDjj9kcxoh24kv0cfhMQLBKSGpNbG4Vp/UaOSixiwcrvsyYbQhrnqU+b07SDtJ+tniVxJlvSqUJrYdf5PxaOE0YdcMii2G086US0pI/sbQ1/KLqpQSOmDvQlbGX5c5zBch0xpSsFJUJNNNQGrx3NEt1IKdv+aLJAmmJGxkSyTkhLvB+RRH8bMYC5YO6Qb2QM0mUKmFMy7q2tyx0fEhKagsCxbk06zD1iz3BNUUM1X5BgsgTmfx0O8loAExyaCD0jrOR5XXVoZXXZvr1CHaqIW7LTI84St4j9gF/2vexz2KNC609E6YI5LbgSNpG0o1uD8JWERRMasAfvVzFaDc0069rJ8yjTnhwF57FI8D9Okj0PqrVfLqktDEvqv52Ezn0YSjvRK6FxptSGdXdIvpJIZPWvgc1300XRUdDKcB5qmdPErM8xR0ipIx6PrYkg0SQabOvRXkhhRs+GgRX8eZpYy6Wa5YA6VuGWZc5OE2Osyf+iv+aI/Fv0bFpF86SVbbjFo+PPzBzgoiio/PZj1JwuZQZR6QkrL1mjt3UbVXnA6Y0+EyKzDMPwfrqewh8uwuifbMim8Ww+ILAUTJC82ID8mPoeJwFGHBVLYJtDyWdZV5krZodhy5FbP7oQOe2sIJONRGzC5YHd8B5mbu1TKJm7tG4nFjmxhe+gM6a5twWs26BNIdtarJLeBrJE0oIu/ZzdwDh6GLH/TRR9qn5ANeLYgg8BhrWWZn5D2974NyZ8n8lJpsCo/x8oz+mtysBCC5+4eKo0N2wIC2O/hPB6tNeu6Rl5kBfSBWjZLdfhf+vDrOo9R6lvK8k3Fn1Ib5FkP0/2aimcr2VZmRWcBdNzem215IpNPLj62ROpQw6rzvK5o3UHs2Ps0vSXlfL7m5LXYadDWSplyFy7QBPIDO7Ra9lljYy9Z2iI1ZRLOcgmTxjpYMbKOfw7XtIaX9Wu8Jl5Cku1Ys6mIBc0kjbDjqT44IPSk7z8g59N8iJODsEe1ZEvbX2GLHrMk51IeiuysOCCLR6cL7EakW8rrKmcLjyCUq9hUBrHNXx5vcYFWKbBlbYIUoiW1sNFVsqcM9BUCUbTlv5lkXjHsHyzKJuVEUqPIFF00V7CZ7AtpaCWFD6xxjge8X4/DLcrXpWSALSTZCkpEbAAdMOnU6ZB8ezqtc4BLd0lKaByqKHfEtZ5KViRrUpKYh03uuZIV1JqkSnpsPDkxLJaVFT4Y3ipoaT/iT2aiZiWDKpYnl7+EH1EXPxvZtGrYbvMyX663J0JIkMiyPdwNcFhO23/OhRGtJAD1pHOfhTXxyVmbUyEZ+Ama+5Y+zgA0HXGnShjS2fOf3gac+/FSv8bn6OnocwUm7w1b/nZQ2YkWkuBbP7wg6YdpZwen4yxgRG1D6rU3qes0REk2nK10US9NhGWY6X6oegy5fQ93OA7XW24GN/R8S/45bqgYtfbQdlQhvy5JffIDNaXzSgJqcH8qg5L0vdvG0otsyhekmiYgZQYDgJ8bayMZAI/j52fMKIGWXEUqiQPiZrxmWCXpu4fhvuzhv+r7cY4HJasdzIOpSKXk9b6c9HG4wSOsJUOvIVt7y/A7zV7lfuvXDJlGLMPveBqCTJ5acurnooe9Ia18nuff2WpXIU+akmzVG+fV2PrRDKMBdgl9g8dX7MAKMhka8mO+T0d9NO7pUQFYbrM8nomIppvUMlnOc8RQkHlXQVZVDPxzLlshK8olSS0ykH/nLRWyClKS4ZaBBmtfTA5ko4JsLQTE5zQoaQ9I1u8M6jyd/6QiFXBZII9Hg+Zi4+U+RcUSWY9hbf0d4N/SBEkIqBv+XqNo+PuA5B/JUWneeKCx4LuW/eWG7Hotejgnxmmy+9uQfNpFD9HnXcJu4W3EK++hUtcPHVH404NSE+gzwYXe8AbDWe/La2XzcK5h38hhng7jWbvK7NFobA/LeMUYEIz5FTvCNYA/A4VRoOThjR2uJweHdJb2lnzFjgw48AqH8zBCp1sVoJVsyYZXBjU9lVUB9JWWbEM9xc4EYQXocFsyAM1cIWvRWoDQriXrqIju1N7HjHSnAHlg+846DPBbvzi+a4Al00SENcNkx0+n58w+d2AekuUpvIZ75Ib+Hf8AeKmk9QGCf+sl3P8TEanh9sF1Ql2/YvfFZ1fMfQtAlW/LUIz+j3aK9GLZ39fCJUPxl47vjMEeHsFi2/c2W2TDxaJ5/3EIFcDjZUeWdC2eSSO/9THLpC+BPNWTVjcWNwtYIBnLn07+6OoDf7QnnYXxWmbsWebxKPjWgokdWcx0LonfqaeK9GchWXAWLHuPMhkOTqWNH+RQPJ5RMHcm6SVwzcSCQ8FMetWS1bYUNPf9gGtISwfuBjrzvKXWlaScWqwn66KQDbSSbNkuG3EO6mORI65kbZG+FhZ0NXyXzSQtil4bWdzvSJlviKxd9B4393Yg+67oQwLi9cN5WNewkUbfOhwOZEeHrI7DEB4vsGcF1dlrZCTnFcy/8W6GLNs5exVP8U8ON7ARaMnZRNElch146aP86LvTO0ecnI3TJ/RHqxYMK9l3bIoTevGiyAdRwdiwRCcQ9LjJqmt8AQMb0etAYMSy1DyuH1eRge0Alt3wHOxWU3n1NECywbpZevgwVyK9bVCJ9nT05nCnL1PYP+ZwQbJCOoIEXHeqL275xdhgykN2D2Ps3D1Dj4gsmHtcL0x89RLB6a+noxB7gdN9PG7GA5drPHYDyul9y4aoFheKcJmnAqzLnpQ9evCH9WeMCuuDPtgsqvRuinHhMyQ7QB43oU8lrxDsA1VPNts9vnPOsflsBht2JrJRG2Gnj6SCTJy18Vr0L/3nifGY3DNIcvqmmTM//Wu8RietpHEFS+WWrnuf9RDUitn9opRi44qu28VTykrZYaroDdjAvFZpKVUB0YiUDC76oo9jGnzJyLbwZuaFf7BNFSyE6D7KZUYjyFo+iYaUUFgY26LARpaUd5BCJQu2/hrPONtDzsJp6LxsOupFH/fbtJCoky6b/KGk2pCceY/sfRq3C0S9f7B+pYvnBlceB8j2kLQMugV3PQ8HPRwv42S7R/Oy6erwS4L5OHThaoMWg5aSWLWEWSJ0DLLhuhQnc7NQcKHLNomuRXK2avreNp1b5PANgWdJirEdlPEEmu+3S3TagS1JR6cnm2LO6ZeHZcG5RVUFZoX8LzYqPOTISCIKnXhYoHG9jdPBTRn7GtZ4+oz85TV9WFjstDjXyLfckq4xDu6F0UUld/aa3nA32KcmWFAu2pF8XAeaJyZUlewO0vW32ONSJoR8O2Edj/fhnJ2t2Movpm+CMxmds1nsbM2thvYEHWsBYrbuJd9OS4oiDO6/ozNW7F4Nf3vz+TsYGWWIuzAnzccGKhQYSQ8mdx17mNuN/bYM02plpckIaphARO9R2yXsOKwXP0hBWKY6Ohzd4B9hYzwPTa68ig5xNlAXiGer4BW0Tfo3HsZmo/VLRx6ZkJt1pKTK+0x8zMc/7niJPIobmYmwk6wk7H3Kjl5tpGaDHWrlcS/6NiQ0KMlt52tnFjBTjAPFl+rJoX1masSw3HJnYA8ONOxYpcydgW2pD+HD+JSWZWzp2zBOhF0QVHDLoN9hn8dt+RO/+x7kYiV9ytxXfKLFDmiO7Pf+PZI2SeDiSRfxv+dfqLWW/LyKdOSzMMf9Fszuo29SqRJ8MkiPOIv5yECjzBMYvTQZbIOMmUGJs0clI/CaXTvj6QtXvqw2FJ7XWvg12fsUtw9MVzo5N5fKOFCBEwud5hiw5OiTlcqC5UDMMbtQ9iI61/ymywSzaVf5Ms4nNlPkJ8kyo+Y5dhMCzkQV6Nd1IDfXbWAjdeF/fbhGsSt5vt+0uyosYiiNN6SSzNTxo1wcqjBssH7HvqKkXxRN6GmTasflPh2WefVDVWG/wj1QcjjZArhhm24d/6ydtZlLCLEJub7uk53l6YM0uE+IN9li7H06zmY2KCDJ/bRgE7T7tMl4Nh1wdM5DTEoy2lNapRwDWgfOfcdW4O/TebyMt3RGNDisFWy96T4FKUP2ZUhjFjaou09QtEZAeZNsNGcAb2iaXMvHyFrZLPfpPrkpOlgEhGEd9M+8X0/LgHlxDXM/Cg5qHT51ZshkD8zzgvy6DNir+LeR4qGOrE6twzTexn9r18uMKPy9jNGVIs3mPOYxD9qB3ocV/KyHYfqLVTSYnXJf3YZqDeT+rY9/wW/gtmn8wzDNk/H7/As8lHK4E8fAi/PBgMbDg2VWWJDFEgEbgclwm6ShmsLI8X7Wx/1w20c1S9XAcc1+VVupZZ8Z+tbKc7sPRy5rYWXpyJEzt8zSW9J40gJFGXoj9/GOzHksUpSQi4fG+nGv+rBoE5OaPmzsfgn0RjJmsoBYh5XtpprMQr0p5f1yGZIPDmyUyG6d1W9h2V6kX9zJZEE8/R2NJ/A3S2pNTVIjHbrVqGpUvmytDJTySUuRguyOrzqavyEFCx3JeV9NQSguW6kG+lRhXEnz6ImFKRdNGxw+Sdbf6ofCv3ZgB8Uo/U79vPm9iV/i7htkv2SDIkC+9PYGmRlZow/IVJ0CigGke/hGp1/+eVj0cNP2/4nCYmDAkNYODlXM60ZQcL/qSV8LBxpLuyNkiOLJ/NohMxxooOuQtbsA/wbTDRg2pNPWk+vkmGlQcyaTiQj+Be8NyFjsqRuh/5X+BjJcdlBwdJVXLDh402TJJ4Z/QYaDF0z2omP4v3Di4CMjx7U9uUTuF2AP5z/6BRRDDrhKpBlCdJ2/EtqgzkGSLqJrPOe1ARWP9IyLwF/R2+A1kw2PCP7vLDeYvKt6slaQXibDVIQPjfTqi4D/xqKD7Y4UNeQvkSHTQXbM0ms8+l8rcPB0SE67A3/ddoQNiGRZIbB5Fht1J842Ydiu6snanAM3qOf5dIrt0CHGLnZsav8AlTL43Ey5Cqph7CwxuEDSo6uk2qjYsaWTdJxiIT+TgvQLdTip+SjUtUk5sAd7NRxWTkWn16qd2ot5ikzWOt/d7Eh/GQf5Ytws1IjoSDks+uzq2cF5yJYIsiOgW5mGuBNjK2Cwv/92vw6JyKeS5KuG7D9sWBmOptyXGq/Ua0jWlQU1LJHlko4xlCUw1rVvQ3TeXDGXqZapV0Ny+DdAyzVxFeX0665le6TxUjzWr8ldIXKFlFFVQ6/M2/3q7jLjT1ZLp4eGlBhsmDkZlCzbNqQaegMzRvNwW7IT1JC94A0p47cqo5OGrb98DaZRJjcGyCl2YThnGZweG7Yk+zVeskZc0lunCcJONnv5Gi8ZEy6464bsqa1f99tx/j19/HEuthjugYi4Y8O98RQNn4fjz/3cwmt9i9r151magcVPJ2zK77BmqwnjWU+3l56Rkl1R1+wt/jsqKdVQKGOjCkNkn7Q+rpl+ViVD/oatcWQqaLXsk7O2Ax7oY5yOUYzWAXlkR5IuPKCPUz/n5V93jVXgDnTJuzdv9TLcDl96zd0xkD53bLsMcTMkxA7e+o7N7xE3M8FRSl3VjiQRedh03yykB2LJlpk8XMz7KGR1rGS7TA4t92MhTCObwOt8+KVT2k0JFlodmwOaTQGD5x1M56lIzr4fejqn2mjZr2X3WYt2Ga77qKuqClC7sSO2ncHpz+F8P+qoYyBvj5zK6UcaXnN2cJJHyrYDAp7lpmIjTGYzrFNQQExuT9JRSa62E1xHS64DEtKOpCFbrPRLbeSya0nv93WbCPrbzFLJGKAWUFnrSA/rBDMqR4FFf8ceAR402zJVJTT1O3b3v0WEC5zUxWIsERcQOgxV7ymGHami3BDNXxmmo4nn0k6fksX/gi0ZGFjjCRklpVC1I6cbbFjneb5+DIdf6f2V8hOuSD7shgle7ZE/txTvsB+xwbxfnwmhYGYOW4O64ROsJfOzYZvZSV9RtrALkoBkUMbDfrlP5gc+MTOTM5Hax8wX/seOB3eBw7x4Re5TBxeYMcC6rjy7Ss74Ahz7WRud1xfI/g4wI3ljacSWYyDf84Yavl7jsrr/+kcYFNDuHoRk9qIaxdGtLBD0LEvjtozTaZiO5h8+dYApIK5hX65B/k7seSRYS07stXZc90guUcmApmFv6/6RWO3LsC28BpKiaHkpcWq3q8CzmK2j3q/XJKyEs5g12w1Ie1ug2x/152hId/EgP7lOGzbG9OAWOwKURSD6GTrAzTXVltbgEUjJb8F++xZ0neajzjDBVAE0lZblWP4eP2/7zc4okn/LEKJniWp/Ludx+rVPMxylIJ9jPU3XP+tNXywjOi4gwhDjgo3XN8DAnY0xa5l8s1OXHKal0CaIMu9sCw7xNkDqXslAjJ2Om76DSgoyGjKasTCRdAJmKBVkrd4iYUIjaxIduchuw/orJqXJ4ltNpuPemQDjZglEbnMvLA46dLPmTgeP5ywUFtyPZJRGikeMr9pRn2+RDz0MM2ZNArIhaA81KxUGJpVk6/I23iKtpFQSd4ULKvrArtuR4sTbfBjO56cdS3QLYSF/6YiJVULOxr7lF81FufWSG/kGp3+2fGM/f+vFTEmIJqFIQTmpeDKwwzTNGZlGJ7tXvR9I2ZMb8QZsZbLb6MHUK1rh4Hf+MeRGlnSSGNGHYYM7MkMxsO7hIqp8pGHS24483QxqPAOmUzgchDwwqKZ/AcudvsetubxpdfD9y0+Ui85v8y3ebyWDOtigsuMmzWvW+089xPM2Wxmv9uypu4ynUzRqVKadFZkG3oySLcqLa0myY32CPRCWZVvgbritsfQ+6JVyq7DxrkeOKLU91oe/auApk+WheJZ0I7/OLti0NiHhaIJHe1f4fLEju6hPFPS1PE5ZM+IQ65nGhQ3VsOwhe/BkGfRF/CjJAmSdLKCN8b1JM5qGXH0BLdPFl74xDZmrOruPcFT5Qybimcj6wI6M5Dy027n+ZCs/tewvtSSR3yH7PptJSjCtk9lISxaRHOjlbg/DHNmslo2clox+HG7OmEf+dDJVDmj2mWYm5smwryTJst70JVMZgv4fO/bmPl1i7TmM/mbnA94nZzxyDHOzoyAXJDUkrSodg6gqKMyz5SgLlPcuhzYv6V5i8V57+4C4iTyYLW4WD+crhlPDHztcigT4GS9uKA6worMUNOtJBBVQsjf1NJmXHyQpnHZY6ZDjWhZnW5IB5dAym7tUmrCTauOeagshojvUW+9b0JVe8dSFqbtd8JXvyLz7vurFRDWnSBBayhHplZ9XolTtL6qax598RKG8PbWZyB3+FGbHBDZTCJTMPAX/p6BZL4J9hlOMbn8Kf68Ofy8oLIsm4IWktAh3UPSBTxUmzpbhDsoQfJUhRipDTb2swvS6YHlfkjx982gz8utSNhuqNjwnT0pSwW9fuZFb25Otw/MMz7gPbyDM6g3LxIyNCE82PLsw7cDJZ7c/hb9Xh78XqJ9FENMVbXjG4Q6KkLqVocNQhjsoVXjGjxmAYdMqwxst64BCsvHMIDE7A0tfcFJyCc40Hbl3udnvGifC484FbruPhgobrmyXSPV5wHdj7e83rLSiCPbtBRmgbiNI/uxxLgkkb/IIY73PHeojpFznczKorAPv/x05itxCP79fVSjoFpKdGwsbwrXc/SrgJoY5LD6hK8kgKdMukMe6L6+V/rss/cZQ+p2v9LNKSv+dln6jKP3wrtJvGGXr/nLtP8yuePBLw3FB5h9e7h81kST/imz2R8YBf4zqf4pEoNIFvSDZtTncXAFG1hIKfu1tch9HHYsAO3mz3Jf8W3/YPSHnkqIKmDvAyqYTzFwcBgawHZka/dYfXpM+fn5GnwbMTSOrtwiYu0+QK3akduC3/giv37OFMmEu6OM6cv6RxHaGDRlkOIRIqt5v/XE5XI/jejAF45iIBO+L5F9GiJnnW4J4pCPlPb/1h52HZsvQqWioB49Axb+2FDa96R7MoRSpDP+tP67DSY/bTLTkJALyoiLL0Alk5l5BAahIErYguflxhRl39QKUkR0pd7ZcN62nmJOtSniuHWlnCHhe+R3hwjdMljgAN9luSjjjO9J2LMHMfRFQ8e9ITQ0gZ1HhOyO1MAZ1YxVjqVfstF0RkkH+9W+QkaeLzKRJMVWAitLWUlrWVPznGZNt4QZlJNCRpjO/9YfptWYXJQzzVR05KDhCzB5YsHzItr4fOf3KLlk2eEqyrmdwx+m0t7Z4seWTgjO7IanpDjM1XyzgLGErKPlRy3LbDAl/Qfahfi/jLTNuG6w0yQamgYrMsKX0jkwvN5SXU7tlrZV8DRvmcvgacSIGDLCtduQ6MWBuBng89k1BP530otwAX03plvIP9iMxmMyY7lZ+KPyS0dfh8Cuu1ci6MKu5sGDEtGqpHntjbSeT+WrJHWmY/Ou//+sf1/FqOjH6H//v///3//7v/wGZx409"; \ No newline at end of file +window.searchData = "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"; \ No newline at end of file diff --git a/docs/api/classes/application_AnalysisProviderRegistry.AnalysisProviderRegistry.html b/docs/api/classes/application_AnalysisProviderRegistry.AnalysisProviderRegistry.html new file mode 100644 index 000000000..7871c5130 --- /dev/null +++ b/docs/api/classes/application_AnalysisProviderRegistry.AnalysisProviderRegistry.html @@ -0,0 +1,162 @@ +AnalysisProviderRegistry | rea-agents - v1.6.0
+
rea-agents - v1.6.0 + +
    +
    +
    Preparing search index...
    +
    +
    + +
    +

    Discover and select overlapping deep providers without starting their clients. +Registration order never affects selection or caller-visible output.

    +
    +
    +
    +
    +
    Index
    +
    +
    + +
    +
    + +
    +
    + +
    +
    + +
    +
    + +
      +
    • + +
      +

      List the unique deep-operation declarations without probing candidates.

      +
      +

      Returns readonly string[]

    +
    + +
      +
    • + +
      +

      Return the configured default without interpreting it as priority.

      +
      +

      Returns string

    +
    + +
      +
    • + +
      +

      List configured candidate identities in canonical provider-ID order.

      +
      +

      Returns readonly ProviderIdentity[]

    +
    + +
    +
    + +
    +
    + +
    +
    diff --git a/docs/api/classes/application_BinarySession.BinarySession.html b/docs/api/classes/application_BinarySession.BinarySession.html index 8895e2023..f44d026ac 100644 --- a/docs/api/classes/application_BinarySession.BinarySession.html +++ b/docs/api/classes/application_BinarySession.BinarySession.html @@ -22,7 +22,7 @@ of retaining a client whose resources were already shut down.

    +
  • Defined in src/application/BinarySession.ts:81
  • @@ -70,24 +70,24 @@ of retaining a client whose resources were already shut down.

    Returns BinarySession

    +
  • Defined in src/application/BinarySession.ts:107
  • -
    +
  • Defined in src/application/BinarySession.ts:108
  • @@ -102,7 +102,7 @@ of retaining a client whose resources were already shut down.

    Returns BinaryTarget | undefined

    +
  • Defined in src/application/BinarySession.ts:574
  • +
  • Defined in src/application/BinarySession.ts:157
  • +
  • Defined in src/application/BinarySession.ts:476
  • +
  • Defined in src/application/BinarySession.ts:197
  • +
  • Defined in src/application/BinarySession.ts:585
  • +
  • Defined in src/application/BinarySession.ts:214
  • +
  • Defined in src/application/BinarySession.ts:202
  • +
  • Defined in src/application/BinarySession.ts:192
  • +
  • Defined in src/application/BinarySession.ts:239
  • +
  • Defined in src/application/BinarySession.ts:207
  • +
  • Defined in src/application/BinarySession.ts:270
  • +
  • Defined in src/application/BinarySession.ts:281
  • +
  • Defined in src/application/BinarySession.ts:338
  • +
  • Defined in src/application/BinarySession.ts:176
  • Returns Promise<Result<BinaryTarget, AnalysisError>>

    +
  • Defined in src/application/BinarySession.ts:364
  • +
  • Defined in src/application/BinarySession.ts:171
  • +
  • Defined in src/application/BinarySession.ts:126
  • +
  • Defined in src/application/BinarySession.ts:182
  • +
  • Defined in src/application/BinarySession.ts:300
  • +
  • Defined in src/application/BinarySession.ts:292
  • +
  • Defined in src/application/BinarySession.ts:259
  • +
  • Defined in src/application/BinarySession.ts:491
  • +
  • Defined in src/application/BinarySession.ts:312
  • +
  • Defined in src/application/BinarySession.ts:349
  • +
  • Defined in src/application/CompositeProvider.ts:32
  • @@ -63,7 +63,7 @@
    providers: readonly AnalysisProvider[]
    +
  • Defined in src/application/CompositeProvider.ts:32
  • @@ -76,7 +76,7 @@

    Returns readonly CapabilityDescriptor[]

    +
  • Defined in src/application/CompositeProvider.ts:74
  • +
  • Defined in src/application/CompositeProvider.ts:88
  • +
  • Defined in src/application/CompositeProvider.ts:70
  • Returns
        | Promise<Result<AnalysisProfileResolution, AnalysisError>>
        | Promise<Result<{ compatibility: {}; profile: null }, never>>

    +
  • Defined in src/application/CompositeProvider.ts:78
  • diff --git a/docs/api/classes/browser_CdpCaptureEvents.CdpCaptureEvents.html b/docs/api/classes/browser_CdpCaptureEvents.CdpCaptureEvents.html index 906d07e8d..48c069ce0 100644 --- a/docs/api/classes/browser_CdpCaptureEvents.CdpCaptureEvents.html +++ b/docs/api/classes/browser_CdpCaptureEvents.CdpCaptureEvents.html @@ -104,7 +104,7 @@
  • Defined in src/browser/CdpCaptureEvents.ts:52
  • -
    responseMetadata: {
        content_encoding: string | null;
        content_length: number | null;
        csp: {
            directives: {
                name: string;
                sources: {
                    kind:
                        | "other"
                        | "keyword"
                        | "scheme"
                        | "approved_origin"
                        | "external_origin";
                    value: string
                    | null;
                }[];
            }[];
            hash_count: number;
            nonce_count: number;
        };
        links: {
            as: string
            | null;
            crossorigin: string | null;
            destination_scope: "approved" | "outside_policy" | "unsupported";
            href: string | null;
            rel: string[];
            type: string | null;
        }[];
        mime_type: string
        | null;
        policies: {
            coep: string | null;
            coop: string | null;
            corp: string | null;
            permissions_policy_features: string[];
            referrer_policy: string | null;
            x_content_type_options: string | null;
        };
        request_id: string;
        url: string;
    }[] = []
    diff --git a/docs/api/classes/domain_errors.AnalysisCancelledError.html b/docs/api/classes/domain_errors.AnalysisCancelledError.html index 1edce19dc..bc637875d 100644 --- a/docs/api/classes/domain_errors.AnalysisCancelledError.html +++ b/docs/api/classes/domain_errors.AnalysisCancelledError.html @@ -14,7 +14,7 @@

    Caller cancellation won before provider-neutral work completed.

    -
    +

    Hierarchy (View Summary)

    • AnalysisError diff --git a/docs/api/classes/domain_errors.AnalysisCapabilityUnavailableError.html b/docs/api/classes/domain_errors.AnalysisCapabilityUnavailableError.html index 4b19dd6f5..20fa2d80b 100644 --- a/docs/api/classes/domain_errors.AnalysisCapabilityUnavailableError.html +++ b/docs/api/classes/domain_errors.AnalysisCapabilityUnavailableError.html @@ -14,7 +14,7 @@

      Selected provider cannot execute a declared analysis operation.

      -
      +

      Hierarchy (View Summary)

      • AnalysisError diff --git a/docs/api/classes/domain_errors.AnalysisError.html b/docs/api/classes/domain_errors.AnalysisError.html index 7862ea88e..1f318041a 100644 --- a/docs/api/classes/domain_errors.AnalysisError.html +++ b/docs/api/classes/domain_errors.AnalysisError.html @@ -14,7 +14,7 @@

        Base class for expected analysis, provider, and session failures.

        -
        +

        Hierarchy (View Summary)

        • Error diff --git a/docs/api/classes/domain_errors.AnalysisInputError.html b/docs/api/classes/domain_errors.AnalysisInputError.html index f6994dee9..4da195ba7 100644 --- a/docs/api/classes/domain_errors.AnalysisInputError.html +++ b/docs/api/classes/domain_errors.AnalysisInputError.html @@ -14,7 +14,7 @@

          Caller input failed provider-neutral application parsing.

          -
          +

          Hierarchy (View Summary)

          • AnalysisError diff --git a/docs/api/classes/domain_errors.AnalysisOutputError.html b/docs/api/classes/domain_errors.AnalysisOutputError.html index f911a508c..52a2cb23a 100644 --- a/docs/api/classes/domain_errors.AnalysisOutputError.html +++ b/docs/api/classes/domain_errors.AnalysisOutputError.html @@ -14,7 +14,7 @@

            Provider output failed provider-neutral application parsing.

            -
            +

            Hierarchy (View Summary)

            • AnalysisError diff --git a/docs/api/classes/domain_errors.AnalysisProtocolError.html b/docs/api/classes/domain_errors.AnalysisProtocolError.html index 1ebf12b37..78353ba41 100644 --- a/docs/api/classes/domain_errors.AnalysisProtocolError.html +++ b/docs/api/classes/domain_errors.AnalysisProtocolError.html @@ -14,7 +14,7 @@

              Provider-neutral invalid analysis input or output at an application boundary.

              -
              +

              Hierarchy (View Summary)

              • AnalysisError diff --git a/docs/api/classes/domain_errors.AnalysisTimeoutError.html b/docs/api/classes/domain_errors.AnalysisTimeoutError.html index b74f469c7..a8366e3f7 100644 --- a/docs/api/classes/domain_errors.AnalysisTimeoutError.html +++ b/docs/api/classes/domain_errors.AnalysisTimeoutError.html @@ -14,7 +14,7 @@

                Provider-neutral operation exceeded its declared execution deadline.

                -
                +

                Hierarchy (View Summary)

                • AnalysisError diff --git a/docs/api/classes/domain_errors.ArtifactOperationError.html b/docs/api/classes/domain_errors.ArtifactOperationError.html index a5803ea01..e8fd0d683 100644 --- a/docs/api/classes/domain_errors.ArtifactOperationError.html +++ b/docs/api/classes/domain_errors.ArtifactOperationError.html @@ -14,14 +14,14 @@

                  Artifact inventory or extraction failed a typed safety boundary.

                  -
                  +

                  Hierarchy (View Summary)

                  +
                • Defined in src/domain/errors.ts:263
                @@ -60,7 +60,7 @@

                Returns ArtifactOperationError

    +
  • Defined in src/domain/errors.ts:266
  • @@ -69,12 +69,12 @@
    _tag: "ArtifactOperationError"
    +
  • Defined in src/domain/errors.ts:264
  • artifactDetails?: Readonly<
        {
            calculatedSha256: string
            | null;
            declaredSha256: string | null;
            logicalPath: string;
            unpacked: boolean;
        },
    >
    +
  • Defined in src/domain/errors.ts:276
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:267
  • reason:
        | "format"
        | "path"
        | "io"
        | "unavailable"
        | "limit"
        | "cancelled"
        | "integrity"
    +
  • Defined in src/domain/errors.ts:268
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -58,7 +58,7 @@

    Returns BinaryTargetError

    +
  • Defined in src/domain/errors.ts:452
  • @@ -67,7 +67,7 @@
    _tag: "BinaryTargetError"
    +
  • Defined in src/domain/errors.ts:451
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:453
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -59,7 +59,7 @@

    Returns BrowserObservationError

    +
  • Defined in src/domain/errors.ts:245
  • @@ -68,7 +68,7 @@
    _tag: "BrowserObservationError"
    +
  • Defined in src/domain/errors.ts:243
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:246
  • reason:
        | "disconnected"
        | "endpoint_unreachable"
        | "invalid_endpoint_response"
        | "target_not_found"
        | "target_not_allowed"
        | "target_changed"
        | "protocol_error"
        | "payload_limit"
    +
  • Defined in src/domain/errors.ts:247
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -76,7 +76,7 @@
    _tag: "ConfigurationError"
    +
  • Defined in src/domain/errors.ts:436
  • cleanupIncomplete: boolean = false
    @@ -59,7 +59,7 @@

    Returns EvidenceFileError

    +
  • Defined in src/domain/errors.ts:312
  • @@ -68,7 +68,7 @@
    _tag: "EvidenceFileError"
    +
  • Defined in src/domain/errors.ts:310
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:313
  • reason:
        | "io"
        | "disabled"
        | "outside-root"
        | "not-file"
        | "too-large"
        | "exists"
        | "invalid-json"
    +
  • Defined in src/domain/errors.ts:314
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -76,7 +76,7 @@
    _tag: "EvidenceIntegrityError"
    +
  • Defined in src/domain/errors.ts:293
  • cleanupIncomplete: boolean = false
    @@ -58,7 +58,7 @@

    Returns EvidenceLimitError

    +
  • Defined in src/domain/errors.ts:300
  • @@ -67,7 +67,7 @@
    _tag: "EvidenceLimitError"
    +
  • Defined in src/domain/errors.ts:298
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:301
  • maximum: number
    +
  • Defined in src/domain/errors.ts:302
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -51,7 +51,7 @@

    Returns HopperCancelledError

    +
  • Defined in src/domain/errors.ts:382
  • @@ -60,7 +60,7 @@
    _tag: "HopperCancelledError"
    +
  • Defined in src/domain/errors.ts:380
  • cleanupIncomplete: boolean = false
    @@ -57,7 +57,7 @@

    Returns HopperProcessError

    +
  • Defined in src/domain/errors.ts:417
  • @@ -66,7 +66,7 @@
    _tag: "HopperProcessError"
    +
  • Defined in src/domain/errors.ts:413
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:417
  • failureCode: HopperStartupFailureCode | undefined
    +
  • Defined in src/domain/errors.ts:414
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    +
  • Defined in src/domain/errors.ts:415
  • @@ -69,7 +69,7 @@
    _tag: "HopperRemoteError"
    +
  • Defined in src/domain/errors.ts:400
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:403
  • diagnosticType: HopperDiagnosticType = "remote"
    +
  • Defined in src/domain/errors.ts:405
  • safeMessage: string
    +
  • Defined in src/domain/errors.ts:404
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -55,7 +55,7 @@

    Returns HopperStartError

    +
  • Defined in src/domain/errors.ts:429
  • @@ -64,7 +64,7 @@
    _tag: "HopperStartError"
    +
  • Defined in src/domain/errors.ts:427
  • cleanupIncomplete: boolean = false
    @@ -56,7 +56,7 @@

    Returns HopperTimeoutError

    +
  • Defined in src/domain/errors.ts:373
  • @@ -65,7 +65,7 @@
    _tag: "HopperTimeoutError"
    +
  • Defined in src/domain/errors.ts:371
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:373
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -59,7 +59,7 @@

    Returns InvestigationWorkspaceError

    +
  • Defined in src/domain/errors.ts:332
  • @@ -68,7 +68,7 @@
    _tag: "InvestigationWorkspaceError"
    +
  • Defined in src/domain/errors.ts:330
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:333
  • reason:
        | "io"
        | "integrity"
        | "disabled"
        | "outside-root"
        | "not-file"
        | "too-large"
        | "invalid-json"
        | "locked"
        | "revision-conflict"
        | "name-conflict"
    +
  • Defined in src/domain/errors.ts:334
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -51,7 +51,7 @@

    Returns NoBinaryOpenError

    +
  • Defined in src/domain/errors.ts:442
  • @@ -60,7 +60,7 @@
    _tag: "NoBinaryOpenError"
    +
  • Defined in src/domain/errors.ts:441
  • cleanupIncomplete: boolean = false
    @@ -64,7 +64,7 @@

    Returns PermissionRequiredError

    +
  • Defined in src/domain/errors.ts:506
  • @@ -73,12 +73,12 @@
    _tag: "PermissionRequiredError" = ...
    +
  • Defined in src/domain/errors.ts:504
  • ceiling: PermissionScope | null
    +
  • Defined in src/domain/errors.ts:509
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:510
  • +
  • Defined in src/domain/errors.ts:508
  • +
  • Defined in src/domain/errors.ts:507
  • restartRequired: boolean
    +
  • Defined in src/domain/errors.ts:511
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -59,7 +59,7 @@

    Returns ProviderAdapterError

    +
  • Defined in src/domain/errors.ts:219
  • @@ -68,7 +68,7 @@
    _tag: "ProviderAdapterError"
    +
  • Defined in src/domain/errors.ts:217
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:221
  • providerId: string
    +
  • Defined in src/domain/errors.ts:220
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -34,11 +34,15 @@
    @@ -47,16 +51,16 @@

    Returns ProviderSelectionError

    +
  • Defined in src/domain/errors.ts:160
  • @@ -65,7 +69,12 @@
    _tag: "ProviderSelectionError"
    +
  • Defined in src/domain/errors.ts:152
  • +
    + +
    candidateIds: readonly string[]
    cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:153
  • +
    + +
    +
    + +
    rejections: readonly ProviderSelectionRejection[]
    +
    + +
    requestedProviderId: string
    userCategory: "permission_required" | "cancelled" | undefined = undefined
    -
    +
    -
    userMessage: string | undefined = undefined
    +
  • Defined in src/domain/errors.ts:158
  • +
    _tagcandidateIdscleanupIncompletecleanupResourcesoperationreasonrejectionsrequestedProviderIduserCategoryuserMessage
    +
  • Defined in src/domain/errors.ts:355
  • @@ -66,7 +66,7 @@
    _tag: "UnknownRegistryError"
    +
  • Defined in src/domain/errors.ts:353
  • cleanupIncomplete: boolean = false
    +
  • Defined in src/domain/errors.ts:356
  • userCategory: "permission_required" | "cancelled" | undefined = undefined
    @@ -34,6 +34,8 @@
    @@ -52,7 +54,7 @@
  • logger: Logger
  • Returns HopperProvider

    +
  • Defined in src/hopper/HopperProvider.ts:89
  • @@ -63,9 +65,9 @@
    +
  • Defined in src/hopper/HopperProvider.ts:98
  • Returns AnalysisClient

    +
  • Defined in src/hopper/HopperProvider.ts:186
  • +
  • Defined in src/hopper/HopperProvider.ts:94
  • - +
    +
    + +
    +
  • Defined in src/hopper/HopperProvider.ts:132
  • +
    + +
    +
    capabilitiescreateClientidentityinspectAvailabilityinspectTargetSupportresolveAnalysisProfile

    Returns AnalysisExecution

    +
  • Defined in src/application/AnalysisProvider.ts:41
  • diff --git a/docs/api/functions/application_CapabilityInventory.buildCapabilityInventory.html b/docs/api/functions/application_CapabilityInventory.buildCapabilityInventory.html index 5c68afc53..b2effc0dd 100644 --- a/docs/api/functions/application_CapabilityInventory.buildCapabilityInventory.html +++ b/docs/api/functions/application_CapabilityInventory.buildCapabilityInventory.html @@ -14,7 +14,7 @@
    diff --git a/docs/api/functions/application_CompositeProvider.compositeProviderIdentity.html b/docs/api/functions/application_CompositeProvider.compositeProviderIdentity.html new file mode 100644 index 000000000..23e541de9 --- /dev/null +++ b/docs/api/functions/application_CompositeProvider.compositeProviderIdentity.html @@ -0,0 +1,44 @@ +compositeProviderIdentity | rea-agents - v1.6.0
    +
    rea-agents - v1.6.0 + +
      +
      +
      Preparing search index...
      +
      +
      +
      + +

      Function compositeProviderIdentity

      +
      +
      +
      + +
      +
      diff --git a/docs/api/functions/application_DirectAnalysis.runDirectAnalysis.html b/docs/api/functions/application_DirectAnalysis.runDirectAnalysis.html index 0ccf485aa..ac9c93ff0 100644 --- a/docs/api/functions/application_DirectAnalysis.runDirectAnalysis.html +++ b/docs/api/functions/application_DirectAnalysis.runDirectAnalysis.html @@ -14,7 +14,7 @@
      +
    • options: {
          logger?: Logger;
          permissionAuthority?: PermissionAuthority;
          providerId?: string;
          signal?: AbortSignal;
          snapshotPath?: string;
      } = {}
    • Returns Promise<JSONType>

      +
    • Defined in src/application/DirectAnalysis.ts:58
    • +
    • Defined in src/application/DirectAnalysis.ts:85
    • +
    • Defined in src/application/DirectAnalysis.ts:101
    • +
    • Defined in src/application/runtime.ts:15
    • diff --git a/docs/api/functions/browser_CdpObservationSession.observeCdpSession.html b/docs/api/functions/browser_CdpObservationSession.observeCdpSession.html index 08154a937..02b870bcb 100644 --- a/docs/api/functions/browser_CdpObservationSession.observeCdpSession.html +++ b/docs/api/functions/browser_CdpObservationSession.observeCdpSession.html @@ -14,7 +14,7 @@
      diff --git a/docs/api/functions/browser_CdpSafeMetadata.safeResponseMetadata.html b/docs/api/functions/browser_CdpSafeMetadata.safeResponseMetadata.html index 7c07eb630..647ac166f 100644 --- a/docs/api/functions/browser_CdpSafeMetadata.safeResponseMetadata.html +++ b/docs/api/functions/browser_CdpSafeMetadata.safeResponseMetadata.html @@ -14,7 +14,7 @@
      -

      Returns {
          agentHints: {
              declaration: string;
              mechanism:
                  | "link_rel"
                  | "dom_link_rel"
                  | "well_known_resource"
                  | "response_header";
              trust: "page-declared-untrusted";
              url: string
              | null;
          }[];
          response: {
              content_encoding: string
              | null;
              content_length: number | null;
              csp: {
                  directives: {
                      name: string;
                      sources: {
                          kind:
                              | "other"
                              | "keyword"
                              | "scheme"
                              | "approved_origin"
                              | "external_origin";
                          value: string
                          | null;
                      }[];
                  }[];
                  hash_count: number;
                  nonce_count: number;
              };
              links: {
                  as: string
                  | null;
                  crossorigin: string | null;
                  destination_scope: "approved" | "outside_policy" | "unsupported";
                  href: string | null;
                  rel: string[];
                  type: string | null;
              }[];
              mime_type: string
              | null;
              policies: {
                  coep: string | null;
                  coop: string | null;
                  corp: string | null;
                  permissions_policy_features: string[];
                  referrer_policy: string | null;
                  x_content_type_options: string | null;
              };
              request_id: string;
              url: string;
          };
      }

      +
    • Defined in src/config.ts:242
    • +
    • Defined in src/contracts/toolOutputSchemas.ts:42
    • +
    • Defined in src/domain/errors.ts:518
    • diff --git a/docs/api/functions/hopper_HopperAnalysisProfile.hopperLoaderArgsForTarget.html b/docs/api/functions/hopper_HopperAnalysisProfile.hopperLoaderArgsForTarget.html index 2317ea9b4..6f8e4773d 100644 --- a/docs/api/functions/hopper_HopperAnalysisProfile.hopperLoaderArgsForTarget.html +++ b/docs/api/functions/hopper_HopperAnalysisProfile.hopperLoaderArgsForTarget.html @@ -24,7 +24,7 @@
    • target: BinaryTarget
    • Returns Result<readonly string[], ProviderAdapterError>

      +
    • Defined in src/hopper/HopperAnalysisProfile.ts:74
    • +
    • Defined in src/hopper/HopperAnalysisProfile.ts:28
    • +
    • Defined in src/server/promptCompletion.ts:39
    • +
    • Defined in src/server/registerSessionTools.ts:612
    • +
    • StableWebResource
    • +
    • Defined in src/application/AnalysisProvider.ts:68
    • +
    • Defined in src/application/AnalysisProvider.ts:37
    • +
    • Defined in src/application/AnalysisProvider.ts:68
    • +
    • Defined in src/application/AnalysisProvider.ts:93
    • Returns AnalysisClient

      +
    • Defined in src/application/AnalysisProvider.ts:142
    • +
    • Defined in src/application/AnalysisProvider.ts:136
    • Returns Promise<Result<AnalysisProfileResolution, AnalysisError>>

      +
    • Defined in src/application/AnalysisProvider.ts:138
    • +
    • Defined in src/application/AnalysisProvider.ts:17
    • +
    • Defined in src/application/AnalysisProvider.ts:88
    • Returns
          | {
              digest: string;
              parameters: Record<string, JSONType>;
              provider: { id: string; name: string; version: string };
              provider_profile_schema_version: number;
              schema_version: 1;
          }
          | undefined

      +
    • Defined in src/application/BinarySessionPort.ts:87
    • +
    • Defined in src/application/BinarySessionPort.ts:39
    • Returns
          | {
              analysis_profile: {
                  digest: string;
                  parameters: Record<string, JSONType>;
                  provider: { id: string; name: string; version: string };
                  provider_profile_schema_version: number;
                  schema_version: 1;
              };
              authority: | "shipped-artifact"
              | "controlled-replay"
              | "historical-reference"
              | "external-service"
              | "analyst-inference";
              confidence: "observed"
              | "derived"
              | "inferred";
              environment:
                  | {
                      architecture: string;
                      id: string;
                      isolation: "process"
                      | "none"
                      | "container"
                      | "virtual-machine";
                      platform: string;
                  }
                  | null;
              evidence_id: string;
              evidence_links: string[];
              limitations: string[];
              locations: (
                  | { address: string; kind: "address" }
                  | { end: string; kind: "address-range"; start: string }
                  | { kind: "artifact-path"; path: string }
                  | { kind: "file-offset"; offset: number }
                  | { end: number; kind: "file-offset-range"; start: number }
              )[];
              normalized_result: JSONType;
              operation: string;
              parameters: Record<string, JSONType>;
              predicate_type: string;
              provider: { id: string; name: string; version: string | null };
              raw_result: JSONType;
              schema_version: 2;
              subject:
                  | {
                      architecture: "x86"
                      | "x86_64"
                      | "arm"
                      | "arm64"
                      | null;
                      digest: { sha256: string };
                      format:
                          | "unknown"
                          | "file"
                          | "directory"
                          | "javascript"
                          | "source-map"
                          | "plist"
                          | "entitlements"
                          | "dmg"
                          | "zip"
                          | "pkg"
                          | "asar"
                          | "javascript-bundle"
                          | "mach-o-universal"
                          | "mach-o"
                          | "elf"
                          | "pe"
                          | "hopper"
                          | "analysis-database"
                          | "ipa"
                          | "apk";
                      local_path: string;
                      name: string;
                  }
                  | null;
          }
          | {
              authority: | "shipped-artifact"
              | "controlled-replay"
              | "historical-reference"
              | "external-service"
              | "analyst-inference";
              confidence: "observed"
              | "derived"
              | "inferred";
              environment:
                  | {
                      architecture: string;
                      id: string;
                      isolation: "process"
                      | "none"
                      | "container"
                      | "virtual-machine";
                      platform: string;
                  }
                  | null;
              evidence_id: string;
              evidence_links: string[];
              limitations: string[];
              locations: (
                  | { address: string; kind: "address" }
                  | { end: string; kind: "address-range"; start: string }
                  | { kind: "artifact-path"; path: string }
                  | { kind: "file-offset"; offset: number }
                  | { end: number; kind: "file-offset-range"; start: number }
              )[];
              normalized_result: JSONType;
              operation: string;
              parameters: Record<string, JSONType>;
              predicate_type: string;
              provider: { id: string; name: string; version: string | null };
              raw_result: JSONType;
              schema_version: 2;
              subject:
                  | {
                      architecture: "x86"
                      | "x86_64"
                      | "arm"
                      | "arm64"
                      | null;
                      digest: { sha256: string };
                      format:
                          | "unknown"
                          | "file"
                          | "directory"
                          | "javascript"
                          | "source-map"
                          | "plist"
                          | "entitlements"
                          | "dmg"
                          | "zip"
                          | "pkg"
                          | "asar"
                          | "javascript-bundle"
                          | "mach-o-universal"
                          | "mach-o"
                          | "elf"
                          | "pe"
                          | "hopper"
                          | "analysis-database"
                          | "ipa"
                          | "apk";
                      local_path: string;
                      name: string;
                  }
                  | null;
          }
          | undefined

      +
    • Defined in src/application/BinarySessionPort.ts:46
    • +
    • Defined in src/application/AnalysisProvider.ts:68
    • +
    • Defined in src/application/BinarySessionPort.ts:51
    • +
    • Defined in src/application/BinarySessionPort.ts:47
    • Returns boolean

      +
    • Defined in src/application/BinarySessionPort.ts:45
    • Returns Result<number, AnalysisError>

      +
    • Defined in src/application/BinarySessionPort.ts:52
    • Returns Result<number, EvidenceIntegrityError | EvidenceLimitError>

      +
    • Defined in src/application/BinarySessionPort.ts:48
    • Returns
          | {
              bundle: {
                  artifacts: {
                      architecture: "x86"
                      | "x86_64"
                      | "arm"
                      | "arm64"
                      | null;
                      digest: { sha256: string };
                      format:
                          | "unknown"
                          | "file"
                          | "directory"
                          | "javascript"
                          | "source-map"
                          | "plist"
                          | "entitlements"
                          | "dmg"
                          | "zip"
                          | "pkg"
                          | "asar"
                          | "javascript-bundle"
                          | "mach-o-universal"
                          | "mach-o"
                          | "elf"
                          | "pe"
                          | "hopper"
                          | "analysis-database"
                          | "ipa"
                          | "apk";
                  }[];
                  bundle_version: 2;
                  captures: { evidence_id: string; predicate_type: string }[];
                  environments: {
                      architecture: string;
                      id: string;
                      isolation: "process" | "none" | "container" | "virtual-machine";
                      platform: string;
                  }[];
                  providers: { id: string; name: string; version: string
                  | null }[];
                  records: (
                      | {
                          analysis_profile: {
                              digest: string;
                              parameters: Record<string, JSONType>;
                              provider: { id: string; name: string; version: string };
                              provider_profile_schema_version: number;
                              schema_version: 1;
                          };
                          authority: | "shipped-artifact"
                          | "controlled-replay"
                          | "historical-reference"
                          | "external-service"
                          | "analyst-inference";
                          confidence: "observed"
                          | "derived"
                          | "inferred";
                          environment:
                              | {
                                  architecture: string;
                                  id: string;
                                  isolation: "process"
                                  | "none"
                                  | "container"
                                  | "virtual-machine";
                                  platform: string;
                              }
                              | null;
                          evidence_id: string;
                          evidence_links: string[];
                          limitations: string[];
                          locations: (
                              | { address: string; kind: "address" }
                              | { end: string; kind: "address-range"; start: string }
                              | { kind: "artifact-path"; path: string }
                              | { kind: "file-offset"; offset: number }
                              | { end: number; kind: "file-offset-range"; start: number }
                          )[];
                          normalized_result: JSONType;
                          operation: string;
                          parameters: Record<string, JSONType>;
                          predicate_type: string;
                          provider: { id: string; name: string; version: string | null };
                          raw_result: JSONType;
                          schema_version: 2;
                          subject:
                              | {
                                  architecture: "x86"
                                  | "x86_64"
                                  | "arm"
                                  | "arm64"
                                  | null;
                                  digest: { sha256: string };
                                  format:
                                      | "unknown"
                                      | "file"
                                      | "directory"
                                      | "javascript"
                                      | "source-map"
                                      | "plist"
                                      | "entitlements"
                                      | "dmg"
                                      | "zip"
                                      | "pkg"
                                      | "asar"
                                      | "javascript-bundle"
                                      | "mach-o-universal"
                                      | "mach-o"
                                      | "elf"
                                      | "pe"
                                      | "hopper"
                                      | "analysis-database"
                                      | "ipa"
                                      | "apk";
                                  local_path: string;
                                  name: string;
                              }
                              | null;
                      }
                      | {
                          authority: | "shipped-artifact"
                          | "controlled-replay"
                          | "historical-reference"
                          | "external-service"
                          | "analyst-inference";
                          confidence: "observed"
                          | "derived"
                          | "inferred";
                          environment:
                              | {
                                  architecture: string;
                                  id: string;
                                  isolation: "process"
                                  | "none"
                                  | "container"
                                  | "virtual-machine";
                                  platform: string;
                              }
                              | null;
                          evidence_id: string;
                          evidence_links: string[];
                          limitations: string[];
                          locations: (
                              | { address: string; kind: "address" }
                              | { end: string; kind: "address-range"; start: string }
                              | { kind: "artifact-path"; path: string }
                              | { kind: "file-offset"; offset: number }
                              | { end: number; kind: "file-offset-range"; start: number }
                          )[];
                          normalized_result: JSONType;
                          operation: string;
                          parameters: Record<string, JSONType>;
                          predicate_type: string;
                          provider: { id: string; name: string; version: string | null };
                          raw_result: JSONType;
                          schema_version: 2;
                          subject:
                              | {
                                  architecture: "x86"
                                  | "x86_64"
                                  | "arm"
                                  | "arm64"
                                  | null;
                                  digest: { sha256: string };
                                  format:
                                      | "unknown"
                                      | "file"
                                      | "directory"
                                      | "javascript"
                                      | "source-map"
                                      | "plist"
                                      | "entitlements"
                                      | "dmg"
                                      | "zip"
                                      | "pkg"
                                      | "asar"
                                      | "javascript-bundle"
                                      | "mach-o-universal"
                                      | "mach-o"
                                      | "elf"
                                      | "pe"
                                      | "hopper"
                                      | "analysis-database"
                                      | "ipa"
                                      | "apk";
                                  local_path: string;
                                  name: string;
                              }
                              | null;
                      }
                  )[];
                  scenarios: {
                      authority: "controlled-replay";
                      evidence_id: string;
                      operation: string;
                  }[];
                  unknowns: {
                      contradicting_evidence_ids: string[];
                      domain: string;
                      mutation_evidence_ids: string[];
                      previous_revision_digest: string
                      | null;
                      question: string;
                      recommended_probes: { operation: string; rationale: string }[];
                      registry_version: 1;
                      relationships: {
                          type: "depends-on" | "related-to" | "contradicts";
                          unknown_id: string;
                      }[];
                      required_authority: | "shipped-artifact"
                      | "controlled-replay"
                      | "historical-reference"
                      | "external-service"
                      | "analyst-inference"
                      | null;
                      required_confidence: "observed"
                      | "derived"
                      | "inferred";
                      required_environment:
                          | {
                              architecture: string
                              | null;
                              id: string | null;
                              isolation: "process" | "none" | "container" | "virtual-machine" | null;
                              platform: string | null;
                          }
                          | null;
                      resolution: | {
                          disposition: "verified";
                          evidence_ids: string[];
                          rationale: string;
                      }
                      | {
                          disposition: "withdrawn"
                          | "out-of-scope";
                          evidence_ids: string[];
                          rationale: string;
                      }
                      | null;
                      revision: number;
                      revision_digest: string;
                      scope_digest: string
                      | null;
                      severity: "low" | "medium" | "high" | "critical";
                      status:
                          | "open"
                          | "investigating"
                          | "blocked"
                          | "contradicted"
                          | "resolved";
                      supporting_evidence_ids: string[];
                      unknown_id: string;
                  }[];
              };
              name: string;
              previous_revision_digest: string
              | null;
              revision: number;
              revision_digest: string;
              runs: (
                  | {
                      comparison_evidence_id: string
                      | null;
                      completed_stages: (
                          | "inventory_left"
                          | "inventory_right"
                          | "compare_artifacts"
                          | "find_changed_behavior"
                      )[];
                      integrity_continue_approved: boolean;
                      integrity_policy: "fail"
                      | "record-and-continue";
                      left: {
                          format:
                              | "unknown"
                              | "file"
                              | "directory"
                              | "javascript"
                              | "source-map"
                              | "plist"
                              | "entitlements"
                              | "dmg"
                              | "zip"
                              | "pkg"
                              | "asar"
                              | "javascript-bundle"
                              | "mach-o-universal"
                              | "mach-o"
                              | "elf"
                              | "pe"
                              | "hopper"
                              | "analysis-database"
                              | "ipa"
                              | "apk";
                          graph_sha256: string;
                          manifest_id: string;
                          root_sha256: string;
                      };
                      left_inventory_evidence_ids: string[];
                      limitations: string[];
                      max_integrity_mismatches: number;
                      options: {
                          change_limit: number;
                          max_compression_ratio: number;
                          max_depth: number;
                          max_entries: number;
                          max_entry_bytes: number;
                          max_path_bytes: number;
                          max_total_bytes: number;
                          page_size: number;
                      };
                      request_sha256: string;
                      result_evidence_id: string
                      | null;
                      right: {
                          format:
                              | "unknown"
                              | "file"
                              | "directory"
                              | "javascript"
                              | "source-map"
                              | "plist"
                              | "entitlements"
                              | "dmg"
                              | "zip"
                              | "pkg"
                              | "asar"
                              | "javascript-bundle"
                              | "mach-o-universal"
                              | "mach-o"
                              | "elf"
                              | "pe"
                              | "hopper"
                              | "analysis-database"
                              | "ipa"
                              | "apk";
                          graph_sha256: string;
                          manifest_id: string;
                          root_sha256: string;
                      };
                      right_inventory_evidence_ids: string[];
                      run_id: string;
                      schema_version: 1;
                      status: "complete"
                      | "running";
                  }
                  | {
                      comparison_evidence_id: string
                      | null;
                      completed_stages: (
                          | "inventory_left"
                          | "inventory_right"
                          | "compare_artifacts"
                          | "find_changed_behavior"
                      )[];
                      integrity_continue_approved: boolean;
                      integrity_policy: "fail"
                      | "record-and-continue";
                      left: {
                          format:
                              | "unknown"
                              | "file"
                              | "directory"
                              | "javascript"
                              | "source-map"
                              | "plist"
                              | "entitlements"
                              | "dmg"
                              | "zip"
                              | "pkg"
                              | "asar"
                              | "javascript-bundle"
                              | "mach-o-universal"
                              | "mach-o"
                              | "elf"
                              | "pe"
                              | "hopper"
                              | "analysis-database"
                              | "ipa"
                              | "apk";
                          graph_sha256: string;
                          manifest_id: string;
                          root_sha256: string;
                      };
                      left_inventory_evidence_ids: string[];
                      legacy_request_identity: true;
                      limitations: string[];
                      max_integrity_mismatches: number;
                      options: {
                          change_limit: number;
                          max_compression_ratio: number;
                          max_depth: number;
                          max_entries: number;
                          max_entry_bytes: number;
                          max_path_bytes: number;
                          max_total_bytes: number;
                          page_size: number;
                      };
                      request_sha256: string;
                      result_evidence_id: string
                      | null;
                      right: {
                          format:
                              | "unknown"
                              | "file"
                              | "directory"
                              | "javascript"
                              | "source-map"
                              | "plist"
                              | "entitlements"
                              | "dmg"
                              | "zip"
                              | "pkg"
                              | "asar"
                              | "javascript-bundle"
                              | "mach-o-universal"
                              | "mach-o"
                              | "elf"
                              | "pe"
                              | "hopper"
                              | "analysis-database"
                              | "ipa"
                              | "apk";
                          graph_sha256: string;
                          manifest_id: string;
                          root_sha256: string;
                      };
                      right_inventory_evidence_ids: string[];
                      run_id: string;
                      schema_version: 1;
                      status: "complete"
                      | "running";
                  }
              )[];
              workspace_id: string;
              workspace_version: 1;
          }
          | undefined

      +
    • Defined in src/application/BinarySessionPort.ts:58
    • +
    • Defined in src/application/BinarySessionPort.ts:62
    • Returns {
          contradicting_evidence_ids: string[];
          domain: string;
          mutation_evidence_ids: string[];
          previous_revision_digest: string | null;
          question: string;
          recommended_probes: { operation: string; rationale: string }[];
          registry_version: 1;
          relationships: {
              type: "depends-on" | "related-to" | "contradicts";
              unknown_id: string;
          }[];
          required_authority: | "shipped-artifact"
          | "controlled-replay"
          | "historical-reference"
          | "external-service"
          | "analyst-inference"
          | null;
          required_confidence: "observed"
          | "derived"
          | "inferred";
          required_environment:
              | {
                  architecture: string
                  | null;
                  id: string | null;
                  isolation: "process" | "none" | "container" | "virtual-machine" | null;
                  platform: string | null;
              }
              | null;
          resolution: | {
              disposition: "verified";
              evidence_ids: string[];
              rationale: string;
          }
          | {
              disposition: "withdrawn"
              | "out-of-scope";
              evidence_ids: string[];
              rationale: string;
          }
          | null;
          revision: number;
          revision_digest: string;
          scope_digest: string
          | null;
          severity: "low" | "medium" | "high" | "critical";
          status: "open" | "investigating" | "blocked" | "contradicted" | "resolved";
          supporting_evidence_ids: string[];
          unknown_id: string;
      }[]

      +
    • Defined in src/application/BinarySessionPort.ts:73
    • Returns () => void

      +
    • Defined in src/application/BinarySessionPort.ts:91
    • Returns Promise<Result<BinaryTarget, AnalysisError>>

      +
    • Defined in src/application/BinarySessionPort.ts:30
    • +
    • Defined in src/application/BinarySessionPort.ts:90
    • Returns ProviderIdentity

      +
    • Defined in src/application/BinarySessionPort.ts:86
    • Returns Result<"added" | "duplicate", EvidenceIntegrityError | EvidenceLimitError>

      +
    • Defined in src/application/BinarySessionPort.ts:42
    • Returns Result<
          | {
              contradicting_evidence_ids: string[];
              domain: string;
              mutation_evidence_ids: string[];
              previous_revision_digest: string
              | null;
              question: string;
              recommended_probes: { operation: string; rationale: string }[];
              registry_version: 1;
              relationships: {
                  type: "depends-on" | "related-to" | "contradicts";
                  unknown_id: string;
              }[];
              required_authority: | "shipped-artifact"
              | "controlled-replay"
              | "historical-reference"
              | "external-service"
              | "analyst-inference"
              | null;
              required_confidence: "observed"
              | "derived"
              | "inferred";
              required_environment:
                  | {
                      architecture: string
                      | null;
                      id: string | null;
                      isolation: "process" | "none" | "container" | "virtual-machine" | null;
                      platform: string | null;
                  }
                  | null;
              resolution: | {
                  disposition: "verified";
                  evidence_ids: string[];
                  rationale: string;
              }
              | {
                  disposition: "withdrawn"
                  | "out-of-scope";
                  evidence_ids: string[];
                  rationale: string;
              }
              | null;
              revision: number;
              revision_digest: string;
              scope_digest: string
              | null;
              severity: "low" | "medium" | "high" | "critical";
              status: "open" | "investigating" | "blocked" | "contradicted" | "resolved";
              supporting_evidence_ids: string[];
              unknown_id: string;
          }
          | null,
          AnalysisError,
      >

      +
    • Defined in src/application/BinarySessionPort.ts:66
    • Returns Result<
          {
              contradicting_evidence_ids: string[];
              domain: string;
              mutation_evidence_ids: string[];
              previous_revision_digest: string
              | null;
              question: string;
              recommended_probes: { operation: string; rationale: string }[];
              registry_version: 1;
              relationships: {
                  type: "depends-on" | "related-to" | "contradicts";
                  unknown_id: string;
              }[];
              required_authority: | "shipped-artifact"
              | "controlled-replay"
              | "historical-reference"
              | "external-service"
              | "analyst-inference"
              | null;
              required_confidence: "observed"
              | "derived"
              | "inferred";
              required_environment:
                  | {
                      architecture: string
                      | null;
                      id: string | null;
                      isolation: "process" | "none" | "container" | "virtual-machine" | null;
                      platform: string | null;
                  }
                  | null;
              resolution: | {
                  disposition: "verified";
                  evidence_ids: string[];
                  rationale: string;
              }
              | {
                  disposition: "withdrawn"
                  | "out-of-scope";
                  evidence_ids: string[];
                  rationale: string;
              }
              | null;
              revision: number;
              revision_digest: string;
              scope_digest: string
              | null;
              severity: "low" | "medium" | "high" | "critical";
              status: "open" | "investigating" | "blocked" | "contradicted" | "resolved";
              supporting_evidence_ids: string[];
              unknown_id: string;
          },
          AnalysisError,
      >

      +
    • Defined in src/application/BinarySessionPort.ts:63
    • Returns "added" | "duplicate"

      +
    • Defined in src/application/BinarySessionPort.ts:55
    • +
    • Defined in src/application/BinarySessionPort.ts:40
    • Returns Result<
          {
              contradicting_evidence_ids: string[];
              domain: string;
              mutation_evidence_ids: string[];
              previous_revision_digest: string
              | null;
              question: string;
              recommended_probes: { operation: string; rationale: string }[];
              registry_version: 1;
              relationships: {
                  type: "depends-on" | "related-to" | "contradicts";
                  unknown_id: string;
              }[];
              required_authority: | "shipped-artifact"
              | "controlled-replay"
              | "historical-reference"
              | "external-service"
              | "analyst-inference"
              | null;
              required_confidence: "observed"
              | "derived"
              | "inferred";
              required_environment:
                  | {
                      architecture: string
                      | null;
                      id: string | null;
                      isolation: "process" | "none" | "container" | "virtual-machine" | null;
                      platform: string | null;
                  }
                  | null;
              resolution: | {
                  disposition: "verified";
                  evidence_ids: string[];
                  rationale: string;
              }
              | {
                  disposition: "withdrawn"
                  | "out-of-scope";
                  evidence_ids: string[];
                  rationale: string;
              }
              | null;
              revision: number;
              revision_digest: string;
              scope_digest: string
              | null;
              severity: "low" | "medium" | "high" | "critical";
              status: "open" | "investigating" | "blocked" | "contradicted" | "resolved";
              supporting_evidence_ids: string[];
              unknown_id: string;
          },
          AnalysisError,
      >

      +
    • Defined in src/application/BinarySessionPort.ts:70
    • Returns Result<
          {
              truthVerified: boolean;
              unknown: {
                  contradicting_evidence_ids: string[];
                  domain: string;
                  mutation_evidence_ids: string[];
                  previous_revision_digest: string
                  | null;
                  question: string;
                  recommended_probes: { operation: string; rationale: string }[];
                  registry_version: 1;
                  relationships: {
                      type: "depends-on" | "related-to" | "contradicts";
                      unknown_id: string;
                  }[];
                  required_authority: | "shipped-artifact"
                  | "controlled-replay"
                  | "historical-reference"
                  | "external-service"
                  | "analyst-inference"
                  | null;
                  required_confidence: "observed"
                  | "derived"
                  | "inferred";
                  required_environment:
                      | {
                          architecture: string
                          | null;
                          id: string | null;
                          isolation: "process" | "none" | "container" | "virtual-machine" | null;
                          platform: string | null;
                      }
                      | null;
                  resolution: | {
                      disposition: "verified";
                      evidence_ids: string[];
                      rationale: string;
                  }
                  | {
                      disposition: "withdrawn"
                      | "out-of-scope";
                      evidence_ids: string[];
                      rationale: string;
                  }
                  | null;
                  revision: number;
                  revision_digest: string;
                  scope_digest: string
                  | null;
                  severity: "low" | "medium" | "high" | "critical";
                  status:
                      | "open"
                      | "investigating"
                      | "blocked"
                      | "contradicted"
                      | "resolved";
                  supporting_evidence_ids: string[];
                  unknown_id: string;
              };
              valid: boolean;
          },
          UnknownRegistryError,
      >

      +
    • Defined in src/application/BinarySessionPort.ts:78
    • @@ -122,14 +122,14 @@
      @@ -150,14 +150,14 @@
      diff --git a/docs/api/interfaces/application_SessionProviderRouter.SessionProviderRoute.html b/docs/api/interfaces/application_SessionProviderRouter.SessionProviderRoute.html new file mode 100644 index 000000000..6feb98c05 --- /dev/null +++ b/docs/api/interfaces/application_SessionProviderRouter.SessionProviderRoute.html @@ -0,0 +1,110 @@ +SessionProviderRoute | rea-agents - v1.6.0
      +
      rea-agents - v1.6.0 + +
        +
        +
        Preparing search index...
        +
        +
        +
        + +

        Interface SessionProviderRoute

        +
        +

        Immutable operation routes and binding metadata for one target transition.

        +
        +
        interface SessionProviderRoute {
            binding: AnalysisProviderBinding | null;
            capabilities: ReadonlyMap<string, CapabilityDescriptor> | undefined;
            compatibility: Readonly<Record<string, JsonValue>>;
            identity: ProviderIdentity;
            profile:
                | {
                    digest: string;
                    parameters: Record<string, JSONType>;
                    provider: { id: string; name: string; version: string };
                    provider_profile_schema_version: number;
                    schema_version: 1;
                }
                | null;
            selection: AnalysisProviderSelection
            | undefined;
            createClient(target: BinaryTarget): AnalysisClient;
        }
        +
        +
        +
        +
        Index
        +
        +
        + +
        +
        + +
        binding: AnalysisProviderBinding | null
        +
        + +
        capabilities: ReadonlyMap<string, CapabilityDescriptor> | undefined
        +
        + +
        compatibility: Readonly<Record<string, JsonValue>>
        +
        + +
        +
        + +
        profile:
            | {
                digest: string;
                parameters: Record<string, JSONType>;
                provider: { id: string; name: string; version: string };
                provider_profile_schema_version: number;
                schema_version: 1;
            }
            | null
        +
        + +
        selection: AnalysisProviderSelection | undefined
        +
        + +
        +
        + +
        +
        + +
        +
        diff --git a/docs/api/interfaces/application_Setup.SetupHost.html b/docs/api/interfaces/application_Setup.SetupHost.html index 6cf237b71..d199af5d2 100644 --- a/docs/api/interfaces/application_Setup.SetupHost.html +++ b/docs/api/interfaces/application_Setup.SetupHost.html @@ -16,7 +16,7 @@ Implementations report interrupted installers as values: setup must not wait indefinitely for stdin or a GUI response in an unattended agent invocation.

        -
        interface SetupHost {
            nodeVersion: string;
            platform: Platform;
            clientNeedsConfigure(
                client: SetupClient,
                hopperPath: string | undefined,
                command: readonly string[],
            ): Promise<boolean>;
            configureClient(
                client: SetupClient,
                hopperPath: string | undefined,
                command: readonly string[],
            ): Promise<ClientConfigurationResult>;
            detectedClients(): Promise<readonly SetupClient[]>;
            doctor(): Promise<
                {
                    checks: readonly DoctorCheck[];
                    healthy: boolean;
                    hopperPath?: string;
                    identity?: {
                        catalog: {
                            counts: {
                                cli_commands: number;
                                mcp_prompts: number;
                                mcp_resource_templates: 7;
                                mcp_resources: 2;
                                mcp_tools: number;
                            };
                            digests: {
                                combined_sha256: string;
                                prompts_sha256: string;
                                resources_sha256: string;
                                tools_sha256: string;
                            };
                            tools: {
                                annotations: {
                                    destructive: boolean;
                                    idempotent: boolean;
                                    open_world: boolean;
                                    read_only: boolean;
                                };
                                name: | "list_browser_targets"
                                | "inspect_web_page"
                                | "analyze_web_bundle"
                                | "observe_web_session"
                                | "discover_webmcp_tools"
                                | "compare_web_captures"
                                | "capture_web_screenshot"
                                | "compare_web_screenshots"
                                | "list_electron_targets"
                                | "inspect_electron_page"
                                | "inventory_artifact"
                                | "extract_artifact"
                                | "swift_classes"
                                | "get_objc_classes"
                                | "get_objc_protocols"
                                | "batch_decompile"
                                | "get_call_graph"
                                | "analyze_swift_types"
                                | "find_xrefs_to_name"
                                | "binary_overview"
                                | "analyze_function"
                                | "trace_feature"
                                | "comment"
                                | "compare_artifacts"
                                | "find_changed_behavior"
                                | "compare_process_captures"
                                | "compare_functions"
                                | "capture_process_scenario"
                                | "address_name"
                                | "current_address"
                                | "current_procedure"
                                | "current_document"
                                | "goto_address"
                                | "inline_comment"
                                | "list_bookmarks"
                                | "list_documents"
                                | "list_names"
                                | "list_procedures"
                                | "list_segments"
                                | "list_strings"
                                | "next_address"
                                | "prev_address"
                                | "procedure_address"
                                | "procedure_assembly"
                                | "procedure_callees"
                                | "procedure_callers"
                                | "procedure_info"
                                | "procedure_references"
                                | "procedure_pseudo_code"
                                | "resolve_containing_procedure"
                                | "search_procedures"
                                | "search_strings"
                                | "set_address_name"
                                | "set_addresses_names"
                                | "set_bookmark"
                                | "set_comment"
                                | "set_current_document"
                                | "set_inline_comment"
                                | "unset_bookmark"
                                | "xrefs"
                                | "inspect_macho"
                                | "inspect_signature"
                                | "inspect_plist"
                                | "list_architectures"
                                | "demangle_swift"
                                | "open_binary"
                                | "close_binary"
                                | "binary_session"
                                | "export_evidence_bundle"
                                | "import_evidence_bundle"
                                | "compare_bundles"
                                | "build_call_path"
                                | "correlate_static_and_runtime"
                                | "verify_reconstruction"
                                | "list_unknowns"
                                | "record_unknown"
                                | "update_unknown"
                                | "verify_unknown_resolution";
                                surface: ToolKind;
                            }[];
                        };
                        cli_package_version: string;
                        expected_skill_version: string;
                        installations: {
                            paths: readonly string[];
                            state: "unknown"
                            | "single"
                            | "multiple";
                        };
                        live_server: { remediation: string; state: "unknown" };
                        registrations: readonly ClientRegistrationStatus[];
                        sdk: {
                            client_test: "2.0.0-beta.4";
                            core: "2.0.0-beta.4";
                            server: "2.0.0-beta.4";
                        };
                        skill: {
                            installed_version: string
                            | null;
                            remediation: string | null;
                            state: "unknown" | "aligned" | "stale";
                        };
                    };
                },
            >;
            hopperPath(): Promise<string | undefined>;
            installHopper(replaceExisting: boolean): Promise<SetupHopperInstallResult>;
            installSkill(): Promise<"failed" | "unchanged" | "installed">;
            linuxDistribution(): Promise<LinuxDistribution | undefined>;
            macosVersion(): Promise<string | undefined>;
            skillNeedsInstall(): Promise<boolean>;
        }
        artifactIntegrityContinueEnabled: boolean
        +
      • Defined in src/config.ts:40
      • artifactNativeMountEnabled: boolean
        +
      • Defined in src/config.ts:39
      • browserAllowedOrigins: readonly string[]
        +
      • Defined in src/config.ts:47
      • browserCdpEndpoints: readonly string[]
        +
      • Defined in src/config.ts:46
      • browserObservationEnabled: boolean
        +
      • Defined in src/config.ts:45
      • electronCdpEndpoints: readonly string[]
        +
      • Defined in src/config.ts:49
      • electronFileRoots: readonly string[]
        +
      • Defined in src/config.ts:50
      • electronObservationEnabled: boolean
        +
      • Defined in src/config.ts:48
      • evidenceFilePolicy: EvidenceFilePolicy
        +
      • Defined in src/config.ts:41
      • hopperLauncherPath: string
        +
      • Defined in src/config.ts:33
      • hopperLoaderArgs: readonly string[]
        +
      • Defined in src/config.ts:36
      • hopperTargetKind: "executable" | "database"
        +
      • Defined in src/config.ts:35
      • hopperTargetPath: string | undefined
        +
      • Defined in src/config.ts:34
      • investigationInputRoots: readonly string[]
        +
      • Defined in src/config.ts:42
      • logLevel: "error" | "trace" | "debug" | "info" | "warn" | "fatal" | "silent"
        +
      • Defined in src/config.ts:37
      • permissionCeilings: readonly PermissionScope[]
        +
      • Defined in src/config.ts:51
      • permissionProjectRoot: string | undefined
        +
      • Defined in src/config.ts:53
      • permissionProjectStore: string | undefined
        +
      • Defined in src/config.ts:54
      • processExecutionPolicy: ProcessExecutionPolicy
        +
      • Defined in src/config.ts:38
      • referenceSourcePolicy: ReferenceSourcePolicy
        +
      • Defined in src/config.ts:44
      • -
        interface AnalysisErrorProjection {
            category:
                | "truncated"
                | "timeout"
                | "unavailable"
                | "permission_required"
                | "cancelled"
                | "execution_failure"
                | "invalid_input"
                | "unsupported_provider"
                | "integrity_mismatch";
            code: | "truncated"
            | "permission_required"
            | "cancelled"
            | "invalid_request"
            | "unreadable_output"
            | "capability_unavailable"
            | "provider_unavailable"
            | "provider_timeout"
            | "artifact_integrity_mismatch"
            | "artifact_operation_failed"
            | "evidence_integrity_mismatch"
            | "process_capture_failed"
            | "cleanup_incomplete"
            | "revision_conflict"
            | "outside_approved_root"
            | "configuration_invalid"
            | "target_unavailable"
            | "execution_failure";
            details?: Readonly<Record<string, JSONType>>;
            message: string;
            remediation: Readonly<
                {
                    action: string;
                    elicitation_supported?: boolean;
                    restart_required: boolean;
                },
            >;
            retryable: boolean;
            readonly [key: string]: JSONType;
        }
        -
        +
        interface AnalysisErrorProjection {
            category:
                | "truncated"
                | "timeout"
                | "unavailable"
                | "permission_required"
                | "cancelled"
                | "execution_failure"
                | "invalid_input"
                | "unsupported_provider"
                | "integrity_mismatch";
            code: | "truncated"
            | "permission_required"
            | "cancelled"
            | "provider_unavailable"
            | "invalid_request"
            | "unreadable_output"
            | "capability_unavailable"
            | "provider_timeout"
            | "artifact_integrity_mismatch"
            | "artifact_operation_failed"
            | "evidence_integrity_mismatch"
            | "process_capture_failed"
            | "cleanup_incomplete"
            | "revision_conflict"
            | "outside_approved_root"
            | "configuration_invalid"
            | "target_unavailable"
            | "execution_failure";
            details?: Readonly<Record<string, JSONType>>;
            message: string;
            remediation: Readonly<
                {
                    action: string;
                    elicitation_supported?: boolean;
                    restart_required: boolean;
                },
            >;
            retryable: boolean;
            readonly [key: string]: JSONType;
        }
        +

        Hierarchy

        +
      • Defined in src/domain/errors.ts:461
      • @@ -46,32 +46,32 @@
        category:
            | "truncated"
            | "timeout"
            | "unavailable"
            | "permission_required"
            | "cancelled"
            | "execution_failure"
            | "invalid_input"
            | "unsupported_provider"
            | "integrity_mismatch"
        +
      • Defined in src/domain/errors.ts:482
      • -
        code:
            | "truncated"
            | "permission_required"
            | "cancelled"
            | "invalid_request"
            | "unreadable_output"
            | "capability_unavailable"
            | "provider_unavailable"
            | "provider_timeout"
            | "artifact_integrity_mismatch"
            | "artifact_operation_failed"
            | "evidence_integrity_mismatch"
            | "process_capture_failed"
            | "cleanup_incomplete"
            | "revision_conflict"
            | "outside_approved_root"
            | "configuration_invalid"
            | "target_unavailable"
            | "execution_failure"
        +
      • Defined in src/domain/errors.ts:463
      • details?: Readonly<Record<string, JSONType>>
        +
      • Defined in src/domain/errors.ts:499
      • message: string
        +
      • Defined in src/domain/errors.ts:492
      • remediation: Readonly<
            {
                action: string;
                elicitation_supported?: boolean;
                restart_required: boolean;
            },
        >
        +
      • Defined in src/domain/errors.ts:494
      • retryable: boolean
        +
      • Defined in src/domain/errors.ts:493
      • interface WebInventoryResourceInput {
            content_size: number | null;
            mime_type: string;
            origin: string | null;
            type: string;
            url: string;
        }
        -
        +

        Hierarchy (View Summary)

        • WebInventoryResourceInput diff --git a/docs/api/interfaces/server_promptCompletion.PromptCompletionSource.html b/docs/api/interfaces/server_promptCompletion.PromptCompletionSource.html index 820157ff9..52438e7cd 100644 --- a/docs/api/interfaces/server_promptCompletion.PromptCompletionSource.html +++ b/docs/api/interfaces/server_promptCompletion.PromptCompletionSource.html @@ -16,7 +16,7 @@
        interface PromptCompletionSource {
            complete(
                kind: PromptCompletionKind,
                value: string,
                context?: CompletionContext,
            ): Promise<readonly string[]>;
        }
        +
      • Defined in src/server/promptCompletion.ts:30
      • @@ -43,7 +43,7 @@
      • Optionalcontext: CompletionContext
      • Returns Promise<readonly string[]>

        +
      • Defined in src/server/promptCompletion.ts:31
      • +
      • Defined in src/server/registerSessionTools.ts:601
      • @@ -31,9 +31,9 @@

        On This Page

        -
        CompositeProvider
        +
        CompositeProvider
        +
        +
        compositeProviderIdentity

        Returns AnalysisClient

        +
      • Defined in src/application/AnalysisProvider.ts:80
      • +
      • Defined in src/application/AnalysisProvider.ts:122
      • +
      • Defined in src/domain/errors.ts:392
      • +
      • Defined in src/contracts/sessionLifecycleInputs.ts:5