diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 63ba3e9aa8..52b62d0481 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,8 +1,25 @@ # CI verification -## Current selected-family replay: #6030 +## Current selected-family replay: #7000 with #7001 The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json), +and [explicit source closure](../certificates/frontier7000-source.json). +`make frontier7000-verify` follows that exact-source selected replay. The review +reuses eleven authenticated preceding executions and records seven fresh serial +application, scalar and complete native-catalogue executions. The earlier +monolithic timeout is retained separately and is not completed coverage. +Consult the receipts for exact commands, source heads and limits. + +The five inherited framework assumptions remain. No complete uniform word, +literal multiplier execution, independent human proof or formal-kernel proof +is asserted. Routine research submissions do not need to rerun this +selected-family replay. The sections below preserve historical checkpoints. + +## Historical selected-family replay: #6030 + +The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), and [explicit source closure](../certificates/frontier6030-source.json). diff --git a/research/historical-selected-replay-gap/README.md b/research/historical-selected-replay-gap/README.md index 55d8cc3b49..36d9a873ca 100644 --- a/research/historical-selected-replay-gap/README.md +++ b/research/historical-selected-replay-gap/README.md @@ -69,7 +69,11 @@ python3 -B scripts/research_package.py --package research/historical-selected-re The direct command prints `PASS_HISTORICAL_SELECTED_REPLAY_GAP`. A registered replay prints `PASS_REGISTERED_RESEARCH_PACKAGE`. Both require Git history -containing the two inspected commits. +containing the two inspected commits and the source and manifest objects at +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. The verifier uses a temporary +sparse checkout of that commit, checks the declared source digests there, and +uses its planner and manifest inventory. The recorded rejections and selection +therefore remain reproducible after later changes to the live Makefile or CI guide. ## Open next questions diff --git a/research/historical-selected-replay-gap/SOURCES.json b/research/historical-selected-replay-gap/SOURCES.json index c1010eec95..62bb8b3950 100644 --- a/research/historical-selected-replay-gap/SOURCES.json +++ b/research/historical-selected-replay-gap/SOURCES.json @@ -4,13 +4,13 @@ "files": [ { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "0d683a06b9e7ee162496108ce9a7c5d2ee94fccf", "sha256": "4f2d4f2dcd15139ec82658a975f85ed300897385f85799218539f4c8d60567da" }, { "path": "certificates/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "eccafa830c16170c36faf93045ddf1f638f7bcd4", "sha256": "4c0b9d37e1034b2076e30a70f8e514416298c462d9ee98bc87fe6556b14df786" }, @@ -22,7 +22,7 @@ }, { "path": "docs/ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "63ba3e9aa8bdc5e942b56e34244b92b16f854085", "sha256": "c7d3027e9ad8bcbff68f07aa9576b30fb2f3c76c44d876d40c7fdbf4a3e2228a" }, @@ -34,163 +34,163 @@ }, { "path": "research/clifford-state-performance/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "6f98a0061a5104dfab82c9e806f819b41811f684", "sha256": "396d0f08df24952248140d5c65c51b8c902ef1c580892ff7ea182890530f67ee" }, { "path": "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "5e0f92af463ec12c5e1dcc3effd44081a88af647", "sha256": "07a9daeaf2bda308a92e9a4684f13d5fc766c7772d74801fceb7f4599fdab226" }, { "path": "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "9e13266bf85e627f1b7dc225e9530ea69fd2c7f0", "sha256": "421e1211fb1897c45621dc6801c276e53f2e6f335583c9c9049e535f87c0a3b1" }, { "path": "research/community-batch932-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "cc4d03eb59b9ab3f952735f7e88ff18c2d15d7af", "sha256": "184629cac91a5cfaca50330a88596008b824221433867dcf8117539c913c284a" }, { "path": "research/community-batch970-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8b9f4111badf7de5d97684799560b55110e9da79", "sha256": "23188ed920e38a54006cb883e181585620821c63bf7e8b5e05d32719417cc37e" }, { "path": "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "a5300d4e7a5381a3f443fc54c768ca6f0f236d68", "sha256": "3c820fb30e1b4d9bcfc6a7ab524375e5b2abd66b940af2c509146104f0bcd79c" }, { "path": "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "d7ff6d777b01d69b6ce84caf25d3b7e4a4d2f211", "sha256": "6b185a9902652f893f3ebd8ada92d2f11b6de6533a9a4d11718a8a4496101128" }, { "path": "research/community-hyperplane599-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "546f37d326d10a99910ae8f908e71ef768524d98", "sha256": "65099d764bfcc39bda5e4d9966783611b094c3522dbdd1435cd498d657a8ef8e" }, { "path": "research/community-k492-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "e538481e4cb16ed936d3195f2dfb5b5a9ca0a76b", "sha256": "2c0f4fa5bc150d05658af2e7c54c4d2c337dd52b7efd3d69530ae73bcbdf452a" }, { "path": "research/community-reconciliation92-audit/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "2a2e93685173d5f13cbb5abe740f5d90352e0228", "sha256": "5f501f3c118131e7d069f30ad77186eb2ad6961f9680a0ef105f4514ed41808a" }, { "path": "research/partial-swap-digest/baseline.py", - "usage": "input", + "usage": "provenance", "git_blob": "a2f0190704db83bd8ef48e46e723c49b925804fe", "sha256": "81e9af92cdf38243a540cdcff2062778e449467848d444da37a9553c12ca4c34" }, { "path": "research/r420-two-sided-basis/SOURCES.json", - "usage": "input", + "usage": "provenance", "git_blob": "5d718e11e62f4bcadecf1e02d6b61f87dbe190b0", "sha256": "d9810b0d139c5a1211fd2c1f0d142187cc1fca30026e1e7bc4f9ecfacf1596d1" }, { "path": "research/skip-clones/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", "sha256": "0b68e63e35a97ce6b0cdb6e291b88ebaa8f2dd4afb70b2498f10ee89428258dc" }, { "path": "research/split-skip/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", "sha256": "7c2b4646a3ecfef6f881da5c43e4bd0fa9a4d1b00548b8ab458d897e16735134" }, { "path": "scripts/historical-ci-inputs/Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "aff68409021c9d401a6f8013b9dfd7dbcc30f2a8", "sha256": "ea8830dd79da493e2d75baf753d733ff7efbcf2b4794afe41fae0ac8f3055646" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "65db599ab0b1dea0312c4ca048e0bd0f44c3736f", "sha256": "96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "34820a8f24678f918f4d0e7a35380d8013fc3495", "sha256": "628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac" }, { "path": "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "c755b76e0d44ba4917aa94440ebe54daefce5b2a", "sha256": "d7fd929726b326aeeaf0a3996475adec88eee9aac09ae0bebeeaa0bc1fc8f199" }, { "path": "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "7f3c012504187917a728b9fe87043f0fc8cd006a", "sha256": "a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0" }, { "path": "scripts/historical-ci-inputs/partial-swap-context.json", - "usage": "input", + "usage": "provenance", "git_blob": "ad65114886bf34a4fd27e79f3be502389e689faa", "sha256": "833a9642f33aeab2ffea17ec9c6b82e0a953f90192b2c82e10bef21538dccba9" }, { "path": "scripts/historical-ci-inputs/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "52075f2463f60af5e16571347f24274fce73a1ea", "sha256": "f3c4be597b2f2136da4ae2cc80c7454f63c90aa01f84e5b8131cee4dd55de815" }, { "path": "scripts/partial_swap/shared.py", - "usage": "input", + "usage": "provenance", "git_blob": "44a0e454c70f9c4b98e258b8443612e6a119904b", "sha256": "5a0646a50b9f3e8ea55168620a78e8853b0ab810517cefc8cfb8696aedee278a" }, { "path": "scripts/replay_historical_check.py", - "usage": "input", + "usage": "provenance", "git_blob": "1e92fff2782970ef71378f594f2350d245a4db26", "sha256": "5467619c78183d3adc82b0cb55af28e5c1a01fca2b0588677816244b53e2bafd" }, { "path": "scripts/research_package.py", - "usage": "input", + "usage": "provenance", "git_blob": "091b4c8f58bac9a9580d76025b887dc5c873d05f", "sha256": "e1256016e7f51827d04fa2179255989f639ae1d97afaa9c16265f85a0c6abd70" }, { "path": "scripts/run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "a96ab35b315ce492e7fbbfd6c5ae211aa066b541", "sha256": "49eb56dd0fc0d8d8ffdb209970a7adf2176223580646f575d5c22e59543b381c" }, { "path": "scripts/verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "6882a4700e410dec569b51ae2eaf1a19cc019195", "sha256": "d6b305eac5b9bdb8172c469ad30a1655a60fa0aceac8b1bf610e1b73f51babd8" }, { "path": "tests/test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "343b24abf6719b81805eba5a84c74e57634c8288", "sha256": "3a5470d0b139828b90e19bf9583ddeafcd69f8e34f2824664eb3a2958a52e34d" } diff --git a/research/historical-selected-replay-gap/VERIFY.json b/research/historical-selected-replay-gap/VERIFY.json index 98553e72ed..ab7efa3471 100644 --- a/research/historical-selected-replay-gap/VERIFY.json +++ b/research/historical-selected-replay-gap/VERIFY.json @@ -4,36 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "Makefile", - "certificates/partial-swap-network.json", - "docs/ci-verification.md", - "research/clifford-state-performance/SOURCE.json", - "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "research/community-batch932-audit/CONTENT-COVERAGE.json", - "research/community-batch970-audit/CONTENT-COVERAGE.json", - "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "research/community-hyperplane599-audit/SOURCE.json", - "research/community-k492-audit/SOURCE.json", - "research/community-reconciliation92-audit/MANIFEST.json", - "research/partial-swap-digest/baseline.py", - "research/r420-two-sided-basis/SOURCES.json", - "research/skip-clones/SOURCE.json", - "research/split-skip/SOURCE.json", - "scripts/historical-ci-inputs/Makefile", - "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "scripts/historical-ci-inputs/partial-swap-context.json", - "scripts/historical-ci-inputs/partial-swap-network.json", - "scripts/partial_swap/shared.py", - "scripts/replay_historical_check.py", - "scripts/research_package.py", - "scripts/run_isolated_tests.py", - "scripts/verify_selected_result.py", - "tests/test_isolated_test_runner.py" + "scripts/research_package.py" ], "commands": [ { diff --git a/research/historical-selected-replay-gap/verify.py b/research/historical-selected-replay-gap/verify.py index 83b995941a..9d266c5a4e 100644 --- a/research/historical-selected-replay-gap/verify.py +++ b/research/historical-selected-replay-gap/verify.py @@ -6,8 +6,10 @@ """ import hashlib import importlib.util +import json import subprocess import sys +import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[2] @@ -61,31 +63,47 @@ def require(ok, message): raise SystemExit(message) -def load_checker(): - path = ROOT / "scripts/replay_historical_check.py" - spec = importlib.util.spec_from_file_location("historical_selected_replay_gap_checker", path) +def load_module(path): + spec = importlib.util.spec_from_file_location(path.stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module +def checkout_snapshot(snapshot, sources, runner, env): + paths = [runner.canonical_relative_path(row["path"]) for row in sources["files"]] + git = ["git", "-c", "maintenance.auto=false", "-c", "gc.auto=0", + "-c", "core.autocrlf=false"] + subprocess.run([*git, "clone", "--quiet", "--shared", "--no-tags", "--no-checkout", + "--", str(ROOT), str(snapshot)], cwd=ROOT, env=env, check=True) + subprocess.run([*git, "update-ref", "--no-deref", "HEAD", INSPECTED], + cwd=snapshot, env=env, check=True) + # The pinned planner reads omitted manifests from the sparse HEAD/index. + patterns = "".join(f"/{path.as_posix()}\n" for path in paths) + subprocess.run([*git, "sparse-checkout", "set", "--no-cone", "--stdin"], + cwd=snapshot, env=env, input=patterns.encode("utf-8"), check=True) + subprocess.run([*git, "read-tree", "-mu", "HEAD"], cwd=snapshot, env=env, check=True) + for path, row in zip(paths, sources["files"], strict=True): + require(hashlib.sha256((snapshot / path).read_bytes()).hexdigest() == row["sha256"], + "historical checkout source digest changed: " + path.as_posix()) + + def entries(checker): for name, config in checker.CONFIG.items(): for entry in [config, *config.get("additional_inputs", [])]: yield name, entry -def reject(checker, entry): +def reject(root, checker, entry): try: - checker.authenticated_input(ROOT, entry) + checker.authenticated_input(root, entry) except ValueError as exc: return str(exc) raise SystemExit("historical input was admitted: " + entry["path"]) -def main(): - require(not sys.flags.optimize, "assertions must stay enabled") - checker = load_checker() +def check_snapshot(root, env): + checker = load_module(root / "scripts/replay_historical_check.py") selected = [entry for name, entry in entries(checker) if name == "tooling-ledger" and entry["path"] == SELECTED_PATH] require(len(selected) == 1, "selected-result checker overlay is not unique") @@ -94,7 +112,7 @@ def main(): require(entry["accepted_live_sha256"] == [SELECTED_ACCEPTED], "accepted selected-checker successors changed") frozen = (checker.INPUTS / entry["input"]).read_bytes() - live = (ROOT / SELECTED_PATH).read_bytes() + live = (root / SELECTED_PATH).read_bytes() require(hashlib.sha256(frozen).hexdigest() == SELECTED_PIN, "frozen selected checker bytes changed") require(hashlib.sha256(live).hexdigest() == SELECTED_LIVE, "live selected checker digest changed") require(SELECTED_LIVE not in (SELECTED_PIN, SELECTED_ACCEPTED), "live checker was already admitted") @@ -102,7 +120,7 @@ def main(): # live successor, not a broken comparison. require(SELECTED_PIN in (SELECTED_PIN, *entry["accepted_live_sha256"]), "pin membership control failed") - require(reject(checker, entry) == REJECTIONS[SELECTED_PATH][1], + require(reject(root, checker, entry) == REJECTIONS[SELECTED_PATH][1], "selected checker rejection text changed") counts = {path: 0 for path in REJECTIONS} @@ -110,7 +128,7 @@ def main(): for _name, item in entries(checker): if item["path"] not in REJECTIONS: continue - message = reject(checker, item) + message = reject(root, checker, item) counts[item["path"]] += 1 messages.setdefault(item["path"], message) for path, (count, message) in REJECTIONS.items(): @@ -118,20 +136,31 @@ def main(): require(messages[path] == message, "rejection text changed for " + path) require(sum(counts.values()) == 19, "rejection total changed") ci = [item for _name, item in entries(checker) if item["path"] == CI_PATH] - require(len(ci) == 1 and hashlib.sha256((ROOT / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, + require(len(ci) == 1 and hashlib.sha256((root / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, "selected CI note digest changed") diff = subprocess.check_output( - ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=ROOT, text=True) + ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=root, env=env, text=True) changed = sorted(name for name in diff.splitlines() if name) require(changed == CHANGED, "inspected commit diff changed") - sys.path.insert(0, str(ROOT / "scripts")) - from research_package import plan_details - details = plan_details(ROOT, set(changed)) + planner = load_module(root / "scripts/research_package.py") + details = planner.plan_details(root, set(changed)) require([row["package"] for row in details] == PLAN_PACKAGES, "helper plan selection changed") matched = {name for row in details for names in row["causes"].values() for name in names} require(sorted(set(changed) - matched) == UNMATCHED, "unmatched plan paths changed") - require(plan_details(ROOT, set()) == [], "empty change set selected a package") + require(planner.plan_details(root, set()) == [], "empty change set selected a package") + + +def main(): + require(not sys.flags.optimize, "assertions must stay enabled") + sources = json.loads(Path(__file__).with_name("SOURCES.json").read_bytes()) + require(sources["base_commit"] == INSPECTED, "historical checkout base changed") + runner = load_module(ROOT / "scripts/research_package.py") + env = runner.git_source_env() + with tempfile.TemporaryDirectory(prefix="historical-selected-replay-") as temporary: + snapshot = Path(temporary) / "snapshot" + checkout_snapshot(snapshot, sources, runner, env) + check_snapshot(snapshot, env) print("PASS_HISTORICAL_SELECTED_REPLAY_GAP") print("selected_checker_live=" + SELECTED_LIVE) print("rejections=19 distinct_paths=7 plan_packages=9") diff --git a/research/p104-endpoint-common-plane-growth-bound/NOTICE.md b/research/p104-endpoint-common-plane-growth-bound/NOTICE.md new file mode 100644 index 0000000000..dfdbd6ac80 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/NOTICE.md @@ -0,0 +1 @@ +The exact source lineage and predecessor credits are in README.md and PROVENANCE.json. OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging. This package is contributed under the repository's Apache-2.0 license. diff --git a/research/p104-endpoint-common-plane-growth-bound/PINS.json b/research/p104-endpoint-common-plane-growth-bound/PINS.json new file mode 100644 index 0000000000..d8a39bb82f --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/PINS.json @@ -0,0 +1,16 @@ +{ + "PROVENANCE.json": "06f58620f83ebc587dec95437b1f0e444b170d34774eac99518e2cab60e66a31", + "cut_flow.py": "a16c67f11d216d0a7d7f4caf0b994cc0a1dcbc01d667ed0924691f72f0959cdb", + "endpoint_replay.py": "24d63caf9e647840f47675fecf775803c509f5fbc7ae6fc6b5d450782ec1d81d", + "independent.py": "2a2152429465177d776aacae7fe3ccd01be9ce1993ce6c7fa649d67ec07e56dc", + "inputs/7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "inputs/R226-PLANES.json": "68ea271a02374de22edfa105e6033ebc670087d3627798f15bab14c9962479b8", + "inputs/closure.py": "64f57a509aac0c7f56c33ce5f84f99c3a4377d4ecc993f7424ad4115542a173f", + "inputs/inventory.py": "347a7d90d34f0d7134d4dc68d95f135ee7cd9e002d6176eb5968f85f00db7d43", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "inputs/target_closure.py": "8ef8fbc45d4f2414944443d2a89147b4b9c2ba225d0faa065dc351f212b709fb", + "lead.py": "77aaf5270d4c73f06cdf113e88fbde493323e8240b356441cd7e6c493ab178ec", + "receipts/INDEPENDENT.json": "73e859d09dbeb7f5b3091de27f3eaf93e3d8df7ed2712f87ab9c6980014dd1fd", + "receipts/LEAD.json.gz": "8b7b11f0e25fc7771f7ddb973982027da318a322491902f510a060f800e70bea", + "reverse_inventory.py": "ac01889cd8e917b5c3f93dcefaa19c159efc18bcdd6973b94b481f08185d0127" +} diff --git a/research/p104-endpoint-common-plane-growth-bound/PROOF.md b/research/p104-endpoint-common-plane-growth-bound/PROOF.md new file mode 100644 index 0000000000..82978e4412 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/PROOF.md @@ -0,0 +1,11 @@ +# Common-plane growth with productive endpoints + +Work in the nine-dimensional binary chart space. Cocharted ADD/COPY contacts connect chart segments into groups. Every member of an eligible group belongs to a public productive helper. Main and owned frames, scalar chronology, and the signed caller stay fixed. An eligible group may keep chart A or change it to A+P, where P is one common two-dimensional subspace. Initial and terminal helper charts may change, subject to their productive edge staying strictly nested. + +On each old nested edge A⊂B of gap d, write a=dim(A+P)−dim(A) and b=dim(B+P)−dim(B). Then a≥b. If b>0, selecting the lower group forces selecting the upper group, and old, upper-only and both-grow gaps are d, d+b and d+b−a. If b=0, lower growth has gap d−a and the upper chart is unchanged. A zero gap costs zero on a paid edge, and a zero productive gap is forbidden. An equal paid edge with b>0 still forces the lower-to-upper implication and has zero both-grow saving. + +The gain on a paid edge is H(old)−H(new) and on a productive target edge it is H(new)−H(old), where H(r)=r^(1−κ) and H(0)=0. On allowed states this objective is affine in the two selection bits, so the lead implements maximum closure. The independent evaluator recovers groups from the literal tape in reverse and prices each edge with direct cut capacities. On a paid edge, offer the both-grow shortening reward at the lower vertex and charge upper-only growth on an upper-to-lower arc. On a productive edge, offer the upper-only reward at the upper vertex, cancel that reward by charging it at the lower vertex, and charge any productive shortening at the lower vertex. Required nesting and positive productive rank are hard implications. Fixed vertices reduce these arcs to terminal capacities where applicable. + +The directed prices enclose all nine increments H(r)−H(r−1) at the same pinned comparator κ. First allow independent directed endpoints for each signed edge contribution. For an unresolved nonpositive case use one common increment vector for every edge. Doubling the increment box gives center c and one-norm radius R equal to the sum of the original interval widths. The doubled box lies in the convex hull of the 18 exact points c±R e_i. For a fixed plane and legal selection the objective is linear in those increments. Its maximum over selections is convex and is bounded above throughout the hull by the largest exact upper at a vertex. A zero optimum includes the option to leave all groups unchanged. + +The candidate ranking uses the sum of available positive isolated paid shortening and productive growth, ignoring dependencies only for ranking. The replay pins the 1,014 planes from the predecessor's four-direction sample, recomputes their entire ordering, and solves only the frozen first 256. The objective grants no extra realization expense. The result applies to the fixed common plane and allowed group selections only. diff --git a/research/p104-endpoint-common-plane-growth-bound/PROVENANCE.json b/research/p104-endpoint-common-plane-growth-bound/PROVENANCE.json new file mode 100644 index 0000000000..fccc06d7bb --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/PROVENANCE.json @@ -0,0 +1,42 @@ +{ + "benchmark": { + "compressed_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "head": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "kappa": "0.003647081039689", + "path": "research/p104-funded-485-1455-return/producer54/reroute/WORD.json.gz", + "pr": 7481, + "uncompressed_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8" + }, + "caller": { + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "pr": 7113 + }, + "predecessors": [ + { + "credit": "Four-direction plane population from fixed-endpoint growth.", + "head": "7f513e3d5519ae5b83394e066fc18eccc538d7d9", + "pr": 7458 + }, + { + "credit": "Endpoint-aware helper groups, reverse index and shared directed increment price enclosure.", + "head": "63e014f34de6d1a8cedcd238c40880746ef47e19", + "pr": 7456 + }, + { + "credit": "Exact direct cut capacities and reverse transport index for helper growth.", + "head": "deb2f815482fbd6009cc72e219b12c48cdd49946", + "pr": 7454 + }, + { + "credit": "Related closure analysis under dimension-linear signed prices.", + "head": "a1b1b327a0780b3ec12c4aa02586487c017e1256", + "pr": 7465 + }, + { + "credit": "Directed rank-power arithmetic.", + "head": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "pr": 7362 + } + ], + "schema_version": 1 +} diff --git a/research/p104-endpoint-common-plane-growth-bound/README.md b/research/p104-endpoint-common-plane-growth-bound/README.md new file mode 100644 index 0000000000..c10b55aa45 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/README.md @@ -0,0 +1,17 @@ +# Bound common-plane helper growth with productive endpoints + +The source is exact [#7481](https://github.com/CrocSwap/integer-mult-bounds/pull/7481) with the retained [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) signed caller. Any eligible productive-public helper component may grow by a common two-dimensional plane, with every productive edge kept positive and every incident paid or productive rank charged. The [proof](PROOF.md) gives the exact paid and productive cut model. + +The two engines exclude all 256 tested planes at the top of the 1,014-plane saved population. All 4,608 shared-price vertex optimizations give upper saving zero. The scan covers 552 eligible helper groups, 2,565 incident paid edges and 193 productive target edges. The other 758 saved planes and 42,421 planes outside the saved population are untested. The conditional exponent is unchanged. + +From a clean POSIX checkout with CPython 3.12: + +```sh +python3.12 -I -B research/p104-endpoint-common-plane-growth-bound/replay.py +``` + +[#7458](https://github.com/CrocSwap/integer-mult-bounds/pull/7458) supplied the four-direction plane population under fixed endpoints. [#7456](https://github.com/CrocSwap/integer-mult-bounds/pull/7456) supplied the common-vector endpoint model and shared price enclosure, [#7454](https://github.com/CrocSwap/integer-mult-bounds/pull/7454) the reverse lifetime and direct-cut routines, and [#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) the directed tariff. [#7465](https://github.com/CrocSwap/integer-mult-bounds/pull/7465) is a related closure proof for dimension-linear signed prices. + +## Open next questions + +The exact tested scope is common-plane growth with fixed scalar order and fixed main and owned frames. Untested planes, mixed promotions and demotions, and independent plane choices per component require new scopes. Any physical build still needs a positive full-invoice price. diff --git a/research/p104-endpoint-common-plane-growth-bound/SOURCES.json b/research/p104-endpoint-common-plane-growth-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "path": "certificates/selected-result.json", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "usage": "provenance" + }, + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/p104-endpoint-common-plane-growth-bound/TASK.json b/research/p104-endpoint-common-plane-growth-bound/TASK.json new file mode 100644 index 0000000000..81a5f8fc09 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7481 with the retained #7113 signed caller. Common two-dimensional plane growth on pure productive-public helper components, allowing productive endpoints subject to positive gaps and charging all incident paid and productive ranks.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 endpoint-aware common-plane growth audit", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "A strict gain requires positive whole-incidence paid MOVE saving. Directed maximum closure bounds it before construction.", + "budget_minutes": 12, + "evidence": "Forward closure bounds all 256 ranked cases by zero at all 18 shared price vertices, covering 552 eligible groups, 2565 paid edges and 193 targets. An independent reverse-word cut replay reproduces the same exact comparisons.", + "open_questions": [ + { + "blocked_by": "This package decides only the exact tested common-plane prefix.", + "first_step": "Choose one bounded distinct model with a positive lower quote before physical construction.", + "question": "Can any untested plane or different admissible rechart model improve the full paid moment?", + "why_it_matters": "Any complete gain needs the actual signed paid profile under the same assumptions." + } + ], + "original_card": { + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "existing_checks": [ + { + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4133: literal-slot defect", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4136: uniform commutation gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4140: uniform encoding gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "status": "author-checked" + }, + { + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "status": "author-checked" + }, + { + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4154: fiber-tag seam mismatch", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "status": "author-checked" + }, + { + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "status": "reviewed" + } + ], + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "id": "p104-side-correction", + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "The previous one-component inherited chart tests do not cover interacting simultaneous changes. A common-vector extension gives an exact tractable coupled model.", + "scope_status": "changed", + "stop_rule": "Test at most 256 ranked cases from the authenticated 1014-plane population, stop after the first positive lower or the declared 60-second scientific cap, and retain unresolved planes.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-endpoint-common-plane-growth-bound/VERIFICATION.md b/research/p104-endpoint-common-plane-growth-bound/VERIFICATION.md new file mode 100644 index 0000000000..a64fd64d48 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/VERIFICATION.md @@ -0,0 +1,3 @@ +The forward closure took 26.96 seconds under its 60-second cap. The separate reverse-word direct cut replay took 46.17 seconds under its own 60-second cap. Both authenticated the exact compressed and uncompressed #7481 word, recovered all 1,517 components, the 552 eligible components, 2,565 paid edges and 193 productive target edges, and independently ranked the same 1,014 saved planes. The exact tested prefix consists of 256 planes. The edgewise upper is slightly positive in each case because it allows different directed increment endpoints on different terms. With one shared price vector, all 4,608 upper optimizations are exactly zero. All 20 exhaustive tiny transition controls passed. + +The wrapper pins all runner and receipt paths. The compressed lead receipt preserves the original bytes. Its saved-population input name is canonicalized to the shared package name only after authenticating the complete input manifest. The independent verifier binds the original lead receipt payload hash and checks each ranking score, edgewise upper and lower, and 18 shared-price upper values. No physical changes were attempted. diff --git a/research/p104-endpoint-common-plane-growth-bound/VERIFY.json b/research/p104-endpoint-common-plane-growth-bound/VERIFY.json new file mode 100644 index 0000000000..7d15c361cb --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Replay the fixed ranked endpoint plane prefix with exact forward closure and independent reverse-word cut certificates.", + "timeout_seconds": 140 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-endpoint-common-plane-growth-bound/cut_flow.py b/research/p104-endpoint-common-plane-growth-bound/cut_flow.py new file mode 100644 index 0000000000..c3b02234c0 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/cut_flow.py @@ -0,0 +1,208 @@ +"""Independent reverse-word inventory and edge-capacitated flow for R219.""" +from collections import deque +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + 'reverse_inventory.py': 'ac01889cd8e917b5c3f93dcefaa19c159efc18bcdd6973b94b481f08185d0127', + 'inputs/pricing.py': 'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', + 'inputs/7334-WORD.json.gz': '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a', +} +WORD_PAYLOAD = '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac' +HEAD = 'aaeec8c0acf01e99a5f331ef363a698d9c084ace' +CALLER = '07a76c5e2738882c0cb322278e56f6cae3c9885d' +SCALE = 10**49 +LOWER = Q('0.00364665195644044790699554028334161') +UPPER = Q('0.00364665195644044790699554028334162') + + +def exact_inventory(word, trace, space): + frames, fixed, adj, _, transport = trace(word) + # Include untouched segments as singleton components, as well as cocharted + # connected components from literal ADD/COPY. Reverse trace dates each + # segment by its ending clock, independently of a forward union-find. + component = {} + charts = [] + allowed = set() + main = set(word['live']) | {r + 112 for r in word['live']} | set(word['hosted']['X2']) | set(word['hosted']['Y2']) + public = word['public'] + assert len(main) == 400 and public == 1501 + for root in sorted(frames): + if root in component: + continue + g = len(charts) + pending = [root] + component[root] = g + pure = True + while pending: + node = pending.pop() + role, _ = node + assert frames[node] == frames[root] + pure = pure and role < public and role not in main and node not in fixed + for peer in sorted(adj.get(node, ())): + if peer not in component: + component[peer] = g + pending.append(peer) + assert component[peer] == g + charts.append(frames[root]) + if pure: + allowed.add(g) + points = [space(basis) for basis in word['frames']] + ranks = list(map(len, word['frames'])) + pairs = {} + for node, entries in transport.items(): + for clock, other_chart, side in entries: + pair = pairs.setdefault(clock, {}) + assert side not in pair + pair[side] = (component[node], frames[node], other_chart) + edges = [] + for clock, pair in sorted(pairs.items()): + lower, lc, a = pair['source'] + upper, uc, b = pair['target'] + assert a == uc and b == lc and lower != upper + if lower not in allowed and upper not in allowed: + continue + assert points[lc] < points[uc] + assert word['program'][clock][0] == 'MOVE' and word['program'][clock][-1] is False + edges.append((lower, upper, ranks[uc]-ranks[lc])) + spaces = [points[c] for c in charts] + return spaces, allowed, edges + + +def arc(graph, u, v, capacity): + assert u != v and capacity > 0 + graph[u][v] = graph[u].get(v, 0) + capacity + graph[v].setdefault(u, 0) + + +def push_until_cut(graph, s, t, offered): + """Shortest augmenting paths, using the explicit bidirectional residual.""" + flow, augmentations = 0, 0 + while flow < offered: + parent = {s: None} + queue = deque([s]) + while queue and t not in parent: + u = queue.popleft() + for v, capacity in graph[u].items(): + if capacity and v not in parent: + parent[v] = u + queue.append(v) + if t not in parent: + return flow, augmentations, set(parent) + v = t + send = offered - flow + while v != s: + u = parent[v] + send = min(send, graph[u][v]) + v = u + v = t + while v != s: + u = parent[v] + graph[u][v] -= send + graph[v][u] += send + v = u + flow += send + augmentations += 1 + return flow, augmentations, {s} + + +def reduce_edges(v, spaces, allowed, edges, increment): + active = [g for g in sorted(allowed) if v not in spaces[g]] + index = {g: i for i, g in enumerate(active)} + source, sink = len(active), len(active) + 1 + graph = [{} for _ in range(len(active) + 2)] + total = 0 + hard = set() + finite_count = 0 + for lower, upper, d in edges: + x, y = index.get(lower), index.get(upper) + if x is None and y is None: + continue + if v in spaces[upper]: + assert x is not None and y is None + reward = increment[d][1] + arc(graph, source, x, reward) + total += reward + finite_count += 1 + continue + # Changed lower frame requires changed upper frame in this case. + if x is not None: + hard.add((x, y if y is not None else sink)) + # A cut pays for changing U alone, including a fixed lower frame. + if y is not None: + penalty = increment[d + 1][0] + arc(graph, y, x if x is not None else sink, penalty) + finite_count += 1 + for x, y in sorted(hard): + arc(graph, x, y, total + 1) + flow, augmentations, cut = push_until_cut(graph, source, sink, total) + assert all(x not in cut or y in cut for x, y in hard) + return {'vector': v, 'variables': len(active), 'implications': len(hard), + 'finite_arc_occurrences': finite_count, 'source_benefit_scaled': total, + 'flow_scaled': flow, 'upper_scaled': total - flow, + 'augmenting_paths': augmentations} + + +def control(): + # Adding the lower frame gives 5, requires adding its upper neighbor, + # and thus incurs 3. A fixed upper frame changes the optimum back to zero. + graph = [{} for _ in range(4)] + for u, v, c in ((2, 0, 5), (0, 1, 6), (1, 3, 3)): + arc(graph, u, v, c) + f, _, cut = push_until_cut(graph, 2, 3, 5) + assert f == 3 and cut == {0, 1, 2} + graph = [{} for _ in range(4)] + for u, v, c in ((2, 0, 5), (0, 1, 6), (1, 3, 6)): + arc(graph, u, v, c) + f, _, cut = push_until_cut(graph, 2, 3, 5) + assert f == 5 and cut == {2} + + +def stop(*_): + raise TimeoutError('60-second binary-vector flow cap') + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(60) + for path, digest in PINS.items(): + assert sha256((ROOT / path).read_bytes()).hexdigest() == digest + data = decompress((ROOT / 'inputs' / '7334-WORD.json.gz').read_bytes()) + assert sha256(data).hexdigest() == WORD_PAYLOAD + word = loads(data) + assert len(word['program']) == 76466 + inv = run_path(str(ROOT / 'reverse_inventory.py')) + spaces, allowed, edges = exact_inventory(word, inv['reverse_trace'], inv['frame_space']) + assert len(allowed) == 482 and len(edges) == 2292 + tariff = run_path(str(ROOT / 'inputs' / 'pricing.py'))['power_bounds'] + bounds = [(Q(0), Q(0))] + [(tariff(r, UPPER)[0], tariff(r, LOWER)[1]) for r in range(1, 10)] + increment = {} + for r in range(1, 10): + lo, hi = (bounds[r][0] - bounds[r-1][1]) * SCALE, (bounds[r][1] - bounds[r-1][0]) * SCALE + assert lo.denominator == hi.denominator == 1 and 0 < lo <= hi + increment[r] = (int(lo), int(hi)) + control() + outcomes = [] + try: + for v in range(1, 512): + outcomes.append(reduce_edges(v, spaces, allowed, edges, increment)) + except TimeoutError: + print(dumps(dict(capped=True, results=outcomes), sort_keys=True, indent=2)) + raise SystemExit(2) + finally: + alarm(0) + print(dumps(dict(head=HEAD, caller=CALLER, pins=PINS, groups=len(spaces), + eligible_groups=len(allowed), incident_edges=len(edges), scale=SCALE, + runner_cap_seconds=60, vector_cap=511, capped=False, + increments=increment, results=outcomes), sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-endpoint-common-plane-growth-bound/endpoint_replay.py b/research/p104-endpoint-common-plane-growth-bound/endpoint_replay.py new file mode 100644 index 0000000000..ede1a2a7e3 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/endpoint_replay.py @@ -0,0 +1,231 @@ +"""Reverse inventory and edge-capacity verification for R222/R223.""" +from collections import defaultdict +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from math import ceil, floor +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal +from sys import argv + +ROOT = Path(__file__).resolve().parent +HEAD = 'aaeec8c0acf01e99a5f331ef363a698d9c084ace' +CALLER = '07a76c5e2738882c0cb322278e56f6cae3c9885d' +PINS = { + 'inputs/7334-WORD.json.gz': '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a', + 'inputs/pricing.py': 'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', + 'reverse_inventory.py': 'ac01889cd8e917b5c3f93dcefaa19c159efc18bcdd6973b94b481f08185d0127', + 'cut_flow.py': 'a16c67f11d216d0a7d7f4caf0b994cc0a1dcbc01d667ed0924691f72f0959cdb', +} +PAYLOAD = '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac' +SCALE = 10**52 + + +def inventory(word, rev): + frames, fixed, adjacent, _, transport = rev['reverse_trace'](word) + main = set(word['live']) | {r+112 for r in word['live']} | set(word['hosted']['X2']) | set(word['hosted']['Y2']) + public = word['public'] + assert public == 1501 and len(main) == 400 + helper = set(range(public)) - main + component, charts, allowed = {}, [], [] + for root in sorted(frames): + if root in component: + continue + i = len(charts) + component[root] = i + pending = [root] + pure = True + while pending: + node = pending.pop() + assert frames[node] == frames[root] + pure = pure and node[0] in helper + for peer in sorted(adjacent.get(node, ())): + if peer not in component: + component[peer] = i + pending.append(peer) + assert component[peer] == i + charts.append(frames[root]) + if pure: + allowed.append(i) + chart_points = list(map(rev['frame_space'], word['frames'])) + points = [chart_points[c] for c in charts] + ranks = [len(word['frames'][c]) for c in charts] + allowed_set = set(allowed) + paid_ends = defaultdict(dict) + for node, rows in transport.items(): + for t, other, side in rows: + assert side not in paid_ends[t] + paid_ends[t][side] = (component[node], other) + edges = [] + for t, pair in sorted(paid_ends.items()): + a, upper_chart = pair['source'] + b, lower_chart = pair['target'] + assert charts[a] == lower_chart and charts[b] == upper_chart + if a not in allowed_set and b not in allowed_set: + continue + assert points[a] < points[b] and word['program'][t][-1] is False + edges.append((a, b, ranks[b]-ranks[a], True)) + ends = defaultdict(list) + for node in fixed: + ends[node[0]].append(node) + for r in sorted(helper): + end = (r, len(word['program'])) + start, = set(ends[r]) - {end} + assert end in fixed and frames[start] == word['initial'][r] and frames[end] == word['final'][r] + a, b = component[start], component[end] + if a not in allowed_set and b not in allowed_set: + continue + assert points[a] < points[b] + edges.append((a, b, ranks[b]-ranks[a], False)) + return points, allowed, edges + + +def compile_edges(v, points, allowed, edges): + active = [g for g in allowed if v not in points[g]] + index = {g: i for i, g in enumerate(active)} + s, t = len(active), len(active)+1 + hard, terms = set(), [] + for a, b, d, paid in edges: + x, y = index.get(a), index.get(b) + if x is None and y is None: + continue + if v in points[b]: + assert x is not None and y is None + if paid: + terms.append((s, x, d, True)) + elif d == 1: + hard.add((x, t)) + else: + terms.append((x, t, d, False)) + continue + if x is not None: + hard.add((x, y if y is not None else t)) + if paid: + if y is not None: + terms.append((y, x if x is not None else t, d+1, False)) + else: + # Nesting forces x <= y, so a reward c for (y,x)=(1,0) + # equals c*y - c*x on every allowed cut. + if y is not None: + terms.append((s, y, d+1, True)) + if x is not None: + terms.append((x, t, d+1, True)) + return s, t, sorted(hard), terms + + +def flow_value(frozen, reward, penalty, push, arc, *, cancel=False): + s, t, hard, terms = frozen + graph = [{} for _ in range(t+1)] + offered = 0 + for u, v, rank, good in terms: + cap = reward[rank] if good else penalty[rank] + arc(graph, u, v, cap) + if u == s: + offered += cap + if cancel: + # A source-to-sink cut crosses exactly one terminal arc at each + # variable. Subtract their common minimum from all cuts and offered. + for node in range(s): + common = min(graph[s].get(node, 0), graph[node].get(t, 0)) + if common: + graph[s][node] -= common + graph[node][t] -= common + offered -= common + for u, v in hard: + arc(graph, u, v, offered+1) + flow, _, cut = push(graph, s, t, offered) + assert all(u not in cut or v in cut for u, v in hard) + return offered-flow + + +def control(push, arc): + # A target reward adds +5 only if the upper grows alone. One paid + # charge of 3 for that upper gives +2. Coupling it to an additional + # finite penalty of 4 makes the upper unprofitable. + terms = [(2, 1, 1, True), (0, 3, 1, True), (1, 3, 2, False)] + for cancel in (False, True): + assert flow_value((2, 3, [(0, 1)], terms), + [0, 5, 3], [0, 5, 3], push, arc, cancel=cancel) == 2 + assert flow_value((2, 3, [(0, 1)], terms+[(1, 3, 3, False)]), + [0, 5, 3, 4], [0, 5, 3, 4], push, arc, cancel=cancel) == 0 + + +def stop(*_): + raise TimeoutError('60-second endpoint shared-price cap') + + +def main(): + assert __debug__ + assert len(argv) in (1, 6) + if len(argv) == 1: + first, last, skip, cap, mode = 1, 511, 0, 60, 'cancel' + else: + first, last, skip, cap = map(int, argv[1:5]) + mode = argv[5] + assert 1 <= first <= last <= 511 and 0 <= skip < 18 and 1 <= cap <= 60 + assert mode in ('direct', 'cancel') + cancel = mode == 'cancel' + signal(SIGALRM, stop) + alarm(cap) + for name, pin in PINS.items(): + assert sha256((ROOT / name).read_bytes()).hexdigest() == pin + raw = decompress((ROOT / 'inputs/7334-WORD.json.gz').read_bytes()) + assert sha256(raw).hexdigest() == PAYLOAD + word = loads(raw) + assert len(word['program']) == 76466 + rev = run_path(str(ROOT / 'reverse_inventory.py')) + points, allowed, edges = inventory(word, rev) + targets, paid = sum(not e[-1] for e in edges), sum(e[-1] for e in edges) + assert (len(points), len(allowed), paid, targets) == (1517, 553, 2573, 193) + flow = run_path(str(ROOT / 'cut_flow.py')) + push, arc = flow['push_until_cut'], flow['arc'] + control(push, arc) + tariff = run_path(str(ROOT / 'inputs/pricing.py'))['power_bounds'] + k0 = Q('0.00364665195644044790699554028334161') + k1 = Q('0.00364665195644044790699554028334162') + h = [(Q(0), Q(0))] + [(tariff(r, k1)[0], tariff(r, k0)[1]) for r in range(1, 10)] + lo = [0] + [floor(SCALE*(h[r][0]-h[r-1][1])) for r in range(1, 10)] + hi = [0] + [ceil(SCALE*(h[r][1]-h[r-1][0])) for r in range(1, 10)] + assert all(0 < a <= b for a, b in zip(lo[1:], hi[1:], strict=True)) + midpoint = [a+b for a,b in zip(lo, hi, strict=True)] + radius = sum(b-a for a,b in zip(lo, hi, strict=True)) + assert 0 < radius < min(midpoint[1:]) + vertices = [] + for rank in range(1, 10): + for sign in (-1, 1): + p = midpoint.copy() + p[rank] += sign*radius + vertices.append(p) + rows, rounding, partial = [], [], None + capped = False + try: + for v in range(first, last+1): + frozen = compile_edges(v, points, allowed, edges) + if v != first or not skip: + rounding.append([v, frozen[0], flow_value(frozen, lo, hi, push, arc, cancel=cancel), + flow_value(frozen, hi, lo, push, arc, cancel=cancel)]) + partial = [v, []] + for price in vertices[skip if v == first else 0:]: + partial[1].append(flow_value(frozen, price, price, push, arc, cancel=cancel)) + rows.append(partial) + partial = None + except TimeoutError: + capped = True + finally: + alarm(0) + print(dumps(dict(head=HEAD, caller=CALLER, pins=PINS, groups=len(points), eligible_groups=len(allowed), + paid_edges=paid, target_edges=targets, increment_scale=SCALE, scale=2*SCALE, + box=list(zip(lo[1:],hi[1:],strict=True)), center=midpoint[1:], radius=radius, + vertices=len(vertices), vectors=len(rows), cap_seconds=cap, + first_vector=first, last_vector=last, skip_first_vertices=skip, mode=mode, + rounding=rounding, rows=rows, partial_row=partial, + max=max((max(values) for _,values in rows),default=None),capped=capped), + indent=2,sort_keys=True)) + if capped: + raise SystemExit(2) + + +if __name__ == '__main__': + main() diff --git a/research/p104-endpoint-common-plane-growth-bound/independent.py b/research/p104-endpoint-common-plane-growth-bound/independent.py new file mode 100644 index 0000000000..a743e32795 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/independent.py @@ -0,0 +1,218 @@ +"""Independent endpoint-aware plane pricing using reverse inventory and direct cuts.""" +from fractions import Fraction as F +from gzip import decompress +from hashlib import sha256 +from itertools import product +from json import dumps, loads +from math import ceil, floor +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal +from sys import argv, implementation, version_info + +ROOT = Path(__file__).resolve().parent +PINS = { + "endpoint_replay.py": "24d63caf9e647840f47675fecf775803c509f5fbc7ae6fc6b5d450782ec1d81d", + "cut_flow.py": "a16c67f11d216d0a7d7f4caf0b994cc0a1dcbc01d667ed0924691f72f0959cdb", + "reverse_inventory.py": "ac01889cd8e917b5c3f93dcefaa19c159efc18bcdd6973b94b481f08185d0127", + "inputs/7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "inputs/R226-PLANES.json": "68ea271a02374de22edfa105e6033ebc670087d3627798f15bab14c9962479b8", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} +PAYLOAD = "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8" +SCALE = 10**52 +CAP = 60 + + +def unique(items): + values = dict(items) + assert len(values) == len(items), "duplicate JSON key" + return values + + +def stop(*_): + raise TimeoutError("60-second independent endpoint-plane cap") + + +def gaps(plane, points): + return [{0: 2, 1: 1, 3: 0}[sum(v in space for v in plane)] for space in points] + + +def compile_plane(gap, allowed, edges): + active = {g:i for i,g in enumerate(g for g in allowed if gap[g])} + source, sink = len(active), len(active)+1 + hard, terms = set(), [] + # Term tuple: from, to, old gap, new gap, directed upper if True. + for a,b,d,paid in edges: + x,y = active.get(a),active.get(b) + if x is None and y is None: + continue + ka,kb = gap[a],gap[b] + assert ka >= kb + both = d+kb-ka + assert 0 <= both <= d <= d+kb <= 9 + if kb and x is not None: + hard.add((x,y if y is not None else sink)) + if x is not None and not paid and not both: + hard.add((x,sink)) + if paid: + if x is not None and d != both: + terms.append((source,x,both,d,True)) + if y is not None: + terms.append((y,x if x is not None else sink,d,d+kb,False)) + else: + if y is not None: + terms.append((source,y,d,d+kb,True)) + if x is not None: + terms.append((x,sink,d,d+kb,True)) + if x is not None and both and d != both: + terms.append((x,sink,both,d,False)) + return source,sink,hard,terms + + +def optimistic_score(gap, allowed, edges, price): + active = {g for g in allowed if gap[g]} + total = 0 + for a,b,d,paid in edges: + ka,kb = gap[a],gap[b] + if paid: + if a in active and (not kb or b in active): + total += price[d]-price[d+kb-ka] + elif b in active: + total += price[d+kb]-price[d] + return total + + +def cumulative(increments): + result = [0] + for inc in increments: + result.append(result[-1]+inc) + return result + + +def cut_value(compiled, reward_price, penalty_price, arc, push): + source,sink,hard,terms = compiled + graph = [{} for _ in range(sink+1)] + offered = 0 + for u,v,a,b,reward in terms: + price = reward_price if reward else penalty_price + cap = price[b]-price[a] + assert cap > 0 + arc(graph,u,v,cap) + offered += cap if u == source else 0 + # Subtract common terminal capacities, which are paid on every cut. + for node in range(source): + common = min(graph[source].get(node,0),graph[node].get(sink,0)) + if common: + graph[source][node] -= common + graph[node][sink] -= common + offered -= common + for u,v in sorted(hard): + arc(graph,u,v,offered+1) + flow,_,side = push(graph,source,sink,offered) + assert all(u not in side or v in side for u,v in hard) + return offered-flow + + +def controls(arc,push): + # These spaces realize both equal paid charts and target collapse. + checks = ( + ([2,2],[(0,1,0,True)]), + ([2,1],[(0,1,1,False)]), + ([2,1],[(0,1,2,False),(0,1,2,True)]), + ([2,0],[(0,1,2,False),(0,1,2,True)]), + ([2,1],[(0,1,2,False)]), + ) + h = [0,4,7,9,10,11,12,13,14,15] + count = 0 + for gap,edges in checks: + for a,b in product((False,True),repeat=2): + allowed = [i for i,t in enumerate((a,b)) if t] + opts = [product((0,1) if i in allowed and gap[i] else (0,),repeat=1) for i in range(2)] + values = [] + for (x,),(y,) in product(*opts): + if x and gap[1] and not y: + continue + new = [d+y*gap[1]-x*gap[0] for _,_,d,_ in edges] + if any(not paid and not z for z,(_,_,_,paid) in zip(new,edges,strict=True)): + continue + values.append(sum((h[d]-h[z])*(1 if paid else -1) + for z,(_,_,d,paid) in zip(new,edges,strict=True))) + assert cut_value(compile_plane(gap,allowed,edges),h,h,arc,push) == max(values) + count += 1 + return count + + +def main(case_path): + assert __debug__ and implementation.name == "cpython" and version_info[:2] == (3,12) + signal(SIGALRM,stop) + alarm(CAP) + for name,pin in PINS.items(): + assert sha256((ROOT/name).read_bytes()).hexdigest() == pin, name + raw = decompress((ROOT/"inputs/7481-WORD.json.gz").read_bytes()) + assert sha256(raw).hexdigest() == PAYLOAD + word = loads(raw,object_pairs_hook=unique) + assert len(word["program"]) == 76475 + endpoint,rev,flow = [run_path(str(ROOT/(x+".py"))) + for x in ("endpoint_replay","reverse_inventory","cut_flow")] + points,allowed,edges = endpoint["inventory"](word,rev) + arc,push = flow["arc"],flow["push_until_cut"] + control_count = controls(arc,push) + h = run_path(str(ROOT/"inputs/pricing.py"))["power_bounds"] + k0,k1 = map(F,("9117702599223995588631135479313/2500000000000000000000000000000000","36470810396895982354524541917253/10000000000000000000000000000000000")) + bounds = [(F(0),F(0))]+[(h(r,k1)[0],h(r,k0)[1]) for r in range(1,10)] + increment_lo = [floor(SCALE*(bounds[r][0]-bounds[r-1][1])) for r in range(1,10)] + increment_hi = [ceil(SCALE*(bounds[r][1]-bounds[r-1][0])) for r in range(1,10)] + center = [a+b for a,b in zip(increment_lo,increment_hi,strict=True)] + radius = sum(b-a for a,b in zip(increment_lo,increment_hi,strict=True)) + assert 0 < radius < min(center) + price_lo,price_hi = map(cumulative,(increment_lo,increment_hi)) + vertices = [] + for r,sign in product(range(9),(-1,1)): + inc = center.copy() + inc[r] += sign*radius + vertices.append(cumulative(inc)) + compressed_cases = case_path.read_bytes() + case_bytes = decompress(compressed_cases) if case_path.suffix == ".gz" else compressed_cases + source_cases = loads(case_bytes,object_pairs_hook=unique) + lead_records = source_cases.get("records") + if lead_records is None: + planes = [tuple(p) for p in source_cases["planes"]] + else: + planes = [tuple(r["plane"]) for r in lead_records] + pool = {tuple(p) for p,_ in loads((ROOT/"inputs/R226-PLANES.json").read_bytes(),object_pairs_hook=unique)["records"]} + assert 1 <= len(planes) <= 256 and len(planes) == len(set(planes)) + assert set(planes) <= pool and len(pool) == 1014 + ranking = sorted(((optimistic_score(gaps(p,points),allowed,edges,price_hi),p) for p in pool), + key=lambda row:(-row[0],row[1])) + assert [p for _,p in ranking[:len(planes)]] == planes + if "ranking" in source_cases: + assert source_cases["ranking"] == [[s,list(p)] for s,p in ranking] + rows = [] + capped = False + try: + for rank,plane in enumerate(planes): + compiled = compile_plane(gaps(plane,points),allowed,edges) + upper = cut_value(compiled,price_hi,price_lo,arc,push) + lower = cut_value(compiled,price_lo,price_hi,arc,push) + cert = [cut_value(compiled,v,v,arc,push) for v in vertices] if upper and not lower else [] + if lead_records is not None: + control = lead_records[rank] + assert (control["score"],control["edgewise_upper"],control["edgewise_lower"],control["shared_price_upper"]) == (ranking[rank][0],upper,lower,cert),plane + rows.append([plane,compiled[0],lower,upper,cert]) + except TimeoutError: + capped = True + finally: + alarm(0) + print(dumps(dict(pins=PINS,case_input_sha256=sha256(case_bytes).hexdigest(), + groups=len(points),eligible_groups=len(allowed),paid_edges=sum(e[-1] for e in edges), + target_edges=sum(not e[-1] for e in edges),case_cap=256,runner_cap_seconds=CAP, + scale=SCALE,shared_scale=2*SCALE,capped=capped,requested=len(planes), + controls=control_count,rows=rows),indent=2,sort_keys=True)) + if capped: + raise SystemExit(2) + + +if __name__ == "__main__": + assert len(argv) == 2 + main(Path(argv[1])) diff --git a/research/p104-endpoint-common-plane-growth-bound/inputs/7481-WORD.json.gz b/research/p104-endpoint-common-plane-growth-bound/inputs/7481-WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-endpoint-common-plane-growth-bound/inputs/7481-WORD.json.gz differ diff --git a/research/p104-endpoint-common-plane-growth-bound/inputs/R226-PLANES.json b/research/p104-endpoint-common-plane-growth-bound/inputs/R226-PLANES.json new file mode 100644 index 0000000000..8e9a6219b4 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/inputs/R226-PLANES.json @@ -0,0 +1,8137 @@ +{ + "capped": false, + "case_cap": 1024, + "inputs": { + "7334-WORD.json.gz": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "closure.py": "64f57a509aac0c7f56c33ce5f84f99c3a4377d4ecc993f7424ad4115542a173f", + "inventory.py": "347a7d90d34f0d7134d4dc68d95f135ee7cd9e002d6176eb5968f85f00db7d43", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "target_closure.py": "8ef8fbc45d4f2414944443d2a89147b4b9c2ba225d0faa065dc351f212b709fb" + }, + "max_upper_scaled": 0, + "plane_count": 1014, + "planes_checked": 1014, + "records": [ + [ + [ + 1, + 244, + 245 + ], + 0 + ], + [ + [ + 1, + 326, + 327 + ], + 0 + ], + [ + [ + 1, + 364, + 365 + ], + 0 + ], + [ + [ + 1, + 370, + 371 + ], + 0 + ], + [ + [ + 2, + 244, + 246 + ], + 0 + ], + [ + [ + 2, + 325, + 327 + ], + 0 + ], + [ + [ + 2, + 365, + 367 + ], + 0 + ], + [ + [ + 2, + 369, + 371 + ], + 0 + ], + [ + [ + 3, + 244, + 247 + ], + 0 + ], + [ + [ + 3, + 324, + 327 + ], + 0 + ], + [ + [ + 3, + 365, + 366 + ], + 0 + ], + [ + [ + 3, + 368, + 371 + ], + 0 + ], + [ + [ + 4, + 240, + 244 + ], + 0 + ], + [ + [ + 4, + 323, + 327 + ], + 0 + ], + [ + [ + 4, + 361, + 365 + ], + 0 + ], + [ + [ + 4, + 371, + 375 + ], + 0 + ], + [ + [ + 5, + 241, + 244 + ], + 0 + ], + [ + [ + 5, + 322, + 327 + ], + 0 + ], + [ + [ + 5, + 360, + 365 + ], + 0 + ], + [ + [ + 5, + 371, + 374 + ], + 0 + ], + [ + [ + 6, + 242, + 244 + ], + 0 + ], + [ + [ + 6, + 321, + 327 + ], + 0 + ], + [ + [ + 6, + 363, + 365 + ], + 0 + ], + [ + [ + 6, + 371, + 373 + ], + 0 + ], + [ + [ + 7, + 243, + 244 + ], + 0 + ], + [ + [ + 7, + 320, + 327 + ], + 0 + ], + [ + [ + 7, + 362, + 365 + ], + 0 + ], + [ + [ + 7, + 371, + 372 + ], + 0 + ], + [ + [ + 8, + 244, + 252 + ], + 0 + ], + [ + [ + 8, + 327, + 335 + ], + 0 + ], + [ + [ + 8, + 357, + 365 + ], + 0 + ], + [ + [ + 8, + 371, + 379 + ], + 0 + ], + [ + [ + 9, + 244, + 253 + ], + 0 + ], + [ + [ + 9, + 327, + 334 + ], + 0 + ], + [ + [ + 9, + 356, + 365 + ], + 0 + ], + [ + [ + 9, + 371, + 378 + ], + 0 + ], + [ + [ + 10, + 244, + 254 + ], + 0 + ], + [ + [ + 10, + 327, + 333 + ], + 0 + ], + [ + [ + 10, + 359, + 365 + ], + 0 + ], + [ + [ + 10, + 371, + 377 + ], + 0 + ], + [ + [ + 11, + 244, + 255 + ], + 0 + ], + [ + [ + 11, + 327, + 332 + ], + 0 + ], + [ + [ + 11, + 358, + 365 + ], + 0 + ], + [ + [ + 11, + 371, + 376 + ], + 0 + ], + [ + [ + 12, + 244, + 248 + ], + 0 + ], + [ + [ + 12, + 327, + 331 + ], + 0 + ], + [ + [ + 12, + 353, + 365 + ], + 0 + ], + [ + [ + 12, + 371, + 383 + ], + 0 + ], + [ + [ + 13, + 244, + 249 + ], + 0 + ], + [ + [ + 13, + 327, + 330 + ], + 0 + ], + [ + [ + 13, + 352, + 365 + ], + 0 + ], + [ + [ + 13, + 371, + 382 + ], + 0 + ], + [ + [ + 14, + 244, + 250 + ], + 0 + ], + [ + [ + 14, + 327, + 329 + ], + 0 + ], + [ + [ + 14, + 355, + 365 + ], + 0 + ], + [ + [ + 14, + 371, + 381 + ], + 0 + ], + [ + [ + 15, + 244, + 251 + ], + 0 + ], + [ + [ + 15, + 327, + 328 + ], + 0 + ], + [ + [ + 15, + 354, + 365 + ], + 0 + ], + [ + [ + 15, + 371, + 380 + ], + 0 + ], + [ + [ + 16, + 228, + 244 + ], + 0 + ], + [ + [ + 16, + 327, + 343 + ], + 0 + ], + [ + [ + 16, + 355, + 371 + ], + 0 + ], + [ + [ + 16, + 365, + 381 + ], + 0 + ], + [ + [ + 17, + 229, + 244 + ], + 0 + ], + [ + [ + 17, + 327, + 342 + ], + 0 + ], + [ + [ + 17, + 354, + 371 + ], + 0 + ], + [ + [ + 17, + 365, + 380 + ], + 0 + ], + [ + [ + 18, + 230, + 244 + ], + 0 + ], + [ + [ + 18, + 327, + 341 + ], + 0 + ], + [ + [ + 18, + 353, + 371 + ], + 0 + ], + [ + [ + 18, + 365, + 383 + ], + 0 + ], + [ + [ + 19, + 231, + 244 + ], + 0 + ], + [ + [ + 19, + 327, + 340 + ], + 0 + ], + [ + [ + 19, + 352, + 371 + ], + 0 + ], + [ + [ + 19, + 365, + 382 + ], + 0 + ], + [ + [ + 20, + 224, + 244 + ], + 0 + ], + [ + [ + 20, + 327, + 339 + ], + 0 + ], + [ + [ + 20, + 359, + 371 + ], + 0 + ], + [ + [ + 20, + 365, + 377 + ], + 0 + ], + [ + [ + 21, + 225, + 244 + ], + 0 + ], + [ + [ + 21, + 327, + 338 + ], + 0 + ], + [ + [ + 21, + 358, + 371 + ], + 0 + ], + [ + [ + 21, + 365, + 376 + ], + 0 + ], + [ + [ + 22, + 226, + 244 + ], + 0 + ], + [ + [ + 22, + 327, + 337 + ], + 0 + ], + [ + [ + 22, + 357, + 371 + ], + 0 + ], + [ + [ + 22, + 365, + 379 + ], + 0 + ], + [ + [ + 23, + 227, + 244 + ], + 0 + ], + [ + [ + 23, + 327, + 336 + ], + 0 + ], + [ + [ + 23, + 356, + 371 + ], + 0 + ], + [ + [ + 23, + 365, + 378 + ], + 0 + ], + [ + [ + 24, + 236, + 244 + ], + 0 + ], + [ + [ + 24, + 327, + 351 + ], + 0 + ], + [ + [ + 24, + 363, + 371 + ], + 0 + ], + [ + [ + 24, + 365, + 373 + ], + 0 + ], + [ + [ + 25, + 237, + 244 + ], + 0 + ], + [ + [ + 25, + 327, + 350 + ], + 0 + ], + [ + [ + 25, + 362, + 371 + ], + 0 + ], + [ + [ + 25, + 365, + 372 + ], + 0 + ], + [ + [ + 26, + 238, + 244 + ], + 0 + ], + [ + [ + 26, + 327, + 349 + ], + 0 + ], + [ + [ + 26, + 361, + 371 + ], + 0 + ], + [ + [ + 26, + 365, + 375 + ], + 0 + ], + [ + [ + 27, + 239, + 244 + ], + 0 + ], + [ + [ + 27, + 327, + 348 + ], + 0 + ], + [ + [ + 27, + 360, + 371 + ], + 0 + ], + [ + [ + 27, + 365, + 374 + ], + 0 + ], + [ + [ + 28, + 232, + 244 + ], + 0 + ], + [ + [ + 28, + 327, + 347 + ], + 0 + ], + [ + [ + 28, + 365, + 369 + ], + 0 + ], + [ + [ + 28, + 367, + 371 + ], + 0 + ], + [ + [ + 29, + 233, + 244 + ], + 0 + ], + [ + [ + 29, + 327, + 346 + ], + 0 + ], + [ + [ + 29, + 365, + 368 + ], + 0 + ], + [ + [ + 29, + 366, + 371 + ], + 0 + ], + [ + [ + 30, + 234, + 244 + ], + 0 + ], + [ + [ + 30, + 327, + 345 + ], + 0 + ], + [ + [ + 30, + 365, + 371 + ], + 0 + ], + [ + [ + 31, + 235, + 244 + ], + 0 + ], + [ + [ + 31, + 327, + 344 + ], + 0 + ], + [ + [ + 31, + 364, + 371 + ], + 0 + ], + [ + [ + 31, + 365, + 370 + ], + 0 + ], + [ + [ + 32, + 212, + 244 + ], + 0 + ], + [ + [ + 32, + 327, + 359 + ], + 0 + ], + [ + [ + 32, + 333, + 365 + ], + 0 + ], + [ + [ + 32, + 339, + 371 + ], + 0 + ], + [ + [ + 33, + 213, + 244 + ], + 0 + ], + [ + [ + 33, + 327, + 358 + ], + 0 + ], + [ + [ + 33, + 332, + 365 + ], + 0 + ], + [ + [ + 33, + 338, + 371 + ], + 0 + ], + [ + [ + 34, + 214, + 244 + ], + 0 + ], + [ + [ + 34, + 327, + 357 + ], + 0 + ], + [ + [ + 34, + 335, + 365 + ], + 0 + ], + [ + [ + 34, + 337, + 371 + ], + 0 + ], + [ + [ + 35, + 215, + 244 + ], + 0 + ], + [ + [ + 35, + 327, + 356 + ], + 0 + ], + [ + [ + 35, + 334, + 365 + ], + 0 + ], + [ + [ + 35, + 336, + 371 + ], + 0 + ], + [ + [ + 36, + 208, + 244 + ], + 0 + ], + [ + [ + 36, + 327, + 355 + ], + 0 + ], + [ + [ + 36, + 329, + 365 + ], + 0 + ], + [ + [ + 36, + 343, + 371 + ], + 0 + ], + [ + [ + 37, + 209, + 244 + ], + 0 + ], + [ + [ + 37, + 327, + 354 + ], + 0 + ], + [ + [ + 37, + 328, + 365 + ], + 0 + ], + [ + [ + 37, + 342, + 371 + ], + 0 + ], + [ + [ + 38, + 210, + 244 + ], + 0 + ], + [ + [ + 38, + 327, + 353 + ], + 0 + ], + [ + [ + 38, + 331, + 365 + ], + 0 + ], + [ + [ + 38, + 341, + 371 + ], + 0 + ], + [ + [ + 39, + 211, + 244 + ], + 0 + ], + [ + [ + 39, + 327, + 352 + ], + 0 + ], + [ + [ + 39, + 330, + 365 + ], + 0 + ], + [ + [ + 39, + 340, + 371 + ], + 0 + ], + [ + [ + 40, + 220, + 244 + ], + 0 + ], + [ + [ + 40, + 325, + 365 + ], + 0 + ], + [ + [ + 40, + 327, + 367 + ], + 0 + ], + [ + [ + 40, + 347, + 371 + ], + 0 + ], + [ + [ + 41, + 221, + 244 + ], + 0 + ], + [ + [ + 41, + 324, + 365 + ], + 0 + ], + [ + [ + 41, + 327, + 366 + ], + 0 + ], + [ + [ + 41, + 346, + 371 + ], + 0 + ], + [ + [ + 42, + 222, + 244 + ], + 0 + ], + [ + [ + 42, + 327, + 365 + ], + 0 + ], + [ + [ + 42, + 345, + 371 + ], + 0 + ], + [ + [ + 43, + 223, + 244 + ], + 0 + ], + [ + [ + 43, + 326, + 365 + ], + 0 + ], + [ + [ + 43, + 327, + 364 + ], + 0 + ], + [ + [ + 43, + 344, + 371 + ], + 0 + ], + [ + [ + 44, + 216, + 244 + ], + 0 + ], + [ + [ + 44, + 321, + 365 + ], + 0 + ], + [ + [ + 44, + 327, + 363 + ], + 0 + ], + [ + [ + 44, + 351, + 371 + ], + 0 + ], + [ + [ + 45, + 217, + 244 + ], + 0 + ], + [ + [ + 45, + 320, + 365 + ], + 0 + ], + [ + [ + 45, + 327, + 362 + ], + 0 + ], + [ + [ + 45, + 350, + 371 + ], + 0 + ], + [ + [ + 46, + 218, + 244 + ], + 0 + ], + [ + [ + 46, + 323, + 365 + ], + 0 + ], + [ + [ + 46, + 327, + 361 + ], + 0 + ], + [ + [ + 46, + 349, + 371 + ], + 0 + ], + [ + [ + 47, + 219, + 244 + ], + 0 + ], + [ + [ + 47, + 322, + 365 + ], + 0 + ], + [ + [ + 47, + 327, + 360 + ], + 0 + ], + [ + [ + 47, + 348, + 371 + ], + 0 + ], + [ + [ + 48, + 196, + 244 + ], + 0 + ], + [ + [ + 48, + 323, + 371 + ], + 0 + ], + [ + [ + 48, + 327, + 375 + ], + 0 + ], + [ + [ + 48, + 349, + 365 + ], + 0 + ], + [ + [ + 49, + 197, + 244 + ], + 0 + ], + [ + [ + 49, + 322, + 371 + ], + 0 + ], + [ + [ + 49, + 327, + 374 + ], + 0 + ], + [ + [ + 49, + 348, + 365 + ], + 0 + ], + [ + [ + 50, + 198, + 244 + ], + 0 + ], + [ + [ + 50, + 321, + 371 + ], + 0 + ], + [ + [ + 50, + 327, + 373 + ], + 0 + ], + [ + [ + 50, + 351, + 365 + ], + 0 + ], + [ + [ + 51, + 199, + 244 + ], + 0 + ], + [ + [ + 51, + 320, + 371 + ], + 0 + ], + [ + [ + 51, + 327, + 372 + ], + 0 + ], + [ + [ + 51, + 350, + 365 + ], + 0 + ], + [ + [ + 52, + 192, + 244 + ], + 0 + ], + [ + [ + 52, + 327, + 371 + ], + 0 + ], + [ + [ + 52, + 345, + 365 + ], + 0 + ], + [ + [ + 53, + 193, + 244 + ], + 0 + ], + [ + [ + 53, + 326, + 371 + ], + 0 + ], + [ + [ + 53, + 327, + 370 + ], + 0 + ], + [ + [ + 53, + 344, + 365 + ], + 0 + ], + [ + [ + 54, + 194, + 244 + ], + 0 + ], + [ + [ + 54, + 325, + 371 + ], + 0 + ], + [ + [ + 54, + 327, + 369 + ], + 0 + ], + [ + [ + 54, + 347, + 365 + ], + 0 + ], + [ + [ + 55, + 195, + 244 + ], + 0 + ], + [ + [ + 55, + 324, + 371 + ], + 0 + ], + [ + [ + 55, + 327, + 368 + ], + 0 + ], + [ + [ + 55, + 346, + 365 + ], + 0 + ], + [ + [ + 56, + 204, + 244 + ], + 0 + ], + [ + [ + 56, + 327, + 383 + ], + 0 + ], + [ + [ + 56, + 331, + 371 + ], + 0 + ], + [ + [ + 56, + 341, + 365 + ], + 0 + ], + [ + [ + 57, + 205, + 244 + ], + 0 + ], + [ + [ + 57, + 327, + 382 + ], + 0 + ], + [ + [ + 57, + 330, + 371 + ], + 0 + ], + [ + [ + 57, + 340, + 365 + ], + 0 + ], + [ + [ + 58, + 206, + 244 + ], + 0 + ], + [ + [ + 58, + 327, + 381 + ], + 0 + ], + [ + [ + 58, + 329, + 371 + ], + 0 + ], + [ + [ + 58, + 343, + 365 + ], + 0 + ], + [ + [ + 59, + 207, + 244 + ], + 0 + ], + [ + [ + 59, + 327, + 380 + ], + 0 + ], + [ + [ + 59, + 328, + 371 + ], + 0 + ], + [ + [ + 59, + 342, + 365 + ], + 0 + ], + [ + [ + 60, + 200, + 244 + ], + 0 + ], + [ + [ + 60, + 327, + 379 + ], + 0 + ], + [ + [ + 60, + 335, + 371 + ], + 0 + ], + [ + [ + 60, + 337, + 365 + ], + 0 + ], + [ + [ + 61, + 201, + 244 + ], + 0 + ], + [ + [ + 61, + 327, + 378 + ], + 0 + ], + [ + [ + 61, + 334, + 371 + ], + 0 + ], + [ + [ + 61, + 336, + 365 + ], + 0 + ], + [ + [ + 62, + 202, + 244 + ], + 0 + ], + [ + [ + 62, + 327, + 377 + ], + 0 + ], + [ + [ + 62, + 333, + 371 + ], + 0 + ], + [ + [ + 62, + 339, + 365 + ], + 0 + ], + [ + [ + 63, + 203, + 244 + ], + 0 + ], + [ + [ + 63, + 327, + 376 + ], + 0 + ], + [ + [ + 63, + 332, + 371 + ], + 0 + ], + [ + [ + 63, + 338, + 365 + ], + 0 + ], + [ + [ + 64, + 180, + 244 + ], + 0 + ], + [ + [ + 64, + 263, + 327 + ], + 0 + ], + [ + [ + 64, + 301, + 365 + ], + 0 + ], + [ + [ + 64, + 307, + 371 + ], + 0 + ], + [ + [ + 65, + 181, + 244 + ], + 0 + ], + [ + [ + 65, + 262, + 327 + ], + 0 + ], + [ + [ + 65, + 300, + 365 + ], + 0 + ], + [ + [ + 65, + 306, + 371 + ], + 0 + ], + [ + [ + 66, + 182, + 244 + ], + 0 + ], + [ + [ + 66, + 261, + 327 + ], + 0 + ], + [ + [ + 66, + 303, + 365 + ], + 0 + ], + [ + [ + 66, + 305, + 371 + ], + 0 + ], + [ + [ + 67, + 183, + 244 + ], + 0 + ], + [ + [ + 67, + 260, + 327 + ], + 0 + ], + [ + [ + 67, + 302, + 365 + ], + 0 + ], + [ + [ + 67, + 304, + 371 + ], + 0 + ], + [ + [ + 68, + 176, + 244 + ], + 0 + ], + [ + [ + 68, + 259, + 327 + ], + 0 + ], + [ + [ + 68, + 297, + 365 + ], + 0 + ], + [ + [ + 68, + 311, + 371 + ], + 0 + ], + [ + [ + 69, + 177, + 244 + ], + 0 + ], + [ + [ + 69, + 258, + 327 + ], + 0 + ], + [ + [ + 69, + 296, + 365 + ], + 0 + ], + [ + [ + 69, + 310, + 371 + ], + 0 + ], + [ + [ + 70, + 178, + 244 + ], + 0 + ], + [ + [ + 70, + 257, + 327 + ], + 0 + ], + [ + [ + 70, + 299, + 365 + ], + 0 + ], + [ + [ + 70, + 309, + 371 + ], + 0 + ], + [ + [ + 71, + 179, + 244 + ], + 0 + ], + [ + [ + 71, + 256, + 327 + ], + 0 + ], + [ + [ + 71, + 298, + 365 + ], + 0 + ], + [ + [ + 71, + 308, + 371 + ], + 0 + ], + [ + [ + 72, + 188, + 244 + ], + 0 + ], + [ + [ + 72, + 271, + 327 + ], + 0 + ], + [ + [ + 72, + 293, + 365 + ], + 0 + ], + [ + [ + 72, + 315, + 371 + ], + 0 + ], + [ + [ + 73, + 189, + 244 + ], + 0 + ], + [ + [ + 73, + 270, + 327 + ], + 0 + ], + [ + [ + 73, + 292, + 365 + ], + 0 + ], + [ + [ + 73, + 314, + 371 + ], + 0 + ], + [ + [ + 74, + 190, + 244 + ], + 0 + ], + [ + [ + 74, + 269, + 327 + ], + 0 + ], + [ + [ + 74, + 295, + 365 + ], + 0 + ], + [ + [ + 74, + 313, + 371 + ], + 0 + ], + [ + [ + 75, + 191, + 244 + ], + 0 + ], + [ + [ + 75, + 268, + 327 + ], + 0 + ], + [ + [ + 75, + 294, + 365 + ], + 0 + ], + [ + [ + 75, + 312, + 371 + ], + 0 + ], + [ + [ + 76, + 184, + 244 + ], + 0 + ], + [ + [ + 76, + 267, + 327 + ], + 0 + ], + [ + [ + 76, + 289, + 365 + ], + 0 + ], + [ + [ + 76, + 319, + 371 + ], + 0 + ], + [ + [ + 77, + 185, + 244 + ], + 0 + ], + [ + [ + 77, + 266, + 327 + ], + 0 + ], + [ + [ + 77, + 288, + 365 + ], + 0 + ], + [ + [ + 77, + 318, + 371 + ], + 0 + ], + [ + [ + 78, + 186, + 244 + ], + 0 + ], + [ + [ + 78, + 265, + 327 + ], + 0 + ], + [ + [ + 78, + 291, + 365 + ], + 0 + ], + [ + [ + 78, + 317, + 371 + ], + 0 + ], + [ + [ + 79, + 187, + 244 + ], + 0 + ], + [ + [ + 79, + 264, + 327 + ], + 0 + ], + [ + [ + 79, + 290, + 365 + ], + 0 + ], + [ + [ + 79, + 316, + 371 + ], + 0 + ], + [ + [ + 80, + 164, + 244 + ], + 0 + ], + [ + [ + 80, + 279, + 327 + ], + 0 + ], + [ + [ + 80, + 291, + 371 + ], + 0 + ], + [ + [ + 80, + 317, + 365 + ], + 0 + ], + [ + [ + 81, + 165, + 244 + ], + 0 + ], + [ + [ + 81, + 278, + 327 + ], + 0 + ], + [ + [ + 81, + 290, + 371 + ], + 0 + ], + [ + [ + 81, + 316, + 365 + ], + 0 + ], + [ + [ + 82, + 166, + 244 + ], + 0 + ], + [ + [ + 82, + 277, + 327 + ], + 0 + ], + [ + [ + 82, + 289, + 371 + ], + 0 + ], + [ + [ + 82, + 319, + 365 + ], + 0 + ], + [ + [ + 83, + 167, + 244 + ], + 0 + ], + [ + [ + 83, + 276, + 327 + ], + 0 + ], + [ + [ + 83, + 288, + 371 + ], + 0 + ], + [ + [ + 83, + 318, + 365 + ], + 0 + ], + [ + [ + 84, + 160, + 244 + ], + 0 + ], + [ + [ + 84, + 275, + 327 + ], + 0 + ], + [ + [ + 84, + 295, + 371 + ], + 0 + ], + [ + [ + 84, + 313, + 365 + ], + 0 + ], + [ + [ + 85, + 161, + 244 + ], + 0 + ], + [ + [ + 85, + 274, + 327 + ], + 0 + ], + [ + [ + 85, + 294, + 371 + ], + 0 + ], + [ + [ + 85, + 312, + 365 + ], + 0 + ], + [ + [ + 86, + 162, + 244 + ], + 0 + ], + [ + [ + 86, + 273, + 327 + ], + 0 + ], + [ + [ + 86, + 293, + 371 + ], + 0 + ], + [ + [ + 86, + 315, + 365 + ], + 0 + ], + [ + [ + 87, + 163, + 244 + ], + 0 + ], + [ + [ + 87, + 272, + 327 + ], + 0 + ], + [ + [ + 87, + 292, + 371 + ], + 0 + ], + [ + [ + 87, + 314, + 365 + ], + 0 + ], + [ + [ + 88, + 172, + 244 + ], + 0 + ], + [ + [ + 88, + 287, + 327 + ], + 0 + ], + [ + [ + 88, + 299, + 371 + ], + 0 + ], + [ + [ + 88, + 309, + 365 + ], + 0 + ], + [ + [ + 89, + 173, + 244 + ], + 0 + ], + [ + [ + 89, + 286, + 327 + ], + 0 + ], + [ + [ + 89, + 298, + 371 + ], + 0 + ], + [ + [ + 89, + 308, + 365 + ], + 0 + ], + [ + [ + 90, + 174, + 244 + ], + 0 + ], + [ + [ + 90, + 285, + 327 + ], + 0 + ], + [ + [ + 90, + 297, + 371 + ], + 0 + ], + [ + [ + 90, + 311, + 365 + ], + 0 + ], + [ + [ + 91, + 175, + 244 + ], + 0 + ], + [ + [ + 91, + 284, + 327 + ], + 0 + ], + [ + [ + 91, + 296, + 371 + ], + 0 + ], + [ + [ + 91, + 310, + 365 + ], + 0 + ], + [ + [ + 92, + 168, + 244 + ], + 0 + ], + [ + [ + 92, + 283, + 327 + ], + 0 + ], + [ + [ + 92, + 303, + 371 + ], + 0 + ], + [ + [ + 92, + 305, + 365 + ], + 0 + ], + [ + [ + 93, + 169, + 244 + ], + 0 + ], + [ + [ + 93, + 282, + 327 + ], + 0 + ], + [ + [ + 93, + 302, + 371 + ], + 0 + ], + [ + [ + 93, + 304, + 365 + ], + 0 + ], + [ + [ + 94, + 170, + 244 + ], + 0 + ], + [ + [ + 94, + 281, + 327 + ], + 0 + ], + [ + [ + 94, + 301, + 371 + ], + 0 + ], + [ + [ + 94, + 307, + 365 + ], + 0 + ], + [ + [ + 95, + 171, + 244 + ], + 0 + ], + [ + [ + 95, + 280, + 327 + ], + 0 + ], + [ + [ + 95, + 300, + 371 + ], + 0 + ], + [ + [ + 95, + 306, + 365 + ], + 0 + ], + [ + [ + 96, + 148, + 244 + ], + 0 + ], + [ + [ + 96, + 269, + 365 + ], + 0 + ], + [ + [ + 96, + 275, + 371 + ], + 0 + ], + [ + [ + 96, + 295, + 327 + ], + 0 + ], + [ + [ + 97, + 149, + 244 + ], + 0 + ], + [ + [ + 97, + 268, + 365 + ], + 0 + ], + [ + [ + 97, + 274, + 371 + ], + 0 + ], + [ + [ + 97, + 294, + 327 + ], + 0 + ], + [ + [ + 98, + 150, + 244 + ], + 0 + ], + [ + [ + 98, + 271, + 365 + ], + 0 + ], + [ + [ + 98, + 273, + 371 + ], + 0 + ], + [ + [ + 98, + 293, + 327 + ], + 0 + ], + [ + [ + 99, + 151, + 244 + ], + 0 + ], + [ + [ + 99, + 270, + 365 + ], + 0 + ], + [ + [ + 99, + 272, + 371 + ], + 0 + ], + [ + [ + 99, + 292, + 327 + ], + 0 + ], + [ + [ + 100, + 144, + 244 + ], + 0 + ], + [ + [ + 100, + 265, + 365 + ], + 0 + ], + [ + [ + 100, + 279, + 371 + ], + 0 + ], + [ + [ + 100, + 291, + 327 + ], + 0 + ], + [ + [ + 101, + 145, + 244 + ], + 0 + ], + [ + [ + 101, + 264, + 365 + ], + 0 + ], + [ + [ + 101, + 278, + 371 + ], + 0 + ], + [ + [ + 101, + 290, + 327 + ], + 0 + ], + [ + [ + 102, + 146, + 244 + ], + 0 + ], + [ + [ + 102, + 267, + 365 + ], + 0 + ], + [ + [ + 102, + 277, + 371 + ], + 0 + ], + [ + [ + 102, + 289, + 327 + ], + 0 + ], + [ + [ + 103, + 147, + 244 + ], + 0 + ], + [ + [ + 103, + 266, + 365 + ], + 0 + ], + [ + [ + 103, + 276, + 371 + ], + 0 + ], + [ + [ + 103, + 288, + 327 + ], + 0 + ], + [ + [ + 104, + 156, + 244 + ], + 0 + ], + [ + [ + 104, + 261, + 365 + ], + 0 + ], + [ + [ + 104, + 283, + 371 + ], + 0 + ], + [ + [ + 104, + 303, + 327 + ], + 0 + ], + [ + [ + 105, + 157, + 244 + ], + 0 + ], + [ + [ + 105, + 260, + 365 + ], + 0 + ], + [ + [ + 105, + 282, + 371 + ], + 0 + ], + [ + [ + 105, + 302, + 327 + ], + 0 + ], + [ + [ + 106, + 158, + 244 + ], + 0 + ], + [ + [ + 106, + 263, + 365 + ], + 0 + ], + [ + [ + 106, + 281, + 371 + ], + 0 + ], + [ + [ + 106, + 301, + 327 + ], + 0 + ], + [ + [ + 107, + 159, + 244 + ], + 0 + ], + [ + [ + 107, + 262, + 365 + ], + 0 + ], + [ + [ + 107, + 280, + 371 + ], + 0 + ], + [ + [ + 107, + 300, + 327 + ], + 0 + ], + [ + [ + 108, + 152, + 244 + ], + 0 + ], + [ + [ + 108, + 257, + 365 + ], + 0 + ], + [ + [ + 108, + 287, + 371 + ], + 0 + ], + [ + [ + 108, + 299, + 327 + ], + 0 + ], + [ + [ + 109, + 153, + 244 + ], + 0 + ], + [ + [ + 109, + 256, + 365 + ], + 0 + ], + [ + [ + 109, + 286, + 371 + ], + 0 + ], + [ + [ + 109, + 298, + 327 + ], + 0 + ], + [ + [ + 110, + 154, + 244 + ], + 0 + ], + [ + [ + 110, + 259, + 365 + ], + 0 + ], + [ + [ + 110, + 285, + 371 + ], + 0 + ], + [ + [ + 110, + 297, + 327 + ], + 0 + ], + [ + [ + 111, + 155, + 244 + ], + 0 + ], + [ + [ + 111, + 258, + 365 + ], + 0 + ], + [ + [ + 111, + 284, + 371 + ], + 0 + ], + [ + [ + 111, + 296, + 327 + ], + 0 + ], + [ + [ + 112, + 132, + 244 + ], + 0 + ], + [ + [ + 112, + 259, + 371 + ], + 0 + ], + [ + [ + 112, + 285, + 365 + ], + 0 + ], + [ + [ + 112, + 311, + 327 + ], + 0 + ], + [ + [ + 113, + 133, + 244 + ], + 0 + ], + [ + [ + 113, + 258, + 371 + ], + 0 + ], + [ + [ + 113, + 284, + 365 + ], + 0 + ], + [ + [ + 113, + 310, + 327 + ], + 0 + ], + [ + [ + 114, + 134, + 244 + ], + 0 + ], + [ + [ + 114, + 257, + 371 + ], + 0 + ], + [ + [ + 114, + 287, + 365 + ], + 0 + ], + [ + [ + 114, + 309, + 327 + ], + 0 + ], + [ + [ + 115, + 135, + 244 + ], + 0 + ], + [ + [ + 115, + 256, + 371 + ], + 0 + ], + [ + [ + 115, + 286, + 365 + ], + 0 + ], + [ + [ + 115, + 308, + 327 + ], + 0 + ], + [ + [ + 116, + 128, + 244 + ], + 0 + ], + [ + [ + 116, + 263, + 371 + ], + 0 + ], + [ + [ + 116, + 281, + 365 + ], + 0 + ], + [ + [ + 116, + 307, + 327 + ], + 0 + ], + [ + [ + 117, + 129, + 244 + ], + 0 + ], + [ + [ + 117, + 262, + 371 + ], + 0 + ], + [ + [ + 117, + 280, + 365 + ], + 0 + ], + [ + [ + 117, + 306, + 327 + ], + 0 + ], + [ + [ + 118, + 130, + 244 + ], + 0 + ], + [ + [ + 118, + 261, + 371 + ], + 0 + ], + [ + [ + 118, + 283, + 365 + ], + 0 + ], + [ + [ + 118, + 305, + 327 + ], + 0 + ], + [ + [ + 119, + 131, + 244 + ], + 0 + ], + [ + [ + 119, + 260, + 371 + ], + 0 + ], + [ + [ + 119, + 282, + 365 + ], + 0 + ], + [ + [ + 119, + 304, + 327 + ], + 0 + ], + [ + [ + 120, + 140, + 244 + ], + 0 + ], + [ + [ + 120, + 267, + 371 + ], + 0 + ], + [ + [ + 120, + 277, + 365 + ], + 0 + ], + [ + [ + 120, + 319, + 327 + ], + 0 + ], + [ + [ + 121, + 141, + 244 + ], + 0 + ], + [ + [ + 121, + 266, + 371 + ], + 0 + ], + [ + [ + 121, + 276, + 365 + ], + 0 + ], + [ + [ + 121, + 318, + 327 + ], + 0 + ], + [ + [ + 122, + 142, + 244 + ], + 0 + ], + [ + [ + 122, + 265, + 371 + ], + 0 + ], + [ + [ + 122, + 279, + 365 + ], + 0 + ], + [ + [ + 122, + 317, + 327 + ], + 0 + ], + [ + [ + 123, + 143, + 244 + ], + 0 + ], + [ + [ + 123, + 264, + 371 + ], + 0 + ], + [ + [ + 123, + 278, + 365 + ], + 0 + ], + [ + [ + 123, + 316, + 327 + ], + 0 + ], + [ + [ + 124, + 136, + 244 + ], + 0 + ], + [ + [ + 124, + 271, + 371 + ], + 0 + ], + [ + [ + 124, + 273, + 365 + ], + 0 + ], + [ + [ + 124, + 315, + 327 + ], + 0 + ], + [ + [ + 125, + 137, + 244 + ], + 0 + ], + [ + [ + 125, + 270, + 371 + ], + 0 + ], + [ + [ + 125, + 272, + 365 + ], + 0 + ], + [ + [ + 125, + 314, + 327 + ], + 0 + ], + [ + [ + 126, + 138, + 244 + ], + 0 + ], + [ + [ + 126, + 269, + 371 + ], + 0 + ], + [ + [ + 126, + 275, + 365 + ], + 0 + ], + [ + [ + 126, + 313, + 327 + ], + 0 + ], + [ + [ + 127, + 139, + 244 + ], + 0 + ], + [ + [ + 127, + 268, + 371 + ], + 0 + ], + [ + [ + 127, + 274, + 365 + ], + 0 + ], + [ + [ + 127, + 312, + 327 + ], + 0 + ], + [ + [ + 128, + 327, + 455 + ], + 0 + ], + [ + [ + 128, + 365, + 493 + ], + 0 + ], + [ + [ + 128, + 371, + 499 + ], + 0 + ], + [ + [ + 129, + 327, + 454 + ], + 0 + ], + [ + [ + 129, + 365, + 492 + ], + 0 + ], + [ + [ + 129, + 371, + 498 + ], + 0 + ], + [ + [ + 130, + 327, + 453 + ], + 0 + ], + [ + [ + 130, + 365, + 495 + ], + 0 + ], + [ + [ + 130, + 371, + 497 + ], + 0 + ], + [ + [ + 131, + 327, + 452 + ], + 0 + ], + [ + [ + 131, + 365, + 494 + ], + 0 + ], + [ + [ + 131, + 371, + 496 + ], + 0 + ], + [ + [ + 132, + 327, + 451 + ], + 0 + ], + [ + [ + 132, + 365, + 489 + ], + 0 + ], + [ + [ + 132, + 371, + 503 + ], + 0 + ], + [ + [ + 133, + 327, + 450 + ], + 0 + ], + [ + [ + 133, + 365, + 488 + ], + 0 + ], + [ + [ + 133, + 371, + 502 + ], + 0 + ], + [ + [ + 134, + 327, + 449 + ], + 0 + ], + [ + [ + 134, + 365, + 491 + ], + 0 + ], + [ + [ + 134, + 371, + 501 + ], + 0 + ], + [ + [ + 135, + 327, + 448 + ], + 0 + ], + [ + [ + 135, + 365, + 490 + ], + 0 + ], + [ + [ + 135, + 371, + 500 + ], + 0 + ], + [ + [ + 136, + 327, + 463 + ], + 0 + ], + [ + [ + 136, + 365, + 485 + ], + 0 + ], + [ + [ + 136, + 371, + 507 + ], + 0 + ], + [ + [ + 137, + 327, + 462 + ], + 0 + ], + [ + [ + 137, + 365, + 484 + ], + 0 + ], + [ + [ + 137, + 371, + 506 + ], + 0 + ], + [ + [ + 138, + 327, + 461 + ], + 0 + ], + [ + [ + 138, + 365, + 487 + ], + 0 + ], + [ + [ + 138, + 371, + 505 + ], + 0 + ], + [ + [ + 139, + 327, + 460 + ], + 0 + ], + [ + [ + 139, + 365, + 486 + ], + 0 + ], + [ + [ + 139, + 371, + 504 + ], + 0 + ], + [ + [ + 140, + 327, + 459 + ], + 0 + ], + [ + [ + 140, + 365, + 481 + ], + 0 + ], + [ + [ + 140, + 371, + 511 + ], + 0 + ], + [ + [ + 141, + 327, + 458 + ], + 0 + ], + [ + [ + 141, + 365, + 480 + ], + 0 + ], + [ + [ + 141, + 371, + 510 + ], + 0 + ], + [ + [ + 142, + 327, + 457 + ], + 0 + ], + [ + [ + 142, + 365, + 483 + ], + 0 + ], + [ + [ + 142, + 371, + 509 + ], + 0 + ], + [ + [ + 143, + 327, + 456 + ], + 0 + ], + [ + [ + 143, + 365, + 482 + ], + 0 + ], + [ + [ + 143, + 371, + 508 + ], + 0 + ], + [ + [ + 144, + 327, + 471 + ], + 0 + ], + [ + [ + 144, + 365, + 509 + ], + 0 + ], + [ + [ + 144, + 371, + 483 + ], + 0 + ], + [ + [ + 145, + 327, + 470 + ], + 0 + ], + [ + [ + 145, + 365, + 508 + ], + 0 + ], + [ + [ + 145, + 371, + 482 + ], + 0 + ], + [ + [ + 146, + 327, + 469 + ], + 0 + ], + [ + [ + 146, + 365, + 511 + ], + 0 + ], + [ + [ + 146, + 371, + 481 + ], + 0 + ], + [ + [ + 147, + 327, + 468 + ], + 0 + ], + [ + [ + 147, + 365, + 510 + ], + 0 + ], + [ + [ + 147, + 371, + 480 + ], + 0 + ], + [ + [ + 148, + 327, + 467 + ], + 0 + ], + [ + [ + 148, + 365, + 505 + ], + 0 + ], + [ + [ + 148, + 371, + 487 + ], + 0 + ], + [ + [ + 149, + 327, + 466 + ], + 0 + ], + [ + [ + 149, + 365, + 504 + ], + 0 + ], + [ + [ + 149, + 371, + 486 + ], + 0 + ], + [ + [ + 150, + 327, + 465 + ], + 0 + ], + [ + [ + 150, + 365, + 507 + ], + 0 + ], + [ + [ + 150, + 371, + 485 + ], + 0 + ], + [ + [ + 151, + 327, + 464 + ], + 0 + ], + [ + [ + 151, + 365, + 506 + ], + 0 + ], + [ + [ + 151, + 371, + 484 + ], + 0 + ], + [ + [ + 152, + 327, + 479 + ], + 0 + ], + [ + [ + 152, + 365, + 501 + ], + 0 + ], + [ + [ + 152, + 371, + 491 + ], + 0 + ], + [ + [ + 153, + 327, + 478 + ], + 0 + ], + [ + [ + 153, + 365, + 500 + ], + 0 + ], + [ + [ + 153, + 371, + 490 + ], + 0 + ], + [ + [ + 154, + 327, + 477 + ], + 0 + ], + [ + [ + 154, + 365, + 503 + ], + 0 + ], + [ + [ + 154, + 371, + 489 + ], + 0 + ], + [ + [ + 155, + 327, + 476 + ], + 0 + ], + [ + [ + 155, + 365, + 502 + ], + 0 + ], + [ + [ + 155, + 371, + 488 + ], + 0 + ], + [ + [ + 156, + 327, + 475 + ], + 0 + ], + [ + [ + 156, + 365, + 497 + ], + 0 + ], + [ + [ + 156, + 371, + 495 + ], + 0 + ], + [ + [ + 157, + 327, + 474 + ], + 0 + ], + [ + [ + 157, + 365, + 496 + ], + 0 + ], + [ + [ + 157, + 371, + 494 + ], + 0 + ], + [ + [ + 158, + 327, + 473 + ], + 0 + ], + [ + [ + 158, + 365, + 499 + ], + 0 + ], + [ + [ + 158, + 371, + 493 + ], + 0 + ], + [ + [ + 159, + 327, + 472 + ], + 0 + ], + [ + [ + 159, + 365, + 498 + ], + 0 + ], + [ + [ + 159, + 371, + 492 + ], + 0 + ], + [ + [ + 160, + 327, + 487 + ], + 0 + ], + [ + [ + 160, + 365, + 461 + ], + 0 + ], + [ + [ + 160, + 371, + 467 + ], + 0 + ], + [ + [ + 161, + 327, + 486 + ], + 0 + ], + [ + [ + 161, + 365, + 460 + ], + 0 + ], + [ + [ + 161, + 371, + 466 + ], + 0 + ], + [ + [ + 162, + 327, + 485 + ], + 0 + ], + [ + [ + 162, + 365, + 463 + ], + 0 + ], + [ + [ + 162, + 371, + 465 + ], + 0 + ], + [ + [ + 163, + 327, + 484 + ], + 0 + ], + [ + [ + 163, + 365, + 462 + ], + 0 + ], + [ + [ + 163, + 371, + 464 + ], + 0 + ], + [ + [ + 164, + 327, + 483 + ], + 0 + ], + [ + [ + 164, + 365, + 457 + ], + 0 + ], + [ + [ + 164, + 371, + 471 + ], + 0 + ], + [ + [ + 165, + 327, + 482 + ], + 0 + ], + [ + [ + 165, + 365, + 456 + ], + 0 + ], + [ + [ + 165, + 371, + 470 + ], + 0 + ], + [ + [ + 166, + 327, + 481 + ], + 0 + ], + [ + [ + 166, + 365, + 459 + ], + 0 + ], + [ + [ + 166, + 371, + 469 + ], + 0 + ], + [ + [ + 167, + 327, + 480 + ], + 0 + ], + [ + [ + 167, + 365, + 458 + ], + 0 + ], + [ + [ + 167, + 371, + 468 + ], + 0 + ], + [ + [ + 168, + 327, + 495 + ], + 0 + ], + [ + [ + 168, + 365, + 453 + ], + 0 + ], + [ + [ + 168, + 371, + 475 + ], + 0 + ], + [ + [ + 169, + 327, + 494 + ], + 0 + ], + [ + [ + 169, + 365, + 452 + ], + 0 + ], + [ + [ + 169, + 371, + 474 + ], + 0 + ], + [ + [ + 170, + 327, + 493 + ], + 0 + ], + [ + [ + 170, + 365, + 455 + ], + 0 + ], + [ + [ + 170, + 371, + 473 + ], + 0 + ], + [ + [ + 171, + 327, + 492 + ], + 0 + ], + [ + [ + 171, + 365, + 454 + ], + 0 + ], + [ + [ + 171, + 371, + 472 + ], + 0 + ], + [ + [ + 172, + 327, + 491 + ], + 0 + ], + [ + [ + 172, + 365, + 449 + ], + 0 + ], + [ + [ + 172, + 371, + 479 + ], + 0 + ], + [ + [ + 173, + 327, + 490 + ], + 0 + ], + [ + [ + 173, + 365, + 448 + ], + 0 + ], + [ + [ + 173, + 371, + 478 + ], + 0 + ], + [ + [ + 174, + 327, + 489 + ], + 0 + ], + [ + [ + 174, + 365, + 451 + ], + 0 + ], + [ + [ + 174, + 371, + 477 + ], + 0 + ], + [ + [ + 175, + 327, + 488 + ], + 0 + ], + [ + [ + 175, + 365, + 450 + ], + 0 + ], + [ + [ + 175, + 371, + 476 + ], + 0 + ], + [ + [ + 176, + 327, + 503 + ], + 0 + ], + [ + [ + 176, + 365, + 477 + ], + 0 + ], + [ + [ + 176, + 371, + 451 + ], + 0 + ], + [ + [ + 177, + 327, + 502 + ], + 0 + ], + [ + [ + 177, + 365, + 476 + ], + 0 + ], + [ + [ + 177, + 371, + 450 + ], + 0 + ], + [ + [ + 178, + 327, + 501 + ], + 0 + ], + [ + [ + 178, + 365, + 479 + ], + 0 + ], + [ + [ + 178, + 371, + 449 + ], + 0 + ], + [ + [ + 179, + 327, + 500 + ], + 0 + ], + [ + [ + 179, + 365, + 478 + ], + 0 + ], + [ + [ + 179, + 371, + 448 + ], + 0 + ], + [ + [ + 180, + 327, + 499 + ], + 0 + ], + [ + [ + 180, + 365, + 473 + ], + 0 + ], + [ + [ + 180, + 371, + 455 + ], + 0 + ], + [ + [ + 181, + 327, + 498 + ], + 0 + ], + [ + [ + 181, + 365, + 472 + ], + 0 + ], + [ + [ + 181, + 371, + 454 + ], + 0 + ], + [ + [ + 182, + 327, + 497 + ], + 0 + ], + [ + [ + 182, + 365, + 475 + ], + 0 + ], + [ + [ + 182, + 371, + 453 + ], + 0 + ], + [ + [ + 183, + 327, + 496 + ], + 0 + ], + [ + [ + 183, + 365, + 474 + ], + 0 + ], + [ + [ + 183, + 371, + 452 + ], + 0 + ], + [ + [ + 184, + 327, + 511 + ], + 0 + ], + [ + [ + 184, + 365, + 469 + ], + 0 + ], + [ + [ + 184, + 371, + 459 + ], + 0 + ], + [ + [ + 185, + 327, + 510 + ], + 0 + ], + [ + [ + 185, + 365, + 468 + ], + 0 + ], + [ + [ + 185, + 371, + 458 + ], + 0 + ], + [ + [ + 186, + 327, + 509 + ], + 0 + ], + [ + [ + 186, + 365, + 471 + ], + 0 + ], + [ + [ + 186, + 371, + 457 + ], + 0 + ], + [ + [ + 187, + 327, + 508 + ], + 0 + ], + [ + [ + 187, + 365, + 470 + ], + 0 + ], + [ + [ + 187, + 371, + 456 + ], + 0 + ], + [ + [ + 188, + 327, + 507 + ], + 0 + ], + [ + [ + 188, + 365, + 465 + ], + 0 + ], + [ + [ + 188, + 371, + 463 + ], + 0 + ], + [ + [ + 189, + 327, + 506 + ], + 0 + ], + [ + [ + 189, + 365, + 464 + ], + 0 + ], + [ + [ + 189, + 371, + 462 + ], + 0 + ], + [ + [ + 190, + 327, + 505 + ], + 0 + ], + [ + [ + 190, + 365, + 467 + ], + 0 + ], + [ + [ + 190, + 371, + 461 + ], + 0 + ], + [ + [ + 191, + 327, + 504 + ], + 0 + ], + [ + [ + 191, + 365, + 466 + ], + 0 + ], + [ + [ + 191, + 371, + 460 + ], + 0 + ], + [ + [ + 192, + 327, + 391 + ], + 0 + ], + [ + [ + 192, + 365, + 429 + ], + 0 + ], + [ + [ + 192, + 371, + 435 + ], + 0 + ], + [ + [ + 193, + 327, + 390 + ], + 0 + ], + [ + [ + 193, + 365, + 428 + ], + 0 + ], + [ + [ + 193, + 371, + 434 + ], + 0 + ], + [ + [ + 194, + 327, + 389 + ], + 0 + ], + [ + [ + 194, + 365, + 431 + ], + 0 + ], + [ + [ + 194, + 371, + 433 + ], + 0 + ], + [ + [ + 195, + 327, + 388 + ], + 0 + ], + [ + [ + 195, + 365, + 430 + ], + 0 + ], + [ + [ + 195, + 371, + 432 + ], + 0 + ], + [ + [ + 196, + 327, + 387 + ], + 0 + ], + [ + [ + 196, + 365, + 425 + ], + 0 + ], + [ + [ + 196, + 371, + 439 + ], + 0 + ], + [ + [ + 197, + 327, + 386 + ], + 0 + ], + [ + [ + 197, + 365, + 424 + ], + 0 + ], + [ + [ + 197, + 371, + 438 + ], + 0 + ], + [ + [ + 198, + 327, + 385 + ], + 0 + ], + [ + [ + 198, + 365, + 427 + ], + 0 + ], + [ + [ + 198, + 371, + 437 + ], + 0 + ], + [ + [ + 199, + 327, + 384 + ], + 0 + ], + [ + [ + 199, + 365, + 426 + ], + 0 + ], + [ + [ + 199, + 371, + 436 + ], + 0 + ], + [ + [ + 200, + 327, + 399 + ], + 0 + ], + [ + [ + 200, + 365, + 421 + ], + 0 + ], + [ + [ + 200, + 371, + 443 + ], + 0 + ], + [ + [ + 201, + 327, + 398 + ], + 0 + ], + [ + [ + 201, + 365, + 420 + ], + 0 + ], + [ + [ + 201, + 371, + 442 + ], + 0 + ], + [ + [ + 202, + 327, + 397 + ], + 0 + ], + [ + [ + 202, + 365, + 423 + ], + 0 + ], + [ + [ + 202, + 371, + 441 + ], + 0 + ], + [ + [ + 203, + 327, + 396 + ], + 0 + ], + [ + [ + 203, + 365, + 422 + ], + 0 + ], + [ + [ + 203, + 371, + 440 + ], + 0 + ], + [ + [ + 204, + 327, + 395 + ], + 0 + ], + [ + [ + 204, + 365, + 417 + ], + 0 + ], + [ + [ + 204, + 371, + 447 + ], + 0 + ], + [ + [ + 205, + 327, + 394 + ], + 0 + ], + [ + [ + 205, + 365, + 416 + ], + 0 + ], + [ + [ + 205, + 371, + 446 + ], + 0 + ], + [ + [ + 206, + 327, + 393 + ], + 0 + ], + [ + [ + 206, + 365, + 419 + ], + 0 + ], + [ + [ + 206, + 371, + 445 + ], + 0 + ], + [ + [ + 207, + 327, + 392 + ], + 0 + ], + [ + [ + 207, + 365, + 418 + ], + 0 + ], + [ + [ + 207, + 371, + 444 + ], + 0 + ], + [ + [ + 208, + 327, + 407 + ], + 0 + ], + [ + [ + 208, + 365, + 445 + ], + 0 + ], + [ + [ + 208, + 371, + 419 + ], + 0 + ], + [ + [ + 209, + 327, + 406 + ], + 0 + ], + [ + [ + 209, + 365, + 444 + ], + 0 + ], + [ + [ + 209, + 371, + 418 + ], + 0 + ], + [ + [ + 210, + 327, + 405 + ], + 0 + ], + [ + [ + 210, + 365, + 447 + ], + 0 + ], + [ + [ + 210, + 371, + 417 + ], + 0 + ], + [ + [ + 211, + 327, + 404 + ], + 0 + ], + [ + [ + 211, + 365, + 446 + ], + 0 + ], + [ + [ + 211, + 371, + 416 + ], + 0 + ], + [ + [ + 212, + 327, + 403 + ], + 0 + ], + [ + [ + 212, + 365, + 441 + ], + 0 + ], + [ + [ + 212, + 371, + 423 + ], + 0 + ], + [ + [ + 213, + 327, + 402 + ], + 0 + ], + [ + [ + 213, + 365, + 440 + ], + 0 + ], + [ + [ + 213, + 371, + 422 + ], + 0 + ], + [ + [ + 214, + 327, + 401 + ], + 0 + ], + [ + [ + 214, + 365, + 443 + ], + 0 + ], + [ + [ + 214, + 371, + 421 + ], + 0 + ], + [ + [ + 215, + 327, + 400 + ], + 0 + ], + [ + [ + 215, + 365, + 442 + ], + 0 + ], + [ + [ + 215, + 371, + 420 + ], + 0 + ], + [ + [ + 216, + 327, + 415 + ], + 0 + ], + [ + [ + 216, + 365, + 437 + ], + 0 + ], + [ + [ + 216, + 371, + 427 + ], + 0 + ], + [ + [ + 217, + 327, + 414 + ], + 0 + ], + [ + [ + 217, + 365, + 436 + ], + 0 + ], + [ + [ + 217, + 371, + 426 + ], + 0 + ], + [ + [ + 218, + 327, + 413 + ], + 0 + ], + [ + [ + 218, + 365, + 439 + ], + 0 + ], + [ + [ + 218, + 371, + 425 + ], + 0 + ], + [ + [ + 219, + 327, + 412 + ], + 0 + ], + [ + [ + 219, + 365, + 438 + ], + 0 + ], + [ + [ + 219, + 371, + 424 + ], + 0 + ], + [ + [ + 220, + 327, + 411 + ], + 0 + ], + [ + [ + 220, + 365, + 433 + ], + 0 + ], + [ + [ + 220, + 371, + 431 + ], + 0 + ], + [ + [ + 221, + 327, + 410 + ], + 0 + ], + [ + [ + 221, + 365, + 432 + ], + 0 + ], + [ + [ + 221, + 371, + 430 + ], + 0 + ], + [ + [ + 222, + 327, + 409 + ], + 0 + ], + [ + [ + 222, + 365, + 435 + ], + 0 + ], + [ + [ + 222, + 371, + 429 + ], + 0 + ], + [ + [ + 223, + 327, + 408 + ], + 0 + ], + [ + [ + 223, + 365, + 434 + ], + 0 + ], + [ + [ + 223, + 371, + 428 + ], + 0 + ], + [ + [ + 224, + 327, + 423 + ], + 0 + ], + [ + [ + 224, + 365, + 397 + ], + 0 + ], + [ + [ + 224, + 371, + 403 + ], + 0 + ], + [ + [ + 225, + 327, + 422 + ], + 0 + ], + [ + [ + 225, + 365, + 396 + ], + 0 + ], + [ + [ + 225, + 371, + 402 + ], + 0 + ], + [ + [ + 226, + 327, + 421 + ], + 0 + ], + [ + [ + 226, + 365, + 399 + ], + 0 + ], + [ + [ + 226, + 371, + 401 + ], + 0 + ], + [ + [ + 227, + 327, + 420 + ], + 0 + ], + [ + [ + 227, + 365, + 398 + ], + 0 + ], + [ + [ + 227, + 371, + 400 + ], + 0 + ], + [ + [ + 228, + 327, + 419 + ], + 0 + ], + [ + [ + 228, + 365, + 393 + ], + 0 + ], + [ + [ + 228, + 371, + 407 + ], + 0 + ], + [ + [ + 229, + 327, + 418 + ], + 0 + ], + [ + [ + 229, + 365, + 392 + ], + 0 + ], + [ + [ + 229, + 371, + 406 + ], + 0 + ], + [ + [ + 230, + 327, + 417 + ], + 0 + ], + [ + [ + 230, + 365, + 395 + ], + 0 + ], + [ + [ + 230, + 371, + 405 + ], + 0 + ], + [ + [ + 231, + 327, + 416 + ], + 0 + ], + [ + [ + 231, + 365, + 394 + ], + 0 + ], + [ + [ + 231, + 371, + 404 + ], + 0 + ], + [ + [ + 232, + 327, + 431 + ], + 0 + ], + [ + [ + 232, + 365, + 389 + ], + 0 + ], + [ + [ + 232, + 371, + 411 + ], + 0 + ], + [ + [ + 233, + 327, + 430 + ], + 0 + ], + [ + [ + 233, + 365, + 388 + ], + 0 + ], + [ + [ + 233, + 371, + 410 + ], + 0 + ], + [ + [ + 234, + 327, + 429 + ], + 0 + ], + [ + [ + 234, + 365, + 391 + ], + 0 + ], + [ + [ + 234, + 371, + 409 + ], + 0 + ], + [ + [ + 235, + 327, + 428 + ], + 0 + ], + [ + [ + 235, + 365, + 390 + ], + 0 + ], + [ + [ + 235, + 371, + 408 + ], + 0 + ], + [ + [ + 236, + 327, + 427 + ], + 0 + ], + [ + [ + 236, + 365, + 385 + ], + 0 + ], + [ + [ + 236, + 371, + 415 + ], + 0 + ], + [ + [ + 237, + 327, + 426 + ], + 0 + ], + [ + [ + 237, + 365, + 384 + ], + 0 + ], + [ + [ + 237, + 371, + 414 + ], + 0 + ], + [ + [ + 238, + 327, + 425 + ], + 0 + ], + [ + [ + 238, + 365, + 387 + ], + 0 + ], + [ + [ + 238, + 371, + 413 + ], + 0 + ], + [ + [ + 239, + 327, + 424 + ], + 0 + ], + [ + [ + 239, + 365, + 386 + ], + 0 + ], + [ + [ + 239, + 371, + 412 + ], + 0 + ], + [ + [ + 240, + 327, + 439 + ], + 0 + ], + [ + [ + 240, + 365, + 413 + ], + 0 + ], + [ + [ + 240, + 371, + 387 + ], + 0 + ], + [ + [ + 241, + 327, + 438 + ], + 0 + ], + [ + [ + 241, + 365, + 412 + ], + 0 + ], + [ + [ + 241, + 371, + 386 + ], + 0 + ], + [ + [ + 242, + 327, + 437 + ], + 0 + ], + [ + [ + 242, + 365, + 415 + ], + 0 + ], + [ + [ + 242, + 371, + 385 + ], + 0 + ], + [ + [ + 243, + 327, + 436 + ], + 0 + ], + [ + [ + 243, + 365, + 414 + ], + 0 + ], + [ + [ + 243, + 371, + 384 + ], + 0 + ], + [ + [ + 244, + 256, + 500 + ], + 0 + ], + [ + [ + 244, + 257, + 501 + ], + 0 + ], + [ + [ + 244, + 258, + 502 + ], + 0 + ], + [ + [ + 244, + 259, + 503 + ], + 0 + ], + [ + [ + 244, + 260, + 496 + ], + 0 + ], + [ + [ + 244, + 261, + 497 + ], + 0 + ], + [ + [ + 244, + 262, + 498 + ], + 0 + ], + [ + [ + 244, + 263, + 499 + ], + 0 + ], + [ + [ + 244, + 264, + 508 + ], + 0 + ], + [ + [ + 244, + 265, + 509 + ], + 0 + ], + [ + [ + 244, + 266, + 510 + ], + 0 + ], + [ + [ + 244, + 267, + 511 + ], + 0 + ], + [ + [ + 244, + 268, + 504 + ], + 0 + ], + [ + [ + 244, + 269, + 505 + ], + 0 + ], + [ + [ + 244, + 270, + 506 + ], + 0 + ], + [ + [ + 244, + 271, + 507 + ], + 0 + ], + [ + [ + 244, + 272, + 484 + ], + 0 + ], + [ + [ + 244, + 273, + 485 + ], + 0 + ], + [ + [ + 244, + 274, + 486 + ], + 0 + ], + [ + [ + 244, + 275, + 487 + ], + 0 + ], + [ + [ + 244, + 276, + 480 + ], + 0 + ], + [ + [ + 244, + 277, + 481 + ], + 0 + ], + [ + [ + 244, + 278, + 482 + ], + 0 + ], + [ + [ + 244, + 279, + 483 + ], + 0 + ], + [ + [ + 244, + 280, + 492 + ], + 0 + ], + [ + [ + 244, + 281, + 493 + ], + 0 + ], + [ + [ + 244, + 282, + 494 + ], + 0 + ], + [ + [ + 244, + 283, + 495 + ], + 0 + ], + [ + [ + 244, + 284, + 488 + ], + 0 + ], + [ + [ + 244, + 285, + 489 + ], + 0 + ], + [ + [ + 244, + 286, + 490 + ], + 0 + ], + [ + [ + 244, + 287, + 491 + ], + 0 + ], + [ + [ + 244, + 288, + 468 + ], + 0 + ], + [ + [ + 244, + 289, + 469 + ], + 0 + ], + [ + [ + 244, + 290, + 470 + ], + 0 + ], + [ + [ + 244, + 291, + 471 + ], + 0 + ], + [ + [ + 244, + 292, + 464 + ], + 0 + ], + [ + [ + 244, + 293, + 465 + ], + 0 + ], + [ + [ + 244, + 294, + 466 + ], + 0 + ], + [ + [ + 244, + 295, + 467 + ], + 0 + ], + [ + [ + 244, + 296, + 476 + ], + 0 + ], + [ + [ + 244, + 297, + 477 + ], + 0 + ], + [ + [ + 244, + 298, + 478 + ], + 0 + ], + [ + [ + 244, + 299, + 479 + ], + 0 + ], + [ + [ + 244, + 300, + 472 + ], + 0 + ], + [ + [ + 244, + 301, + 473 + ], + 0 + ], + [ + [ + 244, + 302, + 474 + ], + 0 + ], + [ + [ + 244, + 303, + 475 + ], + 0 + ], + [ + [ + 244, + 304, + 452 + ], + 0 + ], + [ + [ + 244, + 305, + 453 + ], + 0 + ], + [ + [ + 244, + 306, + 454 + ], + 0 + ], + [ + [ + 244, + 307, + 455 + ], + 0 + ], + [ + [ + 244, + 308, + 448 + ], + 0 + ], + [ + [ + 244, + 309, + 449 + ], + 0 + ], + [ + [ + 244, + 310, + 450 + ], + 0 + ], + [ + [ + 244, + 311, + 451 + ], + 0 + ], + [ + [ + 244, + 312, + 460 + ], + 0 + ], + [ + [ + 244, + 313, + 461 + ], + 0 + ], + [ + [ + 244, + 314, + 462 + ], + 0 + ], + [ + [ + 244, + 315, + 463 + ], + 0 + ], + [ + [ + 244, + 316, + 456 + ], + 0 + ], + [ + [ + 244, + 317, + 457 + ], + 0 + ], + [ + [ + 244, + 318, + 458 + ], + 0 + ], + [ + [ + 244, + 319, + 459 + ], + 0 + ], + [ + [ + 244, + 320, + 436 + ], + 0 + ], + [ + [ + 244, + 321, + 437 + ], + 0 + ], + [ + [ + 244, + 322, + 438 + ], + 0 + ], + [ + [ + 244, + 323, + 439 + ], + 0 + ], + [ + [ + 244, + 324, + 432 + ], + 0 + ], + [ + [ + 244, + 325, + 433 + ], + 0 + ], + [ + [ + 244, + 326, + 434 + ], + 0 + ], + [ + [ + 244, + 327, + 435 + ], + 0 + ], + [ + [ + 244, + 328, + 444 + ], + 0 + ], + [ + [ + 244, + 329, + 445 + ], + 0 + ], + [ + [ + 244, + 330, + 446 + ], + 0 + ], + [ + [ + 244, + 331, + 447 + ], + 0 + ], + [ + [ + 244, + 332, + 440 + ], + 0 + ], + [ + [ + 244, + 333, + 441 + ], + 0 + ], + [ + [ + 244, + 334, + 442 + ], + 0 + ], + [ + [ + 244, + 335, + 443 + ], + 0 + ], + [ + [ + 244, + 336, + 420 + ], + 0 + ], + [ + [ + 244, + 337, + 421 + ], + 0 + ], + [ + [ + 244, + 338, + 422 + ], + 0 + ], + [ + [ + 244, + 339, + 423 + ], + 0 + ], + [ + [ + 244, + 340, + 416 + ], + 0 + ], + [ + [ + 244, + 341, + 417 + ], + 0 + ], + [ + [ + 244, + 342, + 418 + ], + 0 + ], + [ + [ + 244, + 343, + 419 + ], + 0 + ], + [ + [ + 244, + 344, + 428 + ], + 0 + ], + [ + [ + 244, + 345, + 429 + ], + 0 + ], + [ + [ + 244, + 346, + 430 + ], + 0 + ], + [ + [ + 244, + 347, + 431 + ], + 0 + ], + [ + [ + 244, + 348, + 424 + ], + 0 + ], + [ + [ + 244, + 349, + 425 + ], + 0 + ], + [ + [ + 244, + 350, + 426 + ], + 0 + ], + [ + [ + 244, + 351, + 427 + ], + 0 + ], + [ + [ + 244, + 352, + 404 + ], + 0 + ], + [ + [ + 244, + 353, + 405 + ], + 0 + ], + [ + [ + 244, + 354, + 406 + ], + 0 + ], + [ + [ + 244, + 355, + 407 + ], + 0 + ], + [ + [ + 244, + 356, + 400 + ], + 0 + ], + [ + [ + 244, + 357, + 401 + ], + 0 + ], + [ + [ + 244, + 358, + 402 + ], + 0 + ], + [ + [ + 244, + 359, + 403 + ], + 0 + ], + [ + [ + 244, + 360, + 412 + ], + 0 + ], + [ + [ + 244, + 361, + 413 + ], + 0 + ], + [ + [ + 244, + 362, + 414 + ], + 0 + ], + [ + [ + 244, + 363, + 415 + ], + 0 + ], + [ + [ + 244, + 364, + 408 + ], + 0 + ], + [ + [ + 244, + 365, + 409 + ], + 0 + ], + [ + [ + 244, + 366, + 410 + ], + 0 + ], + [ + [ + 244, + 367, + 411 + ], + 0 + ], + [ + [ + 244, + 368, + 388 + ], + 0 + ], + [ + [ + 244, + 369, + 389 + ], + 0 + ], + [ + [ + 244, + 370, + 390 + ], + 0 + ], + [ + [ + 244, + 371, + 391 + ], + 0 + ], + [ + [ + 244, + 372, + 384 + ], + 0 + ], + [ + [ + 244, + 373, + 385 + ], + 0 + ], + [ + [ + 244, + 374, + 386 + ], + 0 + ], + [ + [ + 244, + 375, + 387 + ], + 0 + ], + [ + [ + 244, + 376, + 396 + ], + 0 + ], + [ + [ + 244, + 377, + 397 + ], + 0 + ], + [ + [ + 244, + 378, + 398 + ], + 0 + ], + [ + [ + 244, + 379, + 399 + ], + 0 + ], + [ + [ + 244, + 380, + 392 + ], + 0 + ], + [ + [ + 244, + 381, + 393 + ], + 0 + ], + [ + [ + 244, + 382, + 394 + ], + 0 + ], + [ + [ + 244, + 383, + 395 + ], + 0 + ], + [ + [ + 245, + 327, + 434 + ], + 0 + ], + [ + [ + 245, + 365, + 408 + ], + 0 + ], + [ + [ + 245, + 371, + 390 + ], + 0 + ], + [ + [ + 246, + 327, + 433 + ], + 0 + ], + [ + [ + 246, + 365, + 411 + ], + 0 + ], + [ + [ + 246, + 371, + 389 + ], + 0 + ], + [ + [ + 247, + 327, + 432 + ], + 0 + ], + [ + [ + 247, + 365, + 410 + ], + 0 + ], + [ + [ + 247, + 371, + 388 + ], + 0 + ], + [ + [ + 248, + 327, + 447 + ], + 0 + ], + [ + [ + 248, + 365, + 405 + ], + 0 + ], + [ + [ + 248, + 371, + 395 + ], + 0 + ], + [ + [ + 249, + 327, + 446 + ], + 0 + ], + [ + [ + 249, + 365, + 404 + ], + 0 + ], + [ + [ + 249, + 371, + 394 + ], + 0 + ], + [ + [ + 250, + 327, + 445 + ], + 0 + ], + [ + [ + 250, + 365, + 407 + ], + 0 + ], + [ + [ + 250, + 371, + 393 + ], + 0 + ], + [ + [ + 251, + 327, + 444 + ], + 0 + ], + [ + [ + 251, + 365, + 406 + ], + 0 + ], + [ + [ + 251, + 371, + 392 + ], + 0 + ], + [ + [ + 252, + 327, + 443 + ], + 0 + ], + [ + [ + 252, + 365, + 401 + ], + 0 + ], + [ + [ + 252, + 371, + 399 + ], + 0 + ], + [ + [ + 253, + 327, + 442 + ], + 0 + ], + [ + [ + 253, + 365, + 400 + ], + 0 + ], + [ + [ + 253, + 371, + 398 + ], + 0 + ], + [ + [ + 254, + 327, + 441 + ], + 0 + ], + [ + [ + 254, + 365, + 403 + ], + 0 + ], + [ + [ + 254, + 371, + 397 + ], + 0 + ], + [ + [ + 255, + 327, + 440 + ], + 0 + ], + [ + [ + 255, + 365, + 402 + ], + 0 + ], + [ + [ + 255, + 371, + 396 + ], + 0 + ] + ], + "seconds_cap": 60, + "seed_vectors": [ + 365, + 244, + 327, + 371 + ], + "total_planes": 43435, + "witness": null +} diff --git a/research/p104-endpoint-common-plane-growth-bound/inputs/closure.py b/research/p104-endpoint-common-plane-growth-bound/inputs/closure.py new file mode 100644 index 0000000000..1bd15a2b91 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/inputs/closure.py @@ -0,0 +1,192 @@ +"""Exact directed max closure for adding one binary vector to interior helper frames.""" +from collections import Counter, deque +from fractions import Fraction as F +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from math import ceil, floor +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal +from sys import setrecursionlimit + +HERE = Path(__file__).resolve().parent +SCALE = 10**52 +PINS = { + 'inputs/7334-WORD.json.gz': '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a', + 'inputs/pricing.py': 'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', +} + + +def maxclosure(weights, implications): + count = len(weights) + source, sink = count, count+1 + graph = [[] for _ in range(count+2)] + positive = sum(max(0,w) for w in weights) + inf = positive+1 + + def edge(u,v,c): + graph[u].append([v,c,len(graph[v])]) + graph[v].append([u,0,len(graph[u])-1]) + + for i,w in enumerate(weights): + if w>0: + edge(source,i,w) + elif w<0: + edge(i,sink,-w) + for u,v in implications: + edge(u,sink if v is None else v,inf) + flow = 0 + while True: + level = [-1]*(count+2) + level[source] = 0 + queue = deque([source]) + while queue: + u = queue.popleft() + for v,c,_ in graph[u]: + if c and level[v]<0: + level[v] = level[u]+1 + queue.append(v) + if level[sink]<0: + chosen = {i for i in range(count) if level[i]>=0} + assert all(u not in chosen or v in chosen for u,v in implications) + assert sum(weights[i] for i in chosen)==positive-flow + return positive-flow,chosen + at = [0]*(count+2) + + def push(u,budget): + if u==sink: + return budget + while at[u]0: + lower,selected=maxclosure(wl,implications) + rec['lower_scaled']=lower + if lower>0: + chosen={active[i] for i in selected} + ranks_delta=Counter() + changed=[] + lower_check=upper_check=0 + for t,a,b,ca,cb,d in edges: + x,y=a in chosen,b in chosen + da=spaces[ca]|{u^v for u in spaces[ca]} if x else spaces[ca] + db=spaces[cb]|{u^v for u in spaces[cb]} if y else spaces[cb] + assert da<=db + dn=d+y-x + if dn!=d: + ranks_delta[d]+=1 + if dn: + ranks_delta[dn]-=1 + changed.append([t,d,dn]) + if dnd: + lower_check-=inc[dn][1] + upper_check-=inc[dn][0] + assert lower_check==lower and lower<=upper_check<=upper + witness={'vector':v,'chosen_groups':sorted(chosen),'segments':{g:groups[g] for g in sorted(chosen)}, + 'contacts':{g:uses[g] for g in sorted(chosen)},'changed_rank_edges':changed, + 'incident_paid_edges':sum(a in chosen or b in chosen for _,a,b,*_ in edges), + 'old_minus_new_rank_hist':{r:c for r,c in ranks_delta.items() if c}, + 'raw_directed_bounds':[str(17*F(lower,SCALE)),str(17*F(upper_check,SCALE))]} + results.append(rec) + if witness: + break + except TimeoutError: + capped=True + finally: + alarm(0) + print(dumps({'pins':PINS|{'inputs/inventory.py':sha256((HERE/'inputs/inventory.py').read_bytes()).hexdigest()}, + 'groups':len(groups),'eligible_groups':len(movable),'incident_edges':len(edges), + 'vectors_checked':len(results),'case_cap':511,'seconds_cap':60,'capped':capped, + 'scale':SCALE,'rounding_intervals':inc,'results':results,'witness':witness},sort_keys=True,indent=2)) + if capped: + raise SystemExit(2) + + +if __name__=='__main__': + main() diff --git a/research/p104-endpoint-common-plane-growth-bound/inputs/inventory.py b/research/p104-endpoint-common-plane-growth-bound/inputs/inventory.py new file mode 100644 index 0000000000..ce651d88ee --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/inputs/inventory.py @@ -0,0 +1,164 @@ +"""Exact current-word common-frame screen for closed public helper components.""" +from collections import Counter, defaultdict +from fractions import Fraction as F +from functools import cache +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import alarm + +HERE = Path(__file__).resolve().parent +PINS = { + 'inputs/7334-WORD.json.gz': '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a', + 'inputs/pricing.py': 'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', +} + + +def span(vectors): + result = {0} + for v in vectors: + result |= {x ^ v for x in result} + return result + + +def inventory(w): + roles = w['public'] + w['owned_fields'] + main = set(w['live']) | {i + 112 for i in w['live']} | set(w['hosted']['X2']) | set(w['hosted']['Y2']) + assert w['public'] == 1501 and len(main) == 400 + eligible = set(range(w['public'])) - main + assert len(eligible) == 1101 + parent, nodes, contacts, moves = [], [], [], [] + + def node(role, chart, endpoint=False): + n = len(nodes) + nodes.append([role, chart, endpoint]) + parent.append(n) + return n + + def root(i): + while parent[i] != i: + i, parent[i] = parent[i], parent[parent[i]] + return i + + active = [node(i, c, True) for i, c in enumerate(w['initial'])] + [None]*w['owned_fields'] + assert len(active) == roles + for t,(op,r,*a) in enumerate(w['program']): + old = active[r] + if op == 'INIT': + assert old is None + active[r] = node(r,a[0]) + elif op == 'CLEAR': + assert nodes[old][1] == a[0] + active[r] = None + elif op == 'MOVE': + assert nodes[old][1] == a[0] + new = node(r,a[1]) + moves.append((t,old,new)) + active[r] = new + elif op in ('ADD','COPY'): + s,_,c = a + assert nodes[old][1] == nodes[active[s]][1] == c + parent[root(active[s])] = root(old) + contacts.append((t,old,op)) + else: + assert op == 'SCALE' and nodes[old][1] == a[1] + contacts.append((t,old,op)) + assert all(active[i] is None for i in range(w['public'], roles)) + for i,c in enumerate(w['final']): + assert nodes[active[i]][1] == c + nodes[active[i]][2] = True + groups, uses, incident = defaultdict(list),defaultdict(list),defaultdict(list) + for i,n in enumerate(nodes): + groups[root(i)].append(n) + for t,n,op in contacts: + uses[root(n)].append((t,op)) + for t,a,b in moves: + ra,rb = root(a),root(b) + assert ra != rb + incident[ra].append((t,nodes[b][1],'source')) + incident[rb].append((t,nodes[a][1],'target')) + return eligible,groups,uses,incident + + +def main(): + assert __debug__ + alarm(40) + for name,h in PINS.items(): + assert sha256((HERE/name).read_bytes()).hexdigest() == h + raw = decompress((HERE/'inputs/7334-WORD.json.gz').read_bytes()) + assert sha256(raw).hexdigest() == '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac' + w = loads(raw) + assert len(w['program']) == 76466 + e,groups,uses,incident = inventory(w) + frames = [tuple(v) for v in w['frames']] + spaces = [span(v) for v in frames] + assert all(len(s)==1<0 else lo)[0 if n>0 else 1] for r,n in delta) + right = sum(n*h(r,lo if n>0 else hi)[1 if n>0 else 0] for r,n in delta) + return 17*left,17*right + + counts, cases = Counter(),[] + for g, members in groups.items(): + if sum(op=='ADD' for _,op in uses[g]) < 2: + continue + counts['multi_add'] += 1 + if any(r not in e for r,_,_ in members): + counts['main_or_owned'] += 1 + continue + if any(endpoint for _,_,endpoint in members): + counts['fixed_endpoint'] += 1 + continue + counts['closed_pure'] += 1 + current, = {c for _,c,_ in members} + d = ranks[current] + edges = sorted(incident[g]) + assert edges and all(w['program'][t][0]=='MOVE' for t,_,_ in edges) + lower = [c for _,c,_ in edges if ranks[c] < d] + upper = [c for _,c,_ in edges if ranks[c] > d] + assert len(lower)+len(upper)==len(edges) + assert all(spaces[c] <= spaces[current] for c in lower) + assert all(spaces[current] <= spaces[c] for c in upper) + min_r = max((ranks[c]+1 for c in lower),default=0) + max_r = min((ranks[c]-1 for c in upper),default=9) + low_space = span(x for c in lower for x in frames[c]) + high_space = set.intersection(set(range(512)),*(spaces[c] for c in upper)) + assert low_space <= spaces[current] <= high_space + first = max(min_r,len(low_space).bit_length()-1) + last = min(max_r,len(high_space).bit_length()-1) + assert first <= d <= last + stock = Counter(abs(d-ranks[c]) for _,c,_ in edges) + + def quote(k): + delta = stock.copy() + delta.subtract(abs(k-ranks[c]) for _,c,_ in edges) + return gain(tuple(sorted((r,n) for r,n in delta.items() if n))) + + relaxed = [k for k in sorted({min_r,max_r}) if quote(k)[1]>0] + if not relaxed: + counts['dimension_nonpositive'] += 1 + continue + feasible = [(k,quote(k)) for k in sorted({first,last}) if quote(k)[1]>0] + if feasible: + counts['geometry_survivor'] += 1 + else: + counts['geometry_exclusion'] += 1 + cases.append({'first_contact':uses[g][0][0],'old_chart':current,'old_rank':d, + 'roles':sorted({r for r,_,_ in members}),'contacts':uses[g], 'moves':edges, + 'relaxed_ranks':[min_r,max_r],'feasible_ranks':[first,last], + 'price_positive_relaxed':[(k,quote(k)) for k in relaxed], + 'price_positive_feasible':feasible,'lower_span':sorted(low_space),'upper_span':sorted(high_space)}) + alarm(0) + print(dumps({'pins':PINS,'counts':counts,'cases':sorted(cases,key=lambda x:x['first_contact']), + 'runner_cap_seconds':40,'paid_zero_disallowed':True,'seed':None},sort_keys=True,indent=2,default=str)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-endpoint-common-plane-growth-bound/inputs/pricing.py b/research/p104-endpoint-common-plane-growth-bound/inputs/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/inputs/pricing.py @@ -0,0 +1,82 @@ +"""Directed interval arithmetic and the retained signed BIT invoice.""" +from collections import Counter +from fractions import Fraction +from functools import cache + +TARGET = "10018846261809/2500000000000000" +SCALE = 10**49 + + +def rounded(x, upper): + scaled = SCALE*x + if upper: + return Fraction(-((-scaled.numerator) // scaled.denominator), SCALE) + return Fraction(scaled.numerator // scaled.denominator, SCALE) + + +@cache +def log_bounds(x): + z = (x-1)/(x+1) + terms = 60 + exact_partial = 2*sum(z**(2*i+1)/(2*i+1) for i in range(terms)) + tail = 2*z**(2*terms+1)/((2*terms+1)*(1-z*z)) + return rounded(exact_partial, False), rounded(exact_partial+tail, True) + + +@cache +def power_bounds(rank, k): + binary = 2**(rank.bit_length()-1) + shift = binary.bit_length()-1 + l2, u2 = log_bounds(Fraction(2)) + lo, hi = log_bounds(Fraction(rank, binary)) + lo, hi = k*(lo+shift*l2), k*(hi+shift*u2) + assert 0 <= lo <= hi < 1 + + def exponential(z, terms): + total = term = Fraction(1) + for i in range(1, terms+1): + term *= -z/i + total += term + return total + + return rounded(rank*exponential(hi, 35), False), rounded(rank*exponential(lo, 34), True) + + +def cost(hist, k): + lower = upper = Fraction(0) + for r, n in hist.items(): + a, b = (n*x for x in power_bounds(r, k)) + lower += min(a, b) + upper += max(a, b) + return lower, upper + + +def profile(invoice, native, word, ranks): + copies = invoice["native_calls"] + assert copies == len(invoice["native_instances"]) == 36 + assert {tuple((r["stage"], r["copy"])) for r in invoice["native_instances"]} == { + (stage, which) for stage in range(1, 19) for which in (0, 1) + } + assert all(r["ports"] == 111 for r in invoice["native_instances"]) + assert native == Counter({int(r): n for r, n in invoice["native_paid"].items()}) + assert sum(native.values()) == 2871 + caller_paid = {1: 444, **{r: 444 for r in range(7, 57, 7)}} + assert invoice["event_counts"]["QUERY"]*111 == caller_paid[1] + assert invoice["event_counts"]["IDLE_ONE"]*111 == 8*444 + full_paid = Counter({r: copies*n for r, n in native.items()}) + full_paid.update(caller_paid) + + helpers = Counter(ranks[word["final"][j]]-ranks[word["start"][j]] + for j in range(222, word["public"])) + assert helpers == Counter({int(r): n for r, n in invoice["native_helpers"].items()}) + caller_targets = {**{r: 444 for r in range(8, 65, 7)}, 127: 222} + full_targets = Counter({r: copies*n for r, n in helpers.items()}) + full_targets.update(caller_targets) + assert full_paid == Counter({int(r): n for r, n in invoice["paid"].items()}) + assert full_targets == Counter({int(r): n for r, n in invoice["targets"].items()}) + assert sum(full_paid.values()) == invoice["paid_jobs"] + assert sum(full_targets.values()) == invoice["productive_fields"] + signed = full_targets.copy() + signed.subtract(full_paid) + assert sum(r*n for r, n in signed.items()) == invoice["rank_surplus"] + return signed, copies diff --git a/research/p104-endpoint-common-plane-growth-bound/inputs/target_closure.py b/research/p104-endpoint-common-plane-growth-bound/inputs/target_closure.py new file mode 100644 index 0000000000..745ae99aea --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/inputs/target_closure.py @@ -0,0 +1,149 @@ +"""Coupled one-vector productive endpoint and paid interior chart moves.""" +from collections import Counter +from fractions import Fraction as F +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from math import ceil, floor +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +H = Path(__file__).resolve().parent +I = H / 'inputs' +S = 10**52 + + +def timed_out(*_): + raise TimeoutError + + +def get_inventory(w, base): + public, groups, uses, incident = base['inventory'](w) + spaces = list(map(base['span'],w['frames'])) + chart = {g: members[0][1] for g,members in groups.items()} + movable = {g for g,members in groups.items() if all(r in public for r,_,_ in members)} + endpoint = {(r,c):g for g,members in groups.items() for r,c,b in members if b and r in public} + assert len(endpoint) == 2202 + ends = {} + for g, rows in incident.items(): + for t,_,side in rows: + ends.setdefault(t,{})[side] = g + edges = [(t, e['source'], e['target'], True) for t,e in sorted(ends.items())] + edges += [(r,endpoint[r,w['initial'][r]],endpoint[r,w['final'][r]],False) for r in sorted(public)] + out = [] + for t,a,b,paid in edges: + if a not in movable and b not in movable: + continue + ca,cb = chart[a],chart[b] + assert spaces[ca] < spaces[cb] + assert not paid or w['program'][t][-1] is False + out.append((t,a,b,ca,cb,len(w['frames'][cb])-len(w['frames'][ca]),paid)) + return groups,uses,spaces,chart,movable,out + + +def bound(v, active, spaces, edges, inc, maxclosure, high): + ids = {g:i for i,g in enumerate(active)} + weights = [0]*len(active) + imp = set() + for _,a,b,ca,cb,d,paid in edges: + x,y = ids.get(a), ids.get(b) + if x is None and y is None: + continue + if v in spaces[cb]: + assert x is not None and y is None + if paid: + weights[x] += inc[d][high] + elif d==1: + imp.add((x,None)) + else: + weights[x] -= inc[d][1-high] + else: + slope = -inc[d+1][1-high] if paid else inc[d+1][high] + if x is not None: + imp.add((x,y)) + weights[x] -= slope + if y is not None: + weights[y] += slope + value,chosen = maxclosure(weights,imp) + return value,{active[i] for i in chosen} + + +def certify(v, chosen, edges, spaces, inc): + price = [0,0] + dp,dt = Counter(),Counter() + p,tg = [],[] + for t,a,b,ca,cb,d,paid in edges: + x,y=a in chosen,b in chosen + a2=spaces[ca]|{u^v for u in spaces[ca]} if x else spaces[ca] + b2=spaces[cb]|{u^v for u in spaces[cb]} if y else spaces[cb] + assert a2<=b2 + dn=d+y-x + assert paid or dn>0 + if dn==d: + continue + hist,delta,records=(dp,-1,p) if paid else (dt,1,tg) + hist[d]-=delta + if dn: + hist[dn]+=delta + records.append([t,d,dn]) + l,h = inc[max(d,dn)] + if paid==(dn radius > 0 + vertices = [[(m+s*radius*(i==j),)*2 for i,m in enumerate(center)] + for j in range(9) for s in (-1,1)] + return box,center,radius,vertices + + +def gain(old, new, paid, prices, upper): + if old==new: + return 0 + larger,smaller = max(old,new), min(old,new) + positive = paid == (new=kb + new01 = d+kb if y is not None else None + if x is None: + new11 = None + elif kb and y is None: + new11 = None + else: + new11 = d+kb-ka + assert new11 is None or new11 >= 0 + feasible.append((t,x,y,d,paid,new01,new11)) + return active,feasible + + +def score(edges, prices): + # Sum per-edge available positive changes before imposing shared vertex choices. + return sum(max(0, + gain(d,e1,paid,prices,1) if e1 is not None else 0, + gain(d,e2,paid,prices,1) if e2 is not None and (paid or e2) else 0) + for _,_,_,d,paid,e1,e2 in edges) + + +def optimize(active, edges, prices, upper, solver): + weights = [0]*len(active) + implications=set() + for _,x,y,d,paid,new01,new11 in edges: + only_high=0 + if y is not None: + only_high=gain(d,new01,paid,prices,upper) + weights[y]+=only_high + if x is not None: + if new11 is None or (not paid and new11==0): + implications.add((x,None)) + else: + if y is not None: + implications.add((x,y)) + weights[x]+=gain(d,new11,paid,prices,upper)-only_high + total, selected = solver(weights,implications) + observed=0 + changes=[] + for t,x,y,d,paid,new01,new11 in edges: + new = new11 if x in selected else new01 if y in selected else d + assert new is not None and (paid or new>0) + observed+=gain(d,new,paid,prices,upper) + if d!=new: + changes.append([t,d,new,'paid' if paid else 'target']) + assert observed==total + return total,selected,changes + + +def timed_out(*_): + raise TimeoutError('60-second discovery cap') + + +def main(): + assert __debug__ + signal(SIGALRM,timed_out) + ranked, records, current = [], [], None + witness=None + capped=False + inventory={} + alarm(60) + try: + w,planes=authenticate() + inv=run_path(str(INPUTS/'inventory.py')) + common=run_path(str(INPUTS/'target_closure.py')) + groups,uses,spaces,chart,movable,edges=common['get_inventory'](w,inv) + inventory={'groups':len(groups),'eligible':len(movable), + 'paid_edges':sum(e[-1] for e in edges),'target_edges':sum(not e[-1] for e in edges)} + box,center,radius,vertices=price_tables() + inventory.update({'increment_box':box,'center':center,'radius':radius,'scale':SCALE}) + solver=run_path(str(INPUTS/'closure.py'))['maxclosure'] + ranked=sorted(((score(choices(p,spaces,chart,movable,edges)[1],box),p) for p in planes), + key=lambda row:(-row[0],row[1])) + for value,plane in ranked[:CAP]: + current={'plane':plane,'score':value,'shared_price_upper':[]} + active,case=choices(plane,spaces,chart,movable,edges) + upper,_,_=optimize(active,case,box,1,solver) + current['edgewise_upper']=upper + lower,selected,changes=optimize(active,case,box,0,solver) + current['edgewise_lower']=lower + if lower>0: + witness={'plane':plane,'components':{g:groups[g] for g in (active[i] for i in sorted(selected))}, + 'changed_edges':changes,'raw_lower':str(Fraction(17*lower,SCALE))} + elif upper>0: + for prices in vertices: + result,_,_=optimize(active,case,prices,1,solver) + current['shared_price_upper'].append(result) + current['excluded'] = upper==0 or ( + len(current['shared_price_upper'])==18 and max(current['shared_price_upper'])==0 + ) + records.append(current) + current=None + if witness: + break + except TimeoutError: + capped=True + finally: + alarm(0) + result={'pins':PINS,'benchmark_head':'89eaa9d8cae37c1540de98f2d29a3abaabb96a2b', + 'crossing':CROSSING,'seconds_cap':60,'case_cap':CAP,'inventory':inventory, + 'ranking':ranked,'records':records,'capped':capped,'partial':current,'witness':witness, + 'open_planes':[row['plane'] for row in records if not row['excluded'] and + (witness is None or row['plane'] != witness['plane'])]+ + [plane for _,plane in ranked[len(records):]], + 'untested_planes':[plane for _,plane in ranked[len(records):]], + 'planes_outside_saved_pool':43435-1014} + print(dumps(result,sort_keys=True,indent=2)) + if capped: + raise SystemExit(2) + + +if __name__=='__main__': + main() diff --git a/research/p104-endpoint-common-plane-growth-bound/receipts/INDEPENDENT.json b/research/p104-endpoint-common-plane-growth-bound/receipts/INDEPENDENT.json new file mode 100644 index 0000000000..559f55e4f6 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/receipts/INDEPENDENT.json @@ -0,0 +1,7704 @@ +{ + "capped": false, + "case_cap": 256, + "case_input_sha256": "90992277870eaccfa195004fb31ef323967e6e2125b606ca3e8b4339b6ba00b9", + "controls": 20, + "eligible_groups": 552, + "groups": 1517, + "paid_edges": 2565, + "pins": { + "cut_flow.py": "a16c67f11d216d0a7d7f4caf0b994cc0a1dcbc01d667ed0924691f72f0959cdb", + "endpoint_replay.py": "24d63caf9e647840f47675fecf775803c509f5fbc7ae6fc6b5d450782ec1d81d", + "inputs/7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "inputs/R226-PLANES.json": "68ea271a02374de22edfa105e6033ebc670087d3627798f15bab14c9962479b8", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "reverse_inventory.py": "ac01889cd8e917b5c3f93dcefaa19c159efc18bcdd6973b94b481f08185d0127" + }, + "requested": 256, + "rows": [ + [ + [ + 225, + 371, + 402 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 341, + 417 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 71, + 256, + 327 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 21, + 225, + 244 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 71, + 179, + 244 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 71, + 308, + 371 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 71, + 298, + 365 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 21, + 365, + 376 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 56, + 341, + 365 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 38, + 341, + 371 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 21, + 327, + 338 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 153, + 327, + 478 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 248, + 327, + 447 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 331, + 447 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 376, + 396 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 158, + 371, + 493 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 179, + 371, + 448 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 213, + 327, + 402 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 204, + 371, + 447 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 38, + 210, + 244 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 180, + 327, + 499 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 263, + 499 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 153, + 365, + 500 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 308, + 448 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 106, + 158, + 244 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 56, + 327, + 383 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 210, + 371, + 417 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 255, + 365, + 402 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 56, + 204, + 244 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 210, + 365, + 447 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 11, + 371, + 376 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 128, + 371, + 499 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 230, + 327, + 417 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 115, + 256, + 371 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 256, + 500 + ], + 528, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 281, + 493 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 116, + 128, + 244 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 225, + 365, + 396 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 225, + 327, + 422 + ], + 532, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 298, + 478 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 116, + 307, + 327 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 338, + 422 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 109, + 153, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 173, + 365, + 448 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 89, + 298, + 371 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 116, + 263, + 371 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 129, + 371, + 498 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 11, + 327, + 332 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 106, + 281, + 371 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 158, + 365, + 499 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 56, + 331, + 371 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 89, + 173, + 244 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 135, + 327, + 448 + ], + 537, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 106, + 301, + 327 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 2, + 244, + 246 + ], + 546, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 11, + 244, + 255 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 18, + 327, + 341 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 383, + 395 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 358, + 402 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 185, + 365, + 468 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 173, + 371, + 478 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 33, + 338, + 371 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 128, + 365, + 493 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 38, + 327, + 353 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 203, + 327, + 396 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 153, + 371, + 490 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 255, + 371, + 396 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 33, + 213, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 204, + 365, + 417 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 353, + 405 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 94, + 301, + 371 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 106, + 263, + 365 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 248, + 371, + 395 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 18, + 230, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 33, + 332, + 365 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 213, + 371, + 422 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 24, + 363, + 371 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 185, + 371, + 458 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 288, + 468 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 115, + 308, + 327 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 115, + 135, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 32, + 339, + 371 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 203, + 365, + 422 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 179, + 327, + 500 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 21, + 358, + 371 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 190, + 371, + 461 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 62, + 339, + 365 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 129, + 365, + 492 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 159, + 365, + 498 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 64, + 307, + 371 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 230, + 371, + 405 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 135, + 371, + 500 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 24, + 236, + 244 + ], + 539, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 8, + 327, + 335 + ], + 534, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 313, + 461 + ], + 541, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 12, + 244, + 248 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 170, + 327, + 493 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 210, + 327, + 405 + ], + 532, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 63, + 203, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 181, + 327, + 498 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 116, + 281, + 365 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 94, + 307, + 365 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 12, + 371, + 383 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 204, + 327, + 395 + ], + 532, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 111, + 258, + 365 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 307, + 455 + ], + 528, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 179, + 365, + 478 + ], + 537, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 64, + 180, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 89, + 286, + 327 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 38, + 331, + 365 + ], + 538, + 0, + 242537635153428343000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 63, + 327, + 376 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 18, + 353, + 371 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 158, + 327, + 473 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 301, + 473 + ], + 528, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 63, + 332, + 371 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 230, + 365, + 395 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 87, + 314, + 365 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 10, + 359, + 365 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 111, + 155, + 244 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 182, + 371, + 453 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 107, + 159, + 244 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 318, + 458 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 87, + 272, + 327 + ], + 546, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 1, + 364, + 365 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 272, + 484 + ], + 546, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 180, + 371, + 455 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 94, + 281, + 327 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 89, + 308, + 365 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 248, + 365, + 405 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 47, + 348, + 371 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 117, + 129, + 244 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 129, + 327, + 454 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 18, + 365, + 383 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 103, + 288, + 327 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 109, + 298, + 327 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 246, + 365, + 411 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 6, + 363, + 365 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 157, + 327, + 474 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 181, + 365, + 472 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 159, + 371, + 492 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 285, + 489 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 115, + 286, + 365 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 332, + 440 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 32, + 327, + 359 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 167, + 371, + 468 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 65, + 181, + 244 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 6, + 242, + 244 + ], + 539, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 124, + 136, + 244 + ], + 533, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 333, + 441 + ], + 541, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 160, + 365, + 461 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 175, + 327, + 488 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 64, + 263, + 327 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 17, + 229, + 244 + ], + 532, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 279, + 483 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 171, + 371, + 472 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 174, + 365, + 451 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 132, + 327, + 451 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 20, + 327, + 339 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 159, + 327, + 472 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 378, + 398 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 180, + 365, + 473 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 128, + 327, + 455 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 12, + 327, + 331 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 12, + 353, + 365 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 111, + 296, + 327 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 122, + 279, + 365 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 246, + 327, + 433 + ], + 546, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 17, + 327, + 342 + ], + 534, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 187, + 365, + 470 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 31, + 364, + 371 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 151, + 371, + 484 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 10, + 371, + 377 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 126, + 313, + 327 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 10, + 327, + 333 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 61, + 327, + 378 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 317, + 457 + ], + 546, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 94, + 170, + 244 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 311, + 451 + ], + 534, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 339, + 423 + ], + 541, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 171, + 327, + 492 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 241, + 327, + 438 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 181, + 371, + 454 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 77, + 185, + 244 + ], + 541, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 64, + 301, + 365 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 109, + 256, + 365 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 17, + 365, + 380 + ], + 534, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 88, + 309, + 365 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 136, + 365, + 485 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 227, + 365, + 398 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 95, + 171, + 244 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 190, + 365, + 467 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 5, + 241, + 244 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 63, + 338, + 365 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 144, + 371, + 483 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 377, + 397 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 182, + 327, + 497 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 155, + 371, + 488 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 174, + 327, + 489 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 228, + 327, + 419 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 24, + 365, + 373 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 123, + 316, + 327 + ], + 534, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 314, + 462 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 8, + 244, + 252 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 143, + 365, + 482 + ], + 536, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 302, + 474 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 359, + 403 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 121, + 318, + 327 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 32, + 333, + 365 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 171, + 365, + 454 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 91, + 175, + 244 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 173, + 327, + 490 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 203, + 371, + 440 + ], + 530, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 170, + 371, + 473 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 119, + 260, + 371 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 124, + 315, + 327 + ], + 532, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 2, + 369, + 371 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 33, + 327, + 358 + ], + 531, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 167, + 365, + 458 + ], + 542, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 62, + 333, + 371 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 1, + 370, + 371 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 40, + 220, + 244 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 286, + 490 + ], + 528, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 109, + 286, + 371 + ], + 529, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 123, + 143, + 244 + ], + 534, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 80, + 279, + 327 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 236, + 327, + 427 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 220, + 327, + 411 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 1, + 244, + 245 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 65, + 306, + 371 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 62, + 327, + 377 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 305, + 453 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 79, + 187, + 244 + ], + 533, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 55, + 346, + 365 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 242, + 327, + 437 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 343, + 419 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 177, + 365, + 476 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 91, + 310, + 365 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 186, + 371, + 457 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 11, + 358, + 365 + ], + 538, + 0, + 229020330046211674000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 87, + 292, + 371 + ], + 547, + 0, + 252418392407436172000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 79, + 316, + 371 + ], + 533, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 189, + 371, + 462 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 361, + 413 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 95, + 306, + 365 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 111, + 284, + 371 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 110, + 285, + 371 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 122, + 317, + 327 + ], + 546, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 16, + 228, + 244 + ], + 546, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 238, + 371, + 413 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 346, + 430 + ], + 538, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 349, + 425 + ], + 537, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 244, + 309, + 449 + ], + 535, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 3, + 365, + 366 + ], + 540, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 212, + 365, + 441 + ], + 544, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 175, + 371, + 476 + ], + 547, + 0, + 270018132299731196000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 246, + 371, + 389 + ], + 547, + 0, + 221606976029525046000, + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + ], + "runner_cap_seconds": 60, + "scale": 10000000000000000000000000000000000000000000000000000, + "shared_scale": 20000000000000000000000000000000000000000000000000000, + "target_edges": 193 +} diff --git a/research/p104-endpoint-common-plane-growth-bound/receipts/LEAD.json.gz b/research/p104-endpoint-common-plane-growth-bound/receipts/LEAD.json.gz new file mode 100644 index 0000000000..9a600e847e Binary files /dev/null and b/research/p104-endpoint-common-plane-growth-bound/receipts/LEAD.json.gz differ diff --git a/research/p104-endpoint-common-plane-growth-bound/replay.py b/research/p104-endpoint-common-plane-growth-bound/replay.py new file mode 100644 index 0000000000..e0a941ad92 --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/replay.py @@ -0,0 +1,59 @@ +"""Verify exact forward and independent common-plane receipts.""" +from gzip import decompress +from hashlib import sha256 +from json import loads +from pathlib import Path, PurePosixPath +from subprocess import run +from sys import executable, implementation, version_info + +ROOT = Path(__file__).resolve().parent + + +def unique(pairs): + values = dict(pairs) + assert len(values) == len(pairs), "duplicate JSON key" + return values + + +def read(name): + raw = (ROOT / name).read_bytes() + return loads(decompress(raw) if name.endswith(".gz") else raw, object_pairs_hook=unique) + + +def main(): + assert __debug__ and implementation.name == "cpython" and version_info[:2] == (3, 12) + manifest = read("PINS.json") + files = {f.relative_to(ROOT).as_posix() for folder in ("inputs", "receipts") + for f in (ROOT / folder).iterdir() if f.is_file()} + scripts = {"lead.py", "independent.py", "cut_flow.py", "endpoint_replay.py", "reverse_inventory.py"} + assert set(manifest) == files | scripts | {"PROVENANCE.json"} + for name, digest in manifest.items(): + path = PurePosixPath(name) + assert not path.is_absolute() and ".." not in path.parts + assert sha256((ROOT / path).read_bytes()).hexdigest() == digest, name + + lead_raw = run([executable, "-I", "-B", str(ROOT/"lead.py")], check=True, + capture_output=True, timeout=65).stdout + lead = loads(lead_raw, object_pairs_hook=unique) + expected_lead = read("receipts/LEAD.json.gz") + for result in (lead, expected_lead): + if "SAVED-PLANES.json" in result["pins"]: + result["pins"]["R226-PLANES.json"] = result["pins"].pop("SAVED-PLANES.json") + assert lead == expected_lead + independent_raw = run([executable, "-I", "-B", str(ROOT/"independent.py"), + str(ROOT/"receipts/LEAD.json.gz")], check=True, + capture_output=True, timeout=65).stdout + independent = loads(independent_raw, object_pairs_hook=unique) + assert independent == read("receipts/INDEPENDENT.json") + assert lead["benchmark_head"] == "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b" + assert not lead["capped"] and not independent["capped"] and lead["witness"] is None + assert len(lead["records"]) == len(independent["rows"]) == 256 + assert len(lead["ranking"]) == 1014 and len(lead["open_planes"]) == 758 + assert all(record["excluded"] for record in lead["records"]) + assert all(lower == 0 and (upper == 0 or vertices == [0]*18) + for _, _, lower, upper, vertices in independent["rows"]) + print("PASS_ENDPOINT_PLANE_GROWTH: 256 ranked planes excluded; 758 saved planes untested") + + +if __name__ == "__main__": + main() diff --git a/research/p104-endpoint-common-plane-growth-bound/reverse_inventory.py b/research/p104-endpoint-common-plane-growth-bound/reverse_inventory.py new file mode 100644 index 0000000000..d35e516a9d --- /dev/null +++ b/research/p104-endpoint-common-plane-growth-bound/reverse_inventory.py @@ -0,0 +1,198 @@ +"""Reverse lifetime indexing and BFS for the exact current multi-ADD census.""" +from collections import Counter, defaultdict +from fractions import Fraction +from functools import cache +from gzip import decompress +from hashlib import sha1, sha256 +from itertools import combinations +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import alarm + +ROOT = Path(__file__).resolve().parent +PINS = { + '7334-WORD.json.gz': '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a', + 'pricing.py': 'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', + '7361-REVERSE.json': '917ddb1a1af768333e9e6dd797f4f99704e8160ea9a8210128b9293e0a7166cc', +} + + +def verify_inputs(): + sources = {} + for path, digest in PINS.items(): + data = (ROOT / 'inputs' / path).read_bytes() + assert sha256(data).hexdigest() == digest, path + sources[path] = data + old = sources['7361-REVERSE.json'] + assert sha1(f'blob {len(old)}\0'.encode() + old).hexdigest() == '24889261999bc4dc9f764d5a0dafbc3845ba5351' + word = decompress(sources['7334-WORD.json.gz']) + assert sha256(word).hexdigest() == '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac' + return loads(word), loads(old) + + +def reverse_trace(w): + tape, n = w['program'], w['public'] + cursor = {r: (r, len(tape)) for r in range(n)} + frames = {cursor[r]: c for r, c in enumerate(w['final'])} + fixed = set(cursor.values()) + adj, contacts, transport = defaultdict(set), defaultdict(set), defaultdict(set) + for t in range(len(tape) - 1, -1, -1): + op, r, *payload = tape[t] + if op == 'CLEAR': + assert r >= n and r not in cursor + cursor[r] = r, t + frames[cursor[r]] = payload[0] + continue + outgoing = cursor[r] + if op == 'INIT': + assert r >= n and frames[outgoing] == payload[0] + del cursor[r] + elif op == 'MOVE': + lo, hi, owned = payload + assert frames[outgoing] == hi and owned == (r >= n) + incoming = r, t + frames[incoming] = lo + cursor[r] = incoming + transport[incoming].add((t, hi, 'source')) + transport[outgoing].add((t, lo, 'target')) + elif op in ('ADD', 'COPY'): + s, _, chart = payload + other = cursor[s] + assert r != s and frames[other] == frames[outgoing] == chart + adj[outgoing].add(other) + adj[other].add(outgoing) + contacts[outgoing].add((t, op)) + contacts[other].add((t, op)) + else: + assert op == 'SCALE' and frames[outgoing] == payload[1] + contacts[outgoing].add((t, op)) + assert sorted(cursor) == list(range(n)) + assert [frames[cursor[r]] for r in range(n)] == w['initial'] + fixed.update(cursor.values()) + return frames, fixed, adj, contacts, transport + + +def components(adj): + seen = set() + for vertex in sorted(adj): + if vertex in seen: + continue + group, stack = {vertex}, [vertex] + while stack: + node = stack.pop() + new = adj[node] - group + stack.extend(new) + group.update(new) + seen.update(group) + yield group + + +def frame_space(basis): + points = {0} + for size in range(1, len(basis) + 1): + for terms in combinations(basis, size): + v = 0 + for term in terms: + v ^= term + points.add(v) + assert len(points) == 1 << len(basis) + return points + + +def solve(w, inherited): + n = w['public'] + main = set(w['live']) | {i + 112 for i in w['live']} | set(w['hosted']['X2']) | set(w['hosted']['Y2']) + assert len(main) == 400 and n == 1501 and len(w['program']) == 76466 + frames, fixed, adj, contacts, transport = reverse_trace(w) + spaces = [frame_space(f) for f in w['frames']] + ranks = [len(f) for f in w['frames']] + tariff = run_path(str(ROOT / 'inputs' / 'pricing.py'))['power_bounds'] + k0 = Fraction('0.00364665195644044790699554028334161') + k1 = Fraction('0.00364665195644044790699554028334162') + lower = [Fraction(0)] + [tariff(r, k1)[0] for r in range(1, 10)] + upper = [Fraction(0)] + [tariff(r, k0)[1] for r in range(1, 10)] + + @cache + def priced(deltas): + lo = sum((lower[r] if c > 0 else upper[r]) * c for r, c in deltas) + hi = sum((upper[r] if c > 0 else lower[r]) * c for r, c in deltas) + return str(17 * lo), str(17 * hi) + + counts, rows = Counter(), [] + for group in components(adj): + events = sorted(set().union(*(contacts[s] for s in group))) + if sum(tag == 'ADD' for _, tag in events) < 2: + continue + counts['multi_add'] += 1 + if any(r in main or r >= n for r, _ in group): + counts['main_or_owned'] += 1 + continue + if group & fixed: + counts['fixed_endpoint'] += 1 + continue + counts['closed_pure'] += 1 + chart, = {frames[s] for s in group} + edges = sorted(set().union(*(transport[s] for s in group))) + assert edges and len(edges) == len({t for t, _, _ in edges}) + incoming = [c for _, c, side in edges if side == 'target'] + outgoing = [c for _, c, side in edges if side == 'source'] + assert len(incoming) == len(outgoing) == len(group) + lo = max(ranks[c] + 1 for c in incoming) + hi = min(ranks[c] - 1 for c in outgoing) + low_space, high_space = {0}, set(range(512)) + for c in incoming: + low_space = {a ^ b for a in low_space for b in spaces[c]} + for c in outgoing: + high_space &= spaces[c] + d = ranks[chart] + assert low_space <= spaces[chart] <= high_space and lo <= d <= hi + first = max(lo, len(low_space).bit_length() - 1) + last = min(hi, len(high_space).bit_length() - 1) + assert first <= d <= last + old = Counter([d - ranks[c] for c in incoming] + [ranks[c] - d for c in outgoing]) + + def endpoints(a, b): + out = [] + for rank in sorted({a, b}): + terms = old.copy() + terms.subtract([rank - ranks[c] for c in incoming]) + terms.subtract([ranks[c] - rank for c in outgoing]) + quote = priced(tuple(sorted((r, c) for r, c in terms.items() if c))) + if Fraction(quote[1]) > 0: + out.append((rank, quote)) + return out + + relaxed = endpoints(lo, hi) + if not relaxed: + counts['dimension_nonpositive'] += 1 + continue + possible = endpoints(first, last) + counts['geometry_survivor' if possible else 'geometry_exclusion'] += 1 + rows.append({'first_contact': events[0][0], 'old_chart': chart, 'old_rank': d, + 'roles': sorted({r for r, _ in group}), 'contacts': events, 'moves': edges, + 'relaxed_ranks': [lo, hi], 'feasible_ranks': [first, last], + 'price_positive_relaxed': relaxed, 'price_positive_feasible': possible, + 'lower_span': sorted(low_space), 'upper_span': sorted(high_space)}) + rows.sort(key=lambda r: r['first_contact']) + rebind = {(r['key'][0], min(r['clock_map'][x] for x in r['signed_ancestor_ADDs'])) for r in inherited['outcomes']} + actual = {(r['old_chart'], min(t for t, tag in r['contacts'] if tag == 'ADD')) for r in rows} + assert len(rebind) == 13 and actual - rebind == {(746, 40834)} and rebind <= actual + changed, = (r for r in rows if r['old_chart'] == 746) + assert [t for t, tag in changed['contacts'] if tag == 'ADD'] == [40834, 41179] + assert changed['relaxed_ranks'] == [4, 6] and changed['feasible_ranks'] == [5, 6] + assert not changed['price_positive_feasible'] + return {'counts': counts, 'cases': rows, 'exact_prior_7361_keys': sorted(rebind), + 'exact_prior_7369_key': [746, 40834], 'new_price_positive_keys': [], 'runner_cap_seconds': 40} + + +def main(): + assert __debug__ + alarm(40) + result = solve(*verify_inputs()) + alarm(0) + print(dumps(result, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main()