From b7a7cc01d4d0e874e10464c686b7fdeecd9b348c Mon Sep 17 00:00:00 2001 From: Agent Control Runner Date: Thu, 15 Oct 2026 20:33:19 +0900 Subject: [PATCH] =?UTF-8?q?P18-01-CODE:=20=E5=8E=9F=E6=9C=AC=E9=96=A2?= =?UTF-8?q?=E4=BF=82=E3=83=A2=E3=83=87=E3=83=AB=E3=83=BB=E6=97=A7=E5=80=A4?= =?UTF-8?q?=E4=BF=9D=E5=85=A8=E3=83=BBRuntime=E4=BF=9D=E5=AD=98=E3=81=A8?= =?UTF-8?q?=E8=AA=AD=E5=8F=96=E7=B5=8C=E8=B7=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- autoload/simulation_runtime.gd | 14 +- .../completion_marker_contracts.json | 4 +- .../execution/p18-01-code/IMPLEMENTATION.md | 245 ++- .../p18-01-code/inspect_repair5_inputs.py | 94 + .../p18-01-code/repair-4-prepare.json | 1 + .../p18-01-code/repair-5-input-evidence.json | 158 ++ .../p18-01-code/repair-5-prepare.json | 22 + .../p18-01-code/repair-5-start-shas.json | 11 + scripts/relationship/relationship_service.gd | 13 +- tests/s4/test_original_relationship_model.gd | 43 + .../s4/test_original_relationship_runtime.gd | 1535 +++++++++++++++++ tools/regression/suite-policy.json | 4 +- tools/run_p18_relationship_tests.py | 17 +- 13 files changed, 2132 insertions(+), 29 deletions(-) create mode 100644 docs/plans/original-completion-2026-10-02/execution/p18-01-code/inspect_repair5_inputs.py create mode 100644 docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-4-prepare.json create mode 100644 docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-input-evidence.json create mode 100644 docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-prepare.json create mode 100644 docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-start-shas.json diff --git a/autoload/simulation_runtime.gd b/autoload/simulation_runtime.gd index 27bb139..82fa152 100644 --- a/autoload/simulation_runtime.gd +++ b/autoload/simulation_runtime.gd @@ -1056,14 +1056,10 @@ func _restore_snapshot_internal(snapshot: Dictionary, recovery_mode: bool) -> bo return false var restored_relationships := RelationshipService.new() restored_relationships.configure_original_identity_validator( - func(payload: Dictionary) -> bool: return _original_relationship_identities_valid(payload, restored_staff) + func(payload: Dictionary) -> bool: return _original_relationship_identities_valid(payload, restored_staff, restored_catalog) ) if not restored_relationships.restore_snapshot(runtime_data[&"relationships"]): return false - for relationship: RelationshipState in restored_relationships.get_relationships(): - for actor_id: StringName in [relationship.actor_a_id, relationship.actor_b_id]: - if actor_id != &"player" and not restored_staff.has_staff(actor_id) and not restored_guests.has_guest(actor_id): - return false var restored_events := EventService.new() for raw_definition: Variant in runtime_data[&"event_definitions"]: var definition := EventDefinition.from_variant(raw_definition) @@ -5387,7 +5383,7 @@ func _configure_relationship_event_boundaries() -> void: if relationship_service == null or event_service == null: return relationship_service.configure_original_identity_validator( - func(payload: Dictionary) -> bool: return _original_relationship_identities_valid(payload, staff_service) + func(payload: Dictionary) -> bool: return _original_relationship_identities_valid(payload, staff_service, mvp_content_catalog) ) relationship_service.configure_candidate_callback( Callable(self, "_on_relationship_threshold_candidate") @@ -6770,15 +6766,15 @@ func _execute_progress_staff_task(command: SimulationCommand) -> CommandResult: result.command_id = command.command_id return result -func _original_relationship_identities_valid(payload: Dictionary, staff_registry: StaffService) -> bool: +func _original_relationship_identities_valid(payload: Dictionary, staff_registry: StaffService, catalog: MvpContentCatalog) -> bool: if payload.get("protagonist_id") != "player" or staff_registry == null: return false var subject := StringName(payload.get("subject_id", "")) var rival := StringName(payload.get("rival_id", "")) if subject == &"player" or rival == &"player" or subject == rival or not staff_registry.has_staff(subject): return false - var heroine_definition := mvp_content_catalog.get_entry(&"unique_characters", subject) - var rival_definition := mvp_content_catalog.get_entry(&"unique_characters", rival) + var heroine_definition := catalog.get_entry(&"unique_characters", subject) + var rival_definition := catalog.get_entry(&"unique_characters", rival) var subject_staff := staff_registry.get_staff(subject) return subject_staff.employment_kind == StaffRuntime.EmploymentKind.UNIQUE \ and heroine_definition.get(&"role_id") == String(subject_staff.role_id) \ diff --git a/docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json b/docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json index 5474439..8960459 100644 --- a/docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json +++ b/docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json @@ -7,7 +7,7 @@ "template": "Original relationship model: checks, failures", "required": true, "fixed_check_count_used": false, - "source_sha256_at_schema_audit": "ad509f5fb67ab91e1d1d99a08af51e4695e411b9a2541ea63ee22b1555cb0924", + "source_sha256_at_schema_audit": "c74b243dbbb54dba9bbc165e29508cca910f0beb63e32d25ebbb8ea606dccce9", "authority": { "path": "docs/spec/acceptance/P18-01-code-r01.json", "scope": "new backend suite marker; native execution pending" @@ -18,7 +18,7 @@ "template": "Original relationship runtime: checks, failures", "required": true, "fixed_check_count_used": false, - "source_sha256_at_schema_audit": "374f3d31a65d2f2b62dfef29721c8c838575b856f4fa5a0bca31c6ba4c7e09dd", + "source_sha256_at_schema_audit": "845ae200575563400c3497e517137effb7d4d928dd7e6a4990ed8aabdbda5ae6", "authority": { "path": "docs/spec/acceptance/P18-01-code-r01.json", "scope": "new backend suite marker; native execution pending" diff --git a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/IMPLEMENTATION.md b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/IMPLEMENTATION.md index 453eeb2..2a9bb8e 100644 --- a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/IMPLEMENTATION.md +++ b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/IMPLEMENTATION.md @@ -1,6 +1,53 @@ # P18-01-CODE implementation handoff -Status: submitted for Runner validation; no acceptance or unit completion claimed. +Status: repair 5 submitted for Root native and Runner verification; no acceptance or unit completion claimed. P02-01 inputs are now readable and verified. The repair-3/4 notes below are retained history; repair 5 supersedes their input availability gap. + +## Repair 3 historical failure (2026-10-15) + +Historical record only: stopping independent repairs over decoder permissiveness was wrong. The commander producer-evidence interpretation supersedes this old policy concern; the following describes the failed repair-3 attempt, not the current policy. + +Inspected baseline d2a1f80a613e7c77b02b941026bc49c2d85db863 using read-only git show. +RelationshipState.from_snapshot delegates to configure; _value preserves canonical +key precedence. Numeric fields use int(), with clampi/maxi where applicable. +Thus finite fractional numbers are truncated as well as integral JSON floats; +numeric strings such as metrics.affection = "42" are also converted. The baseline +RelationshipService._parse_snapshot similarly converts version and candidate +sequence with int(). These are broader than a finite-integral-float-only policy. +No acceptance policy for these conflicting formats has been selected here. + +Baseline normalization also replaces non-Dictionary metrics, action_counts, +daily_metric_deltas, flags and crossed_thresholds with defaults, coerces flags +with bool(), and ignores non-Array threshold collections. The immutable spec +requires wrong types to reject, while the repair direction requires baseline +legitimate acceptance without a new restriction or loosening. In particular, +accepting or rejecting numeric strings cannot satisfy both without an explicit +policy decision. Non-numeric/non-finite input, wrong containers, future versions, +duplicates, invalid references, corrupt original records and projection mismatches +remain required rejections under the spec; this report does not waive any. + +Baseline Runtime restore delegates legacy relationships to RelationshipService +without the added actor-existence loop. Baseline GuestService.despawn_guest retains +the departed guest in persistent_records and removes it from active guests. +The held actor loop is therefore still an unresolved repair item. Candidate +catalog selection, lifecycle tests, mutation-through-alias tests, atomic rejection +coverage and source-pin updates are also still outstanding. The numeric Reader +helpers in SimulationSnapshot and SaveService accept bounded finite integral JSON +floats for their own envelope fields; they do not establish a policy overriding +RelationshipState's coercions. P02-01 representative-save applicability has not +been established; no fixture acceptance claim is made. + +Only this handoff and prepare-only evidence were changed. Production code, test +sources and marker/policy pins were left untouched pending policy resolution. +Prepare-only exited 0: 1,311 source files, 67,310,742 bytes; 3,384,279,040 free +bytes; 381,883,542 conservative required bytes; capacity available. Seven suites: +original_relationship_model, original_relationship_runtime, +relationship_event_service, runtime_relationship_events, +runtime_snapshot_serialization, runtime_save_lifecycle, staff_management. +308 future parse paths and nine future native phases; engines/stages = 0, +actual_checks = null, formal_acceptance = false. The first invocation omitted +required --output and exited 2; the corrected invocation used the allowed +p18-01-code/repair-3-prepare output path. Native checks were not run. +P18-01 remains 30/88, in progress, with no partial credit. Scope: dedicated original relationship state, lossless legacy snapshot preservation, Runtime registration and read projection, and the contract-listed tests and collector. @@ -34,8 +81,8 @@ The acceptance specification without its final newline matches the contract SHA2 catalog membership does not invent recruitment. No new original update policy, contact, route, attack, threshold or duel behavior is defined. - Snapshot restore validates candidates before replacing live services, then - rebinds the identity validator to live staff. Existing legacy actor references - must resolve against player, restored staff or restored guests. + rebinds the identity validator to live staff. Legacy relationships retain the original acceptance of departed guests; original + records separately validate staff/person/catalog references. - Every staff-management row exposes `original_relationship`. Missing records have `configured: false` and null values, distinct from explicit zero. Configured projections are copies, so reads and caller edits cannot change service state. @@ -77,3 +124,195 @@ in_progress: ordinary Japanese UI rendering/equality, approved production values all-seven recruitment, final full required roster and applicable Windows final acceptance remain outstanding. No git writes, other agents or Runner controls were used by worker. + +## Repair 4 producer interpretation and independent repairs + +The unchanged wrong-types/valid-legacy contract follows legitimate producers, +not corrupt-input coercions. RelationshipState.create_snapshot +(scripts/relationship/relationship_state.gd:132-152) emits String ids/route, +int numeric fields, named route_lock, Dictionary numeric/bool collections and +Array thresholds. Its validity check (:99-101) requires int metrics. +Read-only git log identifies 423fd6d as the only history entry for that file; +git show of that producer (:132-152) also emits the enum NAME String, not int. + +Actual writer scripts/core/save_service.gd:874-878 serializes the snapshot with +var_to_bytes and ZSTD; Reader :1021-1028 uses bytes_to_var. Thus world numeric +ints remain ints. JSON decoding (:970-978) applies to the manifest, not relationship +payloads. Integral JSON floats are not an established relationship save format +on this path. Accept int legacy values, named route_lock and producer collections. +Reject numeric strings, null, bool-as-number, fractional/nonfinite numbers, float +relationship numbers, int route_lock, wrong containers and invalid enum names. +Unknown extensions remain opaque; canonical values precede aliases, and aliases, +unknown facts and collection order remain raw retained facts. Neither old axis +configures original Affection/Lust/Netorare. + +relationship_service.gd _legacy_types_valid now also checks collection key types +and restricts route_lock to producer enum names. The pre-existing int/container +checks implement the producer policy. No conversion or rewrite of raw input occurs. +Runtime candidate validation now takes restored_catalog; command/service binding +uses the live catalog. Removed only the added active legacy actor loop. +GuestService.despawn_guest (scripts/guest/guest_service.gd:954-978) retains the +persistent record and removes the active guest, so that loop rejected valid saves. +Original identity/person validation remains in place. +Existing StaffService.remove_staff (:897-898) and retire_staff (:942-943) already +refuse UNIQUE departures before changes; tests assert refusal and saved original +record survival. No new departure rule or record deletion was added. + +The two new suites now cover real Service and Runtime affection/dependence +mutations from v1 affinity/obligation, canonical precedence, raw extensions and +order, null original values, v2 restore/rebind, departed persistent guest acceptance, +and atomic malformed candidates. Rejection checks retain service identity/state, +whole Runtime bytes and caller input. The five existing suites remain unchanged. +Fixtures are validation inputs, not production values or newly hired characters. + +Collector derives every sorted .gd path from the exact shared.source_refs map. +Verification binds parse-paths.json, the receipt count, the unique zero-failure +FULL_DEPENDENCY_PARSE marker, actual_parse_checks and the whole retained stage +to that same source map. No count-specific skips or other provenance changes. +This frozen map has 308 paths; expanded maps must verify their own full count. + +### Precise remaining context gap + +The P02-01 input manifest referenced by +docs/plans/original-completion-2026-10-02/execution/multi-agent-dev-handoff/delivery_contract_proposal.json:333 +is absent at artifacts/original-completion-2026-10-02/p02-01-fixed-baseline-r01/input-manifest.json +in this worktree. Reading the exact production-root counterpart returns +Operation not permitted. Production-root listing/search is also denied. +No representative save bytes or decoded fixture are available in this checkout; +.review-material is absent. Accordingly their exact types/applicability have NOT +been verified, no older conflicting producer shape is asserted, and no replacement +representative fixture has been invented. Runner/owner must supply readable pinned +manifest and applicable save members to finish that mandatory evidence and test. +This gap did not stop the independent repairs. No native checks were executed. +UI, values, routes, contacts and duel remain untouched. P18-01 remains 30/88, +in progress. Native seven-suite frozen evidence, p18-model validation, separate +Opus review, latest-main integration and fresh merged-source evidence remain +Root/Runner work; no completion claim is made. + +### Worker static/prepare evidence (repair 4) + +Python AST parsed successfully. git diff --check passed. Both new suite SHA-256 +pins match their final source in marker contracts and suite-policy; all other +rows are unchanged. The five existing suite files are byte-identical to HEAD. +No engine, native collector, default profile or full regression was run. + +Prepare-only roster (seven): original_relationship_model, +original_relationship_runtime, relationship_event_service, +runtime_relationship_events, runtime_snapshot_serialization, +runtime_save_lifecycle, staff_management. Full paths are the unchanged ROSTER in +tools/run_p18_relationship_tests.py:17-25. +Initial repair-4 preview: 1,311 files, 67,318,770 source bytes, +3,388,039,168 free bytes, conservative single-set admission 381,891,570 bytes, +308 parse paths, nine future phases, engines/stages zero, actual_checks null, +formal_acceptance false. A final preview after final edits is retained separately +as repair-4-prepare.json. No native pass is implied by this preview. + +Using the supplied old output estimate conservatively as 474 MiB per full set +(including 351 MiB engine), two fresh sets require 948 MiB = 994,050,048 bytes. +They fit the observed ~3.39 GB free space, with ~2.39 GB left before other new +consumers. This is capacity arithmetic, not a reservation or a measured new run; +actual output growth remains Root's admission responsibility. + +## Repair 5: readable fixed inputs and representative binding + +All work continues from preserved HEAD 0084760ee05a97adfcbd783a71161491f3629918. +Before edits, the nine dirty files were hashed; exact paths and SHA-256 are in +repair-5-start-shas.json. The command direction supplies no nine-file publication +hash table, and no publication table is present in the supplied input context. +Therefore full publication equality cannot independently be asserted. Both +existing test hashes matched their repair-4 marker/policy pins. Current bytes +were preserved and independent work continued; no reset/reimplementation occurred. + +Only the supplied p02-01-fixed-inputs-for-p18-r05 context was used for external +input. No production absolute path in the manifest was followed. Manifest SHA: +d07b6c42ecca11bf3557ee5034ce9cc70b5a750f7b08b6b40f9ef09cdbe787c2. +ROOT_COPY_PROVENANCE.json's manifest hash, all 28 copy-file size/hash entries, +and all 20 original member size/hash entries verified successfully. No missing +file or mismatch occurred. Exact per-member evidence is retained in +repair-5-input-evidence.json; inspect_repair5_inputs.py reproduces the read-only +verification and equivalent little-endian typed Variant decoding. It checks +TTWB/version/header size, compressed-world checksum, ZSTD expansion length and +complete Variant stream consumption. Unsupported types fail explicitly. + +### Observed package evidence + +All five contain a Dictionary v1 relationship payload with an Array +relationships collection, empty; threshold_candidates is empty, and version and +next_candidate_sequence are typed ints. Metric/shield/day fields are absent +because there are no relationship records: their Variant types are **unobserved**, +not float, int, null or guessed defaults. + +| Package | world.bin bytes | Expanded Variant bytes | world.bin SHA-256 | +| --- | ---: | ---: | --- | +| initial | 7523 | 61132 | df91b4624c9afdeea2d366ff38d9f545fcff3f5f99223e3c04ae66d04b2f9fab | +| operating | 48631 | 1020364 | 93732bb0bc042f4da0f90879a03dc3f3e374b3b45000840b0cbae142c42601c6 | +| moving | 27413 | 390624 | a577b190cb3b18cfc5cca1ef15d26521ea950bf5f3d3da68d19b1c8f43672158 | +| date-boundary | 26686 | 579376 | d4443f0bd42c2e9d6a5dd07d1949deade5d7526036f1320b56336b5637c9fcc3 | +| defense | 10110 | 78904 | 34ab140d64743b89425c292b785827fdb82c2bf92510688a4038461a2fe7a5d7 | + +### Type decision and applicability + +Actual producer scripts/core/save_service.gd:874 uses var_to_bytes(snapshot); +:878 compresses ZSTD. Actual Reader :1021-1028 expands then bytes_to_var. +Manifest JSON (:1754) carries identity metadata, not relationship values. +RelationshipState.create_snapshot (scripts/relationship/relationship_state.gd:132-152) +emits typed int metric/shield/day values. No actual relationship JSON-float path +was found. Keep the repair-4 int-only legacy checks closed to floats +(scripts/relationship/relationship_service.gd:544-587); no production type change +was required. Strings, null, bool-as-number, floats including NaN/Inf and wrong +containers remain rejected. No synthetic float producer was invented. + +The empty real collections prove compatibility only for those actual snapshots; +they do not prove every non-empty metric shape, alias or historical producer. +Existing focused alias/mutation fixtures and explicit original fixtures provide +non-empty coverage and remain validation inputs, never production approval. + +Binding: all five exact world.bin files are embedded in the already source-hashed +test_original_relationship_runtime.gd REPRESENTATIVE_SAVES constant. TTWB payloads +are already ZSTD compressed, so the base64 contains compressed bytes, not expanded +Variant streams. Embedded manifests retain the actual checksums. Each test verifies +world.bin size and full SHA before writing only into its owned user://saves/p18_* +fixture directory. It invokes the actual SaveService._load_snapshot_absolute_v1 +Reader with validation, then actual Runtime.restore_snapshot. It asserts exact +legacy facts, null/unconfigured original projections (including the no-staff case), +input preservation, read nonmutation, actual SaveService writer/Reader v2 relationship +round trip and Runtime equality. Physical package format is selected by SaveService; +relationship v2 does not invent a new physical save format. + +Corruption candidates derive from each decoded representative, changing the actual +relationships collection to String, Dictionary or null, and assert rejection +preserves service identity, service/whole-Runtime bytes and input bytes. +Empty representatives cannot provide corrupt per-record metric examples; existing +focused non-empty numeric-string/container tests cover those shapes separately. +Fixture package directories are removed after each applicable test. No loose +fixture binaries or collector fixture-map exceptions were added. All source-map, +stage, per-phase/final inventory guards and source-proof semantics are unchanged. + +The five existing suites remain byte-identical to HEAD. Production scripts, +original values, UI, routes, contacts and duel are untouched in repair 5. +Both new-test pins in marker contracts and suite-policy are refreshed to exact +final source digests. Native suites and GDScript engine parse remain unexecuted. +P18-01 remains **30/88, in progress**. Fresh native seven, strict p18-model, +separate Opus review, latest-main integration and fresh merged native evidence +are the next Root/Runner gates, not backend acceptance or unit completion. + +### Repair-5 static/prepare result + +Python AST, independent extraction of all five embedded compressed streams and +their size/SHA checks, exact marker/policy pins, unchanged non-P18 policy/marker +records, five existing suite byte equality, and git diff --check passed. +Preserved Runtime/service/model/collector and repair-4-prepare hashes still match +the repair-5 starting bytes. No engine, native collector, full regression, Runner, +git write, branch/main operation or additional agent was used. + +Final prepare-only receipt is repair-5-prepare.json. Roster (7): +original_relationship_model, original_relationship_runtime, +relationship_event_service, runtime_relationship_events, +runtime_snapshot_serialization, runtime_save_lifecycle, staff_management. +The exact shared source_refs map yields 1,311 files, 67,498,284 bytes and 308 +sorted .gd parse paths; nine future native phases. Empty actual checks, +engines/stages = 0 and formal_acceptance = false. +Free space at preview: 3,390,361,600 bytes (about 3.39 GB); single-set admission +382,071,084 bytes. At the conservative prior estimate of 474 MiB per set, +two fresh native sets require 994,050,048 bytes and fit, leaving about 2.39 GB. +Capacity remains a point-in-time preview, not reserved disk or native evidence. diff --git a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/inspect_repair5_inputs.py b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/inspect_repair5_inputs.py new file mode 100644 index 0000000..7a29da5 --- /dev/null +++ b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/inspect_repair5_inputs.py @@ -0,0 +1,94 @@ +"""Read-only equivalent of SaveService's ZSTD/Variant reader; no engine invocation.""" +import base64 +import hashlib +import json +from pathlib import Path +import struct +import subprocess + +CONTEXT = Path('/Users/korizatou114/Projects/TheTree-managed-worktrees/p18-01-model/.runtime/P18-01-CODE/build/p02-01-fixed-inputs-for-p18-r05') +HERE = Path(__file__).parent + + +class VariantReader: + def __init__(self, data): + self.data, self.offset = data, 0 + + def unpack(self, fmt): + value = struct.unpack_from('<' + fmt, self.data, self.offset)[0] + self.offset += struct.calcsize('<' + fmt) + return value + + def read(self): + header = self.unpack('I') + kind = header & 0xffff + wide = bool(header & 0x10000) + if kind == 0: + return None + if kind == 1: + return bool(self.unpack('I')) + if kind == 2: + return self.unpack('q' if wide else 'i') + if kind == 3: + return self.unpack('d' if wide else 'f') + if kind in (5, 6, 7, 8, 9, 10, 12, 13): + count = {5: 2, 6: 2, 7: 4, 8: 4, 9: 3, 10: 3, 12: 4, 13: 4}[kind] + fmt = 'i' if kind in (6, 8, 10, 13) else ('d' if wide else 'f') + return tuple(self.unpack(fmt) for _ in range(count)) + if kind in (4, 21): + size = self.unpack('I') + value = self.data[self.offset:self.offset + size].decode('utf-8') + self.offset += (size + 3) & ~3 + return value + if kind == 27: + count = self.unpack('I') & 0x7fffffff + result = {} + for _ in range(count): + key = self.read() + result[key] = self.read() + return result + if kind == 28: + if (header >> 16) & 3: + assert (header >> 16) & 3 == 1, 'only builtin typed arrays supported' + self.unpack('I') # element Variant type, values remain individually tagged + return [self.read() for _ in range(self.unpack('I') & 0x7fffffff)] + raise ValueError(f'unsupported Variant {kind} at {self.offset - 4}') + + +def inspect(): + manifest_bytes = (CONTEXT / 'input-manifest.json').read_bytes() + provenance = json.loads((CONTEXT / 'ROOT_COPY_PROVENANCE.json').read_bytes()) + digest = hashlib.sha256(manifest_bytes).hexdigest() + assert digest == provenance['original_manifest_sha256'] == 'd07b6c42ecca11bf3557ee5034ce9cc70b5a750f7b08b6b40f9ef09cdbe787c2' + manifest = json.loads(manifest_bytes) + for entry in provenance['copy_files']: + path = Path(entry['target']) + assert path.is_relative_to(CONTEXT), str(path) + data = path.read_bytes() + assert len(data) == entry['bytes'] and hashlib.sha256(data).hexdigest() == entry['sha256'], str(path) + evidence = {'manifest_sha256': digest, 'verified_copy_files': len(provenance['copy_files']), 'members': {}, 'packages': {}} + for package, members in manifest['original_packages'].items(): + for member, pin in members.items(): + path = CONTEXT / 'saves' / package / member + data = path.read_bytes() + assert len(data) == pin['bytes'] and hashlib.sha256(data).hexdigest() == pin['sha256'], str(path) + evidence['members'][f'{package}/{member}'] = {'bytes': len(data), 'sha256': pin['sha256']} + world = (CONTEXT / 'saves' / package / 'world.bin').read_bytes() + magic, version, size = struct.unpack('<4sIQ', world[:16]) + assert magic == b'TTWB' and version == 1 + save_manifest = json.loads((CONTEXT / 'saves' / package / 'manifest.json').read_bytes()) + assert hashlib.sha256(world[16:]).hexdigest() == save_manifest['checksum_world'] + raw = subprocess.run(['zstd', '-d', '-q', '-c'], input=world[16:], check=True, capture_output=True).stdout + assert len(raw) == size + reader = VariantReader(raw) + snapshot = reader.read() + assert reader.offset == len(raw) + relationships = snapshot['systems']['runtime']['relationships'] + evidence['packages'][package] = {'world_bytes': len(world), 'raw_bytes': size, 'relationship_payload': relationships, + 'collection_present': 'relationships' in relationships, 'collection_type': type(relationships.get('relationships')).__name__, + 'collection_count': len(relationships['relationships']), 'metric_shield_day_types': 'not observed: empty relationship collection'} + return evidence + + +if __name__ == '__main__': + print(json.dumps(inspect(), indent=2)) diff --git a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-4-prepare.json b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-4-prepare.json new file mode 100644 index 0000000..9c7b119 --- /dev/null +++ b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-4-prepare.json @@ -0,0 +1 @@ +{"roster": ["tests/s4/test_original_relationship_model.gd", "tests/s4/test_original_relationship_runtime.gd", "tests/s4/test_relationship_event_service.gd", "tests/s4/test_runtime_relationship_events.gd", "tests/s6/test_runtime_snapshot_serialization.gd", "tests/s6/test_runtime_save_lifecycle.gd", "tests/ui/test_staff_management.gd"], "source_files": 1311, "source_bytes": 67319279, "free_bytes": 3396403200, "conservative_required_bytes": 381892079, "capacity_available": true, "parse_paths": 308, "future_native_phases": 9, "actual_checks": null, "engines": 0, "stages": 0, "formal_acceptance": false} diff --git a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-input-evidence.json b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-input-evidence.json new file mode 100644 index 0000000..4c0e464 --- /dev/null +++ b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-input-evidence.json @@ -0,0 +1,158 @@ +{ + "manifest_sha256": "d07b6c42ecca11bf3557ee5034ce9cc70b5a750f7b08b6b40f9ef09cdbe787c2", + "verified_copy_files": 28, + "members": { + "initial/journal.log": { + "bytes": 35, + "sha256": "1ec35136aeb728392a832cd3b9197b270f96779cb09c7fe9c51ed385e30f158d" + }, + "initial/world.bin": { + "bytes": 7523, + "sha256": "df91b4624c9afdeea2d366ff38d9f545fcff3f5f99223e3c04ae66d04b2f9fab" + }, + "initial/manifest.json": { + "bytes": 420, + "sha256": "e9c4f7a8ea4ce9897c1e66c7861779fcd558f2dc314e08dbaef1b59bd145f419" + }, + "initial/thumbnail.png": { + "bytes": 83, + "sha256": "0ef55674eca98b6748ae5ccca85a14b042c1545a143810c9c47b487119895c32" + }, + "operating/journal.log": { + "bytes": 35, + "sha256": "2c7f851e72867d6d44247baa7624af46d22abaa31cb16dff197e8e5914d1e866" + }, + "operating/world.bin": { + "bytes": 48631, + "sha256": "93732bb0bc042f4da0f90879a03dc3f3e374b3b45000840b0cbae142c42601c6" + }, + "operating/manifest.json": { + "bytes": 422, + "sha256": "9c8b2c813c78ea1e19f43af31e77ff1547d707ca93f0d142c9e0df5e9bee8bd6" + }, + "operating/thumbnail.png": { + "bytes": 83, + "sha256": "0ef55674eca98b6748ae5ccca85a14b042c1545a143810c9c47b487119895c32" + }, + "moving/journal.log": { + "bytes": 35, + "sha256": "5f5f1cbb5a4b1c94945f503ae9c62989f628aa1db498974e3d5c3fe04cb89120" + }, + "moving/world.bin": { + "bytes": 27413, + "sha256": "a577b190cb3b18cfc5cca1ef15d26521ea950bf5f3d3da68d19b1c8f43672158" + }, + "moving/manifest.json": { + "bytes": 416, + "sha256": "52e87c19e39d7e4e922b47ef5979f4fecbe3211bd3f193ab30fd5418fffc5c73" + }, + "moving/thumbnail.png": { + "bytes": 83, + "sha256": "0ef55674eca98b6748ae5ccca85a14b042c1545a143810c9c47b487119895c32" + }, + "date-boundary/journal.log": { + "bytes": 35, + "sha256": "6fe4347f04e624f74a77d0eb85738508f653103e7522a0d37ed811519b5fe34f" + }, + "date-boundary/world.bin": { + "bytes": 26686, + "sha256": "d4443f0bd42c2e9d6a5dd07d1949deade5d7526036f1320b56336b5637c9fcc3" + }, + "date-boundary/manifest.json": { + "bytes": 430, + "sha256": "5e604491f863537d390f9db11f9dcc2473fcbf7fc0bced8d326caae893572ea2" + }, + "date-boundary/thumbnail.png": { + "bytes": 83, + "sha256": "0ef55674eca98b6748ae5ccca85a14b042c1545a143810c9c47b487119895c32" + }, + "defense/journal.log": { + "bytes": 35, + "sha256": "1ec35136aeb728392a832cd3b9197b270f96779cb09c7fe9c51ed385e30f158d" + }, + "defense/world.bin": { + "bytes": 10110, + "sha256": "34ab140d64743b89425c292b785827fdb82c2bf92510688a4038461a2fe7a5d7" + }, + "defense/manifest.json": { + "bytes": 418, + "sha256": "91d209a9bc295eadfa761359670a0c53ec7799a1f2ab53eedaacc14b2430b015" + }, + "defense/thumbnail.png": { + "bytes": 83, + "sha256": "0ef55674eca98b6748ae5ccca85a14b042c1545a143810c9c47b487119895c32" + } + }, + "packages": { + "initial": { + "world_bytes": 7523, + "raw_bytes": 61132, + "relationship_payload": { + "version": 1, + "relationships": [], + "threshold_candidates": [], + "next_candidate_sequence": 1 + }, + "collection_present": true, + "collection_type": "list", + "collection_count": 0, + "metric_shield_day_types": "not observed: empty relationship collection" + }, + "operating": { + "world_bytes": 48631, + "raw_bytes": 1020364, + "relationship_payload": { + "version": 1, + "relationships": [], + "threshold_candidates": [], + "next_candidate_sequence": 1 + }, + "collection_present": true, + "collection_type": "list", + "collection_count": 0, + "metric_shield_day_types": "not observed: empty relationship collection" + }, + "moving": { + "world_bytes": 27413, + "raw_bytes": 390624, + "relationship_payload": { + "version": 1, + "relationships": [], + "threshold_candidates": [], + "next_candidate_sequence": 1 + }, + "collection_present": true, + "collection_type": "list", + "collection_count": 0, + "metric_shield_day_types": "not observed: empty relationship collection" + }, + "date-boundary": { + "world_bytes": 26686, + "raw_bytes": 579376, + "relationship_payload": { + "version": 1, + "relationships": [], + "threshold_candidates": [], + "next_candidate_sequence": 1 + }, + "collection_present": true, + "collection_type": "list", + "collection_count": 0, + "metric_shield_day_types": "not observed: empty relationship collection" + }, + "defense": { + "world_bytes": 10110, + "raw_bytes": 78904, + "relationship_payload": { + "version": 1, + "relationships": [], + "threshold_candidates": [], + "next_candidate_sequence": 1 + }, + "collection_present": true, + "collection_type": "list", + "collection_count": 0, + "metric_shield_day_types": "not observed: empty relationship collection" + } + } +} diff --git a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-prepare.json b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-prepare.json new file mode 100644 index 0000000..0d07dc9 --- /dev/null +++ b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-prepare.json @@ -0,0 +1,22 @@ +{ + "roster": [ + "tests/s4/test_original_relationship_model.gd", + "tests/s4/test_original_relationship_runtime.gd", + "tests/s4/test_relationship_event_service.gd", + "tests/s4/test_runtime_relationship_events.gd", + "tests/s6/test_runtime_snapshot_serialization.gd", + "tests/s6/test_runtime_save_lifecycle.gd", + "tests/ui/test_staff_management.gd" + ], + "source_files": 1311, + "source_bytes": 67498284, + "free_bytes": 3390361600, + "conservative_required_bytes": 382071084, + "capacity_available": true, + "parse_paths": 308, + "future_native_phases": 9, + "actual_checks": null, + "engines": 0, + "stages": 0, + "formal_acceptance": false +} diff --git a/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-start-shas.json b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-start-shas.json new file mode 100644 index 0000000..6580055 --- /dev/null +++ b/docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-5-start-shas.json @@ -0,0 +1,11 @@ +{ + "autoload/simulation_runtime.gd": "0c8c9356a78bf9df16c362e202a362e044bae018f40efb54145713582d69a2d2", + "docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json": "ea74b503b41d7a38f0ee26f8a7d03626edd7d941329d2355ce235d65d2bf4855", + "docs/plans/original-completion-2026-10-02/execution/p18-01-code/IMPLEMENTATION.md": "28fa682dcc4f6b33347d6e10046d093f3bfb43bae04bb3411d368885d53cc8bc", + "scripts/relationship/relationship_service.gd": "2d137a4dc3712356434b2609723b88292fb717625241e07f9e60984d830df80a", + "tests/s4/test_original_relationship_model.gd": "c74b243dbbb54dba9bbc165e29508cca910f0beb63e32d25ebbb8ea606dccce9", + "tests/s4/test_original_relationship_runtime.gd": "349271cc8b8a4750ef339ecac6905852bd7a5d006cca68ee10d5d0c737f426de", + "tools/regression/suite-policy.json": "2145ef977e72e490d27fddd550c0c00827b52a2e0b844d60e6f86df9a666d5ae", + "tools/run_p18_relationship_tests.py": "ccc8976dd9e9863366d102719dc0ae21d3a57da45dec39b4c72a3fc8c9f31a9b", + "docs/plans/original-completion-2026-10-02/execution/p18-01-code/repair-4-prepare.json": "9d0ae1b3f1e91d44ac84a2a55388bc56e96637dec925f42ecc9757de1c3a3a28" +} diff --git a/scripts/relationship/relationship_service.gd b/scripts/relationship/relationship_service.gd index 35d4670..d4a49ef 100644 --- a/scripts/relationship/relationship_service.gd +++ b/scripts/relationship/relationship_service.gd @@ -543,7 +543,7 @@ func _parse_snapshot(snapshot: Dictionary) -> Dictionary: static func _legacy_types_valid(raw: Dictionary) -> bool: for key: String in ["relationship_id", "actor_a_id", "actor_b_id"]: - if not (raw.get(key) is String or raw.get(key) is StringName): + if not raw.get(key) is String: return false for key: String in ["shield_max", "shield_current", "last_event_at", "daily_attack_count", "attack_day", "metric_delta_day"]: if raw.has(key) and not raw[key] is int: @@ -559,9 +559,9 @@ static func _legacy_types_valid(raw: Dictionary) -> bool: for value: Variant in raw.get(key, {}).values(): if not value is int: return false - for key: String in ["action_counts", "flags"]: + for key: String in ["metrics", "action_counts", "daily_metric_deltas", "flags", "crossed_thresholds"]: for identity: Variant in raw.get(key, {}): - if not (identity is String or identity is StringName): + if not identity is String: return false for value: Variant in raw.get("flags", {}).values(): if not value is bool: @@ -572,10 +572,11 @@ static func _legacy_types_valid(raw: Dictionary) -> bool: for threshold: Variant in value: if not threshold is int: return false - if raw.has("route_id") and not (raw["route_id"] is String or raw["route_id"] is StringName): - return false - if raw.has("route_lock") and not (raw["route_lock"] is int or raw["route_lock"] is String or raw["route_lock"] is StringName): + if raw.has("route_id") and not raw["route_id"] is String: return false + if raw.has("route_lock"): + if not raw["route_lock"] is String or not RelationshipStateType.RouteLock.keys().has(raw["route_lock"]): + return false return true diff --git a/tests/s4/test_original_relationship_model.gd b/tests/s4/test_original_relationship_model.gd index d2a2c81..1f24b4f 100644 --- a/tests/s4/test_original_relationship_model.gd +++ b/tests/s4/test_original_relationship_model.gd @@ -30,7 +30,50 @@ func _service() -> RelationshipService: ) +static func legacy_fixture() -> Dictionary: + return {"version": 1, "relationships": [ + {"relationship_id": "aliases", "actor_a_id": "heroine_anri", "actor_b_id": "player", + "metrics": {"affinity": 41, "obligation": 19, "extension": {"opaque": [3, "keep"]}}, + "extra": ["raw", 2.5]}, + {"relationship_id": "second", "actor_a_id": "departed", "actor_b_id": "player", + "metrics": {"trust": 7}}], + "threshold_candidates": [], "next_candidate_sequence": 1, "extension": ["ordered", 7]} + + +func _alias_mutations() -> void: + var service := _service() + var legacy := legacy_fixture() + var input := var_to_bytes(legacy) + _expect(service.restore_snapshot(legacy), "int v1 aliases accepted") + _expect(service.apply_value_change(&"aliases", &"affection", 2, 0).is_success(), "affection mutation through real service") + _expect(service.apply_value_change(&"aliases", &"dependence", 3, 0).is_success(), "dependence mutation through real service") + var saved := service.create_snapshot() + var raw: Dictionary = saved[&"legacy"]["relationships"][0] + _expect(raw["metrics"]["affection"] == 43 and raw["metrics"]["dependence"] == 22, "canonical changes merged") + _expect(raw["metrics"]["affinity"] == 41 and raw["metrics"]["obligation"] == 19, "aliases remain old facts") + _expect(raw["metrics"]["extension"] == legacy["relationships"][0]["metrics"]["extension"] and raw["extra"] == ["raw", 2.5], "unknown facts survive mutation") + _expect(saved[&"legacy"]["relationships"][1] == legacy["relationships"][1], "record order preserved") + var restored := _service() + _expect(restored.restore_snapshot(saved), "mutated v2 restores") + _expect(var_to_bytes(restored.create_snapshot()) == var_to_bytes(saved), "mutated v2 raw order and bytes preserved") + _expect(restored.get_relationship(&"aliases").get_metric(&"affection") == 43 and restored.get_relationship(&"aliases").get_metric(&"dependence") == 22, "canonical values take precedence over raw aliases") + for key: StringName in [&"affection", &"lust", &"netorare"]: + _expect(restored.get_original_relationship(&"heroine_anri")[key] == null, "old axes never configure original " + String(key)) + _expect(var_to_bytes(legacy) == input, "mutation never changes input bytes") + for value: Variant in ["50", null, true, 50.0, 1.5, INF, NAN]: + var bad := legacy_fixture() + bad["relationships"][0]["metrics"]["affinity"] = value + _rejected(restored, bad) + var bad := legacy_fixture() + bad["relationships"][0]["metrics"] = [] + _rejected(restored, bad) + bad = saved.duplicate(true) + bad[&"relationships"] = [] + _rejected(restored, bad) + + func _run() -> void: + _alias_mutations() var service := _service() var before := var_to_bytes(service.create_snapshot()) var unset := service.get_original_relationship(&"heroine_anri") diff --git a/tests/s4/test_original_relationship_runtime.gd b/tests/s4/test_original_relationship_runtime.gd index f2aa656..a06284c 100644 --- a/tests/s4/test_original_relationship_runtime.gd +++ b/tests/s4/test_original_relationship_runtime.gd @@ -1,6 +1,1386 @@ extends SceneTree const Fixtures = preload("res://tests/s4/test_original_relationship_model.gd") +# Exact P02-01 TTWB files: header plus already-ZSTD-compressed Variant bytes. +# SHA and size are from input-manifest.json, verified before the actual Reader. +const REPRESENTATIVE_SAVES := [ + { + "name": "initial", "size": 7523, + "sha256": "df91b4624c9afdeea2d366ff38d9f545fcff3f5f99223e3c04ae66d04b2f9fab", + "manifest": "{\n\t\"absolute_minute\": 360,\n\t\"checksum_world\": \"a62dd25d7e5649b4253a960bf7e29f3d5ce16d8a682303fd71f45f53bf94dd71\",\n\t\"content_pack_ids\": [],\n\t\"created_at_real\": \"2026-10-09T02:28:50\",\n\t\"day\": 1,\n\t\"display_name\": \"initial\",\n\t\"enabled_filter_profile\": \"default\",\n\t\"format_version\": 1,\n\t\"game_version\": \"0.1.0\",\n\t\"save_id\": \"initial\",\n\t\"seed\": 4260214,\n\t\"uncompressed_size\": 61132,\n\t\"updated_at_real\": \"2026-10-09T02:28:50\"\n}", + "world": ( + "VFRXQgEAAADM7gAAAAAAACi1L/1gzO1N6gBq3tgpUaDYEKUDwLU+8IAO14OVpsnRYTb69BLv8Oi3hqwb40P2QxrQJ3s3I7v7X8tmJbfbjbM8qAzamL8K3iDR" + + "Dsc4PG0G8oFISdrqg//oP/o/IbE7BVoCgALGAqD3eZ7X8TqP8zYve9i7nua9957jPYt3LN6veLfivYp3Kt6neJfiPYp3KN61m6zx/0bTylNGLpYobWmSr+W4" + + "Drc2722WhawoZ/o/CfQ+z/M6Xudx3uZlD3vX07z33nO8Z/GOxfsV71a8V/FOxfsU71K8R/EOxfN4MKUtYdNTVNEog3vKGrlOSvv/s2m1YJ0r0Ex84jMww461" + + "2tnT/83rlFqwIWSFBk7ov4wFI2JG4OaGq505UhAODyyx8petpaAHXnz4VJnI4c8HGqDgIVuDGXeX+h9SwAkAXvj/ZzfIECGFxrVRrXGY2CEJIP6uOaZNmK1F" + + "gFWygAImccMlJglk1NzwtTP/Sastz2tTNP7veK08r91yFzti34xhqt7/n1xbemBtQq03POmp83gXzrVZDeuMK6vh27l2Vopcm+Pt2imoTa0z11JGrCVrZ8ut" + + "Wpv/P7ilvdyft9SkKFgnptl01x2O/x45cuTI0YoazHVaTiV7k7BFZ9RgxpH+f6GhsiUbNSlsVtSanmJtWO3Msjmwl4OpOlGomPF/EW1CrcbVykqYZ7r+F5ke" + + "678Ge/4O46k6tdrcf07LOvGNrdWp+o/932S3txxb5j8nBEMK6NXMtbv/OQ+vOuMW/s+ZrM7tVqSwWTPL+B+kqvHC7puhRq+V+S/6lmdE/c9MMI3zdu7Q/mti" + + "jav/GEgJ/zUatan/GG55O4v7/u/oHDOGvYqp/57/pWuy3TAXK/7fQmvcRe7/5lo3h9/WuatzBTt31OJT/C/6r5KWyv/Z+6/5q534NgvGVW8S/w/9L/3H/osE" + + "samELdJ/UecDa1ljxnWOWk7W7RLu6cFzG3Fzw7erjK2piXH8TxKJlsLb897oocFubzJHDk8NYjkznilL/5OeZsaMYUvGlAc3s4yKWwvYOG7ydhy0uYv/QTok" + + "UiPl/mebzPH0Os1eDtbeZB5l2uG+EOSDlbA2Re827quSMWOQa3NtFjdb0pwbw/8fUGtsqYhHvjFjqNl5QTlCzcN1q7gOyojacJSQE2m16v+leS1rpPEEaZx5" + + "1jkDgFZBu+rV/47WIdqErTxzbZjBCotpJWalZQVrXZvq3FltTh4IHABvp7Sm/0WhjpslMFnwH/ReCswNF49Xo2XFBqxAJcYGBjYmsGFKgTAqGJhYXv5/JGj5" + + "eCwQmDAwvaS0mFpUYlpWTBX8B2lxWYlJuQETY6PFJeU/adOsmWOqK5SxlEYVGy0qLxeoQJWWFRoQg5gVGJcJYm6Y/odAT0enOxyN44vXWtlqZf/nvJSWOy53" + + "tvSQOlW4O8FY42oGiEbTmq3/s45GVodceWp9ZakE88Q13gxx39nh6CujVTTKQBrlzCGzds2apadNeG2OrKYNq4ytqv8BYNw3ZS8XujbL+EDv8zyv43Ue521e" + + "9rB3Pc177+V4z+Idi/cr3q14VbxT8T7FuxTvUbxD8U6wdeO13KrzfxGureF4+u+RwYAgGDhucxDTZrn4X6IomGvf20kVlghWPu//Qx1Y5ylKFlOLy0qMCUbl" + + "xYXG25z9/3Eo5yrWlgbjEpOi0tLiktJcK8Nce9Usu/rv8UoYt5SxdBrv1OZJhf+ajC1m83/Nyl7UtVaDM27nO9JmSeTaLLtWK+VEoeLN/1tccOPiFdky5pGt" + + "POl81tHKd2qlF0I8CjAU7c/G0xGNsCwD0wzPgetF9hkpGQngulFDgFxjjqeVlXbeG2X+f7wweTcxvaBxXZyOSclnNLc72XXD5Cri+mAcF53s5YQFJOvocGQ8" + + "oZlgAbwNRnrhdGKIshc0XOTIkUMKDKJcNRyJVr66lL3/RRzQ6DKdzGwQwjigzsiDssFC6AB1OCQOjOvlJAc78io6JSMkJKNOVsOUmbDcLkvNbW3i3Nn/o801" + + "EqOj+WSbERZjpOQBDlgHZ2MSgyQC53TR2HCgKYYJqVkeGJ2shGRkwiYGDT1xLpMSEAgkaEKbTseTleggBCjrfDimEg8ZM1wjk4sErOOEVDJyvdDiJcJQTj5D" + + "XBZIi4KtxZs1IxIe3mm8oHA4nFSdKY0zMvIMoDHVXdT/zZVr3OTtDidEKinBZNjBs8FCYlwkJhmJEliHhAdOxkExyVCuUIZSgh3xfghhJDxwMBSTDCWK26zN" + + "FcKykxMsPxhCnQptRFiMkRZbFoTnCm02pBckI9DmejIUbVC2EYE2JSMfDWwICGE1OB0OxsngJcaJaAQitW4309H/GywjKRGpkJ3ATdb/S07PlePKUm50EXGR" + + "TpIIosZV5qGpcdVtoOwiooUIhYEmuvG0sUYU7f8XirYH4yiBmrQDGzkBIQLmLTXrVe2qtRKTzdU5yYB0teJFRO3sTd3Wavf/czvZOPfscGjWYi6yGCYNDz10" + + "TU0a4f93aFTUojKOfYJy3m5BgqtuNUU2BfNcTcp109Mop9ar2+HZVMbVzHV27Zlqbb+dqt32f5PjhVp7JmrSTmvlSWOHo8SaGNIPTHSNaEr+a7AOJoZcZ28q" + + "0y6iWms6UfZysGmn9SZpnNJiT9VZN1tqtgxsWfs2qi/3f/Qbt6nNUIXn/R+KMXPkLhkzkYY6V3DLNHZGzbtlrTaHKU7F3LfLtVmax0M0Ui3qEyrhDYZx10lr" + + "n7/bxYuqE7YAGLmAWpfe69zZmWeuGMSssKzE3PjPcUlRieC/RyXmhgvM6GXZUnzqcORwV+3G7X8ndLIc/MdOloMPFDq7E9R0N2ORGLrWhUgrai/6Qq0n5Tio" + + "9bUSf7QpQW9F2SE6Ow3irh04SlEIbVZTyGFtskRycrjD/zty7O0/Jspa01PEpZmQ1uzqIyKlIiV94FarJuU6rbUQrJKWfjK8uXay4pbpBMGotKhIkGO1IZWU" + + "FlNKqk6M56rEwmKCNVJMELCwuMCotLi0NGclhi2r/e+RkXIkkUrGE6UtoJw5rmzuPlCtDZBpcESbMBUpSouWtiIngYmFBoxRscG1MtSulde7TE9WXw5m2ShU" + + "/w/NmEGSZ7ojY6tKfjo2ctpNspgqgHFpaclJLQcz193buUVfm7nQGRU5j3cYMlarUwaCaHehtLlGbsqZb9SqtfNyLysT2GBRgfkPmtER+QBAo3bDfbf8n/Q8" + + "rs2xTu3aD9T63kYB0JfCvh2dEQVLkMZq8e2Q2xwXL6fv3P6/eLU49oUfdeYab/xArXNTbgVyiqoTlnLMHedp1KSNsQAQNsueIoblvJmjqvGC7Px8QPQ0QtEG" + + "eWTMeCGNrHnnrRF2nfb2hmkT3s4y3rhJ2B2OWbu46joixp0/tVk4quatdXY44s3N5Wzj1GL9yBtX1IO7SFUfWzsO8Lyzu3GLdaZsqkPN2x01XqtF1dyk1W48" + + "QRQq5q5RFT+lzlGbWo0SgmA9ZXM4e9apuNpEKkUa3KhZ4wqmLI05PhBK7W1FDmqdb+RaQFWLkQrHuW1wzDDPNIjWskaWFkmYh62pOEWulX1hrp3xxLevGiYS" + + "DPDIPKOMBo2I+aiUzldamOUcU4pmZhgBAPMWABCggEgsGFMjOQ5+FAANKzSMfi4uKDSJAwNiGBgcAwGhARRIARiOAQQ4QBEoShnvlGzhTh+71PGHW8/LPZFm" + + "M5QdoDUh+mrnQCaps6ic4dX9uqzV9B8pLLnXqiRfxvxsPmL1KHdUlNu1Zrf01vQteZXFvVbUFCu7ezc4ofbDt/A4h/uU1MfYdtrQMsOH5LrPo0QLbVzmKMWd" + + "w1j1YBQqN0qcM9FCAw9vIg9Wqh9pvBKKPPJQGGQ4wlq93IPv2t6anM/bYTMY3m/GXvXrPX9BEs7fy2NkfMk0uw8ICPgFgLsl7GJZM8Rt3dTHY5zkI7qy7Mkq" + + "dTfTr2Vvj311Bc/GgR3tgROxbhk+Mi+BpQOgX7hYklcotothEv9jC9x2tJyln5Ut322aWTUWf+vHB64EWq0hsFBZ1s2jDepQWwjn1renoENoJ9Q45D6TdV50" + + "yAkL6D4kdzxevpO1ueh8h+X9nRo/iHu2FiMWm8a5pu/xwMBmWL1tmDkQDS5j0qE76d2m2c4PCdrN6nuk0UPD6IyJxRglekxxivUQ9lZ7sXdHZO0GVffj3juJ" + + "KJGfHyFdbm8bibs/r8fCO4xC0lBEmYlHDE/2QJsrcbLw5qc98r9dN6/gM0W5TxjvEckd5YC1wpO20GGVO07HpKZm8efcMbRmGGJfDRB1zM/yuWZCNpXGIS8B" + + "A+eMYJsFIIegE+l5LtCHb+tp/6AjhKMAf9x9UCCHdzl+ekX6O6qv1FdDWjfQG4qC6pdJozotfS6zpbeJcXe5bp5K1DyiMrjlndFAW5YoUXLn7kHlccIE4e7K" + + "EeGBHOe6eP0nA+XGj8DsDzjZ/Tcv6LT7gTYT6yvskoMHzy8cdXpgRr29TziKdm1daDjf8eOgbgD7SlOPg3oqY2fxJ5fkAfYTrRhGox+pw+HfswqzhWoIFs94" + + "cQhww5EeIfNdWNZ9KfmXntVxMXuPpQm6quyP1FudFPaFJkpKkC2mK00HRYp3vEB4FthH6Lueb1vXzEFeLg7islK6Rj7PXzP7KcNrVkZww47M+yAKDtk6OHHF" + + "f4n78KVIDmNA96RQ7anAKk4W+D8EwfHZIa05/eRi3+bF+QXAuULnYLyGqpnqLN2sYfIIAfdcUGVN4cfr/EpigOhno+FhU2b8W5276aixi3XfLnZUgWS82YcW" + + "2Lha6DXZOpukmrGuO6di3505KKHLlEAfmObtCtFrH4MK2PmEVS3fdtv87HEWVgrNgWbZlcLFgsNV/jllZ9JaJnIBXwmG9xF3My9eWjlsU7u5dwEgZ8EyVWwx" + + "oe1BmZVpeX6roP+82R2BIHE+Im9YFx/X1MTlIVDLj8zlv4i5iZ5UzFQ64cPo+3dEx3gYDrvSsg1cFgbjJhHh5jNa6zbj2TNoLH0BoLlnHcJuG/HFw9ke5umm" + + "d6rzt8E1d6S+y2whHydJTDmc7on/iq4Q1Y6FF//uR2CSN/uk9FI6ldmB4w2e/k7A/67hRh7R57alHkZZouATe+9Jd+5Q9i1gftEol0lpprfliNBHQ3d96gnW" + + "/hgpP+bnMIgQiN+ekYgMew6L6rkOJdsxsK0VcMu4hp/H368moYkYJT88b5OTGUfLm3OL1HY8vzrjARNv5QeGKHn4QGd/98nK/f2yJ8zgndiAsgvS1fPQ5Zl3" + + "2gKrzz1tG087czZBHaXO7kc6CEOZitCF+u0hHim+niME8/6Fb72wZ+xjlKIlFrJwbuB/aFNL4e68k4QKjZSm3T8XoqM8GL7pn38B4U8CpyLB18IMhXY5duCv" + + "kZmfCdGPoNuGRKNDutFn36tSJ8iFkM+zA28e8nSu0uAm72paek91s6HM/BVH526e0vMRZiZQm4Wzd4ODCx6zYGxl9B+eYumC/YLFf82R+p+ekJfO1z39ZE3m" + + "7PhjGZvKvxucuJ90gHuaqeB2cIPQ3911PQ9EnTn6WJzSP17jqH28Y5m+F2zZeXk6ctvb2VMEX/e/MH4vfGJRBTnsI9vMTbgTXBLAzSOsGVSr8XaFOwpvlSAT" + + "syPdKX9r92h3+JNt8WryvjoiIzj+qPKUgfeBICOxielCeKohZF0X4ifGpvgGZoDgq77StL04n9uadv65uWPP0X5lvgzNF/JNjgozBW2hE/3NEPWb6Owqcptr" + + "TYMd4bfL643E7YT4Uuar+Jfe5Ig2zSl0pnoAJFHMBR+eMPRuKbyXsPPLql7wmBZ6qj5Y+TBPbNWNgv2+wZOKVCAyhRqYBkkfDHjjx3d5/HNw4cwuMMbGrp4L" + + "PEkByhWEZuHnaql9wB3tn4ds5nDfdC8Q5KxYv+MrPCwR1o5Pm9VxRmAJY3Lh3IFys2T8B6C3wSJwbK/xG7P3D5MFEgMxv8B7K4gobbGOcTjSh8T2fMUElP7o" + + "nzReZXLZxZipBtq1W3zPvmoKRPcwlGv6uEytfoCUyePbtodRgaIP62aAWaQFKPTGzXsXi+DGK6edU+nc2/yq+9o2Bp+P1um3jnFiDayQBXzHauzJLK5xIf62" + + "BXc1qvPyWkv7sPPWgVeiXaoupYMG1Z6XZH5hgSCX+UsCVsjlVk8xXVxjsGB+1WBeYX2U96MP974DXvUUDw3IXlyia/F7m/6CtI50rlCHTsmxeXjDqRoeGFC0" + + "iCJiVz22A76E3mjV20YvgiX5kA4+EdSs3ZTSYNSOJGqfjoKXtdxV8Y5zM9584quHSslLFN2/avXrZFb38TzDodvtv1v9ff3OXnlT/TDyFPwIs+HOLYHmeNbD" + + "LjpUC4QZ1Gm0UGsj34/8WH/rwIE21EpPgmc3RKc4k/1I19+N3pVnKvsnNJD3Cvtq/JZHvVY/iI5fsDYjg4PniH6uFZ5uYvK+QHp1Mu0ZYyUEzbhbNAHkt8rX" + + "cyW+1bJcHQbVimokQl3rO5Ps675Z1bjry5F199Rn+IhcH+9AToDAmjG3LBbaSyb/AF3tH5PpWOvclPIOBImcyYQ81y0ZHuIDlCAvxG1TZfE5Ft9e/fSLIC0g" + + "HL8vU4vgq325Pj/0VDnOeW1d+XqXoLgJ8UW3v2fd0tiDjpP70xQCDLf1Hec3d3ne7JImjEGUBsNNlyH05tpiuoMFgMIi5CsWdBbGuNsVmKmPgPNmPBsSnxbK" + + "CBAaX9r8euOeOlpDle6AJ7qt08r2EKoHWiZ95JjPJtCtxuZVaz2TeyK5hyWZhoRSERXOQsHbLGa6hoEG8Ehs4HtR/uw8nAKv//V50JMVP4NaXzBrZ2mswZP9" + + "9LnRxyGIE2FFWIlF0XwXZfgSd4BZ2Vsguk5dKFiABgKF/lCCIZ6LKcZPdQZroMuWa6D7QEjVU/fWVtJ+7jsbsoyMdUohHgZqt9FaW+zbz61xeTbGJcQxREBB" + + "lUh3S4hr1912SZS4yByY415l8M5b2LsDyGv4dUSqqvM7YmgJP2E8F4kYHrYjzj3JzIDfODDRsBg7Pxra8/57UgeZPczDtwSfBrlCR2d/N+SqrXdM2kJFpYyo" + + "2RfNoMxzw8zLPWATJNrzTdLUoE99IxLVrytue9nFbLbpjJwqtzpHEByKuBUnZ3agxNFllqe9ZTXPlJs/LWrqyfaDmE52s2/ONtm6W2dGCgmdzZMBJkGk0TFa" + + "+/vWLjZ94LB1yc21pbWJtniKcqRQ/ZdEBgFv8hHP56AJ54A6gmcP+sEC3sWJOgGsAHk26/dZmRqwiQPF4FvPk65me6mKq2oMsGVy0Tk8HzKUfbOssFx/VggQ" + + "OaproKwZvl6KYcHiWG0aFuH4mx0L4kWMvk0I/0PS/sSNFXWDBNI7FrTZvr32t0q+K9MJXYzxA5tRSl0ImVYI1K+O4AvA8Go0x5MHyfrrz7ck54XoBRjnBBHi" + + "qLU1Gezx3fC77SB6OrgXnSRP9SqLv0LQRNx5zjDc/9JsVqTYny7EZh1IahG+3NrY8XDIPnfH391ySw2J498lNZriDiSZA4red3/3ZjP8KyfZPbn4xHy3A1+b" + + "BtCjT9N3TbF+JR5nqTML103FfGhbxRjCU5ePzf0R7uyCQ8u7pZti8NpgaE+2vTVP7kZd0NZAAIa+EgOH602Jvs+pzrpeo5byVaKugjM8c/UPEFeRc8k/RbYm" + + "Cbfw4gBmtyS8FSSp3kXyJ/NU6Zn1nXmuWpHSWeBSy7pQ/WOVA3+lwoUC/gTNE0fbV/ArMdFNFXHlYLH3fEeDK14pHC6w67WvjUxK4+GBODgtRp6xKRiOf04m" + + "0ojuypHzs30SPeITnaqXpRTp+tMzfRRx37Zr6Y+jQqTA+yr07HyE63WcVp3C50ERf82E2YyXhxA5Z4iO2umvUifgge2Rjr+4dJAhtupwjW/Rb1W7L0+ue5iK" + + "V0flJTrn9t5W5UX26GO5wUxOpvRGGNAl+2JazjCEvGL+wQ5tCtrT/Z6Nq2wIcMolzLHwTWx55d/4urm9ECineSPicBYnOsgaf5/b1mzZi9P0FZ5XnMC0lvAa" + + "ODt7CoKaexZVO9Hz8sumpauq/Kj7nooc8Q57BUxbDymwd/DLnl7hOQuEZVWcSAbHetNduAtt6yhI+kbVCcidAmOfqEPA42689ajhU9R/JvB8Rn7HSiLU2RsT" + + "4EQ31Kdy/CBPlaiTu5q/e/7h2PDEYyjF+TfJ/LFgor5L4y8x0XZJW6dhgLWjOT1xMytMo8eXJtBotPhdysXnl914dAmrWS8pgwvJP9anVzAe/ikoiL00ftku" + + "K0Rn7LbtC/iXc5eLScWEsPQes30lyQZjHBX7NHaxP/awIEdUZ2Jh2BAq230M3tG/secsoIhUvgHqBglYW6SCYfvZHN8QsbrYfkHGgNdx7NIu3Adj1icXoV6S" + + "UGDka7/MQlx8mi865IQdf70PBLOnOERliIjh9xO+iNKXVD90ve83TAXDvlwtY8fcQqtsvybLm5qjXanj+473be1ge60ZVgn1z4JvbE+8tkM85WR67BUrHQCd" + + "WyvmIPpHcRBMohQM+F0iXzF67IkoGnNPRTAvg4rog2vpiEXGL3aXrd/8xn5m0kGx8sLL3hp1WwwoEwt+gfNtupXT3hUGF4az+kdRGr8Zek6JDF+khNEg4DcQ" + + "/Tt1s16GsSZkehVYte5A7014xv4Pwc+5ng+2XH+HK+KlwEO6zG0I8SisumcAA3vv+SisXp4hejXhHDypW6CBzQinzK0ffBMMdg8iH0AaCS0Om5Z+ricvN1X5" + + "AeptfsP8nDsKpmNxdQfAyvuZZq+m4DMYEaCcZcCensLK7HAUBZ/BV0KKLAPu7ihsGR6jU+YzGBWgyDLDTofCzvATNAWXwagDijwDdvWU7YyB1yrlWinZkYKa" + + "Uw8UKk5lSKlwaiOlmoMcKNUZYqRB+XHeGeXJ4Z8ozxx7onDg/FOKk/PZuTEy63uktXfAvBtC53uHyylo8NKw3teCS593Ys82iNZSd1jhfY5xqS+P7y0HR4Gz" + + "ilY8/f+uw/264xJiyNLwwPF1jv01v+35T91lJ9H3GnjfySMJ3QIxI/naJeB66Y5/VKgawxbnMaJZPVWQHb5+pd/pRxeBxB093D6yw6ZTve3f6a4gD4gEMAW0" + + "LWddyHl9kulirEnq/t+e8UAKR+fm873F80TmX/xaDJJHCuU62D2hJ37JR3iXajNIfaJuCR4fIr17Ub42A9cHgrCXqAieO9FaBxvrMUrjDZKSM/rkEtx6JemD" + + "xz98DwO93/xrO3l9nwGCH/QfDyDU7m+PcH3VIPxvfJdHVJ+RGb5qdSPHYkfgAsL1XUDwv/FNHlF9oGb42uqKjMWOgkuE21cFwf9m983jMfg/sQNgd7wA5wdx" + + "gnSDFvD5wk7IbXgZuB/sAPgWWcL/i5whseFl+D5xOZdznvoKuPGwy+fH3uv9dTuj5N7ikJs3Jb7dsXaK/90hQyC2U8sizXx00TatMsELri9YQUYFrlGyUogI" + + "Xady5BiJPXxn8UT/nN6W2PLAb8zXUa/Is6ebaGed1szuYtrZ1UKt82nPOrvI3CJQ2Ge+tpqp616gzGHa7sguKH9FW8x37DSuhv6wfmh5w7MtC7vJ6UC+Ap7o" + + "I1J70to1V/yN3mKhiBmcneCVuenL9uV1QuAqzFFBrFawlpe8H4+CwBTkXPN1K9EFMmoSfHM3FqKMGd48a7AV7o4wiJyqfWyDjwfFNaHJTAmvwBAJUfXWq4wT" + + "noZg+5JtzCgn9+DzB0z+jHgrtvKyw6bKsPrnusjc61ECc8r6F8NR06wyhqrerYnwTAV9wJYu1MBy4O1TskgQNmDR1dXk5Q02as/G/HKIbouH0lT5K3eBrVIb" + + "30Mb6m5KysjEXSicUTuN8CPndEXPUVprHLBA7Pwjdde5X/dp/hMU/mPE+kkZjD9HWc/UoeADO1wBZr+QTnwo4LZV1Vbhb54f9q1gxoLlaQyVcbUbeDkmrz1/" + + "S4rDdKb/b2ei7VKpf6vJTdqtsVp5L41d7Qbdo/41PygNDOut23nt0On3kOPJ3p1XqoMR2v4=" + ), + }, + { + "name": "operating", "size": 48631, + "sha256": "93732bb0bc042f4da0f90879a03dc3f3e374b3b45000840b0cbae142c42601c6", + "manifest": "{\n\t\"absolute_minute\": 1872,\n\t\"checksum_world\": \"5997e5197f48fefc64fb9cee1502bf9116477c69d7b519426d02a567e2c6c518\",\n\t\"content_pack_ids\": [],\n\t\"created_at_real\": \"2026-10-09T01:56:08\",\n\t\"day\": 2,\n\t\"display_name\": \"working\",\n\t\"enabled_filter_profile\": \"default\",\n\t\"format_version\": 1,\n\t\"game_version\": \"0.1.0\",\n\t\"save_id\": \"working\",\n\t\"seed\": 424242,\n\t\"uncompressed_size\": 1020364,\n\t\"updated_at_real\": \"2026-10-09T01:56:08\"\n}", + "world": ( + "VFRXQgEAAADMkQ8AAAAAACi1L/2gzJEPALTSABoEVS9asO6I0gHyje+HFR/TNxi+2PgjqPj9GLx5feFP0rF1Nv9mZ5VbzwLt7+1Ddpc/tu1LkmyH5QOhClmg" + + "mobBhE8Fw6ckpZQplbonnIsn8g8eugLSN7SBb+3/RnYKTQNBA8oCLRSGTRt+oWIj5cUNNyQbMlRskDHDSo0aKZl5orKwSWSEJLumDCMBY10skYUlajxSJ7ZU" + + "kwtHh5QXmfnh+cDELDNHdIcaAVJSIiQDLtjEkT6ZOaIjqchYKJeqhcJUaKzQIKmo0IDRqaiXGcvzgYmZedIy7cgwqrKo7BM5Jh6LJFbTyySxsIygpJhNHapj" + + "QkJCBceKDRcpMlYkHWysxFhxkQJDeqFiIyWGCo3M5ECFBANGio0a0gwZmUkSs5A2k1EeimOiQ0mRU00ZNuLDpIgdkaIFuhsXQF+yyWwBuQBykpDUsCA1K4Aj" + + "MIBAPPR4geaJgAAl5EI0HWggG+gDEARB/bEBkw8WmhANazyfeEkYlU3RpURLRWXTFT/WBplT5omdyroomSpKnZhxqE68PjykzNyk1FJRGGaCpARSQYZZHMkz" + + "ZVaWmZuqsjjSVJ1IGBY5JC7r84nBsklm4vCIVUxmmuhE6hPD4ViZWeKKMylcONkEg1EwUqwsHzIThYR1qhgrh8RiSVmMlZkoMlNFC4pgAbSCFhTBgh49eqzg" + + "IzNXrEgoV3giVlnYFK/EYsfiSJd1XTEzR2THQ8XkkKqJk5kleSIzPcgu6xMvKasiTORMns9qzJVhlcVRkcPSkZkimIeastjJzBEoV2BZRblIlUVhEFsmDIsw" + + "IJSUxZZryjrUpoYZILEDMkIEFjnW9cnMXFooD4tUUSAakRgTY3rITBI9evToMTN1pKyirM8LJ7pwpBkPNXWkDJs8mcmBxsOZ4UQWyiNFmalEJ3pyTFWUKovK" + + "OFGHdX2klopiYZkyDyjQoaRONcHAWBwp4xGrzDwRmeHM1GCbhHJFtlRUp4qfzByBXCKnorBrip2KeslMkMwUCbmiSzbFHZk5UkLKIIUIQ2VVzJWZIxAGEzNs" + + "BsvMkVyhZEiuODN5pChDZZwpM01equmSYrwyqeO5rB2ZeeKSURNLZoYk5pmoK2YlnczUTNUEk5kgH57M1HQ8VktmgmCRc8VYWLwysyRmU4ZJEWZqycxNyAky" + + "U5NZLthnqrDMxKATsZjpk5ki2Ynxg43cELOYioKRYhbjsbAcU2aeZOYLx/JwMjMEykxNZmVR2BVlpAkmunCwzCyRmSoyEyQzPQgrDj3i5lZxwa1HG4M3j7RZ" + + "0AbAN48+gtFX7T9yGP/I40dug/cjl8HX1yNHwWnw5xF08Z5HkNcj2AJG0KP/0dtB+aP34r1HLwV3GD0S3gzOX3vkVHiHkSuBGUZOh4/aDf8etRfYedRacOpR" + + "M8EdjFoIrQCufwDsAXAwtPOo9alHfcI7GDUL/hd1C4SPY/kjluHeI4bdPOIV9mHEIzAIDMO915qjNCgCZPjBe9GuUNZwv+hZYCGyspipJTNbzHCqmFkfmNih" + + "nggImoB7CfwQ0IuPAAgOL4QGBQ8BCAP/AIgE7gANPAjNDW+AxgLOAI0IHAiI8gVk4AqY4T/kEJ6A9ID7kEX8jAYDzgN6uAN6Mh8uJmEGQUyTfGlKsLAHk4YU" + + "fvKtEnbIKxgIiISel5L1p4PaqD8XkYdaS0g+Fn4xXyeFe5wckwYNPgJQNHSJhwOkYAhBA5x4yBXgg0W6HTCATYcSrnPYNMZBpJ/DAYHA3ShZ6JuNEH2Q1yiB" + + "NEbyNQKApLsBpM2AusmwgQRCLUYNIq8NQNNWNE3DDDBURBrkL1yANJQBJAQv5aOlBTDSAegGAEjHAEOIOmhfIMl2IZ+f/QRD/nhuUokhQ0qMlRQcKZINGSor" + + "LlZgwLhRQ8aKitixOCkSsehEFtElY7HD8sQcLDCKBYvoyTF5qEkmJTO15QuVGCspMCQZM1ZspLxYiZGCIzNNkHCN+0RrzCfceFN8s5qAzS2cuObIpDX0ywKM" + + "9BVOuKEK2i+FjTsUE9halLxGocTxCSEN7ZowslzChzL0JHyYwEfQCJFQhBD4WGge5ELQTQE1EDQc6A8gF/5YQU074odHzEwSWIeaZK6IxWs1kiKHkrkilpkr" + + "MizG9LD58OCFY2WYSWaOvApE0wHsK7Z0oiczTyasmq4sM0u06FgWi7RjulrIqkh14tWCAiZmVGaOOCzGconXtCMzTToSD5OZjMqqKaYH6AeWSXLBphcrMzUb" + + "Dni5ZANIBbudHa5YTXGkJKkrlmigm4Emh08BBTZpVTE6Niq8pfigAY4giKyaOlXMsikzSzaJURe1QfHeiBMgHbgiKvBijZheKBfOCBPNbTBI0Reorphd1ian" + + "imrZkJxUAe+99957zjnnnHPOtdZaa6211t3d3d3NzMzMzLy7u7u7q02bNm3atGnTpk3b/////7+7u7u7O4QQQgghhO+999577znnnHPOOddaa6211lp3d3d3" + + "NzMzMzPz7u7u7q62tra2tra2trb2/////7+7u7u7O4QQQgghhO+999577znnnHPOOddaa6211lp3d3d3NzMzMzPz7u7u7q6ysrKysrKysrLy/////7+7u7u7" + + "O4QQQgghhO+999577znnnHPOOddaa6211lp3d3d3NzMzMzPz7u7u7q6urq6urq6urq7u/////7+7u7u7O4QQQgghhO+999577znnnHPOOddaa6211lp3d3d3" + + "NzMzMzPzO3yuNe++w+dac3Kw0UB2ogtGeXLEfDKTBImNBqooE6WKmmCsTmaaYBwqw6gWy5OZJk6wK2ZVDAl0Wdl0xSq2SB1KBRETkMAQERACAg9wQBANYIAD" + + "sQAF/JAAH2Ycjx0yMRmGcvWwH6t95TCeFx2PcoHwI+YWlthpjvM5JgRIPBzAAB91AXbQIQcccNywUcNpEOCGGTJscB2jBo96ACs0zLAwVN4LFzK0FAEEAAAx" + + "wPBCu/AO23OtebWFiIUVVEihQRgtCmyBwgkmuBJI4BEgw2hFaBYhMAgfrPCgAw420CADFSlQnDCBwUkJEiYjNiUkIyIhIB+amfginWw0nZh9SIjg5xutrgTa" + + "N1LdIdQ3gi+E/gReewT+QQi8P4DdAcovCHeuAe8Z0LoB4QvojeCTcbqRNxSMWTdyDcX6qLXPNpaPtnU+0jZp4zT30efoj/5S3ehREOA8OA1vybWPYB/A+SPY" + + "BGD9CDb1OoePXs94NvR79Gp4rcO1Afoj1zGgt1DAuv6hPScANvvgO8O7kUPh4VBiunUj1yguDYe2H7WUljXWjVqj9PBR9wv8qPvGR90CaB5179CnG3Wj1PiI" + + "A93d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3MzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM" + + "zMzMzLu7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6" + + "urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6urq6uv//////////////////////////////////////////" + + "////////////////////////7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7urq///////u7u7u7hBCCCGEEL733nvv" + + "veecc84551xrrbXWWmvd3d3d3czMzMzMu7u7u7sKFSpUqFChQoUKFf7/////u7u7u7tDCCGEEEL43nvvvfeec84555xzrbXWWmutdXd3d3czMzMzM+/u7u7u" + + "6tOnT58+ffr06dP3/////+/u7u7uDiGEEEII4Xvvvffee84555xzzrXWWmuttdbd3d3dzczMzMy8u7u7u6tOnTp16tSpU6dO3f////+/u7u7uzuEEEIIIYTv" + + "BYuUqATldKwYRTQAGQkgAAMdAECQUUwpVG0DFIAFFCAuJgwOCAoGBggIAAAABAAEBgwABAAQBAAGLgg+qBFDwGMQS/ZKNhgMqdIsgWDahgqiCEBioUZAgAEm" + + "o6AIkCRQKMJSIICAOikCBFgkgjBUKgCAEpshAAZMJAgVRRGAwEKNhAADREZBGSBJgFCE1UAAAXRSBAmwKABhqFYAgAQ2QyAMmAQQKsoiAIGEGokCBkiEgjJI" + + "ksCEgf10cxXMbmaBoj8dfEqnu+lgmL8u96KBXWpQ3HufZ3VkPQkg7ovG6WueRJ9bcfAyBf7M1LGnlKe3ZHyZEAz1y+dem7xNAY/8gnH6+ybVxV0auMsEhUKc" + + "1MI0s58d0mfL5F5X+fBCDijsz72vcrqSDojg5+qqWdqNUt4T0iZRpF2zHBJ0BWyYsAOhicJNgQVKdgEmadQBsFHSDqASqTaAOuTIALpQYwZFCk0aChssaCJa" + + "MKkjQoGNmUKFlGQlRNKRByCphR2CLKBMONLUAmKkzRBIEiaDiEiyCKCookIggZEyoYBEkiRCEUMqKIAYmygo5su/02N1cj0FIJgmlRJhRx2IpBNmSLJMkQHR" + + "cUMFxIYLJTFWLKgQ2bRQEuSa3E4mKOq702FtTFIMvTIJLewAaJEiE6CDhg2ASRVmQKxQoCOwQaImgA2RciCFTq/S+HICGOqvZ7RWiQzZbhk07AJMEqGHIoOE" + + "HQINVmwBZNCwE2Chwg2AVUqtHTC3Q+/K8WoCADCcEkXGDRkRCm+MhCq1JBIl044YkEkvxNBkmSBTouOCKohNwg1ZkOgvB9/KGYQ4dmk01bhJkELLDkAmGToI" + + "M0rIgdBiwYZABwVbARck7ID4mh5Vs705oNg/h0ibFJE03TRY0AS0YEJOhAIaMwUSKclEiCRDD0BCCzsAWqRo+4Eurp7Lo4U5EOAwKYhIO2pCJFwwQ7JqigSI" + + "jpsyIBZOKInVYkGEyObW5CqF0K/EDlNdCJL0/kyyAW53cXwZ+bfFPeD0C5q8tk7S7C9/XAvVAk//7Ffg6JaPD/rtfiukK8U1SCltHepaQvC/bSE5aPtqMdSR" + + "Wzdfw4k4RnrG6Rsnh8LuZ1k0cs8A3cbozZ+nMNKG0382w3NRXbJdtguGR6tyvwqf1iuEpcJ6JZFb3jGdj7mEg3W0ycI+Vd3WC75RiyuvxTlljOk1Kj/zRym5" + + "jsJlbswXVGP5PVA0vuTPHkG6j+NLheMxjgwrnu7k+6VvQZ2KO5EI+Xn+u25QLt/5S0LyvJ/AEJb5zCnvxW5CsoH1bWkiPlpMR2WrLiN8ASY1H5khTe87HSJN" + + "3Y9UjKXC7sIyTgOHSl+kiWdFYuDUT0uXQqwXa0b4IXhVR5ljFvNFxwdQR1MvFbLcUKywlfhKmTlenL3kxLa2blMv1VpcWGfsw22ZnuHiXMw9PksdpXup7noI" + + "PXO5hZ3Viu9S3uxOyrv4WxnhVujSHWVazKm1je8EauU3QYJ5TQ/xyaPvbXsWfkWP5kGGwHsgezzO92R41b4NFBaypifOdOCnjiabgjpT5VRrcYUxYjsO55ww" + + "nHjelgFizUEURvY8b06QyC9kRgC7LTTZCOTaKqZQSzeEEXaJbY1R5oX7pdp4Ft0aurGBmpWS8N7NIsxC4B5MmZpaXk5M2CK0bXKw8gy/C/vh/TNNyVMFQz7K" + + "xGEeQx//RxsCd8Be67CEkT/X5JiGf0Ve+ygzizfNutgR9qsUs9C1ZXDzTi3+e5jIszM7SV9miN24HNdhwJN6nZNfmMvZRJLDfObSSMUnz/Bk4aFu8zUx3boM" + + "1EwXxiVwaf8VkjInTpgxYGnvhYVkgIAhAQUSDLBwA8MUCgQYsOAGBgkUCGhgww0M8gQ5LE65bwH9hem+rvrMA/TF//Lc91cC5gtIPxTQ/8P7X4ct982fMJKT" + + "ZjWOv5B2KbhJH4deTFKEZ+lj+liiFJMoYlaOOUrx5V+XkHL7P1fpQP2YlhyMdwuOpuOrYlx1YV9iBsCbhFpI/ey3pupc3N589SlWBZROlF+wVehL95iCAElQ" + + "Mots7ixoYMbf2ruagzPXaGlhumKoaVNuUUnGrSPujzCI3UpxoSL2kFSqdpUKYPzDW7mb8DnLx9bRVR/XPe0nqNAHUDlA792NxnOFnXHN2HOei36nWBnjukGW" + + "j1GkfQinLPiSsTqNM43lyhlUYe2G1j+phMmMqQalteHcMjhIsElo/JCeSd+/xftK9tXgBh+Q4/lIB5Z9Mo2HF3VtGx7I4mWQWNUj3u/kadv7dT/DaawOhL/h" + + "WxoDyya5oi1D4UEXtoST6V56xNsgXfRG9RhtvnXbMnbx79QBLFtybZEezu1ssk1B2V1c7bTmN7t6p/CcMEgcNPb3Bnbb29rgbetWfSwz54YLDUPrbvqHUa0D" + + "NS3ZE63zdR5H/x9Ea4YOdLoqo7Xue1E129Q4wr1PanAdec0Y0yVZww9abjqZzqyp2QjepkHGNTKxPZS56cwgnU0H7WxNTafgbQo6HSOTzaGMm6YH4dl0UHfL" + + "1JLgZRJ0ZserRKY2hwBgHdOZpgzS/PRs+tonjSPongTIFTlZSimf9snaopGimSBiCl9L29RIwD3T07HRWcvUSHAD7pQPCE1Bec3Aqfkhd6YnB3U86OBgspRO" + + "PnOtTyftvvSYk+yZOh3MjD4NtePB97LTAzOpt+fs8NHbAPKn6ZjISfccsJrNwMDPkLV2GlDkdBH6xN9pNwVEHaKyZU2H1noVLoFPv2vaFj/TRBAN9BgXSptI" + + "16DzWXvvxhNZGT0aZccD3MtOh3RAV54MXOfzWCf9Gt9ZJT069h06jm5nTJbyxCfeQcdasKZpqtd0bgwEHijU6fSpg7I8cSQHMp+e1FEsJxwePOjGbDoxs/vm" + + "2KZGBBswYz8oNNnS52oAho4dbnuZvEgnT1yVJ053Tkc7GTUdpB1XAXf4aSZI89NJO2qbmnYhMFjphH0Z9jK56TNNMPcI26BjEuhl2OQp4/1liyngP0cPK6Sn" + + "8R2rq3e3trPqkfGiz2vytp8CzHSENeQ8icxL4clz2DfSCTjTRFGCNAToJid5wN2UbytM0VS20D3gTBPMfG9dhsCHGre7nUxIJ59y3iNXOk6EZiKd6n7PZXOy" + + "2jlToFZzff5+ibnpUD8IW4rXNM066clTtf0sQsdvCP0yJeMHRmZN6DUeBPZKOFZ5xnnzzVasd/S4HhVedIv3U3qBQ6VX03OZKc0RcfxUS28AbgYi/X7dRRNP" + + "o6Ye9Ze9VpIg400gBpS93ER4RBQh8MjGYOUDThNB1zdETC1ROdA0CbqSIcRkiWIDp0mg1y0mT4tMbaIEDMu5ZEFp8qnOZ93u7KeZEDUHnawdzf4nRws9z0mg" + + "a4PoZBHKwHkS9NoQPbVEHYcxjDVuU5Cc6OXvwfLDVBKNGGAtlQX55Dl8lRPv+Lm+vybqdKiLYjlxlIOAG/sgdLpKjus1pghk//wDwKfC0dSeghtXBqU4Ujgs" + + "S603JO7rHBWeVfSwDagNSXtMFGOe5QLemQuy+Nfrb9LoZYVGa3jRGJqcK0fMYnXlpimFfjV4uFgVMNdP0XNqQ4RnG7ZvDIP0AQvMdib5gNXXGZAoHkQuTE01" + + "JFUturM3mMvIwoQqAH+ESXBsV0bY7zH0MlHpcxb/ceNKFQbM+rWikHjZnfPMDkJ3+oW4yPwkDu7NzPB+lAJK/XB4UYwll5nQuSD/3UUJ/sPiyiZel39fvu8g" + + "PK6ajqgld6ZEwP2m1Pn6YcBhOUjzTYIu7rcomHKuCxr4KILvmuZKDSTDnYNwJrmYOFesnxoD/nFaFNQH5VjiQwg+15orbCHZ7UIJfsO6XuTrMn9KJnEwmslz" + + "VRDCRxB81zZX1ED87UKEHnHXm3Td9w20OoVFu8Dn0DScqEtKvoWw+y1gZjB7wjxWZj5e27bxFjyTBkwwAXf7l0P/KJ8vkHHYYQg5Xyj0wTnG76XqyLtqkQZa" + + "cSWtnNdc6ZzIBh/kA0l/QYt1IMlab+Gj4fWRKYxcp49M3hq4fCCqp0X5ZCGZR6ODRfucWfnxv1D7P8ik4ZTN6jo7RPo/9FqZqGyE/bMMkfjFwsD2Zx4/sKm0" + + "61DPnnuJBy52jbh9ieErAlgLcuLVE42sR7muIm+SbcRjXDv5Att8vZYU4CzbAS7o+KH8siv+BtYNbm4cp9kIBZDHKnXkFUTMBEoYhOMcJPpsDdB3Y3JboO/4" + + "+yWIwnGkALNFjD1r+54G9UB2Dg4CHe9wusr4oMPZkT5Rlh8r63+vqv6rPiOQiuORgVV7nO7i2SBrE3r1pxCV42oktjK0UMuZiYWaVYPMiIeqYV44NK+4DwYi" + + "OY8IehlbVh9YpaKh1JmJ3eGDavVkUpUEafVkKQUxYR8CKnIKmWE2iqGsW4Wz/d9yoJJzHg/GivLMzHSC54Tya70OAxQ4S8P9RW7/oHxkKtbqDFa1TRpAlo3z" + + "eMkzl/w4f6t/dYbbryDMVEnCJ/A7mcR/ojmI1yZmp9vgddGqfrmMzV/ZNwCXsL4D/lxSfnEU1mzJ/q2FGSdobFggr/Fap6N+1Wz0t6VsmnTzv7PDPz7xoSRs" + + "ooMH4UKX/Xm0TlccDElLR/o/P/shMTIGMzomZPPVaL458ljsmumaegVZaZ9WvKXlwq9Wpb2qV6dPlv8coZeRzQ3PI/9jccfeOUUDcEaF/pDCiT0w5gay36YF" + + "87fN3lsJcr0NI+zjK3lN37D92eZFt3J+Eij9u07FnFUQPCZ52aEb3wTqyMiK9TbHOvnZadLnkYmUrmqPpjqtBSAWqmS/jgh1i6hj4ANvzgyLw2b394QwBuEj" + + "RJIQw9WiFldioO+FZjL5oGm6TZesfff1+x74n15zx0LrL1uVJ62xS05yLVc4muvPv31sdFy8LP/v8v3+rXIjvwl915y4dbnoffjdXquSSO+jHHpjYpkN4eOa" + + "zWDOrL//FHiStpjvb/jR64hjez9EKwCKY5gMIDBTUmzww67Zzo4kalYhz0OmBipyp0ySfUnBoPaz6fskowC8ALAAVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV" + + "VVVVVVVVVVVVVVVVVVVVVVX1/////////////////////////////////////////////////7Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt27Zt" + + "27bdtm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btkREREREREQgAhQKhUKhUCgUCoVCoVAoFAqFQqFQKBQKhUKhUCgUCoVCoVAoFAqFQqFQ" + + "KBQKhUKhUCgUCoVCoVAoFAqFQqFQKBQKhUKhUCgUCoVCoVAoFArv7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7szM" + + "zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMqqqqqqqqqqoqbdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bdu2bduWiIiI" + + "iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkZ2ZmZmZm" + + "ZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmaEQqFQKBQKhRLHcQBoaGhIfMiwaEw0NDA0SDCO4wjAaGBgcOjQYSGBYWIhwYGB" + + "xAJEo6JicRxHgomFBIcMCwqJEAsJRgTjwwaKCmOAoEOGBqOCwsNiopGhgoICQ0SHCYrjOBREHMdhQECFgwcXIkyY0CBCQgULDSIqUHhgAcJxHAcYHEJ4IJCh" + + "EXEcx4BjgYcJBoYCVVVVVVVVVVVVVVVVVVVVVVVV/////////////////////////////////////////////////2/btm3btm3btm3btm3btm3btm3btm3b" + + "tm3btm3btm3btm3btm3bbdu2bdu2bduFeKhTQG4lSWq1BkMfikjKKGgHE4CAwIDAgEAgEAgCKwgoCIwgMBP/m4iulyKoX9cI3f51IZ2ORa90uAldl64qp1u3" + + "eC7ogokenNEy4KvLa/yIo6M3vejqy/cbjTt1dDFGJUSM7p8c+oXeNul6Sbf/KN1VpGNMPaZHUxWQrhvSfUk/KUbdS17dEcDKpCs9G+eCcVpLM/YANmRdL2co" + + "1/UCcBroYqrkXIzgfnJdjIskWxcMdPP0Fm9oBkWnra40Di493/DVJR21HujCdJ35uRi5XHXUD0HfBVheL6oXIW4UXarVeROqVteYDwO6XqMXga6RJTWjAJCA" + + "UEAwmAAUApBAUCgwAJQUgJhAKCAQDBSAkEhIKAAZBAiJSEAoBAgMAYmgSCQIEAwIgYhAZAAUFggBiURABBAUAA2FxEAEIhAEAoWARIIkEBQGAYVAAiASAgYR" + + "hUIBIiACBAaDggAiIwAlBIOAAkEiAAkXAxyU3pbbo0ivFBthq+v1JqiS5SJrbPl+iSmKeKnaiq5fKTWBLNqumuNLVkuMkdTbcvYo0pViI2x1vd4EVbKsyBor" + + "3y8xRREvVVvR61dKTZBF21VzfMlqiXEk9bbcHkW6AASBACQSFAgmBIEGIBIQCgkEAQUiIhJICgADAyIgEhEIQQQDSCIREggBBQFCICkQiQEFAkIhIBEIAYQF" + + "QVEgkRCABARBQKEwEYCKBIBBoCCQgIgEhMFgoBCACIRAwUCg0ABIDEABwWCgAEhIAEmBYCcCCnoC3L4AKmyUF0uwVrEOstJ5x4nD/+VvY8zF/0Hv60OQselr" + + "PAXvrv3KdqUcDH2NXQgVU4EWwt2HflIAEi8ruGQOpdxyRf7iYtMZFQwjTjWC+CX6m6RWAWoBdAE0WI0MS5PRvFzULTOTvdiZG5PBaLAXK+PCWZoFawurtYBe" + + "eqccbVkamxrZS/S61D45y2xna0tzI8zaGPv/KVim//9ESmXYBrF15uWy7dqyShPnfEV+rk6Kzv2u8AQBavq2vXasc7v2SMEW3+Id88D9xuXqut8un/veMHBs" + + "m2MX7jsybffaRfV2r3PoGrfqqfsObev1nKNtbq9zcvzinBb8vxfzdBfus9hleH51XJ37xcH9ju145/9bct7b7ZkQw/D7/ypbjLNzP+GkIGeO5/i9zT2+V3aX" + + "cbfXbsGx4/u1cb3LL7+2GO63/w/rnB2HPbb3Ft9z/PW5xzk9Ov8f5sw5nf8HQbiX/l+1qvs997FBDKakewH33Os6F99i2b1juNe2/2fxKOBydJ2DI3e37nBs" + + "ozqu5+ZfDO9SsQerDS3lsnMtf3R0pESWu62+5w6CTOe4d5flt0IsjJ6sUI2eqOBPilKkT4pSoEVOUJxFTk6YTpqYcNLERBMmJZowIaEyWTKCi0iXEIVAz9+h" + + "if4/RZa77UbXOB4KxI2sRiUDKcPLuVts///qg0xsramRvf6fZca2Mfb/Ux/pA0kD1aHG1NcQvfFFfFFJqgcekgX4g2EYRta67I2s5v9VpZLnweXF0rA0FpKH" + + "H9Hr1B+WGZPBWpvabMa2MZg7Y1sGqxtbaWy8E/qjcpT0I5OJrQtWl62xNQdjS6utMxBYl33FWFi72vz/6vRx9Mcn1b3qwyIqjSaupjZELbWlpv7/pI6mleqj" + + "+khYfTogFGQa57bfPmGlqj6pk3NuokIwxyp36Fuv3ZmOXdLUF+ZEGXbmtbIzt4VBYP8fFYJpjoPerbq3+Lb7/7fcMcqW+86d+/+w545rOq5xLtzH0e2p31tc" + + "v6DGm5Wl+f8SR0+zfJCnr1pYDYzGlZmtM24LWx/Q2ppNDOY2iMFoAT9ERfQ6IULYtlZTI3t1pQQ4OO+tyt1utC0lhEPJYegjDaFD3Z9DKk9T0NNZ6gKUnJNm" + + "mrrOFBRNIU/neVJR01SxUfYtvuu+Q/+/qlNYgecuym/uZvkuy932/y0nHmBoMn0cZsGh3ZrFwlK6vCEarAE7c1sGsBma+/8AUBRFUQVFJRdFU+d5Dp1DNoZI" + + "C85zKKV+MAzDQUhqECAuICoQ/iP94QP0Wj56kD1OX6sHC+XojhBEd3wwDMM6QE9HapomigpBU4hVCqFCUEiopQqdPqEXUwU9MweMWOYAvTIH6nUmDtHrcJhB" + + "qe7LIBYBlfdWMkdTkBqEggyyITC/t5yOimmmytG0KoPOMghFGuRdKMugFCdJMg1BcgZrRgi6ZpgvKLIEPRkwogzQc8kQvS6GKnpdDBIIiCRJIBIIgwKgoo8F" + + "SQK5RhOQCoSBBLK5MdO3DosuNcalAqU2kBtYMDS4NMD4SDBYMF64KL2uBWnEojs6OjIyCghI3sr7QA9BKnrdAVT0ugMnCT0wmkjX2h1QtVquVsuljqaVakA1" + + "sMSAKslKVQ2k0jSNCcEw5p/kAIbhEkdhTrPkpaB3nlpYvFIB1srdZdyN7nMsw2+H3W5765XPxr1yS52D/1/lznTcU9P33HcA2GKZ7ra4fr8COnY8xzj/fwpX" + + "UlJaONpSld4Kyb5gNzOW9v9i6VthdTA7fCSWymRJii8hStMQpYJyHoJqqHISxxXI0RPGLGFA74GMxpXJ2rXmwPtQThoquxNKHDkKU4rV/l+FRErDFJ6eOE91" + + "n6LoCX7m+ZlkGYIkEtmpAKg8RUvPNPHRxEseg7pwvzdaxsXw/69wDqajKU15KCA/2OK6y2ma6jh7juVuy/JXsoEdT4fn2O15S69z50LTWqNZb9gXa0ObyWba" + + "2vr/A1QjJBzKkTSKkaOuyImiqBmCKBGVSAieRFAo6A3pxhdxPIeA3pC0C4g7qLTQWhFTQzPYAAQAgxgEAMNQIAeTJMyyaB8UAAQWHipKOi4SFAoKCBgAAAgo" + + "CABMDAAAGgiJgSEBGBwGhcFB4UCQJCpdGnXAvelGsur2q28TXJxMK6lZonsaMFW/6udsIbTAv0SSHStcxa1AEysU2GRN5voc4A/BtkhmBPBrx+TGJs3xOJfW" + + "jDfNen5iRjJEMkr+e0H3NDkU3tN85utqvPE9Yn6bpbVsxDf+T2CJTtmrvI9OvKsXRXQ8SEZOz6/foc21sBoRgn9NWlS2cweQRBTZOR2bfNHnDa4fZ4gg43pL" + + "sGAtiFxPlc/v7SUOTFJDw8f7uWUcnuFK19uX7WMAhiIco3LuoLuDH/5op5eTc3y7fB8uMCQRGD2MSi7K0xcl6U3iaRyKbBJeleyvdkaMzkk8MdhMfYAOj0/b" + + "c3gUV0s82P9DI0ASJxgcDTTIqotP4maFSh2sufScYuJR5nkkC9q5a7ZlbClU8CVm4AtpAPxoag6tHmjzFB1kUZy+jh4RISSFMVAH+p5zq2w/bGdkov9zJuHT" + + "mhaMDdUN2wP51zFbAEz7Re7QJqWmo73Lo/zwRMFf55rrz6IgEHaCFI9zMi4XVXufri7xA8IPDnxxMSGeZxGOY3AD+GWc6k8Q+LeHlaka5aLKOytE734FHF0U" + + "BoXnMoW3PBwZQhX6uvOTmbuA+swIHMApZGRuCtXQf1Lg9uauCfGnnVe4NePBBPZzuA9HkkU7lgeXeRv8hDn8Q+eJ4MC9cLJ5oWS7EHA0Zs/T2/Dq34Z0GYpU" + + "dDVIvNVchXzKr90NdftaEt0NWv8brKwrybe/j+WG70/Y76T8/+MVKHr8QpnzeNLSPyF+n/v+b2hQ2zCInvegGw7PseFEZY7Ys1s0waHGMH80rAHhqZuWaXUe" + + "FOzmQfukWWVwrvcCjjHu+kWSNAVdaGc3PR4126eq/9UkXhc/nFOes7KKy3+fcyjYZvZ6jOaRrzI7p2pMlHDKw4hmYXqHAALIpXlx6Qpbyej05fMpS7kWFWVm" + + "bmWOPXDJwxk0+vm7z0xBTOHvmQqcv53AYnb6zM+J5g0IKfp/5NV3A8SNB+BsYoiAEGn2oq+eLSzdHqqlfuuS48Odpg2vJQyDbEm7L1f+2dUdKI8ga/DUHqk9" + + "9vKU6QxHECwpsLD4f/4+Ij60v7i8tNe4ikEDm/kidiiSrc9G9l1+2NApvWdlKjs2FQ1cUrqoKR3w7boYBfuW3WUQ+j6eyTNP1uve6ZYX+BJzGr+T8t8S9cvm" + + "iCkq1AtVqnsiRdEI92sjn7/CE+G5xi6d3Eg4mfOU9K8IyrONmcoMhi4HZMX/VgidGCTGH9hsCevNLWJvHZIVhnZq7Qv9sMn2mkR1+hZtbu6olMq3E/k16ZfO" + + "YKy5ZqMZUvpibddnp3J1rityIWo8UWsiyp/jQBpwTYQ3dLO3JwKD0FplMJxHQffnGczoeAQxSGgRMksK8uMwtz33Ekh64kYXjleHdp5dsTwRMgixnEPokFEf" + + "b8xSXkipiiGx5lOA26cU5gy+Y9Mb+GC7tyAnK9XCFCxUY/jJxEf/Vpb9YnDgv73YP8T5vJ4T5H/sXezdR8fiN2vKvbPDD2GjV0q+FSKpwf6vQYvKlFBgQAGW" + + "lk7ruNFN7byKErvU+1DOM4cllNtMpUw8bSnsJt4+VNyM6btXCZrtfPYl7HiMSKrV3zvgocTOTMy2RgHaoxyWXh3lNm7gTsOI+/LBnDQvTfBlreTwRDO+36pZ" + + "nE4ZyH2azf/6zPpA/GAAZzhWCL6WSZ4KvSc+pWqnRX10kP0Hcw5/lm4Eti7QXwd0ybsCHmnYJG/LGmFLQWFxHhXk1TXZhoeI9o0XJvViIGd6ZLjNyi/hAfQD" + + "gj2q++i5GIqoOkbJbWRDcX36mnOFQPM97hOSFIYwHzcLndwrbaNVJeyWq1eGog8sm8Fp/jihO6tYf94C4Q3wVCQolDHxDLGS0aIJD+Je/rjPbqtRXtTVMmpb" + + "BMg76hYsjEx1jX8aHg7hKeJgtmRVx0U7qesbM50h+u9sgo4DSqK5Tu1eoVT1F67mbVhnxjhQziCPUC5Km2jsm5H7H2wTOHwGohAsAfZxpqkMXbCVjTxjHy0t" + + "BX5VzRoKl5FA2j0wPAxN5g1jJWq5tW3jV+uhTN2z97In8zPG8IMNK2ubMErqTn8W7aMrENu9rO/i1f8f3NFW+zbZcfobDcC8Zn25xC472RywtFo1K6/N5NOJ" + + "AQa5meQq/ikjma+aSt70GMN1owNwmaAKWHaZOVNL7a9qNlbn8mfqNqJ2/XdjAwuo+P9DzBRWrp//l4HevGGU/reMOJ/jt7tFmr/gWcwoeXsqYA3CbTJNboF6" + + "m70RnAUGLw70hjILGlOHhwPfFP8BoxbfekfZBc2t58OY8GqDVxCe/3JwzYfm/YOyIbO6Pg68rtrwAsPmX3OtedQ3GlfP7q3bjuPD8H7DtqNeHg9mn41kFGcW" + + "4GGvBYKx97fS1XxtBy5DPcg//+3Mf84YxzOV/KBp+MQaZxEyl4JhTzGev4+JEya+M4k3mQvuQioteOF+Yxsfw6Zy6WV1uzHHwQRv7vo1xdp7FiF4lle6vQ3z" + + "6FJggnSQBuBza0XCpNlgPrGGib13D6PWbsX7LUPa3P33/R6owd0q/Umz2Mb3PEPVf8sU8LXnR32i2rf1Rd66mz5CYXnWOgTfEO/Wlunlf95+N7M97oj45P7Z" + + "CTrxGWWBVG3Rw/Ym3gaAxGHeTpSuGMe+XE7P8Pq2PPSlhT0mE5hY+A/nvhn/n14yhIdchdyIfuno+AVzQ5Sm3VRkW+MHcMALXCQPvAsj7IuqV0iUTOViasv7" + + "UzHqzmHjPepgQiNp+ASr71b/3SGCn0q6/FZFSfK7e4VCJx7qyRZcT2gLckJGm28yA9rL+kW0yeO9C3WNtagUsfGNLSOLJOUQ18h/2E9SCZ+JuAdRV77JJZmM" + + "1jgoCZ8AK0xUVS5r+xo2yjG4uLFklMDBDBhSY0WbLpFp6AWDGniDag1KpWp5l4fMK31mOBmMas9BnW67t/4c0ubP7kVEgk/9mQDH6HT9C3yelgL2voJrfWEm" + + "6/Q4KZ5j9DIdIfNHVdk2a8LS2EYDbuAFeeSgYJJYOhgSYkrNr3ksyG2g2sTJfmiEJ9auVGHrDcUnDyA4BmSpV3ghDDmCZmRRJTyMbyKkFgfLTYDSD0wbLP3q" + + "myIg+6ioJ9sCnoaySmfbwwALw0fWbISAkweXUDm9ALDelq/y4hsXD/9JFPrql/Zt/PhbklAI1quUrz7MD+Eb+kIRsmplwNskeSVYKKHozsDTEmPuQgzWxcif" + + "+spy7A6bAOXVz1Y7TudMY8UQlgoFI7m1Vdb9ZzcrkGU+p8OtzXXuo5xu0AoA29SquhNoro5pSqLqWH5pm/q9rHLov3GTCFYzc+z/IXbOUzzigxcNCy9D7bnS" + + "cnnU6nesI0A4yFxIregsLscbOLzBfpolZB6g5Ho0qg+//oik1t3BD3+0k5fJWfwGW08vQpICbtKa8Tq6WH2HZiwSpKggnUviWcCqjmT8taQogVFqfqRueVgD" + + "bROX7sMhIn0VXtp+Ea7neWyxkX4poag5SwNyMT2pd99wOkLnV6sl581idU4qipgml0OVBScfi/FwgUw6bsgTUp1ecGJo4chHW/hdrASnvj9IvW9bAgxFdeor" + + "6O/DDInJiZIoR2NgbhHIkF2+AxhZpbIMXwTTzazoMrD6i3CJ7MpMWt3wEURbz7f1mp9jNLdxPWM/y33+D0W/EivHH/uWhZ4EBU8aKJ6jj+z4Sb9k3/5hVSIa" + + "usAV+6u/f+md6vHvAO2pId8gMovWYYPegRe4EfqiFbV/rVpUPufW0Zd2rzX2sPoX5cFIA5O0EzxBiZuQ/5Dz3o/ghYCqRyGTMNcwq4lyCqeH0X7gJLXDacVd" + + "DdumiBusqN9KeniNlMrpKxs9T7W4tLZxJGU3ajZvD5XICstumtPKrvLXWc+m/Ocx6+kMdpmT4QClZZO0ENtspWBzmNVbhiJlfhk1GLD8PVAMPrx4AbVoMBTL" + + "Q8o048ms8PUnBnV7vmiheNzYeT9dvOKJZFJ+xFqDBEp6LI3lpxjqIjWNmngApegkMxUjleNxbdDeJXLafB6TLoqB8OjkqNuat0hGpU4eSApKlHgJmqicw+so" + + "oZwNHnZRjxflaebmYTfq+pc4yS4vq1LfEKfTjOFh9WXYcMxvOSINXY1HTX/o9KS+2GTjHk2KsmiutxAoVVzHcqiR8nJK9fsNW4/U7/RY4OBms9XAXJxucYp4" + + "FLULudTWeHCDEa5pcvD6XYt+JsZLk/dIYF7cfBWOKcxTtfGlfvvM2HeR23sBCI+wqrzI7Gj30xsLS6IiRaEeccWzlrnH7Pmpm/+Nc3hk3/t9HW1/iAq7MPRr" + + "GCP7c4Vm/GwKFtjakHU1NmnOwQGxa2YD65qslxyVro6HerQZ/VlwsKoZpEt9vUAzaazzwDVqZMcI0Mi6Xb3pbZNm53jQoTEBWKZgSI7bVAC2kTMzke9tZzEL" + + "pZNPN9A2id6ccWpcLa2q2rDjCivPrtfpF+1xmbxydhtgiaI6pHQmBXQf6Vi+dhJj8lAnRoXpkA1aZGsI/29Dak/RPtYmwi2FhcgeHhV0gm4HXx/MUfAW5FjD" + + "ggygjm9WiR+fpH2651H0zV5f64C9xIaWXPglkK64PXO2TRRYPpeO4uC4RA2TVMvlqQTrQ6t6BO75StKbuqiGD/i6GV+i2E9+UTcubrNTyA2zDS0GYE33ALpO" + + "ZTXXQPGhQdz367z9x1DwbJte1m1/oKRc+uTV6z5AfjN1riMFBfasx8ysv6jkH5dRtLBZg+IvXzHdgey6k/V4Prj3Yb6yng+N5fdaQ7/3K4eONy4SrMiYw2Up" + + "ftHBR8MIraWKH2DP40/CBXvwj7kYMdmnIZg3eXgP3TTLxvxo4+/S3tMJw3cciyajz7bf6sPtVtTRHyzhj3Z6jJyL8DfQvVyQ2GBPa4d37vK6DBrH6d+6YMLD" + + "VAWFPWNunoRINXSW2wl4bKQk8+0f1TkF2tWLKOiQZxA+//6m0DlBWF4b3tY+ucX2abut/YRQMBEukJ4AgNiwf2RQrISEaeNckE9x9VnLpADPS78fGim2wIGD" + + "i7pzJRbutQxxUppv4RdadOHhywZyKG5VXWTDE2L1ZW0vxDFCEgTtmZHRlj3U86byZ3cdL9da8O+J+PEFa/MakGrnOe7v2vlPR/s9HHF1eQ1nBrI2l8LmeDdI" + + "1jKfsPvOwwj50GXNt+Tz9fqr5DxU7H1LE2tngsJ29GOZStgGFfRVftjujXu4Us7WidtQH4A53cnUMCu4Rnz15DYnTbgasXDsYSHK3zlBG987d6nBpypOlHF3" + + "yPKOEqH8olCX/1XQD1E/8QbkPzKtKfnGwuensravkW3Pn2B7LYtPWeoPutWqn1V/DMMzAKhhavsNXuE5pb/9wNNFjzwNJ7GlGvk7h05cE2ZHIBOGKKGE/J1j" + + "KZPifp7UuBS+uFLoHiht/42sZBdR8kdcTGkoe4MsPK5Cyl/sKkDP68aevvVtxgbHONUU9okordgrOnRZQWcqWAX6ca0qgwcWNgJhzrFQ1P/1sy6IpdJ3NYoG" + + "INaWtxG4/7WvvZdwerbzmvGjUx1slP9xMix4p7Z9ymM17+42MZnk+BMMrfrzGoqInJ08bSp/2Ym4toQpbgXHOQzs+JCiZ2jNkVvcKFBs8P7uTCYk/vtK+CJs" + + "btuHLIRKYSB3eV+bZ0ZAQwyk016thvDG61x2LahOOjLLGyXetDM9OjOM/CZg/AFsBQzYL98s8FLGXXSnYB9oQKgQc/2jByqaTGj4+WtF1IiL38dIR4N/w7aO" + + "PSfroELDay0BqZ2mE1O8D6M0ZGeFguv0JrZDdrbw4fr0B/72YVxGg9eN1dt2pqD2xXBqN4yuzQjPlCGhevEXFDpFv+aE2E+AnDII9OiQvEKH8OeiO1956fGL" + + "TJw9gg2sRVF/7KOzR4q5O8gNUwoLropJnRu7OgVG94mS3hSaaLxQ1EIJRn6a5w+3sZP5bDdNbNNJ0Niu2c1gL4JvHLeD/we/XHvY2RyBS3JinKf3iPwksJrC" + + "D5RTWyv9U3Nj62bILgi5Fg5rD4xabZd3IYX+6oISrxoxdRr/OzEyt3pF/IHwWHoUwQB6c8wYSqBacQ7T5mUL6ZmGDqz1fIHx8OJVLimUkCnCxEeNm7ywcGl7" + + "rnF3So2yxp4jT4jCl95hr8yGPZHdW4r8nJNhCjwAqFS0/+3/7p1SiwFkAXsBznSuKgoUzLmq3H2F05bw0UM1wAcEG+4qGh02HzsViecCqmhJ6rGszsnuh4oM" + + "sPUEuuN1SDDBiTsuzZ0AfEwOE5i/Kl1KxTYd8RPg7ilvTY1YPq4gZX8HxR7LtuNShZK8KBKvwsUti8Ldb5B6asse6Vxo2vZ459HaOj0FkU9Qtgz144B/UUBR" + + "Uht8JKHBlJkaVKIGmy0lpjbDnFETw1rp1FSDiflpCjOOP7Bx9PFhra7P9p6anp6ZmrAnBMcem78w48Iz4NNmwBdZNJtP7Xab3feRx0ZfnNY1r+vBvTIjTut1" + + "Y7J4LphhlI2jbOSRoZnNwg65XE6rQp0VqMM6Y+fKpgeO2tTF87FterSi7u40M0er2nI5U9tLWxtNKMjdRZx0KdWdHkAF4Do1iXeE9s5c2qo+E06pD8eDpS0u" + + "1eE8iYf2WAOSeDIbbjMiHB0dCuTe2gOAKh1TRimjQimGrApbzOVyOTEEKWwdCuTeFK5KZFGIQcYQQ5vt1DQBhl3iBBsJe+8IrNVmRagZwBMl9o897F/v+taz" + + "3lfvqnfxPXx38B/0fx/zPvWg/3v4/nuHen/yB93pvek9zBedTC3asjul1HlrmuOhbuDU6VLcjdxpoa0BH9x/w6Rp0905oGVZnZEMDYinBnsH0DpXtQjFAc2G" + + "YL0AIE5VQlem3FAQ0Q7NZgvakXHp0FbNqUXuLtPjsSKoxLZGFyygrZGCAryWDbu4O4hTjYzQ9kTaoa0qhtRDcS5wK4rjkor6vaveRQ9d6j3q/fdQ/6oXP3xw" + + "zNR71PvPof7F1GvV3Mce9q93fetZv3rVix8++P/vY96n3sW8S71H/e8d6und6b3pPcy3LBJu7ak4dIeCCa+7s3hpTm3bdIk9V1aNxWCw18vlarVYrNVKpRLF" + + "MATB/zFjpqbEiJGSior6/aCgnp6cnJqa7ruBVFeEJunQE78xapT6Deo3y////39SJYaqsJWjflBPUT8of2ph8L5eLXeFsBWFrVCgAeMIYAcA/EI2bm2WpCuW" + + "XREuBm/GFLeiOrTo1KEWBKRJJ6vUyqU5I2pAsxpRzVZjatmjtGcDQ2lVJLqstD2f2P/OkIcgmd9gq91ODjSim4jbz222cw7RRMyAhNwd5mML8CJmQjMbjchW" + + "m3FwdxvZKBtl495777333lprrbXWWpumaZqmaZpmWZZlWZZlWZIkSZIkSZJkzjnnnHPOGGOMMcYY33vvvffeu7VZkhnfcWuzJDO+RDQgoBmIBLokM740Dzba" + + "B9rQAg9DRDfbzWuVLqk99ChdzxOsTofSbjaaUAjaSbPVes6Xz4OkPhMpj8AzKbEri8spswF8lMv1fLuej/UckOcrOtEVVbJgE5bgBbPaW31nTsciuftLBsWx" + + "Ol1uRZVWuVVNAl0qls2nQ5fSHHRFlWhmWEK5nW8lhjQ9tWV5CdIkHXri1KE4tZejrj4c57VsD11Kdem5nmDXJBwampmXSsL5ltqUV8S6VOzqK+E8tVVpHl3V" + + "IxowgA6il7AipRQJDiGlNt6yMZaNZZtYdg4N5Cs7X9lWtpU9ZU/ZUsYSysZQ9IWicyxCXmLq/DWWaCVaK9FJdJKsMRGssZCrc8ilx6i3CGX3kGkcu8Sxa+ga" + + "Wse2bmGaZovSzCxI867ZLMEVpRE2SVcW0uiaZtFoalRmYg87E+ndwRQqyyxiyD9kiUEE+CeTPLjcueWoM5YmlpV36/BuErM0iV2iBNNBiR2UDcjcgMTJJE7G" + + "ZXiDSQxTL7nDJjuMjdhJRjbt3LR1eEDrrGKwMr2YWYhGA3E7f26znZo8cwI3UylLFo2SJEMk5JOcr8jifGP3Grn5wi6M+Yo3LmhDlq+YYuMRNoJLGvNQJFzr" + + "251Mut3ON4PCdOXKL+QrSob98OvGxRZqiG5BO6ePrWbzqd1qjuhGGb4p2vqOLSDmHcUcIxiivCO4Iu8IgzFeyPjemQ55LMKgAdkF1bthu3FKv2SY+7tsLKUG" + + "VZo0YTxMJrmkWVFisob8cTPYIL8IiM6oxC68K0ckCAAAkxkABAwDcSRGYiDLUqY9FAAIEhxAYiAqEiIGBiYQBAQIFgACUFAIAOCggOKAMAAIBsBAYBA0Kh9G" + + "TO4AAPTxdfweah08BLh/hRLVQ/s++h+fLH4BtqAf9E1iwbxx/cond8AyAdvIYPHOOLBfXqjVB4l8/Br/QJ+Muffvlxdq8UEiH1+Px50Ktvy73IlYBuf+AqRM" + + "4jlWzsVMY/ic+0yLofgxHIVMuXqKiC43MU3sZRfxVvLoAjs2hO3aC+X0QSU+/pF30AtYjx97+UjE5k0eJtzRMv584OEj1vGIcMakPf45fx90+Sjih0y+4597" + + "C+AlydcxDS5OlIilTJP/mUk/FLrEGvEM8kJ03VchL6MIzMv1wfHGWLCU0ad5fARxH3RwsDhRjCl2xLz60xvvKaIxd5zPA9P12/EfSEKvqP3lWQECOV2oTB+l" + + "J87CgvcXeQkD0lYc6zX4dAxiM+AW1ud9PlaxDoAQFSmGROG21Yq6WYNMWKwKIII+GeHjEcdJLtECuXafkk/8AwufPu6K8Q8mwh/oZnwOpOUfYXtMB5vEj+X4" + + "+L2RHxkoUDNXuJscrL83ij/GjHfoTzSO/J/83hgPSuMP8XwExYYlJ8kdhPPB84rxYLnBZzk+AjEz6Bbb9bWxc8kZkx+dXCBDxIkwKufYxdFxUqSMcPYAzs09" + + "7jr3grwxDmYoXvUYzwF565U242fJwzeQ4AejPUp1vJU82X/r5lucZZxiJ8Qv/dMffaorHgw25Vbc5MKZ8XCdRiPTHxfzMYujIA+b6mLs4hB6PomOV8G9Iddg" + + "8+icdsnsey6yDCZKglHIxvozMlM9DUD77KThjV1klJsVBX0uQxGDZcR0vX3QSON9gGHhPEiLvtY9MtXuLi3hMO8Is+PjVz4IRji19OkoZ3u9N8BKYpH/QSBD" + + "Hxw+h7MxTqfO+XyNWTwyczx9F7KbOg5sGMqLPMWRFFaPBVZBiOjbyWK1VDmBCLiIUQiJpuJuLmbDYMlm9+nylx+N5S1wwXtmw8vOYDEHHLnd6O0hGVeG2JzH" + + "HfljK4CQZAaLPT9haegk6EDq8YYw8RIafPG6A6tHL0kDK/8mQB5Ukh+oe83DKiPZ9U+uU+VjUrqaPOFL8CfeRPDWcnXHYcy1NebY7r6FXjqjkbXmImvtatOG" + + "k/W5MfsXEIUSEBxBi9QCyar90BcASpDlYJQhZJFTxJWJeRRnaQ3tx3wHgONTrdWhVSTv6lwnINai0nUcpkVzC0HXoVafPYbZlGoQPRg2aPsOGa+mDe1LeyDW" + + "rEdBx/h9ZMt3kWcq8Tz8i5jGjtemxSRDxnscWEQ2IuKtLMgzIrwsLMaYtjpqOlvmiLUz2zChaOXMxMTGfqqdyUaHPBjY0SZmxLOPHZK0Y9GhQkjMUfJdpiWx" + + "o9ur8G4JOe6ukqfttQbQQfCIrZmH0YwyDIJPv4S0EgLoab3indAG0i7WOE8q8H9e+f1i+VNY4Jugvedf4YOc0eRR2cQOo37c2anD2zzyO7VcK9E9GQ/OoO9R" + + "zwpxu/01JgZ2Q67Kg4WA6SzFzK8p+ydtP3sazFXZlTP2483gnAXXpv2dMqC9vHwIhQULn9W7yEqt2UYs4x+Y1CiDOYKG8SwzZOALMJqKdjwIe7FmkOXNlTw2" + + "8BniwUVgiRUbRSud5cSzn7+A8La+8INcWQMRrL76wgny++PV4Fcn2shBEgqM++t6od6t3jxriUXcqt9YncKTZvge+ypQZn0w1RiJqKQbuCG/wtdehEdcscEA" + + "PhhxHlsM4sEBY/HFEF8MMYsPBvHBiHNsYgAPDhjHB4b4Yog5PjCID0acYYOBeHDAGL4YwBdDzPHFAHwx4BwbDOCJA8bwwRAfGGKOLwbxgRFn2GIADw4xhg8G" + + "+GIAc7wWbxNeiwPM8cEhNhhwFhuq8LxX9yW4wQs/vGLFDbaM/VTEf2H/E6G4NbNcfkHkXSjtAwDOccYvB3C2gEHCu3m7O0QVcGFf44R7pnhTBfW9hZE7mfFC" + + "Ui2+RZG4o0i4a7mELa0k/rVJVP9pcG7tGPRDKZwzvpg30roYEzm3gUgf/KXXDiYka4ldvWj9p17r7ONSzLMF4AyYugS5fyXnY7JBg+dExB8Z3nCjL9Yz/Ufb" + + "78eue68HDacw9O9Vej5qrcGupfCYLCzFa1M/zX+9ut0kvo3SFMRA5Z/aj7wnXBPz3+M2VEK4T3cQxhsIXPy5dOu//xiK9byidNE6kTj3p+5I17dOvLjV3Vjb" + + "wJs8rQFMoiYej0AQL2mdy2ciN+rWR3smD3ECh24966FuLznt5jFr+E2yHSzQsx+p/zW6D2EqzeqG4/6k1kEh+tOLN1EIh9BdqTTrcqjs+0PqHfKkMCfQzF0d" + + "Ky7lSmM3NrK/t8F48fCXmMQLXI94vrT1/53zWRW6y9mp7XL6mSKsNVzhUpnh+5AiTmqgvkdUvQKShnAnZsyRVut/cxFsO1lu/kygPB3ooS8K2CStULNV5ENz" + + "rAEfOLi3vPEP6eYxdXatNKf2HWhYQ0A8rsVbTcTedkljH6eIOSvwLmeNY4FQXkDT3Lsji5cTM2KGfAya5iccOAfY+zyZ/hbAdPfHuoHKfha8y+QTp85csren" + + "rpAr7tjT36rQI9Ptf+GyqUKiDbNK0DxsdtMV68n83xaV3vC6+owCA9pAKbv1CDuAwvzOVkCrU9tyc9cZJazvPm2wxGJwYH54z0nVfHxYbXytCybIm613EFp2" + + "gCF/24BuH2oiFUuYqvQEPg4raNzKEHeFLIKaZNk8aDOzZoxx6094FzXg++m3yTCGp8gDcaPMCJM+5qM8v4aIHlXLvWCuxsctEd4ESsHD55UrpB8HcWbYwkJ5" + + "ph1QKMu0gYLyGbZQKZdhBwvlMmyBUj6HNcrnuCflOT+mQM7JKMD84quQEm2+EnkUzVyL9KwIInOIp5Ccy1OkEsa/ZGOGI8qPDngxLR/W0ceCrXwY466CPfiS" + + "S8zVMol2L99UGMGRgFJy7KdUzgmQAgvZRV8pl8M6ynFeg0KuRyP/wYugNr08nKEVcu8vb7cHFTx6HN0ruHbeMAxznJxPhUbBDexTneRxLeDV/SUj6IGI4X65" + + "hxZndbulwOfkqcTkT5fHoy/xDUKAfaMmYfAJIyx3WBH/Yfgj+5Cyd7kVTfSajK/Gcm4ELp1G2oA/3Uz+Q3y08yCvOI2s11D57Rus6fLhFTQtvhzqQficFMOp" + + "C7BGJZFXY0GKS2CyJCRQaWYKw3huCvJPvAdayhMjcaNWcfRuNAf/V3LVMOOulAyNj1S6vUqOCXlcPdRrtSLqjbY4MidsTaXebknRdIvYDFa0aEgtJIfJgnkw" + + "99v51MBmr4YjBi5EahzyCbnzrnYey2QgwTyt3iirJKGXuBsnAG0mR2GZb3X8gBTj8e0hXM7ssUhu+1c7qWk55kvkwafk6MvTtSPY4TGbaTrz1iwJn3NDjKYl" + + "1XlfYs+/b/yWBvxplYm/bjWNKnFbzsrbpy5mOB8/5W94GH6m+N1sOm67o8hSzIyWS+1+rhIjcxhXmQ55ytn5ilN+AwjtTrw5HQZiMSn52jKSlgZvz0q8bvBV" + + "QFYve3CWi9uBx9EJAUdxC/GNcL+dAf32FhhuTZQ4ijuM2hj19Qr4uk+NsXWCxGDcA/hG1G93wK95C8a9GQndeAQgQF6gHQjCzqJ9gCHyoDZi2OAzoB+Ocw2h" + + "hv8CHeGYcQCqh7kAhJj5L619w6Hyz5Jpx74Fof9Mfbt6T7PbV+vj2Hei1n57VeIf7HInzwp9e1Wrfi0UIus8AMlWOWOmbe2ETXfVE5/aqgd8i9dPj9leOcGn" + + "beUEzzfVEz/Zq4cFjngs6mjuNRF6hZvPTAvxmAk64muoUlSpOn3RaFb8aFbyZZaZwOAdM9KwmYDh0Py5SmBQ12cMuMMVoGKudU23I0oJbfnVtEtDYt6hhNh9" + + "LIxHGf3MDxlzxnz4xyIGFQvN+cFE5Y0gNe5oI5giw5pBd9iwvqHjCuS9+CZWV2WZw+hkjNskgfNCOOh8q8Ggw5nCV8noASDLfxbtyZXMkAW9aqqD13w98QPV" + + "kY0Z6nRwigHFnOEMRcJN8djhgHs/7XRRUiBPS6XSVB5IHniMIaOlXe2gU/f9XJHs9aQW1RiBtFSD/6JC5rqgacma4Lz+FG/ENM2FU1yXs7R35HvZRxAvcLeg" + + "02k0bBnLBQw+MG0qUwZ+xjTKy48PXhp5DAkC0yX7sV66TUaXgGGi4MuGpZC+hG7rdE7gMNw2fQbfAad+pXytSocZx073uAtkNSMWC45OFpi2Fb0sBFZ9K97q" + + "A76UyqnRKHvt5WRYdWvzfKh4cOfKKER4+s4uYw6g7LkoaT7pSsalp2lE+LQxzV/U9FHHaOmjFj7c5ODxl8Qq1ju3wYK5MTLSQJX3hnLmy4H3ohCCgR0hVfR3" + + "KkQ9cDFylGXi+mhR3geXUUdZRtzm3fyLO3xyIma5+avduU+/DNragynzTvBYkCcuFBR3g46Hr3/cVmC1Iftgwthfs/SnpHRcgh4Uji3i92D1YtRx5irvVifu" + + "PL4HuFPlNG7OwpNzuCri1zyt1vNUWvscPOTA3UkUFuPZL8NV+0ldP/YnABQ5Lbk9rb1lFWCZDje1oXifzgzmKBib2PB/gjI+7Bya9TlPsztEfMQ0keLyBXTa" + + "U3GyfZO7iXXR6ZtyKzXu4yThvJTWmdLiQUNw9dUm91kpv/EoaaQG9lCYK/grI/kN9gtLGVbUUGv5IDnc3dTQyH0skbkP7WbjGCkVyW0x1W4eCVYrL9NTlLtj" + + "441btploz9S+unh+rxzvMS7GqoXxy2D7vX/fQif1DRpmSHZ3RnnDc2r/uFFOTipfz/OL/X3s+6npF982x88d8bLRzKvgi/64v6+IXGMyUAqvHEWY4QeAhHOI" + + "ZtaJVw5zhqik7KNN+QcAE+lMEBzs/rpcgnn3oGbFcfa0u6LurgOBIS3jFXmp2y3KmtdTttYAVhOVNTkW+79UlJ+tIefofBJSFqZ13tAy3eLheadzcfQ5UfF7" + + "uTf1XPEtJiMGxMFFe1RpCgPz6wSnppzXVY97/JCqby036/+DJOwOOcvUqtSKErwT//vWvm7DKmyi+ZRSXlogOrvj35UsKua5tTDDv52queEjeJK2C061Dfo2" + + "jnxPGpE7gZb72G1lYvkNidgarsGUp+EQESYOwJyqzQ9BFPwHyxg5LRXra0xz/t16+aTGhh4bRXeGKXzvFFKTmUUP2rHhso+cUdhoP7Iq4FiPk38zADp0gj6h" + + "XFwHAJTY7aHLb/NiQUocMwZy8BC3rRr89GFzu98BR9VO6TnKqZsMEJaajN/A6h1vct3hvCHr7u7GnA2/n7kcQOC0/uJBuCD4Cp//aSO3XP5llgXNSKlAMphJ" + + "0TiAwb1R//6ihUoBrhzNZTW/U/v4nlueTFyYqL7SKGyzgYLzsmQg6EUQLHD8EY5e7CZA8keznL10ioHej/haPwFjV5e4PKgLg6g/TxH6tTKbb0ez7MmixfPB" + + "eMCC39WIruE6xfu4XwPld9WABcvl7a5BUqgtErc7TwpWCoRLJHgEGMJ15JwSdH0b+eVyHtUWyt9m5nmdIsx2xnybtvwATz1w1/j+PY2I3T9hue+nrfEnYjAF" + + "89HS+qX7PRoVAvRdksC2CwBDP+OLe4LwowZ7DRdsddLF6QmVU5ri5F78Hi7XzzmpTsTKboeOYzLBIBL6vuxsHHwbXtimJDwhn6DEEy6U5GGQrG2hna6TQzey" + + "nUvf2mX7J8E5BT5Ca7Lv8zN6T5sjMSbtEiqIxk252jiNgnXUtnNqyXjN07kxFVbOoE9UeNQTgP/4gDfpv2SM9+1vkkEejZ5mBDavjNXpCFtjqjr5X9HFZ+kj" + + "xEcp5a2VCJ9QmXVl/PYuDyimSkYO+qCon5WVeRS5laEnoPP1/Wb923Owf/b5T7TX1x7qOnX/q9dKcfc43z027atO8MmmKzif7DmBOVBZnWe/LkG9G9TahTS1" + + "HXn13alhzlfg3wm/tqY3JXnpk8Ks3wzCPjH4sIVracB5B7BRfx/giPNW04BwKuR3Axg++akYWilvMXTV/ZJZrWGzY7F6GBAHf7XWJToxLiALvuJ0BDUJkBCa" + + "Xte6d4WWbOCbAJ3bIo+3F/wLVKcAen18FzmA8KYDxRgqPiSdn70SbmUq/2yV41WTix7t66Fm+JaYDjv98T03UETKlFJK6eYXAw3w2TbdnprQJgFsAU0BlQGe" + + "np6eq6mamZmZmZmZEcaH/t+XHruZ47565gfjQ/91/W5mX6ifmh0h/G/nXtZN/Tgj3PjQv507+dONCvM9NuRf107+cldpE16vV6yLameOYI/Ro8foMV7qGCJe" + + "6jghAupoJALqGNt0jJtipUgFQl32v4twCATKBXuNGMIghHKoUIYAykHC95TMPkEY8D1Ks0YuW+F3Ynsh+g7kGBcO8zur2jAOPeg5zGHttce8sIWBwcLZcgtc" + + "VJFAMQOEijBYty7d1ZWNlrvdfOS6aA30BQsRIkBAzcD0ZhYX121Ho+0kbBhiw9qQlbWlG7JABnsUhvdlTHY/NvuZkodhcpmHGVZUTSgEQiEJZzfUTajDJvms" + + "hHosgzpMi88yqHtV6lp8NkA95qnPgDgm9dmPGGFtYiAIj8D/WJF/4+5pefeAR22FOUAi3nWyXKqanQCJDEb2ACcxwqRECKEXCf4bEPIyCP4lyxYklCXgL1sm" + + "IEEE/xG+N6+mfx7he/Nq9tcRvjevJn8c4Xvzau63Eb43r6Z+GuF782rmlxG+N69+X36y9+bV/D7C9+bV/DzC9+bV/DrC9+bV/DjC9+bV/DbC9+bV/DTC9+bV" + + "/DLC9+bVAy8XXEJuD14+rmxcuyiYgIzx69UhvjJ5HowReb0eBnMZJs9r2CCGwRYmw/NUp7PddDobzpbbad1yQm5WQQjkjECQAlBeDne7glkliHGMYx1iRAZA" + + "MYCAwAcAngzcBlhh3XZbWVeZEb43VB6eIdgYDvXeRDBAw9rC6W651+ulQGk0Bc3qwBvsgwf9pfOX/emXDeP38fO4UD/9ix0ZbitvK+T48Nv587+PEcJ/9+ZV" + + "jw351/v7NipUmi1Hm5DfF2GH2LBotx22IFOZ66me6fl5xs5M7+xO7tzOzK8zcmY6Z2ZmZub/5vvm7+br5ufmf5sBaHwOmugZwmKGfY0ZCFt3QlfIdLoTukKm" + + "3wldIdPtZbDEKI+KJ0mV6HeQUOFvL9PkO0sTl3Wv+WGEpzzm/jO4IaztTILAKN/eQqPH102FRY597ik2tJXYUBnkXkLixTZ3DRQfBTUGIbFU7jBrhFK520Ak" + + "a30fOplzWGCNy7EYSuXLNlmF1V9GsZFjJZJfNFCOEcNDFwxU9zlc8F0hi4pV0G9XhUxBjEL6xjTEIHjU7ggoBk/FoFlXxCxzYxA4fpDBFDTcTTzFMF81xWTr" + + "Fyp50o7BPC1TUeqUU54Up3rqpBqTQkRpyuPV2IJDk6JOShQVJfI+hZ3q+PHnRKdPT3kME1Gfdk1BfKIsqjP3yGHP1PMG5pw3L+WdiSiNFE957CbMZsY2XxyK" + + "+dJfvhco2t4FCncUKHv7YXWF29lySLnzkyJdWFu6nJWCGo8rLlsOmtaNxxUXA99doqUKA5Jl08L90N24RpBA8aJFVQoRu5sOlxNyg/247bZyui4AVLpbAZms" + + "aRasdDetIFuZBgi0KEAAQvj///8fELJm8z9HZnd27mVm5owymfbHECp86OneuzC3N0bOffU8VXdVlck+dkzPa+j6MFWzP2PM/F4Tfsx8Tgiha77vf8fu5mdv" + + "XlZVh1IBX9Y+3dVYa2mrfft6vTzcEuS6fFzhcv6wqLv9uvu5+fHb6DG6R4XKHv9Euiyya+yMrd8yZuXeuKqtUPXr1OdPq5phZIbwRPJ+VH/YHCPrb1Z966Um" + + "VP5MVy97fFml+jziidR8CON79M3vzGfInbqrtXKPrWrWlZJyKS0c1+6GJRXlBfAartZcw9W2FnNXW3XfXe3jrR0621XNc1f79PV68cDpcrrbDi2cDiuurpwW" + + "TnfTQcuPNkR3A4LLumHRTsThyura3XRRhyb9JjAkCb4K+MPIO3vK430oe+kp5FMe57+jQrA3lOf94Fnob2mNHY/xIY2B01Lsu+gLm388bPbrqIli/0NbAohJ" + + "qMTp9i2BSUFQAGMbCAjDYBREoRyDnDkUAAQHEBQwECgMFAAKBAgEAAgMAAooBggOOhAOEhQEAAoiIgQEMAyKM04Gix9NcDZPXFTvbWMSl7XQP4pFXxYNH/5P" + + "1NEvjxwG9BvXDPdYFO9zAPjBBaJ/ONsZ9E9IyBjhSAcxU2bMx8q8N2t3pGKx6Lwz5uzGN2ik1n0EQG7HSCGNnvYM4i3T+J0HLWnm9fhwTQznf/yDdY0QFyim" + + "1VV/9H2oREvadjT+4IoRH1dZJOpuF57PTyBEV8uvc9DcaG2cGg6c7CPiqc/KZ/U205MT/YHAEK1/XVgP4GYizuev80Yfh0Po8Lp3MypiVyNcVcsstMkoJndE" + + "CJfiaOzDmR6NiLU0LsRj30OkaWo4+WScRZ76DAJWKRbZ9scidhkK/v3DLYSvyvxBv/v/5HSDPXK/j8oQ/vMPiPCxs04MOTbR2/w0nzJuqDWFjYki+NqcPz87" + + "refvTU5oJo2Rw9mMg+NkETWb4gM7UUPpOPIB93Gi6uKZjO8jHy32bc7Hj12ZvnJK47OCBKRsv1tlc1hAx/eiC/iWibBNh+WiKHAyE7ui2RoVgb3s6OrxAw4A" + + "b7ormZiB74DASrDbpZqq/4PEqnFdm3l5PF+wZ9zZhwXf2D2maNVzHhSu6DKkB6SOZ0VnIpJkZ5X1j71Bijk21hiETYqwz8UcURg4LZFhwYpOREfRloNP2jZW" + + "6zpngGyAtY9VEMNS6BSua4uMXhUNWQpaWpf9oKoGXscv8h1IyggZBs26EWWPAF/b3EmkCdvhUAe+8W1YPbwjZ1PVo72WSNRFpQG4DszB4tgwAOg08CGF9pDB" + + "ti9r9ue+MKe+ii2tHarPE/Jj6HfkUrqmtfTsYjlvHnsRna63rApO1fn6HQUdyFoQXiuqlLsOWLtMK6+HGOdshckaTqkwCBm6yBDmk6CQhFKx0wjSiVGlg95h" + + "eqwFbN8mOowWfu5p5fRxpLJbuQ4a/do+sbftr3p4B0ryY4v51eSYPEA6DywsE/4dUq+JUPh4YwmHjEYPZ6LkI7sugRf+hzhSio/DL/yHaC7lncVw14eXs5Ef" + + "AfudaDVnKrfx/iOEFVQ0jEieksQbJD3Qbf0XSri1HzUqLxu1tNmcmBlTEI6uCkkUR3j+UmOT/WI5OfnzHP7qcqU5hwbPj6aNcpsCHnpyOc5vbIXXyFvma5lw" + + "vY/RxDMglxkflArDWeb92iUf2lS8BxEjfO3KNlhEnp3tEaxhWotcEPJuQBsGl5O0Uo5O40QC5etqXZwtq2Ff6c8jFsNxKhjIZVo4j9UATL1zjYeD2c4u0Qjc" + + "YdOCAfkVU8ZD6ZDFbkjhhH7FVtthIcTbm4vxnf3JMUGi22DoO6qC2fbIHhpNpQd/o6EzQO/LITePw3hQmxY/hKVpfLMdRoAG6ZPELb7UblUqumQepBXB/DpI" + + "AR/gnZtGQ7iOK0pisveDzNglGiltWNoqIZev6jxaR8/uXdUW5+48pieJeWoOkjcS6bmgMRTpO6KGmdlDQHT91pigiaMp0gj3tiiaNQ/Jkf7fVUaXYOSs4Yq4" + + "7Nf2FelnPliPXc74rFVrP7YqIehqyYI5WUrxPV4nWerdycEWW3cf1uBleusS/Mr0aT+uB+lk63eZZMcqYS0h5WEa3DZns1ujTw9tZoLXwLjTLj1lFB2ryEr8" + + "6JyRZAG2+rr5nfgWqec+RKq92i3vRp+ZUPdmaZGkdjVoPa7H/jm8ystFj4nR0a59Pdp8G2X/mLZuSERkLjoxOw+pDGz+VitjI4bQaeu0zNgMsC6H+CE1Rfgu" + + "kXCJo+/As++gjnjO/H5ITHEg33HF/vh0+iGXPLNFnscR1CGn/9sBH9YHAta1o54AvlnkGW1J84ugBTc9D9YjbAYglwN+OsUoD+thcmvqHDqKxBRdpJf3+Sdb" + + "48jl8ZZQc46VK1uksLLXb5Dl0oLCXDVGjhW+IxJ1sFXyVJb1TQKzHt9mZ4Cb4a/4u8LxpOXBcmn2kOjLSfQdNgM/5BI+qYF5j5shiLTIm4Cm9bB9HtSMhmbt" + + "B6fAxYwG9Kpfyf5pQes5tFQDkYNkw0JIrTt3dR6Y6xGsEr8D68id5mWvlLy3OeeBumRsmKODktE7tZWDWvZdTlLTwiOpRDr6ka+H1dAxQ8UiS4PYGvycx3qQ" + + "9V8AwUK9AUyBxwUdtPcCpOnQQdiev8Qe3vYUfKkXuge8mLIT8n55MIFF3A3J3HwSdZRQkzwAz6UTjnsAiY5UjZX215m7enZFRWf1qkdIsy75L/kb7mYI7xpG" + + "yLtEXWzyOJpYKEjJf85EK/MfLwacCRiW/FV+MBu6kq1NdQaCLn5ePet//Z2W2HrN32y0G6rdzz/5+UVx+vBAo6hnlq1ZWsXUINV0MP7L5zdU1lrw7+bXga8I" + + "j8pj6i8DIZ8Am3MtlnVB3n4U38zUh9Zrly0B7aFv8ddrOIGNherXX+T8X6sCjHdQ3YqYfy2/bT/BzMH2UM7VTcnFSZw4/yHdNSGXA7VtORSz5Z0DPcmxX0fi" + + "1wGKDbydEKHpSBYvbTX56hQYf43Cnmc0yjqi/HnIyjCvjGSvkSLg1Sn9ijOddVQKVieyeGkryVeH8MLuZAgmOTzlKYqNm0G845VZqnQi506D7lAaxhM58y7q" + + "wPuHWb+aaoyuMG5q4G5ynGtDiRRDCDQDGoVxqYFzU0PcOiLSDEqgDNApzk0NjEuN4GoIkWYQkWJHo3BuYjBORnr/2TSy2uXyeOqGNktt3uwWMi4Kqk7X574g" + + "s9fDyrVvsH4GRcOe/0PcvLJK7l2b3KG5ZzuYhfmLZOE9MowWDBZiNJKY66RrcJWaVIbUITPyxu33h2f8pgkrg5NwxfE4aiercYeEpFJ1Pp7bi2MnCCNl+FxF" + + "pS1i3Aipsi44eYRQl9uy+AfS4DNjoW1GYba26/5cvecdupag7+UwO3yrVsG/h9qKBFfxWAKL+sFYO1TKQZq/GJxTDEhR9wetyFmMZtPSYfhg8OiZU0iIs3OI" + + "/rvJesF40havHkEE77dpdwm5U7dIHhKTOy3avfQEAJKC8X++6AlmrldD6//eGWPGvft+i4lZP9vVJixNZ998BZk9/9b97Ec4X+dthQN0Xih44S2uFQFZCen4" + + "EIAPgZ7FjtPe7+JJLXezH+FA31f4CnyzfTXmnvEQieNcCH2Ct9m6syx40qCm50rFYi8f7/VEHSR+7Vz5wwrOoxlCNT1gJ0eCjwUJXlTVayQA+Y0gQF0EiZpX" + + "DovSKZfK0CoezE3igbkkaJjpvNt4nk36bbfp4fTT0UoWMd7AMz9FjlF4M6byIr95GXblF3jmyKLQCOnNi+aViLQAVyWxPM+lFNvf88XjHwlPwjvVPJyW8UM4" + + "ie+ge+MBeIBepzZ7w/8PT3FRzlHwWjIW/hdpUl+2lxefp3gTW0F/0qsxjpNgubvz9EvZr3gzearE9vq2P3TuJ08JttdHGwOs4VPqszZUM8u3kAwlS7GbbOiW" + + "Yho2eue4sdUV6ZdS+q7is5n2/sltjOPeKtKe1nz/p7/Nj6TtVjh8RSnFqMVO+9Pt2JnGAEOeWXY8NDeNjT23X19zpvDWevl8Y5hK68HBC0i9lgM5Bql7vTNP" + + "aWvxRsV1qenlOlpvIXWvr+0FpFrLAh6D1L3+yReQai1zepK8iwnCuc4xdSxGCEchtZcZwjFI5fUQ4Sm9Lu4Auh5QuqxjhG+Req2/hUm6FoOErvR1PSouiWy5" + + "Z7yS7+r1uKTXMkzoSl+XC+WSyKtxQjKNXnIfMOuD8gaoaqHYD6zwACjxsipBXmdtlMihP8r7wvWp0cJi6Mr0e3rJ/ZThwlZ3pr/uLcdXncRbnKXNF2q5rxow" + + "1HKHasKw1ZG1EcMSJ2szhkuOq4YMlRyhNmVYdWZtzJA0DZEb+czjTQIHjgnehLNMVeLnCRsRlWBz6B5KCbt39FikwC3MSPCavI56El6PeCGewM32rGHHZyNc" + + "Uc/0PcMP4QbeQf2D2FGa4aSIF0+N2SWeCVeCHdUsnRbxpziB640FoMN7E06px/gtYY+4GkwOtWPFK85PRDsav6cEGsl6pDg35fVL+8PB1Ke0d/5znP7IoMgV" + + "cfJtPEcaz0bbRUAirsYgR2xvwcH038uRwr4XDs+0WcFH8s3Rw+jtUzX1qCEt9B+6Zywl+TxXTibZ60XlHWof3SWHC6P4utA/p+/Cc8V7TBqDoREW2n/UJFFH" + + "2qywiMwSt6ZeqEYJTEQXurmFrvAL953sTPkW8uS3xRDoP56N4pBQ/FaJODUossbrfnm5ej0nuJij2LiscDJpjo8ijgU9zDj6oUBzqn4KK+j6kBdn5LQRhRE4" + + "5XwZJlKlQfkmz3UxootDNRSxM0MzYJQM6mIIVPPzku+hut2xgMSssA+MxoK/dlkslSf1qJExX+2eF8tKUGe54ROHDqPYHxfLCobiYcHTT6iBWHd7xXHOWn1S" + + "yhUffD6aBvJihhCVF6oPejKFfov7ELEtjNqefLGo08uN1V+dlE7ounsqZJkUeC5cTDcj0Keh/hi2qJkv5PtsUTdeDI2ZWzKBQso7CccPZcY6ico+CpQjksxN" + + "lBehg7hzh8RzFvQiYLIbITiNLa6yiw6IDRSHF8lkB7n2YgQ/8bcg+SUHQdZkkoLPK59l6YMJKk8vihUqjyw7+TNBFB/Jtk+epyD68X7WoD7sS0VYwGO4eJLU" + + "hAUk7sWQYlFnEqHMnItJJqk4/pk7JzlIpmIyAg9I2T8mMb2zWsAzuddKBKmRcjFeCrlhGGUwLhLLIc+2AnRnXWCLLdteEl5Pezz3Uecc6gK22LJk5cPFa8dD" + + "YzupTWMWuuze+Czqfj60ZvCQdpqijH+6kT4SqCa3s6XcEj3PJmC3W3RGlA1IwQKl3LJLqxZUSyUAMKBFU3HFqYovOBQp2iCFC8RY2UqjCwpKFTAY0UWjuERW" + + "Tb4YAofSIfFUg8t8ccKwwItiITkj/K6LqqYEXgQWSYyJ38pCzaiBE8GFdDPC71pQTw28KFwkwJ12oyXOHYze5FQ2iWJdyyuQ9T8MNCXFqexwio3DttDwcD0A" + + "s17sMyrwIriYbEaoD4xWwyKlOYI9/uSv7rH2ZKiP14tXZNggmrmfrXjP6A6nC45cuUfKPmpYRTAPt9+pFMaKCL7EswBaaXwTRPCW0wFUUJXNcBF3ywb9VFsm" + + "Tl2rD5NFiLmFDqQzcqfLRYfxW7s61ibF8L3SOmiTKaWUUjKyfLlxUAkIUSjkhJrttvcO/AAcASQBnf7xo3v0Zubd9qi9EfZGrlkjc+y4rFE5cpzOm73buZGj" + + "vvK7wmeFvwr1U6Fyqv/pDhs25Oeor/8w/blsj87NvSzpJVWJOUjjs+p4Ti/q8fS4ViyU5u9R06OqQ+jcRk5hxxi1jp/JnhsrFzuXOflmY9i7+67qnbmqMLnk" + + "cuHHyMH/X3Xu3XG2uW8aOJlykTnG3+TaIVScjJwZE8Kfmwx+OgchDRz4nMefeAP/n9/9u/2bmXm3N1mbhuJkZt60iGpKqtLCLEVXKWHJ1VWCyxiG/XgAvBtN" + + "6//XdffM7vYsc47Q/Td+R01rjd3ZrDH6tjGMz7ltzDGZuSNk5e0CI0IgPmSYKVrYRDa/PqEb8FoJgVApGWZKJZvIBgJlmIkIi4cIRGTzPzCT5xDZ9A3MxD8i" + + "m52BmdQFi4d0EfV8LJTLxYHPx3q5VDoGWiodV8faOX2e6vu6Adrn6aBeXculSp1iNFX3cp18UF2KAS0Vyyun0xmtup3WCcMwktczLAKy1/zIOef+yfH7/buf" + + "Oeb7bmRmrrmO0b/3359b99jd7aq7rLqZ6lAhNyuMceN2wvjLMH5uLsOFy+v/yhzsflWOyqrrqczbXOpyhKq6zr1ucw9TRco9lzUy3eQ+xuSiu8bY/f3M76q7" + + "na6aos4amZGzfF0OpihGV+3uhM6cPRR96dNVSqWBQVc7NyOEzn3H6BLYWWBJVWqWAHdZNQasnQijrye1461gebEy7MpKlUL1sXhYrO+UYqXKGe/u7u7uZmZm" + + "Zmbe3d3d3VVVVVVVzczMzMyM782rGd+bV0c2McYYY/z/////d3d3d3fv7u7u7mZmZmZm3t3d3d1VVVVVVc3MzMzMjO/Nqwnje/Nqbs2rIgMcZFyeiomGRFMg" + + "IXrEg8hsD3EeQF5H9NEaDu13RBikZrfB28YnSM0cg7cT2774Dfq5hszpC2liR+xGUvNb+Ai+C0FmG+pyymzDEIDMgjJoJaXkkwhEalYCM6BMZjsJhENIzZEI" + + "7PFAIPfwH2+jc7gNvsEz9md7hsy2yshVwrScUh5pU4EyEIAneQo0bzAhIE2P5BAIxEcWAhF3aJjpbYhsvAZm6hgiG36x7ac5aQIGGYNVGAnIOhzNXK2uLmSi" + + "WBSc2W23GUtoiXwSSiJdhEYRoQcJQ6iGgFA5hADCDNoQJgyRIEwPiWAuhBBYIUyBMTcIfrITz24SW4qrFCPNUXqLLG9NDVTgo9yxq5k5Q3L5UUwGDxUwD+oZ" + + "gJp4IlOdWBjsgA7q1fF8Xo73tVLeAQ/1Yr2wdHjt9HRey+f18i0Kg2EtTFuDTXN5X8/r61peamuw9Y5mMigtcsQFoPAxDB7TpmBaEKYFpb4utXqHicE6y7Is" + + "A9DpsqUwzIWzLMuyLMt40xR4TYIXGhoaGhqakIuLtl5Oh9pQhZhRgCUhBaMFK+/kKhASxQjQKlSmZEFVqEzBgrCgFk15qe5L4WlZt2LltVinjzUA+zwWI63j" + + "OeXktMi8ZDFY5lp5LVcPqQeF6nu9ugLY5/GwXq4eL0e1g2EYyadLsV6v7jWDAOZEAGbA6OSDAkHudKiIrKjUrPpmMw0A8xkIDAMxHIayHGgp9Q4UgAQRHipi" + + "Kh4SFggKCA4ABAoWCAgmDAQIIhAGBBAEAAQ4AIWBoQCKjCSV+gOLH3ePBR4bFxzLMW7aSAMcDQ7/EfBrxnqGa1n7Q0tWIkJEPJ2Jjww4d7+XnRp8v4j2Ruai" + + "IG+PnIe7fxaANfi+W0WrxR7ZcO4+WcRr8H0lFbc2cMzhPmCzF2uV1+7fxv3aI4drzCkGC0Ovom/x3eWyPbK7eSbW4MaOHZKaIbVHvil3/8vtj31/Bs/h2j6K" + + "hlzvazJ87ZF7qnVth9YP5QyC7H57DjAEBuVPfTKLJ+6+JNtrcGOb7ebskm+g9qenPTaWw3P36122Y+1/ZY5Ottu8U64KiiUby+S8++kCdIfPBgtD2cfO+LQU" + + "lxcbS2lf7CnabnNHxYDxuTASA/QzdSW0w0YE0H0gewq+zjvJOcr0MikYbV7Kr7VyvrBtfNCO2P/iW8HYeSQPJ3Er/wxfa53OFHbEfbVmWc9es/N2Qa6gKx8b" + + "1jGIHVtucBhjw6thn4FIKJflSAtEm9PC16F5YAv2QV+Gq+zuIBMCIE6FOk9oh4fGhVY1WOVQPybFJ1N9DZChvsbn3IAZHejmc9RU7Vpuu8RRvUTR6HeHU8de" + + "6N9YBh6VjbfO619bvoO5f33d0efyLaoUNF/MTdGn+N5QUU5vaCgAoqlvx+J+YdjtXQxto7UUURBFZiTFf5Du25TRv4mKKEfpChBbAobJqD0S/fYxhCAU2yT4" + + "w+Khd5s+1Q0F23MpAyu87/LhSz4SKMfaotyqZz/t/pheuuROMlZhexuAAYoV5sjHdBGE1xqWG/ZucpE/fqalnZB8wexk626u10B8MYjjqfJRmotou73W8Ih0" + + "39MNgTqeM7HLXleEV/xi7wgq1g/WfvOJjQfevjd07mg9SHfhIXzzACndou7y7u4RzhfugwWfHDyIM3RSvZCYz6osiFc/obvMB7+sN2taFn8XNdE1LHO1kdgY" + + "iGbYK6EhJzD44/RBpsTmaC+GbFvuH0hEa18MJ17w1GVr8zGOAtTdrk7GjSRsDgKultH/Iw96mBrnvD+pUucUOHQqYVKw3VVeDvE9+eZBGDmsx2F4G3F9kkDO" + + "v7aqL0G/creDXYmNZFX/xLhCnD3bu1Uuirh/DdPMFVqu3Q2mPARcEMX3Qt6HzSB9YRTs3Idg8ikgINj/vUDwa2JEuzMVEdDtnsnESs62oHNM1ctOEfgpHGpz" + + "BXoHXpHtB7pFCWKp6oUpRwWy/iKiYLPOZdT9mfKwEIPGFLGhjuM0059nWO6yHc5tBxB9Wt1Fp4DYfqc0w05nRR9/01uQZCbig0G6w5+I426HAjFNhn1100Bz" + + "+VTc4OMzCcx71vQ+DV45Tath5+HkK4zoVt31SI9O0jC7+Q74ABb8a76vjMjmorKETEUHZBXZXJd7RNbo8OPlueuXZK2vK9h29YQmCah4BDYDVDTPfXEFEc8Z" + + "We7yOBXBcoxGcYwGqbhcNpR2vhVs/hrDS9cSmXiKaoBMhMKZ1kwbZW9mah7fWMRpKMsvM4iIk/1/hqaU14fTuXorZeo9jlWoujY5bE3gSQlHWevazGk90Q07" + + "1eJXewERUZJfDaJNSugy97w2Y7b6GtlmMsNP3wRcEAtjnoLN42MoSDo2vwrl9Gn+epqFBG9Rk7H1baHY0JSb0PYp3jXuyVw6UEeb/Wl05rITeiridTQGi2PV" + + "crQmJW5iQmYg30T4ALDLWTWZyDcuTgPQtx6W6VV9apmSXDonzTBVTwqjl2xcbCNIOQomMgsdoxydFzDn8rWupldK+RyClp+Gmj/STO6MtF4jPirj/q3g/JeT" + + "UIabuOm6M4Gw9hf+oZzx/yUpYsgHOeQa2eYKVi1esUE9zDSvrvoNq+zjGD7mJUAAE7pze/TAB0itMd5NnXm1KlshSVD4v1uLnu5/PihM/TEjH+gG7IGmjeWo" + + "LGy8QVOfNRFoeXmve/U7U2NViLripHsMcMIDcMZHcQgaeXHsooxK+sCoGvRvAjWHgjQi5Vwlsfumygr9t+rRugSdLq021lnbJerYF3akm3+NSB2CwW7+9FJQ" + + "+amdXs2QZm9sQGLuWpXUWSviOOEqDaBOrLP81fmWDYDHqOj4ECxuG1UhH1ZUMrH+w1IFX/vBWcXXvnCi5mp/OFHytT+c1HztCydqrvaHEyVf+8PJUud851vb" + + "82JjaZN1RUqK1F5VR3nX8L04JmRq+B4puez9/CWno0ZL6mPNx2beRXou8i9Jw2oxL3cRIGocSeTL3EiYGk4a+DhbAVPJCaI+zlLA1HKS0MfZCphKThD1cZYC" + + "ppaThD7OVsBUcoKoj7MUMLWcJPQtuLUtDTSED7ORYFVsfXApGJMS6eNsJSPidLpfS5XCun8f9QGPO1+3qhLsELuW9GgYCjOVDtBA/8NpOi09gOr99L9P6HM9" + + "fo6RgY46bY11Q1jdU4xvnUhAUzcEeNM+AM5ZJ8lU8Cfz80NoDNxIAyB26XvNTXBrCtkeMbDquca8/F8CEthGBlFlqS9mgKhT/vSGmhmQMgsJ219H5m6mE7jl" + + "gxaIEqs150Ie9HWADxUgAlehy+BsnT7rUrYa2fPwodnAexqMEYhpS/wtBwLUKtMFEwiW+kwOaj5GZHzkdeloXqF8Chs1h73d8tpATQIxjlvjy2DmAKHjM2gm" + + "gSj4mcmGWzaIxtxwYMVpZfD/v/1HDf0zuJ1AO29fPVbNs2rlVNb1DE4QJa6zy2HFh30AfiXqWYNMvC5kzG5MR2PO7OwBUaCulHQ76XUT9yxrDfiykGTcVwou" + + "u7nemstyVVEDHYRIg0gD+Vd9pvkAtWpeD3GgPKtvs40z0jVgzb3q3TfQsQNH7qKD1NyrlO0hBqQMnkG1z0L4UmMGontlQZ54zbKwt/3XpUygUET6Fv8pH8wA" + + "pw8acqjJWogRdAVCfc2i87pxvgpJY2UPBhKrNS9ALhNnEBdyJjMIBgQt4wsHN/oZHCFqxJnOQhkuekbpP66CnTX4DgqoQk12/lpjvhpzZmbSWTCrcKD9X5+Z" + + "9XI09Nic3P3kYQMwF3I6G1H7mxNKIafyIH+dFa80gCHyaJ5vALR8REP2CRkCaqKFKOc7weQQTgZeAV2adF0Xv4jtr1J9nDtH5+rMC/xhmyZA+JUfuZPUrz9v" + + "b9jl9OxYonPeKyj+xzBtUCIPkE0mtYahfzmH+T2nw+8O2RRfG47XClQ7dBdtN7+v4Y7MsDEYj2gBs6PacmFRsROgJUGuSWGhpOdGHQWPJq7YGTyxdsIZyZAx" + + "GRuR8SOBMNH9HrXl070PODV8wljCFoGRMTMsBMOPSTzzmzERQ5rlhPRqzeBEtfOLUcdXGM9lfdi/OwWAgSAuOAyEeMM5EuCN08gANxxHArTxHAnghdPIEDec" + + "IxfYvl6keEB4RmaeZxX29sTCcQPIcHbwHZVnQ0tC/p7YwMwgGwWmhf8xeIYG341Qv2FRudsJpuvpSo8APNDqnUDd7skopugsmbw0rOjCBK4VqvARMJ0zKZx6" + + "Mw5koW83e21YFSdkwsk+lcI04AsLwTX4Dv70NgCYxiEzc2bi5bJXMrRLuV+CQGO61wbNCMDxkRZEAd8vv/xGnw8TT4AJIL0O0UpSA/yfhqEoG5i8NnG8PIi3" + + "kdd0Vw6ZcE+hx9DsjEJg38QIWTETWpBN5zcxCNU3WXTZrQEchv90heyWXBQQrV2du3H3E9y82A7ChoRREl7hZMWjfnKAgT8Hob6VELJn+KSpI9ZmGFxiT9oo" + + "18yxdpr6mCy7MsGSsGvfEk4ZOR75opYpuZTHsM1TwNx+XhhodJ7yn353NKQLtKMtoHLjd1MpnnoT3gImj69xEijCft6lCBjjjOhRVGBphowd0SDOKaDOGunf" + + "zRjoBcNxotCkrWoabNiM+ty7fZSc3sRR8VgcvLk5qWMJWLnbg0KDPi6OCMLRHISQTC98GaMXzpp6GC13ZuBS7w3zZgy3NRaVMX3SpwUB07zqYgjfJI8g5lJ1" + + "URMj8XQ/TcxKg33Awh3r9Shj/3CdV6RJ0yBx5A7paDIYG8ayP3hCMUbDmJeVTkfez6R6Nme7jZLHf75odk0DfNmMNKxJ6zj4hhsNxmp2em5GSnKHfSw9ROeV" + + "ZDSvnJuRlrRTxyHA8lc5kOb1dTNSSb9wvV8raMbydIS/YliE5aJ5/diMVMquPsqgTGpl7YDMKPoq3MTPJx3+NMFlRpZqQvtFiYkfM7hphka6tJmXjLieXSgb" + + "6oz6UN5SWWvqK7Bz75TbSdpynSDYGWr+i4Tt7i8xYTSeWLGZF4M1/SgOQHnSmxUyF3e8ISda+mvA8eioODhF11Kaz0Ty+BhOcsMQ2cfmJApcZ6WfGpHjvNGM" + + "7fR8GAL2qz+9ROFoZCBXqEijF75pRowHgnghHaJahalPr8NcSOxgfhYfpEz8//LQyQWL2SLvvGmXDg5jK+YcigXL7lSSrCMpcTxnYMqv+qg5TGB3xo4pavyx" + + "W/ECkS+PHW8omCXuA7DZ3+ouWSALECRFLZ1ovby2Kk5GPCZ5s5AG4sDw2lhAKJt8X8Rz1OjfhQS5VPMrR89mWX5UDiGeUqoYkcGEhcZMifJFC/EuFsyt1RRV" + + "5CRhJOWUF7VAsd4s9od854N4ByR//XhkgYXHInJfZUM6SqTPcCd8DvoZQt8fdTioxQ/v8Q4jlwS9ZMSGPPLeM7/YuBh7qsCYn2VhY8E3a5Z6sVeW0fV9ZEBH" + + "Hw302AeSzeNcOP4dnfBIBkgljutN7w/vQx66zBZoDrh1e8vHiYYwipLTc58S3ChjmXGwenioLAxqvuUHQ/n4vAk/E5Kyg/OrOxuqBkN+i2fQehd7mxv69x07" + + "Mh7YrvJ0lZWdVvH0fu9EH3iu0sMXy4RfH/3VE8Eg+d2YOEiyvcUPoxYDBoG8II/BKvEhNHu3gQg3cg5WC7PwsI1ivCrHs3pgjw74JwFK72k7pBWDL7peNiCp" + + "gC/vcwEdYJTZvkQsLBO2Lm6ne8RyP+owLdGxIRA7+Amulh96SGy3f1TPXNKNmewVRKiGDkhu5r2O4S0IGla5WRURCYJiq2BKBQj6OjKrGCQ9MsEZODVLjJnm" + + "yE5CmJjSVDRshDV43aoLxXqtSf+SCnPOTwtTdAz9DwlQ9nruxSyQ75o4pHodOYCmkqPmQ7xv0PHTSvYft6v8RIV3cu42puXMHcRpxUA+HyobozhV4JKOilYM" + + "4OdDVXt0O3OHr9U61hxiqwGOXhy3Bkw7sGip9Zm70ZQKh/2nx2X9GTzEZ98bWUCDDp8gQ6o1NAJsWaZUZ8qt554aGmXqYCGWm0Y5mHZcZRCaZmc4t8aAZuu7" + + "G6nHnUuoxypoaGM7HV5OUOIn6ilaUT+Fx1KNrmHuIEoX03Twt3HZV+jjpkb+KiAkwrPMRadEh8OuLD/Ip29AeBR6NEYwtNOc8wlqSySm3+Gl2sFKrbgqonD8" + + "UDH+uKm5szcNfWrU9fTGbC5vkCrPcuqT2Q/dhqbjSVE/vT1GVnSF7ecOWw468+/ayHwYl3SUorQNkE7io/w0QlvX7d4oVWN9o9rpiUxtzud/wx5rG6R15CjE" + + "eZS987NJ3kHIOIvSAnhxQ/3+AyEHfI2ULtZD/SZX/1UPzh31QShbhqMLQegGGk/ponYSNc/UcN+ys9LbMfBsPd4WhVMMmbIsx1KGQN6A/FaUN4UujpYy0ASA" + + "g+kbc7/sXfb5ZXWuOQglLmVAN8p/8M1JarRHqJfSbw+ljHY7onGUbkmhABvDJ6mkYNd+mtYSN6T6Y0U0X6mMTJa+/K7S0CQEVwey94CAlix9VwJITY8uSjmx" + + "mE4d0RDjnkMQZmtAH68RBZu2xp/3m6G5y0qGQEzadlTCeN3LmYw/9dRIQ77JfNwpMYxc40/xahfJGJatEZ6wPovucMYu01eFCGxV0Rw4k8VmDB9H8Ozck6W/" + + "Fg/Ed/Oo9kTj4/QRbxtd+Hgu/WthD34CdloOgVbj4w0RmStE8zip5C8bzy8iAUSiYJaRPgzS667yaTtYRMQAel1oFEegLrcBxL6esOgyoaEOX49f0umhWg2H" + + "2ojjytdTrTmS2EOR9l1rFL1gDpU5Yt0Q3LOTMqWUMq7PGYhtRsjJ7BLIbq/szZU7BSwBOQE6Abb2NUrCrS6mFOm1pep7tLpIL41VlXC2r5bd3MuqS+SrVOFQ" + + "7733vfe+994bPX/nO8dz+k7jQyLtlrutTOltJXEqu9oGoOjJy45nnn3299/nnix+3wl8X3ZZzdax1m6R+V6fpCeGn+ibsuNvxGzfzy++n1uL719r8R2KQ1XZ" + + "vkOVHVSV7fsWvkXK9r3MR8s48T3qk15UEt571I9K0jnU71BG/skF3VyI+K/lk54WIbzzJ++fgnT+5PlTkM6f/FOQzqF40juh6OCcP/FPcnDu5FSDc6ftVIPv" + + "H2X3g8bmp4/tIwbfPXQPGHwX6Tw/AOn1Iio430P8HoKC7xl6xhLfK/4K2948Oo+kvXH0E8dsb9ctwdEWbUnsky07tmhv7aK7ELH93t2jvOx6ymEbCOKnzRUv" + + "PFU4jqQIwjSAKGBMcCxFIAA+SD6dkv0W7MVDS11wlWW/jPpG4HKz9shIpaXu67F+rnRdh4OIZJ4o1ti1Rmtfr+6BLa3l3COMcfi9bIo0c9VRVLVgsClkmAm4" + + "vh+dJo8/V0RQlGlQ9qlkMDNdVPnniphlGpS1cdWl8FO1Mvh/V0Sl1tIbxlgVrrLrFQDpU4Vhi+eHZYYuaILhygxhLx0JIQNVHhKzWETk+iulj2W2mtwcU86G" + + "MQ4z+ANb7QBzKK1Ls5X8PjJf66P54pngRybASrZGVXFry+ZMZjHN0WpL5dcXQMboRaqt7AfT4Tf+oq8p/ciwudatuSqtdHMzVV3Btj3aAV1AT6QtNWrdcreV" + + "XWndm7qkgNfSijOypTXV82AoVhzLth7ZcjQVaRZgXGetSMOFcNUd5avvAXTOOR+5CmVt1R63ubeOsTaqOjXLq7o2tdboGfOdxWMxVixGoqfq+85VW5s9bjt7" + + "cSvOVVmdkJsPAohBurEbLQuHlC6MMXQQCnFB9OCcI4FSY/x9duDB8WWCHIZGo2UjDB2ERAhdqHDhA8ZYx4OzY48++RsCevEAAEiywKAgMJ2GXIbkuGJlsAgI" + + "STfh4wHLF+xV4AsxdOBNTdzaWbu6rg6P7rAG4gn6PnHUMG8EvxD6K7O4M4JEf4MAMDWKPmxGkqYLdGFuEYmjawXyBO3MmTPHTTaSfUzwGVelsbmm9xNNFtAH" + + "mVRZNEcWKQszi5Q5ii3RwEf0n7Qp1feCA4qw188PyBrBISBQdxtYN/fOwu/lGr0SDFnZ9RqQwklOiaF2tVqIJr6gMDQCcunWEmlghN044tlMBB/93EPwDbqC" + + "joAX4Pvzthys32gzXWxMDAz2EiG2Bc2CXunOKWcT/Jd8JZ0/4oXgDqQ7ddwH17FtbBku9E7XpXS6bkn/nSRc+p6f9KnelV1s65TucKrDGTAIdcAYgyiWlpMn" + + "+a2c8KXvVN5OcnJ3VdytO6zDWpFqEOgAM0+yxa1tkd48alhAfo7JkQ2/9CNbQQZ87+KQGGPTQ5E4gFVfdk1vNXYdvxeFcOiDhxEYY7FrMZWjxq5JbZt9Nozc" + + "dz1GuLXGru76qq4RbqWtqZLZk5mU1twJtV1xOLPzaum73lxVCWei1fTa0ibVlrrtDae6b662viJIWkitSeEqswTM2HSJlrZyT8vW0pWGoihaoujW5+lPk5/n" + + "eaLn/6vO////o+bpzc7L7b3vvffeew+JCKikz33RDAFQAGMYCBAEY4AsToSkg4x9FIAGEhA0iEhALEQYCBxQAAgMQAAAFDwAFFQkFJMIASCAAA4BFIkJw6EQ" + + "eB8cT6jxTWvg0ASNseQYTkLgM4NkwSkCjMEN8Fevh3AqMNg5S495pBEJKI5TOR4vCAKWLVLLoz7sP+nCgzBi2ZiG4wh2JqcEPBwQBAwvUsODDoawZB7J4qFH" + + "IABZQKZ4XJAIWLZoLQ8aGILCfZJdQ9EQCTSmkJE0zxIMbFLd/v49iuULcJLIl8utTgePYXsIRZ0/U8wZinmBZgpcubwWAIf3LBrN+lqMZfUwcrmVuh9Yqnu/" + + "Bt7TAo8i0FKzbnnIvXEZoNMiP18uR9Vus1Tq4XLPo+xNIMNvHhqw+IXFEzBxe7gcOt/QiAKXE80eZmbWc8uj0gwfeKs8DNq/DrXgJOJTmu3ecj5HtNkm9Sxs" + + "7TnrGt6QdKqilfB5doDQUrlu0CMDZm8Drt3MmvdAvayZnz/R76COPaSPMLszWRKTyB/hnQaBK+CYxpZGea5tmYI0DSiviJYowJ2xDIkR/iSGTQdOSp+6w/z+" + + "px4zXMFPqq5xMz/FI3lkjs+7VCg78ndCFHT+8WQaOyp+8OOEMTFxwCjhWx6qHX15xT4fmNcc/vCXWp/6lvdrqJP/6MFl/L8YoqDjuG9wvH7Z5o0RalbZJoJ+" + + "Z1xUrT6jL+49CZEdtTkSgrkzlmCh/llmQU1NU43UUEA0Ibw7o4idRuIO32JNQ6cfq3tRYHeH6vbiuqQiSiGzrDdPDHpk5ytjiDJpT0PnH69fe4ywtFvkE6Bn" + + "cLEM4ahq+4mPTqGh+481trNamrEGWz2VQpSnPb5Pws7vDA18J3bimbV7pV7fDAGfpfc+hZKuW8UwD+B/FfyvAFcbmp2I51gQmZalwNoHecSjMubDBvzygcPq" + + "ni/3nhXc8IWGAf0SAwmbVmUMFnhPmHRI14ldJjoGf70FYhP7OJ/E7vi7xifTEcZc/vwMQpIHZhcd5OF73ILXtQmKZruEjyRsruJAK0QsAnZGV6S+iV2sHzZQ" + + "DbfY3Jj8eOnz/0Ip+s01jECB8dj3V75ctvVZlZnYT9nzsJwmoW6ufQNg/p7y0XH/9Y73D5mYStLATozS0Cu6XuWh+9DMO6p9tPDYXeBbejSB9dz5eZdlEoo9" + + "T/6zV3o/YsDAcN/gI7JbvtVvEKP7mCnwkbu4Mi4Kd14V2JDBNmYue2R8mZrrtD+O6X8Z1Jyg8ajKtTYfnYx+cEL5CgANdMow+PfuRGw8CiKtn/oBNbcMNKhp" + + "4isAHczJul2PoxwK84nq0Yujwx7eCdXiYJFcJFNL8g/GG5lsIjiObatPMHC5xocO9I2nRt25xbYrIn7ffP3kB1DzcyyqVVIthDyeytyvFV0cub3CSsw86KqV" + + "XNB/9Pbx/ZPlFSvLTMf3RJ9bzQZNg/9CzCdhxyfcd7e31myrR1d3xi4CRxtMiIxN+NPG4vR4TFnGS73PzX9u0SCfXogsO2XZJd96QYdhfLpn7BHSzenTzE3a" + + "nBP6N0DFLruUWFQjf9m1cxhjKpnmUWY7mMmBI00IUd1jCXTN75Zwn3NEz/qzxzDf7JwOd5jXBQjDVgKLDDzB3Y/1O/HmARGuVNy/0EM9i53Nn/nqrbuNdv3t" + + "efx1+BUkUzfUqPtUhi8MAy768Ioo73VIFt1Ne9RCpJeU7EF4nV9Ucs+jsg1WOEUvwf+0GwDWdafubI1ffeQNXzcaNxmYMr2p4twOmKdbWs5+em/bVaGa042t" + + "4KdzZG1cr11oO4Jbvf7uu0/85vbo0wL93Rw1dItbcCIYQFoPAwq2tRphb9vDbuLats45ErVcl972hKQ3AZv6rWsG2kHnE03n8iiYdHdj8gn6NKh8236gpC4B" + + "C5vLr1+3f1ocS9Vdwktp9wWIaTdg6rPzNQ1pRuPiMpJvcwGw5diRttZ4qdfNiV9cd3F6B3xsZ5nX6zXZPvridum6/UqMq5r9VjLYmuSM+Z7ESydxnRqrIDEC" + + "o/FhP4FRqQlH281sfcptqEffOwszUa9NovFFdd9Z9Z/EPXlciQebVP0iWrZtoYTotKfeJB5hJlqLiF1LcOHUtfciuG3iRTzDrsXRbyR0gh4ivJyUW7vLZuDY" + + "/vIITrq1sVgEuO2/JB3iSLd2SvPtP9wf4dc0t4CGPc9oebQN4Mm7zk6jL2nfPkSqgtHYMxaL1L1G273dpIwjQteVd8TVk4mOYNHfr8bZa1NvXf5L8KK1qdvo" + + "MrIBnxdNcNs9be1bNm/6/Uv0ia9dI/TbuHxv6krke/ntPUW22BXlJEexdXMk7mmyMe3eK3lk7BFb7GnZ10TykFs2vofgJKaPXVt6llwC4eiHx3RZ4J4cdFu0" + + "/+22JXkTTanbTs79B1r/bZvvIhYN0WOMwjqx4XZ9afZjZQvidxuVVFqyTW6+3+fPSVjp1gKEgb9xxnRq0uzxYNjcva3d9xBT2qbd7eAjVq3B6pfPl9uOsq0h" + + "Gm0J+Mtr/XgvadGjVQcTz26PiuxaCzuh0mi72yKgxyWlkTLbo9tTyPn+5FHUi26XAIA0+u5mTkuIKhyNPWMxT9nr324mjvu6l6F/hcrtvhIrF7UdGy/+RdcC" + + "1jcFSaNDj+99K6K0BAT+4zM26+2qHuaENGgHCCobQGCXKBySTTos9cvUFUCmNTh/Z/vC6LeG5HPQ2zCkVgnZK+j8CBpNbLgeq+Juu3p3QudEOTODn8tpj2gU" + + "+PYYZ3Cb5+9h+WJ2La/JAX65di5NgejxAVr/aPG5T5bXmV4bPE9e76EDXuUhxlqLWTNm5H4TwM22TOQphVtw7LKH/j3no+OtCrjeek9uHsQ69Zkffe/RakKG" + + "e4No/F2QwlK+TUxk1d8Q6dsXmTMfbpAQ29yZPB6jOwuXIRi4hMj9gQ9PfpeE1P/xQiHigYVb0vJoAhn1BRFtdqlAFTMzTn7TRx8Y5tp7sx/ocWVFyTisIf6P" + + "xdySqtT+syCiTxBx7PlKaxMIKU5rVV3HDkT0/WN1le7Qcgfij7YCGaV3Zvlhzsh1d/TZB+DRmxTq3+oZDtdDThCkhADjRONTBoxHdtV2N5eF/szBLnwjI1JQ" + + "Dr1rxb+MV4/6llMICaON4LGXGA6v794tMuzVFn9V6amFYFqYdDqoD2bAZADXkNJGYdRolsnGH7mGGywBDZKH7YBf/KjMQOAcvDuz2+F47P3hUFINWUWjkqW5" + + "WuEP+PX+2bzMhIs3O7TRxLFA33HSd3s0G4TD4Y6P9aVczjEdD22lHeYBG0YKFyrDzZLgPLAuwUiCNZXB37g1PsOkJmsVmtGbUrfAo9F/obyJv2vuGPNJbfaT" + + "Phkb7brJmKh49M8IqBKT+av8x9VMVdy1nk15Xw+86AoQl39xebA8E+PUaqs9nAkrNKxGFmMkHUWL2KuNo6uAHMqu9OaTjVvH+9LQuSWftc67W55XJD29fms+" + + "4wnAqAM4M4IfWOTgQupuy4TVGEaMYa3wP6tvA7/2uA1wqS2ssGLWHE2nlHsa6JLCPXf9g4TXgPzKgsOQuRbY6K9AxI3ISt0ozW9vdX0vCbwqpgLKgcQVqBYn" + + "iZ5eCgbCKnToJDvK/hhOdcwwd7ooEvrqXbfVHNUICy2WVAlvJS6CMAj5Dt7Cf1/Wa+otXFazwTDV91o0AkxsBBgBApbi5EFDdR6zNB8QedWWk1Bgug/AGUzb" + + "bg9udfryOxhxvKFtbQdJsqnptM+sNZthpx9q8E/qZBLqj/zfwD6yP/Jj2a0PD7QcCPWk3OGGK9tMnyNFvzsn4PLwAe9zlJPIYV9jeL8mutaOyhK7ElsMLpkz" + + "/Fw5Ot05m5+Gy6/fE5hOThWYBlIk4y6yJ1R/Hx+cq+9bzepVdMgysf6QrrV2xo+x7oGT1hlovbjLmsoBxvf6eBqlxqAtoJQQg1uaLNNT2l44j2+sCvK+ROmD" + + "YGBn8nbqsVtSBDJVbmJkadMo8fg5SHV7ubRehNAJwhHyJRBUQu1L7ZJPjD3nLTvg5yV8TVA5nbxn3UgIUN7O0d8b6sbuwHyt1JIv+dkl7PPjkIQxSEkYO7kh" + + "mnutdK7DwaUOOSLf2XruIIIn8puAfBwfHyoYJngViPYUZp952uqNdreV8m/aQ5Le3gDXsE34Wywld30iXTkdkq8D7SWZPwuh2qbuOBWFgugg8Zi/P0Tq58MG" + + "KPlf3jFwcUfA20DpSGOgC2Zrec2Wsx/3Fm+U58lU8XlCxcpq2+L/ImEWxosFQwOMfCALLLKduND6WGQFbXXSAsjaviqAPeJnrcE26bLzA4TD5aqniVpb23um" + + "mf/w/JebP+FHJiyliIcr3i3jazvz13ODXDbXZ6GiRXkAsaJ9iGvfP+CS8DrGcEPdXqJ9Oi+8dwmZ/34Ka7E3Du3U42YcvH06sO1qbobjlBEoDIoCzTsN7VCs" + + "iQWrnX6EqlsTg2hb1MXG72aOPvIG82ZOwTkQ6BdVY0RGPufWGZo8VwTLSXLymwAMrR3gfEyEweuvYh2l7L+9GJxLMPN+UDGNSMXJvTloeHQ3Bqe18Q3d3F39" + + "hmNNNU+MJ0sMOpGtmz1gtg1ZV87i3+R+ZJFCYPDkX8fope/PYLH+7Id7XDVXI9fi47jXqjnx8G9ZZ23c5OIvPGfHGzBQ+3U2reDFLA52nPCTC6gUUCaZ0Wf1" + + "HjDhdWDSeCoWXd66JO0yVnlxVczIK3ckd3+TTQwq+XLZqntB+awZHo9K6GBZuXIIJo05YEFXmw4//kxO2y+6Ydl6ykvrfegYdhzM+p8OgmaDhY/EW5qTZrOf" + + "DIN6RLcNzaZt7zKvKsTAJ1ZC6PVGTLdVsP3Hr0/yWcg+VGeV2EOZWmEUFIQoYm2eg6MP6YMsvOBK/XnZXsUIV7XOi19Npwmg3iPYNM49XumXkfJHMP8l2ps7" + + "FnDogobPjf1/WiiMq7k2+p1xvdfDxFbGu8S/PDjxhOegKNeZTfjfAWjmcMDqrcR+9v17trOtdA//xyxdAvyUGGi6bvL1Ne4VxKvpJensbI567YgQOKKs6FWv" + + "ETZyH5zVJ4lvqi+/mWn9vy7b7GlGt9J7/eJEknzhvnTCLbIHN1E8zTc8RYSLhprMrRHMT6FzNZx4ioj4OF9pbn2opW9qZvQVXl58xzrpwl0uK6ZMkmxbWwwR" + + "/DpEdWLzePxYDJEje/GS/1fOX5iIf2QR9HDdWOMXo6f6vgPD0IlLVFaxFLd1DtbrxR7epP7elN9MoJhRVLI5lbDB6bcajAHjUSYIx6kNhR/V/gqZSMHnNOpe" + + "MvGqSzkQMqd77Y2kEugxEck9db6P17rcguu/2RwqVQYIaouhjWjNOtj0/biaBAxEt+uB2q+v1EvGhYduQo5/R7bPMvLSjoyZuz1Sr/QQQ9tPNWK+3M4I/lRD" + + "mc+uqY71VDEO26KmRf5T2yJ7uSH/IgU550AMBF4c8vcFOMi8dSAb0BAmIA+kxdvNW2iQHlIC2csszGygokHAgzyAHwGEITBkQSaQtNBl9/vweaCf903U+9L6" + + "eXLr89P01edHxBjtWerxwYDHb4lVb531k2ilIfBujY5R5Aw/J+oxIvWlylASLWZwd9zrHvf3RF99//xiXr1guFJLZj0sfVjLONQb+lW/qFlTvX4342+/9Dx6" + + "dKMXntUvUdrdwpaQx5YxdvJ8S95lD1roX90BBQgRKPwcZg+1yOeXobN7cOeAwy7gukr1DW/3Klg5Mb2cn0Z3Z0lMAaiaOXvdvGri+24BOFXIu8po4D/UA8Ob" + + "CIS9cBRjEm3Jgn2qnaf1yeDhAiniNP7BZZ/swwKg8fJQn/+ouXk2V5tGA7ns8LW/QKHLqySRYfddMiE8vAen0S6QoFKvSnZ5mdDAnhc67vtyj3b8X0GI3vNi" + + "+n33JKXDkzUsHmFfHAaqy78PpV4Olsc8cP07jeHnykNWfwfHDQ6eeqLnGigQ9wIanrsdwJWH7/wOBDY4eLj96W33jy2kuH89cuUzl2UHsAbT+Nm0Ff6SYZfX" + + "/peEXPlSnH/8mFFE1i7WF66DWy+LbS6v3ez0ES4LzWyVYf1i3bn4TOnK8VvTkYQgOB+5Je7+Xjg1WBjFBtN86zrdv0hw97nyssHCuPdmOTzNMXnGxM/liz4X" + + "HypPDRYGeN5WsYfMli92ufUK+YnBV7bZYJq1q0Y5/QVVuyeWqXyEzbEAzzdLel6aaSzNtDWszwsnl32W0xgMJhNbXQmh1fq58XLZRdG1wfsZ2QkhNGyfGx2X" + + "XSE6MXg/+xmilAgV+9zQuekk0Z7BGTuqd1R8Fp1VYphX5FzznbDE4LaR7Z7mYEnbdjrXnBB+KtW6aqdI0eemQyTo8VGB5OF5e52B4qYH5QyXl8H9Znyj0wcp" + + "uJzfkzT9maRCuyebaFG1UQyXm84VkrGl7VRsFMXhsnfEkA3WrrRyepx+GQWkIS9HzziCzch/fFYltilt5zAJbnpXSAqsPaQhKjaHrHHNCekbU2i6LZvD0rjm" + + "pPCMKzVdy+YQdK55SY5vcBmoZ/tHxYy2qpcO4WGuOUH+YbBHXGwNtcBkcxF/rjlcjqnrnPLe9O4FTNgYjJ3ib1mqK1gcMw+7HCEC6dmpMpEQrjCfN07uuyy6" + + "NfhDM5UCV+x5OVM3D/fQk4fyf5+b1MF97Li4+7+OYiVX/aguRyOBBq/06mSuAApYmBNLoJxtA4SBp156+UK0xiEFive4oHxx4CGquPpfcF0GOMCcMWjlnSZZ" + + "UcIouWSGO56PTRGq2JhgbOXmlpkon0eT0669HemgJuipoS9TJQEeASwB8OvV9fcdmtSyHe4wPjXazQwGDtWka6fNbH6/38/n8/n+/5+Gw+Fws6ioqKg4bWLy" + + "/yXzxreY79Nws6gm2Uusp7mcbjy3Vs+ucz0N9RbDUA29V3U+5DrlqbrL1HfOda7MpSPfqdjFUNfNNEeOYc4ZAw20QVM/kjQ947YbrCyGLs3U5CU7ayfZV9vI" + + "JrKFbCD7h+aRQ+Oo0jI0DP1Cs9AuFT6tNas1qV0htHYR6dMVdJoXzLMcywqchzMgXQbIcdyysVzRT7ZEJVlIipxWQMwfPkodNvgMKjKG1Ljit1Oc0GQv1jEz" + + "CiLpZC/ZWTqJvhKNiESEhBvI+ePkkc0cJg6wrCplZA6DvwBJFqSK0Tei2Ezb1axWxS6GABFqonx6OINA88e8QBP7ZSfHuGhR5CJyAWFNQvFscjbJL9PKLK1K" + + "K9DFqzhZRVblEWrcUBsKBHktT2sZTGqDuSuKumtXU8/jdR3q5Lq9ZrZfGbUzoUpJqxKKvmQ6REMeXhuEOAj5HPnkUL9bd/GHSeqwzSkmZssN9h9GFev8+1td" + + "hww+REZFaFHRUFDOueZ6VqfmelUA2743rufxusv0zmoxpZxzzovmr/Dvbq/ZZFb9Kxog5tHUm42K9+2o77W5XuDVrS689Lv78tu1ZnuxuRqV9bYDALqLsr23" + + "ru7vqP9r63qlnLPtRdfduMT641086+/r4Vr+vvfS3P/XuER3Yc+D4ZbW17T/ms7tO5b2xp1dqsVuV2qTYnX2u9umber23CuAzQvmk/pOBrwFIs6zxdlCgmmW" + + "bulG4EacNCKNeMZxmzEOQWtTNGM4D7KE5pnlzOLA1DJLrVKrAQ/CySBkEAYj1Ui1S6oFPl36xNKnICzP9EwTmD9m+VP+IOCcJGEPDozj5jCagSmai1PEKbnA" + + "VcjPq/MKJGCa5Y5yR97hUpyUIqVAHdgIjxvecB6AHmlSPBKPwJyYGZKneZoZZwSMaZYlKECEjWvhpBbSpSXfIN3GrXFvbdfWEY3WsiHiOCQDKJqhEY4njZMG" + + "aGN0M5/M8ql8yjVHNVzlpEqqIA3RzAg0bqANlGeMbjx6izwiDyhzZAv3ebps+YZEM6mYJZWSChiDk3EsTmKRWNkWIjb2GHeP3QOsjXhNaS1OiVOZRqIX6rN3" + + "vvRmpinKShEpy7gFTlogLYAw47gDWlTplB2wliFPQFhTSE1eYrb3cs6xW5cuTm4X+kC0c6Ur3KI4ru/173se/f1+P5/P5/u0/z9uhsPhom5Rs9dr9vPR/gxX" + + "e9XUNV3ZVfdbXY5TT9E3bteet+mtb8zqmjyqk63kKubOBc/JUEhXlCxwZoQysbvUeF2xlkXX17seRl/f1OFX1vc9n/5Y9e5Lzf9VdZK2bdLbxvAwtaz6pjJV" + + "zf3Y5OS4d9509dEg5NPD4cgH1TAUFJQBJ4ocwdtuemEiI2P7rv00fbeLX9Spp7r/V17X+TSG15/Udyj8/W95u1YnAG3KQZ10MC92l/4N6uF+k+7a71PUw919" + + "7SSt6m91PT09WZ+geJ5niMK4FE5KIaVUQGHGI+M+so9kCiJgTh2neOoAJwSHr6gTeFY0I0lSSnsGgxhIEIRRPM1RCMTDmPoTgAGDIjHCYBgSA4LgIBAIDAzh" + + "QAjCUAQdgyAYwiEYykEY1nq6ATXg/i0GWNnFSndWdJUi6/uDlpVuVnZnZVcpWLMotKzsZmV3VnSxsqsUqKUZGlZ2Z0U3K7pKqRrdpWElukuZRdUAUKLmdhO9" + + "ZUaZ2J8ylC5GvHptdkIC+U/tWJuE3DtN08kke4ADeEzrJ3BIL+b2UAfkMcqX6nBc55D8Jt9jwFsZTwa0aFo4niYpyi9xNEa/MnaDb0hoEHpvAq0Xolk5TrKn" + + "PskK3hFx0wvKBN6Ft88RyH9Jlf1WZuEwH1i7eqvmJXCIbXfKoMfKF7xFerMhPWZGuvd8pXGRagReTHXOzTFsD9NyBSKahR51ORzWO5HaPRSLh76S2Q9TzPZO" + + "1Qu1rIMOFV8jUQ5VVOw8hyyuThNg3qm4Z0JClai3Fa5bMqdURh78+UN7XoNKO96oIytiKo+mGNI68mamoYvIyMS1kb2cUHF33GMOX6MXMyc6ZoRvrsYmGGYe" + + "9KlYL1wBqWB3m6s+onvJ1wNNwcYPlzh0gc5Sq2qaytzxvvLofGSH6AgehaWG/KcGD56VKms0sCLLEhJYoqKfcR7w+g7uqIgtXqBmW1Qqvk8AtAjto1uLonEN" + + "oT8b4muuKsAw2yE2xivn0yFLhaLqolmTfAC1eST50FvcirBAveL3g8R7nX3LwZZzkGWbwRQfsk++0EcDFvCvW6zrzK3YCCDW1oKABR6VBtQtUH+V+mgNY1Re" + + "aJyu68o3gK5osm/w8fMCoy0qbh/AE2AQCIDFPYhzAzYij4Jp3Ylaab7kdm6Bhzxcas8wKfpHfEob3zWkxClM2S08G7DZI/svAQWkd5UllOkYb6PKmEorYDkE" + + "0LHGMZ1SGDd0ttPFrPpJuWmpesBzsxNsVh74P6WunxlRlvDJ5MqUV2nUOmKPhXGDJLl1wY3nrDfINgnd556qgs17wyYsfAHPc7FHALw0kzoAh8XwAGssbwq/" + + "Mpbhp8Vt5FKhsSIeY2IVpxBAPNW3g5a6jGzFRa7/ewcGOg1coU1M4Wi1BKcfmSZGlOS+vWni0RDcHMsDDXhenpXMPeYJhz0hobq08hYZKu99BgcSkOB0DBxf" + + "UXUDOalzK9mMBJ4t4zD08edSWdz2b7bZF03e13Auo3qcx04x95XPrge7du3ctl/YZBUf01nIcX/kqsVPbe0CVgwaL0sd5D7MaA69wWKZdr6jMpH+NkLHOSma" + + "7kXFL39AlwQijidzdlNYbX/Ch6AFt2OQgDw4jWwJZyY+8dmwgwGPT0v2d+t5sRlUTWRVdq9WI4/vhvzMvYF25Vd2Fg6Fm7XMFvRrH0UyoqZjcAFVmiv7znZj" + + "p28h8JQ+cvRq7g7V1LRruFx+1b9/Rv9NCnO4cC1lxJCteu3+w1/aSHDm2RWmxwYqdnEZb69NPlL49IedkhHEOT51gKq3ZyGuWgb/PXY0H+N3l2fJB63Z+O0j" + + "2yr7EUaoZAmPYGRMj0uA6oHkk3MRh3bul+V/xUx1zxTaat656ZOrCjwO7BFQ/sZx/i8pJK1NyhgG94GZPBD68vyEVko3QxEvmiQFyY1SrqyfjDyEUn9nHAwF" + + "Pd9aFFLWRncM1AV4pAIVyoaXJ9Jb++kCShTPdX+tAzvnfAIy5lbY40Y2lsSYXH0BNyg4YAchOAq3V+zTKxnTs4pqy2LpIzQnIGvODzi1woa9Zpx0NQFJDIMd" + + "eRZA98JdraBdi8X1vJT5juILe7mO0qEMk5T4CW6vg2VkHWYIp6SbEyOA+FIf3+Sw129F5Fzh2BdLggdzNsShhjBIUtj9XkRztHDsjSXJgzcbRUFDGaZJmTYL" + + "b9NQXXN8ppWVHf7kchQLWTyleBrCtcSn98lVaB1mCKeEi29Bb9USs3Zw0QSPaW0jaZqafcrabRUu07eTVtVwaXLdf3TNwyWBP41wg3mSEmcAr8KRe5NAeCs/" + + "T3KIye9lcMROnX6fmY+ysyedUVUrEX81/6gvSB/OWSoCNcQIk+tWyHsGTskHvm7zSU3MXaYiVs5YUmYZmF0a9PQvMWtSGO8mZ7coIF6nutb83QRJbLGXYoPz" + + "+XkSZyV1aqHh59Dbu8Yqwkm/fGezJ4p4m9nwMDYWkWsIF+RONPAqyRxC1heNTVb8wCPCayw5YLVgh5VYiIdI77HJDWVqoOuOJWSGidUFrIW5/nmtESZ5kOUl" + + "NjFRZkVUzlhCwrIwHNYR5xac6wUxSYORl9jkhDIVsHXHEjLDxupCDT3Z3AKA38qw19jEiNUDvwmz82Z9joDl9cyZhwAnmHrOhcdk9DO085uIKlshKmcsIfnK" + + "wuLCegB+kwqu5w7YKC3qRO+MTVrEtVW3cJx+CU+fIUaYsITNJDq+MRxvWKn9ra8VMaVXkLNTBETOsmlyEcXp4IZy7sjUYZybqm6nuE2i/XHiwciS7FZQJv8Y" + + "60vfpmEyBiOPHjJRZ5dl8JH9IXS4FsSFNQKysQSajPb8IJP1dUkGH5n9QYcrgRxYE5CNJaDJsGcPmaizS2TwyPwQGrgW4IA1AflYQs2Me36Qyfq6JBufzP6g" + + "wXVBDqwQkI8l7GzZEbzNMaKHLKmz4zyIMP+QFH6WjQMcocrYvOeTkWhDTnLY9UHs1tcZPBteE4T2B1/ekVcJdkJBY2UwEf7ZQy7qrBIZvDQ/hAbWAx2wJiMf" + + "S6gZ0Z0fBLK+LsHmR7M/arAu2IEV0vKxhBgI5ewhIevsEgbfmx9ShyuBHFgTk40tmGxfEr2bn3oNMhtPDa2+utVEyLM/BGA92AFbA2P/77ueBOaA2NFDcNSz" + + "y7Lx02hD5JnwnMc+twtOOHJWQc/Sk7Od/DMqt/++TG1vA9f+x7FKTGNiiudrjOLFK42sw08c9FivhnE2VrKIz2ie30TWkooYdb+ECCuB75Jzk66glSsIv4lv" + + "zf3Rb+cte/mX8PaNPF+Tc3Oddr8J3s039U3QEhHD2uGXGKAnWUJyrr++tjaBdJDm+iajlq2IkfslRbgS2CVJAy5f+E1uffQY7fklQ7gSyCWTBFhq+E1u+eAh" + + "2vNLhFA1MGuTlfQZ5f1NZJVbE5f/JcRwJeAWc6U9ZR2xXTHmdXKxHhO6c8sy3BjuDY0Ot4y5C6fNKk16DpTCQwegKoX8ylkw4MI9LL+5oqL6xY51QyL/q+j0" + + "Wrd89rbmLM17lFk2+L2j8vJLjzc45m5OiuLdYyua/EUA8VXi1/sPDsCKORTdAB2PhAnI+/Pjq0rtYDGz1jRCM/1KW/PYtEPn6j3BMe7pT7gYULOC3LoSon+j" + + "n+yrSH3EMceXa+n8dg9SnHEMs/F8MB0mBa7feoKRgb9tfZqeGfGyXUYbO9CsNSLIyfK19bWXRccpICdNwKYdofS8jLVaINdZcZS3B2TacTHQPsBAoj4Q548P" + + "vTAXMuXcwTtAGl3JCgMzqPH4m8XRFOOMT/sbJSp3w585ma79c0S9/Y6I5CsHxnUu6j/NSD/Gh4WFUItabNh3C6lh4lpF98ybyTEsGx43fVz3rl3N91KV7JGN" + + "gfBB59bqyZ9UdSjqewdfM2vhWf6uTi9uOGi2j719rLCe84j/vdFMGUve44+X1Q8DAPtetIPdZ2QdLoUzPRiK62WKxMukdvGQeHCtlcKLe9cesHudmhZOOziH" + + "ivKse0Uka1ENK4JsTouunclaw3OF3L/f5gAtrVYm2/J6iu+VFeA11h0KKKr62/l8mJHw8YyF1zwRVeijTP5ujMUAF6Y4BdbyyxSXMW4o7VJiTrBwBO7H+EEY" + + "h4cy5jYCps4fshmz2iN1++U3xYCWOadtpf2FEY5hpe9hGUOWvz4VXPnwse7/qtpukdmUUPrvhi0pRI0ccC7807vxhre+x60kqoqHouva+6D9tghW81Vb45S8" + + "WRQqAYjfoobSutnVxdY5wZLkejEuPaxy+KKlZH8t8gGSqP5Tg6aXYoB31WkYzA6PchMzqBl9jhjeeI5P/R1Rs95YfVhjkJV/vkIrVfnKjH3KUOGmeZqpBn2S" + + "L19jhIFM9uJqxQhgsi3Acvs4MoZHTf04niKJatOvNhgz1Cl4bP3kzS+JxWi5zcq4vk9mk27GPxzZ+DwPP703aKW/H38CEXY3fIDIrzVczR3UfXJ8Ytjs84XQ" + + "yjOFWFt1hBSF3dfq1WM6AwehGvyr9YcMOp1MrYjxyomQzEhUijpzYGmPhaiU7Dc1xD6mT7qnOyyl0VZHilOuX3rjpNYBRD0hw8nRxD2MUDImkf8P6CBTSthW" + + "jqkAKYSq+Fdh1F3HnRaO0nCbudtdwcQxtpRxAOe6hFGpevWQw+ph6swm+Y0Vfd4h70FWiZ92km+pBUfk2uzFJN+v/zJ2sFYXVi3wXannXqsfDNOefDBkjy54" + + "uz6uiPsP1JPMUnicopzH9nFQgGaQWYUMH+dtmXhZ0W+xzi67RMlX+zeXeFvMeabOs+jt8Ru680fStmVQ0gWzsrMs6oX1m4nNIfylGncV29nWeboX6baybk1V" + + "bvXjoYs0u2EMaKUeT6cMU+/0DhPg9czYn9g/304c1wjCQeRunDrNoVyoehQvTQtcIBbht1VPbbPQLKF6ZxNX8h2RQ6zGJORvyT4Ya0rMoNqXgQd7ms930NAJ" + + "9zuhfxz1z4GFXmTl040EDwDpoj47zIXME5ekfGA7SMXNoZYIaUC7yOWZXywfwXjHFJiy6d5PCUhgbA+5gHlJK7OCoElC8T1BN53YdtC0coN0gqEs5s7a7qt+" + + "1x4ys6+VBvcx+BGDFuYAbNf/uxu/H+HNvhXH2pDr4SCppx3wkzfg1HV4CtrtNhU2zK0/uopPIz16Gmc/Y6YK3u6H9y9FFeDS8Dys/d6GhzVzNIMW2xzUCiik" + + "2Sxs4wDS9cyMgF8UYwaT27SJuMsqJPGeKWQGMbP6OpipS2F/JmOkJ51mhwBE0yahs+MtEy4DPo8YCOF+ZJ0ilHyruTcdQmcPWjohIpiNTTgEfo/+WHT+nvv/" + + "jmjumc4Ceg4mMX5MC/RfTOLy+CHIvLplXP+I+gIXBjEiF3z3cLRdULTXBDJxpmG05xkxBs0MD3rWPEG4neatGMTvd1j5UJ5NHvDKpXXAjmfa3yMP2qGpM0MP" + + "fo5o6MsXCPIVZ5YcIxC68RObpJN092eqdZwItmFeAe3TImbRHX1b5UHXomEXCsg43ADzG75xnIP7r/CJ4wzsb8I3jmOw/8aPOO/A/iu/TdwaA+ChPLXJ2pc2" + + "A+xH+MZxB7vLL5Qb+rfJe77PEwQfSFGarH2p4dP/mvp/VqPucWWMg+JJI3r4wwTXJrctNtzYYLXfA7KeUFxVlmax8mWTI2J6rwT8yirvSyuKOCMI9uwvlF/V" + + "MKRVCs6aAeDgm/QLq3Bo8p5o/QTsKhnDgRJU71KHM0ro7ssgnPEMuPusw09XaDjX7ueo03L2ZdgTC9XjImBC5Ydo9OAEJfjuFlyarG2RJeS+xacH9dKNrg/e" + + "3eIafYQjmtx+PQghD4TSxCJLYPzIT49XdMLDB6E0scgSGD/y0+MVnfDwQVRpsvZFloBxIz89XNEJhw9SaXKRJWQ8Jm6b2tcai3YdQ6BQzo1uyfpaIk1ndYf1" + + "+nT4Gx32FuvlEQDlYIAvwbkIAcNEgXMTAgxSFc6FADJIlDS4fDnrDC6wOb5wnoTFh37zeEEnPHgkKg8LAAmaD9rk0QWC8PNLFjwsARIUvrQJp0PA+dIPOC7B" + + "ZoO+cF7ChS/5wnkQbrbkk8bPFTHCwAEPh8rjIgCC4ps2eHSBIPz8khWgimgmApWiAHp3EBdD8HbTBiJIFtdj4GJZHNgGegMfM6qWxYstZCVdzN3SRE2gPttc" + + "eRMfli7/nsOL+5RFdnd3n3U3SSoO/3p24B39be1py6EBbAE4ASkpoxm5RfEY8GisBYF2kVDagskZloDGuRTtU3FLAenKyTnAIOROeWV0kUzvydvlx4EBHgEt" + + "AEwk68Bz7IWAl+uFgGnGuyBdOSj+XMEBk4uNXS0fACZQhpFgZJzXVvani9RbawJKzNTMeChho5kNNTIbaGhkLBEbZDTQ0NiUmKnxYNtk/S5hrTXRi4ud9XVt" + + "0im/wE4oCB9uRWCRL+dBhqaDdTNjorUWsniG7RXHEuNJMD7LsSxYqHCS8acYWMnFxnA2jcyIEjY1MTBeIsW4UJmVc0ibdMp4CSNBAsQHEzU2IFwswCAwfYZz" + + "aq29wBTBcYOEB2cS5LRDxMaHIzsaKPGRYAJLaEkRIDiymwpKkEIyhEcN3qHCR8TESJAcJxTXs2AnCZEeNvqH6kLVFKAwDwLHYkHloXGVw+mvLQeWhZWsK3+G" + + "9daaghk8fxZjIsXEnEoPYybmL01iQbo+BqtprUlorcUD+rxwEowZeT9vVoCVKsOunEPaJVKWE4MgcyvLvPRX3gkkjHXlUvYnGQ8CETj9C9GVS59jvbwJdHEo" + + "guPGCn3Gh7juWmWPVD62t1b99LP/Vk8sIeywxsdrhHrSCuOVyt6au926WhkhjPcxnvfifTfEcFo+q+0ad2q7lW93rK9TimPM+O48MYbSXhbHwnJrp3JCDeV8" + + "zqO+V+qHL9ZIv8r+seu8bbRv8aVyTjjjw9HS61pgZGhIXLBwYbLsuLi0tIhEAACEQiwsINDn4/GsrFSVc65VcY2Ka1Nc23FNx7WUa1Jci+IaFPfEOXFNaoLP" + + "CQVjQIBLQZ0KW5jPn1BYtkIK7eikPjcnWmssNhtmOLTWRG3m5oRNiQIfN8Iuk0aZrCuTTjnH9CWeZZzWWsiNUil4vejoaFxV2H7uhGtnlTROJTDURPqoUeQR" + + "wVRqdF1bv+i4ipOyDNsjjbWKFHiCneBu8BA1t+Pcjsu9lYNPq6S0KkqzPqIPABSIYPCsqALUG/CGR4eSBy7kHIjWSUXOOedk1WAyiJFBiEt0SlwK2NDAuCVA" + + "BgGdlBQXRScURhs1nDrqySfmNHdZ48Q5d/47YiqlzDlCDDWtF9Ks50vdb6a1ZnuFWhuN8pS8wpwzzxhCOGeM1+73sqT96ch/c8n13yqljnVybHGXlcJM6WP5" + + "UFe4whhvPmO3dU75MuQaP8lfvvxo1I/OfK+lEk5M94tx59wtl5Q/Lu3Hyy+9FxQA1Jq1Li0Z8hyvhC/Tju99f++Vk8P4cP+Zq+zPc/+7u+1aPngtrpa+xzHl" + + "FtIPADphWJeBZTkmEwbjwWGBwjKck2UyzbhKmHOBKDig5eMyVM46gk+KRxkpt5bqOWHeuW/9z/vP3bOu9c43MeVxX07hpTfLK2PXGGJp64YvpyD8eHQe3zlq" + + "yr/Xlx/qKaGVV2J9s9z0429qMZ+6R44lnq+1hFfe/FY/+DHqeFYw/lsfRvykphfvLQMpmILwA6HOVMo6q6XwL33Jrf1r6axc5rt3h/Ll1XDuKCG0OEdIuZ1Z" + + "yvg/bZQwlYKjK/Rpo5HHdr3p66//5BtffCPkM8qZ95496ghttHlOnu+TVuKvUmsY53eLq64cXi+j0GekK1xhjFcwjhFry5+EVHZJ79yYb25rxVzen5heC7PN" + + "7/6cc1eLO7Rbv52htvPmnxpXFcYYdEGtWWsre2nt72WuD3l+MHP9HcooZ4ax/pt9TottnXJKyevO+neW/3b+Z/WW77YKzYKavSCRA2GuN5+Y13prfTgfz/Zz" + + "tdhG/BByuzeO9vKb7cT6VYun1BpLnB+0WT91HgIwBONxog+82TATwqYEywRQ1C92jTOW1EJMKeTz56aS/8yP9zfv3JnOy3GVV1O4o9WzPthfS8ltTsEUtDiG" + + "WKiDiS4SERFJUlRQqBzTFkAgEBwKBsZCWZojSZzkPhNAAgOCY+VYHBqFoSyCIByCMCSCMBBBxwgVUQQpCKGrzgF5x5/FIrIB4gqSxJ3OQ1zxObDfjgA2D7FC" + + "ugAF6mH3fo4aYauLYTY3bZYFB8gUj+/tf8WpYnMkEhZxQzTQg9LnBhTCdblGLiocsjFT29TWe2il27qc//bfFyfnHRx6wmKeg5qeuMfIm9ZdPKSfA2g8oCid" + + "InpI5TlFlJOWfj712b7BDVNpTa89vOUaAIscurJOuP6w8Y/J6nOD+eJTjVbwzxI83Iz2O67GqicExm/T4kFlgJohoqIKRj90A4btCyCMEcAfrcDo8oJoCOJT" + + "4zSvAG8ANcu/OABI4+yFTnTJXgqVG5qMycTeooGHLYOt+mM13UM1jKgG4x9e/bXDuSoQGNYmmi+cHWwP9R41+ANmay+3/mljP9AsXySN5FvFbT7WzjcJBl+G" + + "c/9X7z9zOlPwv4fk3b94vvNngXi+G8n5bhwl9AC2vtK85vUsgfkuTFMA5L8C8UKmJgC7P8umxWm6/lx7dSKUF9Cl16VX/07p8n/K2eZP3x2pasxsS6OvasR/" + + "n2sIM7+ZNBefro5N0fxR3IdYt89bOP0Ad/a+R2WlKXwp15wtfGUnShUSbNgvoBf5aov7s0Q914jccU8BnHM38H8bkhfyMw9OiE+GlAHAKtWlHUIDNyhxGLKo" + + "fdOdLOmolzVGD7EqlUgY09uo62PhLlr/pZ7+EjsHLbeTiPZnpI0AaJmfVyd1AVhVRVpG4HmhgRIQIywQKLvDQpQu+9JhwfgJJ8IrR2/jeQAcfzY1kIU4GegP" + + "9zXvpf6F8B5uOZM+sN3qjd5UpSQt7Le1eNom0LY/YN3Y+i3hu8Oj4LrNLvtSOKu79ZMVBDbWM72+TXbIk0fMk2dXoTRv1NoR5WJwVY+L7zOknFFohlf0LSu+" + + "50lFs/xtk0H2FKRXOlo7sdf0teCJlQ9LXO7QbV8ySvTZ6Ndds97iyVjGHZrVSFuUGY1ssIn6K9cXNk4ubXvVy3kEPsc93ef8XsfoifaJ2McvG/F8qbtJkwqI" + + "FoWfwy5/Y+lkAxKH7QRbnBLr9N1YBSxW91FzLWdw6+nyhONhfd0RB0XlV71WvjQtqA/q/UxUDk4JXAUuBhBcwCxOtpwZGE5g1/jLfYGBk3A1Pg4piGnVPnmj" + + "1BM/JsqkDH5RrCewpOlCYFeXKdr0TNYJIIpcn8BS/TJk5zY41ProeHAjY/m7MDiShpApau9HX5rW31h9fnQEJrt4e4AOti2Bcnav+QzKFzbKD7CBzkL/Y1i+" + + "ZWFAfcF9HHYPMrTH3y9eMgdfs5i3tdxb6N/a4wehn4TgazeDj3AyO9XfwwItPGusR6u+nafn4OhOByMbJZVXqNl/u9uyq+D/ZCxOcgsLFAsKCwsLCoUFigWF" + + "hYUFhfJiaSCK2ubTmf9M+84/LZ35z7Tv/NPSmf9M+85JdRNphL4Mn4L+wY5Oaeb74Rfeutkhkao9hahk2lMDQksnfhutW56npxo9PVp9mv/PdRvdisHpTgx/" + + "7zzM99lA/g23ogPRbgBB+KjDWPMDxjchuMEh03xUcGxoKDHfyKAOT+b3vz2/SS9i9+6W7sYv/1S6d1C48NJj5/zMt0a9t2cyX5+MkJHxcC235329LO9aeV+O" + + "1vhzWjasSSako9JI+z5stQwyDF/7lUusaZljEa4FgLSTXSgP4nEBOKe4G6qIwjgKsuu4R/oz9N+kGzZ2/M1Pph1ZhSqscdv5Vr5pinsoyx3/IJ8crcH3kMrd" + + "aU6496I6oV79SRL9yRRfDyx6Pbh27sJww4o8TH06HfP6Crv287bpx7Ht4yLP72750PFjHPd50/6WSh48J+Ubg/9OQYn1dtDs2j2k6lybXJ54/0EeBZAgczcl" + + "3DTkes4iTt3R4tOhYog/PGymXE/or1oTh8h/gSCuyHtNNKpUh9aM/7lr9KosQpBIdr2EJ7IuOjZxzfjXHtEw4rg+albhAnfPD3T9O8qYiQZDzb8xuNn9cpl6" + + "DZWXGPO0XtwcXLoj7Dvo8feGlLZgCkgNVl2/gjcUQ1uRl7ecXYYvNKvaEgUP2v74FfWViFiD7cm82aTuDvNgkzZ/gWww5C4wi1wHWfh/W5PuXnBOmnqIiRhB" + + "RTH2nMVkW8g0yH325uoQJcBcec1m2IvPsgMB1OsEAOaggTYmTd1yzDCnvYEAuefsf18GZPrej/yL2OY74U0CyMo8gKHVyxp/4Gd0HPeM5AvGvL1QRWrDrTAE" + + "eAwNjZlSqXuC7xaOpu9j2f7g2zRUCecMgDnTkZsgApmVxrhqd/2D5/hu9Ndfa9PwgCLrSMN7aWTHSEifCbbe3WYCRExNi6XQi215CAj/sGbf2BnGfzi2+SAR" + + "yirs04wOt7N1BDapU3+hmM3MtOO+NmNILHmsxfEJPVinfBD4Olg2fwx1yerg+GP4kPXqyvkTqkgeqXWrVBHT9UItqR/6HHSCIjUjPXJmBRY2g7sHNRVLK0Hc" + + "aKOcXrIicc53MGPW7OqFWg+gaS7a/gJt6JRdfiq12pF3ZIrpvWS+SKLeaTnv/LbjeAAxyIdZmjQJYG17RSQyTs/7RgoUs3w1gK4luPG4LAGHElPRb9rywiGf" + + "uA4fueWBIpXnGtHvSbLtbqB3+x3ErdYEN7+p+OENY4l8AXTwLvqthXMkLfrd3qmeFvwXdhaGN2GLjpyzO8Kivn7peWrNhdvEngdyeJJj7icLf7YlIzdlqNok" + + "1dDPkV9v4b/+rJ9JvFepcWOuJ9LKmZF89EqnqPQzeHYgmPLr0T6EueEgGBzgj/YbP83tDe5vCRrst48WNBh/M/JwzcIY1PhfoBVUPLuha4eyPNnDBT3x3dPx" + + "u7PPNR39rdaiuuZj4VF+6z15V9K2ww4eYc2pMkEZxWVb2t+CvFebwFw4Fxeq1Gp9iDSP6zAEEVONQRbBOCQPfPKLecDT9Y8jDDH+2LCUc/dFA4yV+tRL4zv8" + + "xo0T0Bc9ZQ9c5zz+vuG2e5VPklMeBVwSHd1jNg/6nWbaNQ5Ld+f878PWk9IUCOOeVZIOh5B7b7nO86/WnzR3HEjMKPHYt/Z2Ipnid3bspG3NFhY24Dj6w73+" + + "pUi/YNYw/7DOKs+tMt9xzzg8h+PVN+eFE2yFdTWPc7HAlb0dc+QiBySIp1h9n4jR8kJbBLrRW+G9iEPaLta5UNiKFbc1u4uhWseDTvBItCHBnd1UiafPrP3j" + + "z+u52r5u+xlyUEeUYUV8ShM3Q174O2boJ7bwUZvjl80kljG+c6HVP6uM7DvygbNB8AoKFo/F+fc1ECHuauB5NXkgiMvOZQEP9zgFwstu/szGnMxyHLAGfnkH" + + "+qu0zaHx/3mdEvRyGfYMTFju9PBBrfia3DYTyMvpxuKcZvjv2CaM+L/XMt2NVv2yCUx3pO9GaykLnEcvC5ht/is9AFJm8W6WwIi4OH7Knjw3p5VwNd5dsI+v" + + "xVrJu7EO2o/nfd/+vf53f0LDf7BD/ZafIzs8TaJ34H2oXk5OjeR7DPRGRr2fxoSj0u10HbeyMYDDJhMruP3jOxca4XC4K14BYrA7sQiAcbu9W7GYHns+6VQz" + + "3Bvcry/5NTj/g73CCa5ZYzs8L/FKv4TUfS+TSO+57Gyk1t3CAu+gai5vJGM3n6CuAtsZHl73EAGGm41dwax6btSUthEFLZUpS/9XWGheIQ29fQjWpJrIozUH" + + "Q3b8PNAtl0BG97y+vr3gUpZcxcGwvVHQGLQbplsfAnRVbebOErw29l5Ym/shlrVSzb6n+sYTpxysjB0Y9kUbAt6AdRyRt6W8lGwK5dE+vH1d+Umu816XdECF" + + "twsPIw/gQx6cWc+Y4jNWS3U8MwiiPi8N1aPcH1zbEDQ7HFSHb7D482WeAKB2SZeUKymr6ciYk4G5o9xq7aTqckPKccByFP4umP0tuqlvntWHEuFUsvVTqn3S" + + "tNr2tXanKImtgXEd70kPsffnBc/Pi3yZ/wpovxgwFFQ0IpgPkUPMlEmNqUHTeBbdKqZGMR+PYbxniXnGs9G4sZ8v/qub11AxjPtJmiCedU4RWhGT3C+ZU4o7" + + "dsTB0X5KMmCvO2o79HoJO25OGk71wXzeAr/OXS9pWj0PO7G5OZUrr4w/hHxuDzbvSHtXjIHfp8yjv46zXRWn8wEGP/Zel8PQDwzqfrat+CzdrqdYuV4cUtaE" + + "uwv3ravOz4t5pU3rMxkg/8vvDid4kaSk8HerOumKAdOpjDm0GHt3xJqW9b47XOcXZQ0mBqAmZ6neqaw/2x8MgZAM0kF/z9LdXscCdO0U5O4ZGI8H0lfA+B83" + + "VrH8k8kfLFhx3X2GuETKyBfflSB4XCty/diLFlywJrw7mVAhLKjNIdGvw3a50+sjYTmpgRiYf1VWHtySZp01QQfNlhgKmaSWYOUdu8jvsbjD42U0i15rfmcF" + + "VkdZNbnFFavmHq9usmrFiMLYGavyvAp2Gj3aT4huvOO1rGbd04z5lRcCnnjddSaS33ErKIlXO1+6JG7YOWefVUN+vSboK2kLuKO7sU45PO5gaopRJU4dJHW8" + + "kTk5NypuRhX2xX2DOBXpl1WF34gaf5IKaT3h10WO+ECibYieW0I99j+5287HD2b7Mniu8vI1W6sbsEqRXCNhVhLy7s5vPQiFzlcxvXooL6f0SjYfgUKEy5AS" + + "1oaSxXeOmioppGZvG8T//I29k3SPAWAVsMWrbo3/L6GnYLlF544BOyA5+uZHsGC57+RBd3hBxK84Zv26B9g57OSmn9Gn9TW3K9Ca4iHyPtrKa4EyAxdza98N" + + "mn7VLxiOABqw9mcn+RMvqf6G8noW9X5rP+8+r5f3Bngln6BUQMBg2faO8KwHwBr2+XK0j5JZ3zh40tuu/+cYagsquf7eO2T33BAVb3vpFx5CfHtNMS7nPS9Z" + + "0r0mYujRXD8mWHVIdC0l1YiDQVZ0xQpds7IrG12Y2Q==" + ), + }, + { + "name": "moving", "size": 27413, + "sha256": "a577b190cb3b18cfc5cca1ef15d26521ea950bf5f3d3da68d19b1c8f43672158", + "manifest": "{\n\t\"absolute_minute\": 631,\n\t\"checksum_world\": \"e87231823be24c9e953bd7e15758f25d2a8f269a9f76b9e8fc2231eb1debcc48\",\n\t\"content_pack_ids\": [],\n\t\"created_at_real\": \"2026-10-09T01:35:29\",\n\t\"day\": 1,\n\t\"display_name\": \"cargo\",\n\t\"enabled_filter_profile\": \"default\",\n\t\"format_version\": 1,\n\t\"game_version\": \"0.1.0\",\n\t\"save_id\": \"cargo\",\n\t\"seed\": 424242,\n\t\"uncompressed_size\": 390624,\n\t\"updated_at_real\": \"2026-10-09T01:35:29\"\n}", + "world": ( + "VFRXQgEAAADg9QUAAAAAACi1L/2g4PUFACTyAKrVxClTwFKNMwZDz8NwiE7KR1HIosIQZHe5LtnM6swOc/FQMT7sRJ5CTSq0ifSope1ldzJdMKUwkItIwqpG" + + "zq5VWlraRIxUffSo0hejVbqw+I/Gd/FxkxRWAnAChgIYqJi0MFExWjFLSCqjFiSU/wKE5ooVI5WU+eLk/6buD2y1bWg/EKCd9bt062v/h3iE5BBFTggdHsgP" + + "VrfhmPjB4jQpPjK4fl1bhgDr4C3t43ohw3AsF8uyLMyjhY6HAdfHJa8wVfPUdtN6EjFdu2muKRzAT3dYwYuzbbl1gnV/Fqw5RWP+53yartUaxAbE4mFr/M2Q" + + "brz/c+7F36T3M7WunyfjVEqlN22hH416Vf9BgNWmVN+H/4vkugpx+jZFaYua9WIO/pNMDV4VXpklPLcK/yf5H9KRwwerBx05fHh5eenB4z8JErdOIqz6Yk1r" + + "vq4g/mbGOdf/IQdDq1qZl37/QQ76P2JnnKp57ltR9aNhKopUeeuLv9AK1uB/RoeW7gr+11gnofe1p3mxHakmqnVFYezc1ZTpBi2HgheYCmI0InT9cE79+2Sy" + + "YWlei8lUVVVt8N/z8vLysqLg3NfiFMtXT99chZaCc2sa/hfgCr/VV0s2nLWFioA1XKG3zovt/qoGOKem6dpSie4RAYB2gpeiUPibm0a9/z+Zlfx/ac6tk7jp" + + "WvDW1H+NdarftTrTCl7L8h/zP/OR62nTOuO/RmQCoEBF2X1V+b9Go+rWK/1fY1s2ua5oOGuL3R/932G5NM9a855gmPGM/5+ftqWl/x9XSG2um6J+0UtR/zEe" + + "D/y/wBCb/mN0/bIK65r/g9RNt54VRU3/Odbn/7XxSafo1f9HwKpVNPU/c7DWlL5m1K26FjXrVoVYr9D/n/8sHw6//x/W/+u/2OpcWyZF1dOn/4v8D/3H/B8R" + + "UyWFFIPFf5L4QYB1S/vQKvphrAwDUhyuaApDQxXK6v+gz7bkqueJ1AKGixcqZsnJyIWLFypeU6vNAe38v7H2rZ9HSimllFJKKaWUUkoppZRSSimllFJKKaWU" + + "UkoppZRSSimllFJKKaWUUsYYY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDFGr+M2LcNkFImi13GblmEyijyv" + + "4zYtw2QUdV7HbVqGySjivI7btAyTUbR5HbdpGSajSPM6btMyTEZR5nXcpmWYjCLM67hNyzAZRdLruE3LMBm9jtu0DJOPogUEsEA7wXrSNlxRpf57PNbm1pY6" + + "r6UoDP7v6KraoOapP7u1NeHwPwid676qjZXxprneapqgDYkAIBSCBARi5CPi6YRwQDaazAfG41pVlvnhXGDdqfp9FLP6bt04haogy4e37vzXaBdzidCwXE1g" + + "Df9/qL407/8iJkCMS3MGzQzsWy1Ys4kEVbf9r8m0Cp9qpjP+d8BJo7Padl+q2uC/SInOk6Ys+P/FAUAUQx4ueDuMwDm+Kg04ITqMBHODq8GDfSl46970Pwjn" + + "2mbLAW1aCIgPGloOElhwCGWxpy9kJMs4n0zGTLi57ow5p9eaOBuRa7JaU44sIamMSmDEmConJBcnLExSUkb/QRdrmtFsdqZbe1A4l2qpVK9wgtV06enDYFTy" + + "3yNMoer+HyJBG4IB8Wg2J02/mfofAs7QLtnTNVlNQjGRYJJIKCvAa1lWOEyh6v+Pic7Y2l5sd6p+nRBv6qUsdJZKIXbWTUELdjYdkgUmKipGJyYzNIJUdlgU" + + "Ua3kdZ2odl2HZWCUIq9UM7phpQrSUu2+EldawUSx47yN00Qi0NNALmr1PwS5mq4tTTDjr+ZvfK3JZvw/c0/G5tTGuLSigXOqBaP+b7DWOH//QxhtovtzMqlw" + + "Pu2pdWcVXjw5nI8FQigWoLk0gArn/5+MMThCookairprmELhb4EEOBkr45pVNJeuPeADFaQJXqDAmCSUGCoqYqCopIxQVpyYzP8HcJkstMm2jLsQyDKP/MvL" + + "Cw95e2zJhioRe22p6mq/mtJa0/CbIZeGqRMhbbE50/+hS8PQBrs2vRbMGH9TX/wfgA9eQrLABAVlNF+oxBiB5DEcEUzb0546xPJZ+9mWBlh3SpVzFTFyXbMJ" + + "5xQoxCrXFlyzKrS0BMJYYGnUCdZ7aZiqIXjpCazbatvyP4SJ7rlamRYE6f+Rz6a0Sv8HKWG69lqKqnnW71a7QTpESdtNNQaU6751sjgx4cE6iX1rziqLsuHc" + + "Fqz5E0Hh/1XDkM5IqXAWwUpgH3gwyRLi0sWoCs5NUThMWfA/SErZ0WRkSBJbMKpmFAJkvD86T5u25KprnnTrEaD9rp1gbQmxrvmK2Csgl6JUp/nZXMOaWu2N" + + "Jjy5YAQj5VNCkkDFiIQyVUxkkP53NJkYeqAQSHaZi4VD2a3r/xDb6rC2bNV/zWrbjG1OTbCG5ipTlM0gH0XZvenUrNK2hiH9LFhR/zX1Vmtanf5rUrWGpqs6" + + "gfXDghGpRUbXMIWiNKreV4W/DksJygsVJJR58sIkxUQFqUTERmoRwUjFJEaIzBVZNJl9LitqgEl5lJFKysQAReWE9N9jgSH+D3ICbxU9QWJtXVWm/x5bQmJx" + + "MpJAxSSpjFRSAtXEhTacDE6GiRMyPgPmhGoS4TgZ2bZtDmQdTUbTNAcyTUZzIOuAAtiwzLWlAIVAWoosc2kpNuxzWVoD3eaxrqEg2bbQZtO20ZUZ2bYamqZp" + + "H5wSF4oamnah8HA38W2TXV3RSlGurGSZ5L6KrZS4ThOBXeeBkeNWZK1eSXL0W/lq1EDs8+hHs+2jIlpj6duuBLjP7lxbdLaZEA71ikp7Mv/h2xbS2dLd2a6N" + + "2zQNw64EuizLCpAdTcYjI8E4GFaAJoMVAAqBrkzLRmCYp6jEgHFiMlmcmKSkmLj4L3JhBGQujIDsc1kDdBqO9YPFaTJXZss81rEsu/X0bY2mYRjHxbIsy7Is" + + "y8oy+YHx+PCoJfphGCgLbbKsxKcCUJZxMEyHFBeJFQ6GXSSk7GgykgQUNZl4WaDMJT+h65588V48j/Ud3g4ST0q5w5M7aOB2XFbKHV4MbUBxR9xBw4kdISlQ" + + "jDs8nuZahW1LzRKTK0qlL/4wkiXjGbveSS9F5TA6Gbn4D8Kh62gyOHQex/Nw6DQZD4fuAwLd0N3QfSwLVEJKedHi493QZa4b5OeybOg+l+XZ4LGOg/NwcDii" + + "jhw+WC8vLz3oyOHDf87mPYBIiQPEhTabCY4IoiiKHs4LbTgeDs7DwUIKHJYOpbByPA+Hh+u6Tgauo8l0MnCcCMfJoMlwMmxWJ9TFsGWuLobtEwJxMWxcDFsH" + + "Q7ZxMGydy2adc9k+uq5z6VxKcPnoOheN40Q4F41zKaGES0gKHOfi4bbOtq2gdTSZbQUSTdM0bQVNk9FW0K4PaLuhZa7thtYBBaDd0G5kmwqZpkK22cg81jUb" + + "JFoprP89NltoUwprZ9tMjHRQCuu22cj+g2ihzYhmI9Ns7JENEEuIS1vTujKiaTY8WZZlIWQhYCIwLAQMCwHrgEJZDSyrgX1CIKwGhtXAMhAwDITsA491zAtZ" + + "IG5FTheJ9qgEbd5TzjGGZmZEGiCgAFMZAACDURxHsiAOdHwUgAUgGi5YJCgSHgwKEhAAAAgaBgAqEgAADBoQARAFgUFIcBAYFg+jc4QyHwHZm7Jek5K27ty+" + + "5YR4u7rwk27FM/52KOo2KcsbvX/5/KLhlbYEruuNc6FNooIX2gIv1uSard2R+wJtZuziT/g4BZ/SWEsOFA9iSX3oaP7rjAi9Atm4MaLdagr1Z9ack/tuBTuw" + + "xBMcBZKio+c3WrGRIV2mIE5N+OtLAza4qWatyPHdE09d+kDOCpedWMRoNYy7+QFJ4ChFm6oLPXBDB8EkTcUSLRnZuJvm2luz2NCWfXMxVCcHnZOvyW37/Mah" + + "s0GURHogJ0UcGBV9Z7qn8rdLe5au4p2rE9E62fqbQ9L4Bee+rRj8N75Fs1MoYPyEBG9xaee4I648G++5QVcTzZGBFWMHVW+HYbMBLLg0CYqGW4rTAoNaFaxV" + + "2ufbmWErHXgfPbKfMbvjLsXUbTfXEtFxyEa0v07zU3cpxkwUPOmB7OFhKUHsNk+Eq2wEDXb4zACFGLmtayfPSRCU9E/a6/IiPm8UeyNYnGIvvLesJY6zskUz" + + "4BzVS+83vu7gyMsLaq+qY8gYdwl1eTv2zzmC87+LWDE1cPqAWDfi8PCCtxhdd3aBsY2VvBFxYxERaSg9QibtFYVFnjFXasxf4DwLjZH4cVK0P7644Zi7iHhW" + + "G9DrIV8O/brUcefFuRxRbfWcz/fNJUST2m8g566OgqfGevhaGz4uBJCX4vepzhlq6a41EsGIukKy0aCENWCpfIb3VcUDW603uPMW3dCJ7zklFqo3Kf5+oTcY" + + "g0cEBk1+XIRT3/7dU8gI+luxwKZIqt2EMu9mebcekuo2V57MH6BPw5lLHsNJMyC5dJ+k/KgeqLkJX562Rz6vD0FycNSm55c140+EOezog71dQuFqJi1cnIY7" + + "uig1ZZR8dG/7om8SvSaDFbixo6jD5SrUBoyDIhmp4Wjg8HkWJH5Jpm1O8AGPGtzU8r2mW3oFyRynRSeyinklqGpgNAqdzvscArrBBsfBIXtCiszDiSHs9Pma" + + "lEV9p3W8mg9qAHkDylfelfkECRQDJO/3PBTd10du0XltQ970PqUUE6d+x1Oie0ix40dnJ2PiBybJHhm8D6qn2oNMkg7pxONj4uOxcSjx7a8w4+TVY2Wduy/U" + + "5KEmdpMXQlO795iY6TAwjEIFUtw+G1ymf6SiTfJkSPpIghR3vcp3gSYEivHESvB3YbqiR7lhwJGsP/hdYMkixyWq85dhw3f4C3tRMzem5v69zcIsEB6lHTgH" + + "4Kx7XEFzO5a4+e0f7OYfVdVpD/yM4It3gLnzPtWL2hKx9rZywSc4cE2A7haePU5U6tcEuse8TXQwd11fq+/1bdY4Ehc2qbDtrZrjjKRY2B023kiDdZr1dyNG" + + "ene6nqpzCnKmW7sSxB/0tsMIXMvw3jKEIq83sMiOFr7bOC8GW1Z2UcGg15oDxpuoXuexHjTWTcOPh4U0CjZfRu7JtxsqJi9JYLEQoTm+iHEW03jIltUpF2F9" + + "WeCJ/pp8EdhUSRWzEr68dylJiCVJZ32XKzRDETR7cYG625/YqaKp58AmnS1/2KB++ICRqqOYwPCkS45OW+XRI3059wUjQ0KFAfctz9lrgSalg8a6kNSWnm+D" + + "m29Z2NdTGEeyDRLoCGlOcOTOc683M0LWz2QQ4hvh7F/oSGMcfCIdCvKSNxlffXBJTOLBPO2JVzT9TkcgdTvCHifdCKvyUNpTrHFxh4tsj+E0zNln/4UDbOiz" + + "k/1vDQ/G36N6uSrlomZdL1zuSDyYQ3vinahfx7c69StUdrzrCNc3NR/A1Hvf1ZGG5QAPTINXepyUdDvPjBdFBWewkGGeJ581cBLG4czjgHVT8jr4jArR65pv" + + "timPuPzzTELJipuh13ZYrBLf4xxUzLHuMJILNeHPSwloLxQ86FLRvkQVBgKyumjE94US7asb1fFTt0n33LyKMT2viwwDE+xGFWeNWc7NJ6V99Gs6QNiJe6eE" + + "CV/D2jCakosv2hQ1sXPTCZtePUzuPNb25GvN5a5pkKCPGzL7PGmQB2ilTw0R/4qt/JdskBO5inCLBZp7mzxIqnw5fdyN4D4CTQkQEmUiGJP2gg0PRqqJcU86" + + "ajgW3SA0VvZUlvJrxcv/fGgNGDkRkG5cJWB99kSzqqzkdRIY7j2S8/7mShdeBgj6I0xlcpNQc0hXpvU+HTaf7gwdRfoVMO7Bx4TtQgEl7gV4DwJYV/crMPkF" + + "YuG1l/iQbztN/FRsGlnHq00l++8O73W/Q7E6Lgn+EYDuCkzyyzVPcn2fLYWWMLyyJxtWp8FjKn04xWHf/tFWMob12rK/0G7fF/i57t1bxkOH0ZYfUXlCpcsG" + + "yQfftEG8hC84+1SBLXmTnvZhUQyccqCNqimGnukYtOVGGH4ngKoeOWt/oo9RxV2lUGwVpf6fdtA7NWt0fkzfYbvAFD+8sgI0C72apQNWUrho+pUPx080bPEz" + + "zQRBmEXlrg47ziVehbNK85AqFY9cvN0biPFbKvjEgJS5WtQ/79xB035qVp9z1DQV5fhyLAzVj97tsIkri+Sz+N/YrOJ4Yy11zn78HXyoCNxIRKqFpL/WdjlI" + + "CmAaYTyYR1XgqqoQ/lgoH2BvjGV2E1vs+KBQovPgifoXQpICXmgLvIzrVOCaWsnAQpyyAVSuq1k1ER4Jg6Xmq2rdmUEIyMqaihfopTHZ2QL9gJI6Dj1QHwcl" + + "A4WpYZPRc26pBVIx+dUIqUafmZ18NFbJ5LOW3se4fJf2HGwpNqLiRi1V40t8EP51UjnRogQ5xnZvLcZvQYEgCaF8VEkvW3TsoMNcGe5zTpqi+hSVf3tu7mrI" + + "cvZrbYrKQ1za+8pnVJVGOyCzAhxwmPAdaefl2yjpVG51nEgrV0mA30eHXf3KGhgwgO7lf8hSdI6txSgF5s6DXHc4C8/aqbE0/JkucQRVPfP2xGp5+L9lxYZv" + + "IPiWc/48PRiJg+lLKJL/5dmibTLl86h8odJlg+SDL20QL8Hg7L+ki7K8auwLQvW62kuTCT2TYeAsNZ/+rw9ewafEUebBLGD2Bsrm/p8N2bjUoVFOUA/lLZrA" + + "jdreIFNCQFJXifiOSoxeW53tY4zhO4OLakwZFLwwmDsiuquzyD3LDQxN7wcTKEQrylJBa4z1paJFZSWvl8A0JxWNMxZE3awKW5yMh2lzUVl56g5ccr7lVXpM" + + "LN7CWubcJy79HHd2Ryc7ogTmut3dJTJcvwpdQUa9BvyGKp4bCoKY8hX1rJ5lrqPm5/j29UmjbwkXKh4CeK+sneIPwG25DPajOH73jNIEAuG9vrpV3cKKEnkT" + + "iGLQwY30VMQ+G5apQO74Tr/n+F21PxE7+xANtu3VWgvV/kcW9fkJ0jQFM+rVEV/Doi9A0uzNF1m5/r9IzPe03IuqSaAkMnZ/VYU/H+k3w5LMEf1HPp9Ig59e" + + "GUqhxS9PsXnVkyx+mgq6qsFOqyUbpYIFg4bvf3WocIhCFqoNC5KY7kkDjWzus3hxFdwaPqC2004uGP1MTTgKXkdpQu2OVaweo/7Roh/veHv7NYhTe0OW66HJ" + + "ChKp9WsjoR+iaVsz37++HQTO7cT+4yA/+crVQJNZAvTjmCVYpaXsoDo8Kok4jqt052aOl1Uzo8dT8DlJ5PdhzeTZj8GWqKlh4UsS003yrbO72oV7t2ncX42g" + + "Qedqbtd0lc6+ZRSce52tHH2z9eSzUq9uZQ3GDu51f4cqRXhhzgKrS8/c2rCXgfkKwLsxwN9v9QEsZCx/UU8sY6IXU8WbwmR7xA8RmNUNfMQlNuR7R6kzBgqh" + + "8az6zlNz52G58f11GKSXgbIPIdrRNS2s3MFXmbajYSsTf7ga4v2pW9dj6peyMFxqgoU76d+SFv2Oe1xt6rjqP3WMeUwUus8ZuyGVx5/oxu8bWj8+dkdojAda" + + "YrxY86P0o7VupEh01fOrATgtdNK0cgzndF8xympF9NgyQx/5m1XZ5I8tbe6WbuUCusafI3fzRWDHRgvFQf+dTI7QQwq8txdOaZ8lCFnScDVngPNq0+XOTkxw" + + "Aq/ITHDvIG5Crri0c9ulh6l/DxpuhZanlcmfsLEs3Uvgg6R40YFJsmxGaF5BuvSsJaaDTAw2WXL3Jh6ExUDRykFJM2G11gBBbnAn4kILoYInerdB7T+S1oVo" + + "YPhNQzAS+H9EmoelyERlgTW+N1EpcvcREr736dWTBJ75jzUahRkJCWZrjHVl+N8oV43Es2txfh0dYNfFe0THA0KA46G7uIV0/aygu+QQ+H8aXxrUd+o+ER5S" + + "5oZh6XftMPn3RoOd/csE9nH7frvtVYz9wrLQWWJ8l64KD4HY0n4A24xXdR/WJj6Zz31FUW3Uyfb+eOmTXp6xs3wZd0DHX2AD4LUSVHFksp9ViBQjyVY63izh" + + "KEN4xGuHGeeKNf0Ho33y3Q2C8RHDQTgFDu8xnN+SX7mSwlXGhlaE5Gs4l+tw61ZvOY52ABwFs5sC2s4Hv0SXw+Gk3oCzylhq8GiD/SATMCqZ77x4Dv+YcXo+" + + "kbqM3cnKrAHEbHUFLAvLAwvsvxZhKRcEfrzLY10IwQ4OFXjHLzfNcBxNlSInq+EzBDmBDwK+11e9biy4VABvDJ71GtKPFOVtkH0xVOIoautg+b90MPi0oFk4" + + "h4kbxd68F7BAM0PoHJin5VzQJjUE2bOAsFCo6v0DtAAoF05g/CXGVnmPf7mk56e5Y8MAhQX8AlRlEBbSo6B6gE7h2l529azkSVDGkbXl0OoDyByKzcb56dIy" + + "JeWejYc1M4UYdV7xM5krBjI86L9Yhnd8J3uFE5ftnM/mJ22Q8PJnDUHAui393OpjI3ADxr1o41+llqCtIVueyN0Bw3S5FXiEeSFrHiuEQohxfuVOt7fFMF05" + + "j/NsceXIjxEmK4TpmYlrT4imWcpA0MNZHesyDZqHokx25i4mw7PgkE5lAQRyJEBHcNIY5qbS/7sDUIzCkS86Bw2Lj3yUYfEdnntp75fP3IZHny4KuDYHWCKu" + + "8SgCXGI/TRivMy+GleV+xIJAbrapkrtWwT4q3qLNwu8J0FxGphmExmCt8Tb3LNwHQUAEggCKAAQFSBQBAYCgCAURFEIQFKAgggIAQAEQRFCEACBCUQSEAARE" + + "KAiACEBABEUBECAIikAUgSIEARGIIiAAEBAAUQRFAIAiFAWgAAFQBIIAChAAiVAQABGCoABFISgqaMJAqBoMhZmqdJlWsgpyLFjDkEqle1EARAgyiJEYLioZ" + + "BBani+4DAgBBUSGiQnQoxKoInV64DwGACEQQARTBIhKjysn0ZhwoQlEMmAhECIfIDiq52kPEc+G8CMECBFnHAXD++Xf3f42NMVvtOoSdAPgh0zVzxn3andp/" + + "5B0nMo72qLvyz21XCVO3dpOHX94r9aIFBwVzAKCHHAyQAIAOODhhAhA64IEJMgTgIOXJ0WNiO0PN59/8/wry0KeuuBd2gt2HAVO5G1SXgSTBpo86f1GX3AyB" + + "8dtj3jFhLXA5/LTmfhjydbqaO6iuU1MfuFkGjUI+iCXDoPeTAB6dekCrSfetw88j6If5qVPUdqAxkQF4o+rRGXis/XehWR3Dz9wAh79/fLhLAHw/3BtfOed7" + + "YnYr8Y/Bx+dwZsll6yc0PBzmOo6mZuQ67v/CXsdikHRPhHZHs1XPDuOO/BzBuysFk/VLejJQgeX5ZGPGVwCRL9Q0jiS71Jpg7vOYOiPflfldfkllnffYDSxd" + + "A9Gv0WSNGL/4lKDoM7h7IW++3xK8ylBuUOxcdoQS1FUC9wMdg7cnhPnyBk7fcukXc9bQEyCQwJ+N/QPoLxPngh0LWmfgrU6MQo5VFL9epTbnRYVvrMcPz7L8" + + "+UjW+zckWxeAtVtMOVwsJvm5/nRPVjxdUrrsx8vPPTrzHY9NxgBStQCvNodIDmgVRcFhB7q1cVEarEhx7i2KS7B93/6/W0OsvGPXi7WV4Xkc2/ETvmwhVw+E" + + "B0fv1spnxnO+m/Kc0YanuMicYVy7fSYK1LoHDsXy4rqe1dB32CS82FEkbls3/3DGGCUXQXcTT5LGxoN6TjkI9L0n2YRMnAVpDpM8xWdt/2vDaRjWkJlTI5co" + + "jOiqHkz2CZ0LJOxrTuuQg5MjF7mde7usTVwRCkM6549HaGXs1zKfdDsfEAGwTMaXi+Q+eNDM2SN0Y+yzrr43m2B0ZKUYzIOngOUzaPlWi9oHAoGcESmXmIjd" + + "MttIc5p1kDetNINP50yZ4p2DA/Z1ICDCOf3+UpyP7/ZUNM9w+J/U8iz/jEeXQdI4PZ/HgVb3q/VOFdsn+E4uM0zktMGd+NFt0da/qrpop/5Kj9ovcdFw6LJS" + + "0VEibrncujsmHAgtEGA8wBDvl4LT96fWsG7tBzgxxhQzalbm4KPKLuQf+V3Zfq1aFHnB/9g6nlkqDOQ1r8788DtjPtnpV2kFIe4L8lYICVdWgDHWnDqod45r" + + "bC14g5vJ3xy4fTjfzINjduDhs4gd8Wzw0bbTZbH834YzN4qo4bubv+67YPOXT+9tgB9Tvf8X25rV2Y7SIAxtYROBPvLiDNR10rzTfv+2PNMVLPVfb90NFtpB" + + "Mo/0WkNVx/xsab5zx7H6f7sHA9pHCWidwyNdiV2RnunF1MUP8/b2+6R29X5J4BeN3OJeicv+bmc+y9mRzVzcd+CfsU7Wrb+HZsq+8f1neI4tafJfPjRjMv/O" + + "7bmz2Kt+d/MYUGwUl2kMZI0vtTMOflPEYYVb+N/Io+94uLY/LAkBapmkH1LgjohzmAbuLAxlDAezzG05otMMShhG754jelCRDpQTuhY2EQo3yUAg7Mvu8vJY" + + "nWjCy5X458rGs8JaZHf3ypsXH7HQbS2N1AdeC9W20uq3P0kp2gHwAdIBGFDUe+uU3h2YxgU6iUKQQpREJCHNd/gcc/ePTuEQS90hajKnHq5JUodlZ4OSuWKp" + + "3d0jZYIfHh4XeRJBInESMuKx4QH1ygTPUVWOe0QxccwsD+kh0wIU9R5TFhtYY8pCuztHaY7nCZJZpUWNouNq6xOFrWwTLXWrHEFRj3tnFJTM2pJ5RUOTeZur" + + "U280VY2oxtaiu18LdFArMxxTUs6Mdqg4nQgBihBhcneQAT6VyuiGyeh0QhoxMgHd/YNtYDCSY2HZtpu7FM50Snv6htzdcupmXIbtZkPN4kwTddZuhlGoVArF" + + "XW+7XJbSRJTX2Zx1KczCosk0Erd8CwfG5Kdt+OYNtaVQOns2C7WLUV2Hs5zDu3l2y9zNKG7LspYKN81yHYrrMs68VMiFX846EnM07lgc9zZDDpzBGJOVpXZA" + + "WnAHhbrXdS/K67acaevZLruhJoadh/LEEHcbxtpiURRF7IkZt31WzDaN0vCHuawtzqlOdzaVUde97r2Yey/Ku6B7O4/G5vu+Cjwam6uC7/CAuSvuigsU0nzc" + + "phmVQCAiQSIamZROuDuG+VZ8K66KTwXnupwUN8XGewrvulamuUFxZ7HM6PdZEOeGOKB7P0wGnBHKjBJu0NWutlEGjpomiZommcAKzqIEf6xUyazTJwDBAAru" + + "oRY1agg5AfPX+AqWDf76LHVKi1tnSilgYAJqmltrNeB1NqOcDdhtmy1WKOi4TRWZPaCgac56oyeoKvfLDBWu43qVjutV7G++7uLwZjJCYTJxWZUO7Ph8rfeW" + + "xa2v1Wp1fCtbt0ZSi1+rBWIzIU7LtkS0MhdoVa6ZzSwOcUC4hVsiWtgLGLc2MBsuTT/A0hRAtXXnTM2tVWX+dDorG8VKIxMm3dIk2OExcvi4AkFvgLtnPiBd" + + "jqSYsVRvcEODg4gIK00JR5ZI92mJE9EpxHEoV1GXGSfG7hkvdWO7L6b7NhkW1WUGC4zFs/5ZM1j+GhkM5j9mCH4xsdvhVrODZ5apBZ3/Oe6R++RyVNUNG51O" + + "aLhUktThytyaC01XKzO8SgpMEmAbrg0hNSRUQ1utW60hD4Jh4ABEcwwDB7WG/ERiBKnk7hqMzTK1gIOQUgOej/pxt1rxVm+9FYTVCrKfCi5qrfX76jnu8eNi" + + "ZZooaEa5ewbDieCAWqsH5uF1GNZhHoY97INh2Kdj6aDrPDpQlWOKaV4ZECUcDOuoHRxXK1e5ylXMgdXKsb0oa61122ouR9WnXCFZrFSn4YmpICI+hFIpzmeA" + + "+uE2Ohs10/kNsISJCUUA1r71YBwPDikLfXb4lZVZmmFIt32wGZUooikLTU0POVOUyAemu+zmYUTLFBRJE8XdK5pDkyRFscyrTUeTkrmlQzq5zKvPpSKy0gzm" + + "E0LHE8TWKWRWCRnLNLRNNLc0qcFSxSxT3B0Adw/5y+ddUsK0tfWJMjsav1xk0N7z2NfvPOc13jfvmvfMO+bdr//L/91r+PeXv97lveWd5V3Ge4x3Gt5neIfh" + + "jwJXdt4ma6Wvs9Timd1z9w8gSerwhcjWoOuv+y+868PWLJADmRqVhCBh72A5onJYIiqZSCeRyciEyd0x1CMcV7lcEU1MJ5JRqWQi2eiQeY/iiHL3DfQ0Myaa" + + "uXwkHFOpvFEQhZW3xoOC5hq66LjQuLSwaDSZDAZzuUtLCwuLDBkf4zX+GX+MXxcC7l5X0D2K73ns63ee8xq/ec1nHvPX/7/X8P7yPuPd5b3lneVdxnuMdxre" + + "Z3iHIcM2UcIyr6BjmFlZBntqcdylOXoe+/qd57zGb17zmcf89f9fw7/8jHd5b3lneZfxMZ6Gn+FhwLDvHzSJyilkVmFpwS5/r++97v///5/bONY7tczYpkX2" + + "FbAcW+RVC7DUuPsmtC0IAQQNhxAS8MBd8/mgFAJrRDk3sOBCigfuruHuGV1iEypH9ORQwqRFMyTT0xsZR7oRTztHMjuS2XOEsyNaHsk2d38ATVnlCG6d8jwZ" + + "DEqmp94fpbVXi8zluNo6xEiCEyclE8lKnyZrp54MR8MyBWicSAGXVgHREeN4Tr1HFilqjqiRsRyczsZU7bx1qWK6O+i6LIjtSAkzen5crFGHmkRRfYKgqE+T" + + "DDEMh6478PkEXufBbTFoHja2OW7NUVlap7BSKyIC4jaNgwU7aJmHb8Pe7T7O27rMcni79tO8DnN3+6yndZnG4W2zIiIg3B1zebDfpmGat50ZJdwpC+xo0cHA" + + "VRU2jMXWF9omAjqdmEjAESVSaQTpBEQCmW0oDIK6Kb57U3jfl6LzNt4IZ7tuZLPWalbTNE170TTt5WvBw7iF7mruCdr3naB5Hww8EbSuE0HjDOA04Ng0wPfz" + + "uo5nw3UUsNsFoumwzGRGgWQW2aBTQHMl6pAVpBIR6UQqkVa2qdLoxwarDUrLMh0DNjpChMLdPf8kJidMG1+iRDoBJRidTlSckDgRkYAmIxWiEhPujo0oebwK" + + "kQmSkqg0OpVIH5nF9/M6brNapuH7eR232dOopESEAsTXcZsdnSiNKBiZEFAykUogdaNbI5pVugRVTJLMo5PSyESKETgqkUSAKk4kExOJ0wmRu4dUAvwAHYu2" + + "qFQxWhlkamYAAFDQAAMYAAAQFAwHkixIgjSL/BQAChkgTow4MBY0CAoWHAaCQgMAOBgAgoThQSgYAIOCwDBAFCiOCZpwD594O53r7qhEYKffdVTof3Zckdrd" + + "GzGwwNq5/iV3kxR9B84WbLcJutmw2SX5sUuzdvksZ5vGlwM9xjnk26AnJC0aOMd0zcTXjrxnwPLe6/Pr58nRV30PbCetX/u/6s17UUF4l8TcpTsimJUMqvnb" + + "QOdj+oRocAckG0nctjNZQO3ena6ZRJSR6yl9LBEPdgO8B2WusL3Bv3P4ty3fpSaSu8ZhZW7v1X5ZYBr8CNMF0mnEoyB6ngRdnI984ATKHJuoH/4SibIPEyg+" + + "zR12c5sgsDwUvKkd8glnvnMoXwRh1WIL6uxzI7rch3WjM9cNVbf+FH956PyAEm28s/Xt5Stpy3BL/NrS5yTlYeQrDzSBjMixC5e7yPCbPWUzoNXsNVlyyM7j" + + "mbc0iV/ZyVtu41oE/32ilhLKTAD9WeZfWH7r+HfSrNFkt/tqcFocd7nWNdmIRyeWonWOd2Pv9INDnDT+ng55dbSgmwS8X9Cfnz6NrT/s1PgCkDtb+jZ3f6Zs" + + "B1uI6V/fPfqJwvc7A8JYMnKa3d17UrsTGoBAfz3s5v91Yu72GzfADCGbIj8/haWcZZ19Za0S9eJlmPWi9e3oA80wtDW2F/nwn1Hwc9ZAWuaV/fPq2ztw75yY" + + "nwb+pzx1vXNMLwv2zgMXvM9XwT6EuHFzuMV4lDgbFM7Z48sLMGkG1/n6OAYebqm8YonXU/hscTCbON40FGYMrMJvi/YDNlz3beW+aXVg9uHwOznm1lOw7L4f" + + "nlyO5jJz428Ytd0aTbBSiTzWRPwsGOhWHdKDYlweNVO+XlRyvSaTfT888tit/YlJQDbm3jPotwCQuASAkLgnDajJ+0XlRGPSFX+31Vq9rKEzb3sC/sx+V+bz" + + "3pwhYPYvRY2vv6deSzFz9OXP2uC1LPL7x29tCV5lIr9f/NYO3uWRZ1idFWLM/8//NcFjeeTti//aGjyVRW6f+G828sqyq42i0zd2z4WjQU8PLV5Qefd5VvHd" + + "SdJuP1OMarthN6D6Kb9Fbe55s6nwUTmjF2x5TXMDmk9vL+V6dhp/aEH7tmtuezjhqjP1siH1c3zvYZT8weqLBQnJEmrAujFCpcFOsgYB/3jASDhK+iDibRXZ" + + "BcOuf7zvOk/QNbmqcRwZ6wQKF1yNAafZHX2+Qk01oadH82h1j8mamKOscyjNRMWf64NBTWWTyLYYAs0LZmlsinGwvMAWOYA5n14P40HvxeIsY/0VvhUv8PDt" + + "Lx8s2OxZrvBx/HNAkXUtiRAjajnY1WskRWI0hX8h/tnDj5BEDEankhaKjzxeJgv59vMQ9GwI3mL84I9nQgS+JsdxAciLxS+G3ghClq5s5/pwNjPoHxeVkKnW" + + "9g8bfC8WADnmxBJMvzSL4AmKjmecrJY8ijFAXhDDBfnPloplNMm4eYFdOUmxAMDBda3AbtqJbuBfMTqiMTlb4Edv6vD1OdOVwaqzeA2XItXe9ULpcfQTgM14" + + "A+3HiQs9SNSxuAzCleyj71WET5JHtksSxKy1JaJCR3zdLZcLzkgSbqSO7y6PaU6q3P4x+hcjGwxc2Zs06Jfcig9dFxtD0BrNYTTLOOP/+VIe3V0xYcKy95ft" + + "Lf93GutiPC3t3NiuuYtP0VUjQbzyZsCD/D/MmP65Df5LwbUCyeDy5Urno3JUJEYzMBPLMfkJT9AGXZL659eVDsHtM+J5YsiCczy2pwdOk4HD+spvvVDV+dup" + + "BOA4N5l6+Er0dg7BFZVg8Ii0lGkNrUk/xRbVIa9k2fkFiE4hA27in5oOkQg0vH9d33EDxW0aXnQV6WFbmmUK8utnadVpdsGgaNyfLkZdivuGJ7geJ3GK+3AM" + + "j+BbwJm74AccxGP4jrPwgo8TP0vVHxOw10PeM+vN+fkIv3OLCYNd3zwogsjyjmt8xZKamZb6+fD0LM377NqbsaF7bP7t/IOzG8KSY3B/v6ebJwq28OyKOJqH" + + "a1Ff/WcMgoPmtObu/FdDf9TanHI9FhifcpWWtzch/Hq2de6VHsfG1tTj9DsyAvmAg6+Rvvqrfth42b3F5Wp+j/fX73qouPadYjmW1ODJmv17/Zzku7mOByOt" + + "tWqd9xG1GTdR3V2pSXMzczZ/+hCV+gk16Ao1eKcBu38hdsk2968x7P/GdGMEvucxTz5ycNq/nN0b+5D5EIHw9Jp5xcEZhhhoNOr9Jinmn9P9nEviF2qv0rgY" + + "FK2Si59uTn7QJllTXOoyfWmlLtR1RRdnrPshXcRJThrhCT7upJqHGXQJc0jC5Il3m8wnCb8EEnPFxMHKefg6UGnP2AB01whZihb+0Vx99MMwpcvcwKQV69w5" + + "xrdz4nw9el3+9IhjW4FpB57ejixs/oxcBz9vRvOsXt+c0DDDedmbVNPhM5IXirwI8oTUphvJnU90Da5/rjj6Z+Sv7YZEf6NAjOYo6+eo+d0p4B7CB0+0XXRc" + + "g37CWXLc2jI5UQD5XwLOzTymNz+Pv0TyN0Q7x20P63ez3+yXYV6RJWzN3Pw3FF/6m+4Sv/aUP1Bjjm/icJ7CgC8023/NxuYFwesV8gbZh2gI0/3C6Wkh/yni" + + "d0+V8Hsja36loIXmilrkYfkx+FB7rGnBALcElDdOWTOeIlNhRb6arm265jDKwuLGTZsObPWn31ioH2yd/jLIelBfx1DfZXvYWE/PlbJi+oh/ODs/mX9WUoAM" + + "3uMoVobbRYrL0FmDQmUU2aWwDEhNKRIHSykCDoZSTI5WU2wOx1FwmUqfgAhkYR8aDgVlAJaeNQJtc4RGBrEi4Ugyiq+A/ZN8GFTZd0CHVukaQsn3zDiOkT1q" + + "UAy6laHpgvE4NUmBOSZBATlmQ5FwdItCcbSaYnF4PrEQKaMTs2ib/8j8sE5t4awzyvO+7c+OVk12HEUjs4dNeux74wmhx7tBsY1zLLLBbk5xiUHeVcCek13d" + + "svB3Xov1c0PNe+gEMICJAboJKD1hBBeAOX1nwf74IaGRhhUa+DguVs445q6APVZzdbqwfO8oyO1rV1t6nUPBxnDBZVtc1rMelkHXlZPJJybD5tTvAXBR2dnu" + + "grhs8Azb6n3lK5XsjEK5JAeV3hrKv11W4PaCf+x3MmbGxV8bRlPV3O2Nz+y1PhvQPfmL31qHHD+1kKUB3qLoZzvGD6xRG/CCn02ZnJ/fe13639J9rY/RW/vX" + + "XVsK9m4bwndaUJ7Q5HZdPGVmI2EpE/mjusHdGn7T/XrMo5JdI2TMy+RzINcBiz6Jj6uTZuMCm82mTZBmuCHwtHnTgg8vznxjY3Fr5Z7oTZz3Pd82fR/Y+16J" + + "oDIQzAziFuatV7KJoTIkLtoPLNIUNJT7I3lfz6sgMMv7F+LXN0V4m9wnL1dLnAwcie621mg2ihIgqW3aC4Uthnp0tcDFIKNdjA1VzbGsaDYaFUJS25QHCi2C" + + "dehugcdGRrsYC1UN5vaOKJDfMQbxIZagcuEaLH8YgHgQS1C/cBWWPwZDNIxlqC64gtUPgyAKYVwlVX2Dlb7h0z8cdEddbPbrlG4TAqz66mre/NdhxFj+FUaf" + + "N5f2vtPe6keBv4f6twqjt8wQI39PyL+59ITuyXze0BKBIygxkiUGGg9HCTTY4ZyGASY8vtESoFtQYJKFFLuGtLg7VOULUTTyt0Qc6b+T/L+J33kGZadLAE5K" + + "2tm7CxlXUI+resBpVV3Lea93aKE8HhTouyPc5ZWmSK8zQO5IGGImPrTLgxFJtUzF6gbwqsks7EwhJEGM5QoA5KE7LGwbTwmk+XFL4svFYkwOEiHGaeM1Je3+" + + "xC4z9y09RXA8pN3cji3F6KUHIkP9fuXcpXa/oBbYUXCbROfweikkxr2mSRnSnsXwKXQ8A/zc6IwU/cck87R8x8bSgSrn6N4OVzTAXVXtR3VG9igAeGb2RujV" + + "p0FrcJCTfTu2bRBTlmefk/CuSnz9Eng9YgZmv9i0GGbrHS57TWAaoHnZWc2Bj9I8/aSuz9TGHrge3Xr8hTc4Ei63AX2Rfw8EX+V+/Tfr0MLqEJb1TKhNkAZf" + + "mh+7c9ZzdhXyf16e3539ftv9aUAn5I2nc+sz12l1DA2DIOmtp548mbV5c2nwSuw7CiqygrPIt6PyWKbm0LoqB/fs87GaeV7WGJErj6m63kbtv+kiTtOsiJOO" + + "j5mqz7BVrMzMu3c1Xj+MM2TPl7z0dCTrwNIAY/cfZ+95C4Ju4wm68mlRYzJZBmFzpJHz9oCSwNUwYO3sYTFUTMJBZufeUzVz/kxHFpgQeFsTahpvaCjxVxNj" + + "ptfj39cF6pkQO99ZFAbCw6n6hDaZD12YXfwlJTZRTLsWYn4Pp9+yJ2IfZKWHrKTVYhCSztWfkK8qVH8U78dYcfb7FoTQJjJYJBy+9t8C1pxDo6rt4y9XvDXT" + + "gYECa5X+FSbxmWsFXpFpoor0CQ03wAyLiP+MGSJ0RqYbNG408DfBHNDnBBVUCmFdE4UX1ZXIOWlto4ZdJE2nM8z+X44hLtL7yYH43ePKYSpDsxW93bQPxz57" + + "7Ot7NyCNmWLrdpmxDIC4+71yO7TicQOjUdXjrLZHdF/N7BELzAoY7OoOCGQwzK4t2OiTeRaxM7x+VDOXuSozplp753BGK4l1yRU+Burctwa+HKh2MDs+av6J" + + "nr7yslweh0flFhRIPriurccba6Axx5i2sMAn0BUr/NZABeVNBn/wysVY2Nl7qTz6LD7IUIxXMkTFv2HFRA/xAkx9rfof9W2HUy3cL5FFA9Xh/oMrGr2hKcj5" + + "xCDdkAW8kRMS37Es9Rab4dncdAjJwAiGPSqeDGtfLsy/gaNimIczsqY49fcohm2ufX1sRWzdJBe+gueUnTcFA7yy26QsyyJa3flALjuc6HfwzIqzyp2jhXFW" + + "g9Mjpb5HtUvuf0DfrbRp8ft2O9YsZDv+A+kPu7obbNOJPPZuF8lwzdTLPbSnRTPvzfMw7zktoXcPu9qwZMbF5ezsZ47RKKtsZE+7aFxWv26owFEsz3rZIBMW" + + "O6huV+ErWxaTWcb5uXq0Y/NYLKjsJxeWMHVIvJh94eI4ac0LWbhF445Z+TiOuTwDrF/yd4JOLQyBuM4MbrqJUZlAaPTym+IC+siXfC5CnysUfKsjC+2rEWHo" + + "gD2n73MMQ7ILj/aauGipufbfmUb6pDHhhmPnceiwQz3aoEajBjDZgZ22gt9vMh9kTWciinWvUV5HYs7Anobs8DW0SE0e65f/gzCDdXDOnTpOxS92ZKDXrTA+" + + "28lAe7LKeAP7a3Z1YE7bHHle8+MiMGKwQWo5sBtqKag2Mi8SCyQaxHz1Jl4yVmPfoxin3TS7tuC+U+BTDsuLE3k0noy1uL9IfwDM272yDstAboGKbldmpBH8" + + "ZoTZ3u7Cg38nhvorjPO3uGz0gi8Mroelh6O4CMpV2R8Dcu26yWY6nbh9pjz8f4sg8jYcobyrp0TuY9F8yZWW4o+KVdDNEr0T5BLlnq8LabprsZ1wtNx2nW0p" + + "i0lH95QwjXrP9Y53nmd9pNZfDbwwYOJyn4OXTPMPr3g4HZR9BhwO9ZsGicXOTG+Q8juacv5k+r0vsj/UoLkgGTTPBU8X+7Y1d+TYeeDAb/kYEcUwigiclZGX" + + "GVZxZ6kVIVJ+zBsRgBzmBWH2sVl7BAZ/lOpLM0DuC7SzOwHT3/CnMgFdQqtNcKAWFMtkjjZh56JO4HoGh2UAuJTrI1eWCulYFtGR/mcz2Q+kvzVly1Cl9QFi" + + "PNOb4NxMMlSMddHN5nGcrPl4qB1eWZjWCaqc5wSN8zhxxpSp9XrvNKq9wmXfTq0vl9EiQ9z1dJjw/jker6nW/nsAoOvmryA3vnbcN3isiaHYY2LO+uVV+ATe" + + "BjtYVAdtZW3YbNGsfnwoRxe90rSQ9B3MM0G/ltEStKKDCdtHTfL0PDTgjbE6VzHif9W7R1320u5ZffrdReaHb9cP52lhqGuBi9mn4kJQHljEdlbv1P5V9J1a" + + "x5lvbbPwEu2nwbEkUwqLgJaCc6G/APR1pmeKAAp06d26TBh5+a0+7BT956M8pp2HwTtQGl9ZaB8Jdvm7Y/bt82alW2anDmDZL0MaWAfNlRfzgDYYrzh8bSuF" + + "kA8ooaY74n8V30p47yLxWjwUG3bUPa5820vrGL06N4hQx24DQopG94ejFdrnISVvqw3ekKnZLMU3Tf7WLksar0PMSYD//Z8l5GdCMG1AfUqYpkLYbJwLP2ho" + + "fuKHMGAyrRtPCZIT1zqzlyLhxbroNgI0jSRTm8bWzUo65fsBvAlV9VeN2yGDLDRnZsjO6Asz8j1jt5LD57l0e2UhUiXo8r8VGw8dNyPMaTt1gMt2Ga6n6s8z" + + "/pR5eaYcMHMtaBhfg+UoRV0hxaOMZQTnoYztYRBo5ouj3uqNQ2fc8ftOpOHnL1iHaNGJkRhig9lDCt1dhTyXKlxzFkzfqr+Fzf9jMBwKzP/qG/SHMLXmAP1G" + + "s/tA9hjtN5cTHl9YsGzWOyXxiJSgrMSuQvvHPZ1+FeCIgMf4v10m8ahOa/0tymOmevvEZ8+AW0+YquDkHIzprrrEykJxTCCi2Yy/5LxpQivSd+4Hiu1yZK+I" + + "+0PDNjPkGV2g5MiiEX6N0BqEe5NxtDHwf4pvWC4oMI03JK5zrQmWoXOZDz0zh6PDJBbRRqfux6AMGg4pdLYVEmsAsZ3FlRazf7u9CMUFGSAK7v9yjEjLFRk2" + + "YID+40dzFGUAIbkJf0ij3qQMb0751pdhCeAT45qVl27xXHOpetNJ47uk2JzPoJ8BEhQ4fr+u0zuq11r/UcfrfZCrx3Bh00/C9o3yd1Nhhh039B+jxzscL87x" + + "MhlFU+l2j3P+KQRt6CioRQtRIpajmSy7CJjutGScuFHbn18qeLhTljb4HiIKW+joepnDf4577NzH47uSJkb9HFivxl0e+/hu6VtYdnf+J76ZwbXlzb/E87OF" + + "jxaqyk5H7/EV/rXMqW3Yng9YBH8e/3rNY4xoxdq6W1OMm5vVY0kA44se3y8G1JYS2ximPIXid5yPc/se0qkLxW79+RJj+1snMdzXw7KL84LTKuQZ0jqsfC9N" + + "rXyqF7iha7aQpVoUcc6t6ZTO01rlwHhh7TyIQvdvf0V39CgMeyWNQySev2znDDgY67/vyRQOe15mGSvQF+PGhOkdwlGW1c+/SAYKgB/MFpbT8C4KZjMXRQR+" + + "qMcRu2ilsIfihPdX+RP0hP37jcPDrdQ+X8TXrP0jD/FSlhaxzA1ICSe5Bn6n0yj+Xal4nyC3DxzhBwo4AyjEAxRE85JP20jB2QeaNOx15t/E8kKUFxt8jIJx" + + "93rwZ846x5g6vmHHG5ThwI0fd/LyvhdeYZ5zRawbi3YxQQuKumeIeN6Ybvx/i98buVcgm9DIEiiGE4A/8PJko8jh7PPEMs7pPeb/kTDPmy+vmuRE8x+JfoVv" + + "V671SdT4tomArexOa7ikN/4ccKQBjXXOyLFeJDZyIRMVBjhV+wOtRPbDBPffmCBBLaRIwfrEBI8ryTRc4n2k/hNhtiIE6oqqY+H7ir9X+zFMuBrRYBvz7nyq" + + "N2Wv/IC3fTvSWIU2ewvdXjC/aSawgAoyxFOzgXcIKK+lUt1iA+afmckmFrvrZuxvWNEPLXQnzAeGSusPEV3PPDWuuNOv1TEi3E/fJtYUYK9DEbQ/XtkVlTgN" + + "TepH35CAfmqedcA3kyEgQpfMsckQrW+BxmUfSEzd9NMTQmYeyPZvLvdi8QsI9ToiyxI9bHtC+nwPcbXw8D42BWOnu1P5bsTZ1wyCeVe/5cNQhf7TQvxtEjAY" + + "ZPCOaiPI9WFbPQwJehZX7FeMUxcBsjOCsJH8wYhFbi+QvWpbGi9s4IieoUIKImUPmR85gO4EI+7wq52k7ShrQEaCkjkHQUcsDYPLibBlkTpgNNgoErgwAtzz" + + "QQWuQMlJlvP1gcUQ2rvib5Z3eTfGAW1vtL1hHxhMO0zQAC0AoQSXh4cIJdTTPz7w/89fJFtwM1lWTXcT4Y6vS5Y3mOaf0bO6cje5d7+HD1x6R4DYvVo2vRMA" + + "j+SA+HeJhh75no6gqIP6USfCxRs/As8Xivw94ENniB7Bsc3t6Dwt7JOAvxoDN9sASnIaJ4oZNYdvjeQWGiaDCtyIjgzGjHQPInIbAJfF46R9njGsMkC8cBf1" + + "T8kkjxfP7ZeKkDq1PwaOj11CHy6bl8n98ieFLTboehPUHz6wwZkipq0U5YC0ip2vbzzAGTOzgbTVn7GXg4qYfMfjsyGsXPShqOAzNdHLOyCrpB5Ff0hDjJoV" + + "MiS9bDAbxqwds4EojRFk7MIseYDvHBDELxg9zxmHiV8+XzGA3iSOdiczcAle5dW2xoGLCtQgub862E0ltSbMUxG+SValJNgbgXiA6Gyoh3NxomcIftIFiNss" + + "KVI0fAcRxNmJtphTIQFzucLCZOapr4NIrxzaq5UD7i7N+65kXGPJfjLikLjlyvY/uG2Pp+haRRTN3h/wpbts3kRRsMNcM6K7osOf7Vz88Pyl0WqlzfVbiHoy" + + "b3n8tcABsfqDwc6j9b9+ynIFsl7YB0ZfvHPTgqmzKGv8fgGxzbxxZc2dKlIPLbiiptLqMy6ECyWwzLF9ctI5BFVcAYrEGChS0JI4D0sRryRFNIwpKyada3EB" + + "2OmDbDFKqNBZxHAwMU2TYS+k0JYmaM2SlHT6J0YMZvrJju1wLDaOZLJLmBaW2mxFCBf52IfBHq2xvc3KDdkpBX4CgQKFAlqI7DIpAXmAlVCVosbKHQw2qDxY" + + "lmmXSV4hhs6VcTQkEw0SEyxQxhsdMhGFeI5eHxTNibEi6OcYfs81qhIW7r1W5QSKRlMyyZIXie4BJS+tWKbxhExMYGgY/hixSvINOCthQXNpUPKFYnlQTGh4" + + "wYNLWNBglHyh7ID+F8zyhPCl9SXBg33wiGjDdMFgeTAsFFIC6mDo1bmwTwczEXGcYAZ4cAkN1kxwYkR/UBaoE0qhK8xaWmsxfJWYfES4PkCRL53ULEsGK6Rt" + + "gKFzWTJs4A+KBeLwf0qeJsYa1twwkuUGi7TVIUNomWTMyvQEVopbMnhzPdESB137Vz+5svDnOYJcI6SKBRe0koen9USaJMe9Kke1DtELmX4skYkFZApSy5WP" + + "35fkWK7+m/pGRvYz1fg0xS9PNXRJyREYjppUb35UWlolrqKrav4Xz0UcjxTTXsd5f1pPJAz3afpNsjT5L3voYy1MrlqoVujKVpWttP7gkHc969qsYd/de++9" + + "994OVyHaBKSjoWkVx/nvOVrauEaoXsyPOkP0RH+LX4q8JPkL37Bg+MaiKK0TCmWp+VHp2rGKJKqqPET/6VTTlVT/SJbW2o4U96cqAuITpjpZnp9wIyWCyCXv" + + "Z2nABrp6a612MxsjY5GN13EXyCP9pKYAiWWFpILUkiKkAkXKA1k2s/Yh0bKCIkXFCkvKAtZarQO79A/CneyUTxxeh/bpoGfHUuippqQJo0hT6jVQTYSfZYhq" + + "VOg3dZWjUtKHoVTnJQ0UeakjN2EbJi9R4dnhiVxXvKs/UVQIyjnnbfPBNpMT8qTb8gmYnuTtRHPpydZ1J+QJdwJu6QmXPy49GXXWWhACX+UoDpGVyNE8ewZf" + + "wA1ny7Zthc2+k8878U6uZrPYNmPbZmwz7hUDxoAxFm8YW8PQMK71vfi8F94LW3UuOs4F5+Je1InKOcObv2C+N8mNMERJD/9RKN7DFIryLoI2WvoJ8RahqUSa" + + "wvDKUJhwgETLSkuKihRrrUYM/4m0p7XE1U5KI0X5R1EN9JdcAGutCIjyTNEP9KNQHG2RahyTtTaEw5qkanKUczpsOZpk6LGiQp4ODtKU4/C/nCIfSTuJqt/F" + + "5GhlnmQp/hInITkakqh5ot9kre1UnaMri9Bp3fA0/SrHmv8l1VDTJFcWHFU/SlVPTnpucjrKT6WWrrx04awoN52ldSTRvzE5enrO6VEucjw6sOb6JX76XDX9" + + "I2nyU1g6S67eE01xFEd9z3WaJ5I52BW6bIDuRoQHgr18tIhLytULbk5O25rWsPA4n4fVrrulxmH5cpCmDj5aTDrVaWUNFKBtzmrWWg1LC6mEMAFBSKJlRYWJ" + + "rpuhVSwwCUv2eZcjUqH95ixzRi4Qp5v8xfMQFjnNEif3t4G6LWvg9ujOt+F1Hi6jZ1dTMkU/SPOQeDrYRosFVkakLECCWSVIGxygcWk40y4VldsA5mDaB4Sv" + + "CUgmXASsEI5IFDIRAYCtFCUiuAFUJ4miHCH52kwKUbEsTWZlkwr92WWlyNYMFgdrQLLrhGbpuDaZhiSHTPMZA3AxHDqhyUY+V4gKyA8//MADDlEsFGwNKdVa" + + "S6emA7JIGoYCD9Z0MpCGguEMNp1Mw9FoQlgntAqnxxJdmsxEFCopAWVXCdKVWdBV7RX6PZmqK2aJRrKKc2EgPCLyuCAFvNFgeSSkgUa0VDBME5JGcsh6+QFd" + + "HoFZe9tamwCHxHLipNP00OlwOJq22WSZRoNh14WxZVXVvdf+cO2Ma324todrZ66VuVbGtTGu5eHucHW4H8i9Qv89OrDPlZkBq/15XJlFZlUPFwQpTIxIgSCF" + + "CRSg66YlJ1WOSr/pUW6y1maXw+MpwZkZUNx7xacL0F/ncV3mMJ6RkXFjzMjIyGyMTdY8TUbGU4JdDFUz1YwHFLcowYqq2gV8BVwXI2j2Xl2t0FUAGwNWQLko" + + "yCpb2e+62HAIMSPX3ut5Xafde+/lqhCcSIsETujkG9OJ6ZAmkAkMTh9+YLIZGRk3xoyMDLt1YPGsgCOsOhw9QTyuyochZIlCfYhk3FOSqw/Tb5KY948N/EnJ" + + "8OP78/QJlXgZ4khT34UsUav/PvxIXfpZcq6bYuhJvnCTWpKjtfbTQZHSkkLCPD0pI1pII1hYSGGJESQFWFhMoEhpwWdPw9/N01qruXQulmUnVX461XX8foDL" + + "h6ISL0cSJBaVEIKUB1Ap1bqaFj8UIaJEhflqi9N04ZymzkJyAIWJllDTaHF6k2xRrhxFdlJFvXmeOLHCwAMtJlY6IkCkHzWpGi0pUHhiUpAVJ1WIGTEwXri4" + + "ppD1xLekAYBp/GIYQHiaYck/GiIi5flHSVKShEQ1/0sKyS9FskSWn+RssdYSYC3LCkklXGCFhaTCWsvBUfsvf1qWGJWaZIqbsAuHPPmS4v17G2pYFz3VkqPI" + + "bpIoigQE9yHKvflL3kG0sOQm+lWYj2EcHfWftJKbHxWGfoqlK2JeVGvJX6y1mMnzQwrlIPx0WtMwxX03TXLtPzXPjuL9+1UlzRI/har5zRN1OjuIECYkTHUV" + + "taIu5kf4Vf7hT6f5fRgyMtcn+nEct7i9vHHgiI/ALo7GP3qP23/7T+QgOO4P+m/3bRvB/jvou9673+m9baCMDMYYZ5cHAz0gBsGx22PneTl33Oiz2G1wBLne" + + "c+eJ/evgiIu/418Wu86NRI/jdDeK2Y8guI3j2H8GbcgDXh4QFKtd7b2tvT1v9z3afm9c3zuPnHP/jfTXfa/B0cubE/mo8/jpLnNgJ3Ye/9/nYCf6zu+xE3dV" + + "7b1BGmPWft9XffqDo/H7z8XOwb7757/sOzh+ovjx0eefy7t30PtAUIvi18Gt+c+fKOYN3HjOm7Yl9sPspzHtYqAXu+9A/337+/7WjTzXn38a1Bn82+Z172DW" + + "22+uO1AcfRrsOFEEOZCPNs3Ff/HdMowxvtqFMSYjgzHG1wzo8YBitau9N8YYY4xZ+30fB2OMMcYb3jY4F4hLpuv+Fz+dOXF/eXPu7TFnPerf2/jWf+s2j+sP" + + "9DT3fefP6zgQ7J/bILc3r7lO5sIgyGlvlMVNjxoENy9uT9Rb9LzmftTb6G+x6zrPx9GP22hzWxe3B0X9jT6va9HvPgOC2Np746LYPVD0nO/6xsfvP+495/6P" + + "ecuj7fNdHnl+7F3WI+4bO+7zuq573kY//u6r9raqT/vsR/Hv7j/Pbzxz3GiUv50/3X1a596Be+w2pzutf/+2N9K5E/Mmeu7xPnJx/LTm7m/0uG4TN6773mdx" + + "b0782yh/2ftf3rZtxI0/jyLvOuuvwe1xXbcFjyio5PKanSqaCSAogm7zFgAAGBgKhoODYZzFYaZ7FAAJHCJOsDYqIDQOiMYEMCg8BgPDBEBIHAYFCQEADZAA" + + "hrIgy1ruAHnHQWIRsQFJfAbzG3n1hi5DRFWmtVweasgBjgWBYsaOQ4kem0G/YO/1Ku9/QobII2BXqxfJddccqOkrwegivedS8ZoHwKlDpMMhNyBWKAE2h8i2" + + "0naZJN/eAVRuIm7nIHgTMTwwD9S/cguw4PEbZIbUiRkdyE9EL6IiLwKlnr/Kh0bXKUFzbHUNmkiH7k9/OIRiX/wQHRF+nKQdq14eOGKGypNGMNiLaEM/kHhs" + + "g4AdPQEG4wlIpTPGuo9nGsIHZ4AzncCg9xZv1SJTGzzzG8bdemq7Lyn2xY9TPtgfZsteyqU38WWuovq2whEL4u1JBkHOhwnPqBCo/RIDMCDwx8IM1ZkZXcTP" + + "KAAd2HUV/4G71zS95tpwP6Ch/UU5Oygzwy37iz7zQI/vmebu74T4yocFSnc3diJv4yjNj0frKx14g40H5iv9ewK7r4CuZ1oe/EC1xuVDfbayyAYMXUEmHrcL" + + "w7tI1znuG53bHYZaG3hconT2ROFNKJ/xqDaxWfVc+YtWVm25DIk0qRQ9RJG0J5Gq54niq/0fZ1mcajqP11NnddsLRke+uCJdlKP3295THfVupBv4aMfzpLt/" + + "qcFadYOfI3Wtz0smQu7nE8TBhtQ2BYFOUYX0m7AR5Pjy2Juf78GHgvhPoeY6aKY7gq796fPMocOpJHT9niyceGKI5kFLGPJENCs/Paj+UKua2uUxb/7DcHP+" + + "pRO73/4gcgTZ9FSD28aGvog8LniBJANPvgiospHIjzmHL+CxRKFQoPFoL672q1hb5ed7CexfxkQ7PX7j82KIrimJd0AJmK6ic6FzubjJcnQiFN5Y0fVBMU4K" + + "QDlWUfT4Q+AFxjp2UWR+BtTR7vOGpWPqiI8pUdgBwg+Cg8nU6yRVIszAbBYARJAScJHH1wiodU11CZrMAoAIbHDCO8bPdOEvOcdxxJDTG9H1dVbs1Mj67AW3" + + "5Kr9GXXLygVDOA32n4mULXhc+/wMk/Zhd9lSGySCHX+VupesVfcB3C5w+ke2umSGlmh6LKD3e3Hi+9yAuqkgxxQmO4UEkeGzSeabUUX4swivP9UGE6kbq6Fe" + + "XrzVhK4wMnc7jMpVsiHHyw6QEYwtgHkAQxBb8KxgjCDMAViC2MKJwWDSSqS5BzddsE9XnHU9M13g5le8cY19XOCWawK4xRZo2AYubZ6D5kmP+U75RZCJJSni" + + "DzPK0FwSWSd762/XZ8vpLpqj7gIzMyfp03V+Nj7fv4G51jt9Xu2Xx6n9IBm7j5YlAO2QcSwlf5BAgPK0XQ19i4WRO4lXt8K4G36RqPe3QCz4QD4RBjxZy2C8" + + "+y5U6R6uCHYKxnIv4V3YeV6TncG/RCzQ+xP9F+HhE8y3bKtWiC7K2Yz/FfWlwEDwuMDEEzpv07diM4662WU93nyfHg/namhHYdhf8AzWbOR7n/DaO39nNh/Z" + + "ht/u3VOWpFzd7E/bu92mVa8CyzByz1UfR29kjBJZjPoOAsFRkKDwRxMUr/cidTaLekkv0lB4tMljZ4Cv5a+7//1bKtnyRm2NFLDC7MkLwU5biWe62IqtFP6M" + + "k8GZeNyE4srxkv/ERLXW9CfDvftljdn1+PNH9yrZLXg7yOPbcE1f3Z2F6XqEyXhhlnLy2NtT1s3yFW7x6Au1wsTl5Pa3U6qztsUByFpsAVx0EkO+A7hadZ6e" + + "JfHwLUS5hdQv7jb7iKWZbxzEzav6gKcpZkFWeuRir0c8h6JkGOEwYt4W6wa6Vbpc+73Jv+nEcND7u+dBOPH5Fq6HbpIF59PD0CQAMvMGr0NyfCENJg+idmUm" + + "VAfh7OBRlk9i96a+stfjhSFiPQ1E55zdc1lwFmBPFiz8Jdf8JAPHO+G+f50NxsPoD9AYkJqgujUrVeOZayMGzXNo7vLn3rSYSuCAU4YsmnuQB0RJBwPT6blA" + + "p/18xWwgAiiRDYKWht3KNy0hAO4guDyBb/AIaegzt+X2Jsmfy3FUU1A42ynuFzwchbUK3QR8N/F3pzj3iPaeW3gD2HUa618ptKyPCTmnh8FZxCM36wV7AnTs" + + "1OKy7pjj009bV/RBzfmjElouyipUCZWPXQ9We7mrV7OCNcip4quoAj3YZzF8S01KBS6mC7kw4Yi7xORsI0bGpL2Bcz8p/mjepjW2C/cBzFUdVTUJMsMgMn9A" + + "KR+6FgVlHeoJ2atrZ2h1bFARPlVaL6tn+huwhkV/kxmw1RJWo2fhHZd9xH2/dIP8KgaSxs9G79YgCfrJB2+t1LnndsMvY+jURzCDmKRbfHbVf7Nsp4d4M2cx" + + "nrauC3qL81gVcGVbd+idmA65gBtZ6w2P06OJ+3l/n2zyjtP1P0FFvOv+vf3vuF0/7pyE5mqObYLXlmFb4k8Q4HhYtjoo0/8taenFgS0M6Vu+0A72weVLKGes" + + "wS9zYgPVx0mzOrzyySaqJnaDEIzcIfRUDLoByIzCbVQxfbDsjIpFbS5h2i+rOYe38vlD7AEvbgUxbeKflvSLM9t577yzpq9bzNvEl0sNGxpir2Xv4Ww/UFPu" + + "XmSV4/GDOl8HcKwY3tF57byApnENcLgm30DXfQite6MBnwHoQP+faROkOsSMAzE6PZc39GyXwH9lEPJRSL+6NOlldr/OHF3TaPqLLx4WD6mBuCb3chIityau" + + "99eGy4LIOZZ+A1kp/nLeTJl3ipp1Svb2Pw/isCrD6dB/sh6Vf4b/YCWRmurZPDRBcT49dLQ9AM4BWRNq9jSRCHmdGuINmlyPPB729ncK2O+DMdXMj4uLEtvW" + + "4JmZGACXHB5yfgT/KxD8ZITGab+aGZymo5bda0cyZput6red16cVOOWiEArNUA4QctpM0jsO+EmTpJkej18G2yq12VPYvJNVNPBvCJ4wwcrhfkaxUCKwnaUL" + + "/g/8Z3HysbLzKXyX3+0S70yUs9Z/sMhoob9CC20o2+aqRaXQKJZJYXa6PkPVntiiyp280fhGu5+S2bfWNZORIgGjiZYkorcrLldqzNmO6wyyD1kmjdkygHyd" + + "x6HMVlch/auzhqI6eeVMdfkxKIRJN61yZ9fCrjqMK+Hy9g5/3RRoDb7j5iLG5zv3VHiFgCH06MxpCu5mqSUNAmRag6EmuDoBWykaAIEdySd8GxQ7x8Q/TMv9" + + "/uPDpcaMF9M7Cfnn3eHRZNpN4eXadIvH4BcBnjGVcTuHWrIxevW9yqKfQvajxidoY3SK8sdZNLpFnq7yRk82GY0XvsFKIzzToJsEF+dbQv8zIblJ2D/+2Jjr" + + "dIKlDCHgUogjefiqut5i63pLihevUcH3mTcHl3ym3fFhtkvnh7M+4I/JMXFByxp5yy5hSuhbBXYOTHJKpHwN85BU00/SLDaqyTTZcsz3/RGjVz1IHJl5pPb3" + + "rVD2KB23GyO6OIb4sVY/Bq3MnW/zMVCXuwFzhWuVqiLncL3G6f0PlrLJOdClb/GO95g6WM7lT1DmdNvby9zdjr7z0svYVaOeaGe4DvWuWsgvyPqv2Wu44uJ9" + + "q1ungBer6pEH60SSaCNjC2vng4dZU5vp+W56vp0YIcQkPRXjvhJjB564R6QtqqZalCi4W/3thsIxMNSzvK1Gf07R8nwSKBcbr9Vz/D0LhwoNMixoaWOX856H" + + "QGJIRUEB8stYUXexQn5RisXOHerwU30FV5CK7JwIKCSUB0d3pxSAeMrDb7kPgP8O5ORwKy/vkRGhOhHn9LOk5RRJgXRTPYEhNbABcflCFF8vmpzq+vwC/G+B" + + "0DhG5VxLsclPJfMfTTTwPQnoRop1TGTqZb/wfU7PTUq82zdERQqYXYcwbxRjnlpsZI4a/IjqjlU12q3x7X+xUhK0xuz3Wjbmg4loyc5hqeK2uLqjTVKfW2Fw" + + "V/O0saxVnkJ9J9OBSyizOlqAjDdud1jUErhn3JoDND92h16yqLD6HJF0tczaETUtFOv2eDebN63++VKNG7jSRwf+fFDldi8BvjzVnf3omwYB4fFkhEaorlrL" + + "iDEHJ+mbcp7vcXKjtRJ3cmtgKmpKYGsqGqiT8T0O/K9RNb+OeFQr6BfJ5N+CH/6Bxjx3yKN6ByTDBo6MaaUUdrdA3txlL6szX03qmDjeZUG/O8O068TU7kAZ" + + "d39Awz+8OZ06z+3oYK0XCRON/XJwjmpayeU/z7F35umVnzRgi7E+OdfsR1awnKPnLrHngJH/e6CE5eJ450Za3db/FxDFryg89JPe7hxIc6zMeud+Tm8bGk++" + + "eT8jSU2H84/42L6zVTgwVXzt8YBRJ3kx12fVJpmKygaCLrub7vcQMrkEuxHmIj/hIsHCRGhdD/1rzJWe6XecT5P4f9c0ruG8NxsYh5toaqYu9IkC/xWxXH3w" + + "ypsEBmVUXFgj0EIRrZDAX4qCi8UuVuLPSsVnGXJahvGT2MxViqp4XQ7bQEedIGdfs2VN2lFFc6voH3G6SlHqhcP7HHnQDE+NTbA5k7ZPrtKk548E1807Q+JA" + + "EzcHzg1uQxX2Mt0YRjNftdHxU3aSlJfzlldK5+PaZ5J419TyEmBwTpPsu+gL6uR84IAv9lWig310aqaTh+kIacWvEdSvjGegR6Fc7gelyy7YFUxZmvz1khX4" + + "/Hzb1odA/MZRFDrzgegP/ut1PqrbHc6xcz8GbzlxfxD4vSUI4fR6bnm8gdJ9+FQjGh69D7calZOUfxbhHj31/w6aM3pFoAaFN4JO98TZLHlK/DoHP8d6lWCm" + + "yu4ZMWtuxBX1kGjqWdFokSP9bci9MRsSoEbxvHN7+1WE2gbZetbr0n4nKtpKKPqnfwer7a2k8cexCSBxvbe/RAl6bhM6fLS+FmkdJorcJlu5QTng/yYYJeIh" + + "443/S2oEnIsYfhNnra3k2MJvsqkPRH8zqQu/hEme64izBNuMs1ybzUQQ+CaXxSwyXB3/lzBAA1PgT86d2ff3GLBrKJ+m44hvwixRDyD++79kJEwEYZtsZYfy" + + "Jf+bNEukB8Tbvl8iAhGLbJNZu7N8zP9NmBLBkfHM/5eMwEQjNvAtwdFvYP3NS7XGSEUxhYQrlPdLGnDglPxjbpVTH+pM34lNa/KmIkhDCukMwP0GxIeXHam+" + + "wWpPM2XfwqzApi+Dl6rwyl55K4APk1Su6L1ejPeGmB/us8HW4zgE8/2sBS9yrM7TqhE6BwtcKj0psrfpTH2xnrmTXui7Z8d2CPO5Hn+hZfb3OqHgahPknTOk" + + "O2hAQj1L/AXN8427od0M+n7WA9nCsdRqGwmmjIE6HL3KYzw4DJOrr8oZpvNwn5buZfD/hi5bX4iWeUDrmw1NlzcMZiM9fQvk+FcPGX1kME6mQ7s5wAX4n+Jg" + + "2+FBs6rjEJMWi7ulyPl5XI7Yy2OGVXVU20EnBesr3lYHclQmpx5Jr5X294UagMna+bOEat5hAbkXRqd9m3nU85nm02jMGLznU+1fifjN1p5YfajOtG/qr67u" + + "2tZ7qZdr0/Pc/NY/W4NSl44gPnBsRPKxnX4NRGt9zbXQa2j7Yop6SNf4LtZsDotNKrwcyuN3Vye6hiD9FuwrBzn1F4gsMqOdGxfglKCO3KE9dwoxWkCOgQno" + + "zW2DoW8MUnk9gHubhA7GI0y3Mz7zGma/8aL8IPq5Z2sy7vOejyt/glMLqL7t4xiZtki3vpj5bhZxLSOsTt1jEbPXQK/90o7plCAdjpcBrywY8zctDrRzelJ4" + + "/pHVsLuKTFpRRHG8pxXArv5efu5eaxanLOxr5h3mHiTHjhe9Sj7ETXH7WfdtJ483iIeP/ZNn8DKfw944FxDJwBblq4Hn1bs2rj9Zn//Bl8ty3cNWD5oXqhPA" + + "EeHlx1T4efHP/2okmy/8unmtEX6/l5Uc+4ovpM+3sJviXZBgt4/mm+mpAwctozn7d8SxfePHgf56Wmqklx3v2xytbuWieJiofUNCi4d8ZweLnXCieTpN29AO" + + "YG/L8TlqwTZp99c1WcorJODAd4gEPv5X8M7RArwPVYZO8NAN73l477cCckQztS48Ij0/UzZcS0E3G/rfxzQ2PM3DnRJv5dPtTA0XNm8BQ3nbOAe29N4HOQju" + + "GaZ6EEQZTmW2xm5z/44hcNPXaWQUrhNWYpF90I5L56Cjg2AiAFJFnouFfbih03XQvY2aevdzSLCJ7Ye0v/r8xANttLmc+AQjcBvM5FmLpFUc99+q7ZpCa4j/" + + "EFfxS2/sKwOKgzMp2mcmDN7mYQ2aNDS8mwsVdkGDoL02mtKYh2kpqzuuSQXAb5GmDPvcuwd48s94fAk5NR9qzEZ2J2jq7DHtFIPy3/PHTf7V9xuWJRbcVaZ1" + + "vkqa9yoNfh+D8k8Y9exEmhw++1nTAlOxX38uXvW3W/IdQ6g385AGNMDG3cI5h+Rrn+r9bREeKOHl4Ad5mH1XqXFhaSiiAgL2dk5QGV1Qf8IeHqOLmOge/3kH" + + "EQLWUGlFxIf2HOqi4qs92RQ+jCOmqxNG20G9kJOtox+p+odEOiFAWyJTSHPGF34rF9X9rxYMjodnJr0DpJFB5Hp59qI3ltrm9mrWoh7nQLseBMVOHL4Xvjb3" + + "MDy4BViZrSKe+/57p3eX5S1MGEPJM5P9Tfe5Us8QMb1u+mUzvM+dhfvzHWbxCw7DO8+ef10KO+ZRLfUauKJkNeBSMkv0zFisyfA6cMy+Q91cj6Tz29+H5o+y" + + "P7pJrjswHugDid3LA8bm7mgBwut7KBywy9ZotchP3nCQYOg7g0Q9oz7zF2cJjBzZxMPoTMB/Z0yWUKoP3RKXiwCSIxsojOu8w8ncXJH5GdIjhNG2YD6hRFrQ" + + "8ZTPzhAe+/DeCZb2uQkvykuH3r9m2M34Dwymj5Rgo3RPl5n9w0PVrr5fPf2Vn1y5i2GdZ8v0z/yeEYhpCoPY9+TnqNNh/7s8wvh8IA9+IjPSesI6YqDI+I/o" + + "9/qEJG+Tft3B2BkGZ/phb8ZbjvF2J3KnXPTG/E0/Q5BdqR05tdlQ+SHrnCagrnotH1rP1SQAIuYGA4/5LhdtXpR+fKFuXjweGZHzedR4oHXEXCm5A77jebbf" + + "l/izKGrUV+GknR0Wc9gxj88FG+xUUsopE+6K3R5njWDP6FHOop0M/frRjQCtVRGyV1pHkqnJUeqvWGothuGaDdHChAxoUcvwrmUrCU39N2YDHJByQ3iQwzNC" + + "V3A2tyN8eTQFI9t0D986ThSYDqx8lHvB+9+BcxTW95GSe/6MTAbHH3IpQPJSpgiFPVVR8Gd6Fi9ow3VsAw2aF2HO5KZM0+XfacNcMHRIwmdS/1eICMEAJMUL" + + "L8eBMPJDpEYm9tah9eQjWvE4vJRKyVJiibuIG17pC9Q2plbo1uIg2PzGF9oijGl6PX7ut05ezG0thHqIZtim5SMxPnYCa+GoKT0rkbT7VmRFQ/Cf5x/GMUQN" + + "61qbyZYwvHVf/F0cyRMNngQ/7T2oeVBluuiCj6uGo21YR/VWsTn6Xuh4O4xVGR6HOD4gEv4+6xZreEsF4MUIWn/VejlofDfKP3bFlW6jLCECuyITHR5JuXR5" + + "7qZHqVuWwAo/2Y3vmJoNvocgsvL8zgk6RVkyxn3UlCsbkeC6Rvuf4UbCzysMCr197UouET78fsVerW9zxTbjDF7/Rk5zQFhpPxbQ/1UZyAwltAUvXk8AOG7r" + + "GOyA4YFo2LsV4F6r/1Z1Dh9fd8bQTNPqg5d2WrCX4SjRRiGEeqkJfIkmoVC4ZoOkJ8Pn7iO4G9AcKDHzwzPU2PsNIqM8fEEMM7YM8mq9jmEa96pn+2egzqTj" + + "zfrLtcQ6/POIUiVgsxMO+vILHa0bMXvH2U0H+PtAu44r+c0/Fec2RjRI/QEzSzIjH+muDZn0YOB1CTPKTG2+cey3hkm1sQDzamTh4gI/Os9TzZ+1zEJPbUMP" + + "ayJ6jE2e85DAeACBKgSy0T+fJiSEXwk0U4TpWqUSYV+3ZuhdrLmCFpd1xQIzQYdnZulhTODfYQ1txhSRWQrQYS/Uji6iN7RdVcJEKJT02ezcHs8a86Xpb+zr" + + "afdbg0mdBxeSD7pcNCg3Qzxc6LWtKFbjxjx4rY867NNRWdglYdouPWa9Rp+DhOO4p+EviVBW77cKuwGIxzSRy424fwUyVlsoINEfEex9H7yqbAuRo4hr6rd4" + + "cjSSiB6LkgHt0Al+7JJocKryGRgNmqZ+taLfJut0sudYL7NQEdJ6G2xQR1jI0Afvbld9pwFxCPPYYJqsaxdJgpyKrnQSTTnwlQhmWMEm3NSCetXee7F79zE+" + + "gyzbDf9WzQ37DtlxU9s/HVEVUpINd9aw9bzRhWGXsJHVPjPo/3xCJb0+wAa9H/lR6u2aA9XYUkPUTpnMpD1TPvLU7yYPYmZqlwSRYcRhX2t9n3W+VqCj2Xg2" + + "o67BSHOqMVcGTreQ1NOA6HnLdZ08/MNUEswy7iqZ6P89GG9uaN2qOVd1YZpQkeDXrEXPVOC67WfZYhBSiztjU8mgW9aHhQ6gaA64IqbmZ4UVhA3s/W0boFFw" + + "d1PEHuAWPJO9GE9vicZcoiVhgKRqM1WgzxH4V2Ps7oQefggv+UuhUPu1L/X6wlzrCeKWDfE5LsH7iBJRWvesmyLI8dtR/WFe32al5q4wu8R7OkOHMAb+Z4xp" + + "yoOYtGs76A76AJxNyEppprOsHW+XlTmPALVvKBmNqIhbqwJATVqUoJIBzOY937oIUNrWC1rdQ98vvwFWcRMck1tYeBQjznDyDu3D97WNxaDVUDcYolmw8GQT" + + "QYJwdoBOuGAiM+U/5OxnKFKdEv+r78jJKpu/zlwwkN81Hy8mbFsj8wpm0QrSK1usbh/dChekDTDkywLRDflDfIYdd65c3kCIQcWmJsP8sKvzWJfiZ/ODHY7L" + + "wgU0CEOtesr32lWZM73JDjfKaaq0tr306jweHni3F15b4aQ99/nygHgH2PlJ5sBF6r61ce01dr4k/o0jYezurQxW503zbhudZa2Ta3FHQ9tAdRg605arsB04" + + "V16P9owox2zhwhBUGloV9EV5xjclvONbbVLjtmhz4e+SeU8BnrrfwmGJhvpFx42o1ccSZcJzgb5LYQD+RaJ631SR9YXnfWow/TVk+AX8F4t9/tq4bEXkNNgV" + + "JyNyoHN00NvTdnK7xNHVlAHm/08yaE+OGgQY9c0mP1sa1zX3/TfXRdaVOAY0YU7H6PP3aV/saT+HUb9srt+uPeKgIFkZGcD/huusZjaJDuxzJq2rgDrQs/56" + + "ov8Be02RThHwGkpieJL1Wc0GLFfHz9urS2C9tTZdsBY6vSoj15hEjCWpbcNu0Oz3ZUtjEeesIGhuWthD3hGg94j8MA6wSE+bmom5fz+Z/aKRDkZDXIXUh87v" + + "mKQz2DGBIh7KYHEz9C1jwodGjAE4H4kTjXfHPwpxeGvGGV47EI0O3gZ+hRmMXaShPVb0kyEUJgwUyQkh99paBxN231bDXUPejRO8jYYQlGBpL8EtNaHJ+Qcc" + + "QniHAzyp1uRZwUq1hGTlBbGYGUNKCILJx5IPQIRSbi6DY2X2zBMmsNDdIF9q+Aaw++Ixd7hZjwXfDWFnrlW21eP3o8tQVTcH45R920BjNCYfSrJ81NbZpisQ" + + "UPSKDYw+nmcu26GpqajdBTn+U/pvZeNpSiiTVHB7nCBP0bp38vn8t3lmKInevc4Wnx8kCodGw9tZ9dm6V8uNJ9+HqFYxT/M38KO/xk5ro4uWn58co58AH4hN" + + "iQ+kOX/+fMdnaX/ZY5yjlMi7H47d+5EVN9dP63bz/Exxl6Q9ZW4tk0B/NluLqEY3BAvgUI/NvFt+qY24pBlc9iM/TxMrb/zZrSPErhnrGy/o/ufRbHyDbwYg" + + "Fs5DD3lfHI2BTPxCPc+KgTx688SLWPikPYJlgHNm7fzvNPZcdJN9GZP1USEZAUt7YvieAnbfWfIOY7K24/Enk8wmv319o6yjOdqjg+m6Y79yYDZsoyJjDzA/" + + "ZpvXgc/bN/Th+mSzj7H1/PVBoIcjJWZdoHy2IGf8r+W+0oHOXCZU19/ifct+JUfwu7wSb/7x6YNMAAGpQaNeW/pIqVIg97KCX1N67KQjBLJ7Wj5o1I5/8PDE" + + "5F6GZEwgTAeNFUXaJIL47swO41fnwJneJIL5F9WoEgfrfTZY+ZeYON7AHuPTO6Vt4hGgLN5UidIlyhmBmj3dLyem91GXmZwq34JbOcxJ3Iew9vPp5OBw/IRm" + + "jvrzuvVFHFjwLNBAR4HikZ6WLfIbtwFXdITOacZbjm4tbZaYL/H14aNQ8nzMO59Ws/CoAd4+TR9yR4hPjWFJlq9U+4HV9d8ActCYoNFzNOxq6UuSY94pDnMO" + + "kcgF5U9nWzcoI+L6J8/1zTsH0eOYDtTiAyvwVEEXLwYOv7b0ZmefUt/QdJvJZh881nCJueDslKb59gNnvJ4Z3+Pnr+hh5Xs1aLinb4qBuQ4d4rfs7pIttFt1" + + "TkRa5sstkS8r3W/MBnuSBbiGftbH2TGn5wD+Kjau4OlBbctFdOZ8mheYSGJA/n6B5tuQqQoLzNevt37uONdUrW40aTt9THkiU+1olNne+TpBB//beuiOO66Y" + + "XQbKOV7TzAOLF1tZBgNKj1h0zSovvk6KSyiCokd6WVkogHraD4zYZ28Jt2hTqoMXPlF6VKe8ZHb3lW2/buggsQ8vWMh7SVC44duvsKZgRwzM3txrHLrdc5PO" + + "ofjjLmeZU3+lI/MYH67pR0G8r/37m3Odg2O1ftBNthYldLithJgSbhfweCbsEC/HxmBsdc0irLE/bB8+0K0+mMVegxkyQQ35Br0wD9why5HRRFhuBZhFt+ma" + + "49INWgmI/LR/ukuMHyu1tlrb33Q4Cz3GyFZ/u5p1kRXgh4K3ZWAYKOz9n8l1pJtsJ7Y4CIlYZgHAizI8G/NDQHrF0Oq5g+/e9Ipa7WfaLXvH6yzWzzmLmBXP" + + "AHe/3GXyZ3BG/gJavwSMBPOankdo3BdeK5xFjOw7/kovgBl8DmsuhcLAKpPYuetbhzA9Rto7hjRlb8SwPuzKeWLANOelUXocyDqWwbOspG6Kt/0WTWO8bQb2" + + "9wmQSJw80qiRSfwKoKcTM06yzjjX/Xn6+mAifN/8Sb1hzcIUqLoHJrHwTzalwvyRL2rz5reKEHB3v5qa6WI/SnYRoPZlW6ZrP/+HOHYLyfnvkozUwL2uV6Tx" + + "9w+21JzCGwZsRw6BTPcZ/sLkHLx940KV9+N8+tj017AJf3puSU71sArL7oVmIsGy3/ie8/L5+87lgxMhOzyWVvTYfTmWHwq+gUP7uni+HOM+7Zyyrf+SptrW" + + "DJFtj+O0h1DQVJ6RUgo5rvRDQLZ2rZcBYj4BOLI+UPM5Ged431DEojwcwD1bbSz5xmCVpRn4ZbPQrLkyH8hmx3c+iJS8/eNyPvmL+ltDVynUhmfVjYGqCUGg" + + "g19e5m5crokn0PuCk7as60Zi7L2Nu/qlJdTCCUYsFdGT0vv+xk00hQHIScj+IfQcnV0ROAE=" + ), + }, + { + "name": "date-boundary", "size": 26686, + "sha256": "d4443f0bd42c2e9d6a5dd07d1949deade5d7526036f1320b56336b5637c9fcc3", + "manifest": "{\n\t\"absolute_minute\": 2880,\n\t\"checksum_world\": \"a1bbb246263099c1187bb8b03ab1eb68424b4dab82133e74f8550cb2e330801f\",\n\t\"content_pack_ids\": [],\n\t\"created_at_real\": \"2026-10-09T01:24:29\",\n\t\"day\": 3,\n\t\"display_name\": \"before-last\",\n\t\"enabled_filter_profile\": \"default\",\n\t\"format_version\": 1,\n\t\"game_version\": \"0.1.0\",\n\t\"save_id\": \"before-last\",\n\t\"seed\": 1241009,\n\t\"uncompressed_size\": 579376,\n\t\"updated_at_real\": \"2026-10-09T01:24:29\"\n}", + "world": ( + "VFRXQgEAAAAw1wgAAAAAACi1L/2gMNcIAKzDAFrZ9CZO8JAo6RTUeQl5FvVkZCI1IpO8KishDYtlYHN0srofAjUCYY2Q8sm3aLMh6YZT+Lfj+VHZG41G7L23" + + "3FJeF46x0WIxqpNpNgpV4H8otiYDmgLhAScCb09G+NrxvrWM8LXjfXMywteO941lhK8d79vKCF873rfLCF87Xn1LMQAHJk2QNFmwiUr5eDg8TKCqmayaLhOq" + + "pqhjSRzYNbPqY2EuK4uuWc0VKGT/MlsgkYw0M8/kfGT2KV4iz7xSVJFFpZg+L5xqZpanM6UJc8MHFCLMUJ55QdjkoYYow7KPpaobKvJMnGq6PJA0RR5pgqrI" + + "ojYvswWyOrOjqh+QNLOImtIEvWRTVk1ohQnJi5ITiAXJCxMVLUxOXrxc1srMIo6qfmBu6ESq2iEBDBIV0EmJBiQsXqhqCGlenAU0QDFhYfIAiQkLqAWJCxaq" + + "agAngrIpRcMBgsHmdGXV3GTVx+JAL1dWTVUN0Q265oo0KWmKsCq6MoyaomxKquqB0RNYVk0sUGVNI3QlwrDZmdcnizGppKCiaupcM0sxfVSVhKpyTFA2V64o" + + "kyYQFLjgmBKHRwabHOvyqGYsKxOlAlUTR6ZjfuaHA1XV3Lhx48ZLJEFZNVmeFs5k4UAv1BRJUIZFlKoOkKE4L5ypMlHQdImkSaVE1YQqa8o4cwPr8kAr1aSi" + + "EmUEqDRBUhV1OhYHymLMSlVFRmxQQVUzGAjF6AldqSapmh5V9cCwTE41YVc0pWpqUVUOVe34cE2WLJodqKqHCCiABGZnyqrPpaoeGKwzM+wFU1UP9TC5fFzz" + + "JaKg6TJlnEhVQ1qq6ILmvDJIoi6rA1UVUZZsilRU9cNiVDRdMwORVDUTVVFHVTk2HqhqRqKsFVXlwCbn+ljYvFQVZGZRhkGzE62oKgiQGqqaySwWzBNVmKqO" + + "kCb2iTyq2qHSnB4shAMz+1RTB5rZh7KwlEhVRVS1hWNRHFX9gFHVjGplTdg1XaCoM1k4mKqKUNWNqnKoKgEBUkoppZRSSimllFJKKaWUUkoZY4wxxhhjjDHG" + + "GGOMMcYYY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMcYYY4wQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBC" + + "CCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQvjee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee++9995777333nvvvffee93d" + + "3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3dzjnnnHPOOeecc84555xzzjnnnHPOOeecc84555xzzjnnnHPOOeecc845" + + "55xzzjnnnHPOOeecc84555xzzjnHzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzLy7u7u7u7u7u7u7u7u7u7u7u7u7" + + "u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7+///////////////////////////////////////////fxnha8f71i4jfO1436SM8LXjfYsywteO9w3K" + + "CF873tJ0oSxsXpWJDKSFslQyLJop0KRSrOl5yTQfHpwWGJC8gCHyVpRIoIKk5ARCMcmgRFVDPDogp1FE15GJKSQYoqLM6kwZNlW1RDZFHahqCEZNl+jKVFVE" + + "9lFVj2y6rKmhJk4IjJ6AXq6oM10eVdVkXjhRZ8o+NvP6YNOkqIgzSbMzqzmtvLCMeOaksGuuVB8Wac6q5AKSEhaKTcrTiWLMESwkZcWJCxUlJ1ALFyYwTFSU" + + "rDCxKkgggEpYPECCYmIBDMhFC1Ut0ZGBKY8R9imBUsLiRQUuVEAanKC0KKksLOrISJSlqiBSZFEvkQfyFbCyT6QACSzD5mdlciaXa2Ig0YqSCFqQSKACKkEh" + + "QYEBocAosSCC6XnJQKjqhxKQVZMzL1XVMDMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMz8+7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u" + + "7u7u7u7u7u7u7u7u/////////////////////////////////////////////////7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3" + + "t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7dLKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJK" + + "KaWUUkoppZRSSimllFIGuyngjvf8/cYFESHE9nZ3azIg1gMD7/eGeHR4kCJSgjCBGUHRkfGw2ciOTABQimQwm5aOhNxh87FNgtmhdWuNlJsPESlpQABECU0A" + + "IlKCKKGRESRGHWLUIUIdog4xs9mIxBxizCFuCoA5RJhDjDhAHGC0AaENqEJNVfUQNx8g0QaMNl44wAbICirUBInRhgaSACG0AaGNFyiwgSEBAAhtwPeeDDDE" + + "o+PJAFukW4aW4b0Y3ovhbQToGF7H8B4M7jUM79V4XeO9zcd7GBfvabo3HyJdo7tGCjU8Pt01NC3inAvtXOh2oV3gFmDbtfBugVtwjgXHLDhHwzENx27zIeJo" + + "OEdjBBos4hwNx5sPDdNwTGMEGpgGNMw0NG53Twjx6NgT+CfwCYxiTeCOjAm8GTGBbwJvCSySwZTAGozOwOhnLAAaj918zFg3g5rh4cSuZv/P2M+gZoQI4Z+h" + + "2RA2xKMjhJVShrAyhB0BoSMDwjEjKCQIlyD8g4tkMB+0BqMyjnJCggJDg1EpgwR/2Hwsig8zaFo2IZprTnO9cePGDZNTRZpJZaI+IqZqUvmAzYkzPRiGRRQn" + + "RBVRHgWoyGW6rkhVN9TmQ2ayqJqky7I4EHZNj6WqAcjQFSUXmJyckEAuUCwgGTnHZV3XBCFCYhNLBmGbFs40YZUIlE0xpJl5Ptc1TYzAsHmtWJdnpEQ1tUAv" + + "13Sx5vWhpkhlJKRFBGVTjAlJs6oiyjMpqYpYpJlN2OSiqiVWogx6SYEmSYpUdQRn8mAfTFVBSFaqqZqizrygyanmNIKVUMGmLMJUdYSDg3lBqjpiBERGBEnz" + + "mlk1oQhamHDcuHEDoycoanKgrJrX9eGoaog0dSYKgIwMqpqZFBXC87GulSrqfFg08gApQyNjZXWmBF3WdF0AxBg9OjjQxerMy8QCm8vKOBHEkkUu18TmRQAm" + + "TZxqggKKfajUJvhHCCEamBEgiADzGwAAQkEYxqCzbHoUgAISEhwgGhgKDggGBAgAAAYOAAAYBgACGGgoABgQALiQJxAAgSyDQ2j6BgEGj0iH3QNxdz1FLynQ" + + "x5Fa6KKeGtkENuXZKp8fgvxkLFXgwmmVa3K4CiUvgpDNjEIJuTj1ck2GFaT8xwd+y6zor63Qyw08zaPclWbudij6rAOrUd8b76gWApjAqgRr6T2F60756iUS" + + "uDuAkAYw/XKq7zKJIkaljmfwXZ0PX2XWKuF19ShmE+tqLy+Tx1WsSMlVDPxRsunadI7bvRHuq5Qv6rskzeuy0v12HUuzAH58qtB2aQzjM0NdK9XMhScoDAUW" + + "wUZruYWiq4rNahEgJjRcRYSVxtBLUW8glHRx3qQKql5rs8rEcnoH3v7YDyz6Rkv3SoIg69PgIpQcjXTMg4kVijI4Oa95kJt1tkLQBkiP3kGwHEDj0k+p3mbz" + + "/ofQlcWYL83twCq1S5caEBzY7Gv5/xya8MEkacVxJ8mvHWSCkbZPTTbSfNO9GzGvktGz+YWRISF8zaXd97obNbk76PyqF8X7ukoarcLxO7jmOJoQCWSwqpoQ" + + "3smHOotWUl/+X+FjUbQ/Vwu+I7va2EH+0isPR+oITZffZLsx2Gse/sY9zrIM6WQTvIb/jsv1LDTl9+5ru8pIHE63govn/N2/DuGiXh3TkIR/W1mRsm+jeSlT" + + "B75uFGBOk7k76NerUNdhv1/VUkUjmXCHeylokakQb3UIfp2anyffXXoMA6kSOvOBdhiCTfWtJ6gaYNKpx8qajDOCoxbsok6bku8IWbSpaQg/Leata4krGN5V" + + "dMWxdqkfTyHGFWKl8YkoOlW7BOS8G0OEvsqmBBumga6DcBSFw97n0lRVuHzlr4qyHNmVItLPHW2e2hxLHj/HkVsrTHryERx2ensl6F5l/RxX1hsAPfDdDywD" + + "PqxUbPc+VlpJL7l7hf+hFvFJKtHbGTiXQJIOvLS4eMKvN5QOa8f4oV3fDqXrgVAQa66VyNqTVQajmXfcaUIqfwXJKfA+uB+NxpcU88mI8gsZyQFT2gAe9+tZ" + + "qO/Yfi/kLsYO5DUxb78QJCW9Zl5THyBxECylma33p1Ibf5VgiEPEFFL9P8FBfVvT5pTHOymxg6taw6Q/ctOTRl0O7Xt5CAh9shBX2hrmLeoorEjim/2mD13L" + + "Kom6boYm2gLS+KjieqFlk1DNssqZyihE+7vB5qdmMsjnMzllazVIjz4Kn5yHr8TMXsXKxvgttZASsgcvXz+KEnbLo8MtuAw8gU6NWZ6GqHvVJctLa+m7D62q" + + "B0GAnKVYqosV8mr7d4XFRl4F1Of4+38dwjy8NZLnEuSG5osMyYERh/Fs6qsNq/1o8NasbHCrvsVuVYztaVpzEzjF0IS1leXWGbbjPSgKs8zeH5o0yjae8J4/" + + "4QMKbuIWQcADbnGnrel3hCwa3D6Dn8qx+Ba6Cl5gP+CNeiWL3UVn62/iSZgy40keOUjuWhHpf440T22OJdOd5cisFCb93GjTqc144vEZTplVDbInHxlMDz2r" + + "8uNvjEi7qgXOX5WKde9YaiEl5P27fBcNd1J2xhxXYL8QSCJwHRgbI0jbVmVZiwZMCwurNBL1iV1xI9pb2BqvqgrYnG+Fi8+vd/8K4qKyJpJmo+SG4osMyQMT" + + "g7H9ItLuK0DHnjejuTZcymuhsRDPdprKAJ5S+zPI3lV7KBV2/Oj3IPpxvKrrpKJhVg3r/aEDmEz9mjkQWySoU+fFSaNy1gqhaGRyBmpaCt72cghBgs6TloNY" + + "SVCtet8q1g7OKpLGicFlNkmFbeudDGM8FxQc8FvN+3eZyXYl9M82aNNXDdf3LJuFamb4n3trxKyS03P5jZEhNaSXm63ErKqNxaaAebCfSoodX3PQ2WwkcY+p" + + "njq3H7/AK/bwmFAOaBvkmrB2G6A+luRqVx33Iny4f8JWYniqaCUdZA/+vj/qoKyb4qWobQmYIbZwH2M60oH3YZBN3Z+QxG19KuV6RefqmL2NwVpDrrLLfWBZ" + + "DufmLlFNgtEjlcPWhCqXMUkErgtjxyVNGRCVvJ6hMJ7WM9W8CmwiG8SmO4/IN6Kw38vUwbfvqgS+2On2/N0f3B6fbrPxmZ9EQ3N6Yv9PM2i2wPhw12FhKa16" + + "fUEladT/+PCVNzFM12tHEJga09+ESX2qYAkedeCq0mShgDv7qZXl227Wh3Bc0hqQk1MZVpzaxj2ToImramS/M5JTnzDyTNWsw3EnrdhVMm32vzAyUiTPbUzS" + + "DuJGwFzXl0phlsFflSwx7044bB7AJpJR18IOP45tpD/n3EKsq9ypW7KjZ2mareigT1/zzyNRt04maivUz//39wpih6L0ce2gVdnjp13bX/p7j0F28CuU+oWG" + + "G6/Q4Xt0mBxnj7HMyuBkK6C0Vc3cj5Hd9JHE3SKsNz++LHsLPccxk5z/jNp31r8TIL5zmx+5VLdtx+XOvdg5DB13zMKqpPTo8cuMDn5sddhaAL7rvyqK3+cq" + + "vNa/cnjn+L1/I8Gisfba5nhZ7lafjzH3IH0Iz0jtbTReBV40Tdr4ARi/mK9+y0yPdEe/orV/bfy+NAqPQcG7E4uar1W+Lk29umodD2BukFuwe8KWQI9Xn1uZ" + + "nRppvkhLeOPU3fDOndM9krioDlL4F76Kts8GE8p2hkFwJnRmN+B8M7fRTrQ7Os4jmIVyo1kf6R8ZXHsLOnwHhrz1pa/M2LrELsxDH6YiVxvIBVEUzHxL03iN" + + "Lczl+ovobBNi0SFQDLtr4GYgi+gCKWj4DnkZWUXApxCiJh/xLJkD0TskizHO+IiKefwy+e4mZKKNKCAu22vEbe9i53QHuY6Da7LcR1I7QDjYdffqB8XlLtbS" + + "FR1YRe/o53sTBEStOv/dW66k6QuIEvORbOHj4Ffr/IzTXuNNMT792umWayUTuUz0KYDpVfL6r8LfGNW6nDdy5DaPKdYMOjVOjOL7e36DVTQYJqtaTCDP1P6G" + + "9q7nn+cGn3mQtlGc7rezwsnYfVHb0Izvn5fD7yr2yj9w+DKOslf5YskZVJDHqkZ/CwU3QXDM9i34hEpHv+jhrQ9DSwRQ1aFMoh8xMJ6rqovITgA7gHU4+2a9" + + "oMeUTXZs2rtDRadbhx7wcaXLOWPnunuQ08FAOGF1cTAo4ZxY90FMK8k+fsZ79t/ETxkHegF4IjzGGjvMKyfKTcdRkTVqYtIhfx1lhbFpj649RCriX2J61xvH" + + "0SHw3snRtaX7h897eF2i50/DMvWlCOPQcPLkM+GtLa+LW209pPlkA9DHTIK3WSaaFpzwa8n781l/omSvgVCmn2iizBhFpiFZBTN4yQMQAWeKpRn47HR/92QZ" + + "mqBXlofh94nW9JLGX2LlZcLPbnTqjJPH44nOv7l56C9MtwLQA1C7JPpk9+TJzJBsTsKysqlgmJypMx68WqDwTR7CuJKLBiHd2Ugfr30yojbHwGH9z46cWnsg" + + "fVYX7CaFYixIAa3MsvyXlO7/F4jnDv+EwT370Wybhv0fJ9Z+LohWvJ6HR3QtUn0qXf2E9E+Rot+QBQzfRLgrXMLT31s3LtXbxfkhc4anvrJvlujiFAIPr0OH" + + "DA7wCh59GgyKoBQIcAiXgEGPw4AwYXFAw44FBihSpEwCCcuSTKBJG4MIkCyoeJICBg0XElKkqmBAGnTUKAgRlkok7NgwgIBNSgLDsCjJoBq0MUkAgZaKEw5h" + + "wHDBIkSqDgOEaEdFDBQhqQQG6iXbFnYz5D0wdsLTD1o3yM3hdMDcB9822Joh94DRGV4/aLshb4ajA2Yf+NrCboa8B8ZOePpB6wa5OZwOmPvg2wZbM+QeMDrD" + + "6wdtN+TNcHTA7ANfW9jNkPfA2AlPP2jdIDeH0wFzH3zbYGuG3ANGzy2IhCGBCouEKccwQLBkGSJSxgFDZIMqJoqAUMNmhQUlQiywAgw6TQKETasJCTIUNGCZ" + + "MmIRBEpWNAJlXBhCpKwiwUEIMWy6GFCiZAEDyqApB0HItGUSIEOjAQZtIwoYokRFA1XEhSkiirgSDDAYg6aLCiFKNhggRJsyYJBMWSZEEjRaMNCipoCAw1Qw" + + "0LAcmCJThAPTAIEWaaqoICNkgwUhpGwDApyWRUKERaEFixYqmAgYcgwDDKuSITJlHDBEEqjgsooIMmQWWFAixSIpwKTTJEBYmBqwaFOBAZIhIxbBoCpFI1LG" + + "hSEExAoWPYwAQ6aJASVaFhKgTJpyCISEWSKDNjUMIFA2ooApqlA0WEVcmCJAiGnRQYMwYJqoEKJlkwBCtikDBkmIJVJqUcMEASVqCkg4DgWDDcuBKRJCGLQd" + + "FDARpogKMlI2SRBiyjYgwKFYIGW6asINhmEZVFQssChBPWqCBN+WZIlIQzmoGGhNkKjSigsQjjzuDEFiFMkCxCDbwlCBBjzFsnCzD1Cx/Fvv4x7Alx6zP4Cs" + + "Z9AUA9Jpf7jzI6M4+no++lHY8TDA/qEBdZxjOlqBxhKuTHzw/LczDmY2uF7fO4m+9lfcR4JuK5gOoRjVcsLeyjoMWx+dD7iak/TUQhFvx84nObf+N92cXs4s" + + "1xZLrP1pCTeUAmE6jP/chG009mp0J1thnpVz2fWiUegN3DqOL+qHDsz2Y5ugOQpbjyAuwIBsVoVU30zmCA78yfIf6Orlv5+q33uZX5ggIIK8kYukDa3V7O0d" + + "CE8FQ1sJ8c8GtdBVI+Yzw1oxuca7cjBGGB4xlZwJ1GLyO/UX3sbfKmaUWIjcqHd6B9xfQNi7rLqGo3f0JfNLcf0I4HvFvz4r16td3XVv3vjZlMlvfljaajYz" + + "DE6RoYDaNN9Gmn2rt+OZ2E7ejD2Cd8O1DmSTA60lXhYuyvI9wqfXwdiVEQ/9iVGAel6auL9HDwM+jhwk/w4lVZbflQPceJFN3A/zBNsNfWofLz/MzT+dBHe9" + + "nH95jX+No7WJUs0SIzbKWgq3Govkd1H+31flxGCZ0Y6/SQCnv0Nrj+//Sc76r/Yx/w8P7B9dsdLA2iuT0DzTRffUTRy14vXahnOjA0wn/tSaAOpeABRK0BZx" + + "DlRMnaoFQ6/FABD4A2++cHbWQwQSAqyC3VaoEID+vtxkiGEE9jtBws2lVS4EhrDdNluK3CLXMBWj9cRXL5gi2v9u0qztlAI0ATUBJAFBMFbde2/3puPGve69" + + "qUAgKa8DYoF4nQWiuZYV+AP8IXItK/uj4374EH3YbAJE8CvZss2FjO1HuIAZzDaV/Uq2nW0uKNhaHI8Wm2225Wxji0QXUbThdScbn/o6robmVmKNjjvVoCHS" + + "qIm1r1TLtRK69jMmVmblmiiKNbFWoiYyIYq1vff2uq21XuF1ekW4ccdtraLjTip2Cp1iC2khAfsrCYnQQiMjLHurtNZCWkiE0M/QWkh1c86g1+XQJQxJeN2J" + + "xKrly7OOy9yqZTWbZRTN5ymAlL8S2OIg5KyCCb+SS3iGZwWZE8YlDE+Vxhhnr8P33g1edzfcX6U+vGr5Lo6IrwaNbwljjDGF1hAnJEdWjmkZM1MYt1T33tZt" + + "LQBb3vorNB00dXfUvS0QDGBt6HU25D4LAeSMBoOh7o7qgMig8TSByCYONJLU2ElDX+7efUGUvKBBSqJgxwP/nJwaDTGG3FMzc0c9UdMr8ioAwH9FUdm7Shdu" + + "OOcPOVMZuEJIcIeVMRZnEZcAIPXoAeL9S/Usc8pYWs4iEEFBWlE0tT4wOQTJHRUGvGuOuaOmKFDPzmqmqI6MdHfTzkojTWSZruqoc6YxqneRgPuVQK1jhkYy" + + "WJqlY8SvJMaIMSwAKMS0HkeLmMWMitl7e93WLlo/8Dr9IFxt3HEbQYt20HHagd26gbhV73vvl/3CBHxpweyt0lpfzUSjXkQsXLR+Ud2cM+h1OQyv14We+Kmv" + + "4/J/YRfmkHTziZxzHkJh6E/krArDMByCGnEwUGGIGmEUxkgwEiQXyX/4CD5yj9wj2Mg1gm/3hjEK3/BNB3gTBf/vV96tvFd5p/I+5YfepbxHeYfy/uTdib/G" + + "oJRM0VlPyalnGVPJl7urSAlGmaxMkJazcSXLoclgoeY0X6h3ltJ4mi8yg4zNTY1LBoemdSMjA/gIM3vIMyiGc+OaobGxuZnpKX3QHndXvaqWMBjpMjI1Y+ar" + + "hbtzq4qO0NXduR40zUlRNDZOSMs1JVeVA5CiK6w8z8eBmTk5ZLr6uDMjUwSjE+xF8sjIHzfFSCY1aE3N2Kce9ac3fem97570oxc99//vV9zKe5V3Ku9Tfuhd" + + "ynuUdyjvT96dfIruwE4yaDVh5IyUyUoYuKbobEZTy5iZpqUPSsKAUo/605u+9N53T/rRi577//cr71beq7xTeZ/yPvQu5T3KO5T3J+9O/iR7kTwssDPWWmut" + + "tdZaa6211lprrbXWWitunUN8QctiWXHrHOILWpYobp1DfEHL2uLWOcQXtCwtbp1DfEHLyuLWOcQXtKxQ3DqH+IKWhcWtc4gvaFlX3DqH+IKWBYpb5xBf0LKs" + + "uHUO8QUti+WiyZBBpsMCm5sa1wwHHNcGm5sZdx9w6kofcyV1ynP8QWUykmaDDU3LA81IY1NzYfzgqsG5weDiIOPuBE45/EZJI1GqBlg+qAc9UVjp7t7rxFba" + + "rHMCX+w0eVTaayRPsmdCGaPJSJ+SwEeeZM+IjM1o3Uj0jWqZmjQSZbogLXlk5M8oI2HmSsA8aZ+rKbqSPqWsHM8f9ORx9wPu/q0pOivTkQdGC+CTluoLNZHc" + + "P/WoP73pS+9996Qfvei5D4dKqHMXTzIyIkmSQqEDIxogBAjDgBhIUhyLKe0DE0DCQWHicWgUEALBYCAQDAyDAAtBoMFgIRgMAggEgoGgYEgIimjhN3eMcHDB" + + "Gi5O+HDhhSkuvDjHwxoPFqzhxYQPK1y4YoWLO+M56G/hxQR3PDjj4YUVjsVuWDHjwwoXrljhHE7XcMWLCW68McLHy7BcwStWTPixjoMrVoZzE7a48WCKOx6M" + + "8QyvK1jijQUz/ljh4mJY3eAUOy68mMaFFyPDuwtLrHhhxRwf1jiGy1U4ccaGG29McOMxjO7wihUL3lhjwo+V4dyCVVycsOOOB4O1g/+3KcTDhf9mIhSt+REQ" + + "1I8NN2xhO/Pdtb6um/VlznlVivaE6AttiuI8kNqTm7+IEsrjqCbZ3PrMPTRi7dKd3BA8n6pRPb5mWzo+5w77KspCjnnIwdHuGofn+2HhXf3vhA24+0AENgRV" + + "TYMiR5le2GjvXcOu/ER5z82xTpf0OmppEH7Lk1k5yS1j6V0BnsysPptZPUjidgeFeYDbzTs3YKV2aXO/WpqPtq0Yi6sl15PaZq3whBwIzRgA0HDjiV/L+spt" + + "xQw4ZF/ipmMtFjU4WwDAiIC2CvnXfh7xGmm8jxVfZav1/9v9invd5Jf9cEm2nKtrBQ3YOcNESbPAy4+4PNcR/8kw+CtrEVyJjn/tugBl+9c2wePGHI8/kKtZ" + + "Chw970f55bIBe6xvMgX6sD27W5MI+z/VLnQw6/iodv5AmihcKwLn0dAn+GN0tg7/AuR2s8rD0WygBJ1uQ41GcCvS5kFfy3sfnFY2CW6s5tJ5r537jH7PtKFX" + + "00aZt6ENw6ohfCxuY6TN4Q6QPMywX6V0BvspispkH6WsDPOnlM5kPKHsGewrFJVhPopSmaynlJXB/JWiM8xHKD2T9YSyMphXUVQGgy1RlkMNFOYUgUIcUqQQ" + + "h4wpxCkBhTJlNVIyhwRKxiGBkjgEomQOgZScQyCpBx3hdjuU45syqs/HbHqo5cYvYtnjyyp79pU3y1i+lNHp5fesoVal6rxP+C4XLr3SIgYsL6+SI5Q8q83f" + + "WDg5UEY/9o5h7g27H/b8ZjWVrM7q7HGq5rqbDXwrw1cyR2o0Phh+NIv51atVde1SO/f6mCuP+CRTyVjut+J/uZ329v+cUtXDYyawdjLHxfnIM7bWLGIN3WFv" + + "uYh6qfO8DAh2iruRLTz3YKmnfx0q3RZD9emeo4SW8fDG3NHJ/rp0P4n4adp3HGq7kdJuF7EJUwjpY2E2IOvTjizJ2RrJ5TyiwyAC+FfY76KKvbTi5u/zXgLr" + + "cTN4O7GNdJwDowtskDDujPIZAk8X2/IbLLZbkUs9EeH7yLKFTyXiL56BNxdmiHfvCSw6UyN8jZR5pN34BMmdLRC+Rgoekm56ikVj6hh9IwWHdDc9waIxJYau" + + "MZA9lAWnKOkIvIpk4KVIBl6NZcAVLBpbx+gJdEJPQCf0ADJDTyAzegYyI/jhuvXrN7xnW93hfiZ0X1fRi32NadiuyA3ySdZm8BVYCabsupLmYkH2CXjut9uO" + + "vu72RP1NeTX3SsSPNZEUKO8DplWZwIhQx3kPsHbqCETEAsv6gLcocygmFijfB6xFGSERBlkFzhy8x6fBujzmX6M1PCdfozG8Tk+zbXgPT1NrMLgx9oMlnRY4" + + "eA+umgwGLEHzstN82kzsdvO6NeHfiIFiMiBhQRq3vg97ZcsPW+ELk7zwC345+oU3ETOKWOb43kBcXT71njPh6wtrP/RmHMQLtM9EBfc/uYLvkZe6u3XtAQNX" + + "507qDi4tVmp+fQs58xu0cVkFD0JAYLoOGLid4ttDuZwoJZOCL/4v15ez7aUGYdjbKbDBabD9rdB3V4NvSKTYSONTK6utbOWrMQenjn1qhRBY1zqGoUrWw9QL" + + "J/XxyszXG5a7UDD+6ELKtZ9pStPvhGwpkhZXlRgudTm9x6M1TkG/we9v/xVdLdGKLjO0i21rL94F0etRbaPLoHqPi6R/IkXyjbctrGW6cGwnlwBQuFfTI5Y9" + + "N3icWzWXVi9sNDgAY1m8qbMY5X2rpqupE7O3+3YsL7vezmdVNrJVXTP3vf1xlkZdSPnfcS2q47ksOCI5/GJHEURwlqaV8QTFAki3V3Uw3Av3O6+vCZr6ow2P" + + "1/E3mLqqJveORes9hXQI8cEQY1dU/pdei4pP6Ydkgw1wEZHI/2KaH15TWye0ZtXhI4bSucz9ySMYj/9a8t3In4jEegIwW7+Qm6CxYaX9e1T+GWxrTllfSchB" + + "vNSxgX7ffB7+0EojCT8UMNGvkVVjMpW5wXVJ5X0d8Rz2J4HiVespXx9DSGw1iomh9tV81OARLpd5BSNTmbtT/5qUi7dhQn1TGdRy3MlgTWqluh4oMIynqL3b" + + "B3F4SNB6WXKNa4Pk+toG5UKfG1ibqlaP+yo6BNf/lB7KHbIQTzsc6mUgIeCAhsYrypbqtKrI+vHRAOAMMpc5bX7uTtwbHB4rX4Ux6dM+Jn1U97j8aA1C807H" + + "fefyx4ZgGeng0UYGLxoG7yYvrshrG23TWDTuA6vRzE4AGpwEm9LbuXMnjDZ2ab5rYnHO+1pTxmcSYhA/9Wmgb4fQIN8aWAyTNVqLtCZQqyZmZsY59wTwRI17" + + "YBPl4c9j7t+YhljhqCBqPT3l2laFa2HMlo9hoBa8wGZOpzNf8kdBKAQjp8k1OUvwKy6zyTEoysjp5JrMYvwvy3EL/KoIXUh/SFU8gUULmrI845PPUwDa9Vih" + + "S7DuoeTQnF3zTre9YrN1iXCJO1C0MYMVGhv31o+cFhL6XnYxfA1D3+LwJ1+yqgJoRxsWT/DcAAXWKzmNJtiWSrM9NtjFrQPfjQe8aLxouABZV+EIZwCwAodS" + + "DOL/RWxBTjlyv+/GFhgqhrDfIQeZihVEV0L0tp8PVyhUwRoR+L6LnkqZ4EUBzLR4CJiMIjv1kV8vXitOYZQSqk1mezsOCqmu2Bd0QIVpFUuNnm3s0Kq2xr5q" + + "PCZQfnmfnxGYppwqcygjmJ4SCn8jxmFaJaXJ64u8wzJ3EN1WTcP55PsFGIPQrz/K6Aa47EhZ86daXJaZZICB9ofH4XIJW61K6QfjNSAJyFyetMVGTXxv8vBD" + + "05LJuQxFbIaEteRIBAwaGDovKigIJVccBmBmlr0OW5AqtZ8jYOO/utWimjQMm9lQF1sAyWkd4PB2SNh8JuEMZKTmTc64SOC+z9xcKqWCHYVNdK6yNaymJlZG" + + "yj13BOClUmrXzucQ4KhUctSGBRcF5VolMIAfSlJdff5pwATHi2z9cIzMNN03DQzHBzESpGHE9HhTzrIxsikSl99mQFwcHwzSFAVfN0QcS7YFpMXMYCW/ph7M" + + "4ePbuTCZ535VUnuVy5r4W4y62tLB7uZHnVsXIxlivUt0CHDOBe0RBpxoO16diwL1rlpDtZh7VKxvQmibq4BlPhsU9/Dvi+lZmOq3f+sDwAAUvBUYuZayf8e9" + + "qA7nsvi3QV5zVjsfsWClzeEd7QyYtgdG+Fxe+ows5vuaoLE/g+C4n61iFdSwgrPFe/MApncKxtqrHiAfDVbN4cZvEmwQD26sst9lkIqM7RsKNejZfEFux3be" + + "0LU+ojBMjHPuCcDLWjGbRyTmGIJx8B7qlk0cqkn2k4jxB4nr5F4WMKSsiqzZHw1SweUSTIfFyGgIBl80OJxoYeQkSDK/O4BNqaRRfZehcJpzLpZA4fbbsJtW" + + "vQKmhQnzON/WdtqNiewfAHH3WUXLKNdbgVs1Kvqi97rVQ10al49pCNuXOCAAPdfNIxZc0XJ4Xy/YEfwrPLLsf37TbEpnGzJP6XBPE+kFm6Tz4cMGvEiSOGAW" + + "MLReqlCQ1UtJbhDyoLbUWVVSuDt/Cs2GlebvULnnYa01Zf0kIQZP24NQgymdUHiMXs08YdEU54MV6b4i8RxpbKbg9nqKy68QJE80iu+1Lw3K4HCpbLmBkQqo" + + "hk8azOYrrbR6eTCapbYEa5yhNZ8SZOfvBtJ05eLcKoluJxOe+7m3m7tAFbceP40mKHpKfFYZ7QrL/95r0XFF5lZc3TY7G10cJBzMtBseI/WqIsQArZNV6lX1" + + "nPqTPQ3UhVxFGu1uw+ISzh1Rwb6Sk1QkPNoQLwkSD5wFjO5LmUa4qq3kKgQNJ4FNaz639YZcGZjtKO3vouTP3V5zcPwpQQ6Sb01Vy//dXp0GV8VJ/IzCBno2" + + "+RruoYdAhC7wHYXxwBh9BDriSNkod2neQ5AFLwDmV2LFpdbXX79DwEmE7cLVGCWhRe23mzaZNHaYMj7aBSMxCWVvatIwr9KCyfPItGElRi5N5eI9yGYO1dSx" + + "h0d/C+iy6ISocAKQ+HIy4XmYc4Ml/M9ZPvh06LEYLYqj98aVQzOtzLVwRe1oEVw85xKsZdHkOBJPGZThePXNVin2+OsY7IbMpXpgueENCtytwMOan75eACS1" + + "FF6gxOcXo65v6WB3e1RNGEkQnTYbymUkqWBAQ8PrGE1oKCiZHaqTCZTKiO0EkOFMmBSymbtzwrDhk+a/cpbnsNeaMv6TEAfxUp8G+nYIDUBTtNBeURiDLtUb" + + "2ppUYIVPOKffhk6uqmUf2PRSh3k4tqswynq6ZZPBt/QBWFirZKioOmqiBTYpGXbFNh9cQRGMnGuuySyG76XNBkegKCPnmmsyi+GjZuOGG691lVOf3JTlruvb" + + "ZO3G8cnnD6ATUj4kEK37KzkU9woB86JLcBVFI8VLGmuLmqjDav0/HW4IVhdtixUwmOcGzQOYG6utnjVU62dHl18vykNJLmOD820DuRhIBAxo0PCck201uqJX" + + "gT9BqmCDviGwge6pY3VQmPeGLgcWeWgyDoVnxUZdc7ZssvcUGyw+HJk0s2LaLvpxsmosD5AqUKZHCkVo2szLLE9hlePyUjJfrL4UCDstjAc2iaJYmQMEzgB6" + + "hsQbUHBcjTMGaaGTT1ZHN7CYEWVibNlfckVmKkr8BcKUZIkaUZ3C0rS5PUqGwZol6UK1EyOEIgAqnAellFJKKfUEpV2ZU8O6Rg1N/LX93929snsHsgF6AZsB" + + "3o+rtbatzlOK3NFRdTaA6jy/fJ0nDiad55DcNbFzzpOMnKcX2YactyhynjPkjoScazIOAneqjOfMeArBnUzGGOPuBWM4MOZauOtgzBmAsYfTwNgHvpOCawW+" + + "2hL43lwh8B2F925P3Hu3mHtBPVyuvPdr494NdTkL7t26az8jy+lrOVOu1bSwXJBrtSRsHdbaOqz9qGDtBoO1Yu12grUtQqwT1oJy2MoVqTfYirJ1xlFnCbZm" + + "UetsoM6aWrmt1s4LdUJQa0eHWlmo84BaJxGVdsSg81Mpt0alWxB0jUrnEJRyhlAsKPVMQek8gxJBKaeilPuAUvpxUbm8b+iGhD4HlDEw0e8NvLUmNwG97WBz" + + "aIW6CYA/EejdWrgdVrt117DDoNojg37WvshQmI63MvC+oCZuDtp2qlgT8lZENQFfB2IumECJkgmM+ADZrQmtoBgqplohK3SCYoVFfDQ5kuR0ZMmRmSNZloFa" + + "TvAOxAOnC7Is+2haA0qYTMBDQzJzpAKUBDFLKsiggizLPBnogZkeWhIjpwxONA3MnGZilswcOUmQZVmL9v//////////////TySX2le6r005b6xvtrheal/p" + + "vjbhvLG+2eJ6qX2l+9p088b6ZovrpfaV7muTzRvrmy2ul9pXuq9NNW+sb7a4Xmpf6b420byxvtnieql9pfva9LyxvtniWmmRIkQsFBdJupwUybIsSJZlcwPi" + + "dg+xGaha05wHOMb///9O/HbvHqrWvw64APyX/iv+L/DbvavWNLuQ4TjG/////3+ti4umcDbAnSv454acY+SbGO+44BBAOSHQf6rB8X7Y35kCmqE7FvS/sYBU" + + "4AkH/jttgD9YT2l/rQ4QBapZoX8nBvD12z3H2Eqq1u880GJOC/jftjgYwP4/EdD/O0X+yZH/d3zg/0z88+L+nweB8C2hwZG+VuWjAWtsYBYjd8ruKGH1HNVJ" + + "1hSg2EPGHbgdHkzf2w37K8D0vZm+PTz2B5q+tTdM350YG429tTX2nuWuYm+898wbiL1RdmspbBWq3lw0zZoMmTyeLti0r1bD9ZZsrbdMa71V0R7OWk8kWGuN" + + "owMeMpYSYWApjrEOVC5XTZZl3I/O5bRRqSK2bEZWiNpSIymyjFBPYk/GkKaVIdkJW0g3IwzF6sGFJmkraR6MsJIVC2tElcgaa1zkCyWyYipxlWIBx5RLlWWZ" + + "t7IZRSikWCOSr4yJyHKVKA5gI5llGchlEokSGjE+Qa1KVihCKWtGclWqWuILxrIJS5GMlS3xRhWGSB4QADBvhMHE1shqhSIrhZIyyrIsBHJ6cCWsNYoAgIlj" + + "BzauRK9xBSPFFhRXy2aEwcIsy0ZCQhcLRYojSYY8NlJcpcrwBRtVKFhqLGGjjYuVZdlI28awhKGkpEIbHq+xK2vCFQsHJcLCVYqMvVCuFpCQbpUqQydaTOUi" + + "X6iWuEqVopIVg4lki4cDIKRxkApLWMsmhXSVLfGmNX48EBQX+fG21yimWGUpwlCglthBqUSYiyWEB+kayU/nJYocvGL0fgULU6iXkP//////////////////" + + "/////////////x/vq22umN7buql+NpmO99U2V0zvbd1UP5s23lfbXDG9t3VT/WzSeN9scQ0fEZgO/EAlMUtmYmgwEW8iOZWAAI+uIyNjJQLO43XAkKhrcppA" + + "Og+JNCqRvC8IEyTakLIVlqGTJxwgVMvoCYjMnB84aSnKRopgN5nQacb0cN8PsKPJSVo6DvgRcQPsqGgQzeNGNB/oEuqAyPy444474uBQMPOITA0p5fw+onnK" + + "UTQAcd8HFHVgPG4Ezgf8Rp8AkyY34SKBJdLLiwjskJw6qiUhY2XKmyQXcPN0nohzIS3BcT6PuoxImDLehzq50JF4A3YEALvSiwiF75u09JlSwgbyQLDTlagT" + + "Vj4d6PlOpSFElOPkUYk0gajCGYLJnjDmBSlXDUpUhWS5iV6oaJkMDcz3fZlNa7RRuUgkDQFWaBMja7Is82bZClcpUgQ/0KhUgqLjcQG4zBfKBge+UPm6D4Z2" + + "MBMEU0qDCxD3QuXjYGgHAwcp3ngTxHU5az6ELRuQF+JcSCyrCfK8EZAX0af7dF7o45VIPRLwDABxSD7ua0LjkkOvKfqMpJCxKDFWlmUe172UQi50K7zGm9TY" + + "mWX4xMV6ieaVOcpgbJ9uXmHhQjC7DVGEja4Wx3W4j42akVWubEaOlFuuoMqVzdiaJepNMDcZTSnhvNKKuUgbUlS1YlmWBYn7qFQNXkszI0gE0ADDGgQAAkEg" + + "inGYgpDSBxQABA8OKkwSGjAYBAYMFgAABhgCABiIABg4EECYgCAACCBjUAhwYUAQtRg0Ny0UmMztxB5BguraacB5Fz35uZ/6yrloFBi7EbBeNBY4qrzZpR57" + + "WAQDJNSL1w7Wo9l3U1Gw4613iP2aruyPmkzlCAJzjSvRvdNnEkQCcb+unl6NoM11a+yDwZd/Iz8DbbRYVPyLJu2oWDmF4JRYpszFV2Pv1lfsVdlxVUOmpRgi" + + "zEF76oPB44AQXQNsNwr8EpZiFaIHLtNYesA1F+b/yUzPmD8dajl8vNwG6xxAc+ZtKvfGXoaXAuBbfLZxyNUi0nr/+/OTlL1RicA0NqBUyvuOkefom4DL7B9F" + + "P2wjjL8BxwCFehb/gOph6kggqTRLFvGDjHaqCgtTdvKNS6EYJnOfGbnmBb6Z5mBr/8LOyg6FVxOh6GNM1o9D2rjTJwqyoaJ/9qPE2RnGMwXLXfs4CG5f6z2q" + + "Ro2r6rgM1I4E6cPXJXt4w6xiWOscpiQxCtRhr368cDIywnbNTmub3jqgru+de5F/1XK5bJXPqaHVm7fSpHgDETfQBErmWthfF/LMtulmNRaQQnKtFpLRc4hb" + + "z2G3iC+XH7qDgsxLjvvCqE5wLf+SdetWf8+2CYofdeMxilwxKKy/HhFPhaWDP6rHvV0EXtW+EZl4XKq3uKGjYICcXaeBHTpeOnaNAZxqu8FMhElRr6t0b+eA" + + "l6ADKOGtepA4fGXig5FgXk+4UXAZzoehZfoVORMCUCS8q0vm2yRYMp8s5VARqIW0SgdXrWOsyfzeZ/8zYDTbPembamjynRueHQ7blhhqUxvXcXjHw3JiIy8c" + + "NgE+tbl4342AhFTkx+i3jXWgmRLIu+SBFiCPM506cj2+u6iAwmFdY4OMKXLDvtLuzVDuWukkoFfQz+ECxDA41Dn6O1eMP93sqg+bCmMu3z6GUFlm3KX6RD6/" + + "QxE8F7DZKmmvVlnhF6GcDzjX2lWfoZPrtvQutNrnVGT1pqk0UiG/PshwSQA9qx9tF6aXbKVCbaO3jQEzHOsevyn8cICqMZP7QE94BIYMDN6SiP+dg01rmjWI" + + "cDPVAD7HV9leKsf5EO8QoNe+pL3ecTFuHbkXzdcgvITkRkyH8p51U0FBxLfztPpjcjXW3LHG7OKk4e3ihjGIIphBhRAq5tqr/R2MFB6UG75spgXAz9J8W9Xm" + + "dmXxEhsdtfeULyA1F3/TYcijXu9eMEjkqOV2i8HCPVvyO/TexD0j2daMlO2hj+yB+g75yK0XuAmAAZ8Yj993Z6UT8cP79yD62l/Dz2QWZmwjpvIwaiBhqtK+" + + "1/d/nlF7tM/+F5L+nOz846ddpAtWInr8FH3w1Kt/8b6NC0cBkaBl4MrGqfQust2zoPoXQjjA7EptAZzH6y6UChFs0N6IhBMzy2qNMdv46ZbB7kKXNQTNZXeq" + + "nup77W2E7YtYdxj8EUAQ/1Zi6GY8bER3G4DWdr3APDfQyyEqftyUpILHBvHMuHYIF8AlYTt7iwTx595A6Tvv5u7OY/NggokW60FDq22MrLmF7nzYep25oike" + + "bghMw2YsAQ3tUdv/XpmDfL9ciW+X8unbR59hfoDvUkuPrnFljccY1Hf3i2DMRjRxD6LQ54bNqkd7PHgG4NAkjO43UT1cEirHzwtk/vVanKaogP5i6g5izhpy" + + "UpNdcTJzB4gZnVXO0wZ6dUzt+SPg9blZOPntQWFg6Ga9s9kG9brHGo2Rok4LTghMUaHuGE2T7wfYYoGme3gBdHP12bXKAObp1/v9N77O6tEmyePm3O3mVKB6" + + "388Kc8LlsAtKjyAqvCxo7V/vs5I5YGx1KPjdlR5Vv5XgclGfDeRVw4AV1rQaMu6QB2V4XvYVi+I7qypEOKrRO5Y1yK9HYLBiodOmoM4hqKAHS4d1HBr1XxT3" + + "u4oXfAjXFWbOQJWGoLCL9e7mW93wrhgy7wY0gxA3MjWjwJeughR3m4lir12mhN6i6+f/+jA9bvNHyVmws9RToTFGeyFWv/Zig0E8eaBVj0Xmgo+ow32v+epi" + + "jTXgr+mgiVmXdcIi6v45Bib7694+fEWE909uBFXg5XZjozFrdO5eBd918N9Aof7YFKyD0WCd3Qpo3U0KU7J5BA3abb5X+OBG2R2scHUYavlxFPRWghI9+c7G" + + "g8HOjYzxYUMBlKmEJsFkSqVLjgfrJJ4C52/m14/ccVZAoDuiwMAw0EdQSFG1tqrkoQJ9V0nxFhYnOvXeAnrCjRR2jrAgbqSdikynYOl1Zv06g3cxesD8hXRv" + + "qBv2N69h3Ph1kROXNjtivxAUXGbdGGkszS5c9uRCk2gFFmSLsx355apgyhM3Xhs873G10uPJqjHWvnVtJT/VTkxqk2QAnjjYj3p0hRTz3ss3/QIReXnVTg69" + + "G+0scgESFwGry4lVAhaGF/hjulDWO+cELbc/dplI0n8p/fR1QwZhLU1xVBrzABMXt1Dhh8TSPnui7uWqFov2XUAZQ1K8H0nuyQ3Z6mRF+x0ylO0t0YIgbxBj" + + "whYtOuo7M4W+rEwnJIhoWISECLZIv1VRuvzxauL7opq8xpfJBKgby4XWj/SGjQmtzq+kO08gF7+yXAj+e5ZMXNqByVpH0DNWo/QV8vyokT0l+u9N0MosjXrB" + + "EKQ4W2Gy4QKu3nD090Dr1v3L/DjB3W6WhScKcDwc70fqLtPlji9m1qI9NMLLSjEezrdq+fXsl4Bl63CYeIhirZpvrjsAPKmmv/TggCGWxfT3Yq5f+RxCazwD" + + "Jk50fucJ2MLHKpdRkGp3eCfGg69fExD+0ZeUnVknf+SMCEe9xBEP8nJVgyzEbwOuNc8B9y9RRev+4Z1nwQEaTrpXqi8IbzVKeXBC5Ecl6Dd1HJfC8VRUgfrE" + + "ef58i94iP7uiyhf3LV/Z1MsTUGc/r9PRV9l18kw5FoMc44xNSfEi7eJmomtnaV2ji9bSJLRNnhGnczLRC18ZneHnpnfZj/Wf7IroXPni3fXndvVvs3xfCW/Y" + + "iWqcYRyte/ir5n8DZ3w9lMDxPDO7lTy0aMSMRkrONXq+gYdz6crfL09QvhKZi97N7n1Z36NB+L4i3f99ZXGXLirLDzAJFZdVeu6Tro5/mci+7JLMihgbAv+W" + + "0Kz4KaZ5cXa4jV0ZepaEfl/N+xBq8nfAd2v5GfCJGUGoHEPXbQ2Fnf/2XCj7OPHGM0oDq+WTckO99uAy04zMLUNj2uZ6w3GM/8fTiYp4CuJJMnkYxWBGa1fS" + + "MFf9Pp0x4/trlnJ65JUlSbK0eL1QRusXi2gufj4rMaNxsuGc7X+Lq0Bj+NhZJoUc9kAY2br/athYfZ2dMe37doZyrqjJMZGO+Zi8VBVrvxRpMublrGEjcwyl" + + "uK//Mt1BY1hWmaRt8b9isOP2f6Zpx+rM3TSKd/PFuRnyGd5Iojwgf6iudTPPNCNfo4nYtvFZU9zxO2134iIe4DzpTHyigTDl/qaTmHY1um+Y43vNU54CueBL" + + "kiz//C8U0ZoDyLQ9Ow2UMVVzW0Bxjt8DYQVX8SeNJXUVdwYI5lhWDzW2Wn8jJuzjnVDknCpytIhIj/SZ9qke22tjpq3YbxqNcTUvIAPnOH33GQWiq64/iYY9" + + "qtnJGVN9zykD5Tg9phzngM8M54BnhnGAvIRTHc23YYRz8EOQJhzgjGEa8IhhHLjMwJLnVkqg/zNuc4+OJg48RDMHPGI0DlhkQOQdq1Vo/xyeuCNCFwUN04wC" + + "ljHMAR0xcOVZd8H25fAhrjDaOdgh7TnBEeMU4IiBe955VdB+GTbKI6Y+JxqjPQp4ZBgFLmJgwmPfVrRfxg1zjNHHgYZo5wCnGEcBiwwseQcGDe2P8SEPYbRz" + + "0DHNKeER4yzAGQN6z8JT0X4zbMsVhjZPNEYzB1xmHAcuMnDKM7EJtC+GV3kF0U5Bx7ROCc8YpoBHDOg9N86K/s+4da4wtCnRGM0c8CLDAMJ7QC9mFPkV7hhL" + + "mUDy/yzOsJ4qn+8qXNlHxtnIT0LP5CQl5OhXIoFQWT9YfeiOSLF377Zd6ogf5gY/B6QI8xbr5KhTiwUN8LQPnrHdxeKBOK/ob4h74MUDGJ0h+KEljIrmmWj4" + + "xQEJ0StfQPDRy9RFooXeJ8jTmWi+4Lii5RdAKA+jr/fDwuXi0RH/3QjD62VfMVSt2ij+i5THYuyKEx0wqi7Tjfpb9NLM2UJZyCIcv5ygWBy+sHs/AuaAlMfy" + + "okH5Tw11EefGiwc6MmbqhVYYFc0z0fCLAxJaJgidcRhwBf+n7M6izhfuYbSIz0RkERQ0Ej3ooLRJg4MxyGKVI3zCKEK3GUTUwvWG5vmFw2vp6/nUowwq+ha0" + + "r3LKkS82YFQN4/HVd4HMjJodZ6OeCjmA/HkssXA6wztEG5wDUh6nhQL77S/1Q0D6O1IauYBASb9rRVB7XPTh49+kXlSAeGZyHg7D6F+dieri5SwObK5T2NLm" + + "L6tHzzL9F1Rf5VY3JzbAqArGXdN/4fhy94Q7o3KqK95WIs7QrQsjl7Qi3hYNMIoowj/du8A4Yfvp3UA3odPjJwBTd9HFmqfdTOAc+j/aeDfImVwcftFjDMDg" + + "cbLRC2pbvwz3F0RkC68wmui7P1yRxQFJhBRBbOzuoppdNEwKfMOoFc5EwsIj/knYru9u+1nIEYIcgVFDs2cJInxxQOqIz0hPy1O8kcWcEdEkjIrmmWj4xQEJ" + + "kawgaBGe0+ucie4CKaPngHT7ozl3JhpmcUDCTThIPuSWyRsXRwOHRxj9xZkoEYsDEgmpQef+2smcszBNE/iGUTueiUBeHJC6xIueZtNqgvZCakpgAkbteyYC" + + "Z3FASkd09F87E9AQFw8TB0YYtcWZCNDFAakkodFnpOxMkZ+JdFkckMA2J17J5oDUZXmxNT+8V5dFBZSnMmAhEBi1aoF/ZvuIJHuTYCwx38Jt9PAIRv9yJqqL" + + "FyKNhH5ftHgTWAAUmHIBRuSJU8ZCCz+CBIACeC7AkkfC7BpeeEIwHZA0fDQcFVR2xkJoXp+7PlDgFxRGx68wOokFlTljEJrXrFQfFHALilGxAJKciUSDydV0" + + "7PMSh8Ha0DFv8dCzh0Mfaz+Yxo0UUsMHba+xUZeRB7xidiNK3ntpFpsSFV+BJLZwqCIbUgSYchTN4slZFULhokCSoPZRcIsVz/yw8BVMAJTcAmFp0eahhRlP" + + "BOD1BasgMdZ4ZzEEbX5g4jhY53phZTbsT8QFoEkh6rfAYXDYNdbCoJGwRkuKynhxU9aGvTAsWmyATV2UChbuNrUsZoXKDmCpi7KCxViN814cx6miqZ8v2zsW" + + "92K6UBn2frGgjClEwChoZHGorCx4t0d8xWIBWGRZCaPsWwuz5YkcjIfuH6WEDm10Wm6RVIoskNRFZimkDGeLzZKkA1wuDkoswfJ5LYagMJr6mEu9I9+FG0ae" + + "7YWFv8CEAIyW3CJhadmUhxeGp/6ykqJnGHWgBePfX2WXYlVwWVxmhAl5XWSUUUr96GKoUNkALi7OQIIGZ10MwWwkdXPBYxe1i+6C5H1FC6biSQKuLTCGhFtz" + + "F+ryC3oYLWKL9YKk85LvGTV3QS1LapDIQqaQRRbMFxYLiQawuXArSMTq8bUYAnJFE49RiX/SXfCLEbf6w+KvYAEAo8p+QV+2FJtDC37xJc0iC5nP+YZDpFvz" + + "LZyyCxRWuhiVWsb3ZtEtiBwgyEJSIUQGdb4YgnuFs7ydQzjKXazKF+eKXDgGi4TKWZgKKx71hMUZWDAouAWpKOkUjxecxZcAXFvgLywc1ZyFqrziQcQWtmFR" + + "riqZxRBoKJQYTu/CS3DxLFciW5RFVhmlQPEt/GUXNENY/EssCMp+gVC0lHHQglmeSIBrC7zChbtxFqryCDgYJeaLtZKl46ntvuLcxRCglUp8r8FSTAfJbANi" + + "3tgfXIsmB60Lh+/blADnvzIs6MaIYQsHvanBUcfaB1NDk4LU2EHbMHYonSUPSnGTgr6dw4rZaOCHioMHOvtSmuxukpIYW4RTYg8oFuCMHHF7C2aDwq+ZRTEz" + + "NNYtLfrGD/eKsig0EnU0s/vmOP63DqswJ8/Ohsp/fSI+oqvXZhj/xpqVPihAEQ8RZdl6lpE7jcgQ5e4Yw0hK8qYE/X7Ex/hhmGLlGbnYsQR3hyzBid82oZcP" + + "uvzB+TVKgBvjwyiafvZ2VuTx+7eXENM3zf1bD9x8lhREz7D8QHdLWCxJYqi+FgcK+51B069s5xAmrv1toDv+TNZxA/rZ2EowFNJX3bh/buBasOYsd7mBbl54" + + "/Ts0Pd4AJX4wJg0WU0TU5I9g8MeaKyHiDtS0w9/fpQGJxQUu6zaplYhwozd3gfLFgs2IkuEV77TAoJYmVNN/Aqt7+MKF2XjAHGsMsYwJK1jGEiN8YRkPjLCD" + + "M0a4YBlLjLALZ2xgwg7OGBk0L4oB/MMA2msYFkfAGqcNIJhCVV1HEBXRtG1BMIWqmqZp2cZUXUFw7B1ZQoQa7XpaZGSTEs96fmY1aQCAiMju3oSucxIApJwk" + + "Ufwjdne3/4a2kTcBUQFiAS/sAr8s5g2jAD9vzrolN2u9lm3NSrnPs8XZ3MpXVo52VNJ5t8ltVssydy+f2zbq0Q/iSFrXopdZ3c5jh78sonrWvedQuzIRJtJc" + + "v4oyDIsjjG9Ot/Tnej1Odpy82vM6rdPu7GzlcuurrfXS2WrJrdOyxn29nPSsztqsLz/Lsg8i3x3WtYvvotxZAJAi5YC9KMMy7AYP3bCGwryFZsIsskRvC3Wa" + + "4znWZQClHZC78u5Uv1L9P4plVXP1ODQonEptbCSN9jQ187Sq+X/WKUVrJks+K/Va6ll39f+/uvfee++917KqtdZq1tZcW2mttdZrK6Vys7l2ouiUU4VzJU6l" + + "qCmlvCm7sbbTtm3bltruyp6qprGk5sopTdOurTQ15fb/rGtvKp1y045kWbbTQU53LHIthjvsmqUDWQw1QqeRaWREkjvktmPbkY1YqBEGwjRN5tRtbHJ1erUz" + + "ErqhO76x2LMY3ohgx30H6DQMljkcxELBCG2QZCIs5NpCGJdOM0CMyLIsBshEiRM+WZbJ/LBYUcLnhE9PjJ4sy0w5COvXfo2uLK54euYwDYkEZiWKmssQGTkd" + + "cpBLAaLnB+gFfvFC1fWXEWRZtqPCne5de7r7QvxlDoZdw7qGwXIPU7pvIRy+RZ57VuFOi/qD5WSfxzcOII6wFBLt7S+HRxjmkoEsy0pYx8CgfCDkdheHeO4k" + + "Dm6VCvUFrbxPpxLgnTvenWes+Qa7FtIil3sW4rAebWw+5teIymGoRRXXsTAP7c75Hm3kLmqYKIJ5d5mruJ5fXyoc8zekAvlYI9x9jz0LZb5doGv0dtconjvY" + + "5aEtxIFdz0HY87KoeR7KYu52xzOHc0oq7cqvGRsx1N7mOVWOMlD6f9LJ7v+butj/N1Wp/29qQv/fNGT+vwmH/H9T0Pb/I0Zaq/X3mh68tffWazq1qBY6tUwt" + + "GKQUKWW7Ui4o0e5V8leJhR+te3/cHxWsrb12ChSITqAJNEHKzc5QCZpm384MiOClZa+X6wWCtWKrlWrlAXVCp5PpxIEkIolslUiDHFrN8TUHg3q72y2wJGwl" + + "UUkooHROmQgJpKRUJoWAbqGl3/JbRgfoFDqnTMkMzCVzLplLRjyzBCTbmSVxVGB+jI+REZjXXjsaYG2tpQKZAPqFzi/zy0hHXpHblS3mShZAPpEn+UQ+ASCL" + + "yFvkFsmxOuy2xehgUbrNLcbDkXLbti3GxI2mbb/FTMhsWtu9Masay8VWLpULDaVCJ5VJZSWZSCabxkQVRNO0IK8FGaViLe3GLimGsvZUZVQZoxPNQGeGmSEz" + + "SbltJJ7RDBjtH8yDyWSwtP5iuVhGJQvFVigVSiaoBJGBhVQavxzLsmyGQpgwRT1/GUDSSCQSTwrHB8bPK6bbInjCA8CsXLnrWOY6pmm6ksrbHd7f5jjIEcji" + + "pztclDscjuCO6a5jOxw/7obGXOOdDPywOHLljRJDHOobI9cx3Uue7iWOZ65FvlWa75AI/DxxBHlCIpDjme+AoAt7IBZDkAj8PNzFkOuouhOO5wXxsUeET8+I" + + "EzF6sAgWKlSAGKDiwO+zOY2+/AI5Tn69xhAX5Y7jfJdgmYNw043i5q78wiLXHIS9QE4AvkEAF3EibOxDXAdrMet0L5DrDmsx99KXY12LfPO4tsfB/wf6/xf/" + + "//P/Lv6/xUVykWQsbA9be9QeIx/K6QoV/5/i/1H8/4n/N/H/Jf6FjEh8j30UjRH/jwoh4v9RDUL8P2oGxP+fsnz4/1MUD/9/StLh/08+OPz/Cbbh/tyfTIOV" + + "tsqImKj08Xkyp0ZmAhLQAhMYcDAgMBamWYxCSVJ9FAAGFhgablRYKEwYEBAkDAAIJFQUVCgAAIADhkWDAAAYEg2AQiMpDBgRPjG48EuB/glBESt7saJ3VvQu" + + "pXqZAgdWit5SZnF137JSe24KjsukYbIbM2fSYLx+ZuOqy7gtWztMmsDQXsImbqYHVe3weDvLy75ZDZzl+IuER62+11oZWtbYT4ZaiJlz4K5q4xhGCZOCMqpR" + + "UGZlXtxCyavyL25gENwJ60Pbh8HT3RsZwNa57HqKGT2Jw+n0YjG5Bd4RPHlkafomTGUs3Nj1WkgHHi3m/OOErW2JOh+6YOZqMJeDGtgKiMX1Hb+maJ55731C" + + "L7zrp5t8n6k7F+7Bfv5lfQxSLB4EkJrXNr/VS4xm1tsdMBcrgdVPYn2riW17V1orXrV7GejMqWSd6Ui/dYKmj/lF/Vgr3+8vUWc9QKKBdHzOgMkPt6mbkUUs" + + "6l6Zl2+etir7PN0fZO57vafo2crlg9SZK80uOGq8w5Du0+LVYSgeSW6Tx/F/kvnhkeQfcP7IyPHBJo/zB8xU6KGUL+488qkyyUPmwoY6jKPrcGqCzcpKDLyT" + + "mCS89xE7O84bvz5xUfDH2hXIKydueSxbwe9B9QD+WyXQv1qS/8vdOdn5gwnxrwDncGpthwE4v736T3HapgU2APAob+md/VOHsvVw/GXff5tjdRbXpXiyKr+k" + + "SVtEvstbMuFRgd6JILb10X0pM/HRxlnKH0GoV4Vvc0Wfl3pCBFfmS+rdRX+8tvgpfPm0dUf3MMRvJ9uOb2rstQKLYkMUjHcuZk64e0HUac6P8SdjMGQWJ3D+" + + "7+127gjsYYV65UO9xJcTAlpS4W7joILkpD2OZ386CWGmVl/KZdMQzrCXx49kkn1MRZu7NiLjBnd7y1ncREyrMLhkWjirBCqHJe2S3P9X+MZiLJsK7Fg6PIU/" + + "mx6sPAdQ/QTjNwXsjpRE8BaS9lIWL8Ua39V7TgUOHyNpuT1eMnC+eEBVJyFA8TJLWhPe8BXVP6N4FgSXao/xM3Av/0d4VRE2kpHOYbmiUahJCTg0g1IrI8BS" + + "ECg7DxbEfUvEXZ8dkcehKMRhDatwnJ8r6cZI1nyNyNTwuEBcBlEEQ1NWKJ43fbd57ZuidyVt7jifXpRIXLbrO/OSQit4CBnxFbQC2d7NwfPuNvGMfXJGxRvp" + + "hdqJ04a965d0nTSmjRqftxVl8pa/Ms/y5vB9OwNMeQVeIt5b2cJ8cp2YCzJNVLixpJOxZgKSd0usTLozRrlf7KVKUi7XeRLNIBWhybsNaEr9Op8cMuZS3WkQ" + + "YPZt79r6E6p4GOY/v/J4HuuDO7Dcjtmr3UJbWf7dyuLBTCdok3rPYS3f6hdzpXnXam6vM8otui+yHCxms8RLt3LH3u/lvM+UlNmRjcMmX54VzvdWj323Ionv" + + "M7sSNd5GK1LO2zfsXfukyzyAbdT4PK0osLf8lXfWJYduUBxg4hW2EtXejYXfnUvKXXzShBtf1ArV96YNewd9bvUnPC6UPMB+DNdBk5xLU8XGCj+trbya6s+5" + + "qqPv8Od3jvrk1oOnZWZyEPFW1tTGZfXBXU6tILfwTq28uZXHd5KUJcfc1A+KnhbXiRtply5acwmXz8xp3xtRVWvsiHei09PKTFugk5jRts5ag4uW8Fy1s4zw" + + "mXVy6Dvz/InGTXPqpNpp076t645Lan5atY18qdX845tD6flkTmPrRE20sXtYp42W1kwawEZgzNp69RtE/ozjVnvjxPlTq1l8kFaprzGtSEW0P7Ygd/RCcexB" + + "S9IRtUNs8kWvkzpLLYKnsGxIHz62xNBNx1Ici0H5Ovl8aYO0gwPgVfGYhfVviThhHcjX6rvb3jB/d2w/yTsmgdaLThNY6PbMwEAPsCy9oREhra3+5aY7f/ly" + + "38Q6txLQTIB6TT4kcaRasWXvd9z3IcvTxJTbgJVI825OfnN3ng6muOutqJA3doR32vFpycQ50Eqce1t/v8MrTxiuuDKt9I5X8skb28kzzYkjbYXqe9N2e299" + + "biUmsm3KyTOJH8xzwCTn0qhmh9AveCUPtgrhvRwpbt6b/UFZeJIGILUCCxO2t6OoqOltvS/FJKm19UKCs/OkYgJ0I3URhfOgyRXAnx2n/zVXSRhpAMN1nPrP" + + "vBFuHoq2b96jaVqamrc66s3+7tK5QauIOKljJO7FHDhcSqKFc3EiXgRLtHpTk0rU6GX8t+B2BBnn7j36HpSGkRQArhW1iLUFw4Kgdubb+KCyeNI2Hg/SsMwn" + + "3OK5paV88C6v7E1wTdYvF/jCbomPTDppkwOeUvmu7RcKEXtjvZrmpafdKYT+dq52tXFFtsvnR9ucm1zXwGUvi/BhxS05it5dslNWUzKcHScTE9C51I04yUF3" + + "K1Le23hp/kWvjjOYXFePm72I7j2fAIfrJYJt7rwnh59QAOUiVAElDOF/Qtdct/JWWGVfapnJTYY/nNgrcGHy7nnyz4AFI6BmHEDFWW4Hp3ZiBOaTOZJ3JQdv" + + "NV8Ci/K0CVARh6HWr2zw/EyfpMFQGTC/34anEKdwN6HXPdzOl6mQif0IJX54K7oOH5uIspzuW2uuxhJur9ZcxI1oBcv5YxN39lP0tpzDsUQeq0qcuEFacbhn" + + "YgRik1kk67OybCwxMMNmRXIuM80uTCYQKw5hJUYoNplFMj1rlscSA2ZsrEzOZdZMK3onj01sxNxVmNu+OeQfS0a15vTBxtyIGLRyaejYRB7JeqxV/ktUvqy4" + + "52jMbRZMOtZV9pusKk6ZiBljiZuWr3gCVOYAGcuhRS7J9tbJOvRQkwBG9ypPVMMF1dQ6RB/AGT8M3J6cnsMYcOyw/98h1AwhyWKazM7pOMysAChylhKjAUDN" + + "3GGHc82Z93Y4B6VQDqEIuMU6uT6l8NkQbcDC2hw0ZjmzCAjyRiwA1X/L55DP7U3VVqiJXWSHCp0IwKT57KIOBL6u6pV0iNb92ucPFMeh3IXjqEkzooxWPR1/" + + "j09H6cxoIXCkJYKVTiI1tIsitxpIcikzFY2C4qfmv3EZW3OtmeaFW3u2mm5Wjq7RmYin8aC5D7uC7bMCxbFlNphgvR+M7ahBmsnLLkDIoJr7Q4ivlknc5xZs" + + "wHMsBj3bKmVl5Efs3CowIDjpNq3ybz8rfshzhI+T+JH7bhi8hAjd6jOJyUScvr8JpVZr2AP5l6wg26xDcm4p21akoPM3qbDmJuFt++aS/5ec46X/RpNza+Bm" + + "OXfIuNrMN1mpuDIiYv4lA5BKGCTnRizM025Q45dy32SlYpSJoemXCCE1IZMQuKi4/JuoFhwS8DD/kgGkJmYSEg5Vy7+JasUoE1GmXyKE9YQMhwJ13nMTvo/R" + + "N++FLjAJ4MH/khgop7lkzP3tu8lQCZzNlHJGqmgf1+0Hr2+RcPhht4xzvW1/qos5hS3J+PoZcoVc8k+aOXwW15tW/IHbElP3WHpKtZgrNlz81MFs4/K3+PrU" + + "qbOovDV2VCqoudzyog2w2/7QRMI0JQzvBLTao/7JbciIvpIKIfUejb/GyWhIXb1uqYxXM1ltefJXshwTaIUsIUr72X35QONWBevt6Dpo/m/25VU4nv6NFC1X" + + "9jAbPBTGwxwvot1zOQLbam8j+BH/y3gpcIznhkac4YA5g6+8iBxPCZ0ogmvs6DXsotp2O8j0qOODcqZfsqDXxxc2WZ5RWZl9bNULBqvth5rG/TcwH46/QRvH" + + "SE6abs7QsGMPrU/qENkbCf//qbc/fJjDfgG9xa/UTaMiD/ApIS7Sud0Y7+wP8YqV049r72T9oyF2wNmRIbpUFPnlhM6J3Pz8VumKrAsHaqPDdysH9FvfxbU3" + + "TnMU+Uo6KDQZbDt5zAinYNv+ePbDavBhy88HJJ5+PdT0OCajp87d7m8p9OcQie1NO/Euy+CuIQSrXLhyKXWocCPM7XCqsJdPozXnmE9Sf54MLggdUa4c7jql" + + "L/tSviH96OtmlrNOHU6HK/S7acebhvo9XuKZK7/KP+SCdhbj3GCsC9dznQqXe5JuHecSKrEh+i5dCcU8m6VRAnwXXbg7Jdlg3ER3H1CbrjaVbrMikbz/ELaj" + + "6RqnnVbrP+Cd7/egzT3teGbAdLgD+UjkNFfKbf3G7bAYEplOcSS6PnJb8BORrpsSb00ixv2b3Z8GvEWsvh93jpH2lb64HXIa3ab6jQ6pk9zW7h+9EHwgJPL0" + + "iufNfW7aF0/k9sxuzrJejFv5E1OjpuX8eFU5c5zP5vbvQCunYEIp+U3fnmrgojNEfuofVxNW4Mus0H6ukjDcudALLjP+p3T38xTP0RFYGlyP/YO2ve1znGfy" + + "Tv6YbBOHUH89dr5itnY3TTb4pLp+3K6zWBAPuswnPE6PIfvHuO0QnezFuOHKePkKBzAccH2WbcwP00LJ6pAvG3Chhvrt74frEdRhzXcFwgtBOAEEd2ahOAYL" + + "epsE66ddDNar5qfgx1HGX6enomLT4cLE8dvx8NgivZgzN3BY6w9crB27oOwd5C0EkTWKYbFk8+ByFQ5zTj61zqcKo2VQGiyD0gDvdS3A/09sH6vuh4PrPVpI" + + "5NHAZoi/Vap7v2MbOh4unJC4tHni0/KYk+Z9SKf4YyFy1DXGbX1ukMlwHPlhw4gdfUBpXyvzsAd7VPTpTzdgmfWZN9fAMc9vrmHLdeJavFxT2vD54u7+3rdK" + + "6bTDDrqF+S6T63seUOHpi1WlwnhWnxxo7i8+tyd2y79o8dGSh34womIrnMCiIGkdIwg2mXO4y52ELc7VDZcb6LgexRl+8o+IJJ2EvbRRcaaaR4uyPTiwuWLf" + + "9HqXUQYshwn+hY0UhPKPc3sBBEd/HJ7Csy328Y3bTjULLVDmtFZf4XiOUAtAYwh8FF79NbBGUW+/2ZqrX6+tj9GIUnUpQdugUBC3S9Ev/8hf6sOTfRfVhTlF" + + "bin2uW/n/iGm/jnnqoR/tsLFf39iPLfI5z5DprheiCjGrU2B5BJiyCf0dPm+j8SNVPKft2WCfWqs3D3JhVtMjxWXm7RZKaWWhJu6sHZnvMTU20LKLq0lhh2t" + + "vLCO9F3oaSWNvZXXhO7SIZi7tQwet23f5cjOfHX/ldCRH+629FNsn8Vb+wOWmgkps9Ml3pPar5Uioc5WPlFzrfbO5+Vq5etakCbS14q86TbTXH6+z5ji3/g6" + + "q2snnPGz1aGoQ2BMKCYuDL+7UQVj3wijVysN04GEkSuzpn69HdTNHQiM6h07jZRKPtqe+RXWjtXKA9EQ3GGK8PBSe0FoVeFrwl1Sgd0i74dZUDaGh06rQ7Gt" + + "pOKx6nqFx2nlmxqJhtVqRaB13+GpYDvVKPW10sf2B9vWaeUxdb86NXrVuBC2tjAyE1wrWThSHxNZNunGEW6nVqmzVRh7S6Dr1cqjaNB/+M0yJN9KrmW9iLnB" + + "5m+SVpsk0kWOKEuAvVhT+UElVf8eV97zRjZE6Emiomerk9QRkK8tm45DcNF95eLltp2FrGZeVM1FLZ8crkJPu49mjUB9XVSt5WcmNqIaYJcrZaiXQMQZ1k12" + + "4rMYGqkiP8rZbeX2pzQljYLWc2dSiehZaEFvVGlyORH90suxY/o5Uu9FOLCdKoH4iGjREQz9u46fXYJHty3gN7Fge1I5fOJV981kxNtWEZtAt61L9Efxjd1N" + + "+PFEbeKfcOh+qvJJOGzjPvrpJsCC/MT7lD2Rn37Uf/UXvG81eoinu8FD5GzTVrxHBG1HtMMjyAmoEUTlWj/CbRtmk3i3/TanL8Gl9TNg7GyEt9vxU50oZGe2" + + "Swz3bpek6kdT+PTwKkCjON+Ib6KEbV1oRvFNY9Lk7900O0X6+vEoUEVXEOIqYF2fu3WD1n/jDzXZpPRYUHmK5uEjE9Inlohm8oRZShhR5CQo7Cx//LCVfS2y" + + "7apQdXgPah5rr2lBwsGEPgf+whOVwhl5rKyjzV6dPeWxt+x7qh/PJbCsucB3A7Vy4YluJArf3qQn0ZtveUnTInCJLt1zxz0Q3VICnWwTqnLHlyBTNZjA5Iuh" + + "bPS7tlk0jCcR/fRWI+Vfx0tm9PX4U8rIRuCtH3gaMqMt4X+DCDaWguffaAsvNisbFOnHHfzIm0C3c6tBmpnHErvmul+i9UNGM7Hbua6uJRaHPg+y8ckTHYJn" + + "bEirbqSDyNmadtMYHnE6jE+CRustymiYhPrgaxFEt4lDFIhdi4zbQ1BThmq7MamH9+PopDO5iF2rKbtPI/OJR+z3fbw1veQSK2NT2g5k7c6+9yVoTitzB0xh" + + "hITwaNved4BAc5kBn0AV3f7FrubtRvHovo9v5FPzbACMNHpxm6xJ0ZqrxHLUlhmBesJPLK2iVnc7EH9jM0jFrCLcXGLln0BEU5DD1I7JRlF0SJ6Ugq57wLpm" + + "1lXfXOiY5tcX93KaC3zi01cjjrZketPB34hkcyiG5+hXcG9d6j4pgZ8pxRE9hnvGufgNdMHwjThWipadwxf082Q7J45FyqoPwq/Y08AjBkkmAjweDUVQAEYr" + + "nEgQraoDbgEUBKUiuAJFcAWsgkDgPCCCK1AEV8AqSBlGVpZ5a1uWqm1JykkWMbq6tt0RoOfzkaJRBJDDkOIIDPdSFmiLonXo7xSDAJwAgwAgc+ZxYvq6Y2fp" + + "61R5U6k9PgmYeize2sWfyi53J+CgUETVYomEqgnuTgrt+vjTwlk/mbGjNk/HS5+9ox2tb31mWHBq4x11TnFQOzW142NaUbOJ6ah/l7wH5CHtx4EwHZ+cX68m" + + "S19+HswABgUmozJCw0LauJiwYlJkMyu2pmXfvJx8AfVubUeYyAMJIRhzd1EIh8XZVr62bXcvmWBQYDIqIzQspI2LCSsmRTazYmta9s3LiYiEBgonSlSA0IcC" + + "pgPKCEMAKqmQAaFiYaTBAAwPjQgWDGQswedkU8Jlg4nIKnDxSRHzIUXLFHhQK2ZCrFywLQMdUM2Ilgx7woLP48bEC4cT2oMDFrOOkcir3drV2d0zPHhwPhCP" + + "49leZ9qLAbeacahTenS+JNT24tS/8UgUA12gg03HrAGuXKpVbbxleXGmMFRNCCtVgzB8xUDXl2s5v46zlm6VihjXuykukwI8rWOngBrFNAeqsDVloARyt6fV" + + "uVp4F7qfuz6N9iEhBnbJb10ebxWj3myroSpC7OXa1YszOZ0s0WU7Xh3O6TnmS8kbIfd0jmraeOeOYwM17Zu8kfc7l+9HNnP3i9cKZLk7CJTNXrEN9zoZl2Ku" + + "nJjeTcnyR6upzd0/GmKu4O6fScwVSPjmxGkSfVCdTSCeZ+LY2THtX0ySOp8+PqJPA9+S1tEJP8ljAG9z928U2qWp5PQ24z5qFJdI5e5vF5M5+3aeyoMJqIJ0" + + "TTRNCsNuUgoSBGMojsMwCiEaQtsBEqDAQC7ScRQ0yCBCiCGEjIhIJBJJICIiIknSAeEOle+a5jObjZcfYDibj/zvVf3RP8FxB4LBr28gzK6Se7MWfF3tK3/K" + + "xOdUKds5cmNkd9zbMJScggr9jCcKqKCCH5RMuv6g5zf/bDkvmB/FbfXuBgB8kUerujEvo7seVXK/mMp6cr57nzvJ3zc9YfdPdPd/VPhHKThOp80sm9qZgGrB" + + "GlNsDp2QcX8M3OtPzIgib586cff8g92OM7e9N+diSEJ/pY+RfFvax2RmWUu4ymmBzrgA/PB54JSo/m+/tooxz2a0fnZlZ0sgeFDxssFRhtJvTCO63qcc8LqT" + + "Hets1zjibzW/hcUCB/+criNMi85LfBxlQm9bPqPtxa4jczmVzauE34sAw4WaW5gOMd+NBgzVQe7+op0b+YYQJ3T0jx7wLzCvT5RxoyYHFCF3JFH2thA/ZwNe" + + "5C9x5Xr6GFZ6o2Q04hSZmwbCL7iZ8huGnGupk5gJ9GpW4vKMdnORFq0Yapkp9s/8moL0ftvf0CQy7uaw00op7DLTntUZV/vc3sfnPzL3D5OKeaCWuPQ0dIsZ" + + "b2jU28NWfyRGYrTAmiUvdGPfSJUy8zubA/fu8yEU7s8wONSjZYUtLcBYOVLR95u1++H8FrnmMazsKj5FfNGeLytgenAeczT+5D6j5zj8vpWZEjDqyHgxxowd" + + "7tm2dIJSGebNU1JWT7AwVpmuBbiQdx6Ckd0BtSNU8jh+3ArHosuXoRryek0TBwYJwVoJAA70/Au6/kE68U7TtakYxVu2he91cHcigy966UR5zqpyFDUPnyvz" + + "/ZX+waOvmZCufBEhxbAog5bD19dpvCcLHfiwqMG+S16OFGXXEVF6iO1wNPVStLjx0+TPHfGRMjN0fj2ZyqFLtmbHAz+E8gfWsOAbWH2yY5wr5BzHP3ldoS2H" + + "rRl0moetEpkX6IcHL/gHoyR0LrF/AmTQ+oN5hY53Df91xOOHRLEyncQrDXcc4pbTBmhg+T4XN7J1jjqFw6xXPJHTFMhrsfjHrSCc/oJ4/UUyj846j0zf+kLf" + + "jDDxa/1bzX6U++8Yyi5ZX1ek4W8VWDanBxxJMfxTt7b0HFsghXgZHyt7AD8DcWbYWnJKJ5+byzGWxnaOx7RHE2SVCs7i3qzlave5uPrtzSrdxdlTvWEBDvNZ" + + "GX+VZTqKhv5U1L6yOQJEz84nP7UfDKhYM83/B6oeqsjNxTIFi9QDHWRzFTyNrfNee59RBnYjtKB7sy+8iFufG6dsf87r4vyrfzpicaC59Wh9acbkN5Q/+wi6" + + "s/J21HKzLVfELAV03BYqdAW9zv/8x0NktktseQdmIb4BAbtUAjzMQT/xWA/qcqQWupgFdpTtHwu0qP2D6fcDvMAC0Lal4EfOZF7sAx1lUKj5rI0lpthcZrZJ" + + "woVAYk6l4clDlJMHYEsfvA6KLM4R6XY1CSqv5ZUYFtatnY/5JyRi12VG85O9puQz7jin6vnOnpT/Sa9dWcdlhquimsdxKoURhefqXqN/hopotOW0lMHxqF9G" + + "AXIx9UhtymwlAfNR3pwEZmnmkNIW6VoE51F9GQGO4twitZWylQCPo/xTEkylWfQYmWFbzIBhm3xxTnyxuG4dJlPakQ8za+9qHn/pWPo8/G88uyYmDdgfcMmx" + + "BkU0cAsy6oZCNn+T9xbVXC14f+uG9ScFge8BzSQJvj2rBXNqQuxXDUy+Bq/03/8cdtNw8A8uFjo29r56/vg78lCXoH2E51pQdsy+fRMnGtmgd/G7aS8nALcT" + + "ql+yyyCHILlnsCcr6VmBVqf0umK1d+QSgHlaGFKQpiEK4Wu08kWPvCxxo7tOlUPtEOuraLRkLI5XHUsCFp6dt1zMHEf+Y23HFbTXp26DNEMbsGbrP/G1Dz+4" + + "RJdfc/kx5Pv07Wu+MJOA+BaI3lWB25hU6VPr5Wu5A2tsWMlnCQXfAOeL85hIr37lx6ngfz0DKPbp30skymo7RAk+ZUVvrZzur1hk9gh9lhPh/QwraOoiiJdX" + + "EUbPfVQEp2H+uprgIRxAmUucl5tQnupl3oHrtZKRScLp6AOrqFEQb6soM3kQHMYpN/VA9hCCbtb4yRap3vkXIw3OLxKATQ1bFDYCs2A0lE+h9Sr51fFXAv/V" + + "J5fMf3e6/fQeF75itl4iUGMikPk6QDuizg/wvHd7DdQPYkNdpfyslr1zsndQmBywBbtNmnwG/6kULKc7uTO/OmH4hzPVvJD3JhYxZ8tNYY9fAQj7WiblziWf" + + "Mwn3xZygT9RXckA5uQFm9nmhC0ksY07mBWzy+W6c59zs2iGWPXr1AWf/2MmYS0e6b8Ch2VE6qQHkYHcFOIR+NH0ERUj0CiM7BUgnsU/mEEgi/6/3v47y/k6p" + + "7V1hO69ZFR1+lK1hk68InGB7ScCXIw1qqEJTSdeD9QuSQimkxetoVrpZQWNlU8rtDOyelRQrH6ygl/J6SBOw4smKWlZspeRP8XesRGWFw0oNK7el8C74Nlak" + + "suLJiroU0/MEh1jpZCWNFZpSxqYb3LICzYqbFfVSpjq1GLDCyQpaVm6B5/hgAw==" + ), + }, + { + "name": "defense", "size": 10110, + "sha256": "34ab140d64743b89425c292b785827fdb82c2bf92510688a4038461a2fe7a5d7", + "manifest": "{\n\t\"absolute_minute\": 362,\n\t\"checksum_world\": \"fb794a9b6cc7f0929bb4fd12a6cc916593d6c7df0b4be3ec6e5017d1db9588d2\",\n\t\"content_pack_ids\": [],\n\t\"created_at_real\": \"2026-10-09T02:28:50\",\n\t\"day\": 1,\n\t\"display_name\": \"defense\",\n\t\"enabled_filter_profile\": \"default\",\n\t\"format_version\": 1,\n\t\"game_version\": \"0.1.0\",\n\t\"save_id\": \"defense\",\n\t\"seed\": 91001,\n\t\"uncompressed_size\": 78904,\n\t\"updated_at_real\": \"2026-10-09T02:28:50\"\n}", + "world": ( + "VFRXQgEAAAA4NAEAAAAAACi1L/2gODQBABU7AfoTMTRYsNQMqQNoSVW4ZBvjW+g5//mZtBvIE7DwyjvvP+k7faM3OMGLb7cUqbeUK6TKvXcSKSGpwKdF6Acr" + + "XeRNv+yOy6+qIud+O99UiX8U1rT84o2oGdna3k1kCvwCNAM1Ay2MgMAQpVELLYyAdLeFyHHnsa+99zUKwDDPUMtOwckO5WfVtQgr7qNsVued+S/EWE7natfd" + + "HA3DPqMkhAVIIpWIkHWeUpZy23e35zNH6W4NlH9nZ4JDrr9xszPx3d2pdmI8t/scpJ497W6LpxZnnuXnPLd70d2harH/hR/rY5NTWV2DWt5cm+uj6oTy570e" + + "uxsktUz9NVEqU09Z+tSv3UIY/83fZTM71t0XN202Wo0pnSfLCXsmiThgJBIygsAImxqmMzoG5ddsYuwhDUo/wlz/3i6m8rxdfGxRe60XAOmWpvyl8sz1P07U" + + "fQyfZoUglZBOTEJGkEqgCBGjE5PurngulTVywu7GZOT6kcLDhwQg4GMFFVJAQfTBgwcGlhPK1/Ckpo7rbgoKTa6Pelinb1Z2Nwffz7XDvGuz36+fQTk/LitY" + + "VLhSsFCoRJWMD6k/QY+mIj9zH+Plw7LCpYKVQoVCRfTBgwcPHo/rYy89QKlYP1tue7n54LEJjbrb8vm6fLCQABmdnIw8eHjcP0XP2bsbdJEgEHICQnqAA0Zk" + + "nadHmWx3dzCurBJSiBJJBClE6OXE12KqKtfORvgoRwlNr0yvZDzK/YV42ty5h7zeyQkxdHp+2d2X1xo416nBamfFZ47xb9aE+bPrWU4NiRHrpXW54I/2ct1Z" + + "yybFYJ1WxfLddya6m+LEiRMnUi5hrtNyp/hahCk6XcKMnXY3Bo2p+Nik8FHekU9NXh9WO3N8GOzlYFYnhnnOwMgJZfVtsxHmlK/d7Xkx1d0VrOnXGp3VKetz" + + "3X152sc68fWXdZ662+puy3Vfy/4o3X3pwA0G+G3m2t2Ht884hbv7Uu3EE4W5n3IKHzVz9O7mnKpf+H8zlPRalNbydEyEqc/7OSO7u+LVt+62LjzQ3RVJbdbd" + + "Fv54O4v/dnfms2cMf/OsuzXdHapkq2HOK+7uCvm4c667LS3/Ofxg+NzVucHPHbXY5N3t6e5TtDR29/W6u9Jd7cT3UdC31yLu7k53h7rb6u6MJJMSiUQCJEgq" + + "hYiALpyElIywcFJipMl8Z+KxY3RSm602fndfXiY7Lne2uy29QdZ5wp0JevXNw3ppa3dfHXXUb6hgkFxnsao85d9YkSeufjPEJ/yJOgqkHmfeMGsXgtdmRz19" + + "WFFsPXW3CZb7C0+xs0DdxyZbQenHzJXZy3UqKo/zNk/zMg/zLs/yrme96lXee+/1iddJeI2E10d4bYRXhNdEeD2E1zW8puH1DCaYun4tt3lwfYn90oAcDRP3" + + "OUgfVUJ3hyhGEgkRsnndwcA6TR5FRqWRkJNRCYlkpLs31J+z3W3RMM7Na6pk5ASEVCqNgDzKbt1NgfHH6E39TjlN3U0xAmwtm7u7stmLXWsl9Lifr2dcqbg2" + + "x681Tgzzm7u7ooIa5zfD0sTOpPKd8nHe5mle5mHe5Vne9axXvcp77/WJ10l4jYTXR3hthNdFeE2E10N4XcNrGl7P8K7VYp3ROY+UfhTlazmuwy/nvY+yKI8p" + + "390gzts8zcs8zLs8y7ue9apXee+9PvE6Ca+R8PoIr43wugivifB6CK9reE3D6xmeRoOfmvxEO/hnrM51Mdru3lhSsM6Nk+JC6BR4WabutrxOyIMONsjuCwgM" + + "sAHFhdFxYIZubmr4dSCDDkwgW0uztbS7LRCYYAZcv01FcQ5vEDCDAWigO76EGX+XdXdHBi9oAAmuE6BKYKLf5d03+cDGBd1dsbK19wOqYwUVRK7hDhEK16Z0" + + "N2jT8rw2o56R57Va7jzjWb2X6vJKRicm3c1B+TqiFFIyIiGVkEhquztThSCNKI1YAIGkk9GJiQkJsHywIODycH2sUFWVCpVK5aXQmXYW+SjPpBzn3W0BZXdT" + + "5OohUWfa4R9RCglRIpF09+XJz0+5zUaIZe0s1lhkddbp299qB1rO6t+MtRy6QhSdxR6fPdPytdXjc8h2Nyd1c334lJuZdlt3b0hl6vU5+Hhe7nZdtSZYp9/7" + + "ubspJLUa/qtleF+a0N2hECIjLKTipJaD2f/mzlU7y4LbSZgCwvIx57RrZy9Fysv6yV4n1t2bq8n+N2b8GXIyG89zMiKVgMAQIaMSSDIBofCadtv8hCCdkERI" + + "Ah9RtQEr8wHq4KgwpN/LA+Jjk4MqAtFi8KXfXPl0iOG1CBIQl8slqzOTFw6OdwDqWXex7rZUuboW72MuHVBHh6WCGGgs1oaNqoPo6vADC9Mhhst1ASG6QFSd" + + "C0SHxYNXg47VIYaLBUJ0gaDhPspSdUDW9fFh5XeCzmcdi8fa4KjQrhtoqo7F8oAujA4fztVcGH3OZfFwLB0cFgqwFKBjkbhgLtblBZKND0+FA0rdLqWj3W2x" + + "rg4dnhFcIuAmqrurODVV9s1Sbsru/lQyVKAPH9yg+nZRVKpvnca5KhkqLA+IKgFB+MfTVq+O0e/uCqOvsS4/wCbNWBwfFzLArGWzVtVuLztElgrz8QKoSnkl" + + "Q3ZfbipM/tmZkNZiJVzXxqgSAw001GF3d6ZyohbL2N8E47xfAdq6bda5ZTDPbVLun3ac8vJuh+fT6NvMddafWUq7n9VO625L9gvlf53YpJ1ETVypdLwKTAy5" + + "zt4s086xl08nZi8Hn3bytYihPqPFUsvmo8CP9e9jf7nu/nSJ+9RmeMLzdndnY2bnqhNSPGPzalnW5zDt7kvm+W+X66MkhYdjE8KWrdtmim/UJ8ZfJ63+NMIU" + + "yIORL/1mLy8SdGu81kDdz3XCrM5an7PwWor7KE9NTqejPMXr3GDmchrqnQnOAzWuz+GOXnSmeXN2eH+zGVvM/Nik3X2RcmlzBgcP7O6OB8pZAVMmiGHPgXr8" + + "EAAFt5PdrSmRSEbooy75s5Ntd53ZvPZvl1MmVi1GgO7OyFhYfKyecZ2fEP6pwVP7cFPD9yuKzXBL4aWo3Ndidg5PCXGcGc8M9CrTM4ap6BkFN6+MuVYBH7sW" + + "b8dBe/EZTrnuvrSY3fQ6aS8H62sxf+DFxgrJ6Xn38d9T9IwvKtz8SHN+DLvbAsrHlmZQaNfO+1x3czrc/4nrNOwRchndXVXex+rUTZD6zLNODw5/gnb7rbsx" + + "8jfAF0JERiEnIaWQ1LXZZ98spof3M+npZG4eMYpAd3PeAykpMULxSJRCTGALpBMTF0xYMBmBwBKSCyMRku7ejChZPBdGJCClUYl0UgoZtdDdF6WRkBOQEiUn" + + "JiXQo2b27CtEsZQGm/7b+cXqhCkOnxJy6Hne587OPHNtF05CREJOSnT3pUdASCFIJyVGSj7vypZiU4edw1/lda27MRWThaG7LZOFwaIDgs7OBLubcbUcy9LQ" + + "0JAWBai4WYpvVkUkJxZ9qH/yTP2lk5DXcjowxTe7Xe/uqzuWlWFZlmVZlrVxXVtCyiXGBZR/bcQbOaOnPH4H09lJiD+DPW6gj3oKOSwnyhMnhztseToZ8qnJ" + + "cQi+tNvGA8qcgixw6k+Tcp18ueEULd1c2HLtRLmW6eSUkEqkEdmr7ZBASiOQrIqIjCAJkJEDRERGSkilkVJ3WzZi+LFGp9x7TtFNlFbEmX2zucNeCuCSEHJk" + + "TkeMRETAE5IJl8pQXhsz1bug/ET95WB3dzw8OuSUx3wmn6LYeoqbjMVqUWTUQslIievu/Vzx137GHOK/k6N4rYFiZZ0okEOjpc7NOPN1WS3JvBxJCAsmIiSP" + + "UH2UBYdHcW32OuW1G/n3PsaBwr8dnY7BEKReLd7Q9znOL4pG624My6LrzNWvb+BFU6xOGOo4zYUHMg0A4KOsyTdwnDefql9Opdq54VDTB6PPOWH6hdRR885b" + + "HX6d9r7W3Zz7OfrtTMza+dZlHOPPm/oo7Kd5a52dCb/5uZytT+l1E69vVIM7p6eNrR0MeN7ZXde8zsxmHTbvZ6pfK/00tWjldRPEMM9f/eSbzy6nrB4vrJ/x" + + "OXy5PvPN4jR6Mn5sVt9gZqlnn49Se1POcRXwVPE5YQ9BKo0IMTEZVZRKdPfmbbxPrI6SDrIybM18Zlwb/8JcP+OJ71ckRhs4AMWl+VwiRODgPcDC6G8sGs/H" + + "ul4YreAtoMK4NhwdHCZUJUgAwM57LTDeey0aYYioqgumEnWkVO5jrqqEqNpYlxIwF8mHyMWVwVxOEIIUWSY8iwUiuWA2PBeGiBIsJ06cqAEDQVQt6B7cl7VL" + + "5arL7O1uz4XzqUYfKRToWBcO5qMBYbEwkOFgLqCLRkXy8QLL0UXAdHB06PDBXCRGl0jkdjlW7suJP5aKYwNT2VyWj7XBEbKAC6zMxSLaAGXgYqpEWCwXONoQ" + + "gVAaDczV0eETAksKKtR0qUScC2yg0rFgMJqrQwQDHHAuzOYy6qA4YQVVjBuoRE9WYholHVNEMxgAACMWAAAoJBKKhcSRJGjuAxQADTA6dpowLiaexIHxIBAK" + + "DcGAwAAIpAAKxQCABhABUgxpp5wB4b6D/9ScozSfy4d9F4SeWfBz19caB1oJnhYbu3ix65gl9yLQxZf8PdwNLK7VN6vVi5bJoem3nE/JD7nLjLc7IPL+QW0n" + + "056KcEkhfjz+MEXUDvgdHD0fxUZGjUI8wGIXZcVdtyO5eK3b+5PZ6KY9lwGrdtXqWAju1qdjkN41ptEMrNdTOwfu49drkXZy8iV4rdru3m95odu8/pvHyDOl" + + "ayTE9GY1su26DrD8jQg/UA11v1OaFUQMmSHg8R5k3srBv9UPZu216Y9TIniD4fSepbDv8brNEPxaYRGE97IL+iOl9LWlNoQWpJEPgVHHBncHJv3m93PoincE" + + "ld2LKINThRbH0mmCmj+lLEMTD4G2eXZGKOWPuexx9Jy7jRGa+9jN2EeG/Mqj2cNr/z0FmCvovAkBvG7lWK085P/rO/LmYkCr545+UM3JVQ9H3O8J+p0B2Wy/" + + "2QKWx36egOzTG1G/Zb0XgZ9kxjPJn/gsjMZpELo04dGpyw19vv3oNEPYru0hy4aXjYZ9cN4HoofqV0PLAAOaLYLOTh263l0VuvcC+QJ2OaC1bm1N4/jiYMJu" + + "bvdlwzsfe+IRSbX4FvwAwOoJnVoaVKqt7wDo6uQnXg8s+0bUk4+0j9h/BsDAfK/uhG4X1v5EXqr7cyWh/5bQn7NG2KkZvbAvy4+ji3D4Fyq3hk5CS9RAkDHV" + + "PTM4Xdb7qiDLLZ4HfS++TJOpeXKH6c+dbs5se+UWY9Ot8nNw8H3l13jr70LxQNMswMyaA1c9uuh1J35PV3HM9wSAmf2aJYj0K5r4Z7L6s3bYK3ShD8KDdgOF" + + "A0qnDvT7R74E5Gl5qGSgDxek64VXGq6kaVVLGwNon3xSfhlW+/8McOzMYQs56D+ZOpaEnBesc44aBvfgE5V/0Kg6J9tNG8ltgO6ZEn3Qw3MHPl8OpfX8dCbH" + + "My33OhOVqcz2woLewGkS/LSgOfshYDOdNzrzJzwpCH9I4nCAT+M+rPr5lTNErwCWYOxXLfMWj7GB+/CTXi+zJH9F3/yFVJn3ETJLD/I3QAOT+o846sPga7TA" + + "EiNxddiA1QHzhw5b+T4Qu1Z652aIi/f2c7YUK47A6PCF1mR7Og7FmPvzejwDkH2tYwK/+RlTNhcedHwH0J4y05m/SEEEqKHQY44e3PoEbXJ8xcXA2U7Uxi9/" + + "HVOQ4CFbQZfyqIP4rUO9uldwfxNdGLeo7f3Fc8OiPE7ieqJPK2jHI5v8znB/4rcZ2/UjRhBfATmPpK2OEtrKXC4Vzxa+xyt3DsfsGwH3tc/0zv4bOWPFu5gH" + + "4TSbGz1dEhD6lr6UBe+rXn+zAPnFunj/QFCnLi91Fq2vGXPMUolvRNhr6ZEjk338Ksw7g6SePoTOElvg7W/g2JQp+RcWrxSvMyReNBxlDd7oi2G90fvC4QzF" + + "jtfVkmcDxTLPNy2TmJeRbCjqLa9C5yBMw18FMAH06zvsQqXg1z5i+X/+dtNn36GDB1nony0jaQJY9mPT7pRqLQ8xPYa9nHrS8csg5h1aK9jJHxROuA44bpmd" + + "BCZXeHhOs2dxJcmuKIK3ctavqr0y0M19nAk59RD2kqkJgc4oS+KY4Y8CyIMky3bBZ/f8RWzOIKsLwJtCf9tFwsvh2bBDo4nhijm9Uq8L+g5j8erBJf/n8Puo" + + "0H3C88Jgbn02LXcu4R8vTGt/MNCyWKV113LSp0bh32UrN9YX/GWoPKExu57Thm/nV656QdoOZWf/vewfrQvw9r4juMEVwHqRAW5LtPP3FYBog0Crh6dWXvy9" + + "jB9uVv7H9v0vKr7YlD9FAsvFp+bjH7VQA7Rrz/IBfUtac0kNFMg+zPXnGBU/I/ezZb59bNYgqbdHv89Uj9Q8/v6i6S7iufBtuneHYHIKeZlb7LUD1LKNy3x4" + + "YjegyElgD4GQmUeRhV/tdsJA3KE/OG8hriZD0+f735qGfJBzrZ0Npz2lRMrU3RV/JCJ88pAD8JOhj967a0HesXjd4H+8FGZo9o7uT7Qk8cPHHlc4OeFVPo7+" + + "0CMM3DNqfTaxYur7oRbYGGFoCOO8/gvB1HWsdq1dsUNC3on63CzV0KnMnrEsHn2CJVMsTDysIyTG0vcdTYWqOW6c2+iBt9DJC4zfOzYNYFayTyyYxWh8XuoX" + + "UH7I3g7CfYxm5a2EPb7eXtoTOHOWU+sPFETlWV/CPbtKuBr3DeQjd5ZqANFpOGs9D/EEfUGwuFOC6zebeap/jhv7D7+UG4TErC3/uNmPgN0snekEgwi255/B" + + "2+yu7VTjHyzo6UNvdIEjNUY6zp/9gk75tAhwMOX6wZfWc7VG0vYi60+7NMvPzwCpu7iRlC/1zXSVtOnsgK9sraVc9ojBWzaN28xfWDo/2ut/x8aasaNjJbJ5" + + "Rrf2vgBIucZlRgDro5+jpI2DJxdPLfWJ/be1gnp3LbHYySLP/7+tIT/Pm4zzORppzOK82blPyqHh3ZgD9UsZ3fdEHVyC2vSQlKuINpftg3PPtyvvjZSSGiGm" + + "56v4Nx3yqJnkFOoLumnkUJbPeXgj17s19r3RN29WFZPC4JKC64OxKpHYxQ5HkG0UbswsUxnoEV/BFFVEg+SgA97zsVqazRxkngk4db+xF3YPKnoN2QqJW5pz" + + "ta4Y8K/7V13PTMibx14jAMqs33EpR1q9Q+dGO+6z0/FrR7ecWAHLINNRMHtCianwxAdVtbhqoO7T/MbscxsmV20yJOMWuIG9wYJd2NYdxDFJnyuGZOeisyey" + + "wOif8EIYJPHemgLqmbqmrsVP5/c1lxLkgFq5UB+XW76RVsYJlmLcw2AhTIeVuAGTTTRTbA/2LjcOfKRGz+PPz27ZuQ/71dKO2tqVE1oD3cp2JBQAPO2GZFKN" + + "hdDBer2Q4bYaFrHuQzIwjGwdYb+z+0Ap9yVfg2e7pzHr3BPOJQVQc32rhZhKXPYEcL8qjlhNZmnHH721t2TwqhLI6ACc4nL6Fnd4cLY5qRP71dKha+3YCGI4" + + "1Zs7JhShpNjrKrrt/F7Cn9Tt7f7YVVIWOHJwCfy7VjLwdjVQARMEEUv4zoe7+tbdHtU7n3x7qEC4RAO8qyJPa8J0H/UzDLfdnb7VENLvoNBt6kKlK6TmO+pw" + + "D4nr5cCNw+4+VOf1GdR4F2qSO8+Q6P2RH4ls9zpQKk0MmqoPrOUyzcRwRLTvDk1SmKpwLOqLboV93fp+jnOt6ZocmuL3TB9cPYfKcz31dEsR6gId6OSXtJgT" + + "UmfGXawTer9f2p+rkq3a11X5ECoI4Emd1mKcEe26v3y1N90fslJ7aiFgLddHrXVJJlFwFYBYF3vtWb+dAD07kg1jDf+mjBzY+Gomn2g0fSFwsq7GHVc/2tVU" + + "/z4HBttL6WcRKi2Ed/nydOh8tS/rp3RA9jeNtqyQIXwJobpRotT8Peum8HxQvHt/MDKFOYHFjmruNrML6TWvIhiDyw4jhFKEiJtrRfoOUhVk91H4LfXOXjPe" + + "LpX36BFC3yQT3kqygzfkihbkcjyvuCc2/0O/1ouztrVpe3vI2OgbaOlvQr/JT1pTVxvnJ0/lPKQ8OOFOGNUxC4PahhZYMgzicd7UJHwv/Z+7Rw338L/GjJ3s" + + "3EOP4YLhTpCfoXqWMB832t2rPBthGrQyJ0+8i2y1tDrAmh0XGCGRLyS0GvUHpfcwsndk/ZcaP5carNcuy26FEqfJVU83vnZi1Hhf1a2eISj/ocbDTe3W67Wl" + + "8cVz+y6HA2kld6wiVxDDh6tJwLULAWRJ6O8VXyXtpXuo8+J21/brNYR5JzKi8zNiaA+DUXoOZmQStvjONaOYc7jwHJONhBRqoqEtekNajkG+c3/rs0J4iyqb" + + "/y7jCsNaArbLI0xqRPa+6L2Z59r3mJgGu0KCnm8KUwZ3kNaPafXr6duOYnGwYX0jj8stURPkgGztOoz1wA2epGBAGU/78e0AJ6tjWu+Ztrp6kKLCb7bLbK2v" + + "qz3zRH0m3cypwoAkpagYjTvl9PtiXmxKzuFHh5tre9eGSKVo8mvJVn/r7SGJQSeb7Mf+HNyRk0D119mhUrF2xieCRoWVgGAu091nVT3gGQ4EnbTc58Iy5iql" + + "xLh11d780LUEbRcrUjB0/rfeuID5rGEfPqq9R1kjMEpjoZs2FRamG5TBMteLkHybl8YPuc7HwS/Uc5BDtmClQ+rb4uaEP0nRNv/aNL7rf9Qu+xUi9HKJX3jN" + + "vRzQ6QnyV//fJPJCbakYlKg5xOrXbjy4fKCi/svDPEmyVyhhWuNDovrVkabm7bLhsIavrZh7Tavy2o0OEpFEQVVjp3CPmh9wPfn7x4t7BSfidJy7x//d7DdK" + + "2p/53/mS/t3CBOZOl3sAXjdf1mHuKyJ+6xA7Y8xcLvbJGkK5H/pRS2ClgfL1s4sWnyLxwS42p3IFN88xMpunSU1WsPdPEK+nHlq/FA8Sspjx95PVNz6q87r5" + + "RphaRjHJJf+63+FVprUbY0JW51Fm6CMWZwJP7NCWiq0A91d1HGJI29x5bdjFx0y9l/kuy/t/1l4uXPBXbmkTBw3wRtfpGD34mG/cgN42yFwQ6pbD1Vx9UjFk" + + "N510WoEvbj8NQgqpWDnzK/7CY1ryQkNfdoOz3eGOhvH1TgJlcj+/3RYMStx/WuyGSVl4L37WUOfpwL6YI5Ie+xbN4D3DHxnHq8bHyKT7sdlJnm7DP4OG+p6S" + + "mUu710YAAG1B8l4n9fa+6jaYBxj0SYveqPgdrZiz/nnIe474/MCPMz5PQkMhvRJ6uI3LsbjealEaDuBPHcSpg/ayDX5pNCrP/3yrZdwBe/LMk3Yv9RgIbC1g" + + "3sGHIcSw5Qs6uhMftRE/ubmJ+GrKcnmHsM+tmG/bNTnPNLusvaOFudXvua8f3q8i4A/6ZUjtTgSj+6kuhL5q+9Z4KYqPMvy0mQuMtjGX08drPFftQnWefPPz" + + "prvvvAwskN35/VGnu9MzyREAnRt1//Om9Y5CTGb7I0QSb8fAnMTP1OOnyxnns6LbVlEHaEcIuwsgiwj9XOQBsMbGGIF+UbnLN1B3YsW/Wja5zJGZq0ZxWZZW" + + "sw/O5K+h9PNQQPC3yLm0I0qt0/WOp9fwAo52i6de/e8HZntUCL+lWUm3IocLZRaPpXh4Y3xGogksCwzu7N0G3TKQeBpJ4FeHdIy3QNz80ntGOW9neKNC8TFI" + + "SWc1k9i/E2rLHbOels/QyodLY4TUuL3DHXopPDtkj1vVnzR/F/qO8xbW512zT2DxqZHEYdBiOmGm+wKgzIAIXQGEwWxxql3gCpvN07sQdJCFf3uxpxJqW2ip" + + "I7ZPLbyu2u8qp/M4kQHPC82NKWy2vP5dQNSlSHtfZmG8qINYUbMiUyjrwKeV2x4PIZrz5fhuJ4Cbie8YPZaCXy937M9C5yARw1Xmrt7JpTAd5Zwu9yNdae9R" + + "U8+UeIbhx5NR/35nCpdkC18V6yp/6w1LidCmUe4C8BBAfXdPNi94KHU6EUufJxUozb/1QfFpAoBjfNAf2Pwjd5LfNeBBNcsVfYbW/p+8V3Kzc1B4O7S+hLzT" + + "SuSiEkfvxIfGcnSnjP/nYGfk/NIkONCq5RxMZFARhGCD9AvZZrXDvoETWwXXeIUTxE/X6Z/jZplfq5JgLGB+nuRyTtnjdpM6mO2/Vltxzy0pD6e5Hf4nOMww" + + "0hcm1mFvKNPH5dJFmvgZc8fU5xgzICjKZP5EOFTz7vLwp7QPgJlLAvobOMkXANhvk5oAjqI2+U7ZEY6Hgx5wW0IoZRsi7fejE+Jl4J/2AeWO/mtn8V+aEtF+" + + "1rYz+8HyZlXQsZfq2tieEuQQXxJe08SxiD/OXc8ISmGPQqbwPU9dgM5qI2OelN0Hj/AxL9c7Gn1Oc+j2Q31GLkXxtyZ32XC0tEfvwgkF5LZLZmBlBkEqYxIL" + + "fSzHOUefmXn/m9mngbfmewv4d165ujlamnGR7rfEG+8yMKoyBu5Vuo1zv4Cdl8Wi/cdqbz7oCCHkLRcP/knon5WRLnuJT/JxsX5/5DmTY76DyavtZfRdgXKP" + + "TGyYYE+DHaaCeEw+2zormOIGgXkF3DprAWp1OBGJL9YHu8IKr4+VSnsou/GXhPAzzTfcBkwvp529t9y/m98MWb8vkHNCZHlhx09gLTTwGCYcF3ED0zpLH/28" + + "M4i0R2sDpmoxjlpOdX9eq3MEXsX8ac2IPedI3Yc93QG05OJN3yr9f4iifrmVHqek0+9zZ911BtwHvVlYyNcnA+zyYSgeCw+5fkZ5wFLamTjVRKHNXAR6yiKT" + + "Aq8pcJlCAZ1yzgT7RArKzKfZU4ozffZOQZT5NHZKcabH3lEQZz7NhlKc6bPb4P2XCmT1WZKdpfxwKEpKEYe3osjn0DeUbBxcQQHN6V0pFJk/Y6MU43DrFHkO" + + "8Y6SzUGqFNA53SWFkvOmqjF67h3yvAHNnO8B7Y6qv6sh65I+8Sun5d6a1DvshEu1nO9g5nofjFwo3428FsV6Uzeil7qRuy/4jm6FEVQW5oGLR6+WNAXWKujf" + + "o6c7dXkQHwYDtzZIv9+exqbtYq3rEYqhrwZ3hY4aVvCJ4AiQ4f/MBVHePbMVaJi8NAq7DuIZehEn9f5MeD8GpEp6z9xK/I3pEtY5YxZrjmgnMpEcj0Rn6EQ9" + + "zwAvf8ZmQbutebqRAnno8p8FZrKCkf612XXNZEQD5Eb+KlsXJXF2Q3jhfAkWKtoJCcQdqVfLHaMXyyC5n9FpOw3D5xL+j6HzPedLhuVp/z4aF354nu5vgG0s" + + "q0cunbqicNcpSRsZ+uVBYkTX9BDE1KfSFS8d6DOQdDc6Db50xB5Fuq7M2Xjori4ZQfZug8Rmp47WYWdgJWFzYCeiZjAmMVMwkxATHCaQKZwSkBlukrAZHJLY" + + "FFpJ2ASMCdQUzCRMxtVkrHT45/Q8aQgt9OraOdi6YcZuL9ylQOJVG+cu7tzeOh7eUmSAfPNdxmZHehpi9E3eJFiVVxZ4FeL1ljUHV6dV7LmFNXW5PpEi+Exl" + + "z1mkjPVE49uUYGJJLtnQwK1VSMS4XqVoS+W7jCgBJntkndrDCCXpcnZXjPvjBo5pTN1xv13v82GFod50e0i/u2cPX5edMGJzWrIM6X121aY1ooSJ2/6umPGi" + + "9ToPsQb8aSEM3yxfRFzd3zU1j2LHQngD4oa7MzIUaVCz/5b/cqseuGJe6Mfry0kSPp/vm5+Bq3/EJPx1i/5lck9D8P1tOYbbqZtDsp3335TK4HtvzJV+6XKv" + + "9EycQlgV2Ahwdw3JrxU0TwUbZ53hNdaN7Gcvj7glM3mjxxPp9GUzeKeFviVGLwUe3H4bt5+5x9eLHd9uy5S4Ns5lv1O65/ipK/klgfzDtyT2AMx23gHju+bo" + + "GUrzqgh+cvYJIwWb8fizV4WnRdiDikmZghfbYx+9Q4YUOxmeKBuy65zx2iA8jFmLKySVyzHatLR7Uys8D8jqaTuwF//njtSxuMjL0QGgRz9RdGcdAXlTuwDG" + + "VLaANfiNO+DKZJAXAD3U75hBqYlXByEwYgC3sYI/UJT1Lp4Ib/iNaZka95G+zxtYfvT8FwATKawICzDonxU88v+ot70Rr1CxmyV9h6NGp3XM15/f1RscghsG" + + "UnzpaP4apW7uGHURS5bCIf1ao73S2/Da9OWs9K+upa/oH5Z7CjbkyzCObv1lx7fkl6sqz+OJN3rnBeuTmu72Vt2zzbHhzT8b5zNzXF92WepMs272UrYDo7yO" + + "ZbtbA1h7GkW/1TMW9dx/FrFUAJ9ncjwYGP8YMotJqsBn22VBUsIxGG4Bb9QwlRmMqVlt/60EguvZibuJFaLVmQ5Q5zmjOJqR69VijuCp+gX3GNcqMzQ4BXPb" + + "rVGIrS0bAgvC3abs7me8uCObhqu0zTYQh9DX+f9J9WecoukYBfcRxWGtVIu9Gvn/HqrtgoxrhLh3W7Tpe3eTesEhPxQm/PGYLlXS2v+fQN3uvqm7xVw09/jj" + + "XZQyGig4AIXuJpUehIy/IMrbZGySdpsxlfL0WJZ+j8Cfe5BCwbsY5ZfoEF0yFiMfD9KGHjPCsAGsUdqJdKIsEsTyB0LBSCV6rg3NTujwG71dnyuywT911vM6" + + "XIf1OVFaEGaDO+knbDo2ctA80WuI2zYjNTiYO/8ys5KWu30PUvD399sHx5crBubc8kuxUXOhZAlpv0T+BYwZQJ3ps9nmdWt54cNiS+A7/B6oIXYLgO5RRi9W" + + "Aic8bdbKPf2lbbv+tRwAuzLHRwMwFv1yM+tp9QbvR/P//l5iPIcFxPyTTkC8FW+7O3rN26cfXCtfvGGPPtf/YDxZ96DvNn+jspLvFoTrpn1A/BNh+ydcBN7/" + + "eGxG6r4zI71o3Ny1knWaC0+CHj8Xh+/oLbT9oKgzkjp/Z3oRLT4t1Ah83G4H9Dj2xzs+VkoawIvROzFNSFMEGzshs/meb2f0xkfMt/SBb+pD7dZP+ie8IpdB" + + "yWBzw/I/BW1jdM86UXLlj5dX2c1JxPKWXbmJLC9li/mtVPmKM8p2q+xORU+C1rIYLmbLTst9Uj6wL6piJK37zFqV8wb50Xvm5AVpCY7N577fu/kmd8qWL7I8" + + "NYZyTvpCNlp5D+nndg6G5NhtnEIpDOugz32UP0VDN03RMNrTzF4ef2TzW74SFIfitJ/YSRU34/C78aR2dth4L4xwRpLHepOh8SHyQoI/eeBY2kPPvvO6cYff" + + "Kb35nsYEDm3hDVz0rjZs7epBCe+LHOg+yXQL7edO8XE2bfC1zUZXO/rt1lxXm/PZm9fapuG25uUtvo+U5V+roVaPjf0Rh9Jvmt0IU2+STrGdluqRd3HNcqJF" + + "E35tYVtljhw98Ncxz29mqBaOt/5+hLHbo/IMdUvrRFmjK1CPDwG2rTPaFfy54+cBK+WX5rIABtowdppfioFu9luhYv6+1x1DZlXJZYkDKWeHhDOCXce98cLo" + + "fyUQeh6r/bDwxrpVIeNUqjjhCVEW17/3Yneg3cYf" + ), + } +] + var _checks := 0 var _failures := 0 @@ -71,8 +1451,163 @@ func _run() -> void: invalid["rival_id"] = "missing" _expect(not runtime.relationship_service.register_original_relationship(invalid).is_success(), "restore rebind keeps identity validator") _expect(runtime.relationship_service.register_original_relationship(fixture).is_success(), "restored service accepts correct identities") + _expect(not runtime.staff_service.remove_staff(&"heroine_anri").is_success(), "registered UNIQUE heroine removal refused") + _expect(not runtime.staff_service.retire_staff(&"heroine_anri").is_success(), "registered UNIQUE heroine retirement refused") + var retained: Dictionary = runtime.create_snapshot() + _expect(runtime.restore_snapshot(retained), "refused departures survive save and readback") + _expect(runtime.relationship_service.get_original_relationship(&"heroine_anri")[&"configured"], "departure never deletes original record") + _extra_coverage(runtime) + _representative_saves(runtime) runtime.free() clock.free() state.free() print("Original relationship runtime: %d checks, %d failures" % [_checks, _failures]) quit(_failures) + + +func _reject_runtime(runtime: Variant, candidate: Dictionary) -> void: + var before := var_to_bytes(runtime.create_snapshot()) + var service: Variant = runtime.relationship_service + var service_bytes := var_to_bytes(service.create_snapshot()) + var input := var_to_bytes(candidate) + _expect(not runtime.restore_snapshot(candidate), "malformed candidate rejected atomically") + _expect(runtime.relationship_service == service and var_to_bytes(service.create_snapshot()) == service_bytes, "rejection preserves prior service identity and bytes") + _expect(var_to_bytes(runtime.create_snapshot()) == before, "rejection preserves whole Runtime bytes") + _expect(var_to_bytes(candidate) == input, "rejection preserves all input bytes") + + +func _representative_saves(runtime: Variant) -> void: + for fixture: Dictionary in REPRESENTATIVE_SAVES: + var label: String = fixture["name"] + var world := Marshalls.base64_to_raw(fixture["world"]) + var digest := HashingContext.new() + digest.start(HashingContext.HASH_SHA256) + digest.update(world) + var bound: bool = world.size() == fixture["size"] and digest.finish().hex_encode() == fixture["sha256"] + _expect(bound, label + " embedded compressed world size and SHA match manifest") + if not bound: + continue + var path := ProjectSettings.globalize_path("user://saves/p18_representative_" + label) + _expect(DirAccess.make_dir_recursive_absolute(path) == OK, label + " owned fixture directory") + var file := FileAccess.open(path.path_join("world.bin"), FileAccess.WRITE) + _expect(file != null, label + " fixture world writable") + if file == null: + continue + file.store_buffer(world) + file.close() + file = FileAccess.open(path.path_join("manifest.json"), FileAccess.WRITE) + _expect(file != null, label + " fixture manifest writable") + if file == null: + SaveService._remove_tree(path) + continue + file.store_string(fixture["manifest"]) + file.close() + # Actual production Reader: header/checksum/ZSTD/bytes_to_var/validation. + var loaded := SaveService._load_snapshot_absolute_v1(path, 1) + _expect(loaded[&"ok"], label + " actual legacy package Reader accepts") + if not loaded[&"ok"]: + SaveService._remove_tree(path) + continue + var snapshot: Dictionary = loaded[&"snapshot"] + var input := var_to_bytes(snapshot) + var legacy: Dictionary = snapshot[&"systems"][&"runtime"][&"relationships"].duplicate(true) + _expect(legacy["version"] is int and legacy["version"] == 1 and legacy["relationships"] is Array and legacy["relationships"].is_empty(), label + " observed empty typed v1 collection") + var restored: bool = runtime.restore_snapshot(snapshot) + _expect(restored, label + " representative Runtime legacy restore succeeds") + if not restored: + SaveService._remove_tree(path) + continue + _expect(var_to_bytes(snapshot) == input, label + " restore leaves decoded input unchanged") + var saved: Dictionary = runtime.create_snapshot() + _expect(var_to_bytes(saved[&"systems"][&"runtime"][&"relationships"][&"legacy"]) == var_to_bytes(legacy), label + " all legacy facts unchanged") + var before := var_to_bytes(saved) + var report: Dictionary = runtime.get_staff_management_report() + for row: Dictionary in report[&"staff"]: + var original: Dictionary = row[&"original_relationship"] + _expect(not original[&"configured"], label + " report original unconfigured") + for key: StringName in [&"affection", &"lust", &"netorare", &"shield_current", &"shield_max"]: + _expect(original[key] == null, label + " report original remains null") + var unset: Dictionary = runtime.relationship_service.get_original_relationship(&"heroine_anri") + _expect(not unset[&"configured"] and unset[&"affection"] == null, label + " absent original is unset even without hired rows") + _expect(var_to_bytes(runtime.create_snapshot()) == before, label + " reads leave entire Runtime unchanged") + _expect(SaveService.save_snapshot("user://saves/p18_roundtrip_" + label, saved)[&"ok"], label + " v2 relationship payload saved by real writer") + var readback := SaveService.load_snapshot("user://saves/p18_roundtrip_" + label) + _expect(readback[&"ok"], label + " saved package Reader accepts") + if readback[&"ok"]: + _expect(var_to_bytes(readback[&"snapshot"]) == before, label + " writer/Reader exact v2 equality") + _expect(runtime.restore_snapshot(readback[&"snapshot"]), label + " v2 Runtime readback restores") + _expect(var_to_bytes(runtime.create_snapshot()) == before, label + " v2 Runtime exact equality") + for shape: Variant in ["corrupt", {}, null]: + var corrupt := snapshot.duplicate(true) + corrupt[&"systems"][&"runtime"][&"relationships"]["relationships"] = shape + _reject_runtime(runtime, corrupt) + # Empty representatives cannot exercise corrupt per-record metrics. Those + # shapes are covered by the focused non-empty aliases and original fixtures. + _expect(var_to_bytes(snapshot) == input, label + " corruption candidates do not mutate representative") + SaveService._remove_tree(path) + SaveService._remove_tree(ProjectSettings.globalize_path("user://saves/p18_roundtrip_" + label)) + + +func _extra_coverage(runtime: Variant) -> void: + var candidate: Dictionary = runtime.create_snapshot() + var legacy := Fixtures.legacy_fixture() + candidate[&"systems"][&"runtime"][&"relationships"] = legacy + # GuestService's legitimate departure representation, retained after active removal. + candidate[&"systems"][&"runtime"][&"guests"][&"persistent_records"].append({ + &"guest_id": "departed", &"guest_type_id": "traveler", &"debt_gold": 0, + &"unresolved_incident_ids": [], &"outstanding_reservation_ids": []}) + candidate[&"systems"][&"runtime"][&"progression"][&"metrics"][&"guest_lifetime"] += 1 + var input := var_to_bytes(candidate) + _expect(runtime.restore_snapshot(candidate), "int v1 and departed persistent guest relationships accepted") + _expect(var_to_bytes(candidate) == input, "accepted v1 Runtime input unchanged") + for change: Dictionary in [{&"metric_id": &"affection", &"delta": 2}, {&"metric_id": &"dependence", &"delta": 3}]: + change[&"relationship_id"] = &"aliases" + _expect(runtime.submit_command(&"change_relationship", change).is_success(), "alias changes use public Runtime command") + var saved: Dictionary = runtime.create_snapshot() + var raw: Dictionary = saved[&"systems"][&"runtime"][&"relationships"][&"legacy"]["relationships"][0] + _expect(raw["metrics"]["affection"] == 43 and raw["metrics"]["dependence"] == 22, "Runtime merges canonical mutations") + _expect(raw["metrics"]["affinity"] == 41 and raw["metrics"]["obligation"] == 19, "Runtime keeps raw aliases") + _expect(raw["extra"] == ["raw", 2.5] and raw["metrics"]["extension"] == {"opaque": [3, "keep"]}, "Runtime keeps unknown facts") + var saved_bytes := var_to_bytes(saved) + _expect(runtime.restore_snapshot(saved), "mutated v2 Runtime restores and rebinds") + _expect(var_to_bytes(runtime.create_snapshot()) == saved_bytes, "v2 Runtime preserves raw bytes and order") + _expect(runtime.relationship_service.get_relationship(&"aliases").get_metric(&"affection") == 43 and runtime.relationship_service.get_relationship(&"aliases").get_metric(&"dependence") == 22, "Runtime canonical precedence survives rebind") + for key: StringName in [&"affection", &"lust", &"netorare"]: + _expect(runtime.relationship_service.get_original_relationship(&"heroine_anri")[key] == null, "Runtime old axes leave original unset") + _expect(runtime.relationship_service.register_original_relationship(Fixtures.fixture()).is_success(), "rebound service accepts original") + saved = runtime.create_snapshot() + for kind: String in ["numeric_string", "metrics_container", "duplicate", "version_type", "unknown_version", "projection", "non_heroine", "counterpart", "non_staff", "corrupt"]: + var bad := saved.duplicate(true) + var relationships: Dictionary = bad[&"systems"][&"runtime"][&"relationships"] + match kind: + "numeric_string", "metrics_container": + if kind == "numeric_string": + relationships[&"legacy"]["relationships"][0]["metrics"]["affection"] = "50" + else: + relationships[&"legacy"]["relationships"][0]["metrics"] = [] + relationships[&"relationships"] = relationships[&"legacy"]["relationships"].duplicate(true) + "duplicate": + relationships[&"original_relationships"].append(Fixtures.fixture()) + "version_type": + relationships[&"version"] = "2" + "unknown_version": + relationships[&"version"] = 3 + "projection": + relationships[&"relationships"] = [] + "non_heroine": + var rival_staff := StaffRuntime.new().configure(&"rival_rai", &"influencer", {&"employment_kind": &"UNIQUE"}) + _expect(rival_staff.is_valid(), "non-heroine rejection fixture is valid UNIQUE staff") + bad[&"systems"][&"runtime"][&"staff"][&"staff"].append(rival_staff.create_snapshot()) + relationships[&"original_relationships"][0]["subject_id"] = "rival_rai" + relationships[&"original_relationships"][0]["rival_id"] = "heroine_anri" + var registry := StaffService.new() + _expect(registry.register_staff(rival_staff).is_success(), "non-heroine UNIQUE exists in identity fixture registry") + _expect(Fixtures.Model.from_snapshot(relationships[&"original_relationships"][0]) != null, "non-heroine payload passes structural model validation") + _expect(not runtime._original_relationship_identities_valid(relationships[&"original_relationships"][0], registry, runtime.mvp_content_catalog), "catalog rejects non-heroine UNIQUE subject specifically") + "counterpart": + relationships[&"original_relationships"][0]["rival_id"] = "rival_other" + "non_staff": + relationships[&"original_relationships"][0]["subject_id"] = "departed" + "corrupt": + relationships[&"original_relationships"][0].erase("lust") + _reject_runtime(runtime, bad) diff --git a/tools/regression/suite-policy.json b/tools/regression/suite-policy.json index 63d34d8..fdaefc3 100644 --- a/tools/regression/suite-policy.json +++ b/tools/regression/suite-policy.json @@ -2,14 +2,14 @@ "schema_version": 1, "suite_policies": { "tests/s4/test_original_relationship_model.gd": { - "source_sha256": "ad509f5fb67ab91e1d1d99a08af51e4695e411b9a2541ea63ee22b1555cb0924", + "source_sha256": "c74b243dbbb54dba9bbc165e29508cca910f0beb63e32d25ebbb8ea606dccce9", "ordinary_cleanup_prepared": false, "ordinary_control_labels": [], "old_bounded_teardown": false, "new_audio_QA": false }, "tests/s4/test_original_relationship_runtime.gd": { - "source_sha256": "374f3d31a65d2f2b62dfef29721c8c838575b856f4fa5a0bca31c6ba4c7e09dd", + "source_sha256": "845ae200575563400c3497e517137effb7d4d928dd7e6a4990ed8aabdbda5ae6", "ordinary_cleanup_prepared": false, "ordinary_control_labels": [], "old_bounded_teardown": false, diff --git a/tools/run_p18_relationship_tests.py b/tools/run_p18_relationship_tests.py index c520311..925ccca 100644 --- a/tools/run_p18_relationship_tests.py +++ b/tools/run_p18_relationship_tests.py @@ -199,6 +199,7 @@ def seal(out, refs, engine, contract_sha): source = content_map(refs) shared.write(out / 'receipt.json', { 'schema': 'guarded-p18-v2', 'source_map': source, + 'parse_checks': len([name for name in refs if name.endswith('.gd')]), 'source_map_sha256': digest(source), 'project_settings_sha256': source['project.godot']['sha256'], 'marker_contract_sha256': contract_sha, @@ -281,8 +282,10 @@ def verify(out, refs, markers, contracts, policy, contract_sha, parse_paths): require(engine and shared.sha(engine) == start['engine_sha256'] == manifest['engine_sha256'] == files['engine.bin']['sha256'], 'current native engine and retained bytes pinned') - require(read('parse-paths.json') == parse_paths and len(parse_paths) == 308, - 'all 308 exact source parse paths') + derived_paths = ['res://' + name for name in sorted(refs) if name.endswith('.gd')] + require(read('parse-paths.json') == parse_paths == derived_paths + and manifest['parse_checks'] == len(derived_paths), + 'all exact source parse paths and receipt count') require(end['passed'] is True and end['engine_ended'] is True and end['error'] is None and end['cleanup_errors'] == [] and end['guard_errors'] == [], 'finished successful collection without guard/cleanup error') @@ -463,8 +466,9 @@ def verify(out, refs, markers, contracts, policy, contract_sha, parse_paths): else: require(row['controlled_environment'] == {}, 'fresh import environment') if phase == 'parse': - require(re.findall(r'(?m)^FULL_DEPENDENCY_PARSE checks=([0-9]+) failures=([0-9]+)\n', raw) - == [('308', '0')] and row['actual_parse_checks'] == 308, 'unique all-script parse marker') + require(len(re.findall(r'(?m)^FULL_DEPENDENCY_PARSE\b', raw)) == 1 + and re.findall(r'(?m)^FULL_DEPENDENCY_PARSE checks=([0-9]+) failures=([0-9]+)\n', raw) + == [(str(len(parse_paths)), '0')] and row['actual_parse_checks'] == len(parse_paths), 'unique all-script parse marker') if test: parsed = markers.parse_raw(test, raw, contracts, source[test]['sha256']) require(parsed['passed'] and row['completion'] == parsed @@ -492,7 +496,7 @@ def verify(out, refs, markers, contracts, policy, contract_sha, parse_paths): 'whole raw evidence unchanged during verification') require(content_map(shared.source_refs(shared.HERE.parent)) == source, 'whole current source unchanged during verification') - print(json.dumps({'verified': True, 'actual_suites': 7, 'parse_checks': 308, + print(json.dumps({'verified': True, 'actual_suites': 7, 'parse_checks': len(parse_paths), 'actual_checks': end['actual_all_roster_checks'], 'engines_started': 0, 'formal_acceptance': False, 'original_unit_complete': False})) return 0 @@ -536,7 +540,6 @@ def main(argv=None): require(contracts[test]['source_sha256_at_schema_audit'] == refs[test]['sha256'], 'new strict source-hashed marker') parse_paths = ['res://' + name for name in sorted(refs) if name.endswith('.gd')] - require(len(parse_paths) == 308, 'exact expected parse count') if args.prepare_only: ancestor = out.parent while not ancestor.exists(): @@ -545,7 +548,7 @@ def main(argv=None): size = sum(p['bytes'] for p in refs.values()) print(json.dumps({'roster': ROSTER, 'source_files': len(refs), 'source_bytes': size, 'free_bytes': free, 'conservative_required_bytes': size + shared.MIN_SPACE, - 'capacity_available': free >= size + shared.MIN_SPACE, 'parse_paths': 308, + 'capacity_available': free >= size + shared.MIN_SPACE, 'parse_paths': len(parse_paths), 'future_native_phases': 9, 'actual_checks': None, 'engines': 0, 'stages': 0, 'formal_acceptance': False})) return 0