From 09e85f6f938b05a4e8777976374a76b4612b6c15 Mon Sep 17 00:00:00 2001 From: Thorsten Fuchs <76904008+ThorFuchs@users.noreply.github.com> Date: Sun, 18 Oct 2026 10:55:39 +0200 Subject: [PATCH 1/3] Integrate source-attached N3 snapshots on current development main --- .../Architecture/ExtractionManifest.json | 4 +- .../NAV7SnapshotReconciliation.md | 21 ++ .../SnapshotExperiment.md | 85 ++++++ .../SnapshotPromotion.md | 63 ++++ .../Qualification/TestDiscovery.json | 10 +- Scripts/ci.py | 12 +- Scripts/qualify_snapshot.py | 120 ++++++++ Scripts/test_qualification_harness.py | 6 +- Sources/JSON/Reading/JSONReadScope.swift | 15 +- Sources/JSONCLIEngine/CLIBuildIdentity.swift | 2 +- .../Documentation.docc/JSONInspection.md | 8 + .../Documentation.docc/StructuralSnapshots.md | 85 ++++++ .../JSONStructuralSnapshot.swift | 240 +++++++++++++++ .../JSONNavigation/JSONTraversalContext.swift | 4 + .../SnapshotAcceptanceTests.swift | 278 ++++++++++++++++++ .../SnapshotPromotionTests.swift | 123 ++++++++ Tools/SnapshotQualification/Package.swift | 12 + Tools/SnapshotQualification/README.md | 10 + .../Sources/SnapshotConsumer/Main.swift | 151 ++++++++++ 19 files changed, 1234 insertions(+), 15 deletions(-) create mode 100644 Documentation/Architecture/StructuralIntelligence/NAV7SnapshotReconciliation.md create mode 100644 Documentation/Architecture/StructuralIntelligence/SnapshotExperiment.md create mode 100644 Documentation/Architecture/StructuralIntelligence/SnapshotPromotion.md create mode 100644 Scripts/qualify_snapshot.py create mode 100644 Sources/JSONInspection/Documentation.docc/StructuralSnapshots.md create mode 100644 Sources/JSONInspection/JSONStructuralSnapshot.swift create mode 100644 Tests/JSONInspectionTests/SnapshotAcceptanceTests.swift create mode 100644 Tests/JSONInspectionTests/SnapshotPromotionTests.swift create mode 100644 Tools/SnapshotQualification/Package.swift create mode 100644 Tools/SnapshotQualification/README.md create mode 100644 Tools/SnapshotQualification/Sources/SnapshotConsumer/Main.swift diff --git a/Documentation/Architecture/ExtractionManifest.json b/Documentation/Architecture/ExtractionManifest.json index 95a8694..0956116 100644 --- a/Documentation/Architecture/ExtractionManifest.json +++ b/Documentation/Architecture/ExtractionManifest.json @@ -299,7 +299,9 @@ "1.6 S3 G7 seeded grammar, scalar-key permutation tests, public replay consumer and strict cardinality/matrix harness are original Apache-2.0 contributions. The 64-schema authored fixture has SHA-256 cb55604183a6db7df5fa968db283e7abeae794277d2b0cef033b0bdb92e615cb. Independent python-jsonschema 4.26.0 is research qualification only, with exact numeric binding; no Python runtime dependency or copied validator/engine is distributed.", "1.6 S3 G8 materializes the unchanged synthetic corpus per caller access, replacing process-lifetime stored JSON payloads exposed by Linux ASan/LSan. The public process-lifetime consumer and strengthened exact/value-copy test are original Apache-2.0 qualification code; no suppression, runtime fallback, new dependency or corpus/digest change is introduced.", "Composition reference-load fixtures, serial descriptor staging, public-only adapter, capacity/terminal tests and strict CI receipt checks are original Apache-2.0 code. Generated JSON graphs introduce no upstream protocol fixtures, engine or dependency. Core public APIs, finite profiles and accounting weights are unchanged.", - "NAV5 public array-evidence packaging, external consumer and DocC are original Apache-2.0 code. Existing exact shape evidence, exclusive reducer, weights and I01-I17 semantics are unchanged; no upstream engine or dependency is adapted. Promotion is a draft candidate, not a released product." + "NAV5 public array-evidence packaging, external consumer and DocC are original Apache-2.0 code. Existing exact shape evidence, exclusive reducer, weights and I01-I17 semantics are unchanged; no upstream engine or dependency is adapted. Promotion is a draft candidate, not a released product.", + "NAV5 package-only complete structural snapshot, parent-linked metadata, original source-ownership transfer and S01-S24 synthetic tests are original Apache-2.0 code. The existing read scope admits once; its default public read/traversal/inspection completion behavior is preserved. No persistent identity, upstream algorithm or new dependency is introduced.", + "NAV6 snapshot access-level promotion, external consumer, independent 28-record maintainer oracle, terminal-transfer/concurrent lookup proofs and compiled DocC are original Apache-2.0 contributions. No upstream engine, new semantic authority, dependency or additional product is adapted." ], "jsonhtml_export_original_contributions": { "license": "Apache-2.0", diff --git a/Documentation/Architecture/StructuralIntelligence/NAV7SnapshotReconciliation.md b/Documentation/Architecture/StructuralIntelligence/NAV7SnapshotReconciliation.md new file mode 100644 index 0000000..df22de3 --- /dev/null +++ b/Documentation/Architecture/StructuralIntelligence/NAV7SnapshotReconciliation.md @@ -0,0 +1,21 @@ +# NAV7 dependent snapshot candidate + +This draft replays37d84e8..b77d43d onto the NAV7 current-main N2 proposal, +including #44 DocC index repair and #45 release metadata. Original #42/#43 and +NAV6 heads remain unchanged. Snapshot source, read-scope ownership designation, +exclusive context, all original S/V tests,14-case external consumer and compiler +probe scripts are byte-identical to b77d43d. No algorithm replacement occurs. + +JSONInspection remains the one opt-in candidate product:44 Inspection declarations +plus23 authored snapshot additions, with Navigation56 unchanged. Construction is +one original scope/admission; a complete immutable snapshot owns one source and +compact records. Each path/value/span lookup has its own explicit bounded full- +source admission. Ordinals are local positions, not transferable node handles. + +G4 native performance remains HOLD with zero timed snapshot workloads and no +retry authorization. Logical counters are policy, not RSS, allocation count or +speed. This source requires fresh Debug/Release/ASan/TSan/strict, ownership/public +negative codegen, external consumer, DocC/site, Linux, WASI/WasmKit, SDK and archive +proofs. Actual outcomes are source-bound in the private NAV7 return; this document +does not invent a pass. No merge, ready transition, release or public projection +is authorized. P1 private experiments remain a separate conditional branch. diff --git a/Documentation/Architecture/StructuralIntelligence/SnapshotExperiment.md b/Documentation/Architecture/StructuralIntelligence/SnapshotExperiment.md new file mode 100644 index 0000000..6fc0ce3 --- /dev/null +++ b/Documentation/Architecture/StructuralIntelligence/SnapshotExperiment.md @@ -0,0 +1,85 @@ +# NAV5 I0 — Complete source-attached snapshot + +Status: accepted design for a package-only experiment; implementation remains +conditional on the N2 public surface freeze and repeated owned-reducer proof. +Base: frozen N2 API candidate 2e952c00ea2f4c2a943032a54f3a3fd85b1b96fb, +with the subsequent generated-identity correction replayed separately. Both descend +from 462f3ea and main 7d72c88. No public N3 API, +new product, persistence, actor, projection, index-by-path or traversal option. + +## Representation and invariants + +One immutable Sendable snapshot holds one JSONDocument plus compact records. +Each record contains ordinal, optional parent, optional exact edge component, +kind, depth, immediate child count and a finalized half-open subtree end. No JSON +subtree, absolute path, span, source bytes or label is stored per record. Ordinals +are snapshot-local inputs to instance methods; no detached node/handle type exists +and no API accepts a replacement document. Metadata lookup is bounds checked. + +The sole builder calls inspectOwned with its default complete physical root and +no options or callback supplied by the caller. Before a depth-d hit, close stack +entries while count > d, setting their ends to the next ordinal. The remaining +top is the parent. Append the record and ordinal after charging storage. The +root has depth 0 and nil parent/component. On finish, require complete summary, +visited/emitted == records.count, and close every remaining frame at total count. +No failed or cancelled finish returns an artifact. Empty/scalar roots yield one +record. Metadata and parent links are immutable after initialization. + +## One original admission and source ownership transfer + +Existing JSONReadScope.complete refunds input/source ownership unconditionally. +Returning a source-attached snapshot without extending that accounting would +underreport live output; readmitting the document would duplicate work/quotas. +Use a narrowly package-scoped, one-shot transferDocumentOwnership capability: +check original scope health/owner and charge one work step, then designate the +already-admitted source bytes as result-owned. At complete, refund paths and +transient invocation storage as before, but retain the original rootBytes in the +same report. The context method remains mutating and returns only the canonical +immutable JSONDocument, never scope/state/meter/cursor. No new admission or ledger. + +Default false preserves every existing read/visit/collect/N2 completion statistic. +Only the N3 finish path invokes transfer, after complete structural finalization. +Invalidation always clears scope document/state; returned source is an ordinary +immutable alias. Failure after transfer still returns no report/artifact, and +scope teardown releases its references. Tests must prove exactly one admitted +node/source-map count, captured source cost retained once, N1/N2 parity, and source +release/terminal behavior. If this narrow package helper cannot preserve existing +semantics or the compiler proof, do not implement N3 with a weaker meter. + +## Logical overlay v1 and complexity + +Declare 96 bytes per record (seven scalar/optional/enum slots plus component +storage policy), plus exact UTF-8 key alias bytes, 16 per open ordinal frame and +128 fixed snapshot/report bytes. Reserve each before append. Source ownership is +the original read-scope admission cost, transferred once rather than recomputed. +All record finalizations charge work and check cancellation; pop/refund a frame +only after removal. These versioned logical weights are policy rather than Swift +MemoryLayout, allocator behavior or RSS. No claimed hard physical-memory bound. + +Record retention O(nodes + key bytes), frontier O(depth). The existing walker +constructs absolute hit paths: build work may be O(sum of depths), plus admission, +key processing and finalization. Do not claim linear total construction or a speedup. + +## Separate bounded lookup + +Snapshot-scoped ordinal methods reject negative/out-of-range indices. Each path, +value or span lookup starts an explicitly separate finite core operation, admits +the captured immutable document using JSONReadScope, charges parent-chain work and +temporary/output path retention, then delegates exact selection/source-map lookup +to the core on that original scope. No lookup runs during build. Values are returned +under existing read-value semantics; a returned JSON alias is caller value storage, +not a second serialized graph. Path result ownership remains charged at handoff. +No incomplete snapshot, missing-as-null or negative-query API is available. + +## Proof gate + +Keep N1's 56 public declarations and unmodified 2-positive/20-negative full-codegen +matrix. Preserve I01-I17. Add S01-S24 structural, exact-key/number, source attachment, +quota/cancel and generated depth/breadth tests; run Debug/Release, strict, sanitizers +and qualified platform lanes. Actual source-bound results decide qualification; +this ADR alone qualifies no executable behavior. + +The builder defaults to 100,000 records inclusive. Negative configuration fails +before source admission; zero fails at the physical root with a typed capacity +error. Invalid lookup ordinals precede source admission. Finalized subtree ends +are nonoptional Int: no public or package result can carry an unfinished range. diff --git a/Documentation/Architecture/StructuralIntelligence/SnapshotPromotion.md b/Documentation/Architecture/StructuralIntelligence/SnapshotPromotion.md new file mode 100644 index 0000000..bf57585 --- /dev/null +++ b/Documentation/Architecture/StructuralIntelligence/SnapshotPromotion.md @@ -0,0 +1,63 @@ +# NAV6 snapshot public candidate + +This isolated draft descends from original package-only N3 872b5fd and reconciled +N2 37d84e8 (current main c79d48c). It proposes a public facade inside the existing +JSONInspection product; it creates no additional SwiftPM product. No merge or +release is authorized. Original #41/#42 evidence identities remain unchanged. + +## Accepted interface + +Keep JSONStructuralSnapshotBuilder(document:limits:), build(maximumRecords:), +JSONStructuralSnapshot.document/recordCount, record(at:), location/value/sourceSpan +(for:limits:), JSONStructuralRecord and the two existing typed failure cases. +There are no public record/snapshot initializers or setters. The implementation +remains the original package/private algorithm; no scope, meter, reducer, observer, +borrowed cursor or source-rebinding capability becomes public. + +An ordinal is an integer position local to the snapshot method being called, +never a detached node identity. Two sources may both have position 1 with different +values; explicitly selecting each snapshot selects its own original source. No +method accepts a record, handle or replacement document. The immutable document +attachment keeps old snapshots coherent after other values are patched/replaced. + +## Ownership and errors + +Build performs complete physical preorder under Navigation’s one original scope +and meter. Source ownership transfers once after finalized half-open subtree ends; +ordinary read/visit/collect/inspectArray never transfer and preserve refunds. All +three counters (record count, open depth, subtree end) are bounded by arrays and +admitted nodes. Parent assignment uses existing indices; end equals records.count; +ordinal < maximumRecords is checked before append, so count can at most Int.max +without an increment from Int.max. No end/count arithmetic adds unchecked user +integers. Core retention/work increments use checked UInt64 accounting. Supported +wasm32 capacities retain the existing admission policy; no new narrowing occurs. + +Negative maximumRecords precedes admission; zero refuses the real root. No quota, +cancellation, incomplete traversal or finalization failure returns an artifact. +The exclusive context latches owned failures, including second transfer. A direct +package read-scope transfer guard is an implementation primitive; public N3 +construction reaches it only through that guarded context. Post-transfer caller +errors and quota/cancellation still invalidate the scope and publish no result. + +## Costs and qualification + +Overlay v1 remains 128 fixed logical bytes, 96 per record, edge-key UTF-8 bytes, +16 per open frame, plus original source/path costs. Compact record retention is +O(nodes + key bytes), while existing walker full-path storage and copying remain +depth-sensitive. record(at:) is O(1) trusted-memory metadata access. Each location, +value or span lookup is an explicitly separate finite operation with full source +re-admission and core prefix/path/selection work. K lookups pay K admissions. These +are semantic costs, not new performance claims; logical bytes are not heap or RSS. + +All I01–I17 and S01–S24 identities remain. Three new proofs add an independent +28-record oracle, post-transfer terminal/lifetime cases and concurrent lookup +health isolation. Exact discovery rises to 747 native / 731 Linux / 643 WASI, +with 325/288 parameter invocations unchanged, 44 Inspection functions and 50/49 +shared-state functions. Preserve 49 cap probes, 126 maintenance identities, +2-positive/20-negative full codegen, composition and schema-example lanes. Public +qualification adds fourteen external cases, three executable DocC examples and +18 external full-codegen negative outcomes. Requirements become passes only when +actual source-bound receipts say so; SDK compilation is not device execution. + +Read the [compiled guide](../../../Sources/JSONInspection/Documentation.docc/StructuralSnapshots.md) +and [independent consumer](../../../Tools/SnapshotQualification). diff --git a/Documentation/Qualification/TestDiscovery.json b/Documentation/Qualification/TestDiscovery.json index c55f9b9..65078da 100644 --- a/Documentation/Qualification/TestDiscovery.json +++ b/Documentation/Qualification/TestDiscovery.json @@ -12,7 +12,7 @@ "JSONCLITests": 88, "JSONNavigationTests": 47, "JSONSchemaExamplesTests": 98, - "JSONInspectionTests": 17 + "JSONInspectionTests": 44 }, "parameterized_invocations": 325, "composition_external_functions": 5, @@ -35,7 +35,7 @@ "JSONCLITests": 1, "JSONNavigationTests": 1, "JSONSchemaExamplesTests": 4, - "JSONInspectionTests": 1 + "JSONInspectionTests": 3 }, "coverage_unmapped": { "Sources/JSON/Pointer/JSONLocationComponent.swift": "declaration-only enum", @@ -76,7 +76,7 @@ "JSONCLITests": 88, "JSONNavigationTests": 47, "JSONSchemaExamplesTests": 98, - "JSONInspectionTests": 17 + "JSONInspectionTests": 44 }, "wasi_root_functions": { "JSONTests": 190, @@ -89,7 +89,7 @@ "JSONBridgesTests": 10, "JSONNavigationTests": 47, "JSONSchemaExamplesTests": 98, - "JSONInspectionTests": 17 + "JSONInspectionTests": 44 }, "wasi_parameterized_invocations": 288, "portable_shared_state_functions": { @@ -103,7 +103,7 @@ "JSONCLITests": 1, "JSONNavigationTests": 1, "JSONSchemaExamplesTests": 4, - "JSONInspectionTests": 1 + "JSONInspectionTests": 3 }, "export_functions": { "JSONSchemaTests": 1, diff --git a/Scripts/ci.py b/Scripts/ci.py index 4b341c6..606dea7 100644 --- a/Scripts/ci.py +++ b/Scripts/ci.py @@ -14,6 +14,7 @@ SHARED_TESTS += '|g1SharedPreparedGeneratorHasIndependentConcurrentInvocations|g3SharedTypedGeneratorHasIndependentConcurrentInvocations|g4SharedAdvancedGeneratorHasIndependentConcurrentInvocations|g5SharedPreparationSeparatesConcurrentFailureAndSuccessHealth' SHARED_TESTS += '|navigationSharedImmutableRootIndependentInvocations' SHARED_TESTS += '|inspectionI17CoverageSpansReplacementAndSharedInvocations' +SHARED_TESTS += '|snapshotS19NavigationParityAndIndependentInvocations|snapshotV22ConcurrentLookupsUseIndependentAdmissionAndHealth' R0_TESTS = 'readerProbe|indexProbes|duplicateRecognitionPrecedesValueAndClosingSyntax' def snapshot(): @@ -24,9 +25,9 @@ def commands(lane, output): output = output.relative_to(ROOT) if lane == 'inspection': result = [['python3', '-B', 'Scripts/public_check.py'], - ['swift', 'test', '--filter', 'inspection'], - ['swift', 'test', '-c', 'release', '--filter', 'inspection'], - ['swift', 'test', '-c', 'release', '--sanitize', 'address', '--scratch-path', '.build/inspection-address', '--filter', 'inspection'], + ['swift', 'test', '--filter', 'inspection|snapshot'], + ['swift', 'test', '-c', 'release', '--filter', 'inspection|snapshot'], + ['swift', 'test', '-c', 'release', '--sanitize', 'address', '--scratch-path', '.build/inspection-address', '--filter', 'inspection|snapshot'], ['swift', 'build', '--target', 'JSONInspection', '--scratch-path', '.build/inspection-strict', '-Xswiftc', '-strict-memory-safety', '-Xswiftc', '-warnings-as-errors'], ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')]] @@ -165,6 +166,7 @@ def commands(lane, output): ['python3', '-B', 'Scripts/qualify_ergonomics.py'], ['python3', '-B', 'Scripts/qualify_navigation.py', '--output', str(output / 'navigation')], ['python3', '-B', 'Scripts/qualify_inspection.py', '--output', str(output / 'inspection-consumer')], + ['python3', '-B', 'Scripts/qualify_snapshot.py', '--output', str(output / 'snapshot-consumer')], ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')], ['swift', 'test', '--package-path', 'Tools/MobileQualification'], ['swift', 'run', '-c', 'release', '--package-path', 'Tools/MobileQualification', 'MobileQualification'], @@ -224,7 +226,7 @@ def check_result(command, code, log, events=None): expected = [DISCOVERY['root_functions']['JSONNavigationTests']] if events is not None: passed = passed and events['module_function_counts'] == {'JSONNavigationTests': expected[0]} and events['parameter_case_invocations'] == 0 - if 'inspection' in command: + if any(f in command for f in ['inspection', 'inspection|snapshot']): expected = [DISCOVERY['root_functions']['JSONInspectionTests']] if events is not None: passed = passed and events['module_function_counts'] == {'JSONInspectionTests': expected[0]} and events['parameter_case_invocations'] == 0 @@ -298,6 +300,8 @@ def check_result(command, code, log, events=None): passed = passed and 'ERGONOMICS_COMPILER passed commands=8 guide_fences=3' in log.splitlines() if command[:3] == ['python3', '-B', 'Scripts/qualify_navigation_reducer.py']: passed = passed and 'REDUCER_CODEGEN passed positive=2 negative=20' in log.splitlines() + if command[:3] == ['python3', '-B', 'Scripts/qualify_snapshot.py']: + passed = passed and 'SNAPSHOT_COMPILER passed configurations=2 consumer_cases=14 address_cases=14 guide_fences=3 negative_probes=18' in log.splitlines() if command[:3] == ['python3', '-B', 'Scripts/qualify_inspection.py']: passed = passed and 'INSPECTION_COMPILER passed configurations=2 consumer_cases=12 address_cases=12 guide_fences=3 negative_probes=8' in log.splitlines() if command[:3] == ['python3', '-B', 'Scripts/qualify_navigation.py']: diff --git a/Scripts/qualify_snapshot.py b/Scripts/qualify_snapshot.py new file mode 100644 index 0000000..903637a --- /dev/null +++ b/Scripts/qualify_snapshot.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Qualify public snapshot imports, semantics and three executable DocC examples.""" +import argparse +import hashlib +import json +import pathlib +import re +import subprocess +import sys +from archive_candidate import files + +ROOT = pathlib.Path(__file__).resolve().parents[1] +CHECKS = {'roots', 'typed-paths', 'unicode', 'numbers', 'duplicate-refusal', + 'preorder-ranges', 'core-differential', 'source-binding', 'bounds', + 'separate-admission', 'capacity-configuration', 'inclusive-budgets', + 'coverage-separation', 'concurrent-lookups'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', required=True) + output = ROOT / parser.parse_args().output + output.mkdir(parents=True, exist_ok=True) + inputs = [{'path': p.relative_to(ROOT).as_posix(), + 'sha256': hashlib.sha256(p.read_bytes()).hexdigest()} for p in files()] + receipt = dict(status='running', source_inputs=inputs, commands=[], consumer_results={}) + + def save(): + (output / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n') + + def run(name, command, expected=None): + result = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, timeout=900) + text = result.stdout + result.stderr + crash = result.returncode < 0 or any(x in text for x in + ['Stack dump:', 'Assertion failed', 'fatal error encountered during compilation']) + diagnostics = re.findall(r': error: ([^\n]+)', result.stderr) + passed = not crash and (result.returncode == 0 if expected is None else + result.returncode > 0 and any(expected in d for d in diagnostics)) + log = output / (name + '.log') + log.write_text(text.replace(str(ROOT), '.')) + receipt['commands'].append(dict(name=name, command=[x.replace(str(ROOT), '.') for x in command], + exit_code=result.returncode, status='passed' if passed else 'failed', compiler_crash=crash, + expected_diagnostic=expected, primary_diagnostics=diagnostics, + log=log.relative_to(ROOT).as_posix(), log_sha256=hashlib.sha256(log.read_bytes()).hexdigest())) + save() + if not passed: + raise ValueError('Unexpected compiler/consumer outcome: ' + name) + return result.stdout + + def consumer(name, command): + text = run(name, command) + checks = re.findall(r'^SNAPSHOT_CHECK (\S+) passed$', text, re.M) + if len(checks) != 14 or set(checks) != CHECKS or 'SNAPSHOT_CONSUMER passed cases=14' not in text: + raise ValueError('Missing/duplicate inspection consumer checks: ' + name) + resource = re.search(r'^SNAPSHOT_RESOURCE work=(\d+) retained=(\d+) peak=(\d+) nodes=(\d+)$', text, re.M) + if resource is None or not all(int(x) > 0 for x in resource.groups()): + raise ValueError('Missing finite cumulative report: ' + name) + receipt['consumer_results'][name] = dict(cases=checks, work_units=int(resource[1]), + logical_retained_bytes=int(resource[2]), peak_logical_retained_bytes=int(resource[3]), + admitted_nodes=int(resource[4])) + save() + + try: + for config in ['debug', 'release']: + run(config + '-build', ['swift', 'build', '-c', config, '--target', 'JSONInspection']) + binpath = pathlib.Path(run(config + '-binpath', ['swift', 'build', '-c', config, '--show-bin-path']).strip()) + modules = binpath / 'Modules' if (binpath / 'Modules').is_dir() else binpath + objects = [] + for module in ['JSON', 'JSONNavigation', 'JSONInspection']: + aggregate = binpath / (module + '.o') + selected = [aggregate] if aggregate.is_file() else sorted((binpath / (module + '.build')).glob('*.o')) + if not selected: + raise ValueError('Missing built objects: ' + module) + objects.extend(str(p) for p in selected) + common = ['swiftc', '-swift-version', '6', '-warnings-as-errors', '-package-name', + 'snapshot_external_consumer', '-I', str(modules), + '-O' if config == 'release' else '-Onone'] + consumer(config, ['swift', 'run', '-c', config, '--package-path', + 'Tools/SnapshotQualification', 'SnapshotConsumer']) + guide = ROOT / 'Sources/JSONInspection/Documentation.docc/StructuralSnapshots.md' + fences = re.findall(r'```swift\n(.*?)\n```', guide.read_text(), re.S) + if len(fences) != 3: + raise ValueError('Changed three-fence guide inventory') + for index, fence in enumerate(fences): + file = output / ('guide-' + str(index) + '.swift') + file.write_text('import Foundation\nimport JSON\nimport JSONNavigation\nimport JSONInspection\n' + '@main struct Guide { static func main() throws {\n' + fence + '\n} }\n') + binary = output / ('guide-' + config + '-' + str(index)) + run(config + '-guide-' + str(index), common + ['-parse-as-library', str(file), *objects, '-o', str(binary)]) + run(config + '-guide-' + str(index) + '-run', [str(binary)]) + probes = [ + ('core-import-isolation', 'import JSON\nlet x = JSONStructuralSnapshotBuilder.self\n', 'cannot find'), + ('scope-isolation', 'import JSON\nlet x = JSONReadScope.self\n', 'cannot find'), + ('meter-isolation', 'import JSON\nlet x = JSONWorkMeter.self\n', 'cannot find'), + ('capability-isolation', 'import JSONNavigation\nlet x = JSONTraversalContext.self\n', 'cannot find'), + ('reducer-isolation', 'import JSONNavigation\nlet x = JSONTraversalOwnedReducer.self\n', 'cannot find'), + ('record-is-readonly', 'import JSONInspection\nfunc change(_ x: inout JSONStructuralRecord) { x.subtreeEndExclusive = 7 }\n', 'setter is inaccessible'), + ('source-is-readonly', 'import JSON\nimport JSONInspection\nfunc change(_ x: inout JSONStructuralSnapshot) { x.document = .init(root: .null) }\n', "'let' constant"), + ('snapshot-is-unforgeable', 'import JSON\nimport JSONInspection\nlet x = JSONStructuralSnapshot(document: .init(root: .null), records: [])\n', 'initializer is inaccessible'), + ('no-source-rebinding', 'import JSON\nimport JSONInspection\nfunc change(_ x: JSONStructuralSnapshot) throws { _ = try x.value(for: 0, document: .init(root: .null)) }\n', "extra argument 'document'"), + ] + for name, source, expected in probes: + file = output / (name + '.swift'); file.write_text(source) + run(config + '-' + name, common + ['-parse-as-library', '-c', str(file), + '-o', str(output / (config + '-' + name + '.o'))], expected) + consumer('address', ['swift', 'run', '-c', 'release', '--sanitize', 'address', + '--scratch-path', '.build/snapshot-consumer-address', '--package-path', + 'Tools/SnapshotQualification', 'SnapshotConsumer']) + receipt['status'] = 'passed' + except (OSError, ValueError, subprocess.TimeoutExpired) as error: + receipt.update(status='failed', error=str(error)) + save() + print('SNAPSHOT_COMPILER ' + receipt['status'] + + ' configurations=2 consumer_cases=14 address_cases=14 guide_fences=3 negative_probes=18') + return 0 if receipt['status'] == 'passed' else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/Scripts/test_qualification_harness.py b/Scripts/test_qualification_harness.py index 8089704..ea91700 100644 --- a/Scripts/test_qualification_harness.py +++ b/Scripts/test_qualification_harness.py @@ -35,7 +35,7 @@ def test_composition_discovery_and_capacity_limits_are_not_blanket_successes(sel # Combined-source checks must retain both independently owned optional products. for module, count, command in [ ('JSONNavigationTests', 47, ['swift', 'test', '--filter', 'navigation']), - ('JSONInspectionTests', 17, ['swift', 'test', '--filter', 'inspection']), + ('JSONInspectionTests', 44, ['swift', 'test', '--filter', 'inspection']), ('JSONSchemaExamplesTests', 98, ['swift', 'test', '--test-product', 'JSONSchemaExamplesTests']), ]: events = dict(bundle_counts=[count], module_function_counts={module: count}, @@ -49,12 +49,12 @@ def test_composition_discovery_and_capacity_limits_are_not_blanket_successes(sel for key in ('root_functions', 'portable_root_functions', 'wasi_root_functions'): self.assertEqual(policy[key]['JSONNavigationTests'], 47) self.assertEqual(policy[key]['JSONSchemaExamplesTests'], 98) - self.assertEqual(policy[key]['JSONInspectionTests'], 17) + self.assertEqual(policy[key]['JSONInspectionTests'], 44) self.assertEqual(policy[key]['JSONIntegrationTests'], 32) for key in ('shared_state_functions', 'portable_shared_state_functions'): self.assertEqual(policy[key]['JSONNavigationTests'], 1) self.assertEqual(policy[key]['JSONSchemaExamplesTests'], 4) - self.assertEqual(policy[key]['JSONInspectionTests'], 1) + self.assertEqual(policy[key]['JSONInspectionTests'], 3) self.assertEqual(policy[key]['JSONIntegrationTests'], 11) def setUp(self): diff --git a/Sources/JSON/Reading/JSONReadScope.swift b/Sources/JSON/Reading/JSONReadScope.swift index 1c9dbef..68f8558 100644 --- a/Sources/JSON/Reading/JSONReadScope.swift +++ b/Sources/JSON/Reading/JSONReadScope.swift @@ -10,6 +10,7 @@ package final class JSONReadScope { private var rootBytes: UInt64 = 0 private var pathBytes: UInt64 = 0 private var retiredPathBytes: UInt64 = 0 + private var resultOwnsDocument = false package init(_ document: JSONDocument, limits: JSONLimits) throws { let state = JSONCodingState(options: .init(limits: limits), meter: try JSONWorkMeter(limits: limits, domain: .core, trackAcceptedCapacities: true)) try JSONAdmission.value(document.root, meter: &state.meter, owned: true) @@ -41,11 +42,23 @@ package final class JSONReadScope { try state.check(); return state } package func invalidate() { document = nil; state = nil } + /// Transfer the original admitted source alias into a source-attached result. + /// Only an owned package reducer uses this one-shot completion designation; + /// ordinary reads/visits retain their original input-refund behavior. + package func transferDocumentOwnership() throws -> JSONDocument { + let state = try check() + try state.meter.work() + guard !resultOwnsDocument, let document else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + resultOwnsDocument = true + return document + } package func complete(_ result: T) throws -> JSONOperationReport { let state = try check() // Paths/root/source cease to be scope-owned. Any escaped path is caller // storage and cannot access this invalidated root or ledger. - try state.meter.release(rootBytes + pathBytes) + try state.meter.release((resultOwnsDocument ? 0 : rootBytes) + pathBytes) let statistics = state.meter.statistics() invalidate() return .init(result: result, statistics: statistics) diff --git a/Sources/JSONCLIEngine/CLIBuildIdentity.swift b/Sources/JSONCLIEngine/CLIBuildIdentity.swift index 1467325..4f1e101 100644 --- a/Sources/JSONCLIEngine/CLIBuildIdentity.swift +++ b/Sources/JSONCLIEngine/CLIBuildIdentity.swift @@ -2,6 +2,6 @@ // Generated by Scripts/generate_cli_identity.py; excludes this file. // SHA-256 of the ordered Package.swift + Sources content manifest, not a Git commit. package enum CLIBuildIdentity { - package static let revision = "sha256:08bfabb7571edc5c1e5242afe312ade4ce91e23594bbcdb6476b9d74522e484e" + package static let revision = "sha256:80afb8a368fb023164ec08f480843d56617b3f10f4d942e549cbc3d0072d3538" package static let kind = "source-sha256" } diff --git a/Sources/JSONInspection/Documentation.docc/JSONInspection.md b/Sources/JSONInspection/Documentation.docc/JSONInspection.md index 41ab5b6..5b58e79 100644 --- a/Sources/JSONInspection/Documentation.docc/JSONInspection.md +++ b/Sources/JSONInspection/Documentation.docc/JSONInspection.md @@ -24,3 +24,11 @@ or numeric matrix. Sampling does not exempt any source from admission. - ``JSONShapeKindCounts`` - ``JSONColumnObservation`` - ``JSONShapeInspectionFailure`` + +### Capture complete source structure + +- +- ``JSONStructuralSnapshotBuilder`` +- ``JSONStructuralSnapshot`` +- ``JSONStructuralRecord`` +- ``JSONStructuralSnapshotFailure`` diff --git a/Sources/JSONInspection/Documentation.docc/StructuralSnapshots.md b/Sources/JSONInspection/Documentation.docc/StructuralSnapshots.md new file mode 100644 index 0000000..26e8359 --- /dev/null +++ b/Sources/JSONInspection/Documentation.docc/StructuralSnapshots.md @@ -0,0 +1,85 @@ +# Index complete physical structure + +Build source-attached metadata without replacing the canonical JSON document. + +## Capture even a scalar root + +```swift +let source = JSONDocument(root: .null) +let report = try JSONStructuralSnapshotBuilder(document: source).build() +let snapshot = report.result +let root = try snapshot.record(at: 0) +precondition(snapshot.recordCount == 1) +precondition(root.parentOrdinal == nil && root.componentFromParent == nil) +precondition(root.depth == 0 && root.childCount == 0 && root.subtreeEndExclusive == 1) +let value = try snapshot.value(for: 0) +precondition(value.result == .null) +``` + +The builder always covers one entire physical root, including null and empty +containers. No filter, prefix, prune, depth selection or caller callback can return +an incomplete snapshot. A negative maximumRecords fails configuration before +admission. Zero refuses the real root with a typed capacity error; there is no +successful empty or partial artifact. Quota exhaustion and cancellation throw. + +## Keep paths and numbers exact + +```swift +let source = try JSONParser().parseDocument(Data(#"{"":null,"0":[9007199254740993,0.0100]}"#.utf8)) +let snapshot = try JSONStructuralSnapshotBuilder(document: source).build().result +let rootPath = try snapshot.location(for: 0).result +let emptyKeyPath = try snapshot.location(for: 1).result +let arrayElementPath = try snapshot.location(for: 3).result +precondition(rootPath.isEmpty && emptyKeyPath == [.key("")]) +precondition(arrayElementPath == [.key("0"), .index(0)]) +let integer = try snapshot.value(for: 3).result.numberValue!.integer(as: UInt64.self) +let lexeme = try snapshot.value(for: 4).result.numberValue!.originalLexeme +precondition(integer == 9_007_199_254_740_993 && lexeme == "0.0100") +let root = try snapshot.record(at: 0) +precondition(root.subtreeEndExclusive == snapshot.recordCount) +``` + +Object members retain insertion order and decoded scalar key identity. Array +indices increase from zero. Root [] differs from an empty key; key "0" differs +from index 0. Parent ordinals are lower than children; finalized half-open subtree +ranges include the node and all its descendants, not merely direct children. +Numbers remain in the exact canonical source, with no binary64 projection. + +## Preserve source binding and explicit lookup budgets + +```swift +let document = try JSONParser().parseDocument(Data(#"{"old":null}"#.utf8)) +let snapshot = try JSONStructuralSnapshotBuilder(document: document).build().result +let replacement = document.replacingRoot(.array([42])) +let newer = try JSONStructuralSnapshotBuilder(document: replacement).build().result +let oldPath = try snapshot.location(for: 1) +let newPath = try newer.location(for: 1) +precondition(oldPath.result == [.key("old")] && newPath.result == [.index(0)]) +let oldSpan = try snapshot.sourceSpan(for: 1) +let newSpan = try newer.sourceSpan(for: 1) +precondition(oldSpan.result != nil && newSpan.result == nil) +precondition(oldPath.statistics[.nodes] == 2 && newPath.statistics[.nodes] == 2) +``` + +Ordinals are positions local to the particular snapshot method being called. +A record carries metadata, not a portable node identity. No method accepts a +replacement source or detached handle. An older snapshot keeps its original +immutable source and coherent map; it never follows another document’s revision. +Only original mapped spans are available. Invalid ordinals throw typed bounds +errors before admission rather than returning null, missing or a default record. + +Construction uses Navigation’s original single cumulative read scope and meter. +It transfers the already-admitted document ownership once after complete range +finalization, retaining one source and parent/edge records, without per-node JSON +values, full paths or source maps. Logical overlay v1 reserves 128 fixed bytes, +96 per record, exact edge-key UTF-8 bytes and 16 per open frame, plus original +source/path costs. These policy weights are not Swift heap layout or process RSS. + +record(at:) is O(1) metadata access without opening a new ledger. Each location, +value or sourceSpan call deliberately opens a separate finite operation and +re-admits the whole captured document, even for root or unmapped-span lookup. +Repeated K lookups pay K admissions; they do not share the builder’s remainder. +Path reconstruction also uses depth-sensitive core prefix copies and selection. +The existing traversal builds full hit paths, so total snapshot build work is +not guaranteed linear in node count. No batch session, persistence, stable source +fingerprint, table certification or new JSON representation is provided. diff --git a/Sources/JSONInspection/JSONStructuralSnapshot.swift b/Sources/JSONInspection/JSONStructuralSnapshot.swift new file mode 100644 index 0000000..52ba154 --- /dev/null +++ b/Sources/JSONInspection/JSONStructuralSnapshot.swift @@ -0,0 +1,240 @@ +// SPDX-License-Identifier: Apache-2.0 +import JSON +import JSONNavigation + +/// Read-only DFS preorder metadata for one physical node in a complete snapshot. +/// Ordinals are local positions in the containing snapshot, not transferable node +/// identities. A record cannot resolve a value or attach to a replacement source. +public struct JSONStructuralRecord: Sendable { + /// Zero-based preorder position within the containing snapshot. + public let ordinal: Int + /// Parent position, strictly lower than this ordinal; nil only for the root. + public let parentOrdinal: Int? + /// Exact key or array index from the parent; nil only for the physical root. + public let componentFromParent: JSONLocationComponent? + /// Canonical JSON kind; no inferred schema, missing or table kind. + public let kind: JSONTraversalKind + /// Number of physical edges from the root, whose depth is zero. + public let depth: Int + /// Number of immediate children; a scalar or empty container has zero. + public let childCount: Int + /// Finalized exclusive preorder end; this node’s subtree is [ordinal, end). + public internal(set) var subtreeEndExclusive: Int +} + +/// A capacity or local-position refusal; no partial snapshot or null substitute. +public enum JSONStructuralSnapshotFailure: Error, Sendable, Equatable { + /// The next physical node exceeds the inclusive record bound. + /// - Parameter limit: Nonnegative maximum configured for this build. + case recordLimitExceeded(limit: Int) + /// The supplied local position is outside 0.. JSONStructuralRecord { + guard ordinal >= 0, ordinal < records.count else { + throw JSONStructuralSnapshotFailure.ordinalOutOfBounds(ordinal) + } + return records[ordinal] + } + + /// Reconstructs an exact typed location in a separate bounded operation. + /// Re-admits the entire captured root/source/map before parent-chain/path work. + /// Core prefix copying can be quadratic in depth; this is not O(1) lookup. + /// - Parameters: + /// - ordinal: Position local to this snapshot; bounds checked before admission. + /// - limits: Finite quotas for this new lookup, independent of construction. + /// - Returns: Exact key/index path and cumulative lookup statistics; [] is root. + /// - Throws: Typed bounds, core resource/configuration failures or cancellation. + public func location(for ordinal: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport<[JSONLocationComponent]> { + try lookup(ordinal, limits: limits) { path, state, _ in + // Output path ownership survives scope completion's temporary refund. + for part in path { + try state.meter.work(); try state.meter.retain(JSONLogicalWeights.indexSlot) + if case .key(let key) = part { + for _ in key.string.utf8 { try state.meter.work(); try state.meter.retain(1) } + } + } + return path + } + } + + /// Resolves a value only against the captured source in a new bounded operation. + /// Each call re-admits the full source and reconstructs its typed path before + /// core selection. The result uses existing immutable read-value alias semantics; + /// no JSON subtree is cached in a record or converted through binary floating point. + /// - Parameters: + /// - ordinal: Position local to this snapshot; invalid positions never become null. + /// - limits: Finite quotas for this separate lookup, not the builder’s remainder. + /// - Returns: The canonical value, including explicit null, and lookup statistics. + /// - Throws: Typed bounds, core access/resource/configuration errors or cancellation. + public func value(for ordinal: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport { + try lookup(ordinal, limits: limits) { path, state, scope in + try state.meter.work() + return try scope.select(path, state: state) + } + } + + /// Looks up a coherent original value span in a new bounded operation. + /// Full captured-source admission and path reconstruction occur even without a + /// source map. A replacement/unmapped document has no invented historical span. + /// - Parameters: + /// - ordinal: Position local to this snapshot; bounds checked before admission. + /// - limits: Finite quotas for this separate source-map lookup. + /// - Returns: Original mapped span or nil when unavailable, plus lookup statistics. + /// - Throws: Typed bounds, core resource/configuration failures or cancellation. + public func sourceSpan(for ordinal: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport { + try lookup(ordinal, limits: limits) { path, state, _ in + try document.sourceMap?.span(at: path, kind: .value, meter: &state.meter) + } + } + + private func lookup(_ ordinal: Int, limits: JSONLimits, + _ body: ([JSONLocationComponent], JSONCodingState, JSONReadScope) throws -> Result) + throws -> JSONOperationReport { + // Invalid ordinals precede admission; never a null/missing default. + _ = try record(at: ordinal) + let scope = try JSONReadScope(document, limits: limits) + defer { scope.invalidate() } + let state = try scope.check() + var reversed: [JSONLocationComponent] = [], temporary: UInt64 = 0 + var current = ordinal + while let parent = records[current].parentOrdinal { + try state.meter.work() + guard parent >= 0, parent < current, let component = records[current].componentFromParent else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + try state.meter.retain(JSONLogicalWeights.indexSlot) + temporary = try state.meter.adding(.retainedBytes, temporary, JSONLogicalWeights.indexSlot) + if case .key(let key) = component { + for _ in key.string.utf8 { + try state.meter.work(); try state.meter.retain(1) + temporary = try state.meter.adding(.retainedBytes, temporary, 1) + } + } + reversed.append(component); current = parent + } + var path = JSONReadPath(scope: scope, components: [], bytes: 0) + for component in reversed.reversed() { + try state.meter.work() + path = try scope.append(component, to: path.components, state: state) + _ = try scope.check() + } + reversed = []; try state.meter.release(temporary) + return try scope.complete(scope.run(path.components) { try body(path.components, $0, scope) }) + } +} + +/// Builds complete source-attached metadata with one original cumulative ledger. +/// No filtering, pruning, prefix, callback, per-node JSON copy or second admission. +/// Records retain parent/edge metadata and one immutable document. Existing walker +/// hit paths mean total construction is depth-sensitive, not guaranteed O(nodes). +/// Logical overlay v1 is 128 fixed bytes, 96/record, exact UTF-8 edge-key bytes and +/// 16/live open frame, plus source/path admission. These weights are not heap/RSS. +public struct JSONStructuralSnapshotBuilder: Sendable { + /// Canonical immutable source; admitted once when build begins. + public let document: JSONDocument + /// Finite construction quotas shared by admission, traversal and finalization. + public let limits: JSONLimits + package var checkpointObserver: (@Sendable (UInt64) -> Void)? + package var lifetimeObserver: (@Sendable (Bool, Bool) -> Void)? + /// Captures trusted source and policy; this initializer performs no admission. + /// - Parameters: + /// - document: Physical canonical root, optionally with coherent source mapping. + /// - limits: One finite profile for the complete construction invocation. + public init(document: JSONDocument, limits: JSONLimits = .balanced) { + self.document = document; self.limits = limits + } + /// Returns every physical node with finalized ranges, or throws without an artifact. + /// Negative capacity fails before admission; zero refuses the real root. Even + /// null and empty containers have one record. Source ownership transfers once + /// only after complete traversal; temporary scope references are invalidated. + /// - Parameter maximumRecords: Inclusive nonnegative bound, default 100,000. + /// - Returns: Immutable complete snapshot and cumulative construction statistics. + /// - Throws: Typed capacity refusal, invalid configuration, resource exhaustion + /// or cancellation. No successful partial snapshot or terminal-error override. + public func build(maximumRecords: Int = 100_000) + throws -> JSONOperationReport { + guard maximumRecords >= 0 else { throw JSONFailure(.configuration, code: .invalidLimits) } + var reducer = SnapshotReducer(maximumRecords: maximumRecords) + var traversal = JSONTraversal(document: document, limits: limits) + traversal.checkpointObserver = checkpointObserver + traversal.lifetimeObserver = lifetimeObserver + return try traversal.inspectOwned(reducer: &reducer) + } +} + +/// Logical overlay v1: 128 fixed, 96/record + exact key bytes, 16/open frame. +private struct SnapshotReducer: JSONTraversalOwnedReducer { + let maximumRecords: Int + var records: [JSONStructuralRecord] = [] + var open: [Int] = [] + + mutating func close(_ end: Int, context: inout JSONTraversalContext) throws { + try context.work() + guard let ordinal = open.last, ordinal < end else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + records[ordinal].subtreeEndExclusive = end + open.removeLast(); try context.release(16) + } + + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { + try context.work() + let ordinal = records.count, depth = hit.relativeDepth + while open.count > depth { try close(ordinal, context: &context) } + guard open.count == depth, ordinal < maximumRecords else { + if ordinal >= maximumRecords { throw JSONStructuralSnapshotFailure.recordLimitExceeded(limit: maximumRecords) } + throw JSONFailure(.configuration, code: .invalidOperation) + } + if ordinal == 0 { try context.retain(128) } + let component = depth == 0 ? nil : hit.absoluteLocation.last + guard (depth == 0) == (component == nil) else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + try context.retain(96) + if case .key(let key) = component { try context.retainKey(key) } + let childCount: Int + switch value { case .object(let o): childCount = o.count; case .array(let a): childCount = a.count; default: childCount = 0 } + records.append(.init(ordinal: ordinal, parentOrdinal: open.last, componentFromParent: component, + kind: hit.kind, depth: depth, childCount: childCount, subtreeEndExclusive: 0)) + try context.retain(16); open.append(ordinal) + return .continue + } + + mutating func finish(_ summary: JSONTraversalSummary, + context: inout JSONTraversalContext) throws -> JSONStructuralSnapshot { + guard summary.completion == .complete, + summary.visitedCount == UInt64(records.count), + summary.emittedCount == UInt64(records.count), !records.isEmpty else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + while !open.isEmpty { try close(records.count, context: &context) } + let document = try context.transferDocumentOwnership() + let result = JSONStructuralSnapshot(document: document, records: records) + records = [] + return result + } +} diff --git a/Sources/JSONNavigation/JSONTraversalContext.swift b/Sources/JSONNavigation/JSONTraversalContext.swift index e075725..a08e58e 100644 --- a/Sources/JSONNavigation/JSONTraversalContext.swift +++ b/Sources/JSONNavigation/JSONTraversalContext.swift @@ -69,4 +69,8 @@ package struct JSONTraversalContext: ~Copyable { try scope.document?.sourceMap?.span(at: path, kind: .value, meter: &state.meter) } } + /// Transfer already-admitted input ownership, without exposing its scope. + package mutating func transferDocumentOwnership() throws -> JSONDocument { + try perform { _ in try scope.transferDocumentOwnership() } + } } diff --git a/Tests/JSONInspectionTests/SnapshotAcceptanceTests.swift b/Tests/JSONInspectionTests/SnapshotAcceptanceTests.swift new file mode 100644 index 0000000..3f4875f --- /dev/null +++ b/Tests/JSONInspectionTests/SnapshotAcceptanceTests.swift @@ -0,0 +1,278 @@ +// SPDX-License-Identifier: Apache-2.0 +import Foundation +import Synchronization +import Testing +import JSON +import JSONNavigation +import JSONInspection + +private func snapshot(_ text: String) throws -> JSONStructuralSnapshot { + try JSONStructuralSnapshotBuilder(document: JSONParser().parseDocument(Data(text.utf8))).build().result +} +private func snapshotFailure(_ body: () throws -> Void) -> JSONFailure? { + do { try body(); Issue.record("Expected resource failure") } + catch let error as JSONFailure { return error } + catch { Issue.record("Unexpected failure: \(error)") } + return nil +} + +@Test func snapshotS01ScalarAndEmptyRootsAreRealRecords() throws { + for text in ["null", "false", "1", #""s""#, "[]", "{}"] { + let result = try snapshot(text), root = try result.record(at: 0) + #expect(result.recordCount == 1 && root.parentOrdinal == nil && root.componentFromParent == nil) + #expect(root.ordinal == 0 && root.depth == 0 && root.childCount == 0 && root.subtreeEndExclusive == 1) + #expect(try result.location(for: 0).result.isEmpty) + #expect(try result.value(for: 0).result == result.document.root) + } +} + +@Test func snapshotS02RootEmptyAndNumericKeysRemainDistinct() throws { + let result = try snapshot(#"{"":1,"0":2}"#) + #expect(try result.location(for: 0).result == []) + #expect(try result.location(for: 1).result == [.key("")]) + #expect(try result.location(for: 2).result == [.key("0")]) + #expect(try result.record(at: 2).componentFromParent != .index(0)) +} + +@Test func snapshotS03NestedArrayPositionsIncreaseFromZero() throws { + let result = try snapshot("[[null,false],[]]") + let paths = try (0..= threshold { observed.withLock { $0 = true }; withUnsafeCurrentTask { $0?.cancel() } } + } + builder.lifetimeObserver = { rootGone, stateGone in invalidated.withLock { $0 = rootGone && stateGone } } + return try builder.build() + } + do { _ = try await task.value; Issue.record("No artifact may escape cancellation") } + catch is CancellationError { } + #expect(observed.withLock { $0 } && invalidated.withLock { $0 }) + } +} + +@Test func snapshotS19NavigationParityAndIndependentInvocations() async throws { + let document = try JSONParser().parseDocument(Data(#"{"rows":[{"a":null},{"b":1}]}"#.utf8)) + let traversal = JSONTraversal(document: document) + let before = try traversal.collect() + let builder = JSONStructuralSnapshotBuilder(document: document) + let baseline = try builder.build() + try await withThrowingTaskGroup(of: UInt64.self) { group in + for _ in 0..<4 { group.addTask { try builder.build().statistics[.workUnits] } } + for try await work in group { #expect(work == baseline.statistics[.workUnits]) } + } + let after = try traversal.collect() + #expect(before.result.nodes.map(\.absoluteLocation) == after.result.nodes.map(\.absoluteLocation)) + #expect(before.statistics[.workUnits] == after.statistics[.workUnits]) + #expect(before.statistics[.retainedBytes] == after.statistics[.retainedBytes]) + #expect(try JSONShapeInspector(document: document).inspectArray(at: [.key("rows")]).result.rowCoverage == .complete) +} + +@Test func snapshotS20OneOriginalAdmissionAndScopeRelease() throws { + let document = try JSONParser().parseDocument(Data(#"{"a":[1,2]}"#.utf8)) + let ordinary = try JSONTraversal(document: document).visit { _, _ in .continue } + let invalidated = Mutex(false) + var builder = JSONStructuralSnapshotBuilder(document: document) + builder.lifetimeObserver = { rootGone, stateGone in invalidated.withLock { $0 = rootGone && stateGone } } + let result = try builder.build() + #expect(result.statistics[.nodes] == ordinary.statistics[.nodes]) + #expect(result.statistics[.sourceMapEntries] == ordinary.statistics[.sourceMapEntries]) + #expect(invalidated.withLock { $0 }) + #expect(try result.result.value(for: 3).result == JSONParser().parse("2")) +} + +@Test func snapshotS21InclusiveWorkAndRetentionBudgets() throws { + let document = JSONDocument(root: .array([.null,.boolean(false)])) + let baseline = try JSONStructuralSnapshotBuilder(document: document).build() + var limits = JSONLimits.balanced; limits[.workUnits] = baseline.statistics[.workUnits] + #expect(try JSONStructuralSnapshotBuilder(document: document, limits: limits).build().result.recordCount == 3) + limits[.workUnits] -= 1 + #expect(snapshotFailure { _ = try JSONStructuralSnapshotBuilder(document: document, limits: limits).build() }?.resource?.attemptedUsage == baseline.statistics[.workUnits]) + limits = .balanced; limits[.retainedBytes] = baseline.statistics.peakLogicalRetainedBytes + #expect(try JSONStructuralSnapshotBuilder(document: document, limits: limits).build().statistics.peakLogicalRetainedBytes == limits[.retainedBytes]) + limits[.retainedBytes] -= 1 + #expect(snapshotFailure { _ = try JSONStructuralSnapshotBuilder(document: document, limits: limits).build() }?.resource?.metric == .retainedBytes) +} + +@Test func snapshotS22IterativeDepthAndBreadthStayFinite() throws { + var deep = JSON.null + for _ in 0..<128 { deep = .array([deep]) } + let depth = try JSONStructuralSnapshotBuilder(document: JSONDocument(root: deep)).build() + let wide = try JSONStructuralSnapshotBuilder(document: JSONDocument(root: .array(Array(repeating: .null, count: 1000)))).build() + #expect(depth.result.recordCount == 129 && wide.result.recordCount == 1001) + #expect(try depth.result.location(for: 128).result.count == 128) + #expect(try wide.result.location(for: 1000).result == [.index(999)]) + print("SNAPSHOT_RESOURCE depth=128 nodes=\(depth.result.recordCount) work=\(depth.statistics[.workUnits]) retained=\(depth.statistics[.retainedBytes]) peak=\(depth.statistics.peakLogicalRetainedBytes)") + print("SNAPSHOT_RESOURCE width=1000 nodes=\(wide.result.recordCount) work=\(wide.statistics[.workUnits]) retained=\(wide.statistics[.retainedBytes]) peak=\(wide.statistics.peakLogicalRetainedBytes)") +} + +@Test func snapshotS23SourceTransferIsOneShotAndOrdinaryReadsRefund() throws { + let document = JSONDocument(root: .array([.null])) + let scope = try JSONReadScope(document, limits: .balanced) + let retained = try scope.check().meter.used(.retainedBytes) + let source = try scope.transferDocumentOwnership() + #expect(source.root == document.root) + #expect(throws: JSONFailure.self) { _ = try scope.transferDocumentOwnership() } + #expect(try scope.complete(source).statistics[.retainedBytes] == retained) + #expect(scope.document == nil && scope.state == nil) + #expect(try document.readWithReport { _ in true }.statistics[.retainedBytes] == 0) +} + +@Test func snapshotS24LookupsAreSeparateBoundedOperations() throws { + let result = try snapshot(#"{"a":[{"b":null}]}"#) + let baseline = try result.location(for: 3) + var limits = JSONLimits.balanced; limits[.workUnits] = baseline.statistics[.workUnits] + #expect(try result.location(for: 3, limits: limits).result == [.key("a"),.index(0),.key("b")]) + limits[.workUnits] -= 1 + #expect(snapshotFailure { _ = try result.location(for: 3, limits: limits) }?.resource?.metric == .workUnits) + limits = .balanced; limits[.retainedBytes] = baseline.statistics.peakLogicalRetainedBytes + #expect(try result.location(for: 3, limits: limits).result.count == 3) + limits[.retainedBytes] -= 1 + #expect(snapshotFailure { _ = try result.location(for: 3, limits: limits) }?.resource?.metric == .retainedBytes) + limits = .balanced; limits[.pointerTokens] = 2 + let pathFailure = snapshotFailure { _ = try result.location(for: 3, limits: limits) } + #expect(pathFailure?.resource?.metric == .pointerTokens && pathFailure?.resource?.attemptedUsage == 3) + limits = .balanced; limits[.nodes] = 0 + #expect(snapshotFailure { _ = try result.value(for: 3, limits: limits) }?.resource?.metric == .nodes) + #expect(try result.value(for: 3).result == .null) // Existing explicit null; no absent/default API. + #expect(baseline.statistics[.retainedBytes] > 0) +} diff --git a/Tests/JSONInspectionTests/SnapshotPromotionTests.swift b/Tests/JSONInspectionTests/SnapshotPromotionTests.swift new file mode 100644 index 0000000..9823dae --- /dev/null +++ b/Tests/JSONInspectionTests/SnapshotPromotionTests.swift @@ -0,0 +1,123 @@ +// SPDX-License-Identifier: Apache-2.0 +import Foundation +import Synchronization +import Testing +import JSON +import JSONNavigation +import JSONInspection + +// Independent NAV6 packet oracle; no expected topology is generated by the walker. +@Test func snapshotV12IndependentMixedOracleMatchesEveryRecord() throws { + let text = "{\n \"\": {\"0\": [null, {\"id\": 9007199254740993, \"amount\": 0.0100}]},\n \"0\": [\"numeric object key, not index\"],\n \"é\": \"composed\",\n \"é\": \"decomposed\",\n \"rows\": [\n {\"z\": null, \"a\": 1},\n {\"a\": 2},\n {},\n {\"b\": 3, \"a\": 4},\n false\n ],\n \"matrix\": [[0.1, 2], [3]]\n}\n" + let result = try JSONStructuralSnapshotBuilder(document: JSONParser().parseDocument(Data(text.utf8))).build().result + let expected: [(Int?, JSONLocationComponent?, JSONTraversalKind, Int, Int, Int)] = [ + (nil, nil, .object, 0, 6, 28), + (0, .key(""), .object, 1, 1, 7), + (1, .key("0"), .array, 2, 2, 7), + (2, .index(0), .null, 3, 0, 4), + (2, .index(1), .object, 3, 2, 7), + (4, .key("id"), .number, 4, 0, 6), + (4, .key("amount"), .number, 4, 0, 7), + (0, .key("0"), .array, 1, 1, 9), + (7, .index(0), .string, 2, 0, 9), + (0, .key("é"), .string, 1, 0, 10), + (0, .key("é"), .string, 1, 0, 11), + (0, .key("rows"), .array, 1, 5, 22), + (11, .index(0), .object, 2, 2, 15), + (12, .key("z"), .null, 3, 0, 14), + (12, .key("a"), .number, 3, 0, 15), + (11, .index(1), .object, 2, 1, 17), + (15, .key("a"), .number, 3, 0, 17), + (11, .index(2), .object, 2, 0, 18), + (11, .index(3), .object, 2, 2, 21), + (18, .key("b"), .number, 3, 0, 20), + (18, .key("a"), .number, 3, 0, 21), + (11, .index(4), .boolean, 2, 0, 22), + (0, .key("matrix"), .array, 1, 2, 28), + (22, .index(0), .array, 2, 2, 26), + (23, .index(0), .number, 3, 0, 25), + (23, .index(1), .number, 3, 0, 26), + (22, .index(1), .array, 2, 1, 28), + (26, .index(0), .number, 3, 0, 28), + ] + #expect(result.recordCount == expected.count) + for ordinal in expected.indices { + let record = try result.record(at: ordinal), want = expected[ordinal] + #expect(record.ordinal == ordinal && record.parentOrdinal == want.0) + #expect(record.componentFromParent == want.1 && record.kind == want.2) + #expect(record.depth == want.3 && record.childCount == want.4 && record.subtreeEndExclusive == want.5) + } +} + +private enum TransferMarker: Error { case afterTransfer } +private struct TransferProbe: JSONTraversalOwnedReducer { + enum Mode: Sendable { case twice, work, caller, cancellation } + let mode: Mode + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { .continue } + mutating func finish(_ summary: JSONTraversalSummary, + context: inout JSONTraversalContext) throws -> JSONDocument { + let document = try context.transferDocumentOwnership() + switch mode { + case .twice: + do { _ = try context.transferDocumentOwnership() } catch { } + case .work: + do { try context.work(64_000_000) } catch { } + case .cancellation: + withUnsafeCurrentTask { $0?.cancel() } + do { try context.checkpoint() } catch { } + case .caller: throw TransferMarker.afterTransfer + } + // Success/replacement cannot mask a terminal failure latched after transfer. + if mode == .twice { return document } + throw TransferMarker.afterTransfer + } +} + +@Test func snapshotV20TransferFailureCannotPublishAndScopeAlwaysInvalidates() async throws { + let document = try JSONParser().parseDocument(Data("[null]".utf8)) + for mode in [TransferProbe.Mode.twice, .work, .caller, .cancellation] { + let invalidated = Mutex(false) + let task = Task { @Sendable [document, mode] in + var walk = JSONTraversal(document: document) + walk.lifetimeObserver = { rootGone, stateGone in invalidated.withLock { $0 = rootGone && stateGone } } + var probe = TransferProbe(mode: mode) + return try walk.inspectOwned(reducer: &probe) + } + do { _ = try await task.value; Issue.record("No post-transfer failure may publish a report") } + catch let error as JSONFailure { + if mode == .twice { #expect(error.category == .configuration && error.code == .invalidOperation) } + else { #expect(mode == .work && error.resource?.metric == .workUnits) } + } + catch is CancellationError { #expect(mode == .cancellation) } + catch is TransferMarker { #expect(mode == .caller) } + #expect(invalidated.withLock { $0 }) + } + // Ordinary read/visit/N2 have no ownership transfer: their refunds are unchanged. + #expect(try document.readWithReport { _ in true }.statistics[.retainedBytes] == 0) + #expect(try JSONTraversal(document: document).visit { _, _ in .continue }.statistics[.retainedBytes] == 0) + let shape = try JSONShapeInspector(document: document).inspectArray() + #expect(shape.statistics[.retainedBytes] == 256) +} + +@Test func snapshotV22ConcurrentLookupsUseIndependentAdmissionAndHealth() async throws { + let document = try JSONParser().parseDocument(Data(#"{"x":[null,9007199254740993]}"#.utf8)) + let snapshot = try JSONStructuralSnapshotBuilder(document: document).build().result + let baseline = try snapshot.value(for: 3) + try await withThrowingTaskGroup(of: UInt64.self) { group in + for ordinal in 0..<16 { group.addTask { + if ordinal.isMultiple(of: 2) { + var limits = JSONLimits.balanced; limits[.nodes] = 0 + do { _ = try snapshot.value(for: 3, limits: limits); Issue.record("Expected source-admission refusal") } + catch let error as JSONFailure { #expect(error.resource?.metric == .nodes) } + } + let value = try snapshot.value(for: 3) + #expect(value.result == baseline.result) + #expect(value.statistics[.nodes] == UInt64(snapshot.recordCount)) + #expect(try snapshot.location(for: 3).result == [.key("x"), .index(1)]) + #expect(try snapshot.sourceSpan(for: 3).result != nil) + return value.statistics[.workUnits] + } } + for try await work in group { #expect(work == baseline.statistics[.workUnits]) } + } +} diff --git a/Tools/SnapshotQualification/Package.swift b/Tools/SnapshotQualification/Package.swift new file mode 100644 index 0000000..0fec6e8 --- /dev/null +++ b/Tools/SnapshotQualification/Package.swift @@ -0,0 +1,12 @@ +// swift-tools-version: 6.4 +// SPDX-License-Identifier: Apache-2.0 +import PackageDescription +let package = Package( + name: "SnapshotQualification", + platforms: [.macOS("27.0"), .iOS("27.0")], + dependencies: [.package(name: "Swift-JSON", path: "../..")], + targets: [.executableTarget(name: "SnapshotConsumer", dependencies: [ + .product(name: "JSON", package: "Swift-JSON"), + .product(name: "JSONNavigation", package: "Swift-JSON"), + .product(name: "JSONInspection", package: "Swift-JSON")])], + swiftLanguageModes: [.v6]) diff --git a/Tools/SnapshotQualification/README.md b/Tools/SnapshotQualification/README.md new file mode 100644 index 0000000..818e0df --- /dev/null +++ b/Tools/SnapshotQualification/README.md @@ -0,0 +1,10 @@ +# Public snapshot consumer + +This independent SwiftPM package imports only public JSON, JSONNavigation and +JSONInspection APIs. Run `swift run -c release --package-path +Tools/SnapshotQualification SnapshotConsumer` on a qualified Swift 6.4 platform. +Its fourteen named checks exercise exact source-bound metadata and separate +bounded lookups, including negative capacity, bounds and quota cases. It does +not establish a release or physical-device qualification. The associated +`Scripts/qualify_snapshot.py` executes all three DocC examples and full-codegen +external-access rejections, with source-bound receipts. diff --git a/Tools/SnapshotQualification/Sources/SnapshotConsumer/Main.swift b/Tools/SnapshotQualification/Sources/SnapshotConsumer/Main.swift new file mode 100644 index 0000000..13b0590 --- /dev/null +++ b/Tools/SnapshotQualification/Sources/SnapshotConsumer/Main.swift @@ -0,0 +1,151 @@ +// SPDX-License-Identifier: Apache-2.0 +import Foundation +import JSON +import JSONNavigation +import JSONInspection + +private func expect(_ condition: @autoclosure () throws -> Bool) throws { + let satisfied = try condition(); precondition(satisfied) +} +private func check(_ name: String, _ body: () throws -> Void) rethrows { + try body(); print("SNAPSHOT_CHECK \(name) passed") +} +private func failure(_ body: () throws -> Void) -> JSONFailure { + do { try body(); preconditionFailure("Expected failure") } + catch let error as JSONFailure { return error } + catch { preconditionFailure("Unexpected error: \(error)") } +} +private func sendable(_ value: T) { _ = value } + +@main struct SnapshotConsumer { + static func main() async throws { + let source = #"{"":null,"0":[9007199254740993,0.1,0.0100],"é":true,"e\u0301":false,"/":{"~":[]}}"# + let document = try JSONParser().parseDocument(Data(source.utf8)) + let builder = JSONStructuralSnapshotBuilder(document: document) + let report = try builder.build() + let snapshot = report.result + sendable(builder); sendable(snapshot); sendable(try snapshot.record(at: 0)) + try check("roots") { + for text in ["null", "false", "1", #""s""#, "{}", "[]"] { + let one = try JSONStructuralSnapshotBuilder(document: .init(root: JSON.parse(text))).build().result + try expect(one.recordCount == 1) + let root = try one.record(at: 0) + try expect(root.ordinal == 0 && root.parentOrdinal == nil && root.componentFromParent == nil) + try expect(root.childCount == 0 && root.depth == 0 && root.subtreeEndExclusive == 1) + } + } + try check("typed-paths") { + try expect(try snapshot.location(for: 0).result == []) + try expect(try snapshot.location(for: 1).result == [.key("")]) + try expect(try snapshot.location(for: 2).result == [.key("0")]) + try expect(try snapshot.location(for: 3).result == [.key("0"), .index(0)]) + try expect(try snapshot.record(at: 2).componentFromParent != .index(0)) + } + try check("unicode") { + try expect(try snapshot.record(at: 6).componentFromParent == .key("é")) + try expect(try snapshot.record(at: 7).componentFromParent == .key("e\u{301}")) + try expect(try snapshot.record(at: 6).componentFromParent != snapshot.record(at: 7).componentFromParent) + } + try check("numbers") { + try expect(try snapshot.value(for: 3).result.numberValue?.integer(as: UInt64.self) == 9_007_199_254_740_993) + try expect(try snapshot.value(for: 4).result.numberValue == JSONNumber(parsing: "0.1")) + try expect(try snapshot.value(for: 5).result.numberValue?.originalLexeme == "0.0100") + try expect(try snapshot.value(for: 1).result == .null) + } + try check("duplicate-refusal") { + let error = failure { _ = try JSONParser().parse(#"{"a":0,"\u0061":1}"#) } + try expect(error.code == .duplicateKey) + } + try check("preorder-ranges") { + let expected = [10,2,6,4,5,6,7,8,10,10] + try expect(snapshot.recordCount == expected.count) + for ordinal in 0.. 0) + } + try expect(report.statistics[.nodes] == UInt64(snapshot.recordCount)) + var noNodes = JSONLimits.balanced; noNodes[.nodes] = 0 + try expect(failure { _ = try snapshot.value(for: 3, limits: noNodes) }.resource?.metric == .nodes) + print("SNAPSHOT_RESOURCE work=\(report.statistics[.workUnits]) retained=\(report.statistics[.retainedBytes]) peak=\(report.statistics.peakLogicalRetainedBytes) nodes=\(report.statistics[.nodes])") + } + try check("capacity-configuration") { + try expect(try builder.build(maximumRecords: snapshot.recordCount).result.recordCount == snapshot.recordCount) + for cap in [0, snapshot.recordCount-1] { + do { _ = try builder.build(maximumRecords: cap); preconditionFailure("No partial success") } + catch let error as JSONStructuralSnapshotFailure { try expect(error == .recordLimitExceeded(limit: cap)) } + } + var limits = JSONLimits.balanced; limits[.nodes] = 0 + try expect(failure { _ = try JSONStructuralSnapshotBuilder(document: document, limits: limits).build(maximumRecords: -1) }.category == .configuration) + } + try check("inclusive-budgets") { + var limits = JSONLimits.balanced; limits[.workUnits] = report.statistics[.workUnits] + try expect(try JSONStructuralSnapshotBuilder(document: document, limits: limits).build().result.recordCount == snapshot.recordCount) + limits[.workUnits] -= 1 + try expect(failure { _ = try JSONStructuralSnapshotBuilder(document: document, limits: limits).build() }.resource?.metric == .workUnits) + limits = .balanced; limits[.retainedBytes] = report.statistics.peakLogicalRetainedBytes + _ = try JSONStructuralSnapshotBuilder(document: document, limits: limits).build() + limits[.retainedBytes] -= 1 + try expect(failure { _ = try JSONStructuralSnapshotBuilder(document: document, limits: limits).build() }.resource?.metric == .retainedBytes) + } + try check("coverage-separation") { + let rows = try JSON.parse(#"[{"a":null},{"b":1},false]"#) + let evidence = try JSONShapeInspector(document: .init(root: rows)).inspectArray(sampling: .prefix(maximumRows: 2)).result + try expect(evidence.rowCoverage == .prefix(examined: 2, total: 3)) + try expect(evidence.observedAllObjects == true) + try expect(try JSONStructuralSnapshotBuilder(document: .init(root: rows)).build().result.recordCount == 6) + } + try await withThrowingTaskGroup(of: UInt64.self) { group in + for _ in 0..<4 { group.addTask { try snapshot.value(for: 3).statistics[.workUnits] } } + let expected = try snapshot.value(for: 3).statistics[.workUnits] + for try await work in group { try expect(work == expected) } + } + print("SNAPSHOT_CHECK concurrent-lookups passed") + print("SNAPSHOT_CONSUMER passed cases=14") + } +} From 931c042450bd19b1ed07fa6f7ecd1852c12e0023 Mon Sep 17 00:00:00 2001 From: Thorsten Fuchs <76904008+ThorFuchs@users.noreply.github.com> Date: Sun, 18 Oct 2026 11:01:06 +0200 Subject: [PATCH 2/3] Restore metered P1 tree and sparse-table proof with original acceptance corpus --- .../P1PrivateProjections.md | 90 ++ .../Qualification/ProjectionCases.json | 38 + .../Qualification/TestDiscovery.json | 10 +- Package.swift | 2 +- Scripts/ci.py | 28 +- Scripts/projection_acceptance.py | 10 + Scripts/qualify_projections.py | 98 ++ Scripts/test_qualification_harness.py | 25 +- Sources/JSONCLIEngine/CLIBuildIdentity.swift | 2 +- .../JSONSparseTableProjection.swift | 179 +++ .../Projections/JSONTreeProjection.swift | 183 +++ .../ProjectionAcceptanceTests.swift | 517 ++++++++ .../ProjectionFixtures/GENERATED-ORACLE.json | 133 ++ .../ProjectionFixtures/MANIFEST.sha256 | 22 + .../ProjectionFixtures/PACKET-ORACLE.json | 1093 +++++++++++++++++ .../ProjectionFixtures/deep-16.json | 1 + .../ProjectionFixtures/deep-256.json | 1 + .../ProjectionFixtures/deep-64.json | 1 + .../ProjectionFixtures/root-keys.json | 1 + .../ProjectionFixtures/sparse-1.json | 1 + .../ProjectionFixtures/sparse-10000.json | 1 + .../ProjectionFixtures/sparse-1024.json | 1 + .../ProjectionFixtures/sparse-16.json | 1 + .../ProjectionFixtures/table-complete.json | 1 + .../table-duplicate-keys.json | 1 + .../table-empty-objects.json | 1 + .../ProjectionFixtures/table-empty.json | 1 + .../ProjectionFixtures/table-equal-rows.json | 1 + .../table-late-invalid.json | 1 + .../ProjectionFixtures/table-nested.json | 1 + .../ProjectionFixtures/table-nonobject.json | 1 + .../table-numeric-keys.json | 1 + .../ProjectionFixtures/table-unicode.json | 1 + .../ProjectionFixtures/tree-nested.json | 1 + .../ProjectionFixtures/wide-1024.json | 1 + 35 files changed, 2428 insertions(+), 22 deletions(-) create mode 100644 Documentation/Architecture/StructuralIntelligence/P1PrivateProjections.md create mode 100644 Documentation/Qualification/ProjectionCases.json create mode 100644 Scripts/projection_acceptance.py create mode 100644 Scripts/qualify_projections.py create mode 100644 Sources/JSONInspection/Projections/JSONSparseTableProjection.swift create mode 100644 Sources/JSONInspection/Projections/JSONTreeProjection.swift create mode 100644 Tests/JSONInspectionTests/ProjectionAcceptanceTests.swift create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/GENERATED-ORACLE.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/MANIFEST.sha256 create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/PACKET-ORACLE.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/deep-16.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/deep-256.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/deep-64.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/root-keys.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/sparse-1.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/sparse-10000.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/sparse-1024.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/sparse-16.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-complete.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-duplicate-keys.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-empty-objects.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-empty.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-equal-rows.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-late-invalid.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-nested.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-nonobject.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-numeric-keys.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/table-unicode.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/tree-nested.json create mode 100644 Tests/JSONInspectionTests/ProjectionFixtures/wide-1024.json diff --git a/Documentation/Architecture/StructuralIntelligence/P1PrivateProjections.md b/Documentation/Architecture/StructuralIntelligence/P1PrivateProjections.md new file mode 100644 index 0000000..eac9d55 --- /dev/null +++ b/Documentation/Architecture/StructuralIntelligence/P1PrivateProjections.md @@ -0,0 +1,90 @@ +# NAV7 P1-A private projection proof + +Status: isolated package-only experiment, no new target or product, no merge/ +release/public-API approval. JSONInspection hosts the proof beside its immutable +snapshot. A separate JSONProjections module would add an interface solely for +private reuse; this wave needs no additional module boundary. N1/N2/N3 code and +public declarations remain unchanged. Exact compiled declarations/proofs are +recorded in the NAV7 return, not inferred from this design note. + +## Source and API + +`JSONTreeProjection.build(snapshot:rootOrdinal:limits:)` accepts a complete sealed +snapshot and returns a view of an original physical interval. It stores that +snapshot, selected root ordinal and finalized end only. Root metadata keeps its +original parent/depth; no synthetic root/value/DOM is constructed. Ordinary fixed +`record(at:)` reads have no new owned growth/report. `children` and `subtreeOrdinals` +are new bounded catalogue operations with an inclusive100000-record default; they +reject insufficient caps and never publish truncation. Direct children jump +finalized subtree ends. `location`, `value`, `sourceSpan` validate local view bounds, +then delegate exactly once to the existing independent N3 operation. + +Every tree build/catalogue invocation uses the established N1 exclusive reducer, +one original read scope and complete captured-source admission. Root-only traversal +reuses already-proven complete snapshot topology; it does not rebuild the tree or +continue the completed snapshot build's meter. Snapshot/row ordinals are local +positions, not portable identifiers. A bare Int can be reused as a position in +another source, but this API accepts no replacement source or detached node handle. + +`JSONSparseTableProjection.build(document:at:limits:maximumRows:maximumColumns: +maximumPresentCells:)` selects one existing array. Every row must be object or a +`nonObjectRow(at:kind:)` error identifies the exact physical row. Full source +admission precedes success, including unselected input. Empty0x0 is explicitly +allowed; `[{},{}]` is2x0. Positive N2 prefix evidence cannot admit an unseen suffix. +Rows remain original array indices, including equal rows. JSONKey columns follow +first encounter in source member order. Sparse member/column ordinal references +and nondecreasing row offsets retain empty rows without a dense null grid. +P27's offsets can be equal for empty rows; demanding strict increase would +contradict P18. Each nonempty row advances the offset. + +`cell(row:column:limits:)` is a separate original-source-admitted read operation. +It charges row-reference scans and delegates key/presence to core JSONObject +lookup/comparison. It returns canonical JSONPresence absent/null/value, preserves +arrays/objects/exact numbers/lexemes, and throws for bad bounds or inconsistent +metadata. It stores no per-cell JSON/path/span, normalizes no key and converts no +number. Wrong type, missing selection, nonobject, operational failure and null +remain distinct. The captured immutable source cannot be rebound. + +## Finite accounting policy v1 + +All49 core profiles/caps are unchanged. Additional inclusive defaults are100000 +rows,10000 columns and1000000 present members; negative configuration fails before +admission. Tree catalogue default is100000 records. Arithmetic products and count +increments are checked before growth. Each scan, key comparison, finalization +step, returned slot and key alias is charged on the original invocation ledger. +Unexpected capacity/resource/cancellation failures throw without successful output. + +Logical output overlays, plus core source/selection costs: + +- Tree view:64 descriptor +128 snapshot header +96 per retained record alias and + exact UTF8 edge-key bytes. COW sharing does not erase logical alias ownership. +- Catalogue:32 header +8 per ordinal;96 temporary record bytes are refunded. +- Table:256 summary +8 per offset +64 per column plus exact UTF8 key bytes +16 per + present member reference. A complete source ownership transfer occurs once. + +These are declared logical weights, not MemoryLayout, allocation bytes or RSS. +Sparse slots are O(rows+columns+present members); exact linear column scans may +be quadratic. Tree build/lookup costs still include full source/map admission; +N1/N3 path reconstruction remains depth-sensitive. No time, RSS, throughput or +scalability improvement is claimed. G4 remains HOLD with zero timed workloads. + +## Proof and boundaries + +32 Swift Testing identities cover all P01–P32 obligations and independent packet +oracles, exact keys/pointers/presence, deep16/64/256 and wide1024 trees, sparse +1/16/1024/10000 rows, core differentials, inclusive caps/work/retention, checked +overflow,16 concurrent mixed-success/failure views and cells, actual source +retention, legacy statistics parity, source replacement and post-finalization +terminal priority. Cancellation is exercised inside long key scans, offset +finalization and after source transfer; scope root/state invalidation is observed. +No deallocation of caller aliases or process-memory bound is claimed. + +The compiler qualifier requires ordinary primary diagnostics in Debug/Release: +external packages cannot name the package types; even same-package code cannot +forge a tree via its file-private initializer or mutate table source/columns. +Original ownership2-positive/20-negative and public Snapshot18-negative probes +remain separate. The full supported native/safety/docs/portable/SDK/archive lanes +must bind to final source. SDK builds do not establish device/simulator runtime. +Public projection surfaces, batching, persistence, durable identity, query DSL, +BFS/matrix/graph/retrieval, mutation, renderer/CLI integration and EngineBench are +future owner gates. No release version is assigned by this prototype. diff --git a/Documentation/Qualification/ProjectionCases.json b/Documentation/Qualification/ProjectionCases.json new file mode 100644 index 0000000..31532ed --- /dev/null +++ b/Documentation/Qualification/ProjectionCases.json @@ -0,0 +1,38 @@ +{ + "module": "JSONInspectionTests", + "functions": [ + "JSONInspectionTests.projectionP01ScalarRootIsOneExactLeaf()", + "JSONInspectionTests.projectionP02EmptyContainerKindsStayDifferent()", + "JSONInspectionTests.projectionP03RootAndEmptyKeyHaveDifferentLocations()", + "JSONInspectionTests.projectionP04NumericKeysAndIndicesAreNotAliases()", + "JSONInspectionTests.projectionP05ScalarExactUnicodeKeysNeverNormalize()", + "JSONInspectionTests.projectionP06ChildrenJumpOverGrandchildren()", + "JSONInspectionTests.projectionP07SourceInsertionAndArrayOrderAreCanonical()", + "JSONInspectionTests.projectionP08EveryRangeMatchesIndependentPacketOracleAndCore()", + "JSONInspectionTests.projectionP09EqualSiblingsKeepDistinctPhysicalPositions()", + "JSONInspectionTests.projectionP10SelectedSubtreeKeepsOriginalRootAndParent()", + "JSONInspectionTests.projectionP11ReplacementCannotRebindAViewOrGivePortableOrdinals()", + "JSONInspectionTests.projectionP12OnlyCapturedCoherentSourceSuppliesSpans()", + "JSONInspectionTests.projectionP13InclusiveCatalogueCapsNeverReturnTruncation()", + "JSONInspectionTests.projectionP14TreeWorkRetentionKeysAndCancellationAreBounded()", + "JSONInspectionTests.projectionP15DeepAndWideCataloguesRemainIterativeAndFinite()", + "JSONInspectionTests.projectionP16SharedViewsHaveIndependentHealthAndLegacyStatistics()", + "JSONInspectionTests.projectionP17EmptyArrayIsExplicitCompleteZeroByZero()", + "JSONInspectionTests.projectionP18EmptyObjectRowsNeverDisappear()", + "JSONInspectionTests.projectionP19EveryNonObjectRowFailsAtItsPhysicalPath()", + "JSONInspectionTests.projectionP20PositivePrefixCannotAdmitLateBadTable()", + "JSONInspectionTests.projectionP21ColumnsFollowFirstEncounterAcrossPermutations()", + "JSONInspectionTests.projectionP22UnicodeColumnsHaveExactSeparatePresence()", + "JSONInspectionTests.projectionP23EqualRowsRemainSeparatePhysicalRows()", + "JSONInspectionTests.projectionP24CellPresenceHasThreeCanonicalStates()", + "JSONInspectionTests.projectionP25MissingCountsUseEveryAdmittedObjectRow()", + "JSONInspectionTests.projectionP26NestedValuesAndExactNumbersRemainAtSource()", + "JSONInspectionTests.projectionP27SparsePrefixesAndMemberOrdinalsMatchOracle()", + "JSONInspectionTests.projectionP28BadBoundsKindsConfigurationPathsAndDuplicatesThrow()", + "JSONInspectionTests.projectionP29ScaleCapsAndCheckedProductsPrecedeGrowth()", + "JSONInspectionTests.projectionP30ConstructionHasOneAdmissionAndRetainsExactSparseOutput()", + "JSONInspectionTests.projectionP31CellLookupIsIndependentFullSourceAdmission()", + "JSONInspectionTests.projectionP32FinalizationFailureCancellationAndScopeTeardownAreTerminal()" + ], + "scope": "P01\u2013P32 private prototype; every exact identity required" +} diff --git a/Documentation/Qualification/TestDiscovery.json b/Documentation/Qualification/TestDiscovery.json index 65078da..6f5fc8a 100644 --- a/Documentation/Qualification/TestDiscovery.json +++ b/Documentation/Qualification/TestDiscovery.json @@ -12,7 +12,7 @@ "JSONCLITests": 88, "JSONNavigationTests": 47, "JSONSchemaExamplesTests": 98, - "JSONInspectionTests": 44 + "JSONInspectionTests": 76 }, "parameterized_invocations": 325, "composition_external_functions": 5, @@ -35,7 +35,7 @@ "JSONCLITests": 1, "JSONNavigationTests": 1, "JSONSchemaExamplesTests": 4, - "JSONInspectionTests": 3 + "JSONInspectionTests": 4 }, "coverage_unmapped": { "Sources/JSON/Pointer/JSONLocationComponent.swift": "declaration-only enum", @@ -76,7 +76,7 @@ "JSONCLITests": 88, "JSONNavigationTests": 47, "JSONSchemaExamplesTests": 98, - "JSONInspectionTests": 44 + "JSONInspectionTests": 76 }, "wasi_root_functions": { "JSONTests": 190, @@ -89,7 +89,7 @@ "JSONBridgesTests": 10, "JSONNavigationTests": 47, "JSONSchemaExamplesTests": 98, - "JSONInspectionTests": 44 + "JSONInspectionTests": 76 }, "wasi_parameterized_invocations": 288, "portable_shared_state_functions": { @@ -103,7 +103,7 @@ "JSONCLITests": 1, "JSONNavigationTests": 1, "JSONSchemaExamplesTests": 4, - "JSONInspectionTests": 3 + "JSONInspectionTests": 4 }, "export_functions": { "JSONSchemaTests": 1, diff --git a/Package.swift b/Package.swift index a2cd93c..dcdd32c 100644 --- a/Package.swift +++ b/Package.swift @@ -22,7 +22,7 @@ let package = Package( // Opt-in N1 product candidate; promotion does not change core navigation semantics. .target(name: "JSONNavigation", dependencies: ["JSON"]), .target(name: "JSONInspection", dependencies: ["JSON", "JSONNavigation"]), - .testTarget(name: "JSONInspectionTests", dependencies: ["JSONInspection", "JSONNavigation", "JSON"]), + .testTarget(name: "JSONInspectionTests", dependencies: ["JSONInspection", "JSONNavigation", "JSON"], resources: [.copy("ProjectionFixtures")]), .testTarget(name: "JSONNavigationTests", dependencies: ["JSONNavigation", "JSON"], exclude: ["Fixtures"]), .target(name: "JSONBridges", dependencies: ["JSON"]), .testTarget(name: "JSONIntegrationTests", dependencies: ["JSON", "JSONSchema", "JSONStreaming", "JSONPatch"]), diff --git a/Scripts/ci.py b/Scripts/ci.py index 606dea7..317bb2a 100644 --- a/Scripts/ci.py +++ b/Scripts/ci.py @@ -5,6 +5,7 @@ from archive_candidate import files from preflight import collect, collect_linux from testing_events import read_events, ROOT_PARAMETER_CASES +from projection_acceptance import check_projection_cases from test_discovery import DISCOVERY, ROOT_COUNTS, SHARED_COUNTS, PARAMETER_INVOCATIONS, check_restored ROOT = pathlib.Path(__file__).resolve().parents[1] @@ -15,6 +16,7 @@ SHARED_TESTS += '|navigationSharedImmutableRootIndependentInvocations' SHARED_TESTS += '|inspectionI17CoverageSpansReplacementAndSharedInvocations' SHARED_TESTS += '|snapshotS19NavigationParityAndIndependentInvocations|snapshotV22ConcurrentLookupsUseIndependentAdmissionAndHealth' +SHARED_TESTS += '|projectionP16SharedViewsHaveIndependentHealthAndLegacyStatistics' R0_TESTS = 'readerProbe|indexProbes|duplicateRecognitionPrecedesValueAndClosingSyntax' def snapshot(): @@ -25,12 +27,13 @@ def commands(lane, output): output = output.relative_to(ROOT) if lane == 'inspection': result = [['python3', '-B', 'Scripts/public_check.py'], - ['swift', 'test', '--filter', 'inspection|snapshot'], - ['swift', 'test', '-c', 'release', '--filter', 'inspection|snapshot'], - ['swift', 'test', '-c', 'release', '--sanitize', 'address', '--scratch-path', '.build/inspection-address', '--filter', 'inspection|snapshot'], + ['swift', 'test', '--filter', 'inspection|snapshot|projectionP'], + ['swift', 'test', '-c', 'release', '--filter', 'inspection|snapshot|projectionP'], + ['swift', 'test', '-c', 'release', '--sanitize', 'address', '--scratch-path', '.build/inspection-address', '--filter', 'inspection|snapshot|projectionP'], ['swift', 'build', '--target', 'JSONInspection', '--scratch-path', '.build/inspection-strict', '-Xswiftc', '-strict-memory-safety', '-Xswiftc', '-warnings-as-errors'], - ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')]] + ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')], + ['python3', '-B', 'Scripts/qualify_projections.py', '--output', str(output / 'projection-codegen')]] return [c + ['--disable-xctest'] if sys.platform == 'linux' and c[:2] == ['swift', 'test'] else c for c in result] if lane == 'schema-examples-qualification': return commands('schema-examples-advanced', ROOT / output) + [['python3', '-B', 'Scripts/qualify_schema_example_matrix.py', '--output', str(output / 'matrix')]] @@ -167,6 +170,7 @@ def commands(lane, output): ['python3', '-B', 'Scripts/qualify_navigation.py', '--output', str(output / 'navigation')], ['python3', '-B', 'Scripts/qualify_inspection.py', '--output', str(output / 'inspection-consumer')], ['python3', '-B', 'Scripts/qualify_snapshot.py', '--output', str(output / 'snapshot-consumer')], + ['python3', '-B', 'Scripts/qualify_projections.py', '--output', str(output / 'projection-codegen')], ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')], ['swift', 'test', '--package-path', 'Tools/MobileQualification'], ['swift', 'run', '-c', 'release', '--package-path', 'Tools/MobileQualification', 'MobileQualification'], @@ -226,20 +230,20 @@ def check_result(command, code, log, events=None): expected = [DISCOVERY['root_functions']['JSONNavigationTests']] if events is not None: passed = passed and events['module_function_counts'] == {'JSONNavigationTests': expected[0]} and events['parameter_case_invocations'] == 0 - if any(f in command for f in ['inspection', 'inspection|snapshot']): + if any(f in command for f in ['inspection', 'inspection|snapshot|projectionP']): expected = [DISCOVERY['root_functions']['JSONInspectionTests']] if events is not None: - passed = passed and events['module_function_counts'] == {'JSONInspectionTests': expected[0]} and events['parameter_case_invocations'] == 0 + passed = passed and events['module_function_counts'] == {'JSONInspectionTests': expected[0]} and events['parameter_case_invocations'] == 0 and check_projection_cases(events) passed = passed and sorted(counts) == expected if 'Tools/CompositionQualification' in command and events is not None: passed = passed and events['module_function_counts'] == {'CompositionScaleTests': DISCOVERY['composition_external_functions']} and events['parameter_case_invocations'] == 0 if 'qa' in command and events is not None: passed = passed and events['module_function_counts'] == DISCOVERY['qa_functions'] and check_restored(events) if 'thread' in command and 'JSONSchemaExamplesTests' not in command and events is not None: - passed = passed and events['module_function_counts'] == SHARED_COUNTS + passed = passed and events['module_function_counts'] == SHARED_COUNTS and check_projection_cases(events, shared=True) if '--filter' not in command and '--test-product' not in command and not any(x.startswith('Tools/') for x in command): if events is not None: - passed = passed and events['module_function_counts'] == ROOT_COUNTS and check_restored(events) + passed = passed and events['module_function_counts'] == ROOT_COUNTS and check_restored(events) and check_projection_cases(events) passed = passed and (events['parameterized_functions'] == ROOT_PARAMETER_CASES if events is not None else sum(int(n) for n in re.findall(r'with (\d+) test cases passed', log)) == PARAMETER_INVOCATIONS) if 'Tools/Qualification' in command: probes = re.findall(r'^CAP_PROBE (\w+) (\S+)$', log, re.MULTILINE) @@ -302,6 +306,12 @@ def check_result(command, code, log, events=None): passed = passed and 'REDUCER_CODEGEN passed positive=2 negative=20' in log.splitlines() if command[:3] == ['python3', '-B', 'Scripts/qualify_snapshot.py']: passed = passed and 'SNAPSHOT_COMPILER passed configurations=2 consumer_cases=14 address_cases=14 guide_fences=3 negative_probes=18' in log.splitlines() + if command[:3] == ['python3', '-B', 'Scripts/qualify_projections.py']: + data = json.loads((ROOT / command[command.index('--output') + 1] / 'receipt.json').read_text()) + probes = [c for c in data['commands'] if c.get('expected_diagnostic')] + passed = data['status'] == 'passed' and len(data['commands']) == 24 and len(probes) == 14 + passed = passed and all(c['status'] == 'passed' and not c['compiler_crash'] for c in data['commands']) + passed = passed and all(c['exit_code'] > 0 and any(c['expected_diagnostic'].lower() in d.lower() for d in c['primary_diagnostics']) for c in probes) if command[:3] == ['python3', '-B', 'Scripts/qualify_inspection.py']: passed = passed and 'INSPECTION_COMPILER passed configurations=2 consumer_cases=12 address_cases=12 guide_fences=3 negative_probes=8' in log.splitlines() if command[:3] == ['python3', '-B', 'Scripts/qualify_navigation.py']: @@ -313,7 +323,7 @@ def check_result(command, code, log, events=None): if command[:3] == ['python3', '-B', 'Scripts/qualify_html_browser.py']: passed = passed and 'JSONHTML_BROWSER passed engines=3 cases=76 skips=0' in log.splitlines() if 'Scripts/test_qualification_harness.py' in command: - passed = passed and 'HARNESS_TESTS passed cases=15' in log.splitlines() + passed = passed and 'HARNESS_TESTS passed cases=16' in log.splitlines() return passed, counts def main(): diff --git a/Scripts/projection_acceptance.py b/Scripts/projection_acceptance.py new file mode 100644 index 0000000..e6090c3 --- /dev/null +++ b/Scripts/projection_acceptance.py @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Pin the full private proof identities, not a blanket nonzero/exit-zero gate.""" +import json +import pathlib +ROOT = pathlib.Path(__file__).resolve().parents[1] +EXPECTED = frozenset(json.loads((ROOT / 'Documentation/Qualification/ProjectionCases.json').read_text())['functions']) +SHARED = frozenset({'JSONInspectionTests.projectionP16SharedViewsHaveIndependentHealthAndLegacyStatistics()'}) +def check_projection_cases(events, shared=False): + observed = [name for name in events['function_names'] if name.startswith('JSONInspectionTests.projectionP')] + return len(observed) == len(set(observed)) and set(observed) == (SHARED if shared else EXPECTED) diff --git a/Scripts/qualify_projections.py b/Scripts/qualify_projections.py new file mode 100644 index 0000000..6624146 --- /dev/null +++ b/Scripts/qualify_projections.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Full-codegen proof of package-only projection access; this creates no product.""" +import argparse, hashlib, json, pathlib, re, subprocess +from archive_candidate import files +ROOT = pathlib.Path(__file__).resolve().parents[1] +POSITIVE = r'''import Foundation +import JSON +import JSONNavigation +import JSONInspection +@main struct PrivateProjectionConsumer { + static func check(_ value: Bool) { precondition(value) } + static func main() throws { + let document = try JSONParser().parseDocument(Data(#"{"x":[{"0":9007199254740993},null]}"#.utf8)) + let snapshot = try JSONStructuralSnapshotBuilder(document: document).build().result + let view = try JSONTreeProjection.build(snapshot: snapshot, rootOrdinal: 1).result + check(try view.children(of: 1).result == [2,4]) + print("PRIVATE_PROJECTION tree passed") + check(try view.value(for: 3).result.numberValue?.integer(as: UInt64.self) == 9007199254740993) + print("PRIVATE_PROJECTION exact passed") + let source = try JSONParser().parseDocument(Data(#"[{"é":null},{"e\u0301":9007199254740993},{}]"#.utf8)) + let built = try JSONSparseTableProjection.build(document: source), table = built.result + check(table.columns == [JSONKey("é"), JSONKey("e\u{301}")]) + check(table.rowOffsets == [0,1,2,2]) + check(try table.cell(row: 0, column: 0).result == .null) + check(try table.cell(row: 2, column: 0).result == .absent) + print("PRIVATE_PROJECTION sparse-presence passed") + let lookup = try table.cell(row: 1, column: 1) + check(built.statistics[.nodes] == 6 && lookup.statistics[.nodes] == 6) + check(built.statistics[.retainedBytes] > 0 && lookup.statistics[.workUnits] > 0) + print("PRIVATE_PROJECTION admission passed") + let late = try JSONParser().parseDocument(Data("[{},{},false]".utf8)) + let evidence = try JSONShapeInspector(document: late).inspectArray(sampling: .prefix(maximumRows: 2)).result + check(evidence.observedAllObjects == true) + do { _ = try JSONSparseTableProjection.build(document: late); preconditionFailure("Late nonobject must fail") } + catch JSONProjectionFailure.nonObjectRow(let path, let kind) { check(path == [.index(2)] && kind == .boolean) } + print("PRIVATE_PROJECTION late-refusal passed") + } +} +''' +PROBES = [ + ('positive', POSITIVE, None, False), + ('external-tree', 'import JSONInspection\nlet x = JSONTreeProjection.self\n', 'cannot find', True), + ('external-table', 'import JSONInspection\nlet x = JSONSparseTableProjection.self\n', 'cannot find', True), + ('external-error', 'import JSONInspection\nlet x = JSONProjectionFailure.self\n', 'cannot find', True), + ('core-isolation', 'import JSON\nlet x = JSONTreeProjection.self\n', 'cannot find', True), + ('forged-tree', 'import JSONInspection\nfunc f(_ s: JSONStructuralSnapshot) { _ = JSONTreeProjection(snapshot: s, rootOrdinal: 0, endExclusive: 1) }\n', 'initializer is inaccessible', False), + ('immutable-source', 'import JSON\nimport JSONInspection\nfunc f(_ x: inout JSONSparseTableProjection) { x.document = JSONDocument(root: .null) }\n', "'document' is a 'let' constant", False), + ('immutable-columns', 'import JSONInspection\nfunc f(_ x: inout JSONSparseTableProjection) { x.columns.removeAll() }\n', "'columns' is a 'let' constant", False), +] +CHECKS = {'tree', 'exact', 'sparse-presence', 'admission', 'late-refusal'} + +def main(): + parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('--output', required=True) + out = ROOT / parser.parse_args().output; out.mkdir(parents=True, exist_ok=True) + receipt = dict(status='running', scope='same-package private consumer + external-package rejection; no public projection product', + source_inputs=[dict(path=p.relative_to(ROOT).as_posix(), sha256=hashlib.sha256(p.read_bytes()).hexdigest()) for p in files()], commands=[]) + def save(): (out / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n') + def run(name, command, expected=None): + result = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, timeout=900) + text = result.stdout + result.stderr; diagnostics = re.findall(r': error: ([^\n]+)', result.stderr) + crash = result.returncode < 0 or any(s in text for s in ['Stack dump:', 'Assertion failed', 'fatal error encountered during compilation', 'Found ownership error']) + passed = not crash and (result.returncode == 0 if expected is None else result.returncode > 0 and any(expected.lower() in d.lower() for d in diagnostics)) + log = out / (name + '.log'); log.write_text(text.replace(str(ROOT), '.')) + receipt['commands'].append(dict(name=name, command=[x.replace(str(ROOT), '.') for x in command], exit_code=result.returncode, + status='passed' if passed else 'failed', compiler_crash=crash, expected_diagnostic=expected, + primary_diagnostics=diagnostics, log=log.relative_to(ROOT).as_posix(), log_sha256=hashlib.sha256(log.read_bytes()).hexdigest())) + save() + if not passed: raise ValueError('Unexpected projection compiler outcome: ' + name) + return result.stdout + try: + identity = re.sub(r'[^a-zA-Z0-9_]', '_', ROOT.name.lower()) + if not identity or identity[0].isdigit(): identity = '_' + identity + for config in ['debug', 'release']: + run(config + '-build', ['swift','build','-c',config,'--target','JSONInspection']) + binpath = pathlib.Path(run(config + '-binpath', ['swift','build','-c',config,'--show-bin-path']).strip()) + modules = binpath / 'Modules' if (binpath / 'Modules').is_dir() else binpath + common = ['swiftc','-swift-version','6','-warnings-as-errors','-I',str(modules),'-Onone' if config == 'debug' else '-O','-parse-as-library'] + for name, text, diagnostic, external in PROBES: + source = out / (name + '.swift'); source.write_text(text) + run(config + '-' + name, common + ['-package-name','projection_external' if external else identity, + '-module-name','ProjectionCompilerProbe','-c',str(source),'-o',str(out / (config + '-' + name + '.o'))], diagnostic) + objects = [] + for module in ['JSON','JSONNavigation','JSONInspection']: + aggregate = binpath / (module + '.o') + selected = [aggregate] if aggregate.is_file() else sorted((binpath / (module + '.build')).glob('*.o')) + if not selected: raise ValueError('Missing objects: ' + module) + objects.extend(str(p) for p in selected) + binary = out / ('private-' + config) + run(config + '-link', common + ['-package-name',identity,str(out/'positive.swift'),*objects,'-o',str(binary)]) + output = run(config + '-run', [str(binary)]) + checks = re.findall(r'^PRIVATE_PROJECTION (\S+) passed$', output, re.M) + if len(checks) != 5 or set(checks) != CHECKS: raise ValueError('Private projection consumer identity/count drift') + receipt['status'] = 'passed' + except (ValueError, OSError, subprocess.TimeoutExpired) as error: receipt.update(status='failed', error=str(error)) + save(); print('PROJECTIONS_COMPILER ' + receipt['status'] + ' commands=24 positive_codegen=2 negative_codegen=14 private_cases=5/config') + return 0 if receipt['status'] == 'passed' else 1 +if __name__ == '__main__': raise SystemExit(main()) diff --git a/Scripts/test_qualification_harness.py b/Scripts/test_qualification_harness.py index ea91700..715800d 100644 --- a/Scripts/test_qualification_harness.py +++ b/Scripts/test_qualification_harness.py @@ -12,6 +12,7 @@ from coverage import executable_objects, shared_objects, validate_export, without_schema_objects from test_discovery import DISCOVERY, ROOT_COUNTS, PARAMETER_INVOCATIONS, check_root, check_restored, RESTORED_FUNCTIONS from ci import check_result, commands +from projection_acceptance import EXPECTED as PROJECTION_FUNCTIONS, check_projection_cases class HarnessTests(unittest.TestCase): def test_composition_discovery_and_capacity_limits_are_not_blanket_successes(self): @@ -35,11 +36,11 @@ def test_composition_discovery_and_capacity_limits_are_not_blanket_successes(sel # Combined-source checks must retain both independently owned optional products. for module, count, command in [ ('JSONNavigationTests', 47, ['swift', 'test', '--filter', 'navigation']), - ('JSONInspectionTests', 44, ['swift', 'test', '--filter', 'inspection']), + ('JSONInspectionTests', 76, ['swift', 'test', '--filter', 'inspection|snapshot|projectionP']), ('JSONSchemaExamplesTests', 98, ['swift', 'test', '--test-product', 'JSONSchemaExamplesTests']), ]: events = dict(bundle_counts=[count], module_function_counts={module: count}, - parameter_case_invocations=0) + parameter_case_invocations=0, function_names=sorted(PROJECTION_FUNCTIONS) if module == 'JSONInspectionTests' else []) self.assertTrue(check_result(command, 0, '', events)[0]) for broken in [dict(events, bundle_counts=[count-1]), dict(events, module_function_counts={'WrongModule': count}), @@ -49,14 +50,26 @@ def test_composition_discovery_and_capacity_limits_are_not_blanket_successes(sel for key in ('root_functions', 'portable_root_functions', 'wasi_root_functions'): self.assertEqual(policy[key]['JSONNavigationTests'], 47) self.assertEqual(policy[key]['JSONSchemaExamplesTests'], 98) - self.assertEqual(policy[key]['JSONInspectionTests'], 44) + self.assertEqual(policy[key]['JSONInspectionTests'], 76) self.assertEqual(policy[key]['JSONIntegrationTests'], 32) for key in ('shared_state_functions', 'portable_shared_state_functions'): self.assertEqual(policy[key]['JSONNavigationTests'], 1) self.assertEqual(policy[key]['JSONSchemaExamplesTests'], 4) - self.assertEqual(policy[key]['JSONInspectionTests'], 3) + self.assertEqual(policy[key]['JSONInspectionTests'], 4) self.assertEqual(policy[key]['JSONIntegrationTests'], 11) + def test_private_projection_identities_cannot_be_missing_renamed_or_duplicated(self): + names = sorted(PROJECTION_FUNCTIONS) + self.assertEqual(len(names), 32) + self.assertTrue(check_projection_cases({'function_names': names})) + for broken in [names[:-1], names + names[:1], + ['WrongModule.' + names[0].split('.', 1)[1]] + names[1:], + [names[0].replace('projectionP01', 'projectionP99')] + names[1:]]: + self.assertFalse(check_projection_cases({'function_names': broken})) + shared = ['JSONInspectionTests.projectionP16SharedViewsHaveIndependentHealthAndLegacyStatistics()'] + self.assertTrue(check_projection_cases({'function_names': shared}, shared=True)) + self.assertFalse(check_projection_cases({'function_names': []}, shared=True)) + def setUp(self): self.temporary = tempfile.TemporaryDirectory() self.addCleanup(self.temporary.cleanup) @@ -148,8 +161,8 @@ def test_exact_discovery_rejects_missing_duplicate_and_changed_parameters(self): identity['function_names'][0] = 'JSONTests.unrelatedReplacement()' self.assertFalse(check_restored(identity)) harness = ['python3', '-B', 'Scripts/test_qualification_harness.py'] - self.assertTrue(check_result(harness, 0, 'HARNESS_TESTS passed cases=15')[0]) - for stale in ['HARNESS_TESTS passed cases=10', 'HARNESS_TESTS passed cases=11', 'HARNESS_TESTS passed cases=12', 'HARNESS_TESTS passed cases=13', 'HARNESS_TESTS passed cases=14', '']: + self.assertTrue(check_result(harness, 0, 'HARNESS_TESTS passed cases=16')[0]) + for stale in ['HARNESS_TESTS passed cases=10', 'HARNESS_TESTS passed cases=11', 'HARNESS_TESTS passed cases=12', 'HARNESS_TESTS passed cases=13', 'HARNESS_TESTS passed cases=14', 'HARNESS_TESTS passed cases=15', '']: self.assertFalse(check_result(harness, 0, stale)[0]) lifetime = ['python3', '-B', 'Scripts/qualify_schema_example_lifetime.py'] marker = 'SCHEMA_EXAMPLES_CORPUS passed mode=owned scopes=128 values=6 exact=1' diff --git a/Sources/JSONCLIEngine/CLIBuildIdentity.swift b/Sources/JSONCLIEngine/CLIBuildIdentity.swift index 4f1e101..814a35c 100644 --- a/Sources/JSONCLIEngine/CLIBuildIdentity.swift +++ b/Sources/JSONCLIEngine/CLIBuildIdentity.swift @@ -2,6 +2,6 @@ // Generated by Scripts/generate_cli_identity.py; excludes this file. // SHA-256 of the ordered Package.swift + Sources content manifest, not a Git commit. package enum CLIBuildIdentity { - package static let revision = "sha256:80afb8a368fb023164ec08f480843d56617b3f10f4d942e549cbc3d0072d3538" + package static let revision = "sha256:7e310dcd81c91d14bf17bfeb2e4bf40434863f451fdd9bb21245b83bd56c2928" package static let kind = "source-sha256" } diff --git a/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift b/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift new file mode 100644 index 0000000..8a6c3f0 --- /dev/null +++ b/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift @@ -0,0 +1,179 @@ +// SPDX-License-Identifier: Apache-2.0 +import JSON +import JSONNavigation + +/// Original object-member and first-seen column positions; row is the offset slice. +package struct JSONSparseTableMember: Sendable, Equatable { + package let memberOrdinal: Int + package let columnOrdinal: Int +} + +/// Experimental complete all-object array metadata, never a schema/matrix verdict. +/// Stores no cell JSON/path copy, dense grid, guessed row id or normalized key. +package struct JSONSparseTableProjection: Sendable { + package let document: JSONDocument + package let selectedArrayPath: [JSONLocationComponent] + package let rowCount: Int + package let columns: [JSONKey] + /// Nondecreasing prefix offsets; an empty object row has an empty slice. + package let rowOffsets: [Int] + package let presentMembers: [JSONSparseTableMember] + /// Descendant traversal may be restricted although every physical row was admitted. + package let traversal: JSONTraversalSummary + fileprivate init(document: JSONDocument, selectedArrayPath: [JSONLocationComponent], + rowCount: Int, columns: [JSONKey], rowOffsets: [Int], + presentMembers: [JSONSparseTableMember], traversal: JSONTraversalSummary) { + self.document = document; self.selectedArrayPath = selectedArrayPath + self.rowCount = rowCount; self.columns = columns; self.rowOffsets = rowOffsets + self.presentMembers = presentMembers; self.traversal = traversal + } + + /// One original N1 invocation, complete source admission and strict object rows. + /// Inclusive defaults:100000 rows,10000 columns,1000000 present members. + /// Negative configuration precedes admission; source/root and row failures throw. + /// Logical policy v1:256 fixed +8/offset +64/column +exact key bytes +16/member, + /// retained selection and captured source. No partial or prefix output exists. + package static func build(document: JSONDocument, at path: [JSONLocationComponent] = [], + limits: JSONLimits = .balanced, maximumRows: Int = 100_000, + maximumColumns: Int = 10_000, maximumPresentCells: Int = 1_000_000) + throws -> JSONOperationReport { + guard maximumRows >= 0, maximumColumns >= 0, maximumPresentCells >= 0 else { + throw JSONFailure(.configuration, code: .invalidLimits) + } + var reducer = SparseTableReducer(maximumRows: maximumRows, maximumColumns: maximumColumns, + maximumPresentCells: maximumPresentCells, limits: limits) + return try JSONTraversal(document: document, limits: limits).inspectOwned( + scope: .subtree(at: path), options: .init(depthLimit: 1), reducer: &reducer) + } + + /// A NEW owned whole-source-admitted lookup, not the construction meter's remainder. + /// Row slices are scanned with charged work. Core JSONObject lookup and scalar + /// comparison own presence/key identity. Wrong bounds never become absence/null. + package func cell(row: Int, column: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport> { + guard row >= 0, row < rowCount else { throw JSONProjectionFailure.rowOutOfBounds(row) } + guard column >= 0, column < columns.count else { throw JSONProjectionFailure.columnOutOfBounds(column) } + let scope = try JSONReadScope(document, limits: limits) + defer { scope.invalidate() } + let state = try scope.check() + var path = JSONReadPath(scope: scope, components: [], bytes: 0) + for component in selectedArrayPath { + try state.meter.work(); path = try scope.append(component, to: path.components, state: state) + _ = try scope.check() + } + path = try scope.append(.index(row), to: path.components, state: state) + let result: JSONPresence = try scope.run(path.components) { state in + guard case .object(let object) = try scope.select(path.components, state: state) else { + throw JSONFailure(.typeMismatch, code: .wrongKind) + } + var member: Int? + // row+1 is safe: construction checked rowCount+1 and row= 0, ordinal < object.count, + try JSONComparison.textEquals(object[ordinal].key.string, columns[column].string, + meter: &state.meter) else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + if case .null = value { return .null } + return .value(value) + default: throw JSONFailure(.configuration, code: .invalidOperation) + } + } + return try scope.complete(result) + } +} + +internal struct SparseTableReducer: JSONTraversalOwnedReducer { + let maximumRows: Int + let maximumColumns: Int + let maximumPresentCells: Int + let limits: JSONLimits + var selection: [JSONLocationComponent] = [] + var totalRows = 0, rows = 0 + var columns: [JSONKey] = [] + var offsets: [Int] = [] + var members: [JSONSparseTableMember] = [] + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { + try context.work() + if hit.relativeDepth == 0 { + totalRows = try context.arrayCount(value, at: hit.absoluteLocation) + guard totalRows <= maximumRows else { throw JSONProjectionFailure.rowLimitExceeded(limit: maximumRows) } + _ = try ProjectionAccounting.next(totalRows, limits: limits) + try context.retain(256) + selection = try context.retainLocation(hit.absoluteLocation) + try context.retain(8); offsets.append(0) + return .continue + } + guard case .object(let object) = value else { + let path = try context.retainLocation(hit.absoluteLocation) + throw JSONProjectionFailure.nonObjectRow(at: path, kind: hit.kind) + } + for ordinal in 0.. JSONSparseTableProjection { + let offsetCount = try ProjectionAccounting.next(totalRows, limits: limits) + guard rows == totalRows, offsets.count == offsetCount, offsets.first == 0, + offsets.last == members.count, summary.visitedCount == UInt64(offsetCount), + summary.emittedCount == UInt64(offsetCount) else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + for position in offsets.indices { + try context.work() + guard offsets[position] >= 0, offsets[position] <= members.count, + position == 0 || offsets[position - 1] <= offsets[position] else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + } + for member in members { + try context.work() + guard member.memberOrdinal >= 0, member.columnOrdinal >= 0, + member.columnOrdinal < columns.count else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + } + let document = try context.transferDocumentOwnership() + let result = JSONSparseTableProjection(document: document, selectedArrayPath: selection, + rowCount: totalRows, columns: columns, rowOffsets: offsets, presentMembers: members, + traversal: summary) + selection = []; columns = []; offsets = []; members = [] + return result + } +} diff --git a/Sources/JSONInspection/Projections/JSONTreeProjection.swift b/Sources/JSONInspection/Projections/JSONTreeProjection.swift new file mode 100644 index 0000000..763cb22 --- /dev/null +++ b/Sources/JSONInspection/Projections/JSONTreeProjection.swift @@ -0,0 +1,183 @@ +// SPDX-License-Identifier: Apache-2.0 +import JSON +import JSONNavigation + +/// Experimental package-only refusals. Positions are local to the captured source. +package enum JSONProjectionFailure: Error, Sendable, Equatable { + case outsideSelectedSubtree(ordinal: Int) + case recordLimitExceeded(limit: Int) + case rowLimitExceeded(limit: Int) + case columnLimitExceeded(limit: Int) + case presentCellLimitExceeded(limit: Int) + case rowOutOfBounds(Int) + case columnOutOfBounds(Int) + case nonObjectRow(at: [JSONLocationComponent], kind: JSONTraversalKind) +} + +/// Version1 logical slot policy, not allocator sizes or a process memory limit. +internal enum ProjectionAccounting { + static func bytes(_ count: Int, unit: UInt64, limits: JSONLimits) throws -> UInt64 { + guard count >= 0 else { throw JSONFailure(.configuration, code: .invalidLimits) } + let (result, overflow) = UInt64(count).multipliedReportingOverflow(by: unit) + guard !overflow else { throw overflowFailure(limits) } + return result + } + static func next(_ count: Int, limits: JSONLimits) throws -> Int { + guard count >= 0 else { throw JSONFailure(.configuration, code: .invalidLimits) } + let (next, overflow) = count.addingReportingOverflow(1) + guard !overflow else { throw overflowFailure(limits) } + return next + } + private static func overflowFailure(_ limits: JSONLimits) -> JSONFailure { + JSONFailure(.resource, code: .counterOverflow, resource: .init( + domain: .core, metric: .retainedBytes, limit: limits[.retainedBytes], + attemptedUsage: nil, overflow: true)) + } +} + +/// A selected physical interval in one complete sealed snapshot, not another DOM. +/// No source replacement or detached handle is accepted. Metadata keeps original +/// parent/depth/path meaning, even when the selected root has a physical parent. +package struct JSONTreeProjection: Sendable { + package let snapshot: JSONStructuralSnapshot + package let rootOrdinal: Int + package let endExclusive: Int + fileprivate init(snapshot: JSONStructuralSnapshot, rootOrdinal: Int, endExclusive: Int) { + self.snapshot = snapshot; self.rootOrdinal = rootOrdinal; self.endExclusive = endExclusive + } + + /// One new owned operation over an already-built snapshot. Full source admission, + /// all retained record/key aliases and selection share the original N1 ledger. + /// Output policy:64 view +128 snapshot header +96/record +exact edge UTF8 bytes, + /// plus the already-admitted source. The physical COW storage may be shared. + package static func build(snapshot: JSONStructuralSnapshot, rootOrdinal: Int = 0, + limits: JSONLimits = .balanced) + throws -> JSONOperationReport { + guard rootOrdinal >= 0, rootOrdinal < snapshot.recordCount else { + throw JSONStructuralSnapshotFailure.ordinalOutOfBounds(rootOrdinal) + } + var reducer = TreeViewReducer(snapshot: snapshot, rootOrdinal: rootOrdinal, limits: limits) + return try JSONTraversal(document: snapshot.document, limits: limits) + .inspectOwned(options: .init(depthLimit: 0), reducer: &reducer) + } + + /// Ordinary fixed metadata access; there is no owned growth or new report. + package func record(at ordinal: Int) throws -> JSONStructuralRecord { + try validate(ordinal) + return try snapshot.record(at: ordinal) + } + private func validate(_ ordinal: Int) throws { + guard ordinal >= rootOrdinal, ordinal < endExclusive else { + throw JSONProjectionFailure.outsideSelectedSubtree(ordinal: ordinal) + } + } + + /// New full-source-admitted operation. Every read/jump/append is charged; + /// returned slots cost32 fixed +8/ordinal, with96 temporary record bytes. + package func children(of ordinal: Int, maximumRecords: Int = 100_000, + limits: JSONLimits = .balanced) throws -> JSONOperationReport<[Int]> { + try catalogue(ordinal, childrenOnly: true, maximumRecords: maximumRecords, limits: limits) + } + /// Includes the selected node in its finalized half-open preorder interval. + /// An insufficient inclusive cap throws rather than returning a truncated list. + package func subtreeOrdinals(of ordinal: Int, maximumRecords: Int = 100_000, + limits: JSONLimits = .balanced) throws -> JSONOperationReport<[Int]> { + try catalogue(ordinal, childrenOnly: false, maximumRecords: maximumRecords, limits: limits) + } + private func catalogue(_ ordinal: Int, childrenOnly: Bool, maximumRecords: Int, + limits: JSONLimits) throws -> JSONOperationReport<[Int]> { + guard maximumRecords >= 0 else { throw JSONFailure(.configuration, code: .invalidLimits) } + try validate(ordinal) + var reducer = TreeCatalogueReducer(view: self, ordinal: ordinal, + childrenOnly: childrenOnly, maximumRecords: maximumRecords) + return try JSONTraversal(document: snapshot.document, limits: limits) + .inspectOwned(options: .init(depthLimit: 0), reducer: &reducer) + } + + /// Each forwarding call delegates once to N3's independent full-source lookup. + /// Constant local bounds checks are ordinary metadata access, not a hidden operation. + package func location(for ordinal: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport<[JSONLocationComponent]> { + try validate(ordinal); return try snapshot.location(for: ordinal, limits: limits) + } + package func value(for ordinal: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport { + try validate(ordinal); return try snapshot.value(for: ordinal, limits: limits) + } + package func sourceSpan(for ordinal: Int, limits: JSONLimits = .balanced) + throws -> JSONOperationReport { + try validate(ordinal); return try snapshot.sourceSpan(for: ordinal, limits: limits) + } +} + +/// Internal reducers are also exercised by post-finalization lifetime/failure proofs. +internal struct TreeViewReducer: JSONTraversalOwnedReducer { + let snapshot: JSONStructuralSnapshot + let rootOrdinal: Int + let limits: JSONLimits + var endExclusive = 0 + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { + try context.work() + guard rootOrdinal >= 0, rootOrdinal < snapshot.recordCount else { + throw JSONStructuralSnapshotFailure.ordinalOutOfBounds(rootOrdinal) + } + try context.retain(192) + try context.retain(ProjectionAccounting.bytes(snapshot.recordCount, unit: 96, limits: limits)) + for ordinal in 0.. rootOrdinal, endExclusive <= snapshot.recordCount else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + return .skipDescendants + } + mutating func finish(_ summary: JSONTraversalSummary, + context: inout JSONTraversalContext) throws -> JSONTreeProjection { + guard summary.visitedCount == 1, summary.emittedCount == 1 else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + // The executor's input is exactly snapshot.document, with no replacement + // parameter. The view's captured snapshot owns that same original source. + _ = try context.transferDocumentOwnership() + return .init(snapshot: snapshot, rootOrdinal: rootOrdinal, endExclusive: endExclusive) + } +} + +internal struct TreeCatalogueReducer: JSONTraversalOwnedReducer { + let view: JSONTreeProjection + let ordinal: Int + let childrenOnly: Bool + let maximumRecords: Int + var ordinals: [Int] = [] + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { + try context.work(); try context.retain(128) //32 output header +96 temporary record + let record = try view.record(at: ordinal) + var next = childrenOnly ? ordinal + 1 : ordinal + while next < record.subtreeEndExclusive { + try context.work() + guard ordinals.count < maximumRecords else { + throw JSONProjectionFailure.recordLimitExceeded(limit: maximumRecords) + } + let child = try view.record(at: next) + if childrenOnly { + guard child.parentOrdinal == ordinal, child.subtreeEndExclusive > next, + child.subtreeEndExclusive <= record.subtreeEndExclusive else { + throw JSONFailure(.configuration, code: .invalidOperation) + } + } + try context.retain(8); ordinals.append(next) + next = childrenOnly ? child.subtreeEndExclusive : next + 1 + } + return .skipDescendants + } + mutating func finish(_ summary: JSONTraversalSummary, + context: inout JSONTraversalContext) throws -> [Int] { + try context.work(); try context.release(96) + let result = ordinals; ordinals = []; return result + } +} diff --git a/Tests/JSONInspectionTests/ProjectionAcceptanceTests.swift b/Tests/JSONInspectionTests/ProjectionAcceptanceTests.swift new file mode 100644 index 0000000..28fbcd1 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionAcceptanceTests.swift @@ -0,0 +1,517 @@ +// SPDX-License-Identifier: Apache-2.0 +import Foundation +import Synchronization +import Testing +import JSON +import JSONNavigation +@testable import JSONInspection + +private func projectionFixture(_ name: String) throws -> Data { + // WASI Foundation's named-resource search can truncate the extension. + // Match the existing JSONHTML fixture loader using the exact copied path. + let root = try #require(Bundle.module.resourceURL) + let url = URL(fileURLWithPath: root.path + "/ProjectionFixtures/" + name + ".json") + return try Data(contentsOf: url) +} +private func projectionDocument(_ text: String) throws -> JSONDocument { + try JSONParser().parseDocument(Data(text.utf8)) +} +private func projectionInput(_ name: String) throws -> JSONDocument { + try JSONParser(options: .init(limits: .offline)).parseDocument(projectionFixture(name)) +} +private func projectionTree(_ document: JSONDocument, root: Int = 0) throws -> JSONTreeProjection { + let snapshot = try JSONStructuralSnapshotBuilder(document: document, limits: .offline).build().result + return try JSONTreeProjection.build(snapshot: snapshot, rootOrdinal: root, limits: .offline).result +} +private func projectionResource(_ body: () throws -> Void) -> JSONFailure? { + do { try body(); Issue.record("Expected an operational resource refusal") } + catch let failure as JSONFailure { return failure } + catch { Issue.record("Wrong failure: \(error)") } + return nil +} +private func projectionPresence(_ value: JSON?) -> JSONPresence { + guard let value else { return .absent } + if case .null = value { return .null } + return .value(value) +} +private func projectionTokens(_ path: [JSONLocationComponent]) -> [String] { + path.map { switch $0 { case .key(let key): key.string; case .index(let index): String(index) } } +} + +@Test func projectionP01ScalarRootIsOneExactLeaf() throws { + for text in ["null", "false", "9007199254740993", #""exact""#] { + let document = try projectionDocument(text), view = try projectionTree(document) + #expect(view.rootOrdinal == 0 && view.endExclusive == 1) + #expect(try view.children(of: 0, maximumRecords: 0).result.isEmpty) + #expect(try view.subtreeOrdinals(of: 0, maximumRecords: 1).result == [0]) + #expect(try view.value(for: 0).result == document.root) + } +} +@Test func projectionP02EmptyContainerKindsStayDifferent() throws { + let view = try projectionTree(projectionDocument("[{},[]]")) + #expect(try view.record(at: 1).kind == .object) + #expect(try view.record(at: 2).kind == .array) + for ordinal in [1,2] { #expect(try view.children(of: ordinal).result.isEmpty) } +} +@Test func projectionP03RootAndEmptyKeyHaveDifferentLocations() throws { + let document = try projectionInput("root-keys"), view = try projectionTree(document) + #expect(try view.location(for: 0).result == []) + #expect(try view.location(for: 1).result == [.key("")]) + #expect(try JSONPointer(parsing: "").resolve(in: document.root) == view.value(for: 0).result) + #expect(try JSONPointer(parsing: "/").resolve(in: document.root) == view.value(for: 1).result) +} +@Test func projectionP04NumericKeysAndIndicesAreNotAliases() throws { + let view = try projectionTree(projectionDocument(#"{"0":[{"0":1}]}"#)) + #expect(try view.location(for: 1).result == [.key("0")]) + #expect(try view.location(for: 2).result == [.key("0"),.index(0)]) + #expect(try view.location(for: 3).result == [.key("0"),.index(0),.key("0")]) + #expect(throws: JSONAccessFailure.self) { + _ = try JSONTraversal(document: view.snapshot.document).collect(scope: .subtree(at: [.index(0)])) + } +} +@Test func projectionP05ScalarExactUnicodeKeysNeverNormalize() throws { + let view = try projectionTree(projectionDocument(#"{"é":1,"e\u0301":2}"#)) + #expect("é" == "e\u{301}") // Swift's canonical equivalence is not JSON identity. + #expect(JSONKey("é") != JSONKey("e\u{301}")) + #expect(try view.location(for: 1).result == [.key("é")]) + #expect(try view.location(for: 2).result == [.key("e\u{301}")]) +} +@Test func projectionP06ChildrenJumpOverGrandchildren() throws { + let view = try projectionTree(projectionInput("tree-nested")) + #expect(try view.children(of: 0).result == [1,8]) + #expect(try view.children(of: 1).result == [2,4]) + #expect(try view.children(of: 4).result == [5,6]) + #expect(try view.subtreeOrdinals(of: 1).result == Array(1..<8)) +} +@Test func projectionP07SourceInsertionAndArrayOrderAreCanonical() throws { + let view = try projectionTree(projectionDocument(#"{"z":[2,1],"a":0}"#)) + #expect(try view.children(of: 0).result == [1,4]) + #expect(try view.record(at: 1).componentFromParent == .key("z")) + #expect(try view.record(at: 4).componentFromParent == .key("a")) + #expect(try view.children(of: 1).result == [2,3]) + #expect(try view.value(for: 2).result == 2 && view.value(for: 3).result == 1) +} +@Test func projectionP08EveryRangeMatchesIndependentPacketOracleAndCore() throws { + // Hand-computed packet topology, independently verified by Python's pair-preserving oracle. + let view = try projectionTree(projectionInput("tree-nested")) + let parents: [Int?] = [nil,0,1,2,1,4,4,6,0] + let depths = [0,1,2,3,2,3,3,4,1], ends = [9,8,4,4,8,6,8,8,9] + let counts = [2,2,1,0,2,0,1,0,0] + for ordinal in 0..<9 { + let record = try view.record(at: ordinal) + #expect(record.parentOrdinal == parents[ordinal] && record.depth == depths[ordinal]) + #expect(record.subtreeEndExclusive == ends[ordinal] && record.childCount == counts[ordinal]) + let path = try view.location(for: ordinal).result + let core = try JSONPointer(tokens: projectionTokens(path)).resolve(in: view.snapshot.document.root) + #expect(try view.value(for: ordinal).result == core) + } +} +@Test func projectionP09EqualSiblingsKeepDistinctPhysicalPositions() throws { + let view = try projectionTree(projectionDocument("[1,1]")) + #expect(try view.children(of: 0).result == [1,2]) + #expect(try view.value(for: 1).result == view.value(for: 2).result) + #expect(try view.location(for: 1).result != view.location(for: 2).result) +} +@Test func projectionP10SelectedSubtreeKeepsOriginalRootAndParent() throws { + let document = try projectionInput("tree-nested"), view = try projectionTree(document, root: 1) + #expect(view.rootOrdinal == 1 && view.endExclusive == 8) + #expect(try view.record(at: 1).parentOrdinal == 0 && view.record(at: 1).depth == 1) + #expect(view.snapshot.document.root == document.root) + #expect(throws: JSONProjectionFailure.outsideSelectedSubtree(ordinal: 8)) { _ = try view.value(for: 8) } + #expect(throws: JSONProjectionFailure.outsideSelectedSubtree(ordinal: 0)) { _ = try view.record(at: 0) } +} +@Test func projectionP11ReplacementCannotRebindAViewOrGivePortableOrdinals() throws { + let old = try projectionDocument(#"{"a":1}"#), changed = old.replacingRoot(try JSON.parse(#"{"b":2}"#)) + let first = try projectionTree(old), second = try projectionTree(changed) + #expect(try first.location(for: 1).result == [.key("a")]) + #expect(try second.location(for: 1).result == [.key("b")]) + #expect(try first.value(for: 1).result == 1 && second.value(for: 1).result == 2) + // The same bare Int is a local position, not an identity carrying a replacement source. +} +@Test func projectionP12OnlyCapturedCoherentSourceSuppliesSpans() throws { + let old = try projectionDocument(#"{"a":1}"#), first = try projectionTree(old) + let changed = old.replacingRoot(try JSON.parse(#"{"a":2}"#)), second = try projectionTree(changed) + #expect(try first.sourceSpan(for: 1).result != nil) + #expect(try second.sourceSpan(for: 1).result == nil) + #expect(try first.sourceSpan(for: 1).result != nil) +} +@Test func projectionP13InclusiveCatalogueCapsNeverReturnTruncation() throws { + let view = try projectionTree(projectionInput("tree-nested")) + #expect(try view.children(of: 0, maximumRecords: 2).result == [1,8]) + #expect(throws: JSONProjectionFailure.recordLimitExceeded(limit: 1)) { _ = try view.children(of: 0, maximumRecords: 1) } + #expect(throws: JSONProjectionFailure.recordLimitExceeded(limit: 0)) { _ = try view.subtreeOrdinals(of: 3, maximumRecords: 0) } + #expect(try view.subtreeOrdinals(of: 3, maximumRecords: 1).result == [3]) + #expect(throws: JSONFailure.self) { _ = try view.children(of: 0, maximumRecords: -1) } +} +@Test func projectionP14TreeWorkRetentionKeysAndCancellationAreBounded() async throws { + let view = try projectionTree(projectionInput("tree-nested")), baseline = try view.children(of: 0) + let built = try JSONTreeProjection.build(snapshot: view.snapshot) + #expect(built.statistics[.nodes] == 9) + let admission = try JSONReadScope(view.snapshot.document, limits: .balanced) + let rootBytes = try admission.check().meter.used(.retainedBytes); admission.invalidate() + // Six exact edge keys: tree/left/leaf/right/leaf/empty =26 UTF8 bytes. + #expect(built.statistics[.retainedBytes] == rootBytes + 192 + 96 * 9 + 26) + for metric in [JSONResourceMetric.workUnits, .retainedBytes] { + var limits = JSONLimits.balanced + limits[metric] = metric == .workUnits ? built.statistics[metric] : built.statistics.peakLogicalRetainedBytes + #expect(try JSONTreeProjection.build(snapshot: view.snapshot, limits: limits).result.rootOrdinal == 0) + limits[metric] -= 1 + #expect(projectionResource { _ = try JSONTreeProjection.build(snapshot: view.snapshot, limits: limits) }?.resource?.metric == metric) + } + for metric in [JSONResourceMetric.workUnits, .retainedBytes] { + var limits = JSONLimits.balanced + limits[metric] = metric == .workUnits ? baseline.statistics[metric] : baseline.statistics.peakLogicalRetainedBytes + #expect(try view.children(of: 0, limits: limits).result == baseline.result) + limits[metric] -= 1 + #expect(projectionResource { _ = try view.children(of: 0, limits: limits) }?.resource?.metric == metric) + } + var keys = JSONLimits.balanced; keys[.keyBytes] = 1 + #expect(projectionResource { _ = try view.children(of: 0, limits: keys) }?.resource?.metric == .keyBytes) + let task = Task { + var limits = JSONLimits.balanced; limits[.cancellationQuantum] = 1 + var walk = JSONTraversal(document: view.snapshot.document, limits: limits) + walk.checkpointObserver = { if $0 >= baseline.statistics[.workUnits] - 1 { withUnsafeCurrentTask { $0?.cancel() } } } + var reducer = TreeCatalogueReducer(view: view, ordinal: 0, childrenOnly: true, maximumRecords: 2) + return try walk.inspectOwned(options: .init(depthLimit: 0), reducer: &reducer) + } + do { _ = try await task.value; Issue.record("Late tree cancellation must not return a catalogue") } + catch is CancellationError { } +} +@Test func projectionP15DeepAndWideCataloguesRemainIterativeAndFinite() throws { + for depth in [16,64,256] { + let document = try projectionInput("deep-\(depth)"), view = try projectionTree(document) + #expect(try view.subtreeOrdinals(of: 0, maximumRecords: depth + 1, limits: .offline).result.count == depth + 1) + var shallow = JSONLimits.offline; shallow[.maxDepth] = 8 + #expect(projectionResource { _ = try view.children(of: depth, limits: shallow) }?.resource?.metric == .maxDepth) + } + let wide = try projectionTree(projectionInput("wide-1024")) + #expect(try wide.children(of: 0, maximumRecords: 1024, limits: .offline).result == Array(1...1024)) +} +@Test func projectionP16SharedViewsHaveIndependentHealthAndLegacyStatistics() async throws { + let document = try projectionInput("tree-nested") + let initial = try JSONStructuralSnapshotBuilder(document: document).build() + let view = try JSONTreeProjection.build(snapshot: initial.result).result + let baseline = try view.children(of: 0) + let table = try JSONSparseTableProjection.build(document: projectionDocument(#"[{"x":1},{}]"#)).result + try await withThrowingTaskGroup(of: UInt64.self) { group in + for index in 0..<16 { group.addTask { + if index.isMultiple(of: 2) { + var limits = JSONLimits.balanced; limits[.nodes] = 0 + #expect(projectionResource { _ = try view.children(of: 0, limits: limits) }?.resource?.metric == .nodes) + } + let report = try view.children(of: 0) + #expect(report.result == [1,8]); #expect(try view.value(for: 3).result == 1) + if index.isMultiple(of: 2) { + var limits = JSONLimits.balanced; limits[.nodes] = 0 + #expect(projectionResource { _ = try table.cell(row: 0, column: 0, limits: limits) }?.resource?.metric == .nodes) + } + #expect(try table.cell(row: 0, column: 0).result == .value(1)) + #expect(try table.cell(row: 1, column: 0).result == .absent) + return report.statistics[.workUnits] + } } + for try await work in group { #expect(work == baseline.statistics[.workUnits]) } + } + let after = try JSONStructuralSnapshotBuilder(document: document).build() + for metric in JSONResourceMetric.allCases { #expect(initial.statistics[metric] == after.statistics[metric]) } +} + +@Test func projectionP17EmptyArrayIsExplicitCompleteZeroByZero() throws { + let document = try projectionInput("table-empty") + let table = try JSONSparseTableProjection.build(document: document).result + #expect(table.rowCount == 0 && table.columns.isEmpty && table.presentMembers.isEmpty && table.rowOffsets == [0]) + #expect(try JSONShapeInspector(document: document).inspectArray().result.observedAllObjects == nil) +} +@Test func projectionP18EmptyObjectRowsNeverDisappear() throws { + let table = try JSONSparseTableProjection.build(document: projectionInput("table-empty-objects"), + maximumRows: 2, maximumColumns: 0, maximumPresentCells: 0).result + #expect(table.rowCount == 2 && table.columns.isEmpty && table.rowOffsets == [0,0,0]) + #expect(throws: JSONProjectionFailure.rowOutOfBounds(2)) { _ = try table.cell(row: 2, column: 0) } +} +@Test func projectionP19EveryNonObjectRowFailsAtItsPhysicalPath() throws { + for (text, row, kind) in [("[null]",0,JSONTraversalKind.null),("[{},false]",1,.boolean),("[{},{},0]",2,.number),("[[]]",0,.array)] { + let document = try projectionDocument("{\"\":" + text + "}") + #expect(throws: JSONProjectionFailure.nonObjectRow(at: [.key(""),.index(row)], kind: kind)) { + _ = try JSONSparseTableProjection.build(document: document, at: [.key("")]) + } + } +} +@Test func projectionP20PositivePrefixCannotAdmitLateBadTable() throws { + let document = try projectionInput("table-late-invalid") + let prefix = try JSONShapeInspector(document: document).inspectArray(sampling: .prefix(maximumRows: 2)).result + #expect(prefix.observedAllObjects == true && prefix.rowCoverage == .prefix(examined: 2, total: 3)) + #expect(throws: JSONProjectionFailure.nonObjectRow(at: [.index(2)], kind: .boolean)) { + _ = try JSONSparseTableProjection.build(document: document) + } +} +@Test func projectionP21ColumnsFollowFirstEncounterAcrossPermutations() throws { + let first = try JSONSparseTableProjection.build(document: projectionDocument(#"[{"z":1,"a":2},{"q":3}]"#)).result + let permuted = try JSONSparseTableProjection.build(document: projectionDocument(#"[{"q":3},{"a":2,"z":1}]"#)).result + #expect(first.columns == [JSONKey("z"),JSONKey("a"),JSONKey("q")]) + #expect(permuted.columns == [JSONKey("q"),JSONKey("a"),JSONKey("z")]) + #expect(try first.cell(row: 0, column: 1).result == .value(2)) + #expect(try permuted.cell(row: 1, column: 1).result == .value(2)) +} +@Test func projectionP22UnicodeColumnsHaveExactSeparatePresence() throws { + let table = try JSONSparseTableProjection.build(document: projectionInput("table-unicode")).result + #expect(table.columns == [JSONKey("é"),JSONKey("e\u{301}")]) + #expect(try table.cell(row: 0, column: 0).result == .null) + #expect(try table.cell(row: 1, column: 0).result == .absent) + #expect(try table.cell(row: 1, column: 1).result == .value(2)) +} +@Test func projectionP23EqualRowsRemainSeparatePhysicalRows() throws { + let table = try JSONSparseTableProjection.build(document: projectionInput("table-equal-rows")).result + #expect(table.rowCount == 2 && table.rowOffsets == [0,1,2] && table.presentMembers.count == 2) + #expect(try table.cell(row: 0, column: 0).result == table.cell(row: 1, column: 0).result) + #expect(table.presentMembers.map(\.memberOrdinal) == [0,0]) +} +@Test func projectionP24CellPresenceHasThreeCanonicalStates() throws { + let table = try JSONSparseTableProjection.build(document: projectionDocument(#"[{"a":null},{},{"a":false}]"#)).result + #expect(try table.cell(row: 0, column: 0).result == .null) + #expect(try table.cell(row: 1, column: 0).result == .absent) + #expect(try table.cell(row: 2, column: 0).result == .value(false)) +} +@Test func projectionP25MissingCountsUseEveryAdmittedObjectRow() throws { + let document = try projectionDocument(#"[{"x":null},{"y":1},{}]"#) + let table = try JSONSparseTableProjection.build(document: document).result + let evidence = try JSONShapeInspector(document: document).inspectArray().result + for column in table.columns.indices { + var missing: UInt64 = 0, nulls: UInt64 = 0 + for row in 0..: JSONTraversalOwnedReducer { + enum Mode: Sendable { case work, cancellation, twice, caller } + var inner: Inner + let mode: Mode + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { + try inner.observe(hit, value: value, context: &context) + } + mutating func finish(_ summary: JSONTraversalSummary, + context: inout JSONTraversalContext) throws -> Inner.Result { + let result = try inner.finish(summary, context: &context) + switch mode { + case .work: + do { try context.work(64_000_000) } catch { } + throw ProjectionAfterFinish.replacement + case .cancellation: + withUnsafeCurrentTask { $0?.cancel() } + do { try context.checkpoint() } catch { } + case .twice: + do { _ = try context.transferDocumentOwnership() } catch { } + case .caller: throw ProjectionAfterFinish.replacement + } + return result + } +} +@Test func projectionP32FinalizationFailureCancellationAndScopeTeardownAreTerminal() async throws { + let document = try projectionDocument(#"[{"x":1},{"y":null}]"#) + let baseline = try JSONSparseTableProjection.build(document: document) + for metric in [JSONResourceMetric.workUnits, .retainedBytes] { + var limits = JSONLimits.balanced + limits[metric] = metric == .workUnits ? baseline.statistics[metric] : baseline.statistics.peakLogicalRetainedBytes + #expect(try JSONSparseTableProjection.build(document: document, limits: limits).result.rowCount == 2) + limits[metric] -= 1 + #expect(projectionResource { _ = try JSONSparseTableProjection.build(document: document, limits: limits) }?.resource?.metric == metric) + } + typealias Probe = ProjectionLateProbe + for mode in [Probe.Mode.work,.cancellation,.twice,.caller] { + let cleared = Mutex(false) + let task = Task { + var walk = JSONTraversal(document: document) + walk.lifetimeObserver = { rootGone,stateGone in cleared.withLock { $0 = rootGone && stateGone } } + var reducer = Probe(inner: SparseTableReducer(maximumRows: 2, maximumColumns: 2, + maximumPresentCells: 2, limits: .balanced), mode: mode) + return try walk.inspectOwned(options: .init(depthLimit: 1), reducer: &reducer) + } + do { _ = try await task.value; Issue.record("No finalized projection may mask terminal failure") } + catch let failure as JSONFailure { + if mode == .twice { #expect(failure.code == .invalidOperation) } + else { #expect(mode == .work && failure.resource?.metric == .workUnits) } + } + catch is CancellationError { #expect(mode == .cancellation) } + catch is ProjectionAfterFinish { #expect(mode == .caller) } + #expect(cleared.withLock { $0 }) + } + + let snapshot = try JSONStructuralSnapshotBuilder(document: document).build().result + typealias TreeProbe = ProjectionLateProbe + for mode in [TreeProbe.Mode.work,.cancellation,.twice,.caller] { + let cleared = Mutex(false) + let task = Task { + var walk = JSONTraversal(document: document) + walk.lifetimeObserver = { rootGone,stateGone in cleared.withLock { $0 = rootGone && stateGone } } + var reducer = TreeProbe(inner: TreeViewReducer(snapshot: snapshot, rootOrdinal: 0, limits: .balanced), mode: mode) + return try walk.inspectOwned(options: .init(depthLimit: 0), reducer: &reducer) + } + do { _ = try await task.value; Issue.record("No source-owning tree may mask final failure") } + catch let failure as JSONFailure { + if mode == .twice { #expect(failure.code == .invalidOperation) } + else { #expect(mode == .work && failure.resource?.metric == .workUnits) } + } + catch is CancellationError { #expect(mode == .cancellation) } + catch is ProjectionAfterFinish { #expect(mode == .caller) } + #expect(cleared.withLock { $0 }) + } + // Cancel inside a long owned key scan, and inside the offset-finalization scan. + for finish in [false,true] { + let trace = ProjectionPhaseTrace() + let text = finish ? "[" + Array(repeating: #"{"x":1}"#, count: 40).joined(separator: ",") + "]" + : "[{\"" + String(repeating: "a", count: 128) + "A\":1},{\"" + String(repeating: "a", count: 128) + "B\":2}]" + let input = try projectionDocument(text) + let cleared = Mutex(false) + let task = Task { + var limits = JSONLimits.balanced; limits[.cancellationQuantum] = 1 + var walk = JSONTraversal(document: input, limits: limits) + walk.checkpointObserver = { _ in if trace.step() { withUnsafeCurrentTask { $0?.cancel() } } } + walk.lifetimeObserver = { rootGone,stateGone in cleared.withLock { $0 = rootGone && stateGone } } + var reducer = ProjectionPhaseProbe(inner: SparseTableReducer(maximumRows: 100, + maximumColumns: 100, maximumPresentCells: 100, limits: limits), trace: trace, finishing: finish) + return try walk.inspectOwned(options: .init(depthLimit: 1), reducer: &reducer) + } + do { _ = try await task.value; Issue.record("Inner projection scan must observe cancellation") } + catch is CancellationError { } + #expect(trace.state.withLock { $0.calls >= 32 }) + #expect(cleared.withLock { $0 }) + } +} + +private final class ProjectionPhaseTrace: Sendable { + struct State { var active = false; var calls = 0 } + let state = Mutex(State()) + func activate() { state.withLock { $0.active = true; $0.calls = 0 } } + func deactivate() { state.withLock { $0.active = false } } + func step() -> Bool { state.withLock { value in + guard value.active else { return false } + value.calls += 1; return value.calls >= 32 + } } +} +private struct ProjectionPhaseProbe: JSONTraversalOwnedReducer { + var inner: SparseTableReducer + let trace: ProjectionPhaseTrace + let finishing: Bool + mutating func observe(_ hit: JSONTraversalHit, value: JSON, + context: inout JSONTraversalContext) throws -> JSONTraversalAction { + let activate = !finishing && hit.relativeDepth == 1 && hit.absoluteLocation.last == .index(1) + if activate { trace.activate() } + defer { if activate { trace.deactivate() } } + return try inner.observe(hit, value: value, context: &context) + } + mutating func finish(_ summary: JSONTraversalSummary, + context: inout JSONTraversalContext) throws -> JSONSparseTableProjection { + if finishing { trace.activate() } + defer { trace.deactivate() } + return try inner.finish(summary, context: &context) + } +} diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/GENERATED-ORACLE.json b/Tests/JSONInspectionTests/ProjectionFixtures/GENERATED-ORACLE.json new file mode 100644 index 0000000..8589ac6 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/GENERATED-ORACLE.json @@ -0,0 +1,133 @@ +{ + "status": "independent fixture generation only; not Swift execution", + "fixtures": [ + { + "file": "sparse-1.json", + "rows": 1, + "columns": 1, + "present_members": 1, + "source_nodes": 3, + "row_offsets": "0...rows inclusive", + "first_seen_columns": [ + "k0" + ], + "bytes": 14, + "sha256": "73cce88a6c9b32a311d1a668b0b292d5d1f23627da1756a48fa42e7a67613395" + }, + { + "file": "sparse-16.json", + "rows": 16, + "columns": 16, + "present_members": 16, + "source_nodes": 33, + "row_offsets": "0...rows inclusive", + "first_seen_columns": [ + "k0", + "k1", + "k2", + "k3", + "k4", + "k5", + "k6", + "k7", + "k8", + "k9", + "k10", + "k11", + "k12", + "k13", + "k14", + "k15" + ], + "bytes": 320, + "sha256": "74287abc7240ac53069eff68f2a0abf3bcdab00b35d2cb35c451c40e24543b25" + }, + { + "file": "sparse-1024.json", + "rows": 1024, + "columns": 16, + "present_members": 1024, + "source_nodes": 2049, + "row_offsets": "0...rows inclusive", + "first_seen_columns": [ + "k0", + "k1", + "k2", + "k3", + "k4", + "k5", + "k6", + "k7", + "k8", + "k9", + "k10", + "k11", + "k12", + "k13", + "k14", + "k15" + ], + "bytes": 20858, + "sha256": "820e1f166d82a34b112d6b100cf510a35a387dfc76325abe15f8959acf240d24" + }, + { + "file": "sparse-10000.json", + "rows": 10000, + "columns": 16, + "present_members": 10000, + "source_nodes": 20001, + "row_offsets": "0...rows inclusive", + "first_seen_columns": [ + "k0", + "k1", + "k2", + "k3", + "k4", + "k5", + "k6", + "k7", + "k8", + "k9", + "k10", + "k11", + "k12", + "k13", + "k14", + "k15" + ], + "bytes": 203744, + "sha256": "916c4e6ff7756cb92436253ae8b8c4ae3258be0671759a972fe273c57b962af0" + }, + { + "file": "deep-16.json", + "source_nodes": 17, + "maximum_node_depth": 16, + "root_children": 1, + "bytes": 34, + "sha256": "614e865f3ee7c118620d8f7551be5d29cf0be346acf527eb511180252dee1171" + }, + { + "file": "deep-64.json", + "source_nodes": 65, + "maximum_node_depth": 64, + "root_children": 1, + "bytes": 130, + "sha256": "f8e98d56449d4c90792a9368b4558e287a6e96fc9cd94059b42f99577f7c38a8" + }, + { + "file": "deep-256.json", + "source_nodes": 257, + "maximum_node_depth": 256, + "root_children": 1, + "bytes": 514, + "sha256": "d8191b41f00b69c70e3ff2e868ba2e4a25bbdbc085e9c93ba92de97d3a5be973" + }, + { + "file": "wide-1024.json", + "source_nodes": 1025, + "root_children": 1024, + "bytes": 11094, + "sha256": "0f8b3a0b866ec2c5447e501f8c0916ac874e4f3f5d29e8d3c87b89dee77fb8c8" + } + ] +} diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/MANIFEST.sha256 b/Tests/JSONInspectionTests/ProjectionFixtures/MANIFEST.sha256 new file mode 100644 index 0000000..37e4455 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/MANIFEST.sha256 @@ -0,0 +1,22 @@ +14cf3e82d36cddafe43484fa950c1820a0a7d6dfbbacb7530885bca071227a5d GENERATED-ORACLE.json +68da46e7372ae8f8fe1da3e795905e29bd8f56d36af185297f2cb34f077da45d PACKET-ORACLE.json +614e865f3ee7c118620d8f7551be5d29cf0be346acf527eb511180252dee1171 deep-16.json +d8191b41f00b69c70e3ff2e868ba2e4a25bbdbc085e9c93ba92de97d3a5be973 deep-256.json +f8e98d56449d4c90792a9368b4558e287a6e96fc9cd94059b42f99577f7c38a8 deep-64.json +7de2c8cbd8634b94974502bcb029673016a1afac458724ba478b1263205cdf5d root-keys.json +73cce88a6c9b32a311d1a668b0b292d5d1f23627da1756a48fa42e7a67613395 sparse-1.json +916c4e6ff7756cb92436253ae8b8c4ae3258be0671759a972fe273c57b962af0 sparse-10000.json +820e1f166d82a34b112d6b100cf510a35a387dfc76325abe15f8959acf240d24 sparse-1024.json +74287abc7240ac53069eff68f2a0abf3bcdab00b35d2cb35c451c40e24543b25 sparse-16.json +c83c3bab11555ceab3ed4e8d5e1738331330c533d6737f8e86acb65ef61dee59 table-complete.json +aa886214aeb2a7d7071ae91582079452493e63d4716b0d087c339da9108e5fa1 table-duplicate-keys.json +8e4d987d18556962d07f4b85a54fb3926f2068657fdb558a5ddfcea702f0f45c table-empty-objects.json +37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570 table-empty.json +bcdc21b212dbb7f53cfaa5c77380cf3a15096ff6147f7049b9f90bce436bd814 table-equal-rows.json +d65cd94eacea0a0e01d582cd959b52a44e45cdacecfbbc9e7b761ac4fb9da097 table-late-invalid.json +d3a076388c727a90a9f77917fab580dad311024b3a93b98d71b8fb2a33ae13ce table-nested.json +161a1bfffa621be8ff92c3a770b613a877f77c8a2d865342c10988ae7f72aa6b table-nonobject.json +5c3e20f876844f0f703b8f92c5dedbbf7fd67f2fb61e6a8ca0af0475c1b5a110 table-numeric-keys.json +4d8592625fa883598299a020db0455e9698417ffb893d669bbf2ac76b9461780 table-unicode.json +2ef21ab9362c0d13ddbf54e19f9389d23669cf8ea5eb29eec9388b150350bb5e tree-nested.json +0f8b3a0b866ec2c5447e501f8c0916ac874e4f3f5d29e8d3c87b89dee77fb8c8 wide-1024.json diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/PACKET-ORACLE.json b/Tests/JSONInspectionTests/ProjectionFixtures/PACKET-ORACLE.json new file mode 100644 index 0000000..3084752 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/PACKET-ORACLE.json @@ -0,0 +1,1093 @@ +{ + "provenance": "Original independent packet oracle; not derived from Swift implementation. Source fixtures copied byte-identically.", + "cases": [ + { + "file": "root-keys.json", + "sha256": "7de2c8cbd8634b94974502bcb029673016a1afac458724ba478b1263205cdf5d", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "object", + "end": 10 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "key", + "" + ], + "depth": 1, + "kind": "string", + "end": 2 + }, + { + "ordinal": 2, + "parent": 0, + "component": [ + "key", + "0" + ], + "depth": 1, + "kind": "array", + "end": 6 + }, + { + "ordinal": 3, + "parent": 2, + "component": [ + "index", + 0 + ], + "depth": 2, + "kind": "number", + "end": 4 + }, + { + "ordinal": 4, + "parent": 2, + "component": [ + "index", + 1 + ], + "depth": 2, + "kind": "object", + "end": 6 + }, + { + "ordinal": 5, + "parent": 4, + "component": [ + "key", + "0" + ], + "depth": 3, + "kind": "boolean", + "end": 6 + }, + { + "ordinal": 6, + "parent": 0, + "component": [ + "key", + "a/b" + ], + "depth": 1, + "kind": "string", + "end": 7 + }, + { + "ordinal": 7, + "parent": 0, + "component": [ + "key", + "~" + ], + "depth": 1, + "kind": "string", + "end": 8 + }, + { + "ordinal": 8, + "parent": 0, + "component": [ + "key", + "é" + ], + "depth": 1, + "kind": "string", + "end": 9 + }, + { + "ordinal": 9, + "parent": 0, + "component": [ + "key", + "é" + ], + "depth": 1, + "kind": "string", + "end": 10 + } + ], + "table": { + "status": "rejected", + "reason": "root wrong kind" + } + }, + { + "file": "table-complete.json", + "sha256": "c83c3bab11555ceab3ed4e8d5e1738331330c533d6737f8e86acb65ef61dee59", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 14 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 5 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "n" + ], + "depth": 2, + "kind": "number", + "end": 3 + }, + { + "ordinal": 3, + "parent": 1, + "component": [ + "key", + "price" + ], + "depth": 2, + "kind": "number", + "end": 4 + }, + { + "ordinal": 4, + "parent": 1, + "component": [ + "key", + "é" + ], + "depth": 2, + "kind": "null", + "end": 5 + }, + { + "ordinal": 5, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 8 + }, + { + "ordinal": 6, + "parent": 5, + "component": [ + "key", + "é" + ], + "depth": 2, + "kind": "string", + "end": 7 + }, + { + "ordinal": 7, + "parent": 5, + "component": [ + "key", + "n" + ], + "depth": 2, + "kind": "number", + "end": 8 + }, + { + "ordinal": 8, + "parent": 0, + "component": [ + "index", + 2 + ], + "depth": 1, + "kind": "object", + "end": 14 + }, + { + "ordinal": 9, + "parent": 8, + "component": [ + "key", + "n" + ], + "depth": 2, + "kind": "number", + "end": 10 + }, + { + "ordinal": 10, + "parent": 8, + "component": [ + "key", + "nest" + ], + "depth": 2, + "kind": "array", + "end": 14 + }, + { + "ordinal": 11, + "parent": 10, + "component": [ + "index", + 0 + ], + "depth": 3, + "kind": "null", + "end": 12 + }, + { + "ordinal": 12, + "parent": 10, + "component": [ + "index", + 1 + ], + "depth": 3, + "kind": "object", + "end": 14 + }, + { + "ordinal": 13, + "parent": 12, + "component": [ + "key", + "0" + ], + "depth": 4, + "kind": "number", + "end": 14 + } + ], + "table": { + "status": "valid", + "rows": 3, + "columns": [ + "n", + "price", + "é", + "é", + "nest" + ], + "column_scalars": [ + [ + 110 + ], + [ + 112, + 114, + 105, + 99, + 101 + ], + [ + 233 + ], + [ + 101, + 769 + ], + [ + 110, + 101, + 115, + 116 + ] + ], + "sparse_offsets": [ + 0, + 3, + 5, + 7 + ], + "members": [ + { + "row": 0, + "member": 0, + "column": 0, + "kind": "number" + }, + { + "row": 0, + "member": 1, + "column": 1, + "kind": "number" + }, + { + "row": 0, + "member": 2, + "column": 2, + "kind": "null" + }, + { + "row": 1, + "member": 0, + "column": 3, + "kind": "string" + }, + { + "row": 1, + "member": 1, + "column": 0, + "kind": "number" + }, + { + "row": 2, + "member": 0, + "column": 0, + "kind": "number" + }, + { + "row": 2, + "member": 1, + "column": 4, + "kind": "array" + } + ] + } + }, + { + "file": "table-duplicate-keys.json", + "sha256": "aa886214aeb2a7d7071ae91582079452493e63d4716b0d087c339da9108e5fa1", + "parse": "duplicate decoded key refusal" + }, + { + "file": "table-empty-objects.json", + "sha256": "8e4d987d18556962d07f4b85a54fb3926f2068657fdb558a5ddfcea702f0f45c", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 3 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 2 + }, + { + "ordinal": 2, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 3 + } + ], + "table": { + "status": "valid", + "rows": 2, + "columns": [], + "column_scalars": [], + "sparse_offsets": [ + 0, + 0, + 0 + ], + "members": [] + } + }, + { + "file": "table-empty.json", + "sha256": "37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 1 + } + ], + "table": { + "status": "valid", + "rows": 0, + "columns": [], + "column_scalars": [], + "sparse_offsets": [ + 0 + ], + "members": [] + } + }, + { + "file": "table-equal-rows.json", + "sha256": "bcdc21b212dbb7f53cfaa5c77380cf3a15096ff6147f7049b9f90bce436bd814", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 5 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 3 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "a" + ], + "depth": 2, + "kind": "number", + "end": 3 + }, + { + "ordinal": 3, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 5 + }, + { + "ordinal": 4, + "parent": 3, + "component": [ + "key", + "a" + ], + "depth": 2, + "kind": "number", + "end": 5 + } + ], + "table": { + "status": "valid", + "rows": 2, + "columns": [ + "a" + ], + "column_scalars": [ + [ + 97 + ] + ], + "sparse_offsets": [ + 0, + 1, + 2 + ], + "members": [ + { + "row": 0, + "member": 0, + "column": 0, + "kind": "number" + }, + { + "row": 1, + "member": 0, + "column": 0, + "kind": "number" + } + ] + } + }, + { + "file": "table-late-invalid.json", + "sha256": "d65cd94eacea0a0e01d582cd959b52a44e45cdacecfbbc9e7b761ac4fb9da097", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 6 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 3 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "a" + ], + "depth": 2, + "kind": "number", + "end": 3 + }, + { + "ordinal": 3, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 5 + }, + { + "ordinal": 4, + "parent": 3, + "component": [ + "key", + "a" + ], + "depth": 2, + "kind": "number", + "end": 5 + }, + { + "ordinal": 5, + "parent": 0, + "component": [ + "index", + 2 + ], + "depth": 1, + "kind": "boolean", + "end": 6 + } + ], + "table": { + "status": "rejected", + "reason": "wrongKind at [2]" + } + }, + { + "file": "table-nested.json", + "sha256": "d3a076388c727a90a9f77917fab580dad311024b3a93b98d71b8fb2a33ae13ce", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 9 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 7 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "x" + ], + "depth": 2, + "kind": "array", + "end": 5 + }, + { + "ordinal": 3, + "parent": 2, + "component": [ + "index", + 0 + ], + "depth": 3, + "kind": "number", + "end": 4 + }, + { + "ordinal": 4, + "parent": 2, + "component": [ + "index", + 1 + ], + "depth": 3, + "kind": "number", + "end": 5 + }, + { + "ordinal": 5, + "parent": 1, + "component": [ + "key", + "y" + ], + "depth": 2, + "kind": "object", + "end": 7 + }, + { + "ordinal": 6, + "parent": 5, + "component": [ + "key", + "0" + ], + "depth": 3, + "kind": "string", + "end": 7 + }, + { + "ordinal": 7, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 9 + }, + { + "ordinal": 8, + "parent": 7, + "component": [ + "key", + "x" + ], + "depth": 2, + "kind": "null", + "end": 9 + } + ], + "table": { + "status": "valid", + "rows": 2, + "columns": [ + "x", + "y" + ], + "column_scalars": [ + [ + 120 + ], + [ + 121 + ] + ], + "sparse_offsets": [ + 0, + 2, + 3 + ], + "members": [ + { + "row": 0, + "member": 0, + "column": 0, + "kind": "array" + }, + { + "row": 0, + "member": 1, + "column": 1, + "kind": "object" + }, + { + "row": 1, + "member": 0, + "column": 0, + "kind": "null" + } + ] + } + }, + { + "file": "table-nonobject.json", + "sha256": "161a1bfffa621be8ff92c3a770b613a877f77c8a2d865342c10988ae7f72aa6b", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 2 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "null", + "end": 2 + } + ], + "table": { + "status": "rejected", + "reason": "wrongKind at [0]" + } + }, + { + "file": "table-numeric-keys.json", + "sha256": "5c3e20f876844f0f703b8f92c5dedbbf7fd67f2fb61e6a8ca0af0475c1b5a110", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 5 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 3 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "0" + ], + "depth": 2, + "kind": "number", + "end": 3 + }, + { + "ordinal": 3, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 5 + }, + { + "ordinal": 4, + "parent": 3, + "component": [ + "key", + "0" + ], + "depth": 2, + "kind": "number", + "end": 5 + } + ], + "table": { + "status": "valid", + "rows": 2, + "columns": [ + "0" + ], + "column_scalars": [ + [ + 48 + ] + ], + "sparse_offsets": [ + 0, + 1, + 2 + ], + "members": [ + { + "row": 0, + "member": 0, + "column": 0, + "kind": "number" + }, + { + "row": 1, + "member": 0, + "column": 0, + "kind": "number" + } + ] + } + }, + { + "file": "table-unicode.json", + "sha256": "4d8592625fa883598299a020db0455e9698417ffb893d669bbf2ac76b9461780", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "array", + "end": 6 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "index", + 0 + ], + "depth": 1, + "kind": "object", + "end": 4 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "é" + ], + "depth": 2, + "kind": "null", + "end": 3 + }, + { + "ordinal": 3, + "parent": 1, + "component": [ + "key", + "é" + ], + "depth": 2, + "kind": "number", + "end": 4 + }, + { + "ordinal": 4, + "parent": 0, + "component": [ + "index", + 1 + ], + "depth": 1, + "kind": "object", + "end": 6 + }, + { + "ordinal": 5, + "parent": 4, + "component": [ + "key", + "é" + ], + "depth": 2, + "kind": "number", + "end": 6 + } + ], + "table": { + "status": "valid", + "rows": 2, + "columns": [ + "é", + "é" + ], + "column_scalars": [ + [ + 233 + ], + [ + 101, + 769 + ] + ], + "sparse_offsets": [ + 0, + 2, + 3 + ], + "members": [ + { + "row": 0, + "member": 0, + "column": 0, + "kind": "null" + }, + { + "row": 0, + "member": 1, + "column": 1, + "kind": "number" + }, + { + "row": 1, + "member": 0, + "column": 1, + "kind": "number" + } + ] + } + }, + { + "file": "tree-nested.json", + "sha256": "2ef21ab9362c0d13ddbf54e19f9389d23669cf8ea5eb29eec9388b150350bb5e", + "parse": "valid", + "records": [ + { + "ordinal": 0, + "parent": null, + "component": null, + "depth": 0, + "kind": "object", + "end": 9 + }, + { + "ordinal": 1, + "parent": 0, + "component": [ + "key", + "tree" + ], + "depth": 1, + "kind": "object", + "end": 8 + }, + { + "ordinal": 2, + "parent": 1, + "component": [ + "key", + "left" + ], + "depth": 2, + "kind": "object", + "end": 4 + }, + { + "ordinal": 3, + "parent": 2, + "component": [ + "key", + "leaf" + ], + "depth": 3, + "kind": "number", + "end": 4 + }, + { + "ordinal": 4, + "parent": 1, + "component": [ + "key", + "right" + ], + "depth": 2, + "kind": "array", + "end": 8 + }, + { + "ordinal": 5, + "parent": 4, + "component": [ + "index", + 0 + ], + "depth": 3, + "kind": "number", + "end": 6 + }, + { + "ordinal": 6, + "parent": 4, + "component": [ + "index", + 1 + ], + "depth": 3, + "kind": "object", + "end": 8 + }, + { + "ordinal": 7, + "parent": 6, + "component": [ + "key", + "leaf" + ], + "depth": 4, + "kind": "number", + "end": 8 + }, + { + "ordinal": 8, + "parent": 0, + "component": [ + "key", + "empty" + ], + "depth": 1, + "kind": "array", + "end": 9 + } + ], + "table": { + "status": "rejected", + "reason": "root wrong kind" + } + } + ] +} diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/deep-16.json b/Tests/JSONInspectionTests/ProjectionFixtures/deep-16.json new file mode 100644 index 0000000..d33201a --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/deep-16.json @@ -0,0 +1 @@ +[[[[[[[[[[[[[[[[0]]]]]]]]]]]]]]]] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/deep-256.json b/Tests/JSONInspectionTests/ProjectionFixtures/deep-256.json new file mode 100644 index 0000000..ec0cb80 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/deep-256.json @@ -0,0 +1 @@ +[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[0]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/deep-64.json b/Tests/JSONInspectionTests/ProjectionFixtures/deep-64.json new file mode 100644 index 0000000..ee7e020 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/deep-64.json @@ -0,0 +1 @@ +[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[0]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/root-keys.json b/Tests/JSONInspectionTests/ProjectionFixtures/root-keys.json new file mode 100644 index 0000000..19f4baa --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/root-keys.json @@ -0,0 +1 @@ +{"":"empty","0":[0,{"0":true}],"a/b":"slash","~":"tilde","é":"composed","e\u0301":"decomposed"} diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/sparse-1.json b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-1.json new file mode 100644 index 0000000..f4ac309 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-1.json @@ -0,0 +1 @@ +[{"k0":null}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/sparse-10000.json b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-10000.json new file mode 100644 index 0000000..361be3b --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-10000.json @@ -0,0 +1 @@ +[{"k0":null},{"k1":9007199254740994},{"k2":9007199254740995},{"k3":null},{"k4":9007199254740997},{"k5":9007199254740998},{"k6":null},{"k7":9007199254741000},{"k8":9007199254741001},{"k9":null},{"k10":9007199254741003},{"k11":9007199254741004},{"k12":null},{"k13":9007199254741006},{"k14":9007199254741007},{"k15":null},{"k0":9007199254741009},{"k1":9007199254741010},{"k2":null},{"k3":9007199254741012},{"k4":9007199254741013},{"k5":null},{"k6":9007199254741015},{"k7":9007199254741016},{"k8":null},{"k9":9007199254741018},{"k10":9007199254741019},{"k11":null},{"k12":9007199254741021},{"k13":9007199254741022},{"k14":null},{"k15":9007199254741024},{"k0":9007199254741025},{"k1":null},{"k2":9007199254741027},{"k3":9007199254741028},{"k4":null},{"k5":9007199254741030},{"k6":9007199254741031},{"k7":null},{"k8":9007199254741033},{"k9":9007199254741034},{"k10":null},{"k11":9007199254741036},{"k12":9007199254741037},{"k13":null},{"k14":9007199254741039},{"k15":9007199254741040},{"k0":null},{"k1":9007199254741042},{"k2":9007199254741043},{"k3":null},{"k4":9007199254741045},{"k5":9007199254741046},{"k6":null},{"k7":9007199254741048},{"k8":9007199254741049},{"k9":null},{"k10":9007199254741051},{"k11":9007199254741052},{"k12":null},{"k13":9007199254741054},{"k14":9007199254741055},{"k15":null},{"k0":9007199254741057},{"k1":9007199254741058},{"k2":null},{"k3":9007199254741060},{"k4":9007199254741061},{"k5":null},{"k6":9007199254741063},{"k7":9007199254741064},{"k8":null},{"k9":9007199254741066},{"k10":9007199254741067},{"k11":null},{"k12":9007199254741069},{"k13":9007199254741070},{"k14":null},{"k15":9007199254741072},{"k0":9007199254741073},{"k1":null},{"k2":9007199254741075},{"k3":9007199254741076},{"k4":null},{"k5":9007199254741078},{"k6":9007199254741079},{"k7":null},{"k8":9007199254741081},{"k9":9007199254741082},{"k10":null},{"k11":9007199254741084},{"k12":9007199254741085},{"k13":null},{"k14":9007199254741087},{"k15":9007199254741088},{"k0":null},{"k1":9007199254741090},{"k2":9007199254741091},{"k3":null},{"k4":9007199254741093},{"k5":9007199254741094},{"k6":null},{"k7":9007199254741096},{"k8":9007199254741097},{"k9":null},{"k10":9007199254741099},{"k11":9007199254741100},{"k12":null},{"k13":9007199254741102},{"k14":9007199254741103},{"k15":null},{"k0":9007199254741105},{"k1":9007199254741106},{"k2":null},{"k3":9007199254741108},{"k4":9007199254741109},{"k5":null},{"k6":9007199254741111},{"k7":9007199254741112},{"k8":null},{"k9":9007199254741114},{"k10":9007199254741115},{"k11":null},{"k12":9007199254741117},{"k13":9007199254741118},{"k14":null},{"k15":9007199254741120},{"k0":9007199254741121},{"k1":null},{"k2":9007199254741123},{"k3":9007199254741124},{"k4":null},{"k5":9007199254741126},{"k6":9007199254741127},{"k7":null},{"k8":9007199254741129},{"k9":9007199254741130},{"k10":null},{"k11":9007199254741132},{"k12":9007199254741133},{"k13":null},{"k14":9007199254741135},{"k15":9007199254741136},{"k0":null},{"k1":9007199254741138},{"k2":9007199254741139},{"k3":null},{"k4":9007199254741141},{"k5":9007199254741142},{"k6":null},{"k7":9007199254741144},{"k8":9007199254741145},{"k9":null},{"k10":9007199254741147},{"k11":9007199254741148},{"k12":null},{"k13":9007199254741150},{"k14":9007199254741151},{"k15":null},{"k0":9007199254741153},{"k1":9007199254741154},{"k2":null},{"k3":9007199254741156},{"k4":9007199254741157},{"k5":null},{"k6":9007199254741159},{"k7":9007199254741160},{"k8":null},{"k9":9007199254741162},{"k10":9007199254741163},{"k11":null},{"k12":9007199254741165},{"k13":9007199254741166},{"k14":null},{"k15":9007199254741168},{"k0":9007199254741169},{"k1":null},{"k2":9007199254741171},{"k3":9007199254741172},{"k4":null},{"k5":9007199254741174},{"k6":9007199254741175},{"k7":null},{"k8":9007199254741177},{"k9":9007199254741178},{"k10":null},{"k11":9007199254741180},{"k12":9007199254741181},{"k13":null},{"k14":9007199254741183},{"k15":9007199254741184},{"k0":null},{"k1":9007199254741186},{"k2":9007199254741187},{"k3":null},{"k4":9007199254741189},{"k5":9007199254741190},{"k6":null},{"k7":9007199254741192},{"k8":9007199254741193},{"k9":null},{"k10":9007199254741195},{"k11":9007199254741196},{"k12":null},{"k13":9007199254741198},{"k14":9007199254741199},{"k15":null},{"k0":9007199254741201},{"k1":9007199254741202},{"k2":null},{"k3":9007199254741204},{"k4":9007199254741205},{"k5":null},{"k6":9007199254741207},{"k7":9007199254741208},{"k8":null},{"k9":9007199254741210},{"k10":9007199254741211},{"k11":null},{"k12":9007199254741213},{"k13":9007199254741214},{"k14":null},{"k15":9007199254741216},{"k0":9007199254741217},{"k1":null},{"k2":9007199254741219},{"k3":9007199254741220},{"k4":null},{"k5":9007199254741222},{"k6":9007199254741223},{"k7":null},{"k8":9007199254741225},{"k9":9007199254741226},{"k10":null},{"k11":9007199254741228},{"k12":9007199254741229},{"k13":null},{"k14":9007199254741231},{"k15":9007199254741232},{"k0":null},{"k1":9007199254741234},{"k2":9007199254741235},{"k3":null},{"k4":9007199254741237},{"k5":9007199254741238},{"k6":null},{"k7":9007199254741240},{"k8":9007199254741241},{"k9":null},{"k10":9007199254741243},{"k11":9007199254741244},{"k12":null},{"k13":9007199254741246},{"k14":9007199254741247},{"k15":null},{"k0":9007199254741249},{"k1":9007199254741250},{"k2":null},{"k3":9007199254741252},{"k4":9007199254741253},{"k5":null},{"k6":9007199254741255},{"k7":9007199254741256},{"k8":null},{"k9":9007199254741258},{"k10":9007199254741259},{"k11":null},{"k12":9007199254741261},{"k13":9007199254741262},{"k14":null},{"k15":9007199254741264},{"k0":9007199254741265},{"k1":null},{"k2":9007199254741267},{"k3":9007199254741268},{"k4":null},{"k5":9007199254741270},{"k6":9007199254741271},{"k7":null},{"k8":9007199254741273},{"k9":9007199254741274},{"k10":null},{"k11":9007199254741276},{"k12":9007199254741277},{"k13":null},{"k14":9007199254741279},{"k15":9007199254741280},{"k0":null},{"k1":9007199254741282},{"k2":9007199254741283},{"k3":null},{"k4":9007199254741285},{"k5":9007199254741286},{"k6":null},{"k7":9007199254741288},{"k8":9007199254741289},{"k9":null},{"k10":9007199254741291},{"k11":9007199254741292},{"k12":null},{"k13":9007199254741294},{"k14":9007199254741295},{"k15":null},{"k0":9007199254741297},{"k1":9007199254741298},{"k2":null},{"k3":9007199254741300},{"k4":9007199254741301},{"k5":null},{"k6":9007199254741303},{"k7":9007199254741304},{"k8":null},{"k9":9007199254741306},{"k10":9007199254741307},{"k11":null},{"k12":9007199254741309},{"k13":9007199254741310},{"k14":null},{"k15":9007199254741312},{"k0":9007199254741313},{"k1":null},{"k2":9007199254741315},{"k3":9007199254741316},{"k4":null},{"k5":9007199254741318},{"k6":9007199254741319},{"k7":null},{"k8":9007199254741321},{"k9":9007199254741322},{"k10":null},{"k11":9007199254741324},{"k12":9007199254741325},{"k13":null},{"k14":9007199254741327},{"k15":9007199254741328},{"k0":null},{"k1":9007199254741330},{"k2":9007199254741331},{"k3":null},{"k4":9007199254741333},{"k5":9007199254741334},{"k6":null},{"k7":9007199254741336},{"k8":9007199254741337},{"k9":null},{"k10":9007199254741339},{"k11":9007199254741340},{"k12":null},{"k13":9007199254741342},{"k14":9007199254741343},{"k15":null},{"k0":9007199254741345},{"k1":9007199254741346},{"k2":null},{"k3":9007199254741348},{"k4":9007199254741349},{"k5":null},{"k6":9007199254741351},{"k7":9007199254741352},{"k8":null},{"k9":9007199254741354},{"k10":9007199254741355},{"k11":null},{"k12":9007199254741357},{"k13":9007199254741358},{"k14":null},{"k15":9007199254741360},{"k0":9007199254741361},{"k1":null},{"k2":9007199254741363},{"k3":9007199254741364},{"k4":null},{"k5":9007199254741366},{"k6":9007199254741367},{"k7":null},{"k8":9007199254741369},{"k9":9007199254741370},{"k10":null},{"k11":9007199254741372},{"k12":9007199254741373},{"k13":null},{"k14":9007199254741375},{"k15":9007199254741376},{"k0":null},{"k1":9007199254741378},{"k2":9007199254741379},{"k3":null},{"k4":9007199254741381},{"k5":9007199254741382},{"k6":null},{"k7":9007199254741384},{"k8":9007199254741385},{"k9":null},{"k10":9007199254741387},{"k11":9007199254741388},{"k12":null},{"k13":9007199254741390},{"k14":9007199254741391},{"k15":null},{"k0":9007199254741393},{"k1":9007199254741394},{"k2":null},{"k3":9007199254741396},{"k4":9007199254741397},{"k5":null},{"k6":9007199254741399},{"k7":9007199254741400},{"k8":null},{"k9":9007199254741402},{"k10":9007199254741403},{"k11":null},{"k12":9007199254741405},{"k13":9007199254741406},{"k14":null},{"k15":9007199254741408},{"k0":9007199254741409},{"k1":null},{"k2":9007199254741411},{"k3":9007199254741412},{"k4":null},{"k5":9007199254741414},{"k6":9007199254741415},{"k7":null},{"k8":9007199254741417},{"k9":9007199254741418},{"k10":null},{"k11":9007199254741420},{"k12":9007199254741421},{"k13":null},{"k14":9007199254741423},{"k15":9007199254741424},{"k0":null},{"k1":9007199254741426},{"k2":9007199254741427},{"k3":null},{"k4":9007199254741429},{"k5":9007199254741430},{"k6":null},{"k7":9007199254741432},{"k8":9007199254741433},{"k9":null},{"k10":9007199254741435},{"k11":9007199254741436},{"k12":null},{"k13":9007199254741438},{"k14":9007199254741439},{"k15":null},{"k0":9007199254741441},{"k1":9007199254741442},{"k2":null},{"k3":9007199254741444},{"k4":9007199254741445},{"k5":null},{"k6":9007199254741447},{"k7":9007199254741448},{"k8":null},{"k9":9007199254741450},{"k10":9007199254741451},{"k11":null},{"k12":9007199254741453},{"k13":9007199254741454},{"k14":null},{"k15":9007199254741456},{"k0":9007199254741457},{"k1":null},{"k2":9007199254741459},{"k3":9007199254741460},{"k4":null},{"k5":9007199254741462},{"k6":9007199254741463},{"k7":null},{"k8":9007199254741465},{"k9":9007199254741466},{"k10":null},{"k11":9007199254741468},{"k12":9007199254741469},{"k13":null},{"k14":9007199254741471},{"k15":9007199254741472},{"k0":null},{"k1":9007199254741474},{"k2":9007199254741475},{"k3":null},{"k4":9007199254741477},{"k5":9007199254741478},{"k6":null},{"k7":9007199254741480},{"k8":9007199254741481},{"k9":null},{"k10":9007199254741483},{"k11":9007199254741484},{"k12":null},{"k13":9007199254741486},{"k14":9007199254741487},{"k15":null},{"k0":9007199254741489},{"k1":9007199254741490},{"k2":null},{"k3":9007199254741492},{"k4":9007199254741493},{"k5":null},{"k6":9007199254741495},{"k7":9007199254741496},{"k8":null},{"k9":9007199254741498},{"k10":9007199254741499},{"k11":null},{"k12":9007199254741501},{"k13":9007199254741502},{"k14":null},{"k15":9007199254741504},{"k0":9007199254741505},{"k1":null},{"k2":9007199254741507},{"k3":9007199254741508},{"k4":null},{"k5":9007199254741510},{"k6":9007199254741511},{"k7":null},{"k8":9007199254741513},{"k9":9007199254741514},{"k10":null},{"k11":9007199254741516},{"k12":9007199254741517},{"k13":null},{"k14":9007199254741519},{"k15":9007199254741520},{"k0":null},{"k1":9007199254741522},{"k2":9007199254741523},{"k3":null},{"k4":9007199254741525},{"k5":9007199254741526},{"k6":null},{"k7":9007199254741528},{"k8":9007199254741529},{"k9":null},{"k10":9007199254741531},{"k11":9007199254741532},{"k12":null},{"k13":9007199254741534},{"k14":9007199254741535},{"k15":null},{"k0":9007199254741537},{"k1":9007199254741538},{"k2":null},{"k3":9007199254741540},{"k4":9007199254741541},{"k5":null},{"k6":9007199254741543},{"k7":9007199254741544},{"k8":null},{"k9":9007199254741546},{"k10":9007199254741547},{"k11":null},{"k12":9007199254741549},{"k13":9007199254741550},{"k14":null},{"k15":9007199254741552},{"k0":9007199254741553},{"k1":null},{"k2":9007199254741555},{"k3":9007199254741556},{"k4":null},{"k5":9007199254741558},{"k6":9007199254741559},{"k7":null},{"k8":9007199254741561},{"k9":9007199254741562},{"k10":null},{"k11":9007199254741564},{"k12":9007199254741565},{"k13":null},{"k14":9007199254741567},{"k15":9007199254741568},{"k0":null},{"k1":9007199254741570},{"k2":9007199254741571},{"k3":null},{"k4":9007199254741573},{"k5":9007199254741574},{"k6":null},{"k7":9007199254741576},{"k8":9007199254741577},{"k9":null},{"k10":9007199254741579},{"k11":9007199254741580},{"k12":null},{"k13":9007199254741582},{"k14":9007199254741583},{"k15":null},{"k0":9007199254741585},{"k1":9007199254741586},{"k2":null},{"k3":9007199254741588},{"k4":9007199254741589},{"k5":null},{"k6":9007199254741591},{"k7":9007199254741592},{"k8":null},{"k9":9007199254741594},{"k10":9007199254741595},{"k11":null},{"k12":9007199254741597},{"k13":9007199254741598},{"k14":null},{"k15":9007199254741600},{"k0":9007199254741601},{"k1":null},{"k2":9007199254741603},{"k3":9007199254741604},{"k4":null},{"k5":9007199254741606},{"k6":9007199254741607},{"k7":null},{"k8":9007199254741609},{"k9":9007199254741610},{"k10":null},{"k11":9007199254741612},{"k12":9007199254741613},{"k13":null},{"k14":9007199254741615},{"k15":9007199254741616},{"k0":null},{"k1":9007199254741618},{"k2":9007199254741619},{"k3":null},{"k4":9007199254741621},{"k5":9007199254741622},{"k6":null},{"k7":9007199254741624},{"k8":9007199254741625},{"k9":null},{"k10":9007199254741627},{"k11":9007199254741628},{"k12":null},{"k13":9007199254741630},{"k14":9007199254741631},{"k15":null},{"k0":9007199254741633},{"k1":9007199254741634},{"k2":null},{"k3":9007199254741636},{"k4":9007199254741637},{"k5":null},{"k6":9007199254741639},{"k7":9007199254741640},{"k8":null},{"k9":9007199254741642},{"k10":9007199254741643},{"k11":null},{"k12":9007199254741645},{"k13":9007199254741646},{"k14":null},{"k15":9007199254741648},{"k0":9007199254741649},{"k1":null},{"k2":9007199254741651},{"k3":9007199254741652},{"k4":null},{"k5":9007199254741654},{"k6":9007199254741655},{"k7":null},{"k8":9007199254741657},{"k9":9007199254741658},{"k10":null},{"k11":9007199254741660},{"k12":9007199254741661},{"k13":null},{"k14":9007199254741663},{"k15":9007199254741664},{"k0":null},{"k1":9007199254741666},{"k2":9007199254741667},{"k3":null},{"k4":9007199254741669},{"k5":9007199254741670},{"k6":null},{"k7":9007199254741672},{"k8":9007199254741673},{"k9":null},{"k10":9007199254741675},{"k11":9007199254741676},{"k12":null},{"k13":9007199254741678},{"k14":9007199254741679},{"k15":null},{"k0":9007199254741681},{"k1":9007199254741682},{"k2":null},{"k3":9007199254741684},{"k4":9007199254741685},{"k5":null},{"k6":9007199254741687},{"k7":9007199254741688},{"k8":null},{"k9":9007199254741690},{"k10":9007199254741691},{"k11":null},{"k12":9007199254741693},{"k13":9007199254741694},{"k14":null},{"k15":9007199254741696},{"k0":9007199254741697},{"k1":null},{"k2":9007199254741699},{"k3":9007199254741700},{"k4":null},{"k5":9007199254741702},{"k6":9007199254741703},{"k7":null},{"k8":9007199254741705},{"k9":9007199254741706},{"k10":null},{"k11":9007199254741708},{"k12":9007199254741709},{"k13":null},{"k14":9007199254741711},{"k15":9007199254741712},{"k0":null},{"k1":9007199254741714},{"k2":9007199254741715},{"k3":null},{"k4":9007199254741717},{"k5":9007199254741718},{"k6":null},{"k7":9007199254741720},{"k8":9007199254741721},{"k9":null},{"k10":9007199254741723},{"k11":9007199254741724},{"k12":null},{"k13":9007199254741726},{"k14":9007199254741727},{"k15":null},{"k0":9007199254741729},{"k1":9007199254741730},{"k2":null},{"k3":9007199254741732},{"k4":9007199254741733},{"k5":null},{"k6":9007199254741735},{"k7":9007199254741736},{"k8":null},{"k9":9007199254741738},{"k10":9007199254741739},{"k11":null},{"k12":9007199254741741},{"k13":9007199254741742},{"k14":null},{"k15":9007199254741744},{"k0":9007199254741745},{"k1":null},{"k2":9007199254741747},{"k3":9007199254741748},{"k4":null},{"k5":9007199254741750},{"k6":9007199254741751},{"k7":null},{"k8":9007199254741753},{"k9":9007199254741754},{"k10":null},{"k11":9007199254741756},{"k12":9007199254741757},{"k13":null},{"k14":9007199254741759},{"k15":9007199254741760},{"k0":null},{"k1":9007199254741762},{"k2":9007199254741763},{"k3":null},{"k4":9007199254741765},{"k5":9007199254741766},{"k6":null},{"k7":9007199254741768},{"k8":9007199254741769},{"k9":null},{"k10":9007199254741771},{"k11":9007199254741772},{"k12":null},{"k13":9007199254741774},{"k14":9007199254741775},{"k15":null},{"k0":9007199254741777},{"k1":9007199254741778},{"k2":null},{"k3":9007199254741780},{"k4":9007199254741781},{"k5":null},{"k6":9007199254741783},{"k7":9007199254741784},{"k8":null},{"k9":9007199254741786},{"k10":9007199254741787},{"k11":null},{"k12":9007199254741789},{"k13":9007199254741790},{"k14":null},{"k15":9007199254741792},{"k0":9007199254741793},{"k1":null},{"k2":9007199254741795},{"k3":9007199254741796},{"k4":null},{"k5":9007199254741798},{"k6":9007199254741799},{"k7":null},{"k8":9007199254741801},{"k9":9007199254741802},{"k10":null},{"k11":9007199254741804},{"k12":9007199254741805},{"k13":null},{"k14":9007199254741807},{"k15":9007199254741808},{"k0":null},{"k1":9007199254741810},{"k2":9007199254741811},{"k3":null},{"k4":9007199254741813},{"k5":9007199254741814},{"k6":null},{"k7":9007199254741816},{"k8":9007199254741817},{"k9":null},{"k10":9007199254741819},{"k11":9007199254741820},{"k12":null},{"k13":9007199254741822},{"k14":9007199254741823},{"k15":null},{"k0":9007199254741825},{"k1":9007199254741826},{"k2":null},{"k3":9007199254741828},{"k4":9007199254741829},{"k5":null},{"k6":9007199254741831},{"k7":9007199254741832},{"k8":null},{"k9":9007199254741834},{"k10":9007199254741835},{"k11":null},{"k12":9007199254741837},{"k13":9007199254741838},{"k14":null},{"k15":9007199254741840},{"k0":9007199254741841},{"k1":null},{"k2":9007199254741843},{"k3":9007199254741844},{"k4":null},{"k5":9007199254741846},{"k6":9007199254741847},{"k7":null},{"k8":9007199254741849},{"k9":9007199254741850},{"k10":null},{"k11":9007199254741852},{"k12":9007199254741853},{"k13":null},{"k14":9007199254741855},{"k15":9007199254741856},{"k0":null},{"k1":9007199254741858},{"k2":9007199254741859},{"k3":null},{"k4":9007199254741861},{"k5":9007199254741862},{"k6":null},{"k7":9007199254741864},{"k8":9007199254741865},{"k9":null},{"k10":9007199254741867},{"k11":9007199254741868},{"k12":null},{"k13":9007199254741870},{"k14":9007199254741871},{"k15":null},{"k0":9007199254741873},{"k1":9007199254741874},{"k2":null},{"k3":9007199254741876},{"k4":9007199254741877},{"k5":null},{"k6":9007199254741879},{"k7":9007199254741880},{"k8":null},{"k9":9007199254741882},{"k10":9007199254741883},{"k11":null},{"k12":9007199254741885},{"k13":9007199254741886},{"k14":null},{"k15":9007199254741888},{"k0":9007199254741889},{"k1":null},{"k2":9007199254741891},{"k3":9007199254741892},{"k4":null},{"k5":9007199254741894},{"k6":9007199254741895},{"k7":null},{"k8":9007199254741897},{"k9":9007199254741898},{"k10":null},{"k11":9007199254741900},{"k12":9007199254741901},{"k13":null},{"k14":9007199254741903},{"k15":9007199254741904},{"k0":null},{"k1":9007199254741906},{"k2":9007199254741907},{"k3":null},{"k4":9007199254741909},{"k5":9007199254741910},{"k6":null},{"k7":9007199254741912},{"k8":9007199254741913},{"k9":null},{"k10":9007199254741915},{"k11":9007199254741916},{"k12":null},{"k13":9007199254741918},{"k14":9007199254741919},{"k15":null},{"k0":9007199254741921},{"k1":9007199254741922},{"k2":null},{"k3":9007199254741924},{"k4":9007199254741925},{"k5":null},{"k6":9007199254741927},{"k7":9007199254741928},{"k8":null},{"k9":9007199254741930},{"k10":9007199254741931},{"k11":null},{"k12":9007199254741933},{"k13":9007199254741934},{"k14":null},{"k15":9007199254741936},{"k0":9007199254741937},{"k1":null},{"k2":9007199254741939},{"k3":9007199254741940},{"k4":null},{"k5":9007199254741942},{"k6":9007199254741943},{"k7":null},{"k8":9007199254741945},{"k9":9007199254741946},{"k10":null},{"k11":9007199254741948},{"k12":9007199254741949},{"k13":null},{"k14":9007199254741951},{"k15":9007199254741952},{"k0":null},{"k1":9007199254741954},{"k2":9007199254741955},{"k3":null},{"k4":9007199254741957},{"k5":9007199254741958},{"k6":null},{"k7":9007199254741960},{"k8":9007199254741961},{"k9":null},{"k10":9007199254741963},{"k11":9007199254741964},{"k12":null},{"k13":9007199254741966},{"k14":9007199254741967},{"k15":null},{"k0":9007199254741969},{"k1":9007199254741970},{"k2":null},{"k3":9007199254741972},{"k4":9007199254741973},{"k5":null},{"k6":9007199254741975},{"k7":9007199254741976},{"k8":null},{"k9":9007199254741978},{"k10":9007199254741979},{"k11":null},{"k12":9007199254741981},{"k13":9007199254741982},{"k14":null},{"k15":9007199254741984},{"k0":9007199254741985},{"k1":null},{"k2":9007199254741987},{"k3":9007199254741988},{"k4":null},{"k5":9007199254741990},{"k6":9007199254741991},{"k7":null},{"k8":9007199254741993},{"k9":9007199254741994},{"k10":null},{"k11":9007199254741996},{"k12":9007199254741997},{"k13":null},{"k14":9007199254741999},{"k15":9007199254742000},{"k0":null},{"k1":9007199254742002},{"k2":9007199254742003},{"k3":null},{"k4":9007199254742005},{"k5":9007199254742006},{"k6":null},{"k7":9007199254742008},{"k8":9007199254742009},{"k9":null},{"k10":9007199254742011},{"k11":9007199254742012},{"k12":null},{"k13":9007199254742014},{"k14":9007199254742015},{"k15":null},{"k0":9007199254742017},{"k1":9007199254742018},{"k2":null},{"k3":9007199254742020},{"k4":9007199254742021},{"k5":null},{"k6":9007199254742023},{"k7":9007199254742024},{"k8":null},{"k9":9007199254742026},{"k10":9007199254742027},{"k11":null},{"k12":9007199254742029},{"k13":9007199254742030},{"k14":null},{"k15":9007199254742032},{"k0":9007199254742033},{"k1":null},{"k2":9007199254742035},{"k3":9007199254742036},{"k4":null},{"k5":9007199254742038},{"k6":9007199254742039},{"k7":null},{"k8":9007199254742041},{"k9":9007199254742042},{"k10":null},{"k11":9007199254742044},{"k12":9007199254742045},{"k13":null},{"k14":9007199254742047},{"k15":9007199254742048},{"k0":null},{"k1":9007199254742050},{"k2":9007199254742051},{"k3":null},{"k4":9007199254742053},{"k5":9007199254742054},{"k6":null},{"k7":9007199254742056},{"k8":9007199254742057},{"k9":null},{"k10":9007199254742059},{"k11":9007199254742060},{"k12":null},{"k13":9007199254742062},{"k14":9007199254742063},{"k15":null},{"k0":9007199254742065},{"k1":9007199254742066},{"k2":null},{"k3":9007199254742068},{"k4":9007199254742069},{"k5":null},{"k6":9007199254742071},{"k7":9007199254742072},{"k8":null},{"k9":9007199254742074},{"k10":9007199254742075},{"k11":null},{"k12":9007199254742077},{"k13":9007199254742078},{"k14":null},{"k15":9007199254742080},{"k0":9007199254742081},{"k1":null},{"k2":9007199254742083},{"k3":9007199254742084},{"k4":null},{"k5":9007199254742086},{"k6":9007199254742087},{"k7":null},{"k8":9007199254742089},{"k9":9007199254742090},{"k10":null},{"k11":9007199254742092},{"k12":9007199254742093},{"k13":null},{"k14":9007199254742095},{"k15":9007199254742096},{"k0":null},{"k1":9007199254742098},{"k2":9007199254742099},{"k3":null},{"k4":9007199254742101},{"k5":9007199254742102},{"k6":null},{"k7":9007199254742104},{"k8":9007199254742105},{"k9":null},{"k10":9007199254742107},{"k11":9007199254742108},{"k12":null},{"k13":9007199254742110},{"k14":9007199254742111},{"k15":null},{"k0":9007199254742113},{"k1":9007199254742114},{"k2":null},{"k3":9007199254742116},{"k4":9007199254742117},{"k5":null},{"k6":9007199254742119},{"k7":9007199254742120},{"k8":null},{"k9":9007199254742122},{"k10":9007199254742123},{"k11":null},{"k12":9007199254742125},{"k13":9007199254742126},{"k14":null},{"k15":9007199254742128},{"k0":9007199254742129},{"k1":null},{"k2":9007199254742131},{"k3":9007199254742132},{"k4":null},{"k5":9007199254742134},{"k6":9007199254742135},{"k7":null},{"k8":9007199254742137},{"k9":9007199254742138},{"k10":null},{"k11":9007199254742140},{"k12":9007199254742141},{"k13":null},{"k14":9007199254742143},{"k15":9007199254742144},{"k0":null},{"k1":9007199254742146},{"k2":9007199254742147},{"k3":null},{"k4":9007199254742149},{"k5":9007199254742150},{"k6":null},{"k7":9007199254742152},{"k8":9007199254742153},{"k9":null},{"k10":9007199254742155},{"k11":9007199254742156},{"k12":null},{"k13":9007199254742158},{"k14":9007199254742159},{"k15":null},{"k0":9007199254742161},{"k1":9007199254742162},{"k2":null},{"k3":9007199254742164},{"k4":9007199254742165},{"k5":null},{"k6":9007199254742167},{"k7":9007199254742168},{"k8":null},{"k9":9007199254742170},{"k10":9007199254742171},{"k11":null},{"k12":9007199254742173},{"k13":9007199254742174},{"k14":null},{"k15":9007199254742176},{"k0":9007199254742177},{"k1":null},{"k2":9007199254742179},{"k3":9007199254742180},{"k4":null},{"k5":9007199254742182},{"k6":9007199254742183},{"k7":null},{"k8":9007199254742185},{"k9":9007199254742186},{"k10":null},{"k11":9007199254742188},{"k12":9007199254742189},{"k13":null},{"k14":9007199254742191},{"k15":9007199254742192},{"k0":null},{"k1":9007199254742194},{"k2":9007199254742195},{"k3":null},{"k4":9007199254742197},{"k5":9007199254742198},{"k6":null},{"k7":9007199254742200},{"k8":9007199254742201},{"k9":null},{"k10":9007199254742203},{"k11":9007199254742204},{"k12":null},{"k13":9007199254742206},{"k14":9007199254742207},{"k15":null},{"k0":9007199254742209},{"k1":9007199254742210},{"k2":null},{"k3":9007199254742212},{"k4":9007199254742213},{"k5":null},{"k6":9007199254742215},{"k7":9007199254742216},{"k8":null},{"k9":9007199254742218},{"k10":9007199254742219},{"k11":null},{"k12":9007199254742221},{"k13":9007199254742222},{"k14":null},{"k15":9007199254742224},{"k0":9007199254742225},{"k1":null},{"k2":9007199254742227},{"k3":9007199254742228},{"k4":null},{"k5":9007199254742230},{"k6":9007199254742231},{"k7":null},{"k8":9007199254742233},{"k9":9007199254742234},{"k10":null},{"k11":9007199254742236},{"k12":9007199254742237},{"k13":null},{"k14":9007199254742239},{"k15":9007199254742240},{"k0":null},{"k1":9007199254742242},{"k2":9007199254742243},{"k3":null},{"k4":9007199254742245},{"k5":9007199254742246},{"k6":null},{"k7":9007199254742248},{"k8":9007199254742249},{"k9":null},{"k10":9007199254742251},{"k11":9007199254742252},{"k12":null},{"k13":9007199254742254},{"k14":9007199254742255},{"k15":null},{"k0":9007199254742257},{"k1":9007199254742258},{"k2":null},{"k3":9007199254742260},{"k4":9007199254742261},{"k5":null},{"k6":9007199254742263},{"k7":9007199254742264},{"k8":null},{"k9":9007199254742266},{"k10":9007199254742267},{"k11":null},{"k12":9007199254742269},{"k13":9007199254742270},{"k14":null},{"k15":9007199254742272},{"k0":9007199254742273},{"k1":null},{"k2":9007199254742275},{"k3":9007199254742276},{"k4":null},{"k5":9007199254742278},{"k6":9007199254742279},{"k7":null},{"k8":9007199254742281},{"k9":9007199254742282},{"k10":null},{"k11":9007199254742284},{"k12":9007199254742285},{"k13":null},{"k14":9007199254742287},{"k15":9007199254742288},{"k0":null},{"k1":9007199254742290},{"k2":9007199254742291},{"k3":null},{"k4":9007199254742293},{"k5":9007199254742294},{"k6":null},{"k7":9007199254742296},{"k8":9007199254742297},{"k9":null},{"k10":9007199254742299},{"k11":9007199254742300},{"k12":null},{"k13":9007199254742302},{"k14":9007199254742303},{"k15":null},{"k0":9007199254742305},{"k1":9007199254742306},{"k2":null},{"k3":9007199254742308},{"k4":9007199254742309},{"k5":null},{"k6":9007199254742311},{"k7":9007199254742312},{"k8":null},{"k9":9007199254742314},{"k10":9007199254742315},{"k11":null},{"k12":9007199254742317},{"k13":9007199254742318},{"k14":null},{"k15":9007199254742320},{"k0":9007199254742321},{"k1":null},{"k2":9007199254742323},{"k3":9007199254742324},{"k4":null},{"k5":9007199254742326},{"k6":9007199254742327},{"k7":null},{"k8":9007199254742329},{"k9":9007199254742330},{"k10":null},{"k11":9007199254742332},{"k12":9007199254742333},{"k13":null},{"k14":9007199254742335},{"k15":9007199254742336},{"k0":null},{"k1":9007199254742338},{"k2":9007199254742339},{"k3":null},{"k4":9007199254742341},{"k5":9007199254742342},{"k6":null},{"k7":9007199254742344},{"k8":9007199254742345},{"k9":null},{"k10":9007199254742347},{"k11":9007199254742348},{"k12":null},{"k13":9007199254742350},{"k14":9007199254742351},{"k15":null},{"k0":9007199254742353},{"k1":9007199254742354},{"k2":null},{"k3":9007199254742356},{"k4":9007199254742357},{"k5":null},{"k6":9007199254742359},{"k7":9007199254742360},{"k8":null},{"k9":9007199254742362},{"k10":9007199254742363},{"k11":null},{"k12":9007199254742365},{"k13":9007199254742366},{"k14":null},{"k15":9007199254742368},{"k0":9007199254742369},{"k1":null},{"k2":9007199254742371},{"k3":9007199254742372},{"k4":null},{"k5":9007199254742374},{"k6":9007199254742375},{"k7":null},{"k8":9007199254742377},{"k9":9007199254742378},{"k10":null},{"k11":9007199254742380},{"k12":9007199254742381},{"k13":null},{"k14":9007199254742383},{"k15":9007199254742384},{"k0":null},{"k1":9007199254742386},{"k2":9007199254742387},{"k3":null},{"k4":9007199254742389},{"k5":9007199254742390},{"k6":null},{"k7":9007199254742392},{"k8":9007199254742393},{"k9":null},{"k10":9007199254742395},{"k11":9007199254742396},{"k12":null},{"k13":9007199254742398},{"k14":9007199254742399},{"k15":null},{"k0":9007199254742401},{"k1":9007199254742402},{"k2":null},{"k3":9007199254742404},{"k4":9007199254742405},{"k5":null},{"k6":9007199254742407},{"k7":9007199254742408},{"k8":null},{"k9":9007199254742410},{"k10":9007199254742411},{"k11":null},{"k12":9007199254742413},{"k13":9007199254742414},{"k14":null},{"k15":9007199254742416},{"k0":9007199254742417},{"k1":null},{"k2":9007199254742419},{"k3":9007199254742420},{"k4":null},{"k5":9007199254742422},{"k6":9007199254742423},{"k7":null},{"k8":9007199254742425},{"k9":9007199254742426},{"k10":null},{"k11":9007199254742428},{"k12":9007199254742429},{"k13":null},{"k14":9007199254742431},{"k15":9007199254742432},{"k0":null},{"k1":9007199254742434},{"k2":9007199254742435},{"k3":null},{"k4":9007199254742437},{"k5":9007199254742438},{"k6":null},{"k7":9007199254742440},{"k8":9007199254742441},{"k9":null},{"k10":9007199254742443},{"k11":9007199254742444},{"k12":null},{"k13":9007199254742446},{"k14":9007199254742447},{"k15":null},{"k0":9007199254742449},{"k1":9007199254742450},{"k2":null},{"k3":9007199254742452},{"k4":9007199254742453},{"k5":null},{"k6":9007199254742455},{"k7":9007199254742456},{"k8":null},{"k9":9007199254742458},{"k10":9007199254742459},{"k11":null},{"k12":9007199254742461},{"k13":9007199254742462},{"k14":null},{"k15":9007199254742464},{"k0":9007199254742465},{"k1":null},{"k2":9007199254742467},{"k3":9007199254742468},{"k4":null},{"k5":9007199254742470},{"k6":9007199254742471},{"k7":null},{"k8":9007199254742473},{"k9":9007199254742474},{"k10":null},{"k11":9007199254742476},{"k12":9007199254742477},{"k13":null},{"k14":9007199254742479},{"k15":9007199254742480},{"k0":null},{"k1":9007199254742482},{"k2":9007199254742483},{"k3":null},{"k4":9007199254742485},{"k5":9007199254742486},{"k6":null},{"k7":9007199254742488},{"k8":9007199254742489},{"k9":null},{"k10":9007199254742491},{"k11":9007199254742492},{"k12":null},{"k13":9007199254742494},{"k14":9007199254742495},{"k15":null},{"k0":9007199254742497},{"k1":9007199254742498},{"k2":null},{"k3":9007199254742500},{"k4":9007199254742501},{"k5":null},{"k6":9007199254742503},{"k7":9007199254742504},{"k8":null},{"k9":9007199254742506},{"k10":9007199254742507},{"k11":null},{"k12":9007199254742509},{"k13":9007199254742510},{"k14":null},{"k15":9007199254742512},{"k0":9007199254742513},{"k1":null},{"k2":9007199254742515},{"k3":9007199254742516},{"k4":null},{"k5":9007199254742518},{"k6":9007199254742519},{"k7":null},{"k8":9007199254742521},{"k9":9007199254742522},{"k10":null},{"k11":9007199254742524},{"k12":9007199254742525},{"k13":null},{"k14":9007199254742527},{"k15":9007199254742528},{"k0":null},{"k1":9007199254742530},{"k2":9007199254742531},{"k3":null},{"k4":9007199254742533},{"k5":9007199254742534},{"k6":null},{"k7":9007199254742536},{"k8":9007199254742537},{"k9":null},{"k10":9007199254742539},{"k11":9007199254742540},{"k12":null},{"k13":9007199254742542},{"k14":9007199254742543},{"k15":null},{"k0":9007199254742545},{"k1":9007199254742546},{"k2":null},{"k3":9007199254742548},{"k4":9007199254742549},{"k5":null},{"k6":9007199254742551},{"k7":9007199254742552},{"k8":null},{"k9":9007199254742554},{"k10":9007199254742555},{"k11":null},{"k12":9007199254742557},{"k13":9007199254742558},{"k14":null},{"k15":9007199254742560},{"k0":9007199254742561},{"k1":null},{"k2":9007199254742563},{"k3":9007199254742564},{"k4":null},{"k5":9007199254742566},{"k6":9007199254742567},{"k7":null},{"k8":9007199254742569},{"k9":9007199254742570},{"k10":null},{"k11":9007199254742572},{"k12":9007199254742573},{"k13":null},{"k14":9007199254742575},{"k15":9007199254742576},{"k0":null},{"k1":9007199254742578},{"k2":9007199254742579},{"k3":null},{"k4":9007199254742581},{"k5":9007199254742582},{"k6":null},{"k7":9007199254742584},{"k8":9007199254742585},{"k9":null},{"k10":9007199254742587},{"k11":9007199254742588},{"k12":null},{"k13":9007199254742590},{"k14":9007199254742591},{"k15":null},{"k0":9007199254742593},{"k1":9007199254742594},{"k2":null},{"k3":9007199254742596},{"k4":9007199254742597},{"k5":null},{"k6":9007199254742599},{"k7":9007199254742600},{"k8":null},{"k9":9007199254742602},{"k10":9007199254742603},{"k11":null},{"k12":9007199254742605},{"k13":9007199254742606},{"k14":null},{"k15":9007199254742608},{"k0":9007199254742609},{"k1":null},{"k2":9007199254742611},{"k3":9007199254742612},{"k4":null},{"k5":9007199254742614},{"k6":9007199254742615},{"k7":null},{"k8":9007199254742617},{"k9":9007199254742618},{"k10":null},{"k11":9007199254742620},{"k12":9007199254742621},{"k13":null},{"k14":9007199254742623},{"k15":9007199254742624},{"k0":null},{"k1":9007199254742626},{"k2":9007199254742627},{"k3":null},{"k4":9007199254742629},{"k5":9007199254742630},{"k6":null},{"k7":9007199254742632},{"k8":9007199254742633},{"k9":null},{"k10":9007199254742635},{"k11":9007199254742636},{"k12":null},{"k13":9007199254742638},{"k14":9007199254742639},{"k15":null},{"k0":9007199254742641},{"k1":9007199254742642},{"k2":null},{"k3":9007199254742644},{"k4":9007199254742645},{"k5":null},{"k6":9007199254742647},{"k7":9007199254742648},{"k8":null},{"k9":9007199254742650},{"k10":9007199254742651},{"k11":null},{"k12":9007199254742653},{"k13":9007199254742654},{"k14":null},{"k15":9007199254742656},{"k0":9007199254742657},{"k1":null},{"k2":9007199254742659},{"k3":9007199254742660},{"k4":null},{"k5":9007199254742662},{"k6":9007199254742663},{"k7":null},{"k8":9007199254742665},{"k9":9007199254742666},{"k10":null},{"k11":9007199254742668},{"k12":9007199254742669},{"k13":null},{"k14":9007199254742671},{"k15":9007199254742672},{"k0":null},{"k1":9007199254742674},{"k2":9007199254742675},{"k3":null},{"k4":9007199254742677},{"k5":9007199254742678},{"k6":null},{"k7":9007199254742680},{"k8":9007199254742681},{"k9":null},{"k10":9007199254742683},{"k11":9007199254742684},{"k12":null},{"k13":9007199254742686},{"k14":9007199254742687},{"k15":null},{"k0":9007199254742689},{"k1":9007199254742690},{"k2":null},{"k3":9007199254742692},{"k4":9007199254742693},{"k5":null},{"k6":9007199254742695},{"k7":9007199254742696},{"k8":null},{"k9":9007199254742698},{"k10":9007199254742699},{"k11":null},{"k12":9007199254742701},{"k13":9007199254742702},{"k14":null},{"k15":9007199254742704},{"k0":9007199254742705},{"k1":null},{"k2":9007199254742707},{"k3":9007199254742708},{"k4":null},{"k5":9007199254742710},{"k6":9007199254742711},{"k7":null},{"k8":9007199254742713},{"k9":9007199254742714},{"k10":null},{"k11":9007199254742716},{"k12":9007199254742717},{"k13":null},{"k14":9007199254742719},{"k15":9007199254742720},{"k0":null},{"k1":9007199254742722},{"k2":9007199254742723},{"k3":null},{"k4":9007199254742725},{"k5":9007199254742726},{"k6":null},{"k7":9007199254742728},{"k8":9007199254742729},{"k9":null},{"k10":9007199254742731},{"k11":9007199254742732},{"k12":null},{"k13":9007199254742734},{"k14":9007199254742735},{"k15":null},{"k0":9007199254742737},{"k1":9007199254742738},{"k2":null},{"k3":9007199254742740},{"k4":9007199254742741},{"k5":null},{"k6":9007199254742743},{"k7":9007199254742744},{"k8":null},{"k9":9007199254742746},{"k10":9007199254742747},{"k11":null},{"k12":9007199254742749},{"k13":9007199254742750},{"k14":null},{"k15":9007199254742752},{"k0":9007199254742753},{"k1":null},{"k2":9007199254742755},{"k3":9007199254742756},{"k4":null},{"k5":9007199254742758},{"k6":9007199254742759},{"k7":null},{"k8":9007199254742761},{"k9":9007199254742762},{"k10":null},{"k11":9007199254742764},{"k12":9007199254742765},{"k13":null},{"k14":9007199254742767},{"k15":9007199254742768},{"k0":null},{"k1":9007199254742770},{"k2":9007199254742771},{"k3":null},{"k4":9007199254742773},{"k5":9007199254742774},{"k6":null},{"k7":9007199254742776},{"k8":9007199254742777},{"k9":null},{"k10":9007199254742779},{"k11":9007199254742780},{"k12":null},{"k13":9007199254742782},{"k14":9007199254742783},{"k15":null},{"k0":9007199254742785},{"k1":9007199254742786},{"k2":null},{"k3":9007199254742788},{"k4":9007199254742789},{"k5":null},{"k6":9007199254742791},{"k7":9007199254742792},{"k8":null},{"k9":9007199254742794},{"k10":9007199254742795},{"k11":null},{"k12":9007199254742797},{"k13":9007199254742798},{"k14":null},{"k15":9007199254742800},{"k0":9007199254742801},{"k1":null},{"k2":9007199254742803},{"k3":9007199254742804},{"k4":null},{"k5":9007199254742806},{"k6":9007199254742807},{"k7":null},{"k8":9007199254742809},{"k9":9007199254742810},{"k10":null},{"k11":9007199254742812},{"k12":9007199254742813},{"k13":null},{"k14":9007199254742815},{"k15":9007199254742816},{"k0":null},{"k1":9007199254742818},{"k2":9007199254742819},{"k3":null},{"k4":9007199254742821},{"k5":9007199254742822},{"k6":null},{"k7":9007199254742824},{"k8":9007199254742825},{"k9":null},{"k10":9007199254742827},{"k11":9007199254742828},{"k12":null},{"k13":9007199254742830},{"k14":9007199254742831},{"k15":null},{"k0":9007199254742833},{"k1":9007199254742834},{"k2":null},{"k3":9007199254742836},{"k4":9007199254742837},{"k5":null},{"k6":9007199254742839},{"k7":9007199254742840},{"k8":null},{"k9":9007199254742842},{"k10":9007199254742843},{"k11":null},{"k12":9007199254742845},{"k13":9007199254742846},{"k14":null},{"k15":9007199254742848},{"k0":9007199254742849},{"k1":null},{"k2":9007199254742851},{"k3":9007199254742852},{"k4":null},{"k5":9007199254742854},{"k6":9007199254742855},{"k7":null},{"k8":9007199254742857},{"k9":9007199254742858},{"k10":null},{"k11":9007199254742860},{"k12":9007199254742861},{"k13":null},{"k14":9007199254742863},{"k15":9007199254742864},{"k0":null},{"k1":9007199254742866},{"k2":9007199254742867},{"k3":null},{"k4":9007199254742869},{"k5":9007199254742870},{"k6":null},{"k7":9007199254742872},{"k8":9007199254742873},{"k9":null},{"k10":9007199254742875},{"k11":9007199254742876},{"k12":null},{"k13":9007199254742878},{"k14":9007199254742879},{"k15":null},{"k0":9007199254742881},{"k1":9007199254742882},{"k2":null},{"k3":9007199254742884},{"k4":9007199254742885},{"k5":null},{"k6":9007199254742887},{"k7":9007199254742888},{"k8":null},{"k9":9007199254742890},{"k10":9007199254742891},{"k11":null},{"k12":9007199254742893},{"k13":9007199254742894},{"k14":null},{"k15":9007199254742896},{"k0":9007199254742897},{"k1":null},{"k2":9007199254742899},{"k3":9007199254742900},{"k4":null},{"k5":9007199254742902},{"k6":9007199254742903},{"k7":null},{"k8":9007199254742905},{"k9":9007199254742906},{"k10":null},{"k11":9007199254742908},{"k12":9007199254742909},{"k13":null},{"k14":9007199254742911},{"k15":9007199254742912},{"k0":null},{"k1":9007199254742914},{"k2":9007199254742915},{"k3":null},{"k4":9007199254742917},{"k5":9007199254742918},{"k6":null},{"k7":9007199254742920},{"k8":9007199254742921},{"k9":null},{"k10":9007199254742923},{"k11":9007199254742924},{"k12":null},{"k13":9007199254742926},{"k14":9007199254742927},{"k15":null},{"k0":9007199254742929},{"k1":9007199254742930},{"k2":null},{"k3":9007199254742932},{"k4":9007199254742933},{"k5":null},{"k6":9007199254742935},{"k7":9007199254742936},{"k8":null},{"k9":9007199254742938},{"k10":9007199254742939},{"k11":null},{"k12":9007199254742941},{"k13":9007199254742942},{"k14":null},{"k15":9007199254742944},{"k0":9007199254742945},{"k1":null},{"k2":9007199254742947},{"k3":9007199254742948},{"k4":null},{"k5":9007199254742950},{"k6":9007199254742951},{"k7":null},{"k8":9007199254742953},{"k9":9007199254742954},{"k10":null},{"k11":9007199254742956},{"k12":9007199254742957},{"k13":null},{"k14":9007199254742959},{"k15":9007199254742960},{"k0":null},{"k1":9007199254742962},{"k2":9007199254742963},{"k3":null},{"k4":9007199254742965},{"k5":9007199254742966},{"k6":null},{"k7":9007199254742968},{"k8":9007199254742969},{"k9":null},{"k10":9007199254742971},{"k11":9007199254742972},{"k12":null},{"k13":9007199254742974},{"k14":9007199254742975},{"k15":null},{"k0":9007199254742977},{"k1":9007199254742978},{"k2":null},{"k3":9007199254742980},{"k4":9007199254742981},{"k5":null},{"k6":9007199254742983},{"k7":9007199254742984},{"k8":null},{"k9":9007199254742986},{"k10":9007199254742987},{"k11":null},{"k12":9007199254742989},{"k13":9007199254742990},{"k14":null},{"k15":9007199254742992},{"k0":9007199254742993},{"k1":null},{"k2":9007199254742995},{"k3":9007199254742996},{"k4":null},{"k5":9007199254742998},{"k6":9007199254742999},{"k7":null},{"k8":9007199254743001},{"k9":9007199254743002},{"k10":null},{"k11":9007199254743004},{"k12":9007199254743005},{"k13":null},{"k14":9007199254743007},{"k15":9007199254743008},{"k0":null},{"k1":9007199254743010},{"k2":9007199254743011},{"k3":null},{"k4":9007199254743013},{"k5":9007199254743014},{"k6":null},{"k7":9007199254743016},{"k8":9007199254743017},{"k9":null},{"k10":9007199254743019},{"k11":9007199254743020},{"k12":null},{"k13":9007199254743022},{"k14":9007199254743023},{"k15":null},{"k0":9007199254743025},{"k1":9007199254743026},{"k2":null},{"k3":9007199254743028},{"k4":9007199254743029},{"k5":null},{"k6":9007199254743031},{"k7":9007199254743032},{"k8":null},{"k9":9007199254743034},{"k10":9007199254743035},{"k11":null},{"k12":9007199254743037},{"k13":9007199254743038},{"k14":null},{"k15":9007199254743040},{"k0":9007199254743041},{"k1":null},{"k2":9007199254743043},{"k3":9007199254743044},{"k4":null},{"k5":9007199254743046},{"k6":9007199254743047},{"k7":null},{"k8":9007199254743049},{"k9":9007199254743050},{"k10":null},{"k11":9007199254743052},{"k12":9007199254743053},{"k13":null},{"k14":9007199254743055},{"k15":9007199254743056},{"k0":null},{"k1":9007199254743058},{"k2":9007199254743059},{"k3":null},{"k4":9007199254743061},{"k5":9007199254743062},{"k6":null},{"k7":9007199254743064},{"k8":9007199254743065},{"k9":null},{"k10":9007199254743067},{"k11":9007199254743068},{"k12":null},{"k13":9007199254743070},{"k14":9007199254743071},{"k15":null},{"k0":9007199254743073},{"k1":9007199254743074},{"k2":null},{"k3":9007199254743076},{"k4":9007199254743077},{"k5":null},{"k6":9007199254743079},{"k7":9007199254743080},{"k8":null},{"k9":9007199254743082},{"k10":9007199254743083},{"k11":null},{"k12":9007199254743085},{"k13":9007199254743086},{"k14":null},{"k15":9007199254743088},{"k0":9007199254743089},{"k1":null},{"k2":9007199254743091},{"k3":9007199254743092},{"k4":null},{"k5":9007199254743094},{"k6":9007199254743095},{"k7":null},{"k8":9007199254743097},{"k9":9007199254743098},{"k10":null},{"k11":9007199254743100},{"k12":9007199254743101},{"k13":null},{"k14":9007199254743103},{"k15":9007199254743104},{"k0":null},{"k1":9007199254743106},{"k2":9007199254743107},{"k3":null},{"k4":9007199254743109},{"k5":9007199254743110},{"k6":null},{"k7":9007199254743112},{"k8":9007199254743113},{"k9":null},{"k10":9007199254743115},{"k11":9007199254743116},{"k12":null},{"k13":9007199254743118},{"k14":9007199254743119},{"k15":null},{"k0":9007199254743121},{"k1":9007199254743122},{"k2":null},{"k3":9007199254743124},{"k4":9007199254743125},{"k5":null},{"k6":9007199254743127},{"k7":9007199254743128},{"k8":null},{"k9":9007199254743130},{"k10":9007199254743131},{"k11":null},{"k12":9007199254743133},{"k13":9007199254743134},{"k14":null},{"k15":9007199254743136},{"k0":9007199254743137},{"k1":null},{"k2":9007199254743139},{"k3":9007199254743140},{"k4":null},{"k5":9007199254743142},{"k6":9007199254743143},{"k7":null},{"k8":9007199254743145},{"k9":9007199254743146},{"k10":null},{"k11":9007199254743148},{"k12":9007199254743149},{"k13":null},{"k14":9007199254743151},{"k15":9007199254743152},{"k0":null},{"k1":9007199254743154},{"k2":9007199254743155},{"k3":null},{"k4":9007199254743157},{"k5":9007199254743158},{"k6":null},{"k7":9007199254743160},{"k8":9007199254743161},{"k9":null},{"k10":9007199254743163},{"k11":9007199254743164},{"k12":null},{"k13":9007199254743166},{"k14":9007199254743167},{"k15":null},{"k0":9007199254743169},{"k1":9007199254743170},{"k2":null},{"k3":9007199254743172},{"k4":9007199254743173},{"k5":null},{"k6":9007199254743175},{"k7":9007199254743176},{"k8":null},{"k9":9007199254743178},{"k10":9007199254743179},{"k11":null},{"k12":9007199254743181},{"k13":9007199254743182},{"k14":null},{"k15":9007199254743184},{"k0":9007199254743185},{"k1":null},{"k2":9007199254743187},{"k3":9007199254743188},{"k4":null},{"k5":9007199254743190},{"k6":9007199254743191},{"k7":null},{"k8":9007199254743193},{"k9":9007199254743194},{"k10":null},{"k11":9007199254743196},{"k12":9007199254743197},{"k13":null},{"k14":9007199254743199},{"k15":9007199254743200},{"k0":null},{"k1":9007199254743202},{"k2":9007199254743203},{"k3":null},{"k4":9007199254743205},{"k5":9007199254743206},{"k6":null},{"k7":9007199254743208},{"k8":9007199254743209},{"k9":null},{"k10":9007199254743211},{"k11":9007199254743212},{"k12":null},{"k13":9007199254743214},{"k14":9007199254743215},{"k15":null},{"k0":9007199254743217},{"k1":9007199254743218},{"k2":null},{"k3":9007199254743220},{"k4":9007199254743221},{"k5":null},{"k6":9007199254743223},{"k7":9007199254743224},{"k8":null},{"k9":9007199254743226},{"k10":9007199254743227},{"k11":null},{"k12":9007199254743229},{"k13":9007199254743230},{"k14":null},{"k15":9007199254743232},{"k0":9007199254743233},{"k1":null},{"k2":9007199254743235},{"k3":9007199254743236},{"k4":null},{"k5":9007199254743238},{"k6":9007199254743239},{"k7":null},{"k8":9007199254743241},{"k9":9007199254743242},{"k10":null},{"k11":9007199254743244},{"k12":9007199254743245},{"k13":null},{"k14":9007199254743247},{"k15":9007199254743248},{"k0":null},{"k1":9007199254743250},{"k2":9007199254743251},{"k3":null},{"k4":9007199254743253},{"k5":9007199254743254},{"k6":null},{"k7":9007199254743256},{"k8":9007199254743257},{"k9":null},{"k10":9007199254743259},{"k11":9007199254743260},{"k12":null},{"k13":9007199254743262},{"k14":9007199254743263},{"k15":null},{"k0":9007199254743265},{"k1":9007199254743266},{"k2":null},{"k3":9007199254743268},{"k4":9007199254743269},{"k5":null},{"k6":9007199254743271},{"k7":9007199254743272},{"k8":null},{"k9":9007199254743274},{"k10":9007199254743275},{"k11":null},{"k12":9007199254743277},{"k13":9007199254743278},{"k14":null},{"k15":9007199254743280},{"k0":9007199254743281},{"k1":null},{"k2":9007199254743283},{"k3":9007199254743284},{"k4":null},{"k5":9007199254743286},{"k6":9007199254743287},{"k7":null},{"k8":9007199254743289},{"k9":9007199254743290},{"k10":null},{"k11":9007199254743292},{"k12":9007199254743293},{"k13":null},{"k14":9007199254743295},{"k15":9007199254743296},{"k0":null},{"k1":9007199254743298},{"k2":9007199254743299},{"k3":null},{"k4":9007199254743301},{"k5":9007199254743302},{"k6":null},{"k7":9007199254743304},{"k8":9007199254743305},{"k9":null},{"k10":9007199254743307},{"k11":9007199254743308},{"k12":null},{"k13":9007199254743310},{"k14":9007199254743311},{"k15":null},{"k0":9007199254743313},{"k1":9007199254743314},{"k2":null},{"k3":9007199254743316},{"k4":9007199254743317},{"k5":null},{"k6":9007199254743319},{"k7":9007199254743320},{"k8":null},{"k9":9007199254743322},{"k10":9007199254743323},{"k11":null},{"k12":9007199254743325},{"k13":9007199254743326},{"k14":null},{"k15":9007199254743328},{"k0":9007199254743329},{"k1":null},{"k2":9007199254743331},{"k3":9007199254743332},{"k4":null},{"k5":9007199254743334},{"k6":9007199254743335},{"k7":null},{"k8":9007199254743337},{"k9":9007199254743338},{"k10":null},{"k11":9007199254743340},{"k12":9007199254743341},{"k13":null},{"k14":9007199254743343},{"k15":9007199254743344},{"k0":null},{"k1":9007199254743346},{"k2":9007199254743347},{"k3":null},{"k4":9007199254743349},{"k5":9007199254743350},{"k6":null},{"k7":9007199254743352},{"k8":9007199254743353},{"k9":null},{"k10":9007199254743355},{"k11":9007199254743356},{"k12":null},{"k13":9007199254743358},{"k14":9007199254743359},{"k15":null},{"k0":9007199254743361},{"k1":9007199254743362},{"k2":null},{"k3":9007199254743364},{"k4":9007199254743365},{"k5":null},{"k6":9007199254743367},{"k7":9007199254743368},{"k8":null},{"k9":9007199254743370},{"k10":9007199254743371},{"k11":null},{"k12":9007199254743373},{"k13":9007199254743374},{"k14":null},{"k15":9007199254743376},{"k0":9007199254743377},{"k1":null},{"k2":9007199254743379},{"k3":9007199254743380},{"k4":null},{"k5":9007199254743382},{"k6":9007199254743383},{"k7":null},{"k8":9007199254743385},{"k9":9007199254743386},{"k10":null},{"k11":9007199254743388},{"k12":9007199254743389},{"k13":null},{"k14":9007199254743391},{"k15":9007199254743392},{"k0":null},{"k1":9007199254743394},{"k2":9007199254743395},{"k3":null},{"k4":9007199254743397},{"k5":9007199254743398},{"k6":null},{"k7":9007199254743400},{"k8":9007199254743401},{"k9":null},{"k10":9007199254743403},{"k11":9007199254743404},{"k12":null},{"k13":9007199254743406},{"k14":9007199254743407},{"k15":null},{"k0":9007199254743409},{"k1":9007199254743410},{"k2":null},{"k3":9007199254743412},{"k4":9007199254743413},{"k5":null},{"k6":9007199254743415},{"k7":9007199254743416},{"k8":null},{"k9":9007199254743418},{"k10":9007199254743419},{"k11":null},{"k12":9007199254743421},{"k13":9007199254743422},{"k14":null},{"k15":9007199254743424},{"k0":9007199254743425},{"k1":null},{"k2":9007199254743427},{"k3":9007199254743428},{"k4":null},{"k5":9007199254743430},{"k6":9007199254743431},{"k7":null},{"k8":9007199254743433},{"k9":9007199254743434},{"k10":null},{"k11":9007199254743436},{"k12":9007199254743437},{"k13":null},{"k14":9007199254743439},{"k15":9007199254743440},{"k0":null},{"k1":9007199254743442},{"k2":9007199254743443},{"k3":null},{"k4":9007199254743445},{"k5":9007199254743446},{"k6":null},{"k7":9007199254743448},{"k8":9007199254743449},{"k9":null},{"k10":9007199254743451},{"k11":9007199254743452},{"k12":null},{"k13":9007199254743454},{"k14":9007199254743455},{"k15":null},{"k0":9007199254743457},{"k1":9007199254743458},{"k2":null},{"k3":9007199254743460},{"k4":9007199254743461},{"k5":null},{"k6":9007199254743463},{"k7":9007199254743464},{"k8":null},{"k9":9007199254743466},{"k10":9007199254743467},{"k11":null},{"k12":9007199254743469},{"k13":9007199254743470},{"k14":null},{"k15":9007199254743472},{"k0":9007199254743473},{"k1":null},{"k2":9007199254743475},{"k3":9007199254743476},{"k4":null},{"k5":9007199254743478},{"k6":9007199254743479},{"k7":null},{"k8":9007199254743481},{"k9":9007199254743482},{"k10":null},{"k11":9007199254743484},{"k12":9007199254743485},{"k13":null},{"k14":9007199254743487},{"k15":9007199254743488},{"k0":null},{"k1":9007199254743490},{"k2":9007199254743491},{"k3":null},{"k4":9007199254743493},{"k5":9007199254743494},{"k6":null},{"k7":9007199254743496},{"k8":9007199254743497},{"k9":null},{"k10":9007199254743499},{"k11":9007199254743500},{"k12":null},{"k13":9007199254743502},{"k14":9007199254743503},{"k15":null},{"k0":9007199254743505},{"k1":9007199254743506},{"k2":null},{"k3":9007199254743508},{"k4":9007199254743509},{"k5":null},{"k6":9007199254743511},{"k7":9007199254743512},{"k8":null},{"k9":9007199254743514},{"k10":9007199254743515},{"k11":null},{"k12":9007199254743517},{"k13":9007199254743518},{"k14":null},{"k15":9007199254743520},{"k0":9007199254743521},{"k1":null},{"k2":9007199254743523},{"k3":9007199254743524},{"k4":null},{"k5":9007199254743526},{"k6":9007199254743527},{"k7":null},{"k8":9007199254743529},{"k9":9007199254743530},{"k10":null},{"k11":9007199254743532},{"k12":9007199254743533},{"k13":null},{"k14":9007199254743535},{"k15":9007199254743536},{"k0":null},{"k1":9007199254743538},{"k2":9007199254743539},{"k3":null},{"k4":9007199254743541},{"k5":9007199254743542},{"k6":null},{"k7":9007199254743544},{"k8":9007199254743545},{"k9":null},{"k10":9007199254743547},{"k11":9007199254743548},{"k12":null},{"k13":9007199254743550},{"k14":9007199254743551},{"k15":null},{"k0":9007199254743553},{"k1":9007199254743554},{"k2":null},{"k3":9007199254743556},{"k4":9007199254743557},{"k5":null},{"k6":9007199254743559},{"k7":9007199254743560},{"k8":null},{"k9":9007199254743562},{"k10":9007199254743563},{"k11":null},{"k12":9007199254743565},{"k13":9007199254743566},{"k14":null},{"k15":9007199254743568},{"k0":9007199254743569},{"k1":null},{"k2":9007199254743571},{"k3":9007199254743572},{"k4":null},{"k5":9007199254743574},{"k6":9007199254743575},{"k7":null},{"k8":9007199254743577},{"k9":9007199254743578},{"k10":null},{"k11":9007199254743580},{"k12":9007199254743581},{"k13":null},{"k14":9007199254743583},{"k15":9007199254743584},{"k0":null},{"k1":9007199254743586},{"k2":9007199254743587},{"k3":null},{"k4":9007199254743589},{"k5":9007199254743590},{"k6":null},{"k7":9007199254743592},{"k8":9007199254743593},{"k9":null},{"k10":9007199254743595},{"k11":9007199254743596},{"k12":null},{"k13":9007199254743598},{"k14":9007199254743599},{"k15":null},{"k0":9007199254743601},{"k1":9007199254743602},{"k2":null},{"k3":9007199254743604},{"k4":9007199254743605},{"k5":null},{"k6":9007199254743607},{"k7":9007199254743608},{"k8":null},{"k9":9007199254743610},{"k10":9007199254743611},{"k11":null},{"k12":9007199254743613},{"k13":9007199254743614},{"k14":null},{"k15":9007199254743616},{"k0":9007199254743617},{"k1":null},{"k2":9007199254743619},{"k3":9007199254743620},{"k4":null},{"k5":9007199254743622},{"k6":9007199254743623},{"k7":null},{"k8":9007199254743625},{"k9":9007199254743626},{"k10":null},{"k11":9007199254743628},{"k12":9007199254743629},{"k13":null},{"k14":9007199254743631},{"k15":9007199254743632},{"k0":null},{"k1":9007199254743634},{"k2":9007199254743635},{"k3":null},{"k4":9007199254743637},{"k5":9007199254743638},{"k6":null},{"k7":9007199254743640},{"k8":9007199254743641},{"k9":null},{"k10":9007199254743643},{"k11":9007199254743644},{"k12":null},{"k13":9007199254743646},{"k14":9007199254743647},{"k15":null},{"k0":9007199254743649},{"k1":9007199254743650},{"k2":null},{"k3":9007199254743652},{"k4":9007199254743653},{"k5":null},{"k6":9007199254743655},{"k7":9007199254743656},{"k8":null},{"k9":9007199254743658},{"k10":9007199254743659},{"k11":null},{"k12":9007199254743661},{"k13":9007199254743662},{"k14":null},{"k15":9007199254743664},{"k0":9007199254743665},{"k1":null},{"k2":9007199254743667},{"k3":9007199254743668},{"k4":null},{"k5":9007199254743670},{"k6":9007199254743671},{"k7":null},{"k8":9007199254743673},{"k9":9007199254743674},{"k10":null},{"k11":9007199254743676},{"k12":9007199254743677},{"k13":null},{"k14":9007199254743679},{"k15":9007199254743680},{"k0":null},{"k1":9007199254743682},{"k2":9007199254743683},{"k3":null},{"k4":9007199254743685},{"k5":9007199254743686},{"k6":null},{"k7":9007199254743688},{"k8":9007199254743689},{"k9":null},{"k10":9007199254743691},{"k11":9007199254743692},{"k12":null},{"k13":9007199254743694},{"k14":9007199254743695},{"k15":null},{"k0":9007199254743697},{"k1":9007199254743698},{"k2":null},{"k3":9007199254743700},{"k4":9007199254743701},{"k5":null},{"k6":9007199254743703},{"k7":9007199254743704},{"k8":null},{"k9":9007199254743706},{"k10":9007199254743707},{"k11":null},{"k12":9007199254743709},{"k13":9007199254743710},{"k14":null},{"k15":9007199254743712},{"k0":9007199254743713},{"k1":null},{"k2":9007199254743715},{"k3":9007199254743716},{"k4":null},{"k5":9007199254743718},{"k6":9007199254743719},{"k7":null},{"k8":9007199254743721},{"k9":9007199254743722},{"k10":null},{"k11":9007199254743724},{"k12":9007199254743725},{"k13":null},{"k14":9007199254743727},{"k15":9007199254743728},{"k0":null},{"k1":9007199254743730},{"k2":9007199254743731},{"k3":null},{"k4":9007199254743733},{"k5":9007199254743734},{"k6":null},{"k7":9007199254743736},{"k8":9007199254743737},{"k9":null},{"k10":9007199254743739},{"k11":9007199254743740},{"k12":null},{"k13":9007199254743742},{"k14":9007199254743743},{"k15":null},{"k0":9007199254743745},{"k1":9007199254743746},{"k2":null},{"k3":9007199254743748},{"k4":9007199254743749},{"k5":null},{"k6":9007199254743751},{"k7":9007199254743752},{"k8":null},{"k9":9007199254743754},{"k10":9007199254743755},{"k11":null},{"k12":9007199254743757},{"k13":9007199254743758},{"k14":null},{"k15":9007199254743760},{"k0":9007199254743761},{"k1":null},{"k2":9007199254743763},{"k3":9007199254743764},{"k4":null},{"k5":9007199254743766},{"k6":9007199254743767},{"k7":null},{"k8":9007199254743769},{"k9":9007199254743770},{"k10":null},{"k11":9007199254743772},{"k12":9007199254743773},{"k13":null},{"k14":9007199254743775},{"k15":9007199254743776},{"k0":null},{"k1":9007199254743778},{"k2":9007199254743779},{"k3":null},{"k4":9007199254743781},{"k5":9007199254743782},{"k6":null},{"k7":9007199254743784},{"k8":9007199254743785},{"k9":null},{"k10":9007199254743787},{"k11":9007199254743788},{"k12":null},{"k13":9007199254743790},{"k14":9007199254743791},{"k15":null},{"k0":9007199254743793},{"k1":9007199254743794},{"k2":null},{"k3":9007199254743796},{"k4":9007199254743797},{"k5":null},{"k6":9007199254743799},{"k7":9007199254743800},{"k8":null},{"k9":9007199254743802},{"k10":9007199254743803},{"k11":null},{"k12":9007199254743805},{"k13":9007199254743806},{"k14":null},{"k15":9007199254743808},{"k0":9007199254743809},{"k1":null},{"k2":9007199254743811},{"k3":9007199254743812},{"k4":null},{"k5":9007199254743814},{"k6":9007199254743815},{"k7":null},{"k8":9007199254743817},{"k9":9007199254743818},{"k10":null},{"k11":9007199254743820},{"k12":9007199254743821},{"k13":null},{"k14":9007199254743823},{"k15":9007199254743824},{"k0":null},{"k1":9007199254743826},{"k2":9007199254743827},{"k3":null},{"k4":9007199254743829},{"k5":9007199254743830},{"k6":null},{"k7":9007199254743832},{"k8":9007199254743833},{"k9":null},{"k10":9007199254743835},{"k11":9007199254743836},{"k12":null},{"k13":9007199254743838},{"k14":9007199254743839},{"k15":null},{"k0":9007199254743841},{"k1":9007199254743842},{"k2":null},{"k3":9007199254743844},{"k4":9007199254743845},{"k5":null},{"k6":9007199254743847},{"k7":9007199254743848},{"k8":null},{"k9":9007199254743850},{"k10":9007199254743851},{"k11":null},{"k12":9007199254743853},{"k13":9007199254743854},{"k14":null},{"k15":9007199254743856},{"k0":9007199254743857},{"k1":null},{"k2":9007199254743859},{"k3":9007199254743860},{"k4":null},{"k5":9007199254743862},{"k6":9007199254743863},{"k7":null},{"k8":9007199254743865},{"k9":9007199254743866},{"k10":null},{"k11":9007199254743868},{"k12":9007199254743869},{"k13":null},{"k14":9007199254743871},{"k15":9007199254743872},{"k0":null},{"k1":9007199254743874},{"k2":9007199254743875},{"k3":null},{"k4":9007199254743877},{"k5":9007199254743878},{"k6":null},{"k7":9007199254743880},{"k8":9007199254743881},{"k9":null},{"k10":9007199254743883},{"k11":9007199254743884},{"k12":null},{"k13":9007199254743886},{"k14":9007199254743887},{"k15":null},{"k0":9007199254743889},{"k1":9007199254743890},{"k2":null},{"k3":9007199254743892},{"k4":9007199254743893},{"k5":null},{"k6":9007199254743895},{"k7":9007199254743896},{"k8":null},{"k9":9007199254743898},{"k10":9007199254743899},{"k11":null},{"k12":9007199254743901},{"k13":9007199254743902},{"k14":null},{"k15":9007199254743904},{"k0":9007199254743905},{"k1":null},{"k2":9007199254743907},{"k3":9007199254743908},{"k4":null},{"k5":9007199254743910},{"k6":9007199254743911},{"k7":null},{"k8":9007199254743913},{"k9":9007199254743914},{"k10":null},{"k11":9007199254743916},{"k12":9007199254743917},{"k13":null},{"k14":9007199254743919},{"k15":9007199254743920},{"k0":null},{"k1":9007199254743922},{"k2":9007199254743923},{"k3":null},{"k4":9007199254743925},{"k5":9007199254743926},{"k6":null},{"k7":9007199254743928},{"k8":9007199254743929},{"k9":null},{"k10":9007199254743931},{"k11":9007199254743932},{"k12":null},{"k13":9007199254743934},{"k14":9007199254743935},{"k15":null},{"k0":9007199254743937},{"k1":9007199254743938},{"k2":null},{"k3":9007199254743940},{"k4":9007199254743941},{"k5":null},{"k6":9007199254743943},{"k7":9007199254743944},{"k8":null},{"k9":9007199254743946},{"k10":9007199254743947},{"k11":null},{"k12":9007199254743949},{"k13":9007199254743950},{"k14":null},{"k15":9007199254743952},{"k0":9007199254743953},{"k1":null},{"k2":9007199254743955},{"k3":9007199254743956},{"k4":null},{"k5":9007199254743958},{"k6":9007199254743959},{"k7":null},{"k8":9007199254743961},{"k9":9007199254743962},{"k10":null},{"k11":9007199254743964},{"k12":9007199254743965},{"k13":null},{"k14":9007199254743967},{"k15":9007199254743968},{"k0":null},{"k1":9007199254743970},{"k2":9007199254743971},{"k3":null},{"k4":9007199254743973},{"k5":9007199254743974},{"k6":null},{"k7":9007199254743976},{"k8":9007199254743977},{"k9":null},{"k10":9007199254743979},{"k11":9007199254743980},{"k12":null},{"k13":9007199254743982},{"k14":9007199254743983},{"k15":null},{"k0":9007199254743985},{"k1":9007199254743986},{"k2":null},{"k3":9007199254743988},{"k4":9007199254743989},{"k5":null},{"k6":9007199254743991},{"k7":9007199254743992},{"k8":null},{"k9":9007199254743994},{"k10":9007199254743995},{"k11":null},{"k12":9007199254743997},{"k13":9007199254743998},{"k14":null},{"k15":9007199254744000},{"k0":9007199254744001},{"k1":null},{"k2":9007199254744003},{"k3":9007199254744004},{"k4":null},{"k5":9007199254744006},{"k6":9007199254744007},{"k7":null},{"k8":9007199254744009},{"k9":9007199254744010},{"k10":null},{"k11":9007199254744012},{"k12":9007199254744013},{"k13":null},{"k14":9007199254744015},{"k15":9007199254744016},{"k0":null},{"k1":9007199254744018},{"k2":9007199254744019},{"k3":null},{"k4":9007199254744021},{"k5":9007199254744022},{"k6":null},{"k7":9007199254744024},{"k8":9007199254744025},{"k9":null},{"k10":9007199254744027},{"k11":9007199254744028},{"k12":null},{"k13":9007199254744030},{"k14":9007199254744031},{"k15":null},{"k0":9007199254744033},{"k1":9007199254744034},{"k2":null},{"k3":9007199254744036},{"k4":9007199254744037},{"k5":null},{"k6":9007199254744039},{"k7":9007199254744040},{"k8":null},{"k9":9007199254744042},{"k10":9007199254744043},{"k11":null},{"k12":9007199254744045},{"k13":9007199254744046},{"k14":null},{"k15":9007199254744048},{"k0":9007199254744049},{"k1":null},{"k2":9007199254744051},{"k3":9007199254744052},{"k4":null},{"k5":9007199254744054},{"k6":9007199254744055},{"k7":null},{"k8":9007199254744057},{"k9":9007199254744058},{"k10":null},{"k11":9007199254744060},{"k12":9007199254744061},{"k13":null},{"k14":9007199254744063},{"k15":9007199254744064},{"k0":null},{"k1":9007199254744066},{"k2":9007199254744067},{"k3":null},{"k4":9007199254744069},{"k5":9007199254744070},{"k6":null},{"k7":9007199254744072},{"k8":9007199254744073},{"k9":null},{"k10":9007199254744075},{"k11":9007199254744076},{"k12":null},{"k13":9007199254744078},{"k14":9007199254744079},{"k15":null},{"k0":9007199254744081},{"k1":9007199254744082},{"k2":null},{"k3":9007199254744084},{"k4":9007199254744085},{"k5":null},{"k6":9007199254744087},{"k7":9007199254744088},{"k8":null},{"k9":9007199254744090},{"k10":9007199254744091},{"k11":null},{"k12":9007199254744093},{"k13":9007199254744094},{"k14":null},{"k15":9007199254744096},{"k0":9007199254744097},{"k1":null},{"k2":9007199254744099},{"k3":9007199254744100},{"k4":null},{"k5":9007199254744102},{"k6":9007199254744103},{"k7":null},{"k8":9007199254744105},{"k9":9007199254744106},{"k10":null},{"k11":9007199254744108},{"k12":9007199254744109},{"k13":null},{"k14":9007199254744111},{"k15":9007199254744112},{"k0":null},{"k1":9007199254744114},{"k2":9007199254744115},{"k3":null},{"k4":9007199254744117},{"k5":9007199254744118},{"k6":null},{"k7":9007199254744120},{"k8":9007199254744121},{"k9":null},{"k10":9007199254744123},{"k11":9007199254744124},{"k12":null},{"k13":9007199254744126},{"k14":9007199254744127},{"k15":null},{"k0":9007199254744129},{"k1":9007199254744130},{"k2":null},{"k3":9007199254744132},{"k4":9007199254744133},{"k5":null},{"k6":9007199254744135},{"k7":9007199254744136},{"k8":null},{"k9":9007199254744138},{"k10":9007199254744139},{"k11":null},{"k12":9007199254744141},{"k13":9007199254744142},{"k14":null},{"k15":9007199254744144},{"k0":9007199254744145},{"k1":null},{"k2":9007199254744147},{"k3":9007199254744148},{"k4":null},{"k5":9007199254744150},{"k6":9007199254744151},{"k7":null},{"k8":9007199254744153},{"k9":9007199254744154},{"k10":null},{"k11":9007199254744156},{"k12":9007199254744157},{"k13":null},{"k14":9007199254744159},{"k15":9007199254744160},{"k0":null},{"k1":9007199254744162},{"k2":9007199254744163},{"k3":null},{"k4":9007199254744165},{"k5":9007199254744166},{"k6":null},{"k7":9007199254744168},{"k8":9007199254744169},{"k9":null},{"k10":9007199254744171},{"k11":9007199254744172},{"k12":null},{"k13":9007199254744174},{"k14":9007199254744175},{"k15":null},{"k0":9007199254744177},{"k1":9007199254744178},{"k2":null},{"k3":9007199254744180},{"k4":9007199254744181},{"k5":null},{"k6":9007199254744183},{"k7":9007199254744184},{"k8":null},{"k9":9007199254744186},{"k10":9007199254744187},{"k11":null},{"k12":9007199254744189},{"k13":9007199254744190},{"k14":null},{"k15":9007199254744192},{"k0":9007199254744193},{"k1":null},{"k2":9007199254744195},{"k3":9007199254744196},{"k4":null},{"k5":9007199254744198},{"k6":9007199254744199},{"k7":null},{"k8":9007199254744201},{"k9":9007199254744202},{"k10":null},{"k11":9007199254744204},{"k12":9007199254744205},{"k13":null},{"k14":9007199254744207},{"k15":9007199254744208},{"k0":null},{"k1":9007199254744210},{"k2":9007199254744211},{"k3":null},{"k4":9007199254744213},{"k5":9007199254744214},{"k6":null},{"k7":9007199254744216},{"k8":9007199254744217},{"k9":null},{"k10":9007199254744219},{"k11":9007199254744220},{"k12":null},{"k13":9007199254744222},{"k14":9007199254744223},{"k15":null},{"k0":9007199254744225},{"k1":9007199254744226},{"k2":null},{"k3":9007199254744228},{"k4":9007199254744229},{"k5":null},{"k6":9007199254744231},{"k7":9007199254744232},{"k8":null},{"k9":9007199254744234},{"k10":9007199254744235},{"k11":null},{"k12":9007199254744237},{"k13":9007199254744238},{"k14":null},{"k15":9007199254744240},{"k0":9007199254744241},{"k1":null},{"k2":9007199254744243},{"k3":9007199254744244},{"k4":null},{"k5":9007199254744246},{"k6":9007199254744247},{"k7":null},{"k8":9007199254744249},{"k9":9007199254744250},{"k10":null},{"k11":9007199254744252},{"k12":9007199254744253},{"k13":null},{"k14":9007199254744255},{"k15":9007199254744256},{"k0":null},{"k1":9007199254744258},{"k2":9007199254744259},{"k3":null},{"k4":9007199254744261},{"k5":9007199254744262},{"k6":null},{"k7":9007199254744264},{"k8":9007199254744265},{"k9":null},{"k10":9007199254744267},{"k11":9007199254744268},{"k12":null},{"k13":9007199254744270},{"k14":9007199254744271},{"k15":null},{"k0":9007199254744273},{"k1":9007199254744274},{"k2":null},{"k3":9007199254744276},{"k4":9007199254744277},{"k5":null},{"k6":9007199254744279},{"k7":9007199254744280},{"k8":null},{"k9":9007199254744282},{"k10":9007199254744283},{"k11":null},{"k12":9007199254744285},{"k13":9007199254744286},{"k14":null},{"k15":9007199254744288},{"k0":9007199254744289},{"k1":null},{"k2":9007199254744291},{"k3":9007199254744292},{"k4":null},{"k5":9007199254744294},{"k6":9007199254744295},{"k7":null},{"k8":9007199254744297},{"k9":9007199254744298},{"k10":null},{"k11":9007199254744300},{"k12":9007199254744301},{"k13":null},{"k14":9007199254744303},{"k15":9007199254744304},{"k0":null},{"k1":9007199254744306},{"k2":9007199254744307},{"k3":null},{"k4":9007199254744309},{"k5":9007199254744310},{"k6":null},{"k7":9007199254744312},{"k8":9007199254744313},{"k9":null},{"k10":9007199254744315},{"k11":9007199254744316},{"k12":null},{"k13":9007199254744318},{"k14":9007199254744319},{"k15":null},{"k0":9007199254744321},{"k1":9007199254744322},{"k2":null},{"k3":9007199254744324},{"k4":9007199254744325},{"k5":null},{"k6":9007199254744327},{"k7":9007199254744328},{"k8":null},{"k9":9007199254744330},{"k10":9007199254744331},{"k11":null},{"k12":9007199254744333},{"k13":9007199254744334},{"k14":null},{"k15":9007199254744336},{"k0":9007199254744337},{"k1":null},{"k2":9007199254744339},{"k3":9007199254744340},{"k4":null},{"k5":9007199254744342},{"k6":9007199254744343},{"k7":null},{"k8":9007199254744345},{"k9":9007199254744346},{"k10":null},{"k11":9007199254744348},{"k12":9007199254744349},{"k13":null},{"k14":9007199254744351},{"k15":9007199254744352},{"k0":null},{"k1":9007199254744354},{"k2":9007199254744355},{"k3":null},{"k4":9007199254744357},{"k5":9007199254744358},{"k6":null},{"k7":9007199254744360},{"k8":9007199254744361},{"k9":null},{"k10":9007199254744363},{"k11":9007199254744364},{"k12":null},{"k13":9007199254744366},{"k14":9007199254744367},{"k15":null},{"k0":9007199254744369},{"k1":9007199254744370},{"k2":null},{"k3":9007199254744372},{"k4":9007199254744373},{"k5":null},{"k6":9007199254744375},{"k7":9007199254744376},{"k8":null},{"k9":9007199254744378},{"k10":9007199254744379},{"k11":null},{"k12":9007199254744381},{"k13":9007199254744382},{"k14":null},{"k15":9007199254744384},{"k0":9007199254744385},{"k1":null},{"k2":9007199254744387},{"k3":9007199254744388},{"k4":null},{"k5":9007199254744390},{"k6":9007199254744391},{"k7":null},{"k8":9007199254744393},{"k9":9007199254744394},{"k10":null},{"k11":9007199254744396},{"k12":9007199254744397},{"k13":null},{"k14":9007199254744399},{"k15":9007199254744400},{"k0":null},{"k1":9007199254744402},{"k2":9007199254744403},{"k3":null},{"k4":9007199254744405},{"k5":9007199254744406},{"k6":null},{"k7":9007199254744408},{"k8":9007199254744409},{"k9":null},{"k10":9007199254744411},{"k11":9007199254744412},{"k12":null},{"k13":9007199254744414},{"k14":9007199254744415},{"k15":null},{"k0":9007199254744417},{"k1":9007199254744418},{"k2":null},{"k3":9007199254744420},{"k4":9007199254744421},{"k5":null},{"k6":9007199254744423},{"k7":9007199254744424},{"k8":null},{"k9":9007199254744426},{"k10":9007199254744427},{"k11":null},{"k12":9007199254744429},{"k13":9007199254744430},{"k14":null},{"k15":9007199254744432},{"k0":9007199254744433},{"k1":null},{"k2":9007199254744435},{"k3":9007199254744436},{"k4":null},{"k5":9007199254744438},{"k6":9007199254744439},{"k7":null},{"k8":9007199254744441},{"k9":9007199254744442},{"k10":null},{"k11":9007199254744444},{"k12":9007199254744445},{"k13":null},{"k14":9007199254744447},{"k15":9007199254744448},{"k0":null},{"k1":9007199254744450},{"k2":9007199254744451},{"k3":null},{"k4":9007199254744453},{"k5":9007199254744454},{"k6":null},{"k7":9007199254744456},{"k8":9007199254744457},{"k9":null},{"k10":9007199254744459},{"k11":9007199254744460},{"k12":null},{"k13":9007199254744462},{"k14":9007199254744463},{"k15":null},{"k0":9007199254744465},{"k1":9007199254744466},{"k2":null},{"k3":9007199254744468},{"k4":9007199254744469},{"k5":null},{"k6":9007199254744471},{"k7":9007199254744472},{"k8":null},{"k9":9007199254744474},{"k10":9007199254744475},{"k11":null},{"k12":9007199254744477},{"k13":9007199254744478},{"k14":null},{"k15":9007199254744480},{"k0":9007199254744481},{"k1":null},{"k2":9007199254744483},{"k3":9007199254744484},{"k4":null},{"k5":9007199254744486},{"k6":9007199254744487},{"k7":null},{"k8":9007199254744489},{"k9":9007199254744490},{"k10":null},{"k11":9007199254744492},{"k12":9007199254744493},{"k13":null},{"k14":9007199254744495},{"k15":9007199254744496},{"k0":null},{"k1":9007199254744498},{"k2":9007199254744499},{"k3":null},{"k4":9007199254744501},{"k5":9007199254744502},{"k6":null},{"k7":9007199254744504},{"k8":9007199254744505},{"k9":null},{"k10":9007199254744507},{"k11":9007199254744508},{"k12":null},{"k13":9007199254744510},{"k14":9007199254744511},{"k15":null},{"k0":9007199254744513},{"k1":9007199254744514},{"k2":null},{"k3":9007199254744516},{"k4":9007199254744517},{"k5":null},{"k6":9007199254744519},{"k7":9007199254744520},{"k8":null},{"k9":9007199254744522},{"k10":9007199254744523},{"k11":null},{"k12":9007199254744525},{"k13":9007199254744526},{"k14":null},{"k15":9007199254744528},{"k0":9007199254744529},{"k1":null},{"k2":9007199254744531},{"k3":9007199254744532},{"k4":null},{"k5":9007199254744534},{"k6":9007199254744535},{"k7":null},{"k8":9007199254744537},{"k9":9007199254744538},{"k10":null},{"k11":9007199254744540},{"k12":9007199254744541},{"k13":null},{"k14":9007199254744543},{"k15":9007199254744544},{"k0":null},{"k1":9007199254744546},{"k2":9007199254744547},{"k3":null},{"k4":9007199254744549},{"k5":9007199254744550},{"k6":null},{"k7":9007199254744552},{"k8":9007199254744553},{"k9":null},{"k10":9007199254744555},{"k11":9007199254744556},{"k12":null},{"k13":9007199254744558},{"k14":9007199254744559},{"k15":null},{"k0":9007199254744561},{"k1":9007199254744562},{"k2":null},{"k3":9007199254744564},{"k4":9007199254744565},{"k5":null},{"k6":9007199254744567},{"k7":9007199254744568},{"k8":null},{"k9":9007199254744570},{"k10":9007199254744571},{"k11":null},{"k12":9007199254744573},{"k13":9007199254744574},{"k14":null},{"k15":9007199254744576},{"k0":9007199254744577},{"k1":null},{"k2":9007199254744579},{"k3":9007199254744580},{"k4":null},{"k5":9007199254744582},{"k6":9007199254744583},{"k7":null},{"k8":9007199254744585},{"k9":9007199254744586},{"k10":null},{"k11":9007199254744588},{"k12":9007199254744589},{"k13":null},{"k14":9007199254744591},{"k15":9007199254744592},{"k0":null},{"k1":9007199254744594},{"k2":9007199254744595},{"k3":null},{"k4":9007199254744597},{"k5":9007199254744598},{"k6":null},{"k7":9007199254744600},{"k8":9007199254744601},{"k9":null},{"k10":9007199254744603},{"k11":9007199254744604},{"k12":null},{"k13":9007199254744606},{"k14":9007199254744607},{"k15":null},{"k0":9007199254744609},{"k1":9007199254744610},{"k2":null},{"k3":9007199254744612},{"k4":9007199254744613},{"k5":null},{"k6":9007199254744615},{"k7":9007199254744616},{"k8":null},{"k9":9007199254744618},{"k10":9007199254744619},{"k11":null},{"k12":9007199254744621},{"k13":9007199254744622},{"k14":null},{"k15":9007199254744624},{"k0":9007199254744625},{"k1":null},{"k2":9007199254744627},{"k3":9007199254744628},{"k4":null},{"k5":9007199254744630},{"k6":9007199254744631},{"k7":null},{"k8":9007199254744633},{"k9":9007199254744634},{"k10":null},{"k11":9007199254744636},{"k12":9007199254744637},{"k13":null},{"k14":9007199254744639},{"k15":9007199254744640},{"k0":null},{"k1":9007199254744642},{"k2":9007199254744643},{"k3":null},{"k4":9007199254744645},{"k5":9007199254744646},{"k6":null},{"k7":9007199254744648},{"k8":9007199254744649},{"k9":null},{"k10":9007199254744651},{"k11":9007199254744652},{"k12":null},{"k13":9007199254744654},{"k14":9007199254744655},{"k15":null},{"k0":9007199254744657},{"k1":9007199254744658},{"k2":null},{"k3":9007199254744660},{"k4":9007199254744661},{"k5":null},{"k6":9007199254744663},{"k7":9007199254744664},{"k8":null},{"k9":9007199254744666},{"k10":9007199254744667},{"k11":null},{"k12":9007199254744669},{"k13":9007199254744670},{"k14":null},{"k15":9007199254744672},{"k0":9007199254744673},{"k1":null},{"k2":9007199254744675},{"k3":9007199254744676},{"k4":null},{"k5":9007199254744678},{"k6":9007199254744679},{"k7":null},{"k8":9007199254744681},{"k9":9007199254744682},{"k10":null},{"k11":9007199254744684},{"k12":9007199254744685},{"k13":null},{"k14":9007199254744687},{"k15":9007199254744688},{"k0":null},{"k1":9007199254744690},{"k2":9007199254744691},{"k3":null},{"k4":9007199254744693},{"k5":9007199254744694},{"k6":null},{"k7":9007199254744696},{"k8":9007199254744697},{"k9":null},{"k10":9007199254744699},{"k11":9007199254744700},{"k12":null},{"k13":9007199254744702},{"k14":9007199254744703},{"k15":null},{"k0":9007199254744705},{"k1":9007199254744706},{"k2":null},{"k3":9007199254744708},{"k4":9007199254744709},{"k5":null},{"k6":9007199254744711},{"k7":9007199254744712},{"k8":null},{"k9":9007199254744714},{"k10":9007199254744715},{"k11":null},{"k12":9007199254744717},{"k13":9007199254744718},{"k14":null},{"k15":9007199254744720},{"k0":9007199254744721},{"k1":null},{"k2":9007199254744723},{"k3":9007199254744724},{"k4":null},{"k5":9007199254744726},{"k6":9007199254744727},{"k7":null},{"k8":9007199254744729},{"k9":9007199254744730},{"k10":null},{"k11":9007199254744732},{"k12":9007199254744733},{"k13":null},{"k14":9007199254744735},{"k15":9007199254744736},{"k0":null},{"k1":9007199254744738},{"k2":9007199254744739},{"k3":null},{"k4":9007199254744741},{"k5":9007199254744742},{"k6":null},{"k7":9007199254744744},{"k8":9007199254744745},{"k9":null},{"k10":9007199254744747},{"k11":9007199254744748},{"k12":null},{"k13":9007199254744750},{"k14":9007199254744751},{"k15":null},{"k0":9007199254744753},{"k1":9007199254744754},{"k2":null},{"k3":9007199254744756},{"k4":9007199254744757},{"k5":null},{"k6":9007199254744759},{"k7":9007199254744760},{"k8":null},{"k9":9007199254744762},{"k10":9007199254744763},{"k11":null},{"k12":9007199254744765},{"k13":9007199254744766},{"k14":null},{"k15":9007199254744768},{"k0":9007199254744769},{"k1":null},{"k2":9007199254744771},{"k3":9007199254744772},{"k4":null},{"k5":9007199254744774},{"k6":9007199254744775},{"k7":null},{"k8":9007199254744777},{"k9":9007199254744778},{"k10":null},{"k11":9007199254744780},{"k12":9007199254744781},{"k13":null},{"k14":9007199254744783},{"k15":9007199254744784},{"k0":null},{"k1":9007199254744786},{"k2":9007199254744787},{"k3":null},{"k4":9007199254744789},{"k5":9007199254744790},{"k6":null},{"k7":9007199254744792},{"k8":9007199254744793},{"k9":null},{"k10":9007199254744795},{"k11":9007199254744796},{"k12":null},{"k13":9007199254744798},{"k14":9007199254744799},{"k15":null},{"k0":9007199254744801},{"k1":9007199254744802},{"k2":null},{"k3":9007199254744804},{"k4":9007199254744805},{"k5":null},{"k6":9007199254744807},{"k7":9007199254744808},{"k8":null},{"k9":9007199254744810},{"k10":9007199254744811},{"k11":null},{"k12":9007199254744813},{"k13":9007199254744814},{"k14":null},{"k15":9007199254744816},{"k0":9007199254744817},{"k1":null},{"k2":9007199254744819},{"k3":9007199254744820},{"k4":null},{"k5":9007199254744822},{"k6":9007199254744823},{"k7":null},{"k8":9007199254744825},{"k9":9007199254744826},{"k10":null},{"k11":9007199254744828},{"k12":9007199254744829},{"k13":null},{"k14":9007199254744831},{"k15":9007199254744832},{"k0":null},{"k1":9007199254744834},{"k2":9007199254744835},{"k3":null},{"k4":9007199254744837},{"k5":9007199254744838},{"k6":null},{"k7":9007199254744840},{"k8":9007199254744841},{"k9":null},{"k10":9007199254744843},{"k11":9007199254744844},{"k12":null},{"k13":9007199254744846},{"k14":9007199254744847},{"k15":null},{"k0":9007199254744849},{"k1":9007199254744850},{"k2":null},{"k3":9007199254744852},{"k4":9007199254744853},{"k5":null},{"k6":9007199254744855},{"k7":9007199254744856},{"k8":null},{"k9":9007199254744858},{"k10":9007199254744859},{"k11":null},{"k12":9007199254744861},{"k13":9007199254744862},{"k14":null},{"k15":9007199254744864},{"k0":9007199254744865},{"k1":null},{"k2":9007199254744867},{"k3":9007199254744868},{"k4":null},{"k5":9007199254744870},{"k6":9007199254744871},{"k7":null},{"k8":9007199254744873},{"k9":9007199254744874},{"k10":null},{"k11":9007199254744876},{"k12":9007199254744877},{"k13":null},{"k14":9007199254744879},{"k15":9007199254744880},{"k0":null},{"k1":9007199254744882},{"k2":9007199254744883},{"k3":null},{"k4":9007199254744885},{"k5":9007199254744886},{"k6":null},{"k7":9007199254744888},{"k8":9007199254744889},{"k9":null},{"k10":9007199254744891},{"k11":9007199254744892},{"k12":null},{"k13":9007199254744894},{"k14":9007199254744895},{"k15":null},{"k0":9007199254744897},{"k1":9007199254744898},{"k2":null},{"k3":9007199254744900},{"k4":9007199254744901},{"k5":null},{"k6":9007199254744903},{"k7":9007199254744904},{"k8":null},{"k9":9007199254744906},{"k10":9007199254744907},{"k11":null},{"k12":9007199254744909},{"k13":9007199254744910},{"k14":null},{"k15":9007199254744912},{"k0":9007199254744913},{"k1":null},{"k2":9007199254744915},{"k3":9007199254744916},{"k4":null},{"k5":9007199254744918},{"k6":9007199254744919},{"k7":null},{"k8":9007199254744921},{"k9":9007199254744922},{"k10":null},{"k11":9007199254744924},{"k12":9007199254744925},{"k13":null},{"k14":9007199254744927},{"k15":9007199254744928},{"k0":null},{"k1":9007199254744930},{"k2":9007199254744931},{"k3":null},{"k4":9007199254744933},{"k5":9007199254744934},{"k6":null},{"k7":9007199254744936},{"k8":9007199254744937},{"k9":null},{"k10":9007199254744939},{"k11":9007199254744940},{"k12":null},{"k13":9007199254744942},{"k14":9007199254744943},{"k15":null},{"k0":9007199254744945},{"k1":9007199254744946},{"k2":null},{"k3":9007199254744948},{"k4":9007199254744949},{"k5":null},{"k6":9007199254744951},{"k7":9007199254744952},{"k8":null},{"k9":9007199254744954},{"k10":9007199254744955},{"k11":null},{"k12":9007199254744957},{"k13":9007199254744958},{"k14":null},{"k15":9007199254744960},{"k0":9007199254744961},{"k1":null},{"k2":9007199254744963},{"k3":9007199254744964},{"k4":null},{"k5":9007199254744966},{"k6":9007199254744967},{"k7":null},{"k8":9007199254744969},{"k9":9007199254744970},{"k10":null},{"k11":9007199254744972},{"k12":9007199254744973},{"k13":null},{"k14":9007199254744975},{"k15":9007199254744976},{"k0":null},{"k1":9007199254744978},{"k2":9007199254744979},{"k3":null},{"k4":9007199254744981},{"k5":9007199254744982},{"k6":null},{"k7":9007199254744984},{"k8":9007199254744985},{"k9":null},{"k10":9007199254744987},{"k11":9007199254744988},{"k12":null},{"k13":9007199254744990},{"k14":9007199254744991},{"k15":null},{"k0":9007199254744993},{"k1":9007199254744994},{"k2":null},{"k3":9007199254744996},{"k4":9007199254744997},{"k5":null},{"k6":9007199254744999},{"k7":9007199254745000},{"k8":null},{"k9":9007199254745002},{"k10":9007199254745003},{"k11":null},{"k12":9007199254745005},{"k13":9007199254745006},{"k14":null},{"k15":9007199254745008},{"k0":9007199254745009},{"k1":null},{"k2":9007199254745011},{"k3":9007199254745012},{"k4":null},{"k5":9007199254745014},{"k6":9007199254745015},{"k7":null},{"k8":9007199254745017},{"k9":9007199254745018},{"k10":null},{"k11":9007199254745020},{"k12":9007199254745021},{"k13":null},{"k14":9007199254745023},{"k15":9007199254745024},{"k0":null},{"k1":9007199254745026},{"k2":9007199254745027},{"k3":null},{"k4":9007199254745029},{"k5":9007199254745030},{"k6":null},{"k7":9007199254745032},{"k8":9007199254745033},{"k9":null},{"k10":9007199254745035},{"k11":9007199254745036},{"k12":null},{"k13":9007199254745038},{"k14":9007199254745039},{"k15":null},{"k0":9007199254745041},{"k1":9007199254745042},{"k2":null},{"k3":9007199254745044},{"k4":9007199254745045},{"k5":null},{"k6":9007199254745047},{"k7":9007199254745048},{"k8":null},{"k9":9007199254745050},{"k10":9007199254745051},{"k11":null},{"k12":9007199254745053},{"k13":9007199254745054},{"k14":null},{"k15":9007199254745056},{"k0":9007199254745057},{"k1":null},{"k2":9007199254745059},{"k3":9007199254745060},{"k4":null},{"k5":9007199254745062},{"k6":9007199254745063},{"k7":null},{"k8":9007199254745065},{"k9":9007199254745066},{"k10":null},{"k11":9007199254745068},{"k12":9007199254745069},{"k13":null},{"k14":9007199254745071},{"k15":9007199254745072},{"k0":null},{"k1":9007199254745074},{"k2":9007199254745075},{"k3":null},{"k4":9007199254745077},{"k5":9007199254745078},{"k6":null},{"k7":9007199254745080},{"k8":9007199254745081},{"k9":null},{"k10":9007199254745083},{"k11":9007199254745084},{"k12":null},{"k13":9007199254745086},{"k14":9007199254745087},{"k15":null},{"k0":9007199254745089},{"k1":9007199254745090},{"k2":null},{"k3":9007199254745092},{"k4":9007199254745093},{"k5":null},{"k6":9007199254745095},{"k7":9007199254745096},{"k8":null},{"k9":9007199254745098},{"k10":9007199254745099},{"k11":null},{"k12":9007199254745101},{"k13":9007199254745102},{"k14":null},{"k15":9007199254745104},{"k0":9007199254745105},{"k1":null},{"k2":9007199254745107},{"k3":9007199254745108},{"k4":null},{"k5":9007199254745110},{"k6":9007199254745111},{"k7":null},{"k8":9007199254745113},{"k9":9007199254745114},{"k10":null},{"k11":9007199254745116},{"k12":9007199254745117},{"k13":null},{"k14":9007199254745119},{"k15":9007199254745120},{"k0":null},{"k1":9007199254745122},{"k2":9007199254745123},{"k3":null},{"k4":9007199254745125},{"k5":9007199254745126},{"k6":null},{"k7":9007199254745128},{"k8":9007199254745129},{"k9":null},{"k10":9007199254745131},{"k11":9007199254745132},{"k12":null},{"k13":9007199254745134},{"k14":9007199254745135},{"k15":null},{"k0":9007199254745137},{"k1":9007199254745138},{"k2":null},{"k3":9007199254745140},{"k4":9007199254745141},{"k5":null},{"k6":9007199254745143},{"k7":9007199254745144},{"k8":null},{"k9":9007199254745146},{"k10":9007199254745147},{"k11":null},{"k12":9007199254745149},{"k13":9007199254745150},{"k14":null},{"k15":9007199254745152},{"k0":9007199254745153},{"k1":null},{"k2":9007199254745155},{"k3":9007199254745156},{"k4":null},{"k5":9007199254745158},{"k6":9007199254745159},{"k7":null},{"k8":9007199254745161},{"k9":9007199254745162},{"k10":null},{"k11":9007199254745164},{"k12":9007199254745165},{"k13":null},{"k14":9007199254745167},{"k15":9007199254745168},{"k0":null},{"k1":9007199254745170},{"k2":9007199254745171},{"k3":null},{"k4":9007199254745173},{"k5":9007199254745174},{"k6":null},{"k7":9007199254745176},{"k8":9007199254745177},{"k9":null},{"k10":9007199254745179},{"k11":9007199254745180},{"k12":null},{"k13":9007199254745182},{"k14":9007199254745183},{"k15":null},{"k0":9007199254745185},{"k1":9007199254745186},{"k2":null},{"k3":9007199254745188},{"k4":9007199254745189},{"k5":null},{"k6":9007199254745191},{"k7":9007199254745192},{"k8":null},{"k9":9007199254745194},{"k10":9007199254745195},{"k11":null},{"k12":9007199254745197},{"k13":9007199254745198},{"k14":null},{"k15":9007199254745200},{"k0":9007199254745201},{"k1":null},{"k2":9007199254745203},{"k3":9007199254745204},{"k4":null},{"k5":9007199254745206},{"k6":9007199254745207},{"k7":null},{"k8":9007199254745209},{"k9":9007199254745210},{"k10":null},{"k11":9007199254745212},{"k12":9007199254745213},{"k13":null},{"k14":9007199254745215},{"k15":9007199254745216},{"k0":null},{"k1":9007199254745218},{"k2":9007199254745219},{"k3":null},{"k4":9007199254745221},{"k5":9007199254745222},{"k6":null},{"k7":9007199254745224},{"k8":9007199254745225},{"k9":null},{"k10":9007199254745227},{"k11":9007199254745228},{"k12":null},{"k13":9007199254745230},{"k14":9007199254745231},{"k15":null},{"k0":9007199254745233},{"k1":9007199254745234},{"k2":null},{"k3":9007199254745236},{"k4":9007199254745237},{"k5":null},{"k6":9007199254745239},{"k7":9007199254745240},{"k8":null},{"k9":9007199254745242},{"k10":9007199254745243},{"k11":null},{"k12":9007199254745245},{"k13":9007199254745246},{"k14":null},{"k15":9007199254745248},{"k0":9007199254745249},{"k1":null},{"k2":9007199254745251},{"k3":9007199254745252},{"k4":null},{"k5":9007199254745254},{"k6":9007199254745255},{"k7":null},{"k8":9007199254745257},{"k9":9007199254745258},{"k10":null},{"k11":9007199254745260},{"k12":9007199254745261},{"k13":null},{"k14":9007199254745263},{"k15":9007199254745264},{"k0":null},{"k1":9007199254745266},{"k2":9007199254745267},{"k3":null},{"k4":9007199254745269},{"k5":9007199254745270},{"k6":null},{"k7":9007199254745272},{"k8":9007199254745273},{"k9":null},{"k10":9007199254745275},{"k11":9007199254745276},{"k12":null},{"k13":9007199254745278},{"k14":9007199254745279},{"k15":null},{"k0":9007199254745281},{"k1":9007199254745282},{"k2":null},{"k3":9007199254745284},{"k4":9007199254745285},{"k5":null},{"k6":9007199254745287},{"k7":9007199254745288},{"k8":null},{"k9":9007199254745290},{"k10":9007199254745291},{"k11":null},{"k12":9007199254745293},{"k13":9007199254745294},{"k14":null},{"k15":9007199254745296},{"k0":9007199254745297},{"k1":null},{"k2":9007199254745299},{"k3":9007199254745300},{"k4":null},{"k5":9007199254745302},{"k6":9007199254745303},{"k7":null},{"k8":9007199254745305},{"k9":9007199254745306},{"k10":null},{"k11":9007199254745308},{"k12":9007199254745309},{"k13":null},{"k14":9007199254745311},{"k15":9007199254745312},{"k0":null},{"k1":9007199254745314},{"k2":9007199254745315},{"k3":null},{"k4":9007199254745317},{"k5":9007199254745318},{"k6":null},{"k7":9007199254745320},{"k8":9007199254745321},{"k9":null},{"k10":9007199254745323},{"k11":9007199254745324},{"k12":null},{"k13":9007199254745326},{"k14":9007199254745327},{"k15":null},{"k0":9007199254745329},{"k1":9007199254745330},{"k2":null},{"k3":9007199254745332},{"k4":9007199254745333},{"k5":null},{"k6":9007199254745335},{"k7":9007199254745336},{"k8":null},{"k9":9007199254745338},{"k10":9007199254745339},{"k11":null},{"k12":9007199254745341},{"k13":9007199254745342},{"k14":null},{"k15":9007199254745344},{"k0":9007199254745345},{"k1":null},{"k2":9007199254745347},{"k3":9007199254745348},{"k4":null},{"k5":9007199254745350},{"k6":9007199254745351},{"k7":null},{"k8":9007199254745353},{"k9":9007199254745354},{"k10":null},{"k11":9007199254745356},{"k12":9007199254745357},{"k13":null},{"k14":9007199254745359},{"k15":9007199254745360},{"k0":null},{"k1":9007199254745362},{"k2":9007199254745363},{"k3":null},{"k4":9007199254745365},{"k5":9007199254745366},{"k6":null},{"k7":9007199254745368},{"k8":9007199254745369},{"k9":null},{"k10":9007199254745371},{"k11":9007199254745372},{"k12":null},{"k13":9007199254745374},{"k14":9007199254745375},{"k15":null},{"k0":9007199254745377},{"k1":9007199254745378},{"k2":null},{"k3":9007199254745380},{"k4":9007199254745381},{"k5":null},{"k6":9007199254745383},{"k7":9007199254745384},{"k8":null},{"k9":9007199254745386},{"k10":9007199254745387},{"k11":null},{"k12":9007199254745389},{"k13":9007199254745390},{"k14":null},{"k15":9007199254745392},{"k0":9007199254745393},{"k1":null},{"k2":9007199254745395},{"k3":9007199254745396},{"k4":null},{"k5":9007199254745398},{"k6":9007199254745399},{"k7":null},{"k8":9007199254745401},{"k9":9007199254745402},{"k10":null},{"k11":9007199254745404},{"k12":9007199254745405},{"k13":null},{"k14":9007199254745407},{"k15":9007199254745408},{"k0":null},{"k1":9007199254745410},{"k2":9007199254745411},{"k3":null},{"k4":9007199254745413},{"k5":9007199254745414},{"k6":null},{"k7":9007199254745416},{"k8":9007199254745417},{"k9":null},{"k10":9007199254745419},{"k11":9007199254745420},{"k12":null},{"k13":9007199254745422},{"k14":9007199254745423},{"k15":null},{"k0":9007199254745425},{"k1":9007199254745426},{"k2":null},{"k3":9007199254745428},{"k4":9007199254745429},{"k5":null},{"k6":9007199254745431},{"k7":9007199254745432},{"k8":null},{"k9":9007199254745434},{"k10":9007199254745435},{"k11":null},{"k12":9007199254745437},{"k13":9007199254745438},{"k14":null},{"k15":9007199254745440},{"k0":9007199254745441},{"k1":null},{"k2":9007199254745443},{"k3":9007199254745444},{"k4":null},{"k5":9007199254745446},{"k6":9007199254745447},{"k7":null},{"k8":9007199254745449},{"k9":9007199254745450},{"k10":null},{"k11":9007199254745452},{"k12":9007199254745453},{"k13":null},{"k14":9007199254745455},{"k15":9007199254745456},{"k0":null},{"k1":9007199254745458},{"k2":9007199254745459},{"k3":null},{"k4":9007199254745461},{"k5":9007199254745462},{"k6":null},{"k7":9007199254745464},{"k8":9007199254745465},{"k9":null},{"k10":9007199254745467},{"k11":9007199254745468},{"k12":null},{"k13":9007199254745470},{"k14":9007199254745471},{"k15":null},{"k0":9007199254745473},{"k1":9007199254745474},{"k2":null},{"k3":9007199254745476},{"k4":9007199254745477},{"k5":null},{"k6":9007199254745479},{"k7":9007199254745480},{"k8":null},{"k9":9007199254745482},{"k10":9007199254745483},{"k11":null},{"k12":9007199254745485},{"k13":9007199254745486},{"k14":null},{"k15":9007199254745488},{"k0":9007199254745489},{"k1":null},{"k2":9007199254745491},{"k3":9007199254745492},{"k4":null},{"k5":9007199254745494},{"k6":9007199254745495},{"k7":null},{"k8":9007199254745497},{"k9":9007199254745498},{"k10":null},{"k11":9007199254745500},{"k12":9007199254745501},{"k13":null},{"k14":9007199254745503},{"k15":9007199254745504},{"k0":null},{"k1":9007199254745506},{"k2":9007199254745507},{"k3":null},{"k4":9007199254745509},{"k5":9007199254745510},{"k6":null},{"k7":9007199254745512},{"k8":9007199254745513},{"k9":null},{"k10":9007199254745515},{"k11":9007199254745516},{"k12":null},{"k13":9007199254745518},{"k14":9007199254745519},{"k15":null},{"k0":9007199254745521},{"k1":9007199254745522},{"k2":null},{"k3":9007199254745524},{"k4":9007199254745525},{"k5":null},{"k6":9007199254745527},{"k7":9007199254745528},{"k8":null},{"k9":9007199254745530},{"k10":9007199254745531},{"k11":null},{"k12":9007199254745533},{"k13":9007199254745534},{"k14":null},{"k15":9007199254745536},{"k0":9007199254745537},{"k1":null},{"k2":9007199254745539},{"k3":9007199254745540},{"k4":null},{"k5":9007199254745542},{"k6":9007199254745543},{"k7":null},{"k8":9007199254745545},{"k9":9007199254745546},{"k10":null},{"k11":9007199254745548},{"k12":9007199254745549},{"k13":null},{"k14":9007199254745551},{"k15":9007199254745552},{"k0":null},{"k1":9007199254745554},{"k2":9007199254745555},{"k3":null},{"k4":9007199254745557},{"k5":9007199254745558},{"k6":null},{"k7":9007199254745560},{"k8":9007199254745561},{"k9":null},{"k10":9007199254745563},{"k11":9007199254745564},{"k12":null},{"k13":9007199254745566},{"k14":9007199254745567},{"k15":null},{"k0":9007199254745569},{"k1":9007199254745570},{"k2":null},{"k3":9007199254745572},{"k4":9007199254745573},{"k5":null},{"k6":9007199254745575},{"k7":9007199254745576},{"k8":null},{"k9":9007199254745578},{"k10":9007199254745579},{"k11":null},{"k12":9007199254745581},{"k13":9007199254745582},{"k14":null},{"k15":9007199254745584},{"k0":9007199254745585},{"k1":null},{"k2":9007199254745587},{"k3":9007199254745588},{"k4":null},{"k5":9007199254745590},{"k6":9007199254745591},{"k7":null},{"k8":9007199254745593},{"k9":9007199254745594},{"k10":null},{"k11":9007199254745596},{"k12":9007199254745597},{"k13":null},{"k14":9007199254745599},{"k15":9007199254745600},{"k0":null},{"k1":9007199254745602},{"k2":9007199254745603},{"k3":null},{"k4":9007199254745605},{"k5":9007199254745606},{"k6":null},{"k7":9007199254745608},{"k8":9007199254745609},{"k9":null},{"k10":9007199254745611},{"k11":9007199254745612},{"k12":null},{"k13":9007199254745614},{"k14":9007199254745615},{"k15":null},{"k0":9007199254745617},{"k1":9007199254745618},{"k2":null},{"k3":9007199254745620},{"k4":9007199254745621},{"k5":null},{"k6":9007199254745623},{"k7":9007199254745624},{"k8":null},{"k9":9007199254745626},{"k10":9007199254745627},{"k11":null},{"k12":9007199254745629},{"k13":9007199254745630},{"k14":null},{"k15":9007199254745632},{"k0":9007199254745633},{"k1":null},{"k2":9007199254745635},{"k3":9007199254745636},{"k4":null},{"k5":9007199254745638},{"k6":9007199254745639},{"k7":null},{"k8":9007199254745641},{"k9":9007199254745642},{"k10":null},{"k11":9007199254745644},{"k12":9007199254745645},{"k13":null},{"k14":9007199254745647},{"k15":9007199254745648},{"k0":null},{"k1":9007199254745650},{"k2":9007199254745651},{"k3":null},{"k4":9007199254745653},{"k5":9007199254745654},{"k6":null},{"k7":9007199254745656},{"k8":9007199254745657},{"k9":null},{"k10":9007199254745659},{"k11":9007199254745660},{"k12":null},{"k13":9007199254745662},{"k14":9007199254745663},{"k15":null},{"k0":9007199254745665},{"k1":9007199254745666},{"k2":null},{"k3":9007199254745668},{"k4":9007199254745669},{"k5":null},{"k6":9007199254745671},{"k7":9007199254745672},{"k8":null},{"k9":9007199254745674},{"k10":9007199254745675},{"k11":null},{"k12":9007199254745677},{"k13":9007199254745678},{"k14":null},{"k15":9007199254745680},{"k0":9007199254745681},{"k1":null},{"k2":9007199254745683},{"k3":9007199254745684},{"k4":null},{"k5":9007199254745686},{"k6":9007199254745687},{"k7":null},{"k8":9007199254745689},{"k9":9007199254745690},{"k10":null},{"k11":9007199254745692},{"k12":9007199254745693},{"k13":null},{"k14":9007199254745695},{"k15":9007199254745696},{"k0":null},{"k1":9007199254745698},{"k2":9007199254745699},{"k3":null},{"k4":9007199254745701},{"k5":9007199254745702},{"k6":null},{"k7":9007199254745704},{"k8":9007199254745705},{"k9":null},{"k10":9007199254745707},{"k11":9007199254745708},{"k12":null},{"k13":9007199254745710},{"k14":9007199254745711},{"k15":null},{"k0":9007199254745713},{"k1":9007199254745714},{"k2":null},{"k3":9007199254745716},{"k4":9007199254745717},{"k5":null},{"k6":9007199254745719},{"k7":9007199254745720},{"k8":null},{"k9":9007199254745722},{"k10":9007199254745723},{"k11":null},{"k12":9007199254745725},{"k13":9007199254745726},{"k14":null},{"k15":9007199254745728},{"k0":9007199254745729},{"k1":null},{"k2":9007199254745731},{"k3":9007199254745732},{"k4":null},{"k5":9007199254745734},{"k6":9007199254745735},{"k7":null},{"k8":9007199254745737},{"k9":9007199254745738},{"k10":null},{"k11":9007199254745740},{"k12":9007199254745741},{"k13":null},{"k14":9007199254745743},{"k15":9007199254745744},{"k0":null},{"k1":9007199254745746},{"k2":9007199254745747},{"k3":null},{"k4":9007199254745749},{"k5":9007199254745750},{"k6":null},{"k7":9007199254745752},{"k8":9007199254745753},{"k9":null},{"k10":9007199254745755},{"k11":9007199254745756},{"k12":null},{"k13":9007199254745758},{"k14":9007199254745759},{"k15":null},{"k0":9007199254745761},{"k1":9007199254745762},{"k2":null},{"k3":9007199254745764},{"k4":9007199254745765},{"k5":null},{"k6":9007199254745767},{"k7":9007199254745768},{"k8":null},{"k9":9007199254745770},{"k10":9007199254745771},{"k11":null},{"k12":9007199254745773},{"k13":9007199254745774},{"k14":null},{"k15":9007199254745776},{"k0":9007199254745777},{"k1":null},{"k2":9007199254745779},{"k3":9007199254745780},{"k4":null},{"k5":9007199254745782},{"k6":9007199254745783},{"k7":null},{"k8":9007199254745785},{"k9":9007199254745786},{"k10":null},{"k11":9007199254745788},{"k12":9007199254745789},{"k13":null},{"k14":9007199254745791},{"k15":9007199254745792},{"k0":null},{"k1":9007199254745794},{"k2":9007199254745795},{"k3":null},{"k4":9007199254745797},{"k5":9007199254745798},{"k6":null},{"k7":9007199254745800},{"k8":9007199254745801},{"k9":null},{"k10":9007199254745803},{"k11":9007199254745804},{"k12":null},{"k13":9007199254745806},{"k14":9007199254745807},{"k15":null},{"k0":9007199254745809},{"k1":9007199254745810},{"k2":null},{"k3":9007199254745812},{"k4":9007199254745813},{"k5":null},{"k6":9007199254745815},{"k7":9007199254745816},{"k8":null},{"k9":9007199254745818},{"k10":9007199254745819},{"k11":null},{"k12":9007199254745821},{"k13":9007199254745822},{"k14":null},{"k15":9007199254745824},{"k0":9007199254745825},{"k1":null},{"k2":9007199254745827},{"k3":9007199254745828},{"k4":null},{"k5":9007199254745830},{"k6":9007199254745831},{"k7":null},{"k8":9007199254745833},{"k9":9007199254745834},{"k10":null},{"k11":9007199254745836},{"k12":9007199254745837},{"k13":null},{"k14":9007199254745839},{"k15":9007199254745840},{"k0":null},{"k1":9007199254745842},{"k2":9007199254745843},{"k3":null},{"k4":9007199254745845},{"k5":9007199254745846},{"k6":null},{"k7":9007199254745848},{"k8":9007199254745849},{"k9":null},{"k10":9007199254745851},{"k11":9007199254745852},{"k12":null},{"k13":9007199254745854},{"k14":9007199254745855},{"k15":null},{"k0":9007199254745857},{"k1":9007199254745858},{"k2":null},{"k3":9007199254745860},{"k4":9007199254745861},{"k5":null},{"k6":9007199254745863},{"k7":9007199254745864},{"k8":null},{"k9":9007199254745866},{"k10":9007199254745867},{"k11":null},{"k12":9007199254745869},{"k13":9007199254745870},{"k14":null},{"k15":9007199254745872},{"k0":9007199254745873},{"k1":null},{"k2":9007199254745875},{"k3":9007199254745876},{"k4":null},{"k5":9007199254745878},{"k6":9007199254745879},{"k7":null},{"k8":9007199254745881},{"k9":9007199254745882},{"k10":null},{"k11":9007199254745884},{"k12":9007199254745885},{"k13":null},{"k14":9007199254745887},{"k15":9007199254745888},{"k0":null},{"k1":9007199254745890},{"k2":9007199254745891},{"k3":null},{"k4":9007199254745893},{"k5":9007199254745894},{"k6":null},{"k7":9007199254745896},{"k8":9007199254745897},{"k9":null},{"k10":9007199254745899},{"k11":9007199254745900},{"k12":null},{"k13":9007199254745902},{"k14":9007199254745903},{"k15":null},{"k0":9007199254745905},{"k1":9007199254745906},{"k2":null},{"k3":9007199254745908},{"k4":9007199254745909},{"k5":null},{"k6":9007199254745911},{"k7":9007199254745912},{"k8":null},{"k9":9007199254745914},{"k10":9007199254745915},{"k11":null},{"k12":9007199254745917},{"k13":9007199254745918},{"k14":null},{"k15":9007199254745920},{"k0":9007199254745921},{"k1":null},{"k2":9007199254745923},{"k3":9007199254745924},{"k4":null},{"k5":9007199254745926},{"k6":9007199254745927},{"k7":null},{"k8":9007199254745929},{"k9":9007199254745930},{"k10":null},{"k11":9007199254745932},{"k12":9007199254745933},{"k13":null},{"k14":9007199254745935},{"k15":9007199254745936},{"k0":null},{"k1":9007199254745938},{"k2":9007199254745939},{"k3":null},{"k4":9007199254745941},{"k5":9007199254745942},{"k6":null},{"k7":9007199254745944},{"k8":9007199254745945},{"k9":null},{"k10":9007199254745947},{"k11":9007199254745948},{"k12":null},{"k13":9007199254745950},{"k14":9007199254745951},{"k15":null},{"k0":9007199254745953},{"k1":9007199254745954},{"k2":null},{"k3":9007199254745956},{"k4":9007199254745957},{"k5":null},{"k6":9007199254745959},{"k7":9007199254745960},{"k8":null},{"k9":9007199254745962},{"k10":9007199254745963},{"k11":null},{"k12":9007199254745965},{"k13":9007199254745966},{"k14":null},{"k15":9007199254745968},{"k0":9007199254745969},{"k1":null},{"k2":9007199254745971},{"k3":9007199254745972},{"k4":null},{"k5":9007199254745974},{"k6":9007199254745975},{"k7":null},{"k8":9007199254745977},{"k9":9007199254745978},{"k10":null},{"k11":9007199254745980},{"k12":9007199254745981},{"k13":null},{"k14":9007199254745983},{"k15":9007199254745984},{"k0":null},{"k1":9007199254745986},{"k2":9007199254745987},{"k3":null},{"k4":9007199254745989},{"k5":9007199254745990},{"k6":null},{"k7":9007199254745992},{"k8":9007199254745993},{"k9":null},{"k10":9007199254745995},{"k11":9007199254745996},{"k12":null},{"k13":9007199254745998},{"k14":9007199254745999},{"k15":null},{"k0":9007199254746001},{"k1":9007199254746002},{"k2":null},{"k3":9007199254746004},{"k4":9007199254746005},{"k5":null},{"k6":9007199254746007},{"k7":9007199254746008},{"k8":null},{"k9":9007199254746010},{"k10":9007199254746011},{"k11":null},{"k12":9007199254746013},{"k13":9007199254746014},{"k14":null},{"k15":9007199254746016},{"k0":9007199254746017},{"k1":null},{"k2":9007199254746019},{"k3":9007199254746020},{"k4":null},{"k5":9007199254746022},{"k6":9007199254746023},{"k7":null},{"k8":9007199254746025},{"k9":9007199254746026},{"k10":null},{"k11":9007199254746028},{"k12":9007199254746029},{"k13":null},{"k14":9007199254746031},{"k15":9007199254746032},{"k0":null},{"k1":9007199254746034},{"k2":9007199254746035},{"k3":null},{"k4":9007199254746037},{"k5":9007199254746038},{"k6":null},{"k7":9007199254746040},{"k8":9007199254746041},{"k9":null},{"k10":9007199254746043},{"k11":9007199254746044},{"k12":null},{"k13":9007199254746046},{"k14":9007199254746047},{"k15":null},{"k0":9007199254746049},{"k1":9007199254746050},{"k2":null},{"k3":9007199254746052},{"k4":9007199254746053},{"k5":null},{"k6":9007199254746055},{"k7":9007199254746056},{"k8":null},{"k9":9007199254746058},{"k10":9007199254746059},{"k11":null},{"k12":9007199254746061},{"k13":9007199254746062},{"k14":null},{"k15":9007199254746064},{"k0":9007199254746065},{"k1":null},{"k2":9007199254746067},{"k3":9007199254746068},{"k4":null},{"k5":9007199254746070},{"k6":9007199254746071},{"k7":null},{"k8":9007199254746073},{"k9":9007199254746074},{"k10":null},{"k11":9007199254746076},{"k12":9007199254746077},{"k13":null},{"k14":9007199254746079},{"k15":9007199254746080},{"k0":null},{"k1":9007199254746082},{"k2":9007199254746083},{"k3":null},{"k4":9007199254746085},{"k5":9007199254746086},{"k6":null},{"k7":9007199254746088},{"k8":9007199254746089},{"k9":null},{"k10":9007199254746091},{"k11":9007199254746092},{"k12":null},{"k13":9007199254746094},{"k14":9007199254746095},{"k15":null},{"k0":9007199254746097},{"k1":9007199254746098},{"k2":null},{"k3":9007199254746100},{"k4":9007199254746101},{"k5":null},{"k6":9007199254746103},{"k7":9007199254746104},{"k8":null},{"k9":9007199254746106},{"k10":9007199254746107},{"k11":null},{"k12":9007199254746109},{"k13":9007199254746110},{"k14":null},{"k15":9007199254746112},{"k0":9007199254746113},{"k1":null},{"k2":9007199254746115},{"k3":9007199254746116},{"k4":null},{"k5":9007199254746118},{"k6":9007199254746119},{"k7":null},{"k8":9007199254746121},{"k9":9007199254746122},{"k10":null},{"k11":9007199254746124},{"k12":9007199254746125},{"k13":null},{"k14":9007199254746127},{"k15":9007199254746128},{"k0":null},{"k1":9007199254746130},{"k2":9007199254746131},{"k3":null},{"k4":9007199254746133},{"k5":9007199254746134},{"k6":null},{"k7":9007199254746136},{"k8":9007199254746137},{"k9":null},{"k10":9007199254746139},{"k11":9007199254746140},{"k12":null},{"k13":9007199254746142},{"k14":9007199254746143},{"k15":null},{"k0":9007199254746145},{"k1":9007199254746146},{"k2":null},{"k3":9007199254746148},{"k4":9007199254746149},{"k5":null},{"k6":9007199254746151},{"k7":9007199254746152},{"k8":null},{"k9":9007199254746154},{"k10":9007199254746155},{"k11":null},{"k12":9007199254746157},{"k13":9007199254746158},{"k14":null},{"k15":9007199254746160},{"k0":9007199254746161},{"k1":null},{"k2":9007199254746163},{"k3":9007199254746164},{"k4":null},{"k5":9007199254746166},{"k6":9007199254746167},{"k7":null},{"k8":9007199254746169},{"k9":9007199254746170},{"k10":null},{"k11":9007199254746172},{"k12":9007199254746173},{"k13":null},{"k14":9007199254746175},{"k15":9007199254746176},{"k0":null},{"k1":9007199254746178},{"k2":9007199254746179},{"k3":null},{"k4":9007199254746181},{"k5":9007199254746182},{"k6":null},{"k7":9007199254746184},{"k8":9007199254746185},{"k9":null},{"k10":9007199254746187},{"k11":9007199254746188},{"k12":null},{"k13":9007199254746190},{"k14":9007199254746191},{"k15":null},{"k0":9007199254746193},{"k1":9007199254746194},{"k2":null},{"k3":9007199254746196},{"k4":9007199254746197},{"k5":null},{"k6":9007199254746199},{"k7":9007199254746200},{"k8":null},{"k9":9007199254746202},{"k10":9007199254746203},{"k11":null},{"k12":9007199254746205},{"k13":9007199254746206},{"k14":null},{"k15":9007199254746208},{"k0":9007199254746209},{"k1":null},{"k2":9007199254746211},{"k3":9007199254746212},{"k4":null},{"k5":9007199254746214},{"k6":9007199254746215},{"k7":null},{"k8":9007199254746217},{"k9":9007199254746218},{"k10":null},{"k11":9007199254746220},{"k12":9007199254746221},{"k13":null},{"k14":9007199254746223},{"k15":9007199254746224},{"k0":null},{"k1":9007199254746226},{"k2":9007199254746227},{"k3":null},{"k4":9007199254746229},{"k5":9007199254746230},{"k6":null},{"k7":9007199254746232},{"k8":9007199254746233},{"k9":null},{"k10":9007199254746235},{"k11":9007199254746236},{"k12":null},{"k13":9007199254746238},{"k14":9007199254746239},{"k15":null},{"k0":9007199254746241},{"k1":9007199254746242},{"k2":null},{"k3":9007199254746244},{"k4":9007199254746245},{"k5":null},{"k6":9007199254746247},{"k7":9007199254746248},{"k8":null},{"k9":9007199254746250},{"k10":9007199254746251},{"k11":null},{"k12":9007199254746253},{"k13":9007199254746254},{"k14":null},{"k15":9007199254746256},{"k0":9007199254746257},{"k1":null},{"k2":9007199254746259},{"k3":9007199254746260},{"k4":null},{"k5":9007199254746262},{"k6":9007199254746263},{"k7":null},{"k8":9007199254746265},{"k9":9007199254746266},{"k10":null},{"k11":9007199254746268},{"k12":9007199254746269},{"k13":null},{"k14":9007199254746271},{"k15":9007199254746272},{"k0":null},{"k1":9007199254746274},{"k2":9007199254746275},{"k3":null},{"k4":9007199254746277},{"k5":9007199254746278},{"k6":null},{"k7":9007199254746280},{"k8":9007199254746281},{"k9":null},{"k10":9007199254746283},{"k11":9007199254746284},{"k12":null},{"k13":9007199254746286},{"k14":9007199254746287},{"k15":null},{"k0":9007199254746289},{"k1":9007199254746290},{"k2":null},{"k3":9007199254746292},{"k4":9007199254746293},{"k5":null},{"k6":9007199254746295},{"k7":9007199254746296},{"k8":null},{"k9":9007199254746298},{"k10":9007199254746299},{"k11":null},{"k12":9007199254746301},{"k13":9007199254746302},{"k14":null},{"k15":9007199254746304},{"k0":9007199254746305},{"k1":null},{"k2":9007199254746307},{"k3":9007199254746308},{"k4":null},{"k5":9007199254746310},{"k6":9007199254746311},{"k7":null},{"k8":9007199254746313},{"k9":9007199254746314},{"k10":null},{"k11":9007199254746316},{"k12":9007199254746317},{"k13":null},{"k14":9007199254746319},{"k15":9007199254746320},{"k0":null},{"k1":9007199254746322},{"k2":9007199254746323},{"k3":null},{"k4":9007199254746325},{"k5":9007199254746326},{"k6":null},{"k7":9007199254746328},{"k8":9007199254746329},{"k9":null},{"k10":9007199254746331},{"k11":9007199254746332},{"k12":null},{"k13":9007199254746334},{"k14":9007199254746335},{"k15":null},{"k0":9007199254746337},{"k1":9007199254746338},{"k2":null},{"k3":9007199254746340},{"k4":9007199254746341},{"k5":null},{"k6":9007199254746343},{"k7":9007199254746344},{"k8":null},{"k9":9007199254746346},{"k10":9007199254746347},{"k11":null},{"k12":9007199254746349},{"k13":9007199254746350},{"k14":null},{"k15":9007199254746352},{"k0":9007199254746353},{"k1":null},{"k2":9007199254746355},{"k3":9007199254746356},{"k4":null},{"k5":9007199254746358},{"k6":9007199254746359},{"k7":null},{"k8":9007199254746361},{"k9":9007199254746362},{"k10":null},{"k11":9007199254746364},{"k12":9007199254746365},{"k13":null},{"k14":9007199254746367},{"k15":9007199254746368},{"k0":null},{"k1":9007199254746370},{"k2":9007199254746371},{"k3":null},{"k4":9007199254746373},{"k5":9007199254746374},{"k6":null},{"k7":9007199254746376},{"k8":9007199254746377},{"k9":null},{"k10":9007199254746379},{"k11":9007199254746380},{"k12":null},{"k13":9007199254746382},{"k14":9007199254746383},{"k15":null},{"k0":9007199254746385},{"k1":9007199254746386},{"k2":null},{"k3":9007199254746388},{"k4":9007199254746389},{"k5":null},{"k6":9007199254746391},{"k7":9007199254746392},{"k8":null},{"k9":9007199254746394},{"k10":9007199254746395},{"k11":null},{"k12":9007199254746397},{"k13":9007199254746398},{"k14":null},{"k15":9007199254746400},{"k0":9007199254746401},{"k1":null},{"k2":9007199254746403},{"k3":9007199254746404},{"k4":null},{"k5":9007199254746406},{"k6":9007199254746407},{"k7":null},{"k8":9007199254746409},{"k9":9007199254746410},{"k10":null},{"k11":9007199254746412},{"k12":9007199254746413},{"k13":null},{"k14":9007199254746415},{"k15":9007199254746416},{"k0":null},{"k1":9007199254746418},{"k2":9007199254746419},{"k3":null},{"k4":9007199254746421},{"k5":9007199254746422},{"k6":null},{"k7":9007199254746424},{"k8":9007199254746425},{"k9":null},{"k10":9007199254746427},{"k11":9007199254746428},{"k12":null},{"k13":9007199254746430},{"k14":9007199254746431},{"k15":null},{"k0":9007199254746433},{"k1":9007199254746434},{"k2":null},{"k3":9007199254746436},{"k4":9007199254746437},{"k5":null},{"k6":9007199254746439},{"k7":9007199254746440},{"k8":null},{"k9":9007199254746442},{"k10":9007199254746443},{"k11":null},{"k12":9007199254746445},{"k13":9007199254746446},{"k14":null},{"k15":9007199254746448},{"k0":9007199254746449},{"k1":null},{"k2":9007199254746451},{"k3":9007199254746452},{"k4":null},{"k5":9007199254746454},{"k6":9007199254746455},{"k7":null},{"k8":9007199254746457},{"k9":9007199254746458},{"k10":null},{"k11":9007199254746460},{"k12":9007199254746461},{"k13":null},{"k14":9007199254746463},{"k15":9007199254746464},{"k0":null},{"k1":9007199254746466},{"k2":9007199254746467},{"k3":null},{"k4":9007199254746469},{"k5":9007199254746470},{"k6":null},{"k7":9007199254746472},{"k8":9007199254746473},{"k9":null},{"k10":9007199254746475},{"k11":9007199254746476},{"k12":null},{"k13":9007199254746478},{"k14":9007199254746479},{"k15":null},{"k0":9007199254746481},{"k1":9007199254746482},{"k2":null},{"k3":9007199254746484},{"k4":9007199254746485},{"k5":null},{"k6":9007199254746487},{"k7":9007199254746488},{"k8":null},{"k9":9007199254746490},{"k10":9007199254746491},{"k11":null},{"k12":9007199254746493},{"k13":9007199254746494},{"k14":null},{"k15":9007199254746496},{"k0":9007199254746497},{"k1":null},{"k2":9007199254746499},{"k3":9007199254746500},{"k4":null},{"k5":9007199254746502},{"k6":9007199254746503},{"k7":null},{"k8":9007199254746505},{"k9":9007199254746506},{"k10":null},{"k11":9007199254746508},{"k12":9007199254746509},{"k13":null},{"k14":9007199254746511},{"k15":9007199254746512},{"k0":null},{"k1":9007199254746514},{"k2":9007199254746515},{"k3":null},{"k4":9007199254746517},{"k5":9007199254746518},{"k6":null},{"k7":9007199254746520},{"k8":9007199254746521},{"k9":null},{"k10":9007199254746523},{"k11":9007199254746524},{"k12":null},{"k13":9007199254746526},{"k14":9007199254746527},{"k15":null},{"k0":9007199254746529},{"k1":9007199254746530},{"k2":null},{"k3":9007199254746532},{"k4":9007199254746533},{"k5":null},{"k6":9007199254746535},{"k7":9007199254746536},{"k8":null},{"k9":9007199254746538},{"k10":9007199254746539},{"k11":null},{"k12":9007199254746541},{"k13":9007199254746542},{"k14":null},{"k15":9007199254746544},{"k0":9007199254746545},{"k1":null},{"k2":9007199254746547},{"k3":9007199254746548},{"k4":null},{"k5":9007199254746550},{"k6":9007199254746551},{"k7":null},{"k8":9007199254746553},{"k9":9007199254746554},{"k10":null},{"k11":9007199254746556},{"k12":9007199254746557},{"k13":null},{"k14":9007199254746559},{"k15":9007199254746560},{"k0":null},{"k1":9007199254746562},{"k2":9007199254746563},{"k3":null},{"k4":9007199254746565},{"k5":9007199254746566},{"k6":null},{"k7":9007199254746568},{"k8":9007199254746569},{"k9":null},{"k10":9007199254746571},{"k11":9007199254746572},{"k12":null},{"k13":9007199254746574},{"k14":9007199254746575},{"k15":null},{"k0":9007199254746577},{"k1":9007199254746578},{"k2":null},{"k3":9007199254746580},{"k4":9007199254746581},{"k5":null},{"k6":9007199254746583},{"k7":9007199254746584},{"k8":null},{"k9":9007199254746586},{"k10":9007199254746587},{"k11":null},{"k12":9007199254746589},{"k13":9007199254746590},{"k14":null},{"k15":9007199254746592},{"k0":9007199254746593},{"k1":null},{"k2":9007199254746595},{"k3":9007199254746596},{"k4":null},{"k5":9007199254746598},{"k6":9007199254746599},{"k7":null},{"k8":9007199254746601},{"k9":9007199254746602},{"k10":null},{"k11":9007199254746604},{"k12":9007199254746605},{"k13":null},{"k14":9007199254746607},{"k15":9007199254746608},{"k0":null},{"k1":9007199254746610},{"k2":9007199254746611},{"k3":null},{"k4":9007199254746613},{"k5":9007199254746614},{"k6":null},{"k7":9007199254746616},{"k8":9007199254746617},{"k9":null},{"k10":9007199254746619},{"k11":9007199254746620},{"k12":null},{"k13":9007199254746622},{"k14":9007199254746623},{"k15":null},{"k0":9007199254746625},{"k1":9007199254746626},{"k2":null},{"k3":9007199254746628},{"k4":9007199254746629},{"k5":null},{"k6":9007199254746631},{"k7":9007199254746632},{"k8":null},{"k9":9007199254746634},{"k10":9007199254746635},{"k11":null},{"k12":9007199254746637},{"k13":9007199254746638},{"k14":null},{"k15":9007199254746640},{"k0":9007199254746641},{"k1":null},{"k2":9007199254746643},{"k3":9007199254746644},{"k4":null},{"k5":9007199254746646},{"k6":9007199254746647},{"k7":null},{"k8":9007199254746649},{"k9":9007199254746650},{"k10":null},{"k11":9007199254746652},{"k12":9007199254746653},{"k13":null},{"k14":9007199254746655},{"k15":9007199254746656},{"k0":null},{"k1":9007199254746658},{"k2":9007199254746659},{"k3":null},{"k4":9007199254746661},{"k5":9007199254746662},{"k6":null},{"k7":9007199254746664},{"k8":9007199254746665},{"k9":null},{"k10":9007199254746667},{"k11":9007199254746668},{"k12":null},{"k13":9007199254746670},{"k14":9007199254746671},{"k15":null},{"k0":9007199254746673},{"k1":9007199254746674},{"k2":null},{"k3":9007199254746676},{"k4":9007199254746677},{"k5":null},{"k6":9007199254746679},{"k7":9007199254746680},{"k8":null},{"k9":9007199254746682},{"k10":9007199254746683},{"k11":null},{"k12":9007199254746685},{"k13":9007199254746686},{"k14":null},{"k15":9007199254746688},{"k0":9007199254746689},{"k1":null},{"k2":9007199254746691},{"k3":9007199254746692},{"k4":null},{"k5":9007199254746694},{"k6":9007199254746695},{"k7":null},{"k8":9007199254746697},{"k9":9007199254746698},{"k10":null},{"k11":9007199254746700},{"k12":9007199254746701},{"k13":null},{"k14":9007199254746703},{"k15":9007199254746704},{"k0":null},{"k1":9007199254746706},{"k2":9007199254746707},{"k3":null},{"k4":9007199254746709},{"k5":9007199254746710},{"k6":null},{"k7":9007199254746712},{"k8":9007199254746713},{"k9":null},{"k10":9007199254746715},{"k11":9007199254746716},{"k12":null},{"k13":9007199254746718},{"k14":9007199254746719},{"k15":null},{"k0":9007199254746721},{"k1":9007199254746722},{"k2":null},{"k3":9007199254746724},{"k4":9007199254746725},{"k5":null},{"k6":9007199254746727},{"k7":9007199254746728},{"k8":null},{"k9":9007199254746730},{"k10":9007199254746731},{"k11":null},{"k12":9007199254746733},{"k13":9007199254746734},{"k14":null},{"k15":9007199254746736},{"k0":9007199254746737},{"k1":null},{"k2":9007199254746739},{"k3":9007199254746740},{"k4":null},{"k5":9007199254746742},{"k6":9007199254746743},{"k7":null},{"k8":9007199254746745},{"k9":9007199254746746},{"k10":null},{"k11":9007199254746748},{"k12":9007199254746749},{"k13":null},{"k14":9007199254746751},{"k15":9007199254746752},{"k0":null},{"k1":9007199254746754},{"k2":9007199254746755},{"k3":null},{"k4":9007199254746757},{"k5":9007199254746758},{"k6":null},{"k7":9007199254746760},{"k8":9007199254746761},{"k9":null},{"k10":9007199254746763},{"k11":9007199254746764},{"k12":null},{"k13":9007199254746766},{"k14":9007199254746767},{"k15":null},{"k0":9007199254746769},{"k1":9007199254746770},{"k2":null},{"k3":9007199254746772},{"k4":9007199254746773},{"k5":null},{"k6":9007199254746775},{"k7":9007199254746776},{"k8":null},{"k9":9007199254746778},{"k10":9007199254746779},{"k11":null},{"k12":9007199254746781},{"k13":9007199254746782},{"k14":null},{"k15":9007199254746784},{"k0":9007199254746785},{"k1":null},{"k2":9007199254746787},{"k3":9007199254746788},{"k4":null},{"k5":9007199254746790},{"k6":9007199254746791},{"k7":null},{"k8":9007199254746793},{"k9":9007199254746794},{"k10":null},{"k11":9007199254746796},{"k12":9007199254746797},{"k13":null},{"k14":9007199254746799},{"k15":9007199254746800},{"k0":null},{"k1":9007199254746802},{"k2":9007199254746803},{"k3":null},{"k4":9007199254746805},{"k5":9007199254746806},{"k6":null},{"k7":9007199254746808},{"k8":9007199254746809},{"k9":null},{"k10":9007199254746811},{"k11":9007199254746812},{"k12":null},{"k13":9007199254746814},{"k14":9007199254746815},{"k15":null},{"k0":9007199254746817},{"k1":9007199254746818},{"k2":null},{"k3":9007199254746820},{"k4":9007199254746821},{"k5":null},{"k6":9007199254746823},{"k7":9007199254746824},{"k8":null},{"k9":9007199254746826},{"k10":9007199254746827},{"k11":null},{"k12":9007199254746829},{"k13":9007199254746830},{"k14":null},{"k15":9007199254746832},{"k0":9007199254746833},{"k1":null},{"k2":9007199254746835},{"k3":9007199254746836},{"k4":null},{"k5":9007199254746838},{"k6":9007199254746839},{"k7":null},{"k8":9007199254746841},{"k9":9007199254746842},{"k10":null},{"k11":9007199254746844},{"k12":9007199254746845},{"k13":null},{"k14":9007199254746847},{"k15":9007199254746848},{"k0":null},{"k1":9007199254746850},{"k2":9007199254746851},{"k3":null},{"k4":9007199254746853},{"k5":9007199254746854},{"k6":null},{"k7":9007199254746856},{"k8":9007199254746857},{"k9":null},{"k10":9007199254746859},{"k11":9007199254746860},{"k12":null},{"k13":9007199254746862},{"k14":9007199254746863},{"k15":null},{"k0":9007199254746865},{"k1":9007199254746866},{"k2":null},{"k3":9007199254746868},{"k4":9007199254746869},{"k5":null},{"k6":9007199254746871},{"k7":9007199254746872},{"k8":null},{"k9":9007199254746874},{"k10":9007199254746875},{"k11":null},{"k12":9007199254746877},{"k13":9007199254746878},{"k14":null},{"k15":9007199254746880},{"k0":9007199254746881},{"k1":null},{"k2":9007199254746883},{"k3":9007199254746884},{"k4":null},{"k5":9007199254746886},{"k6":9007199254746887},{"k7":null},{"k8":9007199254746889},{"k9":9007199254746890},{"k10":null},{"k11":9007199254746892},{"k12":9007199254746893},{"k13":null},{"k14":9007199254746895},{"k15":9007199254746896},{"k0":null},{"k1":9007199254746898},{"k2":9007199254746899},{"k3":null},{"k4":9007199254746901},{"k5":9007199254746902},{"k6":null},{"k7":9007199254746904},{"k8":9007199254746905},{"k9":null},{"k10":9007199254746907},{"k11":9007199254746908},{"k12":null},{"k13":9007199254746910},{"k14":9007199254746911},{"k15":null},{"k0":9007199254746913},{"k1":9007199254746914},{"k2":null},{"k3":9007199254746916},{"k4":9007199254746917},{"k5":null},{"k6":9007199254746919},{"k7":9007199254746920},{"k8":null},{"k9":9007199254746922},{"k10":9007199254746923},{"k11":null},{"k12":9007199254746925},{"k13":9007199254746926},{"k14":null},{"k15":9007199254746928},{"k0":9007199254746929},{"k1":null},{"k2":9007199254746931},{"k3":9007199254746932},{"k4":null},{"k5":9007199254746934},{"k6":9007199254746935},{"k7":null},{"k8":9007199254746937},{"k9":9007199254746938},{"k10":null},{"k11":9007199254746940},{"k12":9007199254746941},{"k13":null},{"k14":9007199254746943},{"k15":9007199254746944},{"k0":null},{"k1":9007199254746946},{"k2":9007199254746947},{"k3":null},{"k4":9007199254746949},{"k5":9007199254746950},{"k6":null},{"k7":9007199254746952},{"k8":9007199254746953},{"k9":null},{"k10":9007199254746955},{"k11":9007199254746956},{"k12":null},{"k13":9007199254746958},{"k14":9007199254746959},{"k15":null},{"k0":9007199254746961},{"k1":9007199254746962},{"k2":null},{"k3":9007199254746964},{"k4":9007199254746965},{"k5":null},{"k6":9007199254746967},{"k7":9007199254746968},{"k8":null},{"k9":9007199254746970},{"k10":9007199254746971},{"k11":null},{"k12":9007199254746973},{"k13":9007199254746974},{"k14":null},{"k15":9007199254746976},{"k0":9007199254746977},{"k1":null},{"k2":9007199254746979},{"k3":9007199254746980},{"k4":null},{"k5":9007199254746982},{"k6":9007199254746983},{"k7":null},{"k8":9007199254746985},{"k9":9007199254746986},{"k10":null},{"k11":9007199254746988},{"k12":9007199254746989},{"k13":null},{"k14":9007199254746991},{"k15":9007199254746992},{"k0":null},{"k1":9007199254746994},{"k2":9007199254746995},{"k3":null},{"k4":9007199254746997},{"k5":9007199254746998},{"k6":null},{"k7":9007199254747000},{"k8":9007199254747001},{"k9":null},{"k10":9007199254747003},{"k11":9007199254747004},{"k12":null},{"k13":9007199254747006},{"k14":9007199254747007},{"k15":null},{"k0":9007199254747009},{"k1":9007199254747010},{"k2":null},{"k3":9007199254747012},{"k4":9007199254747013},{"k5":null},{"k6":9007199254747015},{"k7":9007199254747016},{"k8":null},{"k9":9007199254747018},{"k10":9007199254747019},{"k11":null},{"k12":9007199254747021},{"k13":9007199254747022},{"k14":null},{"k15":9007199254747024},{"k0":9007199254747025},{"k1":null},{"k2":9007199254747027},{"k3":9007199254747028},{"k4":null},{"k5":9007199254747030},{"k6":9007199254747031},{"k7":null},{"k8":9007199254747033},{"k9":9007199254747034},{"k10":null},{"k11":9007199254747036},{"k12":9007199254747037},{"k13":null},{"k14":9007199254747039},{"k15":9007199254747040},{"k0":null},{"k1":9007199254747042},{"k2":9007199254747043},{"k3":null},{"k4":9007199254747045},{"k5":9007199254747046},{"k6":null},{"k7":9007199254747048},{"k8":9007199254747049},{"k9":null},{"k10":9007199254747051},{"k11":9007199254747052},{"k12":null},{"k13":9007199254747054},{"k14":9007199254747055},{"k15":null},{"k0":9007199254747057},{"k1":9007199254747058},{"k2":null},{"k3":9007199254747060},{"k4":9007199254747061},{"k5":null},{"k6":9007199254747063},{"k7":9007199254747064},{"k8":null},{"k9":9007199254747066},{"k10":9007199254747067},{"k11":null},{"k12":9007199254747069},{"k13":9007199254747070},{"k14":null},{"k15":9007199254747072},{"k0":9007199254747073},{"k1":null},{"k2":9007199254747075},{"k3":9007199254747076},{"k4":null},{"k5":9007199254747078},{"k6":9007199254747079},{"k7":null},{"k8":9007199254747081},{"k9":9007199254747082},{"k10":null},{"k11":9007199254747084},{"k12":9007199254747085},{"k13":null},{"k14":9007199254747087},{"k15":9007199254747088},{"k0":null},{"k1":9007199254747090},{"k2":9007199254747091},{"k3":null},{"k4":9007199254747093},{"k5":9007199254747094},{"k6":null},{"k7":9007199254747096},{"k8":9007199254747097},{"k9":null},{"k10":9007199254747099},{"k11":9007199254747100},{"k12":null},{"k13":9007199254747102},{"k14":9007199254747103},{"k15":null},{"k0":9007199254747105},{"k1":9007199254747106},{"k2":null},{"k3":9007199254747108},{"k4":9007199254747109},{"k5":null},{"k6":9007199254747111},{"k7":9007199254747112},{"k8":null},{"k9":9007199254747114},{"k10":9007199254747115},{"k11":null},{"k12":9007199254747117},{"k13":9007199254747118},{"k14":null},{"k15":9007199254747120},{"k0":9007199254747121},{"k1":null},{"k2":9007199254747123},{"k3":9007199254747124},{"k4":null},{"k5":9007199254747126},{"k6":9007199254747127},{"k7":null},{"k8":9007199254747129},{"k9":9007199254747130},{"k10":null},{"k11":9007199254747132},{"k12":9007199254747133},{"k13":null},{"k14":9007199254747135},{"k15":9007199254747136},{"k0":null},{"k1":9007199254747138},{"k2":9007199254747139},{"k3":null},{"k4":9007199254747141},{"k5":9007199254747142},{"k6":null},{"k7":9007199254747144},{"k8":9007199254747145},{"k9":null},{"k10":9007199254747147},{"k11":9007199254747148},{"k12":null},{"k13":9007199254747150},{"k14":9007199254747151},{"k15":null},{"k0":9007199254747153},{"k1":9007199254747154},{"k2":null},{"k3":9007199254747156},{"k4":9007199254747157},{"k5":null},{"k6":9007199254747159},{"k7":9007199254747160},{"k8":null},{"k9":9007199254747162},{"k10":9007199254747163},{"k11":null},{"k12":9007199254747165},{"k13":9007199254747166},{"k14":null},{"k15":9007199254747168},{"k0":9007199254747169},{"k1":null},{"k2":9007199254747171},{"k3":9007199254747172},{"k4":null},{"k5":9007199254747174},{"k6":9007199254747175},{"k7":null},{"k8":9007199254747177},{"k9":9007199254747178},{"k10":null},{"k11":9007199254747180},{"k12":9007199254747181},{"k13":null},{"k14":9007199254747183},{"k15":9007199254747184},{"k0":null},{"k1":9007199254747186},{"k2":9007199254747187},{"k3":null},{"k4":9007199254747189},{"k5":9007199254747190},{"k6":null},{"k7":9007199254747192},{"k8":9007199254747193},{"k9":null},{"k10":9007199254747195},{"k11":9007199254747196},{"k12":null},{"k13":9007199254747198},{"k14":9007199254747199},{"k15":null},{"k0":9007199254747201},{"k1":9007199254747202},{"k2":null},{"k3":9007199254747204},{"k4":9007199254747205},{"k5":null},{"k6":9007199254747207},{"k7":9007199254747208},{"k8":null},{"k9":9007199254747210},{"k10":9007199254747211},{"k11":null},{"k12":9007199254747213},{"k13":9007199254747214},{"k14":null},{"k15":9007199254747216},{"k0":9007199254747217},{"k1":null},{"k2":9007199254747219},{"k3":9007199254747220},{"k4":null},{"k5":9007199254747222},{"k6":9007199254747223},{"k7":null},{"k8":9007199254747225},{"k9":9007199254747226},{"k10":null},{"k11":9007199254747228},{"k12":9007199254747229},{"k13":null},{"k14":9007199254747231},{"k15":9007199254747232},{"k0":null},{"k1":9007199254747234},{"k2":9007199254747235},{"k3":null},{"k4":9007199254747237},{"k5":9007199254747238},{"k6":null},{"k7":9007199254747240},{"k8":9007199254747241},{"k9":null},{"k10":9007199254747243},{"k11":9007199254747244},{"k12":null},{"k13":9007199254747246},{"k14":9007199254747247},{"k15":null},{"k0":9007199254747249},{"k1":9007199254747250},{"k2":null},{"k3":9007199254747252},{"k4":9007199254747253},{"k5":null},{"k6":9007199254747255},{"k7":9007199254747256},{"k8":null},{"k9":9007199254747258},{"k10":9007199254747259},{"k11":null},{"k12":9007199254747261},{"k13":9007199254747262},{"k14":null},{"k15":9007199254747264},{"k0":9007199254747265},{"k1":null},{"k2":9007199254747267},{"k3":9007199254747268},{"k4":null},{"k5":9007199254747270},{"k6":9007199254747271},{"k7":null},{"k8":9007199254747273},{"k9":9007199254747274},{"k10":null},{"k11":9007199254747276},{"k12":9007199254747277},{"k13":null},{"k14":9007199254747279},{"k15":9007199254747280},{"k0":null},{"k1":9007199254747282},{"k2":9007199254747283},{"k3":null},{"k4":9007199254747285},{"k5":9007199254747286},{"k6":null},{"k7":9007199254747288},{"k8":9007199254747289},{"k9":null},{"k10":9007199254747291},{"k11":9007199254747292},{"k12":null},{"k13":9007199254747294},{"k14":9007199254747295},{"k15":null},{"k0":9007199254747297},{"k1":9007199254747298},{"k2":null},{"k3":9007199254747300},{"k4":9007199254747301},{"k5":null},{"k6":9007199254747303},{"k7":9007199254747304},{"k8":null},{"k9":9007199254747306},{"k10":9007199254747307},{"k11":null},{"k12":9007199254747309},{"k13":9007199254747310},{"k14":null},{"k15":9007199254747312},{"k0":9007199254747313},{"k1":null},{"k2":9007199254747315},{"k3":9007199254747316},{"k4":null},{"k5":9007199254747318},{"k6":9007199254747319},{"k7":null},{"k8":9007199254747321},{"k9":9007199254747322},{"k10":null},{"k11":9007199254747324},{"k12":9007199254747325},{"k13":null},{"k14":9007199254747327},{"k15":9007199254747328},{"k0":null},{"k1":9007199254747330},{"k2":9007199254747331},{"k3":null},{"k4":9007199254747333},{"k5":9007199254747334},{"k6":null},{"k7":9007199254747336},{"k8":9007199254747337},{"k9":null},{"k10":9007199254747339},{"k11":9007199254747340},{"k12":null},{"k13":9007199254747342},{"k14":9007199254747343},{"k15":null},{"k0":9007199254747345},{"k1":9007199254747346},{"k2":null},{"k3":9007199254747348},{"k4":9007199254747349},{"k5":null},{"k6":9007199254747351},{"k7":9007199254747352},{"k8":null},{"k9":9007199254747354},{"k10":9007199254747355},{"k11":null},{"k12":9007199254747357},{"k13":9007199254747358},{"k14":null},{"k15":9007199254747360},{"k0":9007199254747361},{"k1":null},{"k2":9007199254747363},{"k3":9007199254747364},{"k4":null},{"k5":9007199254747366},{"k6":9007199254747367},{"k7":null},{"k8":9007199254747369},{"k9":9007199254747370},{"k10":null},{"k11":9007199254747372},{"k12":9007199254747373},{"k13":null},{"k14":9007199254747375},{"k15":9007199254747376},{"k0":null},{"k1":9007199254747378},{"k2":9007199254747379},{"k3":null},{"k4":9007199254747381},{"k5":9007199254747382},{"k6":null},{"k7":9007199254747384},{"k8":9007199254747385},{"k9":null},{"k10":9007199254747387},{"k11":9007199254747388},{"k12":null},{"k13":9007199254747390},{"k14":9007199254747391},{"k15":null},{"k0":9007199254747393},{"k1":9007199254747394},{"k2":null},{"k3":9007199254747396},{"k4":9007199254747397},{"k5":null},{"k6":9007199254747399},{"k7":9007199254747400},{"k8":null},{"k9":9007199254747402},{"k10":9007199254747403},{"k11":null},{"k12":9007199254747405},{"k13":9007199254747406},{"k14":null},{"k15":9007199254747408},{"k0":9007199254747409},{"k1":null},{"k2":9007199254747411},{"k3":9007199254747412},{"k4":null},{"k5":9007199254747414},{"k6":9007199254747415},{"k7":null},{"k8":9007199254747417},{"k9":9007199254747418},{"k10":null},{"k11":9007199254747420},{"k12":9007199254747421},{"k13":null},{"k14":9007199254747423},{"k15":9007199254747424},{"k0":null},{"k1":9007199254747426},{"k2":9007199254747427},{"k3":null},{"k4":9007199254747429},{"k5":9007199254747430},{"k6":null},{"k7":9007199254747432},{"k8":9007199254747433},{"k9":null},{"k10":9007199254747435},{"k11":9007199254747436},{"k12":null},{"k13":9007199254747438},{"k14":9007199254747439},{"k15":null},{"k0":9007199254747441},{"k1":9007199254747442},{"k2":null},{"k3":9007199254747444},{"k4":9007199254747445},{"k5":null},{"k6":9007199254747447},{"k7":9007199254747448},{"k8":null},{"k9":9007199254747450},{"k10":9007199254747451},{"k11":null},{"k12":9007199254747453},{"k13":9007199254747454},{"k14":null},{"k15":9007199254747456},{"k0":9007199254747457},{"k1":null},{"k2":9007199254747459},{"k3":9007199254747460},{"k4":null},{"k5":9007199254747462},{"k6":9007199254747463},{"k7":null},{"k8":9007199254747465},{"k9":9007199254747466},{"k10":null},{"k11":9007199254747468},{"k12":9007199254747469},{"k13":null},{"k14":9007199254747471},{"k15":9007199254747472},{"k0":null},{"k1":9007199254747474},{"k2":9007199254747475},{"k3":null},{"k4":9007199254747477},{"k5":9007199254747478},{"k6":null},{"k7":9007199254747480},{"k8":9007199254747481},{"k9":null},{"k10":9007199254747483},{"k11":9007199254747484},{"k12":null},{"k13":9007199254747486},{"k14":9007199254747487},{"k15":null},{"k0":9007199254747489},{"k1":9007199254747490},{"k2":null},{"k3":9007199254747492},{"k4":9007199254747493},{"k5":null},{"k6":9007199254747495},{"k7":9007199254747496},{"k8":null},{"k9":9007199254747498},{"k10":9007199254747499},{"k11":null},{"k12":9007199254747501},{"k13":9007199254747502},{"k14":null},{"k15":9007199254747504},{"k0":9007199254747505},{"k1":null},{"k2":9007199254747507},{"k3":9007199254747508},{"k4":null},{"k5":9007199254747510},{"k6":9007199254747511},{"k7":null},{"k8":9007199254747513},{"k9":9007199254747514},{"k10":null},{"k11":9007199254747516},{"k12":9007199254747517},{"k13":null},{"k14":9007199254747519},{"k15":9007199254747520},{"k0":null},{"k1":9007199254747522},{"k2":9007199254747523},{"k3":null},{"k4":9007199254747525},{"k5":9007199254747526},{"k6":null},{"k7":9007199254747528},{"k8":9007199254747529},{"k9":null},{"k10":9007199254747531},{"k11":9007199254747532},{"k12":null},{"k13":9007199254747534},{"k14":9007199254747535},{"k15":null},{"k0":9007199254747537},{"k1":9007199254747538},{"k2":null},{"k3":9007199254747540},{"k4":9007199254747541},{"k5":null},{"k6":9007199254747543},{"k7":9007199254747544},{"k8":null},{"k9":9007199254747546},{"k10":9007199254747547},{"k11":null},{"k12":9007199254747549},{"k13":9007199254747550},{"k14":null},{"k15":9007199254747552},{"k0":9007199254747553},{"k1":null},{"k2":9007199254747555},{"k3":9007199254747556},{"k4":null},{"k5":9007199254747558},{"k6":9007199254747559},{"k7":null},{"k8":9007199254747561},{"k9":9007199254747562},{"k10":null},{"k11":9007199254747564},{"k12":9007199254747565},{"k13":null},{"k14":9007199254747567},{"k15":9007199254747568},{"k0":null},{"k1":9007199254747570},{"k2":9007199254747571},{"k3":null},{"k4":9007199254747573},{"k5":9007199254747574},{"k6":null},{"k7":9007199254747576},{"k8":9007199254747577},{"k9":null},{"k10":9007199254747579},{"k11":9007199254747580},{"k12":null},{"k13":9007199254747582},{"k14":9007199254747583},{"k15":null},{"k0":9007199254747585},{"k1":9007199254747586},{"k2":null},{"k3":9007199254747588},{"k4":9007199254747589},{"k5":null},{"k6":9007199254747591},{"k7":9007199254747592},{"k8":null},{"k9":9007199254747594},{"k10":9007199254747595},{"k11":null},{"k12":9007199254747597},{"k13":9007199254747598},{"k14":null},{"k15":9007199254747600},{"k0":9007199254747601},{"k1":null},{"k2":9007199254747603},{"k3":9007199254747604},{"k4":null},{"k5":9007199254747606},{"k6":9007199254747607},{"k7":null},{"k8":9007199254747609},{"k9":9007199254747610},{"k10":null},{"k11":9007199254747612},{"k12":9007199254747613},{"k13":null},{"k14":9007199254747615},{"k15":9007199254747616},{"k0":null},{"k1":9007199254747618},{"k2":9007199254747619},{"k3":null},{"k4":9007199254747621},{"k5":9007199254747622},{"k6":null},{"k7":9007199254747624},{"k8":9007199254747625},{"k9":null},{"k10":9007199254747627},{"k11":9007199254747628},{"k12":null},{"k13":9007199254747630},{"k14":9007199254747631},{"k15":null},{"k0":9007199254747633},{"k1":9007199254747634},{"k2":null},{"k3":9007199254747636},{"k4":9007199254747637},{"k5":null},{"k6":9007199254747639},{"k7":9007199254747640},{"k8":null},{"k9":9007199254747642},{"k10":9007199254747643},{"k11":null},{"k12":9007199254747645},{"k13":9007199254747646},{"k14":null},{"k15":9007199254747648},{"k0":9007199254747649},{"k1":null},{"k2":9007199254747651},{"k3":9007199254747652},{"k4":null},{"k5":9007199254747654},{"k6":9007199254747655},{"k7":null},{"k8":9007199254747657},{"k9":9007199254747658},{"k10":null},{"k11":9007199254747660},{"k12":9007199254747661},{"k13":null},{"k14":9007199254747663},{"k15":9007199254747664},{"k0":null},{"k1":9007199254747666},{"k2":9007199254747667},{"k3":null},{"k4":9007199254747669},{"k5":9007199254747670},{"k6":null},{"k7":9007199254747672},{"k8":9007199254747673},{"k9":null},{"k10":9007199254747675},{"k11":9007199254747676},{"k12":null},{"k13":9007199254747678},{"k14":9007199254747679},{"k15":null},{"k0":9007199254747681},{"k1":9007199254747682},{"k2":null},{"k3":9007199254747684},{"k4":9007199254747685},{"k5":null},{"k6":9007199254747687},{"k7":9007199254747688},{"k8":null},{"k9":9007199254747690},{"k10":9007199254747691},{"k11":null},{"k12":9007199254747693},{"k13":9007199254747694},{"k14":null},{"k15":9007199254747696},{"k0":9007199254747697},{"k1":null},{"k2":9007199254747699},{"k3":9007199254747700},{"k4":null},{"k5":9007199254747702},{"k6":9007199254747703},{"k7":null},{"k8":9007199254747705},{"k9":9007199254747706},{"k10":null},{"k11":9007199254747708},{"k12":9007199254747709},{"k13":null},{"k14":9007199254747711},{"k15":9007199254747712},{"k0":null},{"k1":9007199254747714},{"k2":9007199254747715},{"k3":null},{"k4":9007199254747717},{"k5":9007199254747718},{"k6":null},{"k7":9007199254747720},{"k8":9007199254747721},{"k9":null},{"k10":9007199254747723},{"k11":9007199254747724},{"k12":null},{"k13":9007199254747726},{"k14":9007199254747727},{"k15":null},{"k0":9007199254747729},{"k1":9007199254747730},{"k2":null},{"k3":9007199254747732},{"k4":9007199254747733},{"k5":null},{"k6":9007199254747735},{"k7":9007199254747736},{"k8":null},{"k9":9007199254747738},{"k10":9007199254747739},{"k11":null},{"k12":9007199254747741},{"k13":9007199254747742},{"k14":null},{"k15":9007199254747744},{"k0":9007199254747745},{"k1":null},{"k2":9007199254747747},{"k3":9007199254747748},{"k4":null},{"k5":9007199254747750},{"k6":9007199254747751},{"k7":null},{"k8":9007199254747753},{"k9":9007199254747754},{"k10":null},{"k11":9007199254747756},{"k12":9007199254747757},{"k13":null},{"k14":9007199254747759},{"k15":9007199254747760},{"k0":null},{"k1":9007199254747762},{"k2":9007199254747763},{"k3":null},{"k4":9007199254747765},{"k5":9007199254747766},{"k6":null},{"k7":9007199254747768},{"k8":9007199254747769},{"k9":null},{"k10":9007199254747771},{"k11":9007199254747772},{"k12":null},{"k13":9007199254747774},{"k14":9007199254747775},{"k15":null},{"k0":9007199254747777},{"k1":9007199254747778},{"k2":null},{"k3":9007199254747780},{"k4":9007199254747781},{"k5":null},{"k6":9007199254747783},{"k7":9007199254747784},{"k8":null},{"k9":9007199254747786},{"k10":9007199254747787},{"k11":null},{"k12":9007199254747789},{"k13":9007199254747790},{"k14":null},{"k15":9007199254747792},{"k0":9007199254747793},{"k1":null},{"k2":9007199254747795},{"k3":9007199254747796},{"k4":null},{"k5":9007199254747798},{"k6":9007199254747799},{"k7":null},{"k8":9007199254747801},{"k9":9007199254747802},{"k10":null},{"k11":9007199254747804},{"k12":9007199254747805},{"k13":null},{"k14":9007199254747807},{"k15":9007199254747808},{"k0":null},{"k1":9007199254747810},{"k2":9007199254747811},{"k3":null},{"k4":9007199254747813},{"k5":9007199254747814},{"k6":null},{"k7":9007199254747816},{"k8":9007199254747817},{"k9":null},{"k10":9007199254747819},{"k11":9007199254747820},{"k12":null},{"k13":9007199254747822},{"k14":9007199254747823},{"k15":null},{"k0":9007199254747825},{"k1":9007199254747826},{"k2":null},{"k3":9007199254747828},{"k4":9007199254747829},{"k5":null},{"k6":9007199254747831},{"k7":9007199254747832},{"k8":null},{"k9":9007199254747834},{"k10":9007199254747835},{"k11":null},{"k12":9007199254747837},{"k13":9007199254747838},{"k14":null},{"k15":9007199254747840},{"k0":9007199254747841},{"k1":null},{"k2":9007199254747843},{"k3":9007199254747844},{"k4":null},{"k5":9007199254747846},{"k6":9007199254747847},{"k7":null},{"k8":9007199254747849},{"k9":9007199254747850},{"k10":null},{"k11":9007199254747852},{"k12":9007199254747853},{"k13":null},{"k14":9007199254747855},{"k15":9007199254747856},{"k0":null},{"k1":9007199254747858},{"k2":9007199254747859},{"k3":null},{"k4":9007199254747861},{"k5":9007199254747862},{"k6":null},{"k7":9007199254747864},{"k8":9007199254747865},{"k9":null},{"k10":9007199254747867},{"k11":9007199254747868},{"k12":null},{"k13":9007199254747870},{"k14":9007199254747871},{"k15":null},{"k0":9007199254747873},{"k1":9007199254747874},{"k2":null},{"k3":9007199254747876},{"k4":9007199254747877},{"k5":null},{"k6":9007199254747879},{"k7":9007199254747880},{"k8":null},{"k9":9007199254747882},{"k10":9007199254747883},{"k11":null},{"k12":9007199254747885},{"k13":9007199254747886},{"k14":null},{"k15":9007199254747888},{"k0":9007199254747889},{"k1":null},{"k2":9007199254747891},{"k3":9007199254747892},{"k4":null},{"k5":9007199254747894},{"k6":9007199254747895},{"k7":null},{"k8":9007199254747897},{"k9":9007199254747898},{"k10":null},{"k11":9007199254747900},{"k12":9007199254747901},{"k13":null},{"k14":9007199254747903},{"k15":9007199254747904},{"k0":null},{"k1":9007199254747906},{"k2":9007199254747907},{"k3":null},{"k4":9007199254747909},{"k5":9007199254747910},{"k6":null},{"k7":9007199254747912},{"k8":9007199254747913},{"k9":null},{"k10":9007199254747915},{"k11":9007199254747916},{"k12":null},{"k13":9007199254747918},{"k14":9007199254747919},{"k15":null},{"k0":9007199254747921},{"k1":9007199254747922},{"k2":null},{"k3":9007199254747924},{"k4":9007199254747925},{"k5":null},{"k6":9007199254747927},{"k7":9007199254747928},{"k8":null},{"k9":9007199254747930},{"k10":9007199254747931},{"k11":null},{"k12":9007199254747933},{"k13":9007199254747934},{"k14":null},{"k15":9007199254747936},{"k0":9007199254747937},{"k1":null},{"k2":9007199254747939},{"k3":9007199254747940},{"k4":null},{"k5":9007199254747942},{"k6":9007199254747943},{"k7":null},{"k8":9007199254747945},{"k9":9007199254747946},{"k10":null},{"k11":9007199254747948},{"k12":9007199254747949},{"k13":null},{"k14":9007199254747951},{"k15":9007199254747952},{"k0":null},{"k1":9007199254747954},{"k2":9007199254747955},{"k3":null},{"k4":9007199254747957},{"k5":9007199254747958},{"k6":null},{"k7":9007199254747960},{"k8":9007199254747961},{"k9":null},{"k10":9007199254747963},{"k11":9007199254747964},{"k12":null},{"k13":9007199254747966},{"k14":9007199254747967},{"k15":null},{"k0":9007199254747969},{"k1":9007199254747970},{"k2":null},{"k3":9007199254747972},{"k4":9007199254747973},{"k5":null},{"k6":9007199254747975},{"k7":9007199254747976},{"k8":null},{"k9":9007199254747978},{"k10":9007199254747979},{"k11":null},{"k12":9007199254747981},{"k13":9007199254747982},{"k14":null},{"k15":9007199254747984},{"k0":9007199254747985},{"k1":null},{"k2":9007199254747987},{"k3":9007199254747988},{"k4":null},{"k5":9007199254747990},{"k6":9007199254747991},{"k7":null},{"k8":9007199254747993},{"k9":9007199254747994},{"k10":null},{"k11":9007199254747996},{"k12":9007199254747997},{"k13":null},{"k14":9007199254747999},{"k15":9007199254748000},{"k0":null},{"k1":9007199254748002},{"k2":9007199254748003},{"k3":null},{"k4":9007199254748005},{"k5":9007199254748006},{"k6":null},{"k7":9007199254748008},{"k8":9007199254748009},{"k9":null},{"k10":9007199254748011},{"k11":9007199254748012},{"k12":null},{"k13":9007199254748014},{"k14":9007199254748015},{"k15":null},{"k0":9007199254748017},{"k1":9007199254748018},{"k2":null},{"k3":9007199254748020},{"k4":9007199254748021},{"k5":null},{"k6":9007199254748023},{"k7":9007199254748024},{"k8":null},{"k9":9007199254748026},{"k10":9007199254748027},{"k11":null},{"k12":9007199254748029},{"k13":9007199254748030},{"k14":null},{"k15":9007199254748032},{"k0":9007199254748033},{"k1":null},{"k2":9007199254748035},{"k3":9007199254748036},{"k4":null},{"k5":9007199254748038},{"k6":9007199254748039},{"k7":null},{"k8":9007199254748041},{"k9":9007199254748042},{"k10":null},{"k11":9007199254748044},{"k12":9007199254748045},{"k13":null},{"k14":9007199254748047},{"k15":9007199254748048},{"k0":null},{"k1":9007199254748050},{"k2":9007199254748051},{"k3":null},{"k4":9007199254748053},{"k5":9007199254748054},{"k6":null},{"k7":9007199254748056},{"k8":9007199254748057},{"k9":null},{"k10":9007199254748059},{"k11":9007199254748060},{"k12":null},{"k13":9007199254748062},{"k14":9007199254748063},{"k15":null},{"k0":9007199254748065},{"k1":9007199254748066},{"k2":null},{"k3":9007199254748068},{"k4":9007199254748069},{"k5":null},{"k6":9007199254748071},{"k7":9007199254748072},{"k8":null},{"k9":9007199254748074},{"k10":9007199254748075},{"k11":null},{"k12":9007199254748077},{"k13":9007199254748078},{"k14":null},{"k15":9007199254748080},{"k0":9007199254748081},{"k1":null},{"k2":9007199254748083},{"k3":9007199254748084},{"k4":null},{"k5":9007199254748086},{"k6":9007199254748087},{"k7":null},{"k8":9007199254748089},{"k9":9007199254748090},{"k10":null},{"k11":9007199254748092},{"k12":9007199254748093},{"k13":null},{"k14":9007199254748095},{"k15":9007199254748096},{"k0":null},{"k1":9007199254748098},{"k2":9007199254748099},{"k3":null},{"k4":9007199254748101},{"k5":9007199254748102},{"k6":null},{"k7":9007199254748104},{"k8":9007199254748105},{"k9":null},{"k10":9007199254748107},{"k11":9007199254748108},{"k12":null},{"k13":9007199254748110},{"k14":9007199254748111},{"k15":null},{"k0":9007199254748113},{"k1":9007199254748114},{"k2":null},{"k3":9007199254748116},{"k4":9007199254748117},{"k5":null},{"k6":9007199254748119},{"k7":9007199254748120},{"k8":null},{"k9":9007199254748122},{"k10":9007199254748123},{"k11":null},{"k12":9007199254748125},{"k13":9007199254748126},{"k14":null},{"k15":9007199254748128},{"k0":9007199254748129},{"k1":null},{"k2":9007199254748131},{"k3":9007199254748132},{"k4":null},{"k5":9007199254748134},{"k6":9007199254748135},{"k7":null},{"k8":9007199254748137},{"k9":9007199254748138},{"k10":null},{"k11":9007199254748140},{"k12":9007199254748141},{"k13":null},{"k14":9007199254748143},{"k15":9007199254748144},{"k0":null},{"k1":9007199254748146},{"k2":9007199254748147},{"k3":null},{"k4":9007199254748149},{"k5":9007199254748150},{"k6":null},{"k7":9007199254748152},{"k8":9007199254748153},{"k9":null},{"k10":9007199254748155},{"k11":9007199254748156},{"k12":null},{"k13":9007199254748158},{"k14":9007199254748159},{"k15":null},{"k0":9007199254748161},{"k1":9007199254748162},{"k2":null},{"k3":9007199254748164},{"k4":9007199254748165},{"k5":null},{"k6":9007199254748167},{"k7":9007199254748168},{"k8":null},{"k9":9007199254748170},{"k10":9007199254748171},{"k11":null},{"k12":9007199254748173},{"k13":9007199254748174},{"k14":null},{"k15":9007199254748176},{"k0":9007199254748177},{"k1":null},{"k2":9007199254748179},{"k3":9007199254748180},{"k4":null},{"k5":9007199254748182},{"k6":9007199254748183},{"k7":null},{"k8":9007199254748185},{"k9":9007199254748186},{"k10":null},{"k11":9007199254748188},{"k12":9007199254748189},{"k13":null},{"k14":9007199254748191},{"k15":9007199254748192},{"k0":null},{"k1":9007199254748194},{"k2":9007199254748195},{"k3":null},{"k4":9007199254748197},{"k5":9007199254748198},{"k6":null},{"k7":9007199254748200},{"k8":9007199254748201},{"k9":null},{"k10":9007199254748203},{"k11":9007199254748204},{"k12":null},{"k13":9007199254748206},{"k14":9007199254748207},{"k15":null},{"k0":9007199254748209},{"k1":9007199254748210},{"k2":null},{"k3":9007199254748212},{"k4":9007199254748213},{"k5":null},{"k6":9007199254748215},{"k7":9007199254748216},{"k8":null},{"k9":9007199254748218},{"k10":9007199254748219},{"k11":null},{"k12":9007199254748221},{"k13":9007199254748222},{"k14":null},{"k15":9007199254748224},{"k0":9007199254748225},{"k1":null},{"k2":9007199254748227},{"k3":9007199254748228},{"k4":null},{"k5":9007199254748230},{"k6":9007199254748231},{"k7":null},{"k8":9007199254748233},{"k9":9007199254748234},{"k10":null},{"k11":9007199254748236},{"k12":9007199254748237},{"k13":null},{"k14":9007199254748239},{"k15":9007199254748240},{"k0":null},{"k1":9007199254748242},{"k2":9007199254748243},{"k3":null},{"k4":9007199254748245},{"k5":9007199254748246},{"k6":null},{"k7":9007199254748248},{"k8":9007199254748249},{"k9":null},{"k10":9007199254748251},{"k11":9007199254748252},{"k12":null},{"k13":9007199254748254},{"k14":9007199254748255},{"k15":null},{"k0":9007199254748257},{"k1":9007199254748258},{"k2":null},{"k3":9007199254748260},{"k4":9007199254748261},{"k5":null},{"k6":9007199254748263},{"k7":9007199254748264},{"k8":null},{"k9":9007199254748266},{"k10":9007199254748267},{"k11":null},{"k12":9007199254748269},{"k13":9007199254748270},{"k14":null},{"k15":9007199254748272},{"k0":9007199254748273},{"k1":null},{"k2":9007199254748275},{"k3":9007199254748276},{"k4":null},{"k5":9007199254748278},{"k6":9007199254748279},{"k7":null},{"k8":9007199254748281},{"k9":9007199254748282},{"k10":null},{"k11":9007199254748284},{"k12":9007199254748285},{"k13":null},{"k14":9007199254748287},{"k15":9007199254748288},{"k0":null},{"k1":9007199254748290},{"k2":9007199254748291},{"k3":null},{"k4":9007199254748293},{"k5":9007199254748294},{"k6":null},{"k7":9007199254748296},{"k8":9007199254748297},{"k9":null},{"k10":9007199254748299},{"k11":9007199254748300},{"k12":null},{"k13":9007199254748302},{"k14":9007199254748303},{"k15":null},{"k0":9007199254748305},{"k1":9007199254748306},{"k2":null},{"k3":9007199254748308},{"k4":9007199254748309},{"k5":null},{"k6":9007199254748311},{"k7":9007199254748312},{"k8":null},{"k9":9007199254748314},{"k10":9007199254748315},{"k11":null},{"k12":9007199254748317},{"k13":9007199254748318},{"k14":null},{"k15":9007199254748320},{"k0":9007199254748321},{"k1":null},{"k2":9007199254748323},{"k3":9007199254748324},{"k4":null},{"k5":9007199254748326},{"k6":9007199254748327},{"k7":null},{"k8":9007199254748329},{"k9":9007199254748330},{"k10":null},{"k11":9007199254748332},{"k12":9007199254748333},{"k13":null},{"k14":9007199254748335},{"k15":9007199254748336},{"k0":null},{"k1":9007199254748338},{"k2":9007199254748339},{"k3":null},{"k4":9007199254748341},{"k5":9007199254748342},{"k6":null},{"k7":9007199254748344},{"k8":9007199254748345},{"k9":null},{"k10":9007199254748347},{"k11":9007199254748348},{"k12":null},{"k13":9007199254748350},{"k14":9007199254748351},{"k15":null},{"k0":9007199254748353},{"k1":9007199254748354},{"k2":null},{"k3":9007199254748356},{"k4":9007199254748357},{"k5":null},{"k6":9007199254748359},{"k7":9007199254748360},{"k8":null},{"k9":9007199254748362},{"k10":9007199254748363},{"k11":null},{"k12":9007199254748365},{"k13":9007199254748366},{"k14":null},{"k15":9007199254748368},{"k0":9007199254748369},{"k1":null},{"k2":9007199254748371},{"k3":9007199254748372},{"k4":null},{"k5":9007199254748374},{"k6":9007199254748375},{"k7":null},{"k8":9007199254748377},{"k9":9007199254748378},{"k10":null},{"k11":9007199254748380},{"k12":9007199254748381},{"k13":null},{"k14":9007199254748383},{"k15":9007199254748384},{"k0":null},{"k1":9007199254748386},{"k2":9007199254748387},{"k3":null},{"k4":9007199254748389},{"k5":9007199254748390},{"k6":null},{"k7":9007199254748392},{"k8":9007199254748393},{"k9":null},{"k10":9007199254748395},{"k11":9007199254748396},{"k12":null},{"k13":9007199254748398},{"k14":9007199254748399},{"k15":null},{"k0":9007199254748401},{"k1":9007199254748402},{"k2":null},{"k3":9007199254748404},{"k4":9007199254748405},{"k5":null},{"k6":9007199254748407},{"k7":9007199254748408},{"k8":null},{"k9":9007199254748410},{"k10":9007199254748411},{"k11":null},{"k12":9007199254748413},{"k13":9007199254748414},{"k14":null},{"k15":9007199254748416},{"k0":9007199254748417},{"k1":null},{"k2":9007199254748419},{"k3":9007199254748420},{"k4":null},{"k5":9007199254748422},{"k6":9007199254748423},{"k7":null},{"k8":9007199254748425},{"k9":9007199254748426},{"k10":null},{"k11":9007199254748428},{"k12":9007199254748429},{"k13":null},{"k14":9007199254748431},{"k15":9007199254748432},{"k0":null},{"k1":9007199254748434},{"k2":9007199254748435},{"k3":null},{"k4":9007199254748437},{"k5":9007199254748438},{"k6":null},{"k7":9007199254748440},{"k8":9007199254748441},{"k9":null},{"k10":9007199254748443},{"k11":9007199254748444},{"k12":null},{"k13":9007199254748446},{"k14":9007199254748447},{"k15":null},{"k0":9007199254748449},{"k1":9007199254748450},{"k2":null},{"k3":9007199254748452},{"k4":9007199254748453},{"k5":null},{"k6":9007199254748455},{"k7":9007199254748456},{"k8":null},{"k9":9007199254748458},{"k10":9007199254748459},{"k11":null},{"k12":9007199254748461},{"k13":9007199254748462},{"k14":null},{"k15":9007199254748464},{"k0":9007199254748465},{"k1":null},{"k2":9007199254748467},{"k3":9007199254748468},{"k4":null},{"k5":9007199254748470},{"k6":9007199254748471},{"k7":null},{"k8":9007199254748473},{"k9":9007199254748474},{"k10":null},{"k11":9007199254748476},{"k12":9007199254748477},{"k13":null},{"k14":9007199254748479},{"k15":9007199254748480},{"k0":null},{"k1":9007199254748482},{"k2":9007199254748483},{"k3":null},{"k4":9007199254748485},{"k5":9007199254748486},{"k6":null},{"k7":9007199254748488},{"k8":9007199254748489},{"k9":null},{"k10":9007199254748491},{"k11":9007199254748492},{"k12":null},{"k13":9007199254748494},{"k14":9007199254748495},{"k15":null},{"k0":9007199254748497},{"k1":9007199254748498},{"k2":null},{"k3":9007199254748500},{"k4":9007199254748501},{"k5":null},{"k6":9007199254748503},{"k7":9007199254748504},{"k8":null},{"k9":9007199254748506},{"k10":9007199254748507},{"k11":null},{"k12":9007199254748509},{"k13":9007199254748510},{"k14":null},{"k15":9007199254748512},{"k0":9007199254748513},{"k1":null},{"k2":9007199254748515},{"k3":9007199254748516},{"k4":null},{"k5":9007199254748518},{"k6":9007199254748519},{"k7":null},{"k8":9007199254748521},{"k9":9007199254748522},{"k10":null},{"k11":9007199254748524},{"k12":9007199254748525},{"k13":null},{"k14":9007199254748527},{"k15":9007199254748528},{"k0":null},{"k1":9007199254748530},{"k2":9007199254748531},{"k3":null},{"k4":9007199254748533},{"k5":9007199254748534},{"k6":null},{"k7":9007199254748536},{"k8":9007199254748537},{"k9":null},{"k10":9007199254748539},{"k11":9007199254748540},{"k12":null},{"k13":9007199254748542},{"k14":9007199254748543},{"k15":null},{"k0":9007199254748545},{"k1":9007199254748546},{"k2":null},{"k3":9007199254748548},{"k4":9007199254748549},{"k5":null},{"k6":9007199254748551},{"k7":9007199254748552},{"k8":null},{"k9":9007199254748554},{"k10":9007199254748555},{"k11":null},{"k12":9007199254748557},{"k13":9007199254748558},{"k14":null},{"k15":9007199254748560},{"k0":9007199254748561},{"k1":null},{"k2":9007199254748563},{"k3":9007199254748564},{"k4":null},{"k5":9007199254748566},{"k6":9007199254748567},{"k7":null},{"k8":9007199254748569},{"k9":9007199254748570},{"k10":null},{"k11":9007199254748572},{"k12":9007199254748573},{"k13":null},{"k14":9007199254748575},{"k15":9007199254748576},{"k0":null},{"k1":9007199254748578},{"k2":9007199254748579},{"k3":null},{"k4":9007199254748581},{"k5":9007199254748582},{"k6":null},{"k7":9007199254748584},{"k8":9007199254748585},{"k9":null},{"k10":9007199254748587},{"k11":9007199254748588},{"k12":null},{"k13":9007199254748590},{"k14":9007199254748591},{"k15":null},{"k0":9007199254748593},{"k1":9007199254748594},{"k2":null},{"k3":9007199254748596},{"k4":9007199254748597},{"k5":null},{"k6":9007199254748599},{"k7":9007199254748600},{"k8":null},{"k9":9007199254748602},{"k10":9007199254748603},{"k11":null},{"k12":9007199254748605},{"k13":9007199254748606},{"k14":null},{"k15":9007199254748608},{"k0":9007199254748609},{"k1":null},{"k2":9007199254748611},{"k3":9007199254748612},{"k4":null},{"k5":9007199254748614},{"k6":9007199254748615},{"k7":null},{"k8":9007199254748617},{"k9":9007199254748618},{"k10":null},{"k11":9007199254748620},{"k12":9007199254748621},{"k13":null},{"k14":9007199254748623},{"k15":9007199254748624},{"k0":null},{"k1":9007199254748626},{"k2":9007199254748627},{"k3":null},{"k4":9007199254748629},{"k5":9007199254748630},{"k6":null},{"k7":9007199254748632},{"k8":9007199254748633},{"k9":null},{"k10":9007199254748635},{"k11":9007199254748636},{"k12":null},{"k13":9007199254748638},{"k14":9007199254748639},{"k15":null},{"k0":9007199254748641},{"k1":9007199254748642},{"k2":null},{"k3":9007199254748644},{"k4":9007199254748645},{"k5":null},{"k6":9007199254748647},{"k7":9007199254748648},{"k8":null},{"k9":9007199254748650},{"k10":9007199254748651},{"k11":null},{"k12":9007199254748653},{"k13":9007199254748654},{"k14":null},{"k15":9007199254748656},{"k0":9007199254748657},{"k1":null},{"k2":9007199254748659},{"k3":9007199254748660},{"k4":null},{"k5":9007199254748662},{"k6":9007199254748663},{"k7":null},{"k8":9007199254748665},{"k9":9007199254748666},{"k10":null},{"k11":9007199254748668},{"k12":9007199254748669},{"k13":null},{"k14":9007199254748671},{"k15":9007199254748672},{"k0":null},{"k1":9007199254748674},{"k2":9007199254748675},{"k3":null},{"k4":9007199254748677},{"k5":9007199254748678},{"k6":null},{"k7":9007199254748680},{"k8":9007199254748681},{"k9":null},{"k10":9007199254748683},{"k11":9007199254748684},{"k12":null},{"k13":9007199254748686},{"k14":9007199254748687},{"k15":null},{"k0":9007199254748689},{"k1":9007199254748690},{"k2":null},{"k3":9007199254748692},{"k4":9007199254748693},{"k5":null},{"k6":9007199254748695},{"k7":9007199254748696},{"k8":null},{"k9":9007199254748698},{"k10":9007199254748699},{"k11":null},{"k12":9007199254748701},{"k13":9007199254748702},{"k14":null},{"k15":9007199254748704},{"k0":9007199254748705},{"k1":null},{"k2":9007199254748707},{"k3":9007199254748708},{"k4":null},{"k5":9007199254748710},{"k6":9007199254748711},{"k7":null},{"k8":9007199254748713},{"k9":9007199254748714},{"k10":null},{"k11":9007199254748716},{"k12":9007199254748717},{"k13":null},{"k14":9007199254748719},{"k15":9007199254748720},{"k0":null},{"k1":9007199254748722},{"k2":9007199254748723},{"k3":null},{"k4":9007199254748725},{"k5":9007199254748726},{"k6":null},{"k7":9007199254748728},{"k8":9007199254748729},{"k9":null},{"k10":9007199254748731},{"k11":9007199254748732},{"k12":null},{"k13":9007199254748734},{"k14":9007199254748735},{"k15":null},{"k0":9007199254748737},{"k1":9007199254748738},{"k2":null},{"k3":9007199254748740},{"k4":9007199254748741},{"k5":null},{"k6":9007199254748743},{"k7":9007199254748744},{"k8":null},{"k9":9007199254748746},{"k10":9007199254748747},{"k11":null},{"k12":9007199254748749},{"k13":9007199254748750},{"k14":null},{"k15":9007199254748752},{"k0":9007199254748753},{"k1":null},{"k2":9007199254748755},{"k3":9007199254748756},{"k4":null},{"k5":9007199254748758},{"k6":9007199254748759},{"k7":null},{"k8":9007199254748761},{"k9":9007199254748762},{"k10":null},{"k11":9007199254748764},{"k12":9007199254748765},{"k13":null},{"k14":9007199254748767},{"k15":9007199254748768},{"k0":null},{"k1":9007199254748770},{"k2":9007199254748771},{"k3":null},{"k4":9007199254748773},{"k5":9007199254748774},{"k6":null},{"k7":9007199254748776},{"k8":9007199254748777},{"k9":null},{"k10":9007199254748779},{"k11":9007199254748780},{"k12":null},{"k13":9007199254748782},{"k14":9007199254748783},{"k15":null},{"k0":9007199254748785},{"k1":9007199254748786},{"k2":null},{"k3":9007199254748788},{"k4":9007199254748789},{"k5":null},{"k6":9007199254748791},{"k7":9007199254748792},{"k8":null},{"k9":9007199254748794},{"k10":9007199254748795},{"k11":null},{"k12":9007199254748797},{"k13":9007199254748798},{"k14":null},{"k15":9007199254748800},{"k0":9007199254748801},{"k1":null},{"k2":9007199254748803},{"k3":9007199254748804},{"k4":null},{"k5":9007199254748806},{"k6":9007199254748807},{"k7":null},{"k8":9007199254748809},{"k9":9007199254748810},{"k10":null},{"k11":9007199254748812},{"k12":9007199254748813},{"k13":null},{"k14":9007199254748815},{"k15":9007199254748816},{"k0":null},{"k1":9007199254748818},{"k2":9007199254748819},{"k3":null},{"k4":9007199254748821},{"k5":9007199254748822},{"k6":null},{"k7":9007199254748824},{"k8":9007199254748825},{"k9":null},{"k10":9007199254748827},{"k11":9007199254748828},{"k12":null},{"k13":9007199254748830},{"k14":9007199254748831},{"k15":null},{"k0":9007199254748833},{"k1":9007199254748834},{"k2":null},{"k3":9007199254748836},{"k4":9007199254748837},{"k5":null},{"k6":9007199254748839},{"k7":9007199254748840},{"k8":null},{"k9":9007199254748842},{"k10":9007199254748843},{"k11":null},{"k12":9007199254748845},{"k13":9007199254748846},{"k14":null},{"k15":9007199254748848},{"k0":9007199254748849},{"k1":null},{"k2":9007199254748851},{"k3":9007199254748852},{"k4":null},{"k5":9007199254748854},{"k6":9007199254748855},{"k7":null},{"k8":9007199254748857},{"k9":9007199254748858},{"k10":null},{"k11":9007199254748860},{"k12":9007199254748861},{"k13":null},{"k14":9007199254748863},{"k15":9007199254748864},{"k0":null},{"k1":9007199254748866},{"k2":9007199254748867},{"k3":null},{"k4":9007199254748869},{"k5":9007199254748870},{"k6":null},{"k7":9007199254748872},{"k8":9007199254748873},{"k9":null},{"k10":9007199254748875},{"k11":9007199254748876},{"k12":null},{"k13":9007199254748878},{"k14":9007199254748879},{"k15":null},{"k0":9007199254748881},{"k1":9007199254748882},{"k2":null},{"k3":9007199254748884},{"k4":9007199254748885},{"k5":null},{"k6":9007199254748887},{"k7":9007199254748888},{"k8":null},{"k9":9007199254748890},{"k10":9007199254748891},{"k11":null},{"k12":9007199254748893},{"k13":9007199254748894},{"k14":null},{"k15":9007199254748896},{"k0":9007199254748897},{"k1":null},{"k2":9007199254748899},{"k3":9007199254748900},{"k4":null},{"k5":9007199254748902},{"k6":9007199254748903},{"k7":null},{"k8":9007199254748905},{"k9":9007199254748906},{"k10":null},{"k11":9007199254748908},{"k12":9007199254748909},{"k13":null},{"k14":9007199254748911},{"k15":9007199254748912},{"k0":null},{"k1":9007199254748914},{"k2":9007199254748915},{"k3":null},{"k4":9007199254748917},{"k5":9007199254748918},{"k6":null},{"k7":9007199254748920},{"k8":9007199254748921},{"k9":null},{"k10":9007199254748923},{"k11":9007199254748924},{"k12":null},{"k13":9007199254748926},{"k14":9007199254748927},{"k15":null},{"k0":9007199254748929},{"k1":9007199254748930},{"k2":null},{"k3":9007199254748932},{"k4":9007199254748933},{"k5":null},{"k6":9007199254748935},{"k7":9007199254748936},{"k8":null},{"k9":9007199254748938},{"k10":9007199254748939},{"k11":null},{"k12":9007199254748941},{"k13":9007199254748942},{"k14":null},{"k15":9007199254748944},{"k0":9007199254748945},{"k1":null},{"k2":9007199254748947},{"k3":9007199254748948},{"k4":null},{"k5":9007199254748950},{"k6":9007199254748951},{"k7":null},{"k8":9007199254748953},{"k9":9007199254748954},{"k10":null},{"k11":9007199254748956},{"k12":9007199254748957},{"k13":null},{"k14":9007199254748959},{"k15":9007199254748960},{"k0":null},{"k1":9007199254748962},{"k2":9007199254748963},{"k3":null},{"k4":9007199254748965},{"k5":9007199254748966},{"k6":null},{"k7":9007199254748968},{"k8":9007199254748969},{"k9":null},{"k10":9007199254748971},{"k11":9007199254748972},{"k12":null},{"k13":9007199254748974},{"k14":9007199254748975},{"k15":null},{"k0":9007199254748977},{"k1":9007199254748978},{"k2":null},{"k3":9007199254748980},{"k4":9007199254748981},{"k5":null},{"k6":9007199254748983},{"k7":9007199254748984},{"k8":null},{"k9":9007199254748986},{"k10":9007199254748987},{"k11":null},{"k12":9007199254748989},{"k13":9007199254748990},{"k14":null},{"k15":9007199254748992},{"k0":9007199254748993},{"k1":null},{"k2":9007199254748995},{"k3":9007199254748996},{"k4":null},{"k5":9007199254748998},{"k6":9007199254748999},{"k7":null},{"k8":9007199254749001},{"k9":9007199254749002},{"k10":null},{"k11":9007199254749004},{"k12":9007199254749005},{"k13":null},{"k14":9007199254749007},{"k15":9007199254749008},{"k0":null},{"k1":9007199254749010},{"k2":9007199254749011},{"k3":null},{"k4":9007199254749013},{"k5":9007199254749014},{"k6":null},{"k7":9007199254749016},{"k8":9007199254749017},{"k9":null},{"k10":9007199254749019},{"k11":9007199254749020},{"k12":null},{"k13":9007199254749022},{"k14":9007199254749023},{"k15":null},{"k0":9007199254749025},{"k1":9007199254749026},{"k2":null},{"k3":9007199254749028},{"k4":9007199254749029},{"k5":null},{"k6":9007199254749031},{"k7":9007199254749032},{"k8":null},{"k9":9007199254749034},{"k10":9007199254749035},{"k11":null},{"k12":9007199254749037},{"k13":9007199254749038},{"k14":null},{"k15":9007199254749040},{"k0":9007199254749041},{"k1":null},{"k2":9007199254749043},{"k3":9007199254749044},{"k4":null},{"k5":9007199254749046},{"k6":9007199254749047},{"k7":null},{"k8":9007199254749049},{"k9":9007199254749050},{"k10":null},{"k11":9007199254749052},{"k12":9007199254749053},{"k13":null},{"k14":9007199254749055},{"k15":9007199254749056},{"k0":null},{"k1":9007199254749058},{"k2":9007199254749059},{"k3":null},{"k4":9007199254749061},{"k5":9007199254749062},{"k6":null},{"k7":9007199254749064},{"k8":9007199254749065},{"k9":null},{"k10":9007199254749067},{"k11":9007199254749068},{"k12":null},{"k13":9007199254749070},{"k14":9007199254749071},{"k15":null},{"k0":9007199254749073},{"k1":9007199254749074},{"k2":null},{"k3":9007199254749076},{"k4":9007199254749077},{"k5":null},{"k6":9007199254749079},{"k7":9007199254749080},{"k8":null},{"k9":9007199254749082},{"k10":9007199254749083},{"k11":null},{"k12":9007199254749085},{"k13":9007199254749086},{"k14":null},{"k15":9007199254749088},{"k0":9007199254749089},{"k1":null},{"k2":9007199254749091},{"k3":9007199254749092},{"k4":null},{"k5":9007199254749094},{"k6":9007199254749095},{"k7":null},{"k8":9007199254749097},{"k9":9007199254749098},{"k10":null},{"k11":9007199254749100},{"k12":9007199254749101},{"k13":null},{"k14":9007199254749103},{"k15":9007199254749104},{"k0":null},{"k1":9007199254749106},{"k2":9007199254749107},{"k3":null},{"k4":9007199254749109},{"k5":9007199254749110},{"k6":null},{"k7":9007199254749112},{"k8":9007199254749113},{"k9":null},{"k10":9007199254749115},{"k11":9007199254749116},{"k12":null},{"k13":9007199254749118},{"k14":9007199254749119},{"k15":null},{"k0":9007199254749121},{"k1":9007199254749122},{"k2":null},{"k3":9007199254749124},{"k4":9007199254749125},{"k5":null},{"k6":9007199254749127},{"k7":9007199254749128},{"k8":null},{"k9":9007199254749130},{"k10":9007199254749131},{"k11":null},{"k12":9007199254749133},{"k13":9007199254749134},{"k14":null},{"k15":9007199254749136},{"k0":9007199254749137},{"k1":null},{"k2":9007199254749139},{"k3":9007199254749140},{"k4":null},{"k5":9007199254749142},{"k6":9007199254749143},{"k7":null},{"k8":9007199254749145},{"k9":9007199254749146},{"k10":null},{"k11":9007199254749148},{"k12":9007199254749149},{"k13":null},{"k14":9007199254749151},{"k15":9007199254749152},{"k0":null},{"k1":9007199254749154},{"k2":9007199254749155},{"k3":null},{"k4":9007199254749157},{"k5":9007199254749158},{"k6":null},{"k7":9007199254749160},{"k8":9007199254749161},{"k9":null},{"k10":9007199254749163},{"k11":9007199254749164},{"k12":null},{"k13":9007199254749166},{"k14":9007199254749167},{"k15":null},{"k0":9007199254749169},{"k1":9007199254749170},{"k2":null},{"k3":9007199254749172},{"k4":9007199254749173},{"k5":null},{"k6":9007199254749175},{"k7":9007199254749176},{"k8":null},{"k9":9007199254749178},{"k10":9007199254749179},{"k11":null},{"k12":9007199254749181},{"k13":9007199254749182},{"k14":null},{"k15":9007199254749184},{"k0":9007199254749185},{"k1":null},{"k2":9007199254749187},{"k3":9007199254749188},{"k4":null},{"k5":9007199254749190},{"k6":9007199254749191},{"k7":null},{"k8":9007199254749193},{"k9":9007199254749194},{"k10":null},{"k11":9007199254749196},{"k12":9007199254749197},{"k13":null},{"k14":9007199254749199},{"k15":9007199254749200},{"k0":null},{"k1":9007199254749202},{"k2":9007199254749203},{"k3":null},{"k4":9007199254749205},{"k5":9007199254749206},{"k6":null},{"k7":9007199254749208},{"k8":9007199254749209},{"k9":null},{"k10":9007199254749211},{"k11":9007199254749212},{"k12":null},{"k13":9007199254749214},{"k14":9007199254749215},{"k15":null},{"k0":9007199254749217},{"k1":9007199254749218},{"k2":null},{"k3":9007199254749220},{"k4":9007199254749221},{"k5":null},{"k6":9007199254749223},{"k7":9007199254749224},{"k8":null},{"k9":9007199254749226},{"k10":9007199254749227},{"k11":null},{"k12":9007199254749229},{"k13":9007199254749230},{"k14":null},{"k15":9007199254749232},{"k0":9007199254749233},{"k1":null},{"k2":9007199254749235},{"k3":9007199254749236},{"k4":null},{"k5":9007199254749238},{"k6":9007199254749239},{"k7":null},{"k8":9007199254749241},{"k9":9007199254749242},{"k10":null},{"k11":9007199254749244},{"k12":9007199254749245},{"k13":null},{"k14":9007199254749247},{"k15":9007199254749248},{"k0":null},{"k1":9007199254749250},{"k2":9007199254749251},{"k3":null},{"k4":9007199254749253},{"k5":9007199254749254},{"k6":null},{"k7":9007199254749256},{"k8":9007199254749257},{"k9":null},{"k10":9007199254749259},{"k11":9007199254749260},{"k12":null},{"k13":9007199254749262},{"k14":9007199254749263},{"k15":null},{"k0":9007199254749265},{"k1":9007199254749266},{"k2":null},{"k3":9007199254749268},{"k4":9007199254749269},{"k5":null},{"k6":9007199254749271},{"k7":9007199254749272},{"k8":null},{"k9":9007199254749274},{"k10":9007199254749275},{"k11":null},{"k12":9007199254749277},{"k13":9007199254749278},{"k14":null},{"k15":9007199254749280},{"k0":9007199254749281},{"k1":null},{"k2":9007199254749283},{"k3":9007199254749284},{"k4":null},{"k5":9007199254749286},{"k6":9007199254749287},{"k7":null},{"k8":9007199254749289},{"k9":9007199254749290},{"k10":null},{"k11":9007199254749292},{"k12":9007199254749293},{"k13":null},{"k14":9007199254749295},{"k15":9007199254749296},{"k0":null},{"k1":9007199254749298},{"k2":9007199254749299},{"k3":null},{"k4":9007199254749301},{"k5":9007199254749302},{"k6":null},{"k7":9007199254749304},{"k8":9007199254749305},{"k9":null},{"k10":9007199254749307},{"k11":9007199254749308},{"k12":null},{"k13":9007199254749310},{"k14":9007199254749311},{"k15":null},{"k0":9007199254749313},{"k1":9007199254749314},{"k2":null},{"k3":9007199254749316},{"k4":9007199254749317},{"k5":null},{"k6":9007199254749319},{"k7":9007199254749320},{"k8":null},{"k9":9007199254749322},{"k10":9007199254749323},{"k11":null},{"k12":9007199254749325},{"k13":9007199254749326},{"k14":null},{"k15":9007199254749328},{"k0":9007199254749329},{"k1":null},{"k2":9007199254749331},{"k3":9007199254749332},{"k4":null},{"k5":9007199254749334},{"k6":9007199254749335},{"k7":null},{"k8":9007199254749337},{"k9":9007199254749338},{"k10":null},{"k11":9007199254749340},{"k12":9007199254749341},{"k13":null},{"k14":9007199254749343},{"k15":9007199254749344},{"k0":null},{"k1":9007199254749346},{"k2":9007199254749347},{"k3":null},{"k4":9007199254749349},{"k5":9007199254749350},{"k6":null},{"k7":9007199254749352},{"k8":9007199254749353},{"k9":null},{"k10":9007199254749355},{"k11":9007199254749356},{"k12":null},{"k13":9007199254749358},{"k14":9007199254749359},{"k15":null},{"k0":9007199254749361},{"k1":9007199254749362},{"k2":null},{"k3":9007199254749364},{"k4":9007199254749365},{"k5":null},{"k6":9007199254749367},{"k7":9007199254749368},{"k8":null},{"k9":9007199254749370},{"k10":9007199254749371},{"k11":null},{"k12":9007199254749373},{"k13":9007199254749374},{"k14":null},{"k15":9007199254749376},{"k0":9007199254749377},{"k1":null},{"k2":9007199254749379},{"k3":9007199254749380},{"k4":null},{"k5":9007199254749382},{"k6":9007199254749383},{"k7":null},{"k8":9007199254749385},{"k9":9007199254749386},{"k10":null},{"k11":9007199254749388},{"k12":9007199254749389},{"k13":null},{"k14":9007199254749391},{"k15":9007199254749392},{"k0":null},{"k1":9007199254749394},{"k2":9007199254749395},{"k3":null},{"k4":9007199254749397},{"k5":9007199254749398},{"k6":null},{"k7":9007199254749400},{"k8":9007199254749401},{"k9":null},{"k10":9007199254749403},{"k11":9007199254749404},{"k12":null},{"k13":9007199254749406},{"k14":9007199254749407},{"k15":null},{"k0":9007199254749409},{"k1":9007199254749410},{"k2":null},{"k3":9007199254749412},{"k4":9007199254749413},{"k5":null},{"k6":9007199254749415},{"k7":9007199254749416},{"k8":null},{"k9":9007199254749418},{"k10":9007199254749419},{"k11":null},{"k12":9007199254749421},{"k13":9007199254749422},{"k14":null},{"k15":9007199254749424},{"k0":9007199254749425},{"k1":null},{"k2":9007199254749427},{"k3":9007199254749428},{"k4":null},{"k5":9007199254749430},{"k6":9007199254749431},{"k7":null},{"k8":9007199254749433},{"k9":9007199254749434},{"k10":null},{"k11":9007199254749436},{"k12":9007199254749437},{"k13":null},{"k14":9007199254749439},{"k15":9007199254749440},{"k0":null},{"k1":9007199254749442},{"k2":9007199254749443},{"k3":null},{"k4":9007199254749445},{"k5":9007199254749446},{"k6":null},{"k7":9007199254749448},{"k8":9007199254749449},{"k9":null},{"k10":9007199254749451},{"k11":9007199254749452},{"k12":null},{"k13":9007199254749454},{"k14":9007199254749455},{"k15":null},{"k0":9007199254749457},{"k1":9007199254749458},{"k2":null},{"k3":9007199254749460},{"k4":9007199254749461},{"k5":null},{"k6":9007199254749463},{"k7":9007199254749464},{"k8":null},{"k9":9007199254749466},{"k10":9007199254749467},{"k11":null},{"k12":9007199254749469},{"k13":9007199254749470},{"k14":null},{"k15":9007199254749472},{"k0":9007199254749473},{"k1":null},{"k2":9007199254749475},{"k3":9007199254749476},{"k4":null},{"k5":9007199254749478},{"k6":9007199254749479},{"k7":null},{"k8":9007199254749481},{"k9":9007199254749482},{"k10":null},{"k11":9007199254749484},{"k12":9007199254749485},{"k13":null},{"k14":9007199254749487},{"k15":9007199254749488},{"k0":null},{"k1":9007199254749490},{"k2":9007199254749491},{"k3":null},{"k4":9007199254749493},{"k5":9007199254749494},{"k6":null},{"k7":9007199254749496},{"k8":9007199254749497},{"k9":null},{"k10":9007199254749499},{"k11":9007199254749500},{"k12":null},{"k13":9007199254749502},{"k14":9007199254749503},{"k15":null},{"k0":9007199254749505},{"k1":9007199254749506},{"k2":null},{"k3":9007199254749508},{"k4":9007199254749509},{"k5":null},{"k6":9007199254749511},{"k7":9007199254749512},{"k8":null},{"k9":9007199254749514},{"k10":9007199254749515},{"k11":null},{"k12":9007199254749517},{"k13":9007199254749518},{"k14":null},{"k15":9007199254749520},{"k0":9007199254749521},{"k1":null},{"k2":9007199254749523},{"k3":9007199254749524},{"k4":null},{"k5":9007199254749526},{"k6":9007199254749527},{"k7":null},{"k8":9007199254749529},{"k9":9007199254749530},{"k10":null},{"k11":9007199254749532},{"k12":9007199254749533},{"k13":null},{"k14":9007199254749535},{"k15":9007199254749536},{"k0":null},{"k1":9007199254749538},{"k2":9007199254749539},{"k3":null},{"k4":9007199254749541},{"k5":9007199254749542},{"k6":null},{"k7":9007199254749544},{"k8":9007199254749545},{"k9":null},{"k10":9007199254749547},{"k11":9007199254749548},{"k12":null},{"k13":9007199254749550},{"k14":9007199254749551},{"k15":null},{"k0":9007199254749553},{"k1":9007199254749554},{"k2":null},{"k3":9007199254749556},{"k4":9007199254749557},{"k5":null},{"k6":9007199254749559},{"k7":9007199254749560},{"k8":null},{"k9":9007199254749562},{"k10":9007199254749563},{"k11":null},{"k12":9007199254749565},{"k13":9007199254749566},{"k14":null},{"k15":9007199254749568},{"k0":9007199254749569},{"k1":null},{"k2":9007199254749571},{"k3":9007199254749572},{"k4":null},{"k5":9007199254749574},{"k6":9007199254749575},{"k7":null},{"k8":9007199254749577},{"k9":9007199254749578},{"k10":null},{"k11":9007199254749580},{"k12":9007199254749581},{"k13":null},{"k14":9007199254749583},{"k15":9007199254749584},{"k0":null},{"k1":9007199254749586},{"k2":9007199254749587},{"k3":null},{"k4":9007199254749589},{"k5":9007199254749590},{"k6":null},{"k7":9007199254749592},{"k8":9007199254749593},{"k9":null},{"k10":9007199254749595},{"k11":9007199254749596},{"k12":null},{"k13":9007199254749598},{"k14":9007199254749599},{"k15":null},{"k0":9007199254749601},{"k1":9007199254749602},{"k2":null},{"k3":9007199254749604},{"k4":9007199254749605},{"k5":null},{"k6":9007199254749607},{"k7":9007199254749608},{"k8":null},{"k9":9007199254749610},{"k10":9007199254749611},{"k11":null},{"k12":9007199254749613},{"k13":9007199254749614},{"k14":null},{"k15":9007199254749616},{"k0":9007199254749617},{"k1":null},{"k2":9007199254749619},{"k3":9007199254749620},{"k4":null},{"k5":9007199254749622},{"k6":9007199254749623},{"k7":null},{"k8":9007199254749625},{"k9":9007199254749626},{"k10":null},{"k11":9007199254749628},{"k12":9007199254749629},{"k13":null},{"k14":9007199254749631},{"k15":9007199254749632},{"k0":null},{"k1":9007199254749634},{"k2":9007199254749635},{"k3":null},{"k4":9007199254749637},{"k5":9007199254749638},{"k6":null},{"k7":9007199254749640},{"k8":9007199254749641},{"k9":null},{"k10":9007199254749643},{"k11":9007199254749644},{"k12":null},{"k13":9007199254749646},{"k14":9007199254749647},{"k15":null},{"k0":9007199254749649},{"k1":9007199254749650},{"k2":null},{"k3":9007199254749652},{"k4":9007199254749653},{"k5":null},{"k6":9007199254749655},{"k7":9007199254749656},{"k8":null},{"k9":9007199254749658},{"k10":9007199254749659},{"k11":null},{"k12":9007199254749661},{"k13":9007199254749662},{"k14":null},{"k15":9007199254749664},{"k0":9007199254749665},{"k1":null},{"k2":9007199254749667},{"k3":9007199254749668},{"k4":null},{"k5":9007199254749670},{"k6":9007199254749671},{"k7":null},{"k8":9007199254749673},{"k9":9007199254749674},{"k10":null},{"k11":9007199254749676},{"k12":9007199254749677},{"k13":null},{"k14":9007199254749679},{"k15":9007199254749680},{"k0":null},{"k1":9007199254749682},{"k2":9007199254749683},{"k3":null},{"k4":9007199254749685},{"k5":9007199254749686},{"k6":null},{"k7":9007199254749688},{"k8":9007199254749689},{"k9":null},{"k10":9007199254749691},{"k11":9007199254749692},{"k12":null},{"k13":9007199254749694},{"k14":9007199254749695},{"k15":null},{"k0":9007199254749697},{"k1":9007199254749698},{"k2":null},{"k3":9007199254749700},{"k4":9007199254749701},{"k5":null},{"k6":9007199254749703},{"k7":9007199254749704},{"k8":null},{"k9":9007199254749706},{"k10":9007199254749707},{"k11":null},{"k12":9007199254749709},{"k13":9007199254749710},{"k14":null},{"k15":9007199254749712},{"k0":9007199254749713},{"k1":null},{"k2":9007199254749715},{"k3":9007199254749716},{"k4":null},{"k5":9007199254749718},{"k6":9007199254749719},{"k7":null},{"k8":9007199254749721},{"k9":9007199254749722},{"k10":null},{"k11":9007199254749724},{"k12":9007199254749725},{"k13":null},{"k14":9007199254749727},{"k15":9007199254749728},{"k0":null},{"k1":9007199254749730},{"k2":9007199254749731},{"k3":null},{"k4":9007199254749733},{"k5":9007199254749734},{"k6":null},{"k7":9007199254749736},{"k8":9007199254749737},{"k9":null},{"k10":9007199254749739},{"k11":9007199254749740},{"k12":null},{"k13":9007199254749742},{"k14":9007199254749743},{"k15":null},{"k0":9007199254749745},{"k1":9007199254749746},{"k2":null},{"k3":9007199254749748},{"k4":9007199254749749},{"k5":null},{"k6":9007199254749751},{"k7":9007199254749752},{"k8":null},{"k9":9007199254749754},{"k10":9007199254749755},{"k11":null},{"k12":9007199254749757},{"k13":9007199254749758},{"k14":null},{"k15":9007199254749760},{"k0":9007199254749761},{"k1":null},{"k2":9007199254749763},{"k3":9007199254749764},{"k4":null},{"k5":9007199254749766},{"k6":9007199254749767},{"k7":null},{"k8":9007199254749769},{"k9":9007199254749770},{"k10":null},{"k11":9007199254749772},{"k12":9007199254749773},{"k13":null},{"k14":9007199254749775},{"k15":9007199254749776},{"k0":null},{"k1":9007199254749778},{"k2":9007199254749779},{"k3":null},{"k4":9007199254749781},{"k5":9007199254749782},{"k6":null},{"k7":9007199254749784},{"k8":9007199254749785},{"k9":null},{"k10":9007199254749787},{"k11":9007199254749788},{"k12":null},{"k13":9007199254749790},{"k14":9007199254749791},{"k15":null},{"k0":9007199254749793},{"k1":9007199254749794},{"k2":null},{"k3":9007199254749796},{"k4":9007199254749797},{"k5":null},{"k6":9007199254749799},{"k7":9007199254749800},{"k8":null},{"k9":9007199254749802},{"k10":9007199254749803},{"k11":null},{"k12":9007199254749805},{"k13":9007199254749806},{"k14":null},{"k15":9007199254749808},{"k0":9007199254749809},{"k1":null},{"k2":9007199254749811},{"k3":9007199254749812},{"k4":null},{"k5":9007199254749814},{"k6":9007199254749815},{"k7":null},{"k8":9007199254749817},{"k9":9007199254749818},{"k10":null},{"k11":9007199254749820},{"k12":9007199254749821},{"k13":null},{"k14":9007199254749823},{"k15":9007199254749824},{"k0":null},{"k1":9007199254749826},{"k2":9007199254749827},{"k3":null},{"k4":9007199254749829},{"k5":9007199254749830},{"k6":null},{"k7":9007199254749832},{"k8":9007199254749833},{"k9":null},{"k10":9007199254749835},{"k11":9007199254749836},{"k12":null},{"k13":9007199254749838},{"k14":9007199254749839},{"k15":null},{"k0":9007199254749841},{"k1":9007199254749842},{"k2":null},{"k3":9007199254749844},{"k4":9007199254749845},{"k5":null},{"k6":9007199254749847},{"k7":9007199254749848},{"k8":null},{"k9":9007199254749850},{"k10":9007199254749851},{"k11":null},{"k12":9007199254749853},{"k13":9007199254749854},{"k14":null},{"k15":9007199254749856},{"k0":9007199254749857},{"k1":null},{"k2":9007199254749859},{"k3":9007199254749860},{"k4":null},{"k5":9007199254749862},{"k6":9007199254749863},{"k7":null},{"k8":9007199254749865},{"k9":9007199254749866},{"k10":null},{"k11":9007199254749868},{"k12":9007199254749869},{"k13":null},{"k14":9007199254749871},{"k15":9007199254749872},{"k0":null},{"k1":9007199254749874},{"k2":9007199254749875},{"k3":null},{"k4":9007199254749877},{"k5":9007199254749878},{"k6":null},{"k7":9007199254749880},{"k8":9007199254749881},{"k9":null},{"k10":9007199254749883},{"k11":9007199254749884},{"k12":null},{"k13":9007199254749886},{"k14":9007199254749887},{"k15":null},{"k0":9007199254749889},{"k1":9007199254749890},{"k2":null},{"k3":9007199254749892},{"k4":9007199254749893},{"k5":null},{"k6":9007199254749895},{"k7":9007199254749896},{"k8":null},{"k9":9007199254749898},{"k10":9007199254749899},{"k11":null},{"k12":9007199254749901},{"k13":9007199254749902},{"k14":null},{"k15":9007199254749904},{"k0":9007199254749905},{"k1":null},{"k2":9007199254749907},{"k3":9007199254749908},{"k4":null},{"k5":9007199254749910},{"k6":9007199254749911},{"k7":null},{"k8":9007199254749913},{"k9":9007199254749914},{"k10":null},{"k11":9007199254749916},{"k12":9007199254749917},{"k13":null},{"k14":9007199254749919},{"k15":9007199254749920},{"k0":null},{"k1":9007199254749922},{"k2":9007199254749923},{"k3":null},{"k4":9007199254749925},{"k5":9007199254749926},{"k6":null},{"k7":9007199254749928},{"k8":9007199254749929},{"k9":null},{"k10":9007199254749931},{"k11":9007199254749932},{"k12":null},{"k13":9007199254749934},{"k14":9007199254749935},{"k15":null},{"k0":9007199254749937},{"k1":9007199254749938},{"k2":null},{"k3":9007199254749940},{"k4":9007199254749941},{"k5":null},{"k6":9007199254749943},{"k7":9007199254749944},{"k8":null},{"k9":9007199254749946},{"k10":9007199254749947},{"k11":null},{"k12":9007199254749949},{"k13":9007199254749950},{"k14":null},{"k15":9007199254749952},{"k0":9007199254749953},{"k1":null},{"k2":9007199254749955},{"k3":9007199254749956},{"k4":null},{"k5":9007199254749958},{"k6":9007199254749959},{"k7":null},{"k8":9007199254749961},{"k9":9007199254749962},{"k10":null},{"k11":9007199254749964},{"k12":9007199254749965},{"k13":null},{"k14":9007199254749967},{"k15":9007199254749968},{"k0":null},{"k1":9007199254749970},{"k2":9007199254749971},{"k3":null},{"k4":9007199254749973},{"k5":9007199254749974},{"k6":null},{"k7":9007199254749976},{"k8":9007199254749977},{"k9":null},{"k10":9007199254749979},{"k11":9007199254749980},{"k12":null},{"k13":9007199254749982},{"k14":9007199254749983},{"k15":null},{"k0":9007199254749985},{"k1":9007199254749986},{"k2":null},{"k3":9007199254749988},{"k4":9007199254749989},{"k5":null},{"k6":9007199254749991},{"k7":9007199254749992},{"k8":null},{"k9":9007199254749994},{"k10":9007199254749995},{"k11":null},{"k12":9007199254749997},{"k13":9007199254749998},{"k14":null},{"k15":9007199254750000},{"k0":9007199254750001},{"k1":null},{"k2":9007199254750003},{"k3":9007199254750004},{"k4":null},{"k5":9007199254750006},{"k6":9007199254750007},{"k7":null},{"k8":9007199254750009},{"k9":9007199254750010},{"k10":null},{"k11":9007199254750012},{"k12":9007199254750013},{"k13":null},{"k14":9007199254750015},{"k15":9007199254750016},{"k0":null},{"k1":9007199254750018},{"k2":9007199254750019},{"k3":null},{"k4":9007199254750021},{"k5":9007199254750022},{"k6":null},{"k7":9007199254750024},{"k8":9007199254750025},{"k9":null},{"k10":9007199254750027},{"k11":9007199254750028},{"k12":null},{"k13":9007199254750030},{"k14":9007199254750031},{"k15":null},{"k0":9007199254750033},{"k1":9007199254750034},{"k2":null},{"k3":9007199254750036},{"k4":9007199254750037},{"k5":null},{"k6":9007199254750039},{"k7":9007199254750040},{"k8":null},{"k9":9007199254750042},{"k10":9007199254750043},{"k11":null},{"k12":9007199254750045},{"k13":9007199254750046},{"k14":null},{"k15":9007199254750048},{"k0":9007199254750049},{"k1":null},{"k2":9007199254750051},{"k3":9007199254750052},{"k4":null},{"k5":9007199254750054},{"k6":9007199254750055},{"k7":null},{"k8":9007199254750057},{"k9":9007199254750058},{"k10":null},{"k11":9007199254750060},{"k12":9007199254750061},{"k13":null},{"k14":9007199254750063},{"k15":9007199254750064},{"k0":null},{"k1":9007199254750066},{"k2":9007199254750067},{"k3":null},{"k4":9007199254750069},{"k5":9007199254750070},{"k6":null},{"k7":9007199254750072},{"k8":9007199254750073},{"k9":null},{"k10":9007199254750075},{"k11":9007199254750076},{"k12":null},{"k13":9007199254750078},{"k14":9007199254750079},{"k15":null},{"k0":9007199254750081},{"k1":9007199254750082},{"k2":null},{"k3":9007199254750084},{"k4":9007199254750085},{"k5":null},{"k6":9007199254750087},{"k7":9007199254750088},{"k8":null},{"k9":9007199254750090},{"k10":9007199254750091},{"k11":null},{"k12":9007199254750093},{"k13":9007199254750094},{"k14":null},{"k15":9007199254750096},{"k0":9007199254750097},{"k1":null},{"k2":9007199254750099},{"k3":9007199254750100},{"k4":null},{"k5":9007199254750102},{"k6":9007199254750103},{"k7":null},{"k8":9007199254750105},{"k9":9007199254750106},{"k10":null},{"k11":9007199254750108},{"k12":9007199254750109},{"k13":null},{"k14":9007199254750111},{"k15":9007199254750112},{"k0":null},{"k1":9007199254750114},{"k2":9007199254750115},{"k3":null},{"k4":9007199254750117},{"k5":9007199254750118},{"k6":null},{"k7":9007199254750120},{"k8":9007199254750121},{"k9":null},{"k10":9007199254750123},{"k11":9007199254750124},{"k12":null},{"k13":9007199254750126},{"k14":9007199254750127},{"k15":null},{"k0":9007199254750129},{"k1":9007199254750130},{"k2":null},{"k3":9007199254750132},{"k4":9007199254750133},{"k5":null},{"k6":9007199254750135},{"k7":9007199254750136},{"k8":null},{"k9":9007199254750138},{"k10":9007199254750139},{"k11":null},{"k12":9007199254750141},{"k13":9007199254750142},{"k14":null},{"k15":9007199254750144},{"k0":9007199254750145},{"k1":null},{"k2":9007199254750147},{"k3":9007199254750148},{"k4":null},{"k5":9007199254750150},{"k6":9007199254750151},{"k7":null},{"k8":9007199254750153},{"k9":9007199254750154},{"k10":null},{"k11":9007199254750156},{"k12":9007199254750157},{"k13":null},{"k14":9007199254750159},{"k15":9007199254750160},{"k0":null},{"k1":9007199254750162},{"k2":9007199254750163},{"k3":null},{"k4":9007199254750165},{"k5":9007199254750166},{"k6":null},{"k7":9007199254750168},{"k8":9007199254750169},{"k9":null},{"k10":9007199254750171},{"k11":9007199254750172},{"k12":null},{"k13":9007199254750174},{"k14":9007199254750175},{"k15":null},{"k0":9007199254750177},{"k1":9007199254750178},{"k2":null},{"k3":9007199254750180},{"k4":9007199254750181},{"k5":null},{"k6":9007199254750183},{"k7":9007199254750184},{"k8":null},{"k9":9007199254750186},{"k10":9007199254750187},{"k11":null},{"k12":9007199254750189},{"k13":9007199254750190},{"k14":null},{"k15":9007199254750192},{"k0":9007199254750193},{"k1":null},{"k2":9007199254750195},{"k3":9007199254750196},{"k4":null},{"k5":9007199254750198},{"k6":9007199254750199},{"k7":null},{"k8":9007199254750201},{"k9":9007199254750202},{"k10":null},{"k11":9007199254750204},{"k12":9007199254750205},{"k13":null},{"k14":9007199254750207},{"k15":9007199254750208},{"k0":null},{"k1":9007199254750210},{"k2":9007199254750211},{"k3":null},{"k4":9007199254750213},{"k5":9007199254750214},{"k6":null},{"k7":9007199254750216},{"k8":9007199254750217},{"k9":null},{"k10":9007199254750219},{"k11":9007199254750220},{"k12":null},{"k13":9007199254750222},{"k14":9007199254750223},{"k15":null},{"k0":9007199254750225},{"k1":9007199254750226},{"k2":null},{"k3":9007199254750228},{"k4":9007199254750229},{"k5":null},{"k6":9007199254750231},{"k7":9007199254750232},{"k8":null},{"k9":9007199254750234},{"k10":9007199254750235},{"k11":null},{"k12":9007199254750237},{"k13":9007199254750238},{"k14":null},{"k15":9007199254750240},{"k0":9007199254750241},{"k1":null},{"k2":9007199254750243},{"k3":9007199254750244},{"k4":null},{"k5":9007199254750246},{"k6":9007199254750247},{"k7":null},{"k8":9007199254750249},{"k9":9007199254750250},{"k10":null},{"k11":9007199254750252},{"k12":9007199254750253},{"k13":null},{"k14":9007199254750255},{"k15":9007199254750256},{"k0":null},{"k1":9007199254750258},{"k2":9007199254750259},{"k3":null},{"k4":9007199254750261},{"k5":9007199254750262},{"k6":null},{"k7":9007199254750264},{"k8":9007199254750265},{"k9":null},{"k10":9007199254750267},{"k11":9007199254750268},{"k12":null},{"k13":9007199254750270},{"k14":9007199254750271},{"k15":null},{"k0":9007199254750273},{"k1":9007199254750274},{"k2":null},{"k3":9007199254750276},{"k4":9007199254750277},{"k5":null},{"k6":9007199254750279},{"k7":9007199254750280},{"k8":null},{"k9":9007199254750282},{"k10":9007199254750283},{"k11":null},{"k12":9007199254750285},{"k13":9007199254750286},{"k14":null},{"k15":9007199254750288},{"k0":9007199254750289},{"k1":null},{"k2":9007199254750291},{"k3":9007199254750292},{"k4":null},{"k5":9007199254750294},{"k6":9007199254750295},{"k7":null},{"k8":9007199254750297},{"k9":9007199254750298},{"k10":null},{"k11":9007199254750300},{"k12":9007199254750301},{"k13":null},{"k14":9007199254750303},{"k15":9007199254750304},{"k0":null},{"k1":9007199254750306},{"k2":9007199254750307},{"k3":null},{"k4":9007199254750309},{"k5":9007199254750310},{"k6":null},{"k7":9007199254750312},{"k8":9007199254750313},{"k9":null},{"k10":9007199254750315},{"k11":9007199254750316},{"k12":null},{"k13":9007199254750318},{"k14":9007199254750319},{"k15":null},{"k0":9007199254750321},{"k1":9007199254750322},{"k2":null},{"k3":9007199254750324},{"k4":9007199254750325},{"k5":null},{"k6":9007199254750327},{"k7":9007199254750328},{"k8":null},{"k9":9007199254750330},{"k10":9007199254750331},{"k11":null},{"k12":9007199254750333},{"k13":9007199254750334},{"k14":null},{"k15":9007199254750336},{"k0":9007199254750337},{"k1":null},{"k2":9007199254750339},{"k3":9007199254750340},{"k4":null},{"k5":9007199254750342},{"k6":9007199254750343},{"k7":null},{"k8":9007199254750345},{"k9":9007199254750346},{"k10":null},{"k11":9007199254750348},{"k12":9007199254750349},{"k13":null},{"k14":9007199254750351},{"k15":9007199254750352},{"k0":null},{"k1":9007199254750354},{"k2":9007199254750355},{"k3":null},{"k4":9007199254750357},{"k5":9007199254750358},{"k6":null},{"k7":9007199254750360},{"k8":9007199254750361},{"k9":null},{"k10":9007199254750363},{"k11":9007199254750364},{"k12":null},{"k13":9007199254750366},{"k14":9007199254750367},{"k15":null},{"k0":9007199254750369},{"k1":9007199254750370},{"k2":null},{"k3":9007199254750372},{"k4":9007199254750373},{"k5":null},{"k6":9007199254750375},{"k7":9007199254750376},{"k8":null},{"k9":9007199254750378},{"k10":9007199254750379},{"k11":null},{"k12":9007199254750381},{"k13":9007199254750382},{"k14":null},{"k15":9007199254750384},{"k0":9007199254750385},{"k1":null},{"k2":9007199254750387},{"k3":9007199254750388},{"k4":null},{"k5":9007199254750390},{"k6":9007199254750391},{"k7":null},{"k8":9007199254750393},{"k9":9007199254750394},{"k10":null},{"k11":9007199254750396},{"k12":9007199254750397},{"k13":null},{"k14":9007199254750399},{"k15":9007199254750400},{"k0":null},{"k1":9007199254750402},{"k2":9007199254750403},{"k3":null},{"k4":9007199254750405},{"k5":9007199254750406},{"k6":null},{"k7":9007199254750408},{"k8":9007199254750409},{"k9":null},{"k10":9007199254750411},{"k11":9007199254750412},{"k12":null},{"k13":9007199254750414},{"k14":9007199254750415},{"k15":null},{"k0":9007199254750417},{"k1":9007199254750418},{"k2":null},{"k3":9007199254750420},{"k4":9007199254750421},{"k5":null},{"k6":9007199254750423},{"k7":9007199254750424},{"k8":null},{"k9":9007199254750426},{"k10":9007199254750427},{"k11":null},{"k12":9007199254750429},{"k13":9007199254750430},{"k14":null},{"k15":9007199254750432},{"k0":9007199254750433},{"k1":null},{"k2":9007199254750435},{"k3":9007199254750436},{"k4":null},{"k5":9007199254750438},{"k6":9007199254750439},{"k7":null},{"k8":9007199254750441},{"k9":9007199254750442},{"k10":null},{"k11":9007199254750444},{"k12":9007199254750445},{"k13":null},{"k14":9007199254750447},{"k15":9007199254750448},{"k0":null},{"k1":9007199254750450},{"k2":9007199254750451},{"k3":null},{"k4":9007199254750453},{"k5":9007199254750454},{"k6":null},{"k7":9007199254750456},{"k8":9007199254750457},{"k9":null},{"k10":9007199254750459},{"k11":9007199254750460},{"k12":null},{"k13":9007199254750462},{"k14":9007199254750463},{"k15":null},{"k0":9007199254750465},{"k1":9007199254750466},{"k2":null},{"k3":9007199254750468},{"k4":9007199254750469},{"k5":null},{"k6":9007199254750471},{"k7":9007199254750472},{"k8":null},{"k9":9007199254750474},{"k10":9007199254750475},{"k11":null},{"k12":9007199254750477},{"k13":9007199254750478},{"k14":null},{"k15":9007199254750480},{"k0":9007199254750481},{"k1":null},{"k2":9007199254750483},{"k3":9007199254750484},{"k4":null},{"k5":9007199254750486},{"k6":9007199254750487},{"k7":null},{"k8":9007199254750489},{"k9":9007199254750490},{"k10":null},{"k11":9007199254750492},{"k12":9007199254750493},{"k13":null},{"k14":9007199254750495},{"k15":9007199254750496},{"k0":null},{"k1":9007199254750498},{"k2":9007199254750499},{"k3":null},{"k4":9007199254750501},{"k5":9007199254750502},{"k6":null},{"k7":9007199254750504},{"k8":9007199254750505},{"k9":null},{"k10":9007199254750507},{"k11":9007199254750508},{"k12":null},{"k13":9007199254750510},{"k14":9007199254750511},{"k15":null},{"k0":9007199254750513},{"k1":9007199254750514},{"k2":null},{"k3":9007199254750516},{"k4":9007199254750517},{"k5":null},{"k6":9007199254750519},{"k7":9007199254750520},{"k8":null},{"k9":9007199254750522},{"k10":9007199254750523},{"k11":null},{"k12":9007199254750525},{"k13":9007199254750526},{"k14":null},{"k15":9007199254750528},{"k0":9007199254750529},{"k1":null},{"k2":9007199254750531},{"k3":9007199254750532},{"k4":null},{"k5":9007199254750534},{"k6":9007199254750535},{"k7":null},{"k8":9007199254750537},{"k9":9007199254750538},{"k10":null},{"k11":9007199254750540},{"k12":9007199254750541},{"k13":null},{"k14":9007199254750543},{"k15":9007199254750544},{"k0":null},{"k1":9007199254750546},{"k2":9007199254750547},{"k3":null},{"k4":9007199254750549},{"k5":9007199254750550},{"k6":null},{"k7":9007199254750552},{"k8":9007199254750553},{"k9":null},{"k10":9007199254750555},{"k11":9007199254750556},{"k12":null},{"k13":9007199254750558},{"k14":9007199254750559},{"k15":null},{"k0":9007199254750561},{"k1":9007199254750562},{"k2":null},{"k3":9007199254750564},{"k4":9007199254750565},{"k5":null},{"k6":9007199254750567},{"k7":9007199254750568},{"k8":null},{"k9":9007199254750570},{"k10":9007199254750571},{"k11":null},{"k12":9007199254750573},{"k13":9007199254750574},{"k14":null},{"k15":9007199254750576},{"k0":9007199254750577},{"k1":null},{"k2":9007199254750579},{"k3":9007199254750580},{"k4":null},{"k5":9007199254750582},{"k6":9007199254750583},{"k7":null},{"k8":9007199254750585},{"k9":9007199254750586},{"k10":null},{"k11":9007199254750588},{"k12":9007199254750589},{"k13":null},{"k14":9007199254750591},{"k15":9007199254750592},{"k0":null},{"k1":9007199254750594},{"k2":9007199254750595},{"k3":null},{"k4":9007199254750597},{"k5":9007199254750598},{"k6":null},{"k7":9007199254750600},{"k8":9007199254750601},{"k9":null},{"k10":9007199254750603},{"k11":9007199254750604},{"k12":null},{"k13":9007199254750606},{"k14":9007199254750607},{"k15":null},{"k0":9007199254750609},{"k1":9007199254750610},{"k2":null},{"k3":9007199254750612},{"k4":9007199254750613},{"k5":null},{"k6":9007199254750615},{"k7":9007199254750616},{"k8":null},{"k9":9007199254750618},{"k10":9007199254750619},{"k11":null},{"k12":9007199254750621},{"k13":9007199254750622},{"k14":null},{"k15":9007199254750624},{"k0":9007199254750625},{"k1":null},{"k2":9007199254750627},{"k3":9007199254750628},{"k4":null},{"k5":9007199254750630},{"k6":9007199254750631},{"k7":null},{"k8":9007199254750633},{"k9":9007199254750634},{"k10":null},{"k11":9007199254750636},{"k12":9007199254750637},{"k13":null},{"k14":9007199254750639},{"k15":9007199254750640},{"k0":null},{"k1":9007199254750642},{"k2":9007199254750643},{"k3":null},{"k4":9007199254750645},{"k5":9007199254750646},{"k6":null},{"k7":9007199254750648},{"k8":9007199254750649},{"k9":null},{"k10":9007199254750651},{"k11":9007199254750652},{"k12":null},{"k13":9007199254750654},{"k14":9007199254750655},{"k15":null},{"k0":9007199254750657},{"k1":9007199254750658},{"k2":null},{"k3":9007199254750660},{"k4":9007199254750661},{"k5":null},{"k6":9007199254750663},{"k7":9007199254750664},{"k8":null},{"k9":9007199254750666},{"k10":9007199254750667},{"k11":null},{"k12":9007199254750669},{"k13":9007199254750670},{"k14":null},{"k15":9007199254750672},{"k0":9007199254750673},{"k1":null},{"k2":9007199254750675},{"k3":9007199254750676},{"k4":null},{"k5":9007199254750678},{"k6":9007199254750679},{"k7":null},{"k8":9007199254750681},{"k9":9007199254750682},{"k10":null},{"k11":9007199254750684},{"k12":9007199254750685},{"k13":null},{"k14":9007199254750687},{"k15":9007199254750688},{"k0":null},{"k1":9007199254750690},{"k2":9007199254750691},{"k3":null},{"k4":9007199254750693},{"k5":9007199254750694},{"k6":null},{"k7":9007199254750696},{"k8":9007199254750697},{"k9":null},{"k10":9007199254750699},{"k11":9007199254750700},{"k12":null},{"k13":9007199254750702},{"k14":9007199254750703},{"k15":null},{"k0":9007199254750705},{"k1":9007199254750706},{"k2":null},{"k3":9007199254750708},{"k4":9007199254750709},{"k5":null},{"k6":9007199254750711},{"k7":9007199254750712},{"k8":null},{"k9":9007199254750714},{"k10":9007199254750715},{"k11":null},{"k12":9007199254750717},{"k13":9007199254750718},{"k14":null},{"k15":9007199254750720},{"k0":9007199254750721},{"k1":null},{"k2":9007199254750723},{"k3":9007199254750724},{"k4":null},{"k5":9007199254750726},{"k6":9007199254750727},{"k7":null},{"k8":9007199254750729},{"k9":9007199254750730},{"k10":null},{"k11":9007199254750732},{"k12":9007199254750733},{"k13":null},{"k14":9007199254750735},{"k15":9007199254750736},{"k0":null},{"k1":9007199254750738},{"k2":9007199254750739},{"k3":null},{"k4":9007199254750741},{"k5":9007199254750742},{"k6":null},{"k7":9007199254750744},{"k8":9007199254750745},{"k9":null},{"k10":9007199254750747},{"k11":9007199254750748},{"k12":null},{"k13":9007199254750750},{"k14":9007199254750751},{"k15":null},{"k0":9007199254750753},{"k1":9007199254750754},{"k2":null},{"k3":9007199254750756},{"k4":9007199254750757},{"k5":null},{"k6":9007199254750759},{"k7":9007199254750760},{"k8":null},{"k9":9007199254750762},{"k10":9007199254750763},{"k11":null},{"k12":9007199254750765},{"k13":9007199254750766},{"k14":null},{"k15":9007199254750768},{"k0":9007199254750769},{"k1":null},{"k2":9007199254750771},{"k3":9007199254750772},{"k4":null},{"k5":9007199254750774},{"k6":9007199254750775},{"k7":null},{"k8":9007199254750777},{"k9":9007199254750778},{"k10":null},{"k11":9007199254750780},{"k12":9007199254750781},{"k13":null},{"k14":9007199254750783},{"k15":9007199254750784},{"k0":null},{"k1":9007199254750786},{"k2":9007199254750787},{"k3":null},{"k4":9007199254750789},{"k5":9007199254750790},{"k6":null},{"k7":9007199254750792},{"k8":9007199254750793},{"k9":null},{"k10":9007199254750795},{"k11":9007199254750796},{"k12":null},{"k13":9007199254750798},{"k14":9007199254750799},{"k15":null},{"k0":9007199254750801},{"k1":9007199254750802},{"k2":null},{"k3":9007199254750804},{"k4":9007199254750805},{"k5":null},{"k6":9007199254750807},{"k7":9007199254750808},{"k8":null},{"k9":9007199254750810},{"k10":9007199254750811},{"k11":null},{"k12":9007199254750813},{"k13":9007199254750814},{"k14":null},{"k15":9007199254750816},{"k0":9007199254750817},{"k1":null},{"k2":9007199254750819},{"k3":9007199254750820},{"k4":null},{"k5":9007199254750822},{"k6":9007199254750823},{"k7":null},{"k8":9007199254750825},{"k9":9007199254750826},{"k10":null},{"k11":9007199254750828},{"k12":9007199254750829},{"k13":null},{"k14":9007199254750831},{"k15":9007199254750832},{"k0":null},{"k1":9007199254750834},{"k2":9007199254750835},{"k3":null},{"k4":9007199254750837},{"k5":9007199254750838},{"k6":null},{"k7":9007199254750840},{"k8":9007199254750841},{"k9":null},{"k10":9007199254750843},{"k11":9007199254750844},{"k12":null},{"k13":9007199254750846},{"k14":9007199254750847},{"k15":null},{"k0":9007199254750849},{"k1":9007199254750850},{"k2":null},{"k3":9007199254750852},{"k4":9007199254750853},{"k5":null},{"k6":9007199254750855},{"k7":9007199254750856},{"k8":null},{"k9":9007199254750858},{"k10":9007199254750859},{"k11":null},{"k12":9007199254750861},{"k13":9007199254750862},{"k14":null},{"k15":9007199254750864},{"k0":9007199254750865},{"k1":null},{"k2":9007199254750867},{"k3":9007199254750868},{"k4":null},{"k5":9007199254750870},{"k6":9007199254750871},{"k7":null},{"k8":9007199254750873},{"k9":9007199254750874},{"k10":null},{"k11":9007199254750876},{"k12":9007199254750877},{"k13":null},{"k14":9007199254750879},{"k15":9007199254750880},{"k0":null},{"k1":9007199254750882},{"k2":9007199254750883},{"k3":null},{"k4":9007199254750885},{"k5":9007199254750886},{"k6":null},{"k7":9007199254750888},{"k8":9007199254750889},{"k9":null},{"k10":9007199254750891},{"k11":9007199254750892},{"k12":null},{"k13":9007199254750894},{"k14":9007199254750895},{"k15":null},{"k0":9007199254750897},{"k1":9007199254750898},{"k2":null},{"k3":9007199254750900},{"k4":9007199254750901},{"k5":null},{"k6":9007199254750903},{"k7":9007199254750904},{"k8":null},{"k9":9007199254750906},{"k10":9007199254750907},{"k11":null},{"k12":9007199254750909},{"k13":9007199254750910},{"k14":null},{"k15":9007199254750912},{"k0":9007199254750913},{"k1":null},{"k2":9007199254750915},{"k3":9007199254750916},{"k4":null},{"k5":9007199254750918},{"k6":9007199254750919},{"k7":null},{"k8":9007199254750921},{"k9":9007199254750922},{"k10":null},{"k11":9007199254750924},{"k12":9007199254750925},{"k13":null},{"k14":9007199254750927},{"k15":9007199254750928},{"k0":null},{"k1":9007199254750930},{"k2":9007199254750931},{"k3":null},{"k4":9007199254750933},{"k5":9007199254750934},{"k6":null},{"k7":9007199254750936},{"k8":9007199254750937},{"k9":null},{"k10":9007199254750939},{"k11":9007199254750940},{"k12":null},{"k13":9007199254750942},{"k14":9007199254750943},{"k15":null},{"k0":9007199254750945},{"k1":9007199254750946},{"k2":null},{"k3":9007199254750948},{"k4":9007199254750949},{"k5":null},{"k6":9007199254750951},{"k7":9007199254750952},{"k8":null},{"k9":9007199254750954},{"k10":9007199254750955},{"k11":null},{"k12":9007199254750957},{"k13":9007199254750958},{"k14":null},{"k15":9007199254750960},{"k0":9007199254750961},{"k1":null},{"k2":9007199254750963},{"k3":9007199254750964},{"k4":null},{"k5":9007199254750966},{"k6":9007199254750967},{"k7":null},{"k8":9007199254750969},{"k9":9007199254750970},{"k10":null},{"k11":9007199254750972},{"k12":9007199254750973},{"k13":null},{"k14":9007199254750975},{"k15":9007199254750976},{"k0":null},{"k1":9007199254750978},{"k2":9007199254750979},{"k3":null},{"k4":9007199254750981},{"k5":9007199254750982},{"k6":null},{"k7":9007199254750984},{"k8":9007199254750985},{"k9":null},{"k10":9007199254750987},{"k11":9007199254750988},{"k12":null},{"k13":9007199254750990},{"k14":9007199254750991},{"k15":null}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/sparse-1024.json b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-1024.json new file mode 100644 index 0000000..7bba458 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-1024.json @@ -0,0 +1 @@ +[{"k0":null},{"k1":9007199254740994},{"k2":9007199254740995},{"k3":null},{"k4":9007199254740997},{"k5":9007199254740998},{"k6":null},{"k7":9007199254741000},{"k8":9007199254741001},{"k9":null},{"k10":9007199254741003},{"k11":9007199254741004},{"k12":null},{"k13":9007199254741006},{"k14":9007199254741007},{"k15":null},{"k0":9007199254741009},{"k1":9007199254741010},{"k2":null},{"k3":9007199254741012},{"k4":9007199254741013},{"k5":null},{"k6":9007199254741015},{"k7":9007199254741016},{"k8":null},{"k9":9007199254741018},{"k10":9007199254741019},{"k11":null},{"k12":9007199254741021},{"k13":9007199254741022},{"k14":null},{"k15":9007199254741024},{"k0":9007199254741025},{"k1":null},{"k2":9007199254741027},{"k3":9007199254741028},{"k4":null},{"k5":9007199254741030},{"k6":9007199254741031},{"k7":null},{"k8":9007199254741033},{"k9":9007199254741034},{"k10":null},{"k11":9007199254741036},{"k12":9007199254741037},{"k13":null},{"k14":9007199254741039},{"k15":9007199254741040},{"k0":null},{"k1":9007199254741042},{"k2":9007199254741043},{"k3":null},{"k4":9007199254741045},{"k5":9007199254741046},{"k6":null},{"k7":9007199254741048},{"k8":9007199254741049},{"k9":null},{"k10":9007199254741051},{"k11":9007199254741052},{"k12":null},{"k13":9007199254741054},{"k14":9007199254741055},{"k15":null},{"k0":9007199254741057},{"k1":9007199254741058},{"k2":null},{"k3":9007199254741060},{"k4":9007199254741061},{"k5":null},{"k6":9007199254741063},{"k7":9007199254741064},{"k8":null},{"k9":9007199254741066},{"k10":9007199254741067},{"k11":null},{"k12":9007199254741069},{"k13":9007199254741070},{"k14":null},{"k15":9007199254741072},{"k0":9007199254741073},{"k1":null},{"k2":9007199254741075},{"k3":9007199254741076},{"k4":null},{"k5":9007199254741078},{"k6":9007199254741079},{"k7":null},{"k8":9007199254741081},{"k9":9007199254741082},{"k10":null},{"k11":9007199254741084},{"k12":9007199254741085},{"k13":null},{"k14":9007199254741087},{"k15":9007199254741088},{"k0":null},{"k1":9007199254741090},{"k2":9007199254741091},{"k3":null},{"k4":9007199254741093},{"k5":9007199254741094},{"k6":null},{"k7":9007199254741096},{"k8":9007199254741097},{"k9":null},{"k10":9007199254741099},{"k11":9007199254741100},{"k12":null},{"k13":9007199254741102},{"k14":9007199254741103},{"k15":null},{"k0":9007199254741105},{"k1":9007199254741106},{"k2":null},{"k3":9007199254741108},{"k4":9007199254741109},{"k5":null},{"k6":9007199254741111},{"k7":9007199254741112},{"k8":null},{"k9":9007199254741114},{"k10":9007199254741115},{"k11":null},{"k12":9007199254741117},{"k13":9007199254741118},{"k14":null},{"k15":9007199254741120},{"k0":9007199254741121},{"k1":null},{"k2":9007199254741123},{"k3":9007199254741124},{"k4":null},{"k5":9007199254741126},{"k6":9007199254741127},{"k7":null},{"k8":9007199254741129},{"k9":9007199254741130},{"k10":null},{"k11":9007199254741132},{"k12":9007199254741133},{"k13":null},{"k14":9007199254741135},{"k15":9007199254741136},{"k0":null},{"k1":9007199254741138},{"k2":9007199254741139},{"k3":null},{"k4":9007199254741141},{"k5":9007199254741142},{"k6":null},{"k7":9007199254741144},{"k8":9007199254741145},{"k9":null},{"k10":9007199254741147},{"k11":9007199254741148},{"k12":null},{"k13":9007199254741150},{"k14":9007199254741151},{"k15":null},{"k0":9007199254741153},{"k1":9007199254741154},{"k2":null},{"k3":9007199254741156},{"k4":9007199254741157},{"k5":null},{"k6":9007199254741159},{"k7":9007199254741160},{"k8":null},{"k9":9007199254741162},{"k10":9007199254741163},{"k11":null},{"k12":9007199254741165},{"k13":9007199254741166},{"k14":null},{"k15":9007199254741168},{"k0":9007199254741169},{"k1":null},{"k2":9007199254741171},{"k3":9007199254741172},{"k4":null},{"k5":9007199254741174},{"k6":9007199254741175},{"k7":null},{"k8":9007199254741177},{"k9":9007199254741178},{"k10":null},{"k11":9007199254741180},{"k12":9007199254741181},{"k13":null},{"k14":9007199254741183},{"k15":9007199254741184},{"k0":null},{"k1":9007199254741186},{"k2":9007199254741187},{"k3":null},{"k4":9007199254741189},{"k5":9007199254741190},{"k6":null},{"k7":9007199254741192},{"k8":9007199254741193},{"k9":null},{"k10":9007199254741195},{"k11":9007199254741196},{"k12":null},{"k13":9007199254741198},{"k14":9007199254741199},{"k15":null},{"k0":9007199254741201},{"k1":9007199254741202},{"k2":null},{"k3":9007199254741204},{"k4":9007199254741205},{"k5":null},{"k6":9007199254741207},{"k7":9007199254741208},{"k8":null},{"k9":9007199254741210},{"k10":9007199254741211},{"k11":null},{"k12":9007199254741213},{"k13":9007199254741214},{"k14":null},{"k15":9007199254741216},{"k0":9007199254741217},{"k1":null},{"k2":9007199254741219},{"k3":9007199254741220},{"k4":null},{"k5":9007199254741222},{"k6":9007199254741223},{"k7":null},{"k8":9007199254741225},{"k9":9007199254741226},{"k10":null},{"k11":9007199254741228},{"k12":9007199254741229},{"k13":null},{"k14":9007199254741231},{"k15":9007199254741232},{"k0":null},{"k1":9007199254741234},{"k2":9007199254741235},{"k3":null},{"k4":9007199254741237},{"k5":9007199254741238},{"k6":null},{"k7":9007199254741240},{"k8":9007199254741241},{"k9":null},{"k10":9007199254741243},{"k11":9007199254741244},{"k12":null},{"k13":9007199254741246},{"k14":9007199254741247},{"k15":null},{"k0":9007199254741249},{"k1":9007199254741250},{"k2":null},{"k3":9007199254741252},{"k4":9007199254741253},{"k5":null},{"k6":9007199254741255},{"k7":9007199254741256},{"k8":null},{"k9":9007199254741258},{"k10":9007199254741259},{"k11":null},{"k12":9007199254741261},{"k13":9007199254741262},{"k14":null},{"k15":9007199254741264},{"k0":9007199254741265},{"k1":null},{"k2":9007199254741267},{"k3":9007199254741268},{"k4":null},{"k5":9007199254741270},{"k6":9007199254741271},{"k7":null},{"k8":9007199254741273},{"k9":9007199254741274},{"k10":null},{"k11":9007199254741276},{"k12":9007199254741277},{"k13":null},{"k14":9007199254741279},{"k15":9007199254741280},{"k0":null},{"k1":9007199254741282},{"k2":9007199254741283},{"k3":null},{"k4":9007199254741285},{"k5":9007199254741286},{"k6":null},{"k7":9007199254741288},{"k8":9007199254741289},{"k9":null},{"k10":9007199254741291},{"k11":9007199254741292},{"k12":null},{"k13":9007199254741294},{"k14":9007199254741295},{"k15":null},{"k0":9007199254741297},{"k1":9007199254741298},{"k2":null},{"k3":9007199254741300},{"k4":9007199254741301},{"k5":null},{"k6":9007199254741303},{"k7":9007199254741304},{"k8":null},{"k9":9007199254741306},{"k10":9007199254741307},{"k11":null},{"k12":9007199254741309},{"k13":9007199254741310},{"k14":null},{"k15":9007199254741312},{"k0":9007199254741313},{"k1":null},{"k2":9007199254741315},{"k3":9007199254741316},{"k4":null},{"k5":9007199254741318},{"k6":9007199254741319},{"k7":null},{"k8":9007199254741321},{"k9":9007199254741322},{"k10":null},{"k11":9007199254741324},{"k12":9007199254741325},{"k13":null},{"k14":9007199254741327},{"k15":9007199254741328},{"k0":null},{"k1":9007199254741330},{"k2":9007199254741331},{"k3":null},{"k4":9007199254741333},{"k5":9007199254741334},{"k6":null},{"k7":9007199254741336},{"k8":9007199254741337},{"k9":null},{"k10":9007199254741339},{"k11":9007199254741340},{"k12":null},{"k13":9007199254741342},{"k14":9007199254741343},{"k15":null},{"k0":9007199254741345},{"k1":9007199254741346},{"k2":null},{"k3":9007199254741348},{"k4":9007199254741349},{"k5":null},{"k6":9007199254741351},{"k7":9007199254741352},{"k8":null},{"k9":9007199254741354},{"k10":9007199254741355},{"k11":null},{"k12":9007199254741357},{"k13":9007199254741358},{"k14":null},{"k15":9007199254741360},{"k0":9007199254741361},{"k1":null},{"k2":9007199254741363},{"k3":9007199254741364},{"k4":null},{"k5":9007199254741366},{"k6":9007199254741367},{"k7":null},{"k8":9007199254741369},{"k9":9007199254741370},{"k10":null},{"k11":9007199254741372},{"k12":9007199254741373},{"k13":null},{"k14":9007199254741375},{"k15":9007199254741376},{"k0":null},{"k1":9007199254741378},{"k2":9007199254741379},{"k3":null},{"k4":9007199254741381},{"k5":9007199254741382},{"k6":null},{"k7":9007199254741384},{"k8":9007199254741385},{"k9":null},{"k10":9007199254741387},{"k11":9007199254741388},{"k12":null},{"k13":9007199254741390},{"k14":9007199254741391},{"k15":null},{"k0":9007199254741393},{"k1":9007199254741394},{"k2":null},{"k3":9007199254741396},{"k4":9007199254741397},{"k5":null},{"k6":9007199254741399},{"k7":9007199254741400},{"k8":null},{"k9":9007199254741402},{"k10":9007199254741403},{"k11":null},{"k12":9007199254741405},{"k13":9007199254741406},{"k14":null},{"k15":9007199254741408},{"k0":9007199254741409},{"k1":null},{"k2":9007199254741411},{"k3":9007199254741412},{"k4":null},{"k5":9007199254741414},{"k6":9007199254741415},{"k7":null},{"k8":9007199254741417},{"k9":9007199254741418},{"k10":null},{"k11":9007199254741420},{"k12":9007199254741421},{"k13":null},{"k14":9007199254741423},{"k15":9007199254741424},{"k0":null},{"k1":9007199254741426},{"k2":9007199254741427},{"k3":null},{"k4":9007199254741429},{"k5":9007199254741430},{"k6":null},{"k7":9007199254741432},{"k8":9007199254741433},{"k9":null},{"k10":9007199254741435},{"k11":9007199254741436},{"k12":null},{"k13":9007199254741438},{"k14":9007199254741439},{"k15":null},{"k0":9007199254741441},{"k1":9007199254741442},{"k2":null},{"k3":9007199254741444},{"k4":9007199254741445},{"k5":null},{"k6":9007199254741447},{"k7":9007199254741448},{"k8":null},{"k9":9007199254741450},{"k10":9007199254741451},{"k11":null},{"k12":9007199254741453},{"k13":9007199254741454},{"k14":null},{"k15":9007199254741456},{"k0":9007199254741457},{"k1":null},{"k2":9007199254741459},{"k3":9007199254741460},{"k4":null},{"k5":9007199254741462},{"k6":9007199254741463},{"k7":null},{"k8":9007199254741465},{"k9":9007199254741466},{"k10":null},{"k11":9007199254741468},{"k12":9007199254741469},{"k13":null},{"k14":9007199254741471},{"k15":9007199254741472},{"k0":null},{"k1":9007199254741474},{"k2":9007199254741475},{"k3":null},{"k4":9007199254741477},{"k5":9007199254741478},{"k6":null},{"k7":9007199254741480},{"k8":9007199254741481},{"k9":null},{"k10":9007199254741483},{"k11":9007199254741484},{"k12":null},{"k13":9007199254741486},{"k14":9007199254741487},{"k15":null},{"k0":9007199254741489},{"k1":9007199254741490},{"k2":null},{"k3":9007199254741492},{"k4":9007199254741493},{"k5":null},{"k6":9007199254741495},{"k7":9007199254741496},{"k8":null},{"k9":9007199254741498},{"k10":9007199254741499},{"k11":null},{"k12":9007199254741501},{"k13":9007199254741502},{"k14":null},{"k15":9007199254741504},{"k0":9007199254741505},{"k1":null},{"k2":9007199254741507},{"k3":9007199254741508},{"k4":null},{"k5":9007199254741510},{"k6":9007199254741511},{"k7":null},{"k8":9007199254741513},{"k9":9007199254741514},{"k10":null},{"k11":9007199254741516},{"k12":9007199254741517},{"k13":null},{"k14":9007199254741519},{"k15":9007199254741520},{"k0":null},{"k1":9007199254741522},{"k2":9007199254741523},{"k3":null},{"k4":9007199254741525},{"k5":9007199254741526},{"k6":null},{"k7":9007199254741528},{"k8":9007199254741529},{"k9":null},{"k10":9007199254741531},{"k11":9007199254741532},{"k12":null},{"k13":9007199254741534},{"k14":9007199254741535},{"k15":null},{"k0":9007199254741537},{"k1":9007199254741538},{"k2":null},{"k3":9007199254741540},{"k4":9007199254741541},{"k5":null},{"k6":9007199254741543},{"k7":9007199254741544},{"k8":null},{"k9":9007199254741546},{"k10":9007199254741547},{"k11":null},{"k12":9007199254741549},{"k13":9007199254741550},{"k14":null},{"k15":9007199254741552},{"k0":9007199254741553},{"k1":null},{"k2":9007199254741555},{"k3":9007199254741556},{"k4":null},{"k5":9007199254741558},{"k6":9007199254741559},{"k7":null},{"k8":9007199254741561},{"k9":9007199254741562},{"k10":null},{"k11":9007199254741564},{"k12":9007199254741565},{"k13":null},{"k14":9007199254741567},{"k15":9007199254741568},{"k0":null},{"k1":9007199254741570},{"k2":9007199254741571},{"k3":null},{"k4":9007199254741573},{"k5":9007199254741574},{"k6":null},{"k7":9007199254741576},{"k8":9007199254741577},{"k9":null},{"k10":9007199254741579},{"k11":9007199254741580},{"k12":null},{"k13":9007199254741582},{"k14":9007199254741583},{"k15":null},{"k0":9007199254741585},{"k1":9007199254741586},{"k2":null},{"k3":9007199254741588},{"k4":9007199254741589},{"k5":null},{"k6":9007199254741591},{"k7":9007199254741592},{"k8":null},{"k9":9007199254741594},{"k10":9007199254741595},{"k11":null},{"k12":9007199254741597},{"k13":9007199254741598},{"k14":null},{"k15":9007199254741600},{"k0":9007199254741601},{"k1":null},{"k2":9007199254741603},{"k3":9007199254741604},{"k4":null},{"k5":9007199254741606},{"k6":9007199254741607},{"k7":null},{"k8":9007199254741609},{"k9":9007199254741610},{"k10":null},{"k11":9007199254741612},{"k12":9007199254741613},{"k13":null},{"k14":9007199254741615},{"k15":9007199254741616},{"k0":null},{"k1":9007199254741618},{"k2":9007199254741619},{"k3":null},{"k4":9007199254741621},{"k5":9007199254741622},{"k6":null},{"k7":9007199254741624},{"k8":9007199254741625},{"k9":null},{"k10":9007199254741627},{"k11":9007199254741628},{"k12":null},{"k13":9007199254741630},{"k14":9007199254741631},{"k15":null},{"k0":9007199254741633},{"k1":9007199254741634},{"k2":null},{"k3":9007199254741636},{"k4":9007199254741637},{"k5":null},{"k6":9007199254741639},{"k7":9007199254741640},{"k8":null},{"k9":9007199254741642},{"k10":9007199254741643},{"k11":null},{"k12":9007199254741645},{"k13":9007199254741646},{"k14":null},{"k15":9007199254741648},{"k0":9007199254741649},{"k1":null},{"k2":9007199254741651},{"k3":9007199254741652},{"k4":null},{"k5":9007199254741654},{"k6":9007199254741655},{"k7":null},{"k8":9007199254741657},{"k9":9007199254741658},{"k10":null},{"k11":9007199254741660},{"k12":9007199254741661},{"k13":null},{"k14":9007199254741663},{"k15":9007199254741664},{"k0":null},{"k1":9007199254741666},{"k2":9007199254741667},{"k3":null},{"k4":9007199254741669},{"k5":9007199254741670},{"k6":null},{"k7":9007199254741672},{"k8":9007199254741673},{"k9":null},{"k10":9007199254741675},{"k11":9007199254741676},{"k12":null},{"k13":9007199254741678},{"k14":9007199254741679},{"k15":null},{"k0":9007199254741681},{"k1":9007199254741682},{"k2":null},{"k3":9007199254741684},{"k4":9007199254741685},{"k5":null},{"k6":9007199254741687},{"k7":9007199254741688},{"k8":null},{"k9":9007199254741690},{"k10":9007199254741691},{"k11":null},{"k12":9007199254741693},{"k13":9007199254741694},{"k14":null},{"k15":9007199254741696},{"k0":9007199254741697},{"k1":null},{"k2":9007199254741699},{"k3":9007199254741700},{"k4":null},{"k5":9007199254741702},{"k6":9007199254741703},{"k7":null},{"k8":9007199254741705},{"k9":9007199254741706},{"k10":null},{"k11":9007199254741708},{"k12":9007199254741709},{"k13":null},{"k14":9007199254741711},{"k15":9007199254741712},{"k0":null},{"k1":9007199254741714},{"k2":9007199254741715},{"k3":null},{"k4":9007199254741717},{"k5":9007199254741718},{"k6":null},{"k7":9007199254741720},{"k8":9007199254741721},{"k9":null},{"k10":9007199254741723},{"k11":9007199254741724},{"k12":null},{"k13":9007199254741726},{"k14":9007199254741727},{"k15":null},{"k0":9007199254741729},{"k1":9007199254741730},{"k2":null},{"k3":9007199254741732},{"k4":9007199254741733},{"k5":null},{"k6":9007199254741735},{"k7":9007199254741736},{"k8":null},{"k9":9007199254741738},{"k10":9007199254741739},{"k11":null},{"k12":9007199254741741},{"k13":9007199254741742},{"k14":null},{"k15":9007199254741744},{"k0":9007199254741745},{"k1":null},{"k2":9007199254741747},{"k3":9007199254741748},{"k4":null},{"k5":9007199254741750},{"k6":9007199254741751},{"k7":null},{"k8":9007199254741753},{"k9":9007199254741754},{"k10":null},{"k11":9007199254741756},{"k12":9007199254741757},{"k13":null},{"k14":9007199254741759},{"k15":9007199254741760},{"k0":null},{"k1":9007199254741762},{"k2":9007199254741763},{"k3":null},{"k4":9007199254741765},{"k5":9007199254741766},{"k6":null},{"k7":9007199254741768},{"k8":9007199254741769},{"k9":null},{"k10":9007199254741771},{"k11":9007199254741772},{"k12":null},{"k13":9007199254741774},{"k14":9007199254741775},{"k15":null},{"k0":9007199254741777},{"k1":9007199254741778},{"k2":null},{"k3":9007199254741780},{"k4":9007199254741781},{"k5":null},{"k6":9007199254741783},{"k7":9007199254741784},{"k8":null},{"k9":9007199254741786},{"k10":9007199254741787},{"k11":null},{"k12":9007199254741789},{"k13":9007199254741790},{"k14":null},{"k15":9007199254741792},{"k0":9007199254741793},{"k1":null},{"k2":9007199254741795},{"k3":9007199254741796},{"k4":null},{"k5":9007199254741798},{"k6":9007199254741799},{"k7":null},{"k8":9007199254741801},{"k9":9007199254741802},{"k10":null},{"k11":9007199254741804},{"k12":9007199254741805},{"k13":null},{"k14":9007199254741807},{"k15":9007199254741808},{"k0":null},{"k1":9007199254741810},{"k2":9007199254741811},{"k3":null},{"k4":9007199254741813},{"k5":9007199254741814},{"k6":null},{"k7":9007199254741816},{"k8":9007199254741817},{"k9":null},{"k10":9007199254741819},{"k11":9007199254741820},{"k12":null},{"k13":9007199254741822},{"k14":9007199254741823},{"k15":null},{"k0":9007199254741825},{"k1":9007199254741826},{"k2":null},{"k3":9007199254741828},{"k4":9007199254741829},{"k5":null},{"k6":9007199254741831},{"k7":9007199254741832},{"k8":null},{"k9":9007199254741834},{"k10":9007199254741835},{"k11":null},{"k12":9007199254741837},{"k13":9007199254741838},{"k14":null},{"k15":9007199254741840},{"k0":9007199254741841},{"k1":null},{"k2":9007199254741843},{"k3":9007199254741844},{"k4":null},{"k5":9007199254741846},{"k6":9007199254741847},{"k7":null},{"k8":9007199254741849},{"k9":9007199254741850},{"k10":null},{"k11":9007199254741852},{"k12":9007199254741853},{"k13":null},{"k14":9007199254741855},{"k15":9007199254741856},{"k0":null},{"k1":9007199254741858},{"k2":9007199254741859},{"k3":null},{"k4":9007199254741861},{"k5":9007199254741862},{"k6":null},{"k7":9007199254741864},{"k8":9007199254741865},{"k9":null},{"k10":9007199254741867},{"k11":9007199254741868},{"k12":null},{"k13":9007199254741870},{"k14":9007199254741871},{"k15":null},{"k0":9007199254741873},{"k1":9007199254741874},{"k2":null},{"k3":9007199254741876},{"k4":9007199254741877},{"k5":null},{"k6":9007199254741879},{"k7":9007199254741880},{"k8":null},{"k9":9007199254741882},{"k10":9007199254741883},{"k11":null},{"k12":9007199254741885},{"k13":9007199254741886},{"k14":null},{"k15":9007199254741888},{"k0":9007199254741889},{"k1":null},{"k2":9007199254741891},{"k3":9007199254741892},{"k4":null},{"k5":9007199254741894},{"k6":9007199254741895},{"k7":null},{"k8":9007199254741897},{"k9":9007199254741898},{"k10":null},{"k11":9007199254741900},{"k12":9007199254741901},{"k13":null},{"k14":9007199254741903},{"k15":9007199254741904},{"k0":null},{"k1":9007199254741906},{"k2":9007199254741907},{"k3":null},{"k4":9007199254741909},{"k5":9007199254741910},{"k6":null},{"k7":9007199254741912},{"k8":9007199254741913},{"k9":null},{"k10":9007199254741915},{"k11":9007199254741916},{"k12":null},{"k13":9007199254741918},{"k14":9007199254741919},{"k15":null},{"k0":9007199254741921},{"k1":9007199254741922},{"k2":null},{"k3":9007199254741924},{"k4":9007199254741925},{"k5":null},{"k6":9007199254741927},{"k7":9007199254741928},{"k8":null},{"k9":9007199254741930},{"k10":9007199254741931},{"k11":null},{"k12":9007199254741933},{"k13":9007199254741934},{"k14":null},{"k15":9007199254741936},{"k0":9007199254741937},{"k1":null},{"k2":9007199254741939},{"k3":9007199254741940},{"k4":null},{"k5":9007199254741942},{"k6":9007199254741943},{"k7":null},{"k8":9007199254741945},{"k9":9007199254741946},{"k10":null},{"k11":9007199254741948},{"k12":9007199254741949},{"k13":null},{"k14":9007199254741951},{"k15":9007199254741952},{"k0":null},{"k1":9007199254741954},{"k2":9007199254741955},{"k3":null},{"k4":9007199254741957},{"k5":9007199254741958},{"k6":null},{"k7":9007199254741960},{"k8":9007199254741961},{"k9":null},{"k10":9007199254741963},{"k11":9007199254741964},{"k12":null},{"k13":9007199254741966},{"k14":9007199254741967},{"k15":null},{"k0":9007199254741969},{"k1":9007199254741970},{"k2":null},{"k3":9007199254741972},{"k4":9007199254741973},{"k5":null},{"k6":9007199254741975},{"k7":9007199254741976},{"k8":null},{"k9":9007199254741978},{"k10":9007199254741979},{"k11":null},{"k12":9007199254741981},{"k13":9007199254741982},{"k14":null},{"k15":9007199254741984},{"k0":9007199254741985},{"k1":null},{"k2":9007199254741987},{"k3":9007199254741988},{"k4":null},{"k5":9007199254741990},{"k6":9007199254741991},{"k7":null},{"k8":9007199254741993},{"k9":9007199254741994},{"k10":null},{"k11":9007199254741996},{"k12":9007199254741997},{"k13":null},{"k14":9007199254741999},{"k15":9007199254742000},{"k0":null},{"k1":9007199254742002},{"k2":9007199254742003},{"k3":null},{"k4":9007199254742005},{"k5":9007199254742006},{"k6":null},{"k7":9007199254742008},{"k8":9007199254742009},{"k9":null},{"k10":9007199254742011},{"k11":9007199254742012},{"k12":null},{"k13":9007199254742014},{"k14":9007199254742015},{"k15":null}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/sparse-16.json b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-16.json new file mode 100644 index 0000000..04541cb --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/sparse-16.json @@ -0,0 +1 @@ +[{"k0":null},{"k1":9007199254740994},{"k2":9007199254740995},{"k3":null},{"k4":9007199254740997},{"k5":9007199254740998},{"k6":null},{"k7":9007199254741000},{"k8":9007199254741001},{"k9":null},{"k10":9007199254741003},{"k11":9007199254741004},{"k12":null},{"k13":9007199254741006},{"k14":9007199254741007},{"k15":null}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-complete.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-complete.json new file mode 100644 index 0000000..a5bb11a --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-complete.json @@ -0,0 +1 @@ +[{"n":9007199254740993,"price":0.0100,"é":null},{"e\u0301":"accent","n":9007199254740993},{"n":0.1,"nest":[null,{"0":4}]}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-duplicate-keys.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-duplicate-keys.json new file mode 100644 index 0000000..5318a8e --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-duplicate-keys.json @@ -0,0 +1 @@ +[{"a":1,"a":2}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-empty-objects.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-empty-objects.json new file mode 100644 index 0000000..76418be --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-empty-objects.json @@ -0,0 +1 @@ +[{},{}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-empty.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-empty.json new file mode 100644 index 0000000..fe51488 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-empty.json @@ -0,0 +1 @@ +[] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-equal-rows.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-equal-rows.json new file mode 100644 index 0000000..31dc802 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-equal-rows.json @@ -0,0 +1 @@ +[{"a":1},{"a":1}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-late-invalid.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-late-invalid.json new file mode 100644 index 0000000..2f558d9 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-late-invalid.json @@ -0,0 +1 @@ +[{"a":1},{"a":2},false] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-nested.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-nested.json new file mode 100644 index 0000000..98b2c0a --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-nested.json @@ -0,0 +1 @@ +[{"x":[1,2],"y":{"0":"key"}},{"x":null}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-nonobject.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-nonobject.json new file mode 100644 index 0000000..62864b3 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-nonobject.json @@ -0,0 +1 @@ +[null] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-numeric-keys.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-numeric-keys.json new file mode 100644 index 0000000..2621cfb --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-numeric-keys.json @@ -0,0 +1 @@ +[{"0":1},{"0":2}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/table-unicode.json b/Tests/JSONInspectionTests/ProjectionFixtures/table-unicode.json new file mode 100644 index 0000000..fe2c563 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/table-unicode.json @@ -0,0 +1 @@ +[{"é":null,"e\u0301":1},{"e\u0301":2}] diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/tree-nested.json b/Tests/JSONInspectionTests/ProjectionFixtures/tree-nested.json new file mode 100644 index 0000000..a711409 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/tree-nested.json @@ -0,0 +1 @@ +{"tree":{"left":{"leaf":1},"right":[2,{"leaf":3}]},"empty":[]} diff --git a/Tests/JSONInspectionTests/ProjectionFixtures/wide-1024.json b/Tests/JSONInspectionTests/ProjectionFixtures/wide-1024.json new file mode 100644 index 0000000..4b5a529 --- /dev/null +++ b/Tests/JSONInspectionTests/ProjectionFixtures/wide-1024.json @@ -0,0 +1 @@ +{"w0":0,"w1":1,"w2":2,"w3":3,"w4":4,"w5":5,"w6":6,"w7":7,"w8":8,"w9":9,"w10":10,"w11":11,"w12":12,"w13":13,"w14":14,"w15":15,"w16":16,"w17":17,"w18":18,"w19":19,"w20":20,"w21":21,"w22":22,"w23":23,"w24":24,"w25":25,"w26":26,"w27":27,"w28":28,"w29":29,"w30":30,"w31":31,"w32":32,"w33":33,"w34":34,"w35":35,"w36":36,"w37":37,"w38":38,"w39":39,"w40":40,"w41":41,"w42":42,"w43":43,"w44":44,"w45":45,"w46":46,"w47":47,"w48":48,"w49":49,"w50":50,"w51":51,"w52":52,"w53":53,"w54":54,"w55":55,"w56":56,"w57":57,"w58":58,"w59":59,"w60":60,"w61":61,"w62":62,"w63":63,"w64":64,"w65":65,"w66":66,"w67":67,"w68":68,"w69":69,"w70":70,"w71":71,"w72":72,"w73":73,"w74":74,"w75":75,"w76":76,"w77":77,"w78":78,"w79":79,"w80":80,"w81":81,"w82":82,"w83":83,"w84":84,"w85":85,"w86":86,"w87":87,"w88":88,"w89":89,"w90":90,"w91":91,"w92":92,"w93":93,"w94":94,"w95":95,"w96":96,"w97":97,"w98":98,"w99":99,"w100":100,"w101":101,"w102":102,"w103":103,"w104":104,"w105":105,"w106":106,"w107":107,"w108":108,"w109":109,"w110":110,"w111":111,"w112":112,"w113":113,"w114":114,"w115":115,"w116":116,"w117":117,"w118":118,"w119":119,"w120":120,"w121":121,"w122":122,"w123":123,"w124":124,"w125":125,"w126":126,"w127":127,"w128":128,"w129":129,"w130":130,"w131":131,"w132":132,"w133":133,"w134":134,"w135":135,"w136":136,"w137":137,"w138":138,"w139":139,"w140":140,"w141":141,"w142":142,"w143":143,"w144":144,"w145":145,"w146":146,"w147":147,"w148":148,"w149":149,"w150":150,"w151":151,"w152":152,"w153":153,"w154":154,"w155":155,"w156":156,"w157":157,"w158":158,"w159":159,"w160":160,"w161":161,"w162":162,"w163":163,"w164":164,"w165":165,"w166":166,"w167":167,"w168":168,"w169":169,"w170":170,"w171":171,"w172":172,"w173":173,"w174":174,"w175":175,"w176":176,"w177":177,"w178":178,"w179":179,"w180":180,"w181":181,"w182":182,"w183":183,"w184":184,"w185":185,"w186":186,"w187":187,"w188":188,"w189":189,"w190":190,"w191":191,"w192":192,"w193":193,"w194":194,"w195":195,"w196":196,"w197":197,"w198":198,"w199":199,"w200":200,"w201":201,"w202":202,"w203":203,"w204":204,"w205":205,"w206":206,"w207":207,"w208":208,"w209":209,"w210":210,"w211":211,"w212":212,"w213":213,"w214":214,"w215":215,"w216":216,"w217":217,"w218":218,"w219":219,"w220":220,"w221":221,"w222":222,"w223":223,"w224":224,"w225":225,"w226":226,"w227":227,"w228":228,"w229":229,"w230":230,"w231":231,"w232":232,"w233":233,"w234":234,"w235":235,"w236":236,"w237":237,"w238":238,"w239":239,"w240":240,"w241":241,"w242":242,"w243":243,"w244":244,"w245":245,"w246":246,"w247":247,"w248":248,"w249":249,"w250":250,"w251":251,"w252":252,"w253":253,"w254":254,"w255":255,"w256":256,"w257":257,"w258":258,"w259":259,"w260":260,"w261":261,"w262":262,"w263":263,"w264":264,"w265":265,"w266":266,"w267":267,"w268":268,"w269":269,"w270":270,"w271":271,"w272":272,"w273":273,"w274":274,"w275":275,"w276":276,"w277":277,"w278":278,"w279":279,"w280":280,"w281":281,"w282":282,"w283":283,"w284":284,"w285":285,"w286":286,"w287":287,"w288":288,"w289":289,"w290":290,"w291":291,"w292":292,"w293":293,"w294":294,"w295":295,"w296":296,"w297":297,"w298":298,"w299":299,"w300":300,"w301":301,"w302":302,"w303":303,"w304":304,"w305":305,"w306":306,"w307":307,"w308":308,"w309":309,"w310":310,"w311":311,"w312":312,"w313":313,"w314":314,"w315":315,"w316":316,"w317":317,"w318":318,"w319":319,"w320":320,"w321":321,"w322":322,"w323":323,"w324":324,"w325":325,"w326":326,"w327":327,"w328":328,"w329":329,"w330":330,"w331":331,"w332":332,"w333":333,"w334":334,"w335":335,"w336":336,"w337":337,"w338":338,"w339":339,"w340":340,"w341":341,"w342":342,"w343":343,"w344":344,"w345":345,"w346":346,"w347":347,"w348":348,"w349":349,"w350":350,"w351":351,"w352":352,"w353":353,"w354":354,"w355":355,"w356":356,"w357":357,"w358":358,"w359":359,"w360":360,"w361":361,"w362":362,"w363":363,"w364":364,"w365":365,"w366":366,"w367":367,"w368":368,"w369":369,"w370":370,"w371":371,"w372":372,"w373":373,"w374":374,"w375":375,"w376":376,"w377":377,"w378":378,"w379":379,"w380":380,"w381":381,"w382":382,"w383":383,"w384":384,"w385":385,"w386":386,"w387":387,"w388":388,"w389":389,"w390":390,"w391":391,"w392":392,"w393":393,"w394":394,"w395":395,"w396":396,"w397":397,"w398":398,"w399":399,"w400":400,"w401":401,"w402":402,"w403":403,"w404":404,"w405":405,"w406":406,"w407":407,"w408":408,"w409":409,"w410":410,"w411":411,"w412":412,"w413":413,"w414":414,"w415":415,"w416":416,"w417":417,"w418":418,"w419":419,"w420":420,"w421":421,"w422":422,"w423":423,"w424":424,"w425":425,"w426":426,"w427":427,"w428":428,"w429":429,"w430":430,"w431":431,"w432":432,"w433":433,"w434":434,"w435":435,"w436":436,"w437":437,"w438":438,"w439":439,"w440":440,"w441":441,"w442":442,"w443":443,"w444":444,"w445":445,"w446":446,"w447":447,"w448":448,"w449":449,"w450":450,"w451":451,"w452":452,"w453":453,"w454":454,"w455":455,"w456":456,"w457":457,"w458":458,"w459":459,"w460":460,"w461":461,"w462":462,"w463":463,"w464":464,"w465":465,"w466":466,"w467":467,"w468":468,"w469":469,"w470":470,"w471":471,"w472":472,"w473":473,"w474":474,"w475":475,"w476":476,"w477":477,"w478":478,"w479":479,"w480":480,"w481":481,"w482":482,"w483":483,"w484":484,"w485":485,"w486":486,"w487":487,"w488":488,"w489":489,"w490":490,"w491":491,"w492":492,"w493":493,"w494":494,"w495":495,"w496":496,"w497":497,"w498":498,"w499":499,"w500":500,"w501":501,"w502":502,"w503":503,"w504":504,"w505":505,"w506":506,"w507":507,"w508":508,"w509":509,"w510":510,"w511":511,"w512":512,"w513":513,"w514":514,"w515":515,"w516":516,"w517":517,"w518":518,"w519":519,"w520":520,"w521":521,"w522":522,"w523":523,"w524":524,"w525":525,"w526":526,"w527":527,"w528":528,"w529":529,"w530":530,"w531":531,"w532":532,"w533":533,"w534":534,"w535":535,"w536":536,"w537":537,"w538":538,"w539":539,"w540":540,"w541":541,"w542":542,"w543":543,"w544":544,"w545":545,"w546":546,"w547":547,"w548":548,"w549":549,"w550":550,"w551":551,"w552":552,"w553":553,"w554":554,"w555":555,"w556":556,"w557":557,"w558":558,"w559":559,"w560":560,"w561":561,"w562":562,"w563":563,"w564":564,"w565":565,"w566":566,"w567":567,"w568":568,"w569":569,"w570":570,"w571":571,"w572":572,"w573":573,"w574":574,"w575":575,"w576":576,"w577":577,"w578":578,"w579":579,"w580":580,"w581":581,"w582":582,"w583":583,"w584":584,"w585":585,"w586":586,"w587":587,"w588":588,"w589":589,"w590":590,"w591":591,"w592":592,"w593":593,"w594":594,"w595":595,"w596":596,"w597":597,"w598":598,"w599":599,"w600":600,"w601":601,"w602":602,"w603":603,"w604":604,"w605":605,"w606":606,"w607":607,"w608":608,"w609":609,"w610":610,"w611":611,"w612":612,"w613":613,"w614":614,"w615":615,"w616":616,"w617":617,"w618":618,"w619":619,"w620":620,"w621":621,"w622":622,"w623":623,"w624":624,"w625":625,"w626":626,"w627":627,"w628":628,"w629":629,"w630":630,"w631":631,"w632":632,"w633":633,"w634":634,"w635":635,"w636":636,"w637":637,"w638":638,"w639":639,"w640":640,"w641":641,"w642":642,"w643":643,"w644":644,"w645":645,"w646":646,"w647":647,"w648":648,"w649":649,"w650":650,"w651":651,"w652":652,"w653":653,"w654":654,"w655":655,"w656":656,"w657":657,"w658":658,"w659":659,"w660":660,"w661":661,"w662":662,"w663":663,"w664":664,"w665":665,"w666":666,"w667":667,"w668":668,"w669":669,"w670":670,"w671":671,"w672":672,"w673":673,"w674":674,"w675":675,"w676":676,"w677":677,"w678":678,"w679":679,"w680":680,"w681":681,"w682":682,"w683":683,"w684":684,"w685":685,"w686":686,"w687":687,"w688":688,"w689":689,"w690":690,"w691":691,"w692":692,"w693":693,"w694":694,"w695":695,"w696":696,"w697":697,"w698":698,"w699":699,"w700":700,"w701":701,"w702":702,"w703":703,"w704":704,"w705":705,"w706":706,"w707":707,"w708":708,"w709":709,"w710":710,"w711":711,"w712":712,"w713":713,"w714":714,"w715":715,"w716":716,"w717":717,"w718":718,"w719":719,"w720":720,"w721":721,"w722":722,"w723":723,"w724":724,"w725":725,"w726":726,"w727":727,"w728":728,"w729":729,"w730":730,"w731":731,"w732":732,"w733":733,"w734":734,"w735":735,"w736":736,"w737":737,"w738":738,"w739":739,"w740":740,"w741":741,"w742":742,"w743":743,"w744":744,"w745":745,"w746":746,"w747":747,"w748":748,"w749":749,"w750":750,"w751":751,"w752":752,"w753":753,"w754":754,"w755":755,"w756":756,"w757":757,"w758":758,"w759":759,"w760":760,"w761":761,"w762":762,"w763":763,"w764":764,"w765":765,"w766":766,"w767":767,"w768":768,"w769":769,"w770":770,"w771":771,"w772":772,"w773":773,"w774":774,"w775":775,"w776":776,"w777":777,"w778":778,"w779":779,"w780":780,"w781":781,"w782":782,"w783":783,"w784":784,"w785":785,"w786":786,"w787":787,"w788":788,"w789":789,"w790":790,"w791":791,"w792":792,"w793":793,"w794":794,"w795":795,"w796":796,"w797":797,"w798":798,"w799":799,"w800":800,"w801":801,"w802":802,"w803":803,"w804":804,"w805":805,"w806":806,"w807":807,"w808":808,"w809":809,"w810":810,"w811":811,"w812":812,"w813":813,"w814":814,"w815":815,"w816":816,"w817":817,"w818":818,"w819":819,"w820":820,"w821":821,"w822":822,"w823":823,"w824":824,"w825":825,"w826":826,"w827":827,"w828":828,"w829":829,"w830":830,"w831":831,"w832":832,"w833":833,"w834":834,"w835":835,"w836":836,"w837":837,"w838":838,"w839":839,"w840":840,"w841":841,"w842":842,"w843":843,"w844":844,"w845":845,"w846":846,"w847":847,"w848":848,"w849":849,"w850":850,"w851":851,"w852":852,"w853":853,"w854":854,"w855":855,"w856":856,"w857":857,"w858":858,"w859":859,"w860":860,"w861":861,"w862":862,"w863":863,"w864":864,"w865":865,"w866":866,"w867":867,"w868":868,"w869":869,"w870":870,"w871":871,"w872":872,"w873":873,"w874":874,"w875":875,"w876":876,"w877":877,"w878":878,"w879":879,"w880":880,"w881":881,"w882":882,"w883":883,"w884":884,"w885":885,"w886":886,"w887":887,"w888":888,"w889":889,"w890":890,"w891":891,"w892":892,"w893":893,"w894":894,"w895":895,"w896":896,"w897":897,"w898":898,"w899":899,"w900":900,"w901":901,"w902":902,"w903":903,"w904":904,"w905":905,"w906":906,"w907":907,"w908":908,"w909":909,"w910":910,"w911":911,"w912":912,"w913":913,"w914":914,"w915":915,"w916":916,"w917":917,"w918":918,"w919":919,"w920":920,"w921":921,"w922":922,"w923":923,"w924":924,"w925":925,"w926":926,"w927":927,"w928":928,"w929":929,"w930":930,"w931":931,"w932":932,"w933":933,"w934":934,"w935":935,"w936":936,"w937":937,"w938":938,"w939":939,"w940":940,"w941":941,"w942":942,"w943":943,"w944":944,"w945":945,"w946":946,"w947":947,"w948":948,"w949":949,"w950":950,"w951":951,"w952":952,"w953":953,"w954":954,"w955":955,"w956":956,"w957":957,"w958":958,"w959":959,"w960":960,"w961":961,"w962":962,"w963":963,"w964":964,"w965":965,"w966":966,"w967":967,"w968":968,"w969":969,"w970":970,"w971":971,"w972":972,"w973":973,"w974":974,"w975":975,"w976":976,"w977":977,"w978":978,"w979":979,"w980":980,"w981":981,"w982":982,"w983":983,"w984":984,"w985":985,"w986":986,"w987":987,"w988":988,"w989":989,"w990":990,"w991":991,"w992":992,"w993":993,"w994":994,"w995":995,"w996":996,"w997":997,"w998":998,"w999":999,"w1000":1000,"w1001":1001,"w1002":1002,"w1003":1003,"w1004":1004,"w1005":1005,"w1006":1006,"w1007":1007,"w1008":1008,"w1009":1009,"w1010":1010,"w1011":1011,"w1012":1012,"w1013":1013,"w1014":1014,"w1015":1015,"w1016":1016,"w1017":1017,"w1018":1018,"w1019":1019,"w1020":1020,"w1021":1021,"w1022":1022,"w1023":1023} From 4f2c4253d6f59e6fafc7b3315fdf3f5de85d2193 Mon Sep 17 00:00:00 2001 From: Thorsten Fuchs <76904008+ThorFuchs@users.noreply.github.com> Date: Sun, 18 Oct 2026 11:10:54 +0200 Subject: [PATCH 3/3] Expose checked immutable structural views with public consumers and DocC --- AGENTS.md | 3 +- .../Architecture/ExtractionManifest.json | 3 +- .../StructuralIntelligence/Inspection.md | 6 +- .../StructuralIntelligence/NAV8Completion.md | 107 ++++++++++++ .../StructuralIntelligence/NAV8Progress.json | 31 ++++ .../SOURCE-AUTHORITY.md | 9 + Documentation/CI/README.md | 14 ++ Documentation/Performance/README.md | 5 +- .../Qualification/ProjectionCases.json | 20 ++- Documentation/Qualification/ReleaseLines.md | 12 +- README.md | 23 ++- Scripts/README.md | 6 + Scripts/build_documentation_site.py | 2 +- Scripts/ci.py | 11 +- Scripts/projection_acceptance.py | 26 +++ Scripts/qualify_projections.py | 10 +- Scripts/qualify_public_projections.py | 117 +++++++++++++ Scripts/test_qualification_harness.py | 31 +++- Sources/JSONCLIEngine/CLIBuildIdentity.swift | 2 +- .../Documentation.docc/JSONInspection.md | 7 + .../StructuralProjections.md | 102 +++++++++++ .../JSONSparseTableProjection.swift | 41 ++++- .../Projections/JSONTreeProjection.swift | 85 +++++++-- Tools/ProjectionQualification/Package.swift | 12 ++ Tools/ProjectionQualification/README.md | 14 ++ .../Sources/ProjectionConsumer/Main.swift | 162 ++++++++++++++++++ 26 files changed, 813 insertions(+), 48 deletions(-) create mode 100644 Documentation/Architecture/StructuralIntelligence/NAV8Completion.md create mode 100644 Documentation/Architecture/StructuralIntelligence/NAV8Progress.json create mode 100644 Scripts/qualify_public_projections.py create mode 100644 Sources/JSONInspection/Documentation.docc/StructuralProjections.md create mode 100644 Tools/ProjectionQualification/Package.swift create mode 100644 Tools/ProjectionQualification/README.md create mode 100644 Tools/ProjectionQualification/Sources/ProjectionConsumer/Main.swift diff --git a/AGENTS.md b/AGENTS.md index 9ad4ec2..2aebea7 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -42,4 +42,5 @@ Documentation/Architecture before changing behavior. user instruction. Preserve unrelated changes. Scalar scanning and immutable plan-local regex sharing are selected private -optimizations. Projection and JSON text-sequence framing remain deferred. +optimizations. Source-attached N3 snapshots and P1 tree/sparse-table projections live in JSONInspection. +P2 graph/store/set/matrix/retrieval/persistence and JSON text-sequence framing remain deferred. diff --git a/Documentation/Architecture/ExtractionManifest.json b/Documentation/Architecture/ExtractionManifest.json index 0956116..4a191c4 100644 --- a/Documentation/Architecture/ExtractionManifest.json +++ b/Documentation/Architecture/ExtractionManifest.json @@ -301,7 +301,8 @@ "Composition reference-load fixtures, serial descriptor staging, public-only adapter, capacity/terminal tests and strict CI receipt checks are original Apache-2.0 code. Generated JSON graphs introduce no upstream protocol fixtures, engine or dependency. Core public APIs, finite profiles and accounting weights are unchanged.", "NAV5 public array-evidence packaging, external consumer and DocC are original Apache-2.0 code. Existing exact shape evidence, exclusive reducer, weights and I01-I17 semantics are unchanged; no upstream engine or dependency is adapted. Promotion is a draft candidate, not a released product.", "NAV5 package-only complete structural snapshot, parent-linked metadata, original source-ownership transfer and S01-S24 synthetic tests are original Apache-2.0 code. The existing read scope admits once; its default public read/traversal/inspection completion behavior is preserved. No persistent identity, upstream algorithm or new dependency is introduced.", - "NAV6 snapshot access-level promotion, external consumer, independent 28-record maintainer oracle, terminal-transfer/concurrent lookup proofs and compiled DocC are original Apache-2.0 contributions. No upstream engine, new semantic authority, dependency or additional product is adapted." + "NAV6 snapshot access-level promotion, external consumer, independent 28-record maintainer oracle, terminal-transfer/concurrent lookup proofs and compiled DocC are original Apache-2.0 contributions. No upstream engine, new semantic authority, dependency or additional product is adapted.", + "NAV8 current-main N3/P1 reconciliation, minimal public immutable projection API, independent 16-case consumer and DocC/access-control proofs are original Apache-2.0 contributions. NAV7 donor db991c5/bda8aef and packet SHA-256 57ca72cb817272ed466a7cb8810043d56a079190d830ea7b995abd308070f98d retain provenance. No external engine, dependency or product is added." ], "jsonhtml_export_original_contributions": { "license": "Apache-2.0", diff --git a/Documentation/Architecture/StructuralIntelligence/Inspection.md b/Documentation/Architecture/StructuralIntelligence/Inspection.md index 7975176..84d8307 100644 --- a/Documentation/Architecture/StructuralIntelligence/Inspection.md +++ b/Documentation/Architecture/StructuralIntelligence/Inspection.md @@ -71,5 +71,7 @@ inner cancellation, source coherence and independent shared-source invocations. Current native/Linux/WASI/platform receipts must qualify final source; this document does not turn an unexecuted lane into a pass. This contract grants no release authority. -Snapshots, persistent indexes, projections, retrieval, BFS, JSONPath, HTML/CLI -integration, schema inference and numeric matrices remain deferred. +At the original N2 milestone snapshots/projections were deferred. NAV8 adds +source-attached snapshots and tree/sparse-table views; see NAV8Completion.md. +Persistent indexes, retrieval, BFS, JSONPath, HTML/CLI integration, schema inference +and numeric matrices remain deferred. diff --git a/Documentation/Architecture/StructuralIntelligence/NAV8Completion.md b/Documentation/Architecture/StructuralIntelligence/NAV8Completion.md new file mode 100644 index 0000000..73cdcf1 --- /dev/null +++ b/Documentation/Architecture/StructuralIntelligence/NAV8Completion.md @@ -0,0 +1,107 @@ +# Navigation V1 completion on development main + +NAV8 starts at development main `e0a4185477047d92e4b8e1a2b56303848472d9be` +on `feature/json-navigation-v1-completion`, proposed in +[PR #59](https://github.com/ThorFuchs/Swift-JSON/pull/59). Published 1.6.1 at +`e431f157ececc0cf3d061192420b0e36a9062f83` remains immutable and has no Inspection. +This is unreleased 1.7.0-dev source, with the same ten products/nine libraries. +No version/tag/publication or sibling feature is part of this integration. + +## Source reconciliation and semantic owners + +N1 walker/reducer and N2 shape source blobs are identical on starting main and +NAV7's final P1 donor. They are retained rather than replayed. Only the missing +N3 increment (`db991c51dc15e8e47a0356a66ae7e03f4ed51b98` relative to +`258a23eb01cd0cbcc702c0a2550d35ff05f4881d`) and P1 increment +(`bda8aef4c8347ac4f6f2d7264c4be244367e4869` relative to `db991c5`) are adapted. +Original NAV7 stacked drafts remain evidence, not integration bases. + +| Operation | Sole existing semantic authority | Budget boundary | +| --- | --- | --- | +| Snapshot build | Navigation's exclusive mutating-inout owned reducer, original read scope/admission | One full physical-root invocation; finalize all ranges before one-shot source transfer | +| Tree build | Same owned executor plus sealed snapshot topology | New full-source admission; charge retained snapshot alias and view; no new DOM | +| Tree metadata | Snapshot's checked `record(at:)` after selected-interval bounds | Fixed trusted metadata read; no owned growth/report | +| Tree child/subtree catalogue | Same owned executor, finalized physical ranges | Separate whole-source invocation, charged output slots; cap refusal throws | +| Tree location/value/span | Exactly one existing snapshot lookup | Separate full-source admission; original typed selection/map; no hidden nested operation | +| Sparse table build | Same exclusive reducer and original exact key comparison | One complete row pass and cumulative ledger including finalization/source transfer | +| Sparse cell | Original core read scope, selection, object lookup/scalar comparison | New explicit full-source admission; no construction remainder or null-on-error | + +The two package-only transfer hooks extend completion accounting only for a +source-owning result. Ordinary core read/visit/collect/N2 completion does not +designate transfer and retains its original refunds/statistics. No borrowed +callback, escaped cursor, second meter, normalized key/value or new concurrency +authority is introduced. The historical Swift 6.4 nonmutating-borrow codegen bug +is not declared fixed; full positive/negative exclusive-inout codegen remains. + +## Deliberate public P1 decision + +Promote the checked `JSONTreeProjection` factory, immutable snapshot/root/end, +metadata/catalogue and delegated location/value/span methods. Promote the checked +`JSONSparseTableProjection` factory, immutable source/selection/row count/columns/ +traversal and tri-state `cell` lookup. Expose typed `JSONProjectionFailure` cases. +Keep initializers fileprivate, sparse offsets/member references package-only, +and accounting/reducers internal. This is a small surface within JSONInspection, +with no extra product, umbrella facade, setter or rival path model. + +Bare Int positions are intentionally consistent with N3's existing snapshot-local +ordinal contract. A captured immutable owner enforces source attachment and range; +it cannot diagnose accidental reuse of an in-range integer from another snapshot. +There is no detached identity or public replacement-source argument. A stronger +token type is deferred rather than implying provenance that this API cannot prove. + +All table rows must be objects. Prefix evidence does not certify a suffix. Empty +arrays are 0-by-0; empty objects remain rows. Columns retain first-seen exact scalar +identity; missing/null/value stay distinct. Row admission is complete even when +descendant traversal coverage is restricted. Constructors never publish partial +artifacts after wrong kind, missing target, quota, cancellation or terminal error. + +No Navigation or original N2 declaration changes. N3 preserves its original 23 +public additions; P1's precise promoted declaration fragments are audited from +the actual Swift 6.4 compiler graph. Public usage and costs appear in the +[compiled guide](../../../Sources/JSONInspection/Documentation.docc/StructuralProjections.md) +and [independent SwiftPM consumer](../../../Tools/ProjectionQualification). + +## Qualification and review boundary + +Original I01–I17, S01–S24/promotion, P01–P32 and pinned independent fixtures remain. +The public consumer adds 16 named scenarios each in Debug/Release/ASan, three +compiled guide blocks/configuration and 18 ordinary external full-codegen +rejections. Private compiler cases are retained, replacing the now-obsolete +public-type-invisibility negatives with sparse-storage/accounting/reducer +invisibility negatives. No former invariant or behavior assertion is removed. +The receipt harness rejects missing/duplicate/renamed cases, zero counters, +incidental diagnostics, compiler crashes and incomplete command inventories. + +Current discovery is 76 Inspection functions, 779 native/763 Linux/675 WASI root +functions, unchanged 325/288 parameter invocations and 51/50 shared functions. +All 49 core metric witnesses and 126 maintenance identities remain mandatory. +These are required inventories, not claims of unexecuted qualification. Final +source-bound native/safety/docs/Git-free reproduction, both Linux architectures, +full Node WASI, limited direct Inspection WasmKit, Apple SDK compile/link, +external consumer and source/API/protection receipts accompany this PR. +SDK compilation is not mobile runtime; limited WasmKit is not full-root support. + +The source/public API review compares canonical donor algorithms, final compiler +fragments, exact fixtures and independent public consumers. Human owner review +and a fresh protected-main/check/thread lease remain prerequisites to merge; +historical green receipts cannot qualify this combined source. + +## Resource and performance disposition + +Published 49 profiles/metrics remain unchanged. Additional finite bounds and +logical weights are those in the compiled guide and original P1 proof record. +Every reservation precedes growth and every owned loop is cumulative/cancellable. +Source aliases incur logical ownership even when physical COW shares storage. +No bound on caller instructions, physical heap, RSS or allocator behavior follows. + +G4 controlled performance remains **HOLD**, with zero accepted timing samples. +The owner explicitly permits this correctness/platform-qualified integration +with that HOLD and **no performance claims**. G4 blocks speed claims, not this +specific guarded merge; other semantic/API/compiler/platform/protection gates +are unchanged. There is no benchmark PASS, shifted threshold or inferred speedup. +Snapshot build remains depth-sensitive; repeated lookups re-admit the full source; +linear first-seen column scans may be quadratic. No EngineBench claim is made. + +Persistence, global/durable indexes, graph/store/set/matrix, retrieval, BFS, +JSONPath/query grammar, HTML/CLI additions and unrelated DSL/composition/developer +kit work remain out of this completion train. diff --git a/Documentation/Architecture/StructuralIntelligence/NAV8Progress.json b/Documentation/Architecture/StructuralIntelligence/NAV8Progress.json new file mode 100644 index 0000000..2f609a4 --- /dev/null +++ b/Documentation/Architecture/StructuralIntelligence/NAV8Progress.json @@ -0,0 +1,31 @@ +{ + "schema_version": 1, + "base": "e0a4185477047d92e4b8e1a2b56303848472d9be", + "branch": "feature/json-navigation-v1-completion", + "pr": 59, + "N1_N2": "Already on main; implementation and authored declarations unchanged", + "N3_checkpoint": "09e85f6: focused six-command inspection lane passed 44 cases each Debug/Release/ASan, strict memory and 2-positive/20-negative full codegen", + "P1_private_checkpoint": "931c042: original donor algorithms/P01-P32 fixtures restored separately", + "P1_public": "28 deliberately promoted declarations within JSONInspection; independent 16-case consumer,18 negative full-codegen outcomes and3 DocC fences/config passed in initial proof", + "expected_final_public": { + "Navigation": 56, + "Inspection": 95, + "package_authored": 1172 + }, + "full_final_source_qualification": "Required; read exact PR/checkpoint receipts rather than infer a pass from this planning status", + "G4": { + "status": "HOLD", + "accepted_timing_samples": 0, + "owner_classification": "blocking for speed claims; explicitly nonblocking for correctness/platform-qualified NAV8 guarded merge" + }, + "release_action": "Not authorized; remains unreleased1.7.0-dev", + "deferred": [ + "P2", + "persistence", + "retrieval", + "BFS", + "matrix/graph/store/set", + "CLI/HTML", + "unrelated sibling work" + ] +} diff --git a/Documentation/Architecture/StructuralIntelligence/SOURCE-AUTHORITY.md b/Documentation/Architecture/StructuralIntelligence/SOURCE-AUTHORITY.md index 2d01dbf..9895555 100644 --- a/Documentation/Architecture/StructuralIntelligence/SOURCE-AUTHORITY.md +++ b/Documentation/Architecture/StructuralIntelligence/SOURCE-AUTHORITY.md @@ -140,3 +140,12 @@ JSONOperationReport envelopes, passes the source value separately to a synchrono visitor, and keeps records metadata-only. Its module is experimental; **no public SwiftPM product is added**. API shape and all remaining release gates are recorded in [API-DECISIONS](API-DECISIONS.md). + +## NAV8 current-main completion + +The [NAV8 contract](NAV8Completion.md) reconciles current1.7.0-dev main e0a4185 +with only missing N3/P1 source from db991c5/bda8aef. N1/N2 are already on main; +old draft heads are provenance, not merge bases. N3 snapshots and public immutable +tree/sparse-table operations remain within JSONInspection. No extra product or +release action; stable1.6.1 is unchanged. Current source-bound receipts, rather +than the historical stage counts above, establish qualification. diff --git a/Documentation/CI/README.md b/Documentation/CI/README.md index 02bcb04..2c1de90 100644 --- a/Documentation/CI/README.md +++ b/Documentation/CI/README.md @@ -1,3 +1,17 @@ +# NAV8 Navigation V1 integration + +Current required discovery retains 779 native /763 Linux /675 WASI functions, +325 native/Linux /288 WASI parameter invocations, 76 Inspection functions, +51 native /50 Linux shared functions, all 49 core caps and 126 maintenance +identities. Nine library catalogs and ten products remain. Native/Linux and +focused Inspection execute both the private invariant proof and public 16-case +projection consumer with 18 external negative codegen outcomes/three guide blocks. +The harness requires 17 negative/cardinality tests. Counts specify gates; actual +source-bound receipts establish passes. G4 stays HOLD, explicitly nonblocking +for this owner's guarded merge without performance claims. + +Earlier sections below retain their original source histories. + # NAV6 integrated inspection candidate Adds Inspection to schema-example-enabled main: ten products, nine libraries, diff --git a/Documentation/Performance/README.md b/Documentation/Performance/README.md index ac190a2..9eefb46 100644 --- a/Documentation/Performance/README.md +++ b/Documentation/Performance/README.md @@ -27,5 +27,6 @@ pattern and aggregate-byte quotas; sharing does not bypass admission or work. Logical retained bytes differ from process RSS. Darwin ru_maxrss is cumulative; allocator end observations are not isolated workload allocations. These results -make no cross-machine throughput or OS-enforced memory guarantee. Projection and -JSON text-sequence framing remain deferred. +make no cross-machine throughput or OS-enforced memory guarantee. Source-attached structural views in unreleased Inspection carry no performance +claim (G4 HOLD). P2 matrix/graph/store/set/retrieval and JSON text-sequence framing +remain deferred. diff --git a/Documentation/Qualification/ProjectionCases.json b/Documentation/Qualification/ProjectionCases.json index 31532ed..cc6f97d 100644 --- a/Documentation/Qualification/ProjectionCases.json +++ b/Documentation/Qualification/ProjectionCases.json @@ -34,5 +34,23 @@ "JSONInspectionTests.projectionP31CellLookupIsIndependentFullSourceAdmission()", "JSONInspectionTests.projectionP32FinalizationFailureCancellationAndScopeTeardownAreTerminal()" ], - "scope": "P01\u2013P32 private prototype; every exact identity required" + "scope": "P01\u2013P32 private prototype; every exact identity required", + "public_consumer_checks": [ + "scalar-roots", + "selected-interval", + "typed-locations", + "exact-values", + "canonical-order", + "source-coherence", + "complete-columns", + "scalar-key-columns", + "presence", + "empty-tables", + "equal-physical-rows", + "late-row-refusal", + "capacity-and-bounds", + "separate-admission", + "inclusive-ledgers", + "cancellation-health" + ] } diff --git a/Documentation/Qualification/ReleaseLines.md b/Documentation/Qualification/ReleaseLines.md index 0e59994..7937767 100644 --- a/Documentation/Qualification/ReleaseLines.md +++ b/Documentation/Qualification/ReleaseLines.md @@ -4,7 +4,7 @@ | --- | --- | --- | | Published 1.6.0 | `f975ac1c5a18af9b422db0994cbc551fd37eee2f` | Eight libraries plus CLI, eight catalogs, 1,077 authored declarations | | Published 1.6.1 (latest stable) | `e431f157ececc0cf3d061192420b0e36a9062f83` | Same eight-library public API and runtime as 1.6.0; no Inspection | -| Unreleased 1.7.0-dev | Main, retaining N2 admitted at `2b24f47e7405821240cf8dfc66b840c9a7f8efa5` | Nine libraries plus CLI, nine catalogs, 1,121 authored declarations | +| Unreleased 1.7.0-dev | Main, retaining N2 admitted at `2b24f47e7405821240cf8dfc66b840c9a7f8efa5` | Nine libraries plus CLI, nine catalogs, 1,172 authored declarations (N2 plus N3/P1 additions) | Source versions do not establish publication. Consult the [official releases](https://github.com/ThorFuchs/Swift-JSON/releases) for published @@ -19,8 +19,8 @@ reference. Installation examples retain the compatible `from: "1.6.0"` requireme The compatible requirement can resolve 1.6.1; use `exact: "1.6.1"` and retain Package.resolved when reproducing the independently verified patch release. -Navigation's 56 declarations are common to both lines. Inspection's 44 are only -on development main. N3 snapshots, private P1, DSL, independent composition/root +Navigation's 56 declarations are common to both lines. Inspection's original 44 array-evidence declarations and NAV8 snapshot/projection +additions are only on development main. N3 snapshots, private P1, DSL, independent composition/root proposals and lower deployment floors are not part of this maintenance edition. Swift tools/compiler 6.4+, language mode 6 and Apple OS/SDK 27+ remain required; the separately qualified Ubuntu 24.04/glibc and full-language WASI scopes remain. @@ -30,3 +30,9 @@ overwriting its version or N2. With squash/rebase integration, the maintenance tip need not be an ancestor of main: use the exact commit/content mapping in the release qualification receipt. No tag or release follows automatically from a source version, merged PR, documentation deployment or successful CI run. + +NAV8 completes source-attached N3 snapshots and public P1 tree/sparse-table views +within the existing Inspection product; see [the completion contract](../Architecture/StructuralIntelligence/NAV8Completion.md). +Stable 1.6.1 has neither. Main stays 1.7.0-dev with ten products. G4 controlled +performance remains HOLD without speed claims; this is distinct from technical +qualification and does not authorize any release/tag. diff --git a/README.md b/README.md index bed889c..d25fe73 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # Swift-JSON This source is **1.7.0-dev**, the unreleased development line. It retains the -admitted JSONInspection API (44 authored declarations) alongside the unchanged -56-declaration JSONNavigation API: nine libraries, ten products and nine catalogs. +admitted JSONInspection array-evidence API plus source-attached snapshots and +tree/sparse-table projections alongside the unchanged 56-declaration Navigation API: nine libraries, ten products and nine catalogs. The stable 1.6 line has eight libraries and eight catalogs. Do not use a main snapshot as a 1.6 maintenance release. @@ -101,7 +101,7 @@ Choose the products your application needs: | **swift-json** | Bounded command-line JSON workflows (available since 1.5.0) | | **JSONBridges** | Opt-in native integer, Double and Foundation Decimal conversions (available in the 1.4.0 tag and 1.5.0 release) | | **JSONNavigation** | Opt-in exact many-node DFS, physical/virtual scopes, finite metadata and explicit coverage, introduced in 1.6.0 | -| **JSONInspection** | Unreleased source: observed array kinds, exact first-seen columns and explicit complete/prefix row coverage | +| **JSONInspection** | Unreleased source: array evidence, complete source-attached snapshots, selected trees and strict sparse object-row tables | | **JSONPatch** | Staged RFC 6902 JSON Patch and RFC 7396 Merge Patch | `JSONSchema`, `JSONStreaming`, `JSONPatch`, `JSONHTML` and opt-in `JSONBridges` build on `JSON`. The package-private @@ -697,3 +697,20 @@ Full source admission still includes the unobserved suffix. Complete row evidenc can have restricted descendant traversal; structural rectangular width is not numeric matrix or schema admission. See the [compiled evidence guide](Sources/JSONInspection/Documentation.docc/ArrayEvidence.md), [public consumer](Tools/InspectionQualification) and [accounting contract](Documentation/Architecture/StructuralIntelligence/Inspection.md). + +## Complete source-attached structural views (unreleased) + +Opt-in JSONInspection on 1.7.0-dev main now combines array observations with a +complete parent-linked snapshot, selected physical tree views and strict sparse +all-object tables. Use core Pointer/read for one value and Navigation for many-node +traversal. Inspection keeps exact typed locations, source order and numeric/key +meaning. Sparse cells distinguish missing, explicit null and values; positive +prefix observations never certify the complete table. + +Read the [compiled structural guide](Sources/JSONInspection/Documentation.docc/StructuralProjections.md), +[public consumer](Tools/ProjectionQualification) and [NAV8 source/API decision](Documentation/Architecture/StructuralIntelligence/NAV8Completion.md). +Every construction has one cumulative finite ledger. Each later catalogue/cell/ +location/value/span lookup is an explicitly separate full-source-admitted operation. +Ordinals are snapshot-local trusted positions, not durable identity. Logical +retention is not RSS; G4 controlled performance remains HOLD, with no speed claim. +These additions are absent from published 1.6.1 and do not publish 1.7.0. diff --git a/Scripts/README.md b/Scripts/README.md index 780fe1e..5d5e469 100644 --- a/Scripts/README.md +++ b/Scripts/README.md @@ -40,3 +40,9 @@ lanes. Their receipts retain precise scopes; preparation does not establish a pa `Documentation/Qualification/TestDiscovery.json` is the reviewed exact root, QA, shared-state and portable inventory; it does not infer expected counts from the current test output. Native and Linux retain all 49 public cap outcomes. + +NAV8 adds `qualify_public_projections.py`: independent public SwiftPM Debug/ +Release/ASan16 checks,18 full-codegen negatives and3 executable guide blocks. +`qualify_projections.py` retains private sparse-storage/reducer/invariant proofs. +Both run through native/Linux and focused Inspection; all49 caps/126 maintenance +identities and exact root/cardinality checks remain required. diff --git a/Scripts/build_documentation_site.py b/Scripts/build_documentation_site.py index d19b73b..1efbf7d 100644 --- a/Scripts/build_documentation_site.py +++ b/Scripts/build_documentation_site.py @@ -40,7 +40,7 @@ 'JSONHTML': 'Exact standalone HTML with offline disclosure/search and native-byte copy/download.', 'JSONBridges': 'Opt-in trusted integer construction and policy-explicit Double and Foundation Decimal projection.', 'JSONNavigation': 'Exact typed DFS with physical and virtual scopes, explicit coverage and one cumulative budget.', - 'JSONInspection': 'Complete or prefix-scoped array evidence, exact ordered columns and cumulative finite reports.'} + 'JSONInspection': 'Array evidence, complete source-attached snapshots, tree views and strict sparse tables with finite reports.'} class Links(HTMLParser): diff --git a/Scripts/ci.py b/Scripts/ci.py index 317bb2a..096ea07 100644 --- a/Scripts/ci.py +++ b/Scripts/ci.py @@ -5,7 +5,7 @@ from archive_candidate import files from preflight import collect, collect_linux from testing_events import read_events, ROOT_PARAMETER_CASES -from projection_acceptance import check_projection_cases +from projection_acceptance import check_projection_cases, check_public_projection_receipt from test_discovery import DISCOVERY, ROOT_COUNTS, SHARED_COUNTS, PARAMETER_INVOCATIONS, check_restored ROOT = pathlib.Path(__file__).resolve().parents[1] @@ -33,7 +33,8 @@ def commands(lane, output): ['swift', 'build', '--target', 'JSONInspection', '--scratch-path', '.build/inspection-strict', '-Xswiftc', '-strict-memory-safety', '-Xswiftc', '-warnings-as-errors'], ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')], - ['python3', '-B', 'Scripts/qualify_projections.py', '--output', str(output / 'projection-codegen')]] + ['python3', '-B', 'Scripts/qualify_projections.py', '--output', str(output / 'projection-codegen')], + ['python3', '-B', 'Scripts/qualify_public_projections.py', '--output', str(output / 'public-projection-consumer')]] return [c + ['--disable-xctest'] if sys.platform == 'linux' and c[:2] == ['swift', 'test'] else c for c in result] if lane == 'schema-examples-qualification': return commands('schema-examples-advanced', ROOT / output) + [['python3', '-B', 'Scripts/qualify_schema_example_matrix.py', '--output', str(output / 'matrix')]] @@ -171,6 +172,7 @@ def commands(lane, output): ['python3', '-B', 'Scripts/qualify_inspection.py', '--output', str(output / 'inspection-consumer')], ['python3', '-B', 'Scripts/qualify_snapshot.py', '--output', str(output / 'snapshot-consumer')], ['python3', '-B', 'Scripts/qualify_projections.py', '--output', str(output / 'projection-codegen')], + ['python3', '-B', 'Scripts/qualify_public_projections.py', '--output', str(output / 'public-projection-consumer')], ['python3', '-B', 'Scripts/qualify_navigation_reducer.py', '--output', str(output / 'owned-codegen')], ['swift', 'test', '--package-path', 'Tools/MobileQualification'], ['swift', 'run', '-c', 'release', '--package-path', 'Tools/MobileQualification', 'MobileQualification'], @@ -306,6 +308,9 @@ def check_result(command, code, log, events=None): passed = passed and 'REDUCER_CODEGEN passed positive=2 negative=20' in log.splitlines() if command[:3] == ['python3', '-B', 'Scripts/qualify_snapshot.py']: passed = passed and 'SNAPSHOT_COMPILER passed configurations=2 consumer_cases=14 address_cases=14 guide_fences=3 negative_probes=18' in log.splitlines() + if command[:3] == ['python3', '-B', 'Scripts/qualify_public_projections.py']: + data = json.loads((ROOT / command[command.index('--output') + 1] / 'receipt.json').read_text()) + passed = passed and check_public_projection_receipt(data) if command[:3] == ['python3', '-B', 'Scripts/qualify_projections.py']: data = json.loads((ROOT / command[command.index('--output') + 1] / 'receipt.json').read_text()) probes = [c for c in data['commands'] if c.get('expected_diagnostic')] @@ -323,7 +328,7 @@ def check_result(command, code, log, events=None): if command[:3] == ['python3', '-B', 'Scripts/qualify_html_browser.py']: passed = passed and 'JSONHTML_BROWSER passed engines=3 cases=76 skips=0' in log.splitlines() if 'Scripts/test_qualification_harness.py' in command: - passed = passed and 'HARNESS_TESTS passed cases=16' in log.splitlines() + passed = passed and 'HARNESS_TESTS passed cases=17' in log.splitlines() return passed, counts def main(): diff --git a/Scripts/projection_acceptance.py b/Scripts/projection_acceptance.py index e6090c3..22f2f9f 100644 --- a/Scripts/projection_acceptance.py +++ b/Scripts/projection_acceptance.py @@ -8,3 +8,29 @@ def check_projection_cases(events, shared=False): observed = [name for name in events['function_names'] if name.startswith('JSONInspectionTests.projectionP')] return len(observed) == len(set(observed)) and set(observed) == (SHARED if shared else EXPECTED) + +PUBLIC_CHECKS = frozenset(json.loads((ROOT / 'Documentation/Qualification/ProjectionCases.json').read_text())['public_consumer_checks']) + +def check_public_projection_receipt(data): + commands = data.get('commands', []) + results = data.get('consumer_results', {}) + if (data.get('status') != 'passed' or len(commands) != 37 + or len({c.get('name') for c in commands}) != 37 + or set(results) != {'debug', 'release', 'address'}): + return False + if not all(c.get('status') == 'passed' and c.get('compiler_crash') is False for c in commands): + return False + negatives = [c for c in commands if c.get('expected_diagnostic')] + if len(negatives) != 18 or not all(c['exit_code'] > 0 and any( + c['expected_diagnostic'] in d for d in c['primary_diagnostics']) for c in negatives): + return False + if not all(c['exit_code'] == 0 for c in commands if not c.get('expected_diagnostic')): + return False + for result in results.values(): + cases = result.get('cases', []) + if len(cases) != 16 or len(set(cases)) != 16 or set(cases) != PUBLIC_CHECKS: + return False + if not all(isinstance(result.get(k), int) and result[k] > 0 for k in + ['work_units', 'logical_retained_bytes', 'peak_logical_retained_bytes', 'admitted_nodes']): + return False + return True diff --git a/Scripts/qualify_projections.py b/Scripts/qualify_projections.py index 6624146..f101ae0 100644 --- a/Scripts/qualify_projections.py +++ b/Scripts/qualify_projections.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 # SPDX-License-Identifier: Apache-2.0 -"""Full-codegen proof of package-only projection access; this creates no product.""" +"""Full-codegen proof of projection invariants and package-only storage/reducers.""" import argparse, hashlib, json, pathlib, re, subprocess from archive_candidate import files ROOT = pathlib.Path(__file__).resolve().parents[1] @@ -40,9 +40,9 @@ ''' PROBES = [ ('positive', POSITIVE, None, False), - ('external-tree', 'import JSONInspection\nlet x = JSONTreeProjection.self\n', 'cannot find', True), - ('external-table', 'import JSONInspection\nlet x = JSONSparseTableProjection.self\n', 'cannot find', True), - ('external-error', 'import JSONInspection\nlet x = JSONProjectionFailure.self\n', 'cannot find', True), + ('external-member', 'import JSONInspection\nlet x = JSONSparseTableMember.self\n', 'cannot find', True), + ('external-accounting', 'import JSONInspection\nlet x = ProjectionAccounting.self\n', 'cannot find', True), + ('external-reducer', 'import JSONInspection\nlet x = SparseTableReducer.self\n', 'cannot find', True), ('core-isolation', 'import JSON\nlet x = JSONTreeProjection.self\n', 'cannot find', True), ('forged-tree', 'import JSONInspection\nfunc f(_ s: JSONStructuralSnapshot) { _ = JSONTreeProjection(snapshot: s, rootOrdinal: 0, endExclusive: 1) }\n', 'initializer is inaccessible', False), ('immutable-source', 'import JSON\nimport JSONInspection\nfunc f(_ x: inout JSONSparseTableProjection) { x.document = JSONDocument(root: .null) }\n', "'document' is a 'let' constant", False), @@ -53,7 +53,7 @@ def main(): parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('--output', required=True) out = ROOT / parser.parse_args().output; out.mkdir(parents=True, exist_ok=True) - receipt = dict(status='running', scope='same-package private consumer + external-package rejection; no public projection product', + receipt = dict(status='running', scope='same-package sparse-storage proof + external invariant rejection; public views stay in JSONInspection', source_inputs=[dict(path=p.relative_to(ROOT).as_posix(), sha256=hashlib.sha256(p.read_bytes()).hexdigest()) for p in files()], commands=[]) def save(): (out / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n') def run(name, command, expected=None): diff --git a/Scripts/qualify_public_projections.py b/Scripts/qualify_public_projections.py new file mode 100644 index 0000000..2ec3f73 --- /dev/null +++ b/Scripts/qualify_public_projections.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Qualify public projection imports, semantics and three executable DocC examples.""" +import argparse +import hashlib +import json +import pathlib +import re +import subprocess +import sys +from archive_candidate import files + +ROOT = pathlib.Path(__file__).resolve().parents[1] +CHECKS = {'scalar-roots', 'selected-interval', 'typed-locations', 'exact-values', 'canonical-order', 'source-coherence', 'complete-columns', 'scalar-key-columns', 'presence', 'empty-tables', 'equal-physical-rows', 'late-row-refusal', 'capacity-and-bounds', 'separate-admission', 'inclusive-ledgers', 'cancellation-health'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', required=True) + output = ROOT / parser.parse_args().output + output.mkdir(parents=True, exist_ok=True) + inputs = [{'path': p.relative_to(ROOT).as_posix(), + 'sha256': hashlib.sha256(p.read_bytes()).hexdigest()} for p in files()] + receipt = dict(status='running', source_inputs=inputs, commands=[], consumer_results={}) + + def save(): + (output / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n') + + def run(name, command, expected=None): + result = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, timeout=900) + text = result.stdout + result.stderr + crash = result.returncode < 0 or any(x in text for x in + ['Stack dump:', 'Assertion failed', 'fatal error encountered during compilation']) + diagnostics = re.findall(r': error: ([^\n]+)', result.stderr) + passed = not crash and (result.returncode == 0 if expected is None else + result.returncode > 0 and any(expected in d for d in diagnostics)) + log = output / (name + '.log') + log.write_text(text.replace(str(ROOT), '.')) + receipt['commands'].append(dict(name=name, command=[x.replace(str(ROOT), '.') for x in command], + exit_code=result.returncode, status='passed' if passed else 'failed', compiler_crash=crash, + expected_diagnostic=expected, primary_diagnostics=diagnostics, + log=log.relative_to(ROOT).as_posix(), log_sha256=hashlib.sha256(log.read_bytes()).hexdigest())) + save() + if not passed: + raise ValueError('Unexpected compiler/consumer outcome: ' + name) + return result.stdout + + def consumer(name, command): + text = run(name, command) + checks = re.findall(r'^PROJECTION_CHECK (\S+) passed$', text, re.M) + if len(checks) != 16 or set(checks) != CHECKS or 'PROJECTION_CONSUMER passed cases=16' not in text: + raise ValueError('Missing/duplicate inspection consumer checks: ' + name) + resource = re.search(r'^PROJECTION_RESOURCE work=(\d+) retained=(\d+) peak=(\d+) nodes=(\d+)$', text, re.M) + if resource is None or not all(int(x) > 0 for x in resource.groups()): + raise ValueError('Missing finite cumulative report: ' + name) + receipt['consumer_results'][name] = dict(cases=checks, work_units=int(resource[1]), + logical_retained_bytes=int(resource[2]), peak_logical_retained_bytes=int(resource[3]), + admitted_nodes=int(resource[4])) + save() + + try: + for config in ['debug', 'release']: + run(config + '-build', ['swift', 'build', '-c', config, '--target', 'JSONInspection']) + binpath = pathlib.Path(run(config + '-binpath', ['swift', 'build', '-c', config, '--show-bin-path']).strip()) + modules = binpath / 'Modules' if (binpath / 'Modules').is_dir() else binpath + objects = [] + for module in ['JSON', 'JSONNavigation', 'JSONInspection']: + aggregate = binpath / (module + '.o') + selected = [aggregate] if aggregate.is_file() else sorted((binpath / (module + '.build')).glob('*.o')) + if not selected: + raise ValueError('Missing built objects: ' + module) + objects.extend(str(p) for p in selected) + common = ['swiftc', '-swift-version', '6', '-warnings-as-errors', '-package-name', + 'projection_external_consumer', '-I', str(modules), + '-O' if config == 'release' else '-Onone'] + consumer(config, ['swift', 'run', '-c', config, '--package-path', + 'Tools/ProjectionQualification', 'ProjectionConsumer']) + guide = ROOT / 'Sources/JSONInspection/Documentation.docc/StructuralProjections.md' + fences = re.findall(r'```swift\n(.*?)\n```', guide.read_text(), re.S) + if len(fences) != 3: + raise ValueError('Changed three-fence guide inventory') + for index, fence in enumerate(fences): + file = output / ('guide-' + str(index) + '.swift') + file.write_text('import Foundation\nimport JSON\nimport JSONNavigation\nimport JSONInspection\n' + '@main struct Guide { static func main() throws {\n' + fence + '\n} }\n') + binary = output / ('guide-' + config + '-' + str(index)) + run(config + '-guide-' + str(index), common + ['-parse-as-library', str(file), *objects, '-o', str(binary)]) + run(config + '-guide-' + str(index) + '-run', [str(binary)]) + probes = [ + ('core-import-isolation', 'import JSON\nlet x = JSONTreeProjection.self\n', 'cannot find'), + ('scope-isolation', 'import JSON\nlet x = JSONReadScope.self\n', 'cannot find'), + ('capability-isolation', 'import JSONNavigation\nlet x = JSONTraversalContext.self\n', 'cannot find'), + ('forged-tree', 'import JSONInspection\nfunc f(_ s: JSONStructuralSnapshot) { _ = JSONTreeProjection(snapshot: s, rootOrdinal: 0, endExclusive: 1) }\n', 'initializer is inaccessible'), + ('forged-table', 'import JSONInspection\nlet x = JSONSparseTableProjection()\n', 'initializer is inaccessible'), + ('columns-are-readonly', 'import JSONInspection\nfunc f(_ x: inout JSONSparseTableProjection) { x.columns.removeAll() }\n', "'let' constant"), + ('storage-is-private', 'import JSONInspection\nfunc f(_ x: JSONSparseTableProjection) { _ = x.rowOffsets }\n', 'is inaccessible'), + ('member-is-private', 'import JSONInspection\nlet x = JSONSparseTableMember.self\n', 'cannot find'), + ('no-source-rebinding', 'import JSON\nimport JSONInspection\nfunc f(_ x: JSONTreeProjection) throws { _ = try x.value(for: 0, document: .init(root: .null)) }\n', "extra argument 'document'"), + ] + for name, source, expected in probes: + file = output / (name + '.swift'); file.write_text(source) + run(config + '-' + name, common + ['-parse-as-library', '-c', str(file), + '-o', str(output / (config + '-' + name + '.o'))], expected) + consumer('address', ['swift', 'run', '-c', 'release', '--sanitize', 'address', + '--scratch-path', '.build/projection-consumer-address', '--package-path', + 'Tools/ProjectionQualification', 'ProjectionConsumer']) + receipt['status'] = 'passed' + except (OSError, ValueError, subprocess.TimeoutExpired) as error: + receipt.update(status='failed', error=str(error)) + save() + print('PUBLIC_PROJECTIONS_COMPILER ' + receipt['status'] + + ' configurations=2 consumer_cases=16 address_cases=16 guide_fences=3 negative_probes=18') + return 0 if receipt['status'] == 'passed' else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/Scripts/test_qualification_harness.py b/Scripts/test_qualification_harness.py index 715800d..843ec53 100644 --- a/Scripts/test_qualification_harness.py +++ b/Scripts/test_qualification_harness.py @@ -12,9 +12,34 @@ from coverage import executable_objects, shared_objects, validate_export, without_schema_objects from test_discovery import DISCOVERY, ROOT_COUNTS, PARAMETER_INVOCATIONS, check_root, check_restored, RESTORED_FUNCTIONS from ci import check_result, commands -from projection_acceptance import EXPECTED as PROJECTION_FUNCTIONS, check_projection_cases +from projection_acceptance import EXPECTED as PROJECTION_FUNCTIONS, PUBLIC_CHECKS, check_projection_cases, check_public_projection_receipt class HarnessTests(unittest.TestCase): + def test_public_projection_receipt_rejects_incomplete_and_incidental_successes(self): + valid = dict(status='passed', commands=[dict(name=str(i), status='passed', + compiler_crash=False, expected_diagnostic='inaccessible' if i < 18 else None, + primary_diagnostics=['inaccessible'] if i < 18 else [], exit_code=1 if i < 18 else 0) + for i in range(37)], consumer_results={config: dict(cases=sorted(PUBLIC_CHECKS), + work_units=1, logical_retained_bytes=1, peak_logical_retained_bytes=1, admitted_nodes=1) + for config in ['debug', 'release', 'address']}) + self.assertTrue(check_public_projection_receipt(valid)) + broken = copy.deepcopy(valid); broken['commands'].pop() + self.assertFalse(check_public_projection_receipt(broken)) + broken = copy.deepcopy(valid); broken['commands'][0]['primary_diagnostics'] = ['unrelated warning'] + self.assertFalse(check_public_projection_receipt(broken)) + broken = copy.deepcopy(valid); broken['commands'][0]['compiler_crash'] = True + self.assertFalse(check_public_projection_receipt(broken)) + broken = copy.deepcopy(valid); broken['commands'][0]['exit_code'] = 0 + self.assertFalse(check_public_projection_receipt(broken)) + for config in ['debug', 'release', 'address']: + for mode in ['missing', 'duplicate', 'renamed', 'zero-resource']: + broken = copy.deepcopy(valid); row = broken['consumer_results'][config] + if mode == 'missing': row['cases'].pop() + elif mode == 'duplicate': row['cases'][0] = row['cases'][1] + elif mode == 'renamed': row['cases'][0] = 'unexpected' + else: row['work_units'] = 0 + self.assertFalse(check_public_projection_receipt(broken)) + def test_composition_discovery_and_capacity_limits_are_not_blanket_successes(self): command = ['swift', 'test', '--package-path', 'Tools/CompositionQualification'] events = dict(bundle_counts=[5], module_function_counts={'CompositionScaleTests': 5}, @@ -161,8 +186,8 @@ def test_exact_discovery_rejects_missing_duplicate_and_changed_parameters(self): identity['function_names'][0] = 'JSONTests.unrelatedReplacement()' self.assertFalse(check_restored(identity)) harness = ['python3', '-B', 'Scripts/test_qualification_harness.py'] - self.assertTrue(check_result(harness, 0, 'HARNESS_TESTS passed cases=16')[0]) - for stale in ['HARNESS_TESTS passed cases=10', 'HARNESS_TESTS passed cases=11', 'HARNESS_TESTS passed cases=12', 'HARNESS_TESTS passed cases=13', 'HARNESS_TESTS passed cases=14', 'HARNESS_TESTS passed cases=15', '']: + self.assertTrue(check_result(harness, 0, 'HARNESS_TESTS passed cases=17')[0]) + for stale in ['HARNESS_TESTS passed cases=10', 'HARNESS_TESTS passed cases=11', 'HARNESS_TESTS passed cases=12', 'HARNESS_TESTS passed cases=13', 'HARNESS_TESTS passed cases=14', 'HARNESS_TESTS passed cases=15', 'HARNESS_TESTS passed cases=16', '']: self.assertFalse(check_result(harness, 0, stale)[0]) lifetime = ['python3', '-B', 'Scripts/qualify_schema_example_lifetime.py'] marker = 'SCHEMA_EXAMPLES_CORPUS passed mode=owned scopes=128 values=6 exact=1' diff --git a/Sources/JSONCLIEngine/CLIBuildIdentity.swift b/Sources/JSONCLIEngine/CLIBuildIdentity.swift index 814a35c..0a2b127 100644 --- a/Sources/JSONCLIEngine/CLIBuildIdentity.swift +++ b/Sources/JSONCLIEngine/CLIBuildIdentity.swift @@ -2,6 +2,6 @@ // Generated by Scripts/generate_cli_identity.py; excludes this file. // SHA-256 of the ordered Package.swift + Sources content manifest, not a Git commit. package enum CLIBuildIdentity { - package static let revision = "sha256:7e310dcd81c91d14bf17bfeb2e4bf40434863f451fdd9bb21245b83bd56c2928" + package static let revision = "sha256:b7cfb84e34289d4bb2342e2897c637cdf4fd19f2455072696d27f396bf8ef735" package static let kind = "source-sha256" } diff --git a/Sources/JSONInspection/Documentation.docc/JSONInspection.md b/Sources/JSONInspection/Documentation.docc/JSONInspection.md index 5b58e79..31eb714 100644 --- a/Sources/JSONInspection/Documentation.docc/JSONInspection.md +++ b/Sources/JSONInspection/Documentation.docc/JSONInspection.md @@ -32,3 +32,10 @@ or numeric matrix. Sampling does not exempt any source from admission. - ``JSONStructuralSnapshot`` - ``JSONStructuralRecord`` - ``JSONStructuralSnapshotFailure`` + +### Use complete structural projections + +- +- ``JSONTreeProjection`` +- ``JSONSparseTableProjection`` +- ``JSONProjectionFailure`` diff --git a/Sources/JSONInspection/Documentation.docc/StructuralProjections.md b/Sources/JSONInspection/Documentation.docc/StructuralProjections.md new file mode 100644 index 0000000..091dc61 --- /dev/null +++ b/Sources/JSONInspection/Documentation.docc/StructuralProjections.md @@ -0,0 +1,102 @@ +# Use complete source-attached structural projections + +Choose core Pointer/read APIs for one value, Navigation for many-node traversal, +and Inspection for observed evidence or complete structural metadata. These +projections are opt-in through `JSONInspection` on unreleased 1.7.0-dev main; +published 1.6.1 does not contain them. They are not schema validation, a new JSON +model or a query language. + +## Select a physical tree + +Build a complete snapshot, then capture one checked physical interval. Metadata +keeps the original parent/depth and insertion/index order. Scalars and empty +containers each have one node. Returned catalogues are complete or throw when +their inclusive cap is insufficient. + +```swift +let document = JSONDocument(root: try JSON.parse(#"{"items":[null,{"0":9007199254740993}]}"#)) +let snapshot = try JSONStructuralSnapshotBuilder(document: document).build().result +let view = try JSONTreeProjection.build(snapshot: snapshot, rootOrdinal: 1).result +let children = try view.children(of: 1, maximumRecords: 2) +precondition(children.result == [2, 3]) +let exactPath = try view.location(for: 4).result +precondition(exactPath == [.key("items"), .index(1), .key("0")]) +let exact = try view.value(for: 4).result.numberValue!.integer(as: UInt64.self) +precondition(exact == 9_007_199_254_740_993) +``` + +Ordinals are trusted integer positions local to the captured snapshot. An integer +accidentally copied from another snapshot cannot be recognized as foreign if it +is in range. Neither records nor ordinals are durable identity. Constructors are +inaccessible; a view cannot attach a replacement document or forge its interval. +`record(at:)` reads fixed metadata without owned growth. Each catalogue, location, +value or span lookup is an explicitly separate finite operation that re-admits +the entire captured source. K lookups pay K admissions. Full value/path lookup is +not constant-time; spans are optional coherent original mappings only. + +## Admit every row before returning a sparse table + +The complete selected array must contain only objects, including its final row. +Rows keep original physical positions; columns follow first-seen exact JSONKey +order. Empty `[]` is 0-by-0; `[{},{}]` is 2-by-0. A sparse table stores original +member positions internally rather than a dense null grid or another JSON tree. +Cell lookup preserves three-state presence and exact decimals/scalar keys. + +```swift +let source = JSONDocument(root: try JSON.parse(#"[{"n":9007199254740993,"é":null},{"e\u0301":0.0100},{}]"#)) +let report = try JSONSparseTableProjection.build(document: source) +let table = report.result +precondition(table.rowCount == 3) +precondition(table.columns == [JSONKey("n"), JSONKey("é"), JSONKey("e\u{301}")]) +let explicitNull = try table.cell(row: 0, column: 1).result +let missing = try table.cell(row: 2, column: 0).result +precondition(explicitNull == .null && missing == .absent) +if case .value(let value) = try table.cell(row: 0, column: 0).result { + let integer = try value.numberValue!.integer(as: UInt64.self) + precondition(integer == 9_007_199_254_740_993) +} else { preconditionFailure("Expected an exact present integer") } +precondition(report.statistics[.workUnits] > 0) +``` + +`rowCount` certifies complete row admission by this constructor. The `traversal` +summary separately describes walker coverage; descendants may be restricted. +Bounds errors never return absent/null. Negative settings fail before admission; +missing/wrong-kind selection, nonobject rows, quota exhaustion and cancellation +throw without a usable partial table. Existing prefix evidence cannot admit a +complete table or prove a numeric matrix/schema. + +```swift +let source = JSONDocument(root: try JSON.parse("[{},{},false]")) +let prefix = try JSONShapeInspector(document: source) + .inspectArray(sampling: .prefix(maximumRows: 2)).result +precondition(prefix.observedAllObjects == true) +do { + _ = try JSONSparseTableProjection.build(document: source) + preconditionFailure("A prefix cannot certify the unexamined final row") +} catch JSONProjectionFailure.nonObjectRow(let location, let kind) { + precondition(location == [.index(2)] && kind == .boolean) +} +``` + +## Finite ownership and costs + +Every constructor uses one original Navigation-owned reducer/read scope/meter, +including full source admission, exact comparisons, growth, finalization and +one-shot source transfer. No read cursor escapes. Separate public lookup calls +have separate explicit finite limits, not the construction ledger's remainder. +Returned immutable values may be shared; each concurrent invocation owns its +mutable state. Caller instructions and storage remain caller work. + +Defaults are inclusive and finite: 100,000 snapshot/catalogue records, 100,000 +table rows, 10,000 first-seen columns and 1,000,000 present members, plus existing +49 core caps. Original logical weights remain: tree view 64 plus snapshot alias +128 + 96 per record + edge-key UTF-8 bytes; catalogue 32 + 8 per returned ordinal +and 96 temporary bytes; table 256 + 8 per offset + 64 per column + key bytes + 16 +per present member, plus captured source/selection. Reservations precede growth. +These are logical policy, not heap size, RSS or caller instruction limits. + +Record retention is proportional to nodes/edge-key bytes. Build costs are +depth-sensitive; exact linear first-seen column scans may be quadratic. G4 +controlled performance remains HOLD. No throughput, latency, RSS or speedup +claim follows from these structures. Persistence, graph/store/set/matrix, +retrieval, BFS, JSONPath and CLI/HTML integration remain separate future work. diff --git a/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift b/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift index 8a6c3f0..2ac127d 100644 --- a/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift +++ b/Sources/JSONInspection/Projections/JSONSparseTableProjection.swift @@ -8,18 +8,22 @@ package struct JSONSparseTableMember: Sendable, Equatable { package let columnOrdinal: Int } -/// Experimental complete all-object array metadata, never a schema/matrix verdict. +/// Complete all-object array metadata, never a schema or numeric matrix verdict. /// Stores no cell JSON/path copy, dense grid, guessed row id or normalized key. -package struct JSONSparseTableProjection: Sendable { - package let document: JSONDocument - package let selectedArrayPath: [JSONLocationComponent] - package let rowCount: Int - package let columns: [JSONKey] +public struct JSONSparseTableProjection: Sendable { + /// Captured immutable source; cell lookups cannot rebind it. + public let document: JSONDocument + /// Exact absolute path of the completely checked array; [] denotes the root. + public let selectedArrayPath: [JSONLocationComponent] + /// Complete number of original array rows, including empty object rows. + public let rowCount: Int + /// Distinct decoded-scalar keys in deterministic first-seen source order. + public let columns: [JSONKey] /// Nondecreasing prefix offsets; an empty object row has an empty slice. package let rowOffsets: [Int] package let presentMembers: [JSONSparseTableMember] /// Descendant traversal may be restricted although every physical row was admitted. - package let traversal: JSONTraversalSummary + public let traversal: JSONTraversalSummary fileprivate init(document: JSONDocument, selectedArrayPath: [JSONLocationComponent], rowCount: Int, columns: [JSONKey], rowOffsets: [Int], presentMembers: [JSONSparseTableMember], traversal: JSONTraversalSummary) { @@ -33,7 +37,20 @@ package struct JSONSparseTableProjection: Sendable { /// Negative configuration precedes admission; source/root and row failures throw. /// Logical policy v1:256 fixed +8/offset +64/column +exact key bytes +16/member, /// retained selection and captured source. No partial or prefix output exists. - package static func build(document: JSONDocument, at path: [JSONLocationComponent] = [], + /// Every selected row is checked, even when prior N2 prefix evidence was positive. + /// An empty array is 0-by-0; two empty objects are 2-by-0. Linear exact column + /// scans may be quadratic. Logical bytes are policy, not process RSS. + /// - Parameters: + /// - document: Canonical immutable source, admitted once in this invocation. + /// - path: Existing exact typed array location; keys and indices are distinct. + /// - limits: One finite profile shared by selection, classification and output. + /// - maximumRows: Inclusive complete-row bound, default 100,000. + /// - maximumColumns: Inclusive first-seen exact-key bound, default 10,000. + /// - maximumPresentCells: Inclusive present-member bound, default 1,000,000. + /// - Returns: Complete source-attached sparse table and cumulative statistics. + /// - Throws: Negative configuration, wrong-kind/missing source, nonobject row, + /// capacity/resource failure or cancellation; never a partial successful table. + public static func build(document: JSONDocument, at path: [JSONLocationComponent] = [], limits: JSONLimits = .balanced, maximumRows: Int = 100_000, maximumColumns: Int = 10_000, maximumPresentCells: Int = 1_000_000) throws -> JSONOperationReport { @@ -49,7 +66,13 @@ package struct JSONSparseTableProjection: Sendable { /// A NEW owned whole-source-admitted lookup, not the construction meter's remainder. /// Row slices are scanned with charged work. Core JSONObject lookup and scalar /// comparison own presence/key identity. Wrong bounds never become absence/null. - package func cell(row: Int, column: Int, limits: JSONLimits = .balanced) + /// - Parameters: + /// - row: Original zero-based physical array position. + /// - column: Position in this table's first-seen exact columns. + /// - limits: Finite quotas for this new operation, independent of construction. + /// - Returns: Distinct absent, explicit null or canonical value and actual statistics. + /// - Throws: Typed bounds, core access/resource/configuration errors or cancellation. + public func cell(row: Int, column: Int, limits: JSONLimits = .balanced) throws -> JSONOperationReport> { guard row >= 0, row < rowCount else { throw JSONProjectionFailure.rowOutOfBounds(row) } guard column >= 0, column < columns.count else { throw JSONProjectionFailure.columnOutOfBounds(column) } diff --git a/Sources/JSONInspection/Projections/JSONTreeProjection.swift b/Sources/JSONInspection/Projections/JSONTreeProjection.swift index 763cb22..ed207c3 100644 --- a/Sources/JSONInspection/Projections/JSONTreeProjection.swift +++ b/Sources/JSONInspection/Projections/JSONTreeProjection.swift @@ -2,15 +2,33 @@ import JSON import JSONNavigation -/// Experimental package-only refusals. Positions are local to the captured source. -package enum JSONProjectionFailure: Error, Sendable, Equatable { +/// Checked projection refusals; positions are local to the captured source. +public enum JSONProjectionFailure: Error, Sendable, Equatable { + /// The local position is outside the selected physical interval. + /// - Parameter ordinal: Rejected snapshot-local position. case outsideSelectedSubtree(ordinal: Int) + /// The next catalogue entry exceeds the inclusive returned-record cap. + /// - Parameter limit: Configured nonnegative maximum. case recordLimitExceeded(limit: Int) + /// The complete array exceeds the inclusive row cap. + /// - Parameter limit: Configured nonnegative maximum. case rowLimitExceeded(limit: Int) + /// The next first-seen exact key exceeds the inclusive column cap. + /// - Parameter limit: Configured nonnegative maximum. case columnLimitExceeded(limit: Int) + /// The next present object member exceeds the inclusive sparse-cell cap. + /// - Parameter limit: Configured nonnegative maximum. case presentCellLimitExceeded(limit: Int) + /// A row position is outside the complete table. + /// - Parameter row: Rejected physical row position. case rowOutOfBounds(Int) + /// A column position is outside the first-seen exact columns. + /// - Parameter column: Rejected local column position. case columnOutOfBounds(Int) + /// An actual row is not an object; a prefix observation cannot admit it. + /// - Parameters: + /// - at: Absolute exact typed location of the rejected row. + /// - kind: Canonical kind of that row. case nonObjectRow(at: [JSONLocationComponent], kind: JSONTraversalKind) } @@ -38,10 +56,13 @@ internal enum ProjectionAccounting { /// A selected physical interval in one complete sealed snapshot, not another DOM. /// No source replacement or detached handle is accepted. Metadata keeps original /// parent/depth/path meaning, even when the selected root has a physical parent. -package struct JSONTreeProjection: Sendable { - package let snapshot: JSONStructuralSnapshot - package let rootOrdinal: Int - package let endExclusive: Int +public struct JSONTreeProjection: Sendable { + /// Complete immutable snapshot captured by this view. + public let snapshot: JSONStructuralSnapshot + /// Selected root position in the captured snapshot; depths are not rebased. + public let rootOrdinal: Int + /// Exclusive end of this selected physical preorder interval. + public let endExclusive: Int fileprivate init(snapshot: JSONStructuralSnapshot, rootOrdinal: Int, endExclusive: Int) { self.snapshot = snapshot; self.rootOrdinal = rootOrdinal; self.endExclusive = endExclusive } @@ -50,7 +71,13 @@ package struct JSONTreeProjection: Sendable { /// all retained record/key aliases and selection share the original N1 ledger. /// Output policy:64 view +128 snapshot header +96/record +exact edge UTF8 bytes, /// plus the already-admitted source. The physical COW storage may be shared. - package static func build(snapshot: JSONStructuralSnapshot, rootOrdinal: Int = 0, + /// - Parameters: + /// - snapshot: Complete attached snapshot; no replacement source is accepted. + /// - rootOrdinal: Local trusted position; bounds checked before admission. + /// - limits: Finite quotas for this independent construction operation. + /// - Returns: Immutable source-attached view and cumulative construction statistics. + /// - Throws: Snapshot bounds, resource/configuration failures or cancellation. + public static func build(snapshot: JSONStructuralSnapshot, rootOrdinal: Int = 0, limits: JSONLimits = .balanced) throws -> JSONOperationReport { guard rootOrdinal >= 0, rootOrdinal < snapshot.recordCount else { @@ -62,7 +89,10 @@ package struct JSONTreeProjection: Sendable { } /// Ordinary fixed metadata access; there is no owned growth or new report. - package func record(at ordinal: Int) throws -> JSONStructuralRecord { + /// - Parameter ordinal: Local snapshot position within this selected interval. + /// - Returns: Original immutable metadata, including physical parent and depth. + /// - Throws: `JSONProjectionFailure.outsideSelectedSubtree` for an invalid position. + public func record(at ordinal: Int) throws -> JSONStructuralRecord { try validate(ordinal) return try snapshot.record(at: ordinal) } @@ -74,13 +104,25 @@ package struct JSONTreeProjection: Sendable { /// New full-source-admitted operation. Every read/jump/append is charged; /// returned slots cost32 fixed +8/ordinal, with96 temporary record bytes. - package func children(of ordinal: Int, maximumRecords: Int = 100_000, + /// - Parameters: + /// - ordinal: Local position within the selected interval. + /// - maximumRecords: Inclusive returned-child cap, default 100,000. + /// - limits: Finite quotas for this separate whole-source-admitted operation. + /// - Returns: Immediate child positions in canonical order and actual statistics. + /// - Throws: Invalid bounds/configuration, capacity/resource refusal or cancellation. + public func children(of ordinal: Int, maximumRecords: Int = 100_000, limits: JSONLimits = .balanced) throws -> JSONOperationReport<[Int]> { try catalogue(ordinal, childrenOnly: true, maximumRecords: maximumRecords, limits: limits) } /// Includes the selected node in its finalized half-open preorder interval. /// An insufficient inclusive cap throws rather than returning a truncated list. - package func subtreeOrdinals(of ordinal: Int, maximumRecords: Int = 100_000, + /// - Parameters: + /// - ordinal: Local position within the selected interval. + /// - maximumRecords: Inclusive returned-position cap, default 100,000. + /// - limits: Finite quotas for this separate whole-source-admitted operation. + /// - Returns: Complete preorder subtree positions and actual operation statistics. + /// - Throws: Invalid bounds/configuration, capacity/resource refusal or cancellation. + public func subtreeOrdinals(of ordinal: Int, maximumRecords: Int = 100_000, limits: JSONLimits = .balanced) throws -> JSONOperationReport<[Int]> { try catalogue(ordinal, childrenOnly: false, maximumRecords: maximumRecords, limits: limits) } @@ -96,15 +138,32 @@ package struct JSONTreeProjection: Sendable { /// Each forwarding call delegates once to N3's independent full-source lookup. /// Constant local bounds checks are ordinary metadata access, not a hidden operation. - package func location(for ordinal: Int, limits: JSONLimits = .balanced) + /// - Parameters: + /// - ordinal: Trusted position local to the captured snapshot and selected interval. + /// - limits: Finite quotas for this separate full-source-admitted lookup. + /// - Returns: Absolute exact typed location and cumulative lookup statistics. + /// - Throws: Bounds, core resource/configuration errors or cancellation. + public func location(for ordinal: Int, limits: JSONLimits = .balanced) throws -> JSONOperationReport<[JSONLocationComponent]> { try validate(ordinal); return try snapshot.location(for: ordinal, limits: limits) } - package func value(for ordinal: Int, limits: JSONLimits = .balanced) + /// Resolves the canonical value through the snapshot's one semantic delegate. + /// - Parameters: + /// - ordinal: Trusted local position inside the selected interval. + /// - limits: Finite quotas for a new whole-source-admitted lookup. + /// - Returns: Immutable read-value alias and actual lookup statistics. + /// - Throws: Bounds, core access/resource/configuration errors or cancellation. + public func value(for ordinal: Int, limits: JSONLimits = .balanced) throws -> JSONOperationReport { try validate(ordinal); return try snapshot.value(for: ordinal, limits: limits) } - package func sourceSpan(for ordinal: Int, limits: JSONLimits = .balanced) + /// Resolves a coherent original span through the captured snapshot. + /// - Parameters: + /// - ordinal: Trusted local position inside the selected interval. + /// - limits: Finite quotas for a new whole-source-admitted lookup. + /// - Returns: Optional original span and actual statistics; no historical map is invented. + /// - Throws: Bounds, core resource/configuration errors or cancellation. + public func sourceSpan(for ordinal: Int, limits: JSONLimits = .balanced) throws -> JSONOperationReport { try validate(ordinal); return try snapshot.sourceSpan(for: ordinal, limits: limits) } diff --git a/Tools/ProjectionQualification/Package.swift b/Tools/ProjectionQualification/Package.swift new file mode 100644 index 0000000..46ec995 --- /dev/null +++ b/Tools/ProjectionQualification/Package.swift @@ -0,0 +1,12 @@ +// swift-tools-version: 6.4 +// SPDX-License-Identifier: Apache-2.0 +import PackageDescription +let package = Package( + name: "ProjectionQualification", + platforms: [.macOS("27.0"), .iOS("27.0")], + dependencies: [.package(name: "Swift-JSON", path: "../..")], + targets: [.executableTarget(name: "ProjectionConsumer", dependencies: [ + .product(name: "JSON", package: "Swift-JSON"), + .product(name: "JSONNavigation", package: "Swift-JSON"), + .product(name: "JSONInspection", package: "Swift-JSON")])], + swiftLanguageModes: [.v6]) diff --git a/Tools/ProjectionQualification/README.md b/Tools/ProjectionQualification/README.md new file mode 100644 index 0000000..b834915 --- /dev/null +++ b/Tools/ProjectionQualification/README.md @@ -0,0 +1,14 @@ +# Public projection consumer + +This independent SwiftPM package depends on public JSON, JSONNavigation and +JSONInspection products. Run `swift run --package-path Tools/ProjectionQualification +ProjectionConsumer` from the repository root. It executes 16 named cases using +public APIs only: exact physical intervals/paths/values, source coherence, complete +table admission, scalar-distinct columns, three-state presence, empty/equal rows, +late refusal, finite bounds, inclusive work/retention and cancellation health. + +`Scripts/qualify_public_projections.py` checks those exact identities in Debug, +Release and ASan, compiles/runs all three DocC guide blocks in both configurations, +and requires 18 ordinary full-codegen access/invariant diagnostics. The separate +private-storage qualifier retains the original P1 reducer/storage proofs. No new +product/dependency or platform/runtime/performance claim is introduced. diff --git a/Tools/ProjectionQualification/Sources/ProjectionConsumer/Main.swift b/Tools/ProjectionQualification/Sources/ProjectionConsumer/Main.swift new file mode 100644 index 0000000..04b52b1 --- /dev/null +++ b/Tools/ProjectionQualification/Sources/ProjectionConsumer/Main.swift @@ -0,0 +1,162 @@ +// SPDX-License-Identifier: Apache-2.0 +import Foundation +import JSON +import JSONNavigation +import JSONInspection + +private func expect(_ condition: @autoclosure () throws -> Bool) throws { + let satisfied = try condition(); precondition(satisfied) +} +private func check(_ name: String, _ body: () throws -> Void) rethrows { + try body(); print("PROJECTION_CHECK \(name) passed") +} +private func document(_ text: String) throws -> JSONDocument { + try JSONParser().parseDocument(Data(text.utf8)) +} +private func resource(_ body: () throws -> Void) -> JSONFailure { + do { try body(); preconditionFailure("Expected operational failure") } + catch let error as JSONFailure { return error } + catch { preconditionFailure("Unexpected error: \(error)") } +} +private func sendable(_ value: T) { _ = value } + +@main struct ProjectionConsumer { + static func main() async throws { + let source = try document(#"{"":null,"0":[9007199254740993,0.1,0.0100],"rows":[{"é":null,"n":9007199254740993},{"e\u0301":0.0100},{}]}"#) + let captured = try JSONStructuralSnapshotBuilder(document: source).build() + let snapshot = captured.result + let treeReport = try JSONTreeProjection.build(snapshot: snapshot) + let tree = treeReport.result + let built = try JSONSparseTableProjection.build(document: source, at: [.key("rows")]) + let table = built.result + sendable(tree); sendable(table); sendable(JSONProjectionFailure.rowOutOfBounds(-1)) + + try check("scalar-roots") { + for text in ["null", "false", "1", #""s""#, "{}", "[]"] { + let one = try JSONStructuralSnapshotBuilder(document: document(text)).build().result + let view = try JSONTreeProjection.build(snapshot: one).result + try expect(view.rootOrdinal == 0 && view.endExclusive == 1) + try expect(try view.children(of: 0).result.isEmpty) + try expect(try view.subtreeOrdinals(of: 0).result == [0]) + } + } + try check("selected-interval") { + let selected = try JSONTreeProjection.build(snapshot: snapshot, rootOrdinal: 2).result + try expect(selected.rootOrdinal == 2 && selected.endExclusive == 6) + let root = try selected.record(at: 2) + try expect(root.parentOrdinal == 0 && root.depth == 1) + try expect(try selected.children(of: 2).result == [3,4,5]) + do { _ = try selected.record(at: 1); preconditionFailure("Outside interval") } + catch JSONProjectionFailure.outsideSelectedSubtree(let ordinal) { try expect(ordinal == 1) } + } + try check("typed-locations") { + try expect(try tree.location(for: 0).result == []) + try expect(try tree.location(for: 1).result == [.key("")]) + try expect(try tree.location(for: 2).result == [.key("0")]) + try expect(try tree.location(for: 3).result == [.key("0"), .index(0)]) + try expect(try tree.record(at: 2).componentFromParent != .index(0)) + } + try check("exact-values") { + try expect(try tree.value(for: 3).result.numberValue?.integer(as: UInt64.self) == 9_007_199_254_740_993) + try expect(try tree.value(for: 4).result.numberValue == JSONNumber(parsing: "0.1")) + try expect(try tree.value(for: 5).result.numberValue?.originalLexeme == "0.0100") + if case .value(let n) = try table.cell(row: 0, column: 1).result { + try expect(try n.numberValue?.integer(as: UInt64.self) == 9_007_199_254_740_993) + } else { preconditionFailure("Exact nonnull integer required") } + } + try check("canonical-order") { + try expect(try tree.children(of: 0).result == [1,2,6]) + let visited = try JSONTraversal(document: source).collect().result + let positions = try tree.subtreeOrdinals(of: 0).result + try expect(positions.count == snapshot.recordCount) + for index in positions.indices { + try expect(try tree.location(for: positions[index]).result == visited.nodes[index].absoluteLocation) + } + } + try check("source-coherence") { + try expect(try tree.sourceSpan(for: 3).result != nil) + let replacement = source.replacingRoot(.null) + let other = try JSONTreeProjection.build(snapshot: JSONStructuralSnapshotBuilder(document: replacement).build().result).result + try expect(try other.sourceSpan(for: 0).result == nil) + try expect(try tree.value(for: 0).result == source.root) + } + try check("complete-columns") { + try expect(table.rowCount == 3 && table.selectedArrayPath == [.key("rows")]) + try expect(table.columns == [JSONKey("é"), JSONKey("n"), JSONKey("e\u{301}")]) + try expect(table.document.root == source.root) + // Row admission is complete even though nested traversal is restricted. + try expect(table.traversal.visitedCount == 4) + } + try check("scalar-key-columns") { + try expect(table.columns[0] != table.columns[2]) + if case .value(let value) = try table.cell(row: 1, column: 2).result { + try expect(value.numberValue?.originalLexeme == "0.0100") + } else { preconditionFailure("Scalar-distinct key required") } + try expect(try table.cell(row: 1, column: 0).result == .absent) + } + try check("presence") { + try expect(try table.cell(row: 0, column: 0).result == .null) + try expect(try table.cell(row: 2, column: 0).result == .absent) + try expect(try table.cell(row: 0, column: 1).result != .null) + } + try check("empty-tables") { + let zero = try JSONSparseTableProjection.build(document: document("[]")).result + let rows = try JSONSparseTableProjection.build(document: document("[{},{}]")).result + try expect(zero.rowCount == 0 && zero.columns.isEmpty) + try expect(rows.rowCount == 2 && rows.columns.isEmpty) + do { _ = try rows.cell(row: 0, column: 0); preconditionFailure("No fabricated cell") } + catch JSONProjectionFailure.columnOutOfBounds(let column) { try expect(column == 0) } + } + try check("equal-physical-rows") { + let equal = try JSONSparseTableProjection.build(document: document(#"[{"0":7},{"0":7}]"#)).result + try expect(equal.rowCount == 2 && equal.columns == [JSONKey("0")]) + try expect(try equal.cell(row: 0, column: 0).result == equal.cell(row: 1, column: 0).result) + } + try check("late-row-refusal") { + let late = try document(#"{"rows":[{},{},false]}"#) + let evidence = try JSONShapeInspector(document: late).inspectArray(at: [.key("rows")], sampling: .prefix(maximumRows: 2)).result + try expect(evidence.observedAllObjects == true) + do { _ = try JSONSparseTableProjection.build(document: late, at: [.key("rows")]); preconditionFailure("Prefix cannot certify suffix") } + catch JSONProjectionFailure.nonObjectRow(let path, let kind) { + try expect(path == [.key("rows"), .index(2)] && kind == .boolean) + } + } + try check("capacity-and-bounds") { + do { _ = try tree.children(of: 0, maximumRecords: 2); preconditionFailure("No partial catalogue") } + catch JSONProjectionFailure.recordLimitExceeded(let cap) { try expect(cap == 2) } + do { _ = try JSONSparseTableProjection.build(document: source, at: [.key("rows")], maximumRows: 2); preconditionFailure("All rows required") } + catch JSONProjectionFailure.rowLimitExceeded(let cap) { try expect(cap == 2) } + do { _ = try table.cell(row: -1, column: 0); preconditionFailure("No absent fallback") } + catch JSONProjectionFailure.rowOutOfBounds(let row) { try expect(row == -1) } + var none = JSONLimits.balanced; none[.nodes] = 0 + try expect(resource { _ = try JSONSparseTableProjection.build(document: source, limits: none, maximumColumns: -1) }.category == .configuration) + } + try check("separate-admission") { + let lookup = try table.cell(row: 2, column: 0) + for stats in [treeReport.statistics, built.statistics, lookup.statistics] { + try expect(stats[.nodes] == captured.statistics[.nodes]) + try expect(stats[.sourceMapEntries] == captured.statistics[.sourceMapEntries]) + try expect(stats[.workUnits] > 0) + } + print("PROJECTION_RESOURCE work=\(built.statistics[.workUnits]) retained=\(built.statistics[.retainedBytes]) peak=\(built.statistics.peakLogicalRetainedBytes) nodes=\(built.statistics[.nodes])") + } + try check("inclusive-ledgers") { + for metric in [JSONResourceMetric.workUnits, .retainedBytes] { + var limits = JSONLimits.balanced + limits[metric] = metric == .workUnits ? built.statistics[metric] : built.statistics.peakLogicalRetainedBytes + try expect(try JSONSparseTableProjection.build(document: source, at: [.key("rows")], limits: limits).result.rowCount == 3) + limits[metric] -= 1 + try expect(resource { _ = try JSONSparseTableProjection.build(document: source, at: [.key("rows")], limits: limits) }.resource?.metric == metric) + } + } + let cancelled = Task { + withUnsafeCurrentTask { $0?.cancel() } + return try JSONSparseTableProjection.build(document: source, at: [.key("rows")]) + } + do { _ = try await cancelled.value; preconditionFailure("No artifact on cancellation") } + catch is CancellationError { } + try expect(try table.cell(row: 0, column: 0).result == .null) + print("PROJECTION_CHECK cancellation-health passed") + print("PROJECTION_CONSUMER passed cases=16") + } +}