From e309e17f83f5759b1ea1fa24a76f24838784cb4d Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Tue, 13 Oct 2026 12:03:08 -0500 Subject: [PATCH] Add R438 bit source boundary with full hosted invoice --- .../bit-boundary-persistence/CERTIFICATE.json | 2052 +++++++++++++++++ .../bit-boundary-persistence/FRAME-PATHS.json | 1327 +++++++++++ research/bit-boundary-persistence/NOTICE.md | 28 + research/bit-boundary-persistence/PROOF.md | 185 ++ research/bit-boundary-persistence/README.md | 127 + .../bit-boundary-persistence/SOURCES.json | 177 ++ research/bit-boundary-persistence/build.py | 201 ++ research/bit-boundary-persistence/pipeline.py | 200 ++ research/bit-boundary-persistence/verify.py | 206 ++ 9 files changed, 4503 insertions(+) create mode 100644 research/bit-boundary-persistence/CERTIFICATE.json create mode 100644 research/bit-boundary-persistence/FRAME-PATHS.json create mode 100644 research/bit-boundary-persistence/NOTICE.md create mode 100644 research/bit-boundary-persistence/PROOF.md create mode 100644 research/bit-boundary-persistence/README.md create mode 100644 research/bit-boundary-persistence/SOURCES.json create mode 100644 research/bit-boundary-persistence/build.py create mode 100644 research/bit-boundary-persistence/pipeline.py create mode 100644 research/bit-boundary-persistence/verify.py diff --git a/research/bit-boundary-persistence/CERTIFICATE.json b/research/bit-boundary-persistence/CERTIFICATE.json new file mode 100644 index 0000000000..5640092005 --- /dev/null +++ b/research/bit-boundary-persistence/CERTIFICATE.json @@ -0,0 +1,2052 @@ +{ + "base_commit": "8bddbee377e2f3ce1f1247196c4b290d55767d20", + "boundary": { + "all_paths_sha256": "a030398460debf9b3da94457f0039d9797f374a7baf375f439edaf035b924847", + "before": { + "444": 0, + "77": 186 + }, + "birth": 230, + "changed_surviving_paths": { + "444": [ + [ + 0, + 79, + 509, + 392, + 513, + 1 + ], + [ + 0, + 186, + 509, + 392, + 513, + 1 + ] + ] + }, + "frames": { + "186": { + "lines": [ + 33, + 77 + ], + "rank": 2 + }, + "509": { + "lines": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92 + ], + "rank": 4 + }, + "79": { + "lines": [ + 77 + ], + "rank": 1 + } + }, + "helper": 470, + "new_frame": 186, + "next_frame": { + "444": 509, + "77": 186 + }, + "read": 1993, + "receiver": 444, + "removed_path": [ + 0, + 79, + 1 + ], + "retained_copy_uses": 0, + "source": 77, + "source_path": [ + 79, + 186, + 509, + 386, + 560, + 1 + ], + "source_unchanged": true + }, + "controls": { + "accepted_paid_neutral_pair": { + "extra_adds": 2, + "same_profile": true + }, + "rejected": [ + { + "name": "source77_changed_before_read", + "rejection": "Source changed before the late read" + }, + { + "name": "another_live_carrier_use", + "rejection": "Carrier has another live use" + }, + { + "name": "late_source_read_in_old_line_frame", + "rejection": "Frame descent" + }, + { + "name": "omitted_literal_restoration", + "rejection": "Wrong arbitrary-dirty endpoint" + }, + { + "name": "omitted_dirty_target_compensation", + "rejection": "Wrong arbitrary-dirty endpoint" + }, + { + "name": "deleted_helper_without_returned_idle_charge", + "rejection": "Wrong hosted rank mass" + } + ] + }, + "hosted": { + "baseline": { + "audit": { + "bank_assignments": 0, + "deficit": 10272, + "emitted_events": 7843392, + "emitted_program_sha256": "96c7ad2e744e9a503a4ef5ecd52d0f6a8899bdb5efac2e3aafa0db18adf99523", + "hosted_residuals": 126432, + "live": 28416, + "maxchild": 42, + "mutations_rejected": [ + "slot outside window", + "copy index outside family", + "negative slot offset", + "wrong residual width", + "duplicate helper", + "omitted helper", + "hosted owner in another replica or outside the data stock", + "hosted owner on a wrong data family", + "wrong call orientation", + "duplicate call", + "changed idle rank", + "understated live stock", + "missing remainder summary", + "stale stage count", + "hosted coordinate beyond the pending set", + "overlapping hosted coordinates" + ], + "physical": 28425, + "profile": { + "1": 381024, + "2": 400416, + "3": 22752, + "4": 26880, + "42": 288, + "5": 29376, + "6": 17376, + "7": 26784 + }, + "rank_mass": 1808352, + "status": "PASS_INDEPENDENT_REPLICATED_HOSTING_AUDIT" + }, + "invoice": { + "R": 439, + "bit": { + "bank_assignments": 0, + "charged_prefix_bits": 192, + "charged_two_level_coefficient_bits": 512, + "coefficient_bits": 177, + "halving_depth": 2, + "hosted_residuals": 126432, + "live": 28416, + "maxchild": 42, + "physical": 28425, + "prefix_bits": 177, + "rank_mass": 1808352, + "row_coefficient": 18355, + "two_level_coefficient_bits": 393 + }, + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "bit_lower_decimal": "0.001733427039589844234749", + "bit_profile": { + "1": 381024, + "2": 400416, + "3": 22752, + "4": 26880, + "42": 288, + "5": 29376, + "6": 17376, + "7": 26784 + }, + "emitted_program_sha256": "96c7ad2e744e9a503a4ef5ecd52d0f6a8899bdb5efac2e3aafa0db18adf99523", + "next_grid_point_rejected": "6933708158359376939/4000000000000000000000", + "replicas": 32, + "stages": 9, + "status": "PASS_NINE_STAGE_WHOLE_HOSTED_BIT_PRICE_AND_CITED_ASSEMBLY" + }, + "parent": { + "all_scalar_columns_restored": true, + "bridge_additions": 63936, + "copy_erase_episodes": 2592, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "independent_unbanked_scalar_columns": 4839, + "local_checks": { + "forward": { + "adds": 24305, + "all_columns": 661, + "cancellation_free_row_l1": 49347, + "copies": 9, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "records": 27234, + "sha256": "a778a0300bbf4b07908ee24c0d271426ba6c70568e788af2f0ac8517897cb5b4" + }, + "reverse": { + "adds": 24305, + "all_columns": 661, + "cancellation_free_row_l1": 1113070, + "copies": 9, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "records": 27234, + "sha256": "98d97804744d691548b4d54868a8a0e5f500c55ab32ac4be96f3ba30e6f5bef8" + } + }, + "local_invocations": 288, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "scalar_stages": [ + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 0 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 1 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 2 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 3 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 4 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 5 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 6 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": true, + "stage": 7 + }, + { + "all_columns": 4839, + "helper_columns": 3951, + "reverse": false, + "stage": 8 + } + ] + }, + "parent_controls": [ + "omit an idle child", + "omit a bridge", + "omit terminal exchange", + "remove a local invocation", + "understate live stock", + "omit a local paid move", + "wrong reflected copy charge", + "alter residual orthogonal basis", + "misstate replication count", + "misstate stage count", + "alias data across stages", + "delay an idle advance past its level", + "truncate the last idle advance", + "re-use a helper bank slot", + "wrong residual frame", + "alias data across replica groups", + "omit the fourth replica group" + ] + }, + "candidate": { + "audit": { + "bank_assignments": 0, + "deficit": 10272, + "emitted_events": 7826400, + "emitted_program_sha256": "aa12307186ffceae745cb149810a8f69de1bb16a06d71785c7172864d68db607", + "hosted_residuals": 126144, + "live": 28416, + "maxchild": 42, + "mutations_rejected": [ + "slot outside window", + "copy index outside family", + "negative slot offset", + "wrong residual width", + "duplicate helper", + "omitted helper", + "hosted owner in another replica or outside the data stock", + "hosted owner on a wrong data family", + "wrong call orientation", + "duplicate call", + "changed idle rank", + "understated live stock", + "missing remainder summary", + "stale stage count", + "hosted coordinate beyond the pending set", + "overlapping hosted coordinates" + ], + "physical": 28425, + "profile": { + "1": 380448, + "10": 160, + "12": 96, + "14": 32, + "2": 400832, + "3": 22464, + "4": 26784, + "42": 288, + "5": 29376, + "6": 17344, + "7": 26496 + }, + "rank_mass": 1808352, + "status": "PASS_INDEPENDENT_REPLICATED_HOSTING_AUDIT" + }, + "invoice": { + "R": 438, + "bit": { + "bank_assignments": 0, + "charged_prefix_bits": 192, + "charged_two_level_coefficient_bits": 512, + "coefficient_bits": 177, + "halving_depth": 2, + "hosted_residuals": 126144, + "live": 28416, + "maxchild": 42, + "physical": 28425, + "prefix_bits": 177, + "rank_mass": 1808352, + "row_coefficient": 18355, + "two_level_coefficient_bits": 393 + }, + "bit_lower": "433544072119966441673/250000000000000000000000", + "bit_lower_decimal": "0.001734176288479865766692", + "bit_profile": { + "1": 380448, + "10": 160, + "12": 96, + "14": 32, + "2": 400832, + "3": 22464, + "4": 26784, + "42": 288, + "5": 29376, + "6": 17344, + "7": 26496 + }, + "emitted_program_sha256": "aa12307186ffceae745cb149810a8f69de1bb16a06d71785c7172864d68db607", + "next_grid_point_rejected": "1734176288479865766693/1000000000000000000000000", + "replicas": 32, + "stages": 9, + "status": "PASS_NINE_STAGE_WHOLE_HOSTED_BIT_PRICE_AND_CITED_ASSEMBLY" + }, + "parent": { + "all_scalar_columns_restored": true, + "bridge_additions": 63936, + "copy_erase_episodes": 2592, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "independent_unbanked_scalar_columns": 4830, + "local_checks": { + "forward": { + "adds": 24248, + "all_columns": 660, + "cancellation_free_row_l1": 49347, + "copies": 9, + "profile": { + "1": 1321, + "2": 1344, + "3": 78, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "records": 27175, + "sha256": "bea1cc10547012bc2586c1e0eefa93efaad944b9b081753dcb7946765433df56" + }, + "reverse": { + "adds": 24248, + "all_columns": 660, + "cancellation_free_row_l1": 1113070, + "copies": 9, + "profile": { + "1": 1321, + "2": 1344, + "3": 78, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "records": 27175, + "sha256": "72d6999a278773914dfd3d8140d91681bb109b3c34425f333a9f02ee12b74266" + } + }, + "local_invocations": 288, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "scalar_stages": [ + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 0 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 1 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 2 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 3 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 4 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 5 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 6 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": true, + "stage": 7 + }, + { + "all_columns": 4830, + "helper_columns": 3942, + "reverse": false, + "stage": 8 + } + ] + }, + "parent_controls": [ + "omit an idle child", + "omit a bridge", + "omit terminal exchange", + "remove a local invocation", + "understate live stock", + "omit a local paid move", + "wrong reflected copy charge", + "alter residual orthogonal basis", + "misstate replication count", + "misstate stage count", + "alias data across stages", + "delay an idle advance past its level", + "truncate the last idle advance", + "re-use a helper bank slot", + "wrong residual frame", + "alias data across replica groups", + "omit the fourth replica group" + ] + } + }, + "hosting_change": { + "hosted_helpers_per_replica": 3942, + "new_remainders": { + "10": 5, + "12": 3, + "14": 1, + "2": 430, + "4": 441, + "42": 9, + "6": 443, + "7": 666 + }, + "old_remainders": { + "2": 435, + "4": 444, + "42": 9, + "6": 444, + "7": 666 + }, + "removed_slots": [ + [ + 2, + 82, + 16, + 8, + 0, + 248 + ], + [ + 2, + 155, + 0, + 8, + 1, + 248 + ], + [ + 4, + 47, + 24, + 8, + 2, + 248 + ], + [ + 4, + 135, + 16, + 8, + 4, + 248 + ], + [ + 4, + 185, + 32, + 8, + 5, + 248 + ], + [ + 6, + 49, + 24, + 8, + 3, + 248 + ], + [ + 6, + 174, + 32, + 8, + 7, + 248 + ], + [ + 7, + 86, + 0, + 8, + 6, + 248 + ], + [ + 8, + 31, + 0, + 8, + 8, + 248 + ] + ], + "returned_idle_rank_per_replica": 72 + }, + "local": { + "baseline": { + "adds": 24305, + "copies": 9, + "forward_bound": 49347, + "helpers": 439, + "local_bits": 93, + "nine_stage_bits": 177, + "profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "rank_mass": 5129, + "records": 27234, + "registers": 661, + "reverse_bound": 1113070, + "word_sha256": "5642fd0e35a1acc11acff8d0c08350c1617e95f310d4d35ad63a651f9eeeba0b" + }, + "candidate": { + "adds": 24248, + "copies": 9, + "forward_bound": 49347, + "helpers": 438, + "local_bits": 93, + "nine_stage_bits": 177, + "profile": { + "1": 1321, + "2": 1344, + "3": 78, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "rank_mass": 5121, + "records": 27175, + "registers": 660, + "reverse_bound": 1113070, + "word_sha256": "27609b6880f8913900c0e1758c63a482f8588c16fede1bd0071c6df36ef2e285" + } + }, + "native": { + "baseline": { + "columns": { + "11": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1549, + "fresh_center_copies": 99, + "global_live_registers": 1549, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 267355, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "5": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121525, + "formal_columns_checked": 883, + "fresh_center_copies": 45, + "global_live_registers": 883, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "9": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1327, + "fresh_center_copies": 81, + "global_live_registers": 1327, + "independent_dirty_registers": 439, + "local_odd_scalar_additions": 24305, + "local_raw_H": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "local_registers": 661, + "local_scalar_additions": 24305, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218745, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24305, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "interface": { + "columns": 661, + "conclusion": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copy_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "gates": { + "A": 2075, + "B": 712, + "C": 2574, + "D": 111 + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "interleaving": { + "B_target_reads_of_registers_rewritten_earlier_in_B": 111, + "B_z_operand_kinds": { + "helper<-helper": 3, + "helper<-source": 13, + "source<-helper": 108, + "source<-source": 375 + }, + "B_z_operand_kinds_by_dim": { + "dim4:helper<-source": 13, + "dim4:source<-source": 375, + "dim6:helper<-helper": 3, + "dim6:source<-helper": 108 + }, + "B_z_write_frame_dims": { + "4": 388, + "6": 111 + }, + "B_z_writes_after_a_target_read_of_the_same_register": 454, + "cleanup_gates": 2574, + "helper_writes_B": 16, + "source_writes_A": 0, + "source_writes_B": 483, + "sources_rewritten_B": 108, + "target_reads_of_targets": 0, + "z_gates_A": 2075, + "z_gates_B": 499 + }, + "punctured": 9, + "status": "PASS_EXACT_REPLAY_AND_INTERLEAVED_INTERFACE", + "totals_on_punctured_hyperplanes": true, + "v": 111 + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24305, + "containment_pairs_checked": 2386, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2911, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1323 + ], + [ + 2, + 1342 + ], + [ + 3, + 79 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 19 + ] + ], + "rank_mass": 5129, + "records": 27234, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + }, + "candidate": { + "columns": { + "11": { + "bridge_additions": 2664, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1548, + "fresh_center_copies": 99, + "global_live_registers": 1548, + "independent_dirty_registers": 438, + "local_odd_scalar_additions": 24248, + "local_raw_H": [ + [ + 1, + 1321 + ], + [ + 2, + 1344 + ], + [ + 3, + 78 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "local_registers": 660, + "local_scalar_additions": 24248, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 266728, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "5": { + "bridge_additions": 666, + "copied_center_original_source_immutable": true, + "five_stage_additions": 121240, + "formal_columns_checked": 882, + "fresh_center_copies": 45, + "global_live_registers": 882, + "independent_dirty_registers": 438, + "local_odd_scalar_additions": 24248, + "local_raw_H": [ + [ + 1, + 1321 + ], + [ + 2, + 1344 + ], + [ + 3, + 78 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "local_registers": 660, + "local_scalar_additions": 24248, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "9": { + "bridge_additions": 1998, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1326, + "fresh_center_copies": 81, + "global_live_registers": 1326, + "independent_dirty_registers": 438, + "local_odd_scalar_additions": 24248, + "local_raw_H": [ + [ + 1, + 1321 + ], + [ + 2, + 1344 + ], + [ + 3, + 78 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "local_registers": 660, + "local_scalar_additions": 24248, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 93, + "payload_prefix_upper": "9528119495320518471870892800", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 16, + "cancellation_free_signed_row_l1_upper": "49347", + "reverse": false + }, + { + "bits": 21, + "cancellation_free_signed_row_l1_upper": "1113070", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 218232, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 24248, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + } + }, + "interface": { + "columns": 660, + "conclusion": { + "C_is_U_inverse": true, + "J_identity": true, + "K_equals_D": true, + "U_block_form": true + }, + "copy_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "gates": { + "A": 2074, + "B": 712, + "C": 2573, + "D": 111 + }, + "hypotheses": { + "H1_no_target_feeds_z": true, + "H2_D_frame0_targets_from_helpers": true, + "H3_A_z_only_scatter_targets_B_split": true, + "H4_C_literal_reverse_at_full": true, + "H5_V_identity": true + }, + "interleaving": { + "B_target_reads_of_registers_rewritten_earlier_in_B": 111, + "B_z_operand_kinds": { + "helper<-helper": 3, + "helper<-source": 13, + "source<-helper": 108, + "source<-source": 375 + }, + "B_z_operand_kinds_by_dim": { + "dim4:helper<-source": 13, + "dim4:source<-source": 375, + "dim6:helper<-helper": 3, + "dim6:source<-helper": 108 + }, + "B_z_write_frame_dims": { + "4": 388, + "6": 111 + }, + "B_z_writes_after_a_target_read_of_the_same_register": 454, + "cleanup_gates": 2573, + "helper_writes_B": 16, + "source_writes_A": 0, + "source_writes_B": 483, + "sources_rewritten_B": 108, + "target_reads_of_targets": 0, + "z_gates_A": 2074, + "z_gates_B": 499 + }, + "punctured": 9, + "status": "PASS_EXACT_REPLAY_AND_INTERLEAVED_INTERFACE", + "totals_on_punctured_hyperplanes": true, + "v": 111 + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 24248, + "containment_pairs_checked": 2384, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2909, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 635, + "paid_histogram": [ + [ + 1, + 1321 + ], + [ + 2, + 1344 + ], + [ + 3, + 78 + ], + [ + 4, + 44 + ], + [ + 5, + 102 + ], + [ + 6, + 11 + ], + [ + 7, + 18 + ] + ], + "rank_mass": 5121, + "records": 27175, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + } + }, + "no_new_kappa": true, + "paid_recount": { + "paid_calls": { + "baseline": 904896, + "candidate": 904320 + }, + "returned_idle_rank": 2304, + "saved_calls": 576 + }, + "selected_context": { + "binding": "complex", + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "complex_lower": "416181814685169713943/250000000000000000000000", + "kappa": "1661960547713947/1000000000000000000" + }, + "status": "PASS_R438_SOURCE_BOUNDARY_AND_FULL_HOSTED_INVOICE" +} diff --git a/research/bit-boundary-persistence/FRAME-PATHS.json b/research/bit-boundary-persistence/FRAME-PATHS.json new file mode 100644 index 0000000000..b1862b43e1 --- /dev/null +++ b/research/bit-boundary-persistence/FRAME-PATHS.json @@ -0,0 +1,1327 @@ +{ + "baseline": [ + [2, 507, 326, 531, 1], + [3, 212, 522, 472, 634, 1], + [4, 231, 523, 452, 532, 1], + [5, 127, 507, 337, 579, 1], + [6, 230, 523, 457, 633, 1], + [7, 114, 506, 344, 528, 1], + [8, 113, 506, 1], + [9, 215, 522, 473, 628, 1], + [10, 249, 524, 436, 632, 1], + [11, 506, 345, 525, 1], + [12, 195, 521, 493, 635, 1], + [13, 126, 507, 338, 572, 1], + [14, 252, 524, 442, 610, 1], + [15, 194, 521, 503, 598, 1], + [16, 236, 523, 468, 625, 1], + [17, 134, 519, 413, 580, 1], + [18, 243, 523, 462, 554, 1], + [19, 183, 509, 395, 582, 1], + [20, 242, 523, 460, 626, 1], + [21, 152, 508, 1], + [22, 240, 523, 453, 631, 1], + [23, 165, 520, 363, 540, 1], + [24, 182, 509, 1], + [25, 137, 519, 398, 551, 1], + [26, 220, 522, 487, 613, 1], + [27, 226, 522, 474, 529, 1], + [28, 168, 520, 373, 600, 1], + [29, 156, 508, 425, 563, 1], + [30, 224, 522, 482, 543, 1], + [31, 222, 522, 479, 615, 1], + [32, 140, 519, 415, 589, 1], + [33, 256, 524, 434, 535, 1], + [34, 202, 521, 504, 570, 1], + [35, 185, 509, 383, 614, 1], + [36, 204, 521, 488, 533, 1], + [37, 159, 508, 419, 547, 1], + [38, 172, 520, 369, 555, 1], + [39, 254, 524, 450, 604, 1], + [40, 188, 509, 389, 568, 1], + [41, 207, 521, 492, 537, 1], + [42, 260, 524, 435, 629, 1], + [43, 143, 519, 404, 569, 1], + [44, 206, 521, 496, 556, 1], + [45, 158, 508, 422, 558, 1], + [46, 170, 520, 370, 607, 1], + [47, 263, 524, 440, 557, 1], + [48, 506, 354, 587, 1], + [49, 121, 506, 356, 586, 1], + [50, 119, 506, 347, 536, 1], + [51, 146, 519, 405, 561, 1], + [52, 509, 397, 590, 1], + [53, 178, 520, 375, 574, 1], + [54, 120, 506, 358, 593, 1], + [55, 149, 519, 414, 596, 1], + [56, 506, 355, 597, 1], + [57, 179, 520, 365, 616, 1], + [58, 118, 506, 353, 594, 1], + [59, 161, 508, 430, 592, 1], + [60, 124, 506, 360, 588, 1], + [61, 147, 519, 402, 627, 1], + [62, 509, 396, 591, 1], + [63, 507, 343, 583, 1], + [64, 129, 507, 327, 530, 1], + [65, 131, 507, 342, 573, 1], + [66, 181, 520, 379, 584, 1], + [67, 508, 433, 585, 1], + [68, 508, 417, 617, 1], + [69, 192, 509, 387, 599, 1], + [70, 133, 507, 334, 581, 1], + [71, 128, 507, 329, 534, 1], + [72, 150, 519, 409, 609, 1], + [73, 180, 520, 377, 578, 1], + [74, 507, 333, 571, 1], + [75, 265, 524, 437, 538, 1], + [76, 160, 508, 423, 602, 1], + [77, 145, 519, 407, 605, 1], + [78, 209, 521, 494, 562, 1], + [79, 186, 509, 386, 560, 1], + [80, 264, 524, 446, 567, 1], + [81, 211, 521, 500, 565, 1], + [82, 173, 520, 366, 621, 1], + [83, 257, 524, 448, 564, 1], + [84, 144, 519, 410, 576, 1], + [85, 201, 521, 498, 611, 1], + [86, 174, 520, 378, 595, 1], + [87, 205, 521, 502, 603, 1], + [88, 259, 524, 443, 559, 1], + [89, 189, 509, 384, 552, 1], + [90, 247, 523, 463, 624, 1], + [91, 155, 508, 429, 575, 1], + [92, 239, 523, 467, 623, 1], + [93, 135, 519, 400, 546, 1], + [94, 184, 509, 381, 544, 1], + [95, 246, 523, 454, 526, 1], + [96, 167, 520, 362, 548, 1], + [97, 241, 523, 466, 550, 1], + [98, 139, 519, 403, 619, 1], + [99, 154, 508, 416, 542, 1], + [100, 229, 522, 480, 620, 1], + [101, 219, 522, 471, 527, 1], + [102, 228, 522, 476, 545, 1], + [103, 223, 522, 484, 541, 1], + [104, 166, 520, 368, 566, 1], + [105, 233, 523, 464, 553, 1], + [106, 199, 521, 489, 630, 1], + [107, 251, 524, 451, 601, 1], + [108, 217, 522, 477, 539, 1], + [109, 198, 521, 495, 606, 1], + [110, 214, 522, 486, 618, 1], + [111, 235, 523, 459, 549, 1], + [112, 250, 524, 445, 608, 1], + [0, 127, 525], + [0, 217, 526], + [0, 233, 527], + [0, 528], + [0, 235, 529], + [0, 11, 530], + [0, 114, 531], + [0, 214, 532], + [0, 252, 533], + [0, 534], + [0, 198, 535], + [0, 2, 536], + [0, 249, 537], + [0, 199, 538], + [0, 239, 539], + [0, 139, 540], + [0, 246, 541], + [0, 184, 542], + [0, 247, 543], + [0, 155, 544], + [0, 241, 545], + [0, 168, 546], + [0, 547], + [0, 135, 548], + [0, 222, 549], + [0, 229, 550], + [0, 165, 551], + [0, 154, 552], + [0, 226, 553], + [0, 223, 554], + [0, 143, 555], + [0, 257, 556], + [0, 205, 557], + [0, 188, 558], + [0, 202, 559], + [0, 160, 560], + [0, 173, 561], + [0, 259, 562], + [0, 186, 563], + [0, 211, 564], + [0, 263, 565], + [0, 145, 566], + [0, 207, 567], + [0, 159, 568], + [0, 172, 569], + [0, 265, 570], + [0, 571], + [0, 124, 572], + [0, 121, 573], + [0, 149, 574], + [0, 62, 575], + [0, 181, 576], + [0, 119, 577], + [0, 147, 578], + [0, 48, 579], + [0, 178, 580], + [0, 56, 581], + [0, 67, 582], + [0, 120, 583], + [0, 150, 584], + [0, 585], + [0, 586], + [0, 74, 587], + [0, 63, 588], + [0, 180, 589], + [0, 68, 590], + [0, 591], + [0, 52, 592], + [0, 131, 593], + [0, 129, 594], + [0, 146, 595], + [0, 179, 596], + [0, 597], + [0, 264, 598], + [0, 599], + [0, 144, 600], + [0, 206, 601], + [0, 189, 602], + [0, 260, 603], + [0, 209, 604], + [0, 174, 605], + [0, 256, 606], + [0, 140, 607], + [0, 204, 608], + [0, 170, 609], + [0, 201, 610], + [0, 254, 611], + [0, 185, 612], + [0, 242, 613], + [0, 156, 614], + [0, 240, 615], + [0, 134, 616], + [0, 182, 617], + [0, 243, 618], + [0, 166, 619], + [0, 236, 620], + [0, 137, 621], + [0, 152, 622], + [0, 228, 623], + [0, 220, 624], + [0, 224, 625], + [0, 219, 626], + [0, 167, 627], + [0, 230, 628], + [0, 194, 629], + [0, 250, 630], + [0, 212, 631], + [0, 195, 632], + [0, 215, 633], + [0, 231, 634], + [0, 251, 635], + [0, 2, 125, 267, 374, 578, 1], + [0, 2, 126, 268, 348, 528, 1], + [0, 3, 213, 288, 474, 1], + [0, 3, 214, 300, 396, 582, 1], + [0, 4, 230, 266, 475, 634, 1], + [0, 4, 232, 456, 633, 1], + [0, 5, 125, 507, 330, 531, 1], + [0, 5, 336, 581, 1], + [0, 6, 233, 290, 472, 1], + [0, 6, 234, 278, 471, 1], + [0, 7, 113, 276, 379, 595, 1], + [0, 7, 506, 352, 515, 1], + [0, 8, 115, 270, 328, 530, 1], + [0, 8, 268, 327, 534, 1], + [0, 9, 212, 266, 457, 631, 1], + [0, 9, 216, 483, 541, 1], + [0, 10, 248, 266, 493, 630, 1], + [0, 10, 250, 289, 491, 1], + [0, 11, 114, 274, 330, 510, 1], + [0, 11, 115, 506, 361, 516, 1], + [0, 7, 272, 347, 1], + [0, 11, 266, 344, 525, 1], + [0, 12, 194, 266, 439, 632, 1], + [0, 12, 196, 497, 562, 1], + [0, 13, 127, 271, 346, 525, 1], + [0, 13, 266, 326, 530, 1], + [0, 14, 248, 444, 610, 1], + [0, 14, 251, 279, 436, 1], + [0, 15, 197, 505, 598, 1], + [0, 15, 198, 291, 377, 584, 1], + [0, 2, 270, 367, 616, 1], + [0, 5, 269, 368, 555, 1], + [0, 16, 237, 465, 550, 1], + [0, 16, 238, 294, 466, 625, 1], + [0, 17, 135, 282, 334, 571, 1], + [0, 17, 136, 399, 546, 1], + [0, 18, 242, 268, 487, 618, 1], + [0, 18, 244, 461, 624, 1], + [0, 19, 182, 268, 463, 626, 1], + [0, 19, 280, 408, 1], + [0, 20, 245, 299, 484, 618, 1], + [0, 20, 246, 281, 483, 613, 1], + [0, 21, 153, 293, 360, 1], + [0, 21, 154, 287, 372, 1], + [0, 22, 236, 270, 469, 625, 1], + [0, 22, 239, 297, 478, 539, 1], + [0, 23, 164, 270, 403, 627, 1], + [0, 23, 166, 295, 401, 1], + [0, 24, 184, 287, 418, 1], + [0, 24, 509, 382, 544, 1], + [0, 25, 134, 270, 347, 528, 1], + [0, 25, 138, 401, 551, 1], + [0, 26, 218, 268, 385, 614, 1], + [0, 26, 219, 281, 462, 626, 1], + [0, 27, 224, 270, 481, 620, 1], + [0, 27, 225, 475, 628, 1], + [0, 28, 164, 372, 566, 1], + [0, 28, 167, 296, 400, 1], + [0, 29, 152, 268, 421, 617, 1], + [0, 29, 155, 280, 382, 1], + [0, 30, 227, 294, 504, 603, 1], + [0, 30, 228, 284, 465, 623, 1], + [0, 31, 218, 485, 613, 1], + [0, 31, 221, 292, 407, 1], + [0, 32, 141, 287, 383, 1], + [0, 32, 142, 412, 576, 1], + [0, 33, 254, 274, 499, 606, 1], + [0, 33, 255, 293, 498, 1], + [0, 34, 200, 501, 565, 1], + [0, 34, 201, 297, 341, 1], + [0, 35, 186, 295, 426, 1], + [0, 35, 187, 509, 380, 552, 1], + [0, 36, 200, 272, 427, 602, 1], + [0, 36, 203, 491, 630, 1], + [0, 37, 158, 272, 391, 517, 1], + [0, 37, 508, 427, 612, 1], + [0, 38, 170, 274, 409, 605, 1], + [0, 38, 171, 280, 419, 1], + [0, 39, 257, 286, 486, 1], + [0, 39, 258, 298, 495, 556, 1], + [0, 40, 185, 272, 445, 610, 1], + [0, 40, 189, 296, 423, 1], + [0, 41, 206, 274, 451, 604, 1], + [0, 41, 208, 286, 351, 594, 1], + [0, 42, 261, 294, 479, 1], + [0, 42, 262, 441, 608, 1], + [0, 43, 140, 274, 348, 1], + [0, 43, 144, 280, 369, 1], + [0, 44, 209, 281, 333, 1], + [0, 44, 210, 490, 533, 1], + [0, 45, 160, 283, 353, 587, 1], + [0, 45, 295, 364, 1], + [0, 46, 173, 299, 461, 554, 1], + [0, 46, 174, 287, 405, 1], + [0, 47, 260, 272, 505, 603, 1], + [0, 47, 264, 297, 501, 1], + [0, 48, 116, 286, 449, 1], + [0, 48, 117, 506, 357, 586, 1], + [0, 49, 119, 300, 361, 593, 1], + [0, 49, 120, 298, 357, 1], + [0, 50, 122, 506, 349, 536, 1], + [0, 50, 123, 292, 339, 572, 1], + [0, 48, 288, 355, 594, 1], + [0, 56, 282, 352, 1], + [0, 51, 147, 288, 337, 581, 1], + [0, 51, 148, 406, 561, 1], + [0, 67, 300, 432, 514, 1], + [0, 68, 279, 332, 1], + [0, 52, 191, 300, 455, 1], + [0, 52, 192, 279, 431, 585, 1], + [0, 53, 176, 374, 574, 1], + [0, 53, 177, 371, 600, 1], + [0, 52, 276, 433, 592, 1], + [0, 62, 289, 437, 1], + [0, 54, 122, 294, 358, 586, 1], + [0, 54, 124, 290, 393, 513, 1], + [0, 55, 146, 276, 344, 1], + [0, 55, 150, 278, 453, 1], + [0, 56, 116, 506, 351, 515, 1], + [0, 56, 118, 278, 350, 587, 1], + [0, 57, 176, 276, 397, 591, 1], + [0, 57, 180, 278, 411, 576, 1], + [0, 58, 117, 284, 352, 597, 1], + [0, 58, 280, 333, 579, 1], + [0, 59, 276, 415, 596, 1], + [0, 59, 162, 290, 356, 588, 1], + [0, 60, 121, 296, 365, 1], + [0, 60, 123, 506, 348, 511, 1], + [0, 61, 149, 301, 438, 1], + [0, 61, 151, 267, 326, 1], + [0, 62, 191, 509, 393, 590, 1], + [0, 62, 193, 267, 428, 575, 1], + [0, 64, 279, 355, 1], + [0, 74, 283, 388, 1], + [0, 63, 131, 291, 361, 1], + [0, 63, 132, 507, 341, 573, 1], + [0, 64, 507, 340, 572, 1], + [0, 64, 128, 282, 366, 1], + [0, 65, 507, 331, 510, 1], + [0, 65, 133, 292, 370, 1], + [0, 66, 177, 288, 414, 580, 1], + [0, 66, 179, 301, 376, 574, 1], + [0, 67, 161, 289, 350, 1], + [0, 67, 163, 508, 432, 592, 1], + [0, 63, 293, 339, 1], + [0, 65, 294, 441, 557, 1], + [0, 68, 162, 508, 420, 518, 1], + [0, 68, 163, 267, 392, 582, 1], + [0, 69, 290, 454, 1], + [0, 69, 193, 509, 391, 599, 1], + [0, 70, 132, 295, 340, 1], + [0, 70, 290, 338, 573, 1], + [0, 71, 281, 448, 604, 1], + [0, 71, 130, 278, 332, 571, 1], + [0, 72, 148, 291, 435, 1], + [0, 72, 151, 408, 609, 1], + [0, 73, 178, 291, 413, 589, 1], + [0, 73, 181, 267, 410, 580, 1], + [0, 74, 129, 280, 351, 1], + [0, 74, 130, 507, 332, 512, 1], + [0, 75, 261, 438, 538, 1], + [0, 75, 263, 285, 443, 1], + [0, 76, 159, 296, 390, 1], + [0, 76, 508, 428, 514, 1], + [0, 77, 141, 411, 589, 1], + [0, 77, 143, 292, 357, 516, 1], + [0, 78, 207, 298, 420, 1], + [0, 78, 211, 269, 404, 561, 1], + [0, 79, 188, 284, 424, 1], + [0, 79, 190, 271, 440, 1], + [0, 80, 262, 282, 442, 557, 1], + [0, 80, 265, 271, 500, 1], + [0, 81, 208, 499, 611, 1], + [0, 81, 210, 293, 417, 1], + [0, 82, 171, 364, 621, 1], + [0, 82, 175, 269, 446, 1], + [0, 83, 255, 449, 601, 1], + [0, 83, 259, 269, 494, 1], + [0, 37, 284, 335, 579, 1], + [0, 76, 271, 422, 563, 1], + [0, 84, 142, 299, 342, 1], + [0, 84, 145, 269, 327, 1], + [0, 85, 203, 282, 503, 570, 1], + [0, 85, 205, 271, 386, 568, 1], + [0, 86, 172, 292, 460, 1], + [0, 86, 175, 376, 595, 1], + [0, 87, 202, 285, 502, 1], + [0, 87, 204, 294, 340, 583, 1], + [0, 88, 256, 281, 497, 1], + [0, 88, 258, 439, 629, 1], + [0, 89, 187, 283, 425, 1], + [0, 89, 190, 509, 390, 517, 1], + [0, 90, 243, 286, 496, 611, 1], + [0, 90, 245, 455, 631, 1], + [0, 91, 153, 508, 426, 563, 1], + [0, 91, 157, 275, 330, 1], + [0, 92, 237, 284, 480, 1], + [0, 92, 241, 273, 464, 550, 1], + [0, 93, 137, 295, 387, 1], + [0, 93, 139, 273, 346, 1], + [0, 94, 183, 298, 450, 1], + [0, 94, 275, 458, 554, 1], + [0, 95, 244, 292, 485, 1], + [0, 95, 247, 275, 482, 541, 1], + [0, 96, 165, 285, 363, 1], + [0, 96, 169, 273, 398, 546, 1], + [0, 97, 238, 469, 623, 1], + [0, 97, 240, 283, 477, 615, 1], + [0, 98, 136, 296, 341, 577, 1], + [0, 98, 138, 285, 402, 1], + [0, 99, 156, 298, 342, 583, 1], + [0, 99, 157, 508, 418, 542, 1], + [0, 100, 225, 283, 468, 1], + [0, 100, 227, 478, 620, 1], + [0, 101, 221, 470, 527, 1], + [0, 101, 223, 275, 416, 547, 1], + [0, 102, 226, 297, 467, 1], + [0, 102, 229, 273, 476, 539, 1], + [0, 103, 220, 299, 406, 1], + [0, 103, 222, 286, 459, 1], + [0, 104, 168, 282, 399, 1], + [0, 104, 169, 367, 621, 1], + [0, 79, 509, 392, 513, 1], + [0, 24, 293, 447, 564, 1], + [0, 105, 231, 288, 456, 1], + [0, 105, 235, 277, 470, 529, 1], + [0, 106, 195, 301, 412, 596, 1], + [0, 106, 197, 279, 490, 1], + [0, 107, 249, 301, 492, 1], + [0, 107, 253, 447, 601, 1], + [0, 108, 213, 481, 615, 1], + [0, 108, 215, 290, 429, 585, 1], + [0, 109, 196, 289, 430, 575, 1], + [0, 109, 199, 277, 349, 1], + [0, 110, 216, 278, 375, 584, 1], + [0, 110, 217, 277, 452, 526, 1], + [0, 111, 232, 300, 473, 1], + [0, 111, 234, 458, 549, 1], + [0, 112, 252, 291, 489, 1], + [0, 112, 253, 277, 488, 537, 1], + [0, 49, 506, 1], + [0, 54, 506, 1], + [0, 56, 506, 1], + [0, 2, 507, 339, 577, 1], + [0, 21, 508, 424, 612, 1], + [0, 29, 508, 1], + [0, 40, 509, 385, 622, 1], + [0, 52, 517, 1], + [0, 79, 1], + [0, 94, 509, 1], + [0, 8, 328, 510, 1], + [0, 13, 346, 511, 1], + [0, 58, 335, 512, 1], + [0, 59, 394, 513, 1], + [0, 69, 431, 514, 1], + [0, 71, 350, 515, 1], + [0, 70, 359, 516, 1], + [0, 45, 388, 517, 1], + [0, 19, 421, 518, 1], + [0, 113, 277, 434, 538, 1], + [0, 114, 275, 380, 544, 1], + [0, 7, 273, 329, 1], + [0, 115, 271, 328, 1], + [0, 8, 269, 345, 536, 1], + [0, 11, 267, 349, 511, 1], + [0, 48, 289, 394, 591, 1], + [0, 116, 287, 336, 1], + [0, 117, 285, 353, 1], + [0, 56, 283, 334, 1], + [0, 58, 281, 354, 597, 1], + [0, 118, 279, 395, 590, 1], + [0, 119, 301, 343, 1], + [0, 120, 299, 360, 593, 1], + [0, 121, 297, 359, 588, 1], + [0, 122, 295, 359, 1], + [0, 123, 293, 384, 1], + [0, 124, 291, 338, 1], + [0, 125, 277, 331, 1], + [0, 126, 274, 373, 607, 1], + [0, 2, 272, 329, 531, 1], + [0, 127, 273, 362, 540, 1], + [0, 5, 275, 345, 1], + [0, 13, 276, 331, 534, 1], + [0, 64, 288, 378, 578, 1], + [0, 71, 287, 354, 1], + [0, 74, 285, 335, 1], + [0, 128, 284, 389, 1], + [0, 129, 286, 336, 512, 1], + [0, 130, 289, 337, 1], + [0, 131, 300, 343, 577, 1], + [0, 63, 299, 371, 1], + [0, 132, 297, 444, 1], + [0, 65, 296, 358, 1], + [0, 133, 298, 381, 1], + [0, 70, 301, 356, 1], + [0, 134, 307, 367, 1], + [0, 135, 306, 384, 622, 1], + [0, 136, 305, 401, 619, 1], + [0, 137, 304, 364, 540, 1], + [0, 138, 303, 381, 614, 1], + [0, 139, 302, 396, 1], + [0, 140, 313, 395, 1], + [0, 141, 312, 408, 569, 1], + [0, 142, 311, 371, 566, 1], + [0, 143, 310, 389, 599, 1], + [0, 144, 309, 440, 559, 1], + [0, 145, 308, 394, 1], + [0, 146, 319, 447, 1], + [0, 147, 318, 378, 1], + [0, 148, 317, 391, 1], + [0, 149, 316, 386, 1], + [0, 150, 315, 385, 1], + [0, 151, 314, 374, 1], + [0, 152, 315, 375, 1], + [0, 153, 306, 366, 548, 1], + [0, 154, 321, 419, 617, 1], + [0, 155, 320, 418, 518, 1], + [0, 156, 303, 363, 616, 1], + [0, 157, 318, 411, 1], + [0, 158, 317, 377, 1], + [0, 159, 323, 426, 612, 1], + [0, 37, 310, 370, 555, 1], + [0, 160, 311, 407, 569, 1], + [0, 45, 322, 451, 1], + [0, 76, 316, 376, 1], + [0, 59, 325, 428, 1], + [0, 67, 302, 362, 1], + [0, 68, 313, 373, 1], + [0, 161, 308, 368, 1], + [0, 162, 307, 393, 1], + [0, 163, 324, 442, 1], + [0, 164, 302, 403, 1], + [0, 165, 306, 420, 547, 1], + [0, 166, 305, 365, 548, 1], + [0, 167, 304, 400, 627, 1], + [0, 168, 303, 399, 619, 1], + [0, 169, 307, 432, 1], + [0, 170, 308, 409, 1], + [0, 171, 312, 445, 1], + [0, 172, 311, 388, 560, 1], + [0, 173, 310, 406, 609, 1], + [0, 174, 309, 405, 605, 1], + [0, 175, 313, 404, 1], + [0, 176, 314, 450, 567, 1], + [0, 177, 315, 414, 1], + [0, 178, 316, 413, 1], + [0, 179, 317, 459, 624, 1], + [0, 180, 318, 380, 1], + [0, 181, 319, 379, 1], + [0, 182, 318, 444, 559, 1], + [0, 183, 306, 452, 1], + [0, 19, 321, 383, 552, 1], + [0, 184, 320, 382, 622, 1], + [0, 24, 303, 457, 1], + [0, 94, 315, 441, 1], + [0, 185, 316, 462, 1], + [0, 186, 323, 446, 564, 1], + [0, 187, 310, 439, 1], + [0, 188, 311, 434, 1], + [0, 189, 322, 423, 558, 1], + [0, 190, 317, 422, 1], + [0, 52, 324, 433, 1], + [0, 191, 307, 398, 1], + [0, 192, 308, 431, 1], + [0, 62, 313, 467, 553, 1], + [0, 69, 302, 429, 1], + [0, 193, 325, 443, 608, 1], + [0, 194, 310, 425, 602, 1], + [0, 195, 321, 469, 1], + [0, 196, 304, 458, 1], + [0, 197, 305, 463, 1], + [0, 198, 320, 464, 1], + [0, 199, 311, 424, 558, 1], + [0, 200, 312, 372, 607, 1], + [0, 201, 318, 421, 1], + [0, 202, 325, 397, 1], + [0, 203, 324, 392, 1], + [0, 204, 315, 416, 1], + [0, 205, 309, 369, 600, 1], + [0, 206, 322, 387, 560, 1], + [0, 207, 314, 415, 1], + [0, 208, 307, 449, 567, 1], + [0, 209, 302, 448, 1], + [0, 210, 319, 410, 1], + [0, 211, 323, 390, 568, 1], + [0, 212, 303, 417, 542, 1], + [0, 213, 323, 456, 532, 1], + [0, 214, 312, 472, 527, 1], + [0, 215, 309, 505, 1], + [0, 216, 322, 474, 634, 1], + [0, 217, 306, 402, 551, 1], + [0, 218, 305, 436, 535, 1], + [0, 219, 316, 427, 1], + [0, 220, 325, 461, 1], + [0, 221, 324, 460, 549, 1], + [0, 222, 317, 412, 1], + [0, 223, 304, 437, 629, 1], + [0, 224, 321, 438, 632, 1], + [0, 225, 314, 468, 553, 1], + [0, 226, 313, 430, 1], + [0, 227, 308, 478, 1], + [0, 228, 319, 495, 1], + [0, 229, 320, 435, 535, 1], + [0, 230, 306, 475, 1], + [0, 231, 322, 453, 526, 1], + [0, 232, 309, 454, 633, 1], + [0, 233, 312, 500, 570, 1], + [0, 234, 323, 471, 628, 1], + [0, 235, 303, 470, 1], + [0, 236, 320, 481, 1], + [0, 237, 314, 480, 545, 1], + [0, 238, 313, 479, 545, 1], + [0, 239, 308, 466, 1], + [0, 240, 319, 465, 1], + [0, 241, 321, 476, 1], + [0, 242, 304, 487, 1], + [0, 243, 316, 486, 543, 1], + [0, 244, 325, 485, 543, 1], + [0, 245, 324, 484, 1], + [0, 246, 317, 483, 1], + [0, 247, 305, 482, 1], + [0, 248, 311, 493, 1], + [0, 249, 320, 492, 635, 1], + [0, 250, 305, 491, 537, 1], + [0, 251, 304, 490, 635, 1], + [0, 252, 321, 489, 533, 1], + [0, 253, 310, 488, 1], + [0, 254, 323, 499, 1], + [0, 255, 314, 498, 562, 1], + [0, 256, 307, 497, 606, 1], + [0, 257, 302, 496, 1], + [0, 258, 319, 477, 1], + [0, 259, 322, 494, 556, 1], + [0, 260, 309, 473, 529, 1], + [0, 261, 318, 504, 1], + [0, 262, 325, 503, 1], + [0, 263, 324, 502, 565, 1], + [0, 264, 315, 501, 598, 1], + [0, 265, 312, 455, 532, 1] + ], + "candidate": [ + [2, 507, 326, 531, 1], + [3, 212, 522, 472, 634, 1], + [4, 231, 523, 452, 532, 1], + [5, 127, 507, 337, 579, 1], + [6, 230, 523, 457, 633, 1], + [7, 114, 506, 344, 528, 1], + [8, 113, 506, 1], + [9, 215, 522, 473, 628, 1], + [10, 249, 524, 436, 632, 1], + [11, 506, 345, 525, 1], + [12, 195, 521, 493, 635, 1], + [13, 126, 507, 338, 572, 1], + [14, 252, 524, 442, 610, 1], + [15, 194, 521, 503, 598, 1], + [16, 236, 523, 468, 625, 1], + [17, 134, 519, 413, 580, 1], + [18, 243, 523, 462, 554, 1], + [19, 183, 509, 395, 582, 1], + [20, 242, 523, 460, 626, 1], + [21, 152, 508, 1], + [22, 240, 523, 453, 631, 1], + [23, 165, 520, 363, 540, 1], + [24, 182, 509, 1], + [25, 137, 519, 398, 551, 1], + [26, 220, 522, 487, 613, 1], + [27, 226, 522, 474, 529, 1], + [28, 168, 520, 373, 600, 1], + [29, 156, 508, 425, 563, 1], + [30, 224, 522, 482, 543, 1], + [31, 222, 522, 479, 615, 1], + [32, 140, 519, 415, 589, 1], + [33, 256, 524, 434, 535, 1], + [34, 202, 521, 504, 570, 1], + [35, 185, 509, 383, 614, 1], + [36, 204, 521, 488, 533, 1], + [37, 159, 508, 419, 547, 1], + [38, 172, 520, 369, 555, 1], + [39, 254, 524, 450, 604, 1], + [40, 188, 509, 389, 568, 1], + [41, 207, 521, 492, 537, 1], + [42, 260, 524, 435, 629, 1], + [43, 143, 519, 404, 569, 1], + [44, 206, 521, 496, 556, 1], + [45, 158, 508, 422, 558, 1], + [46, 170, 520, 370, 607, 1], + [47, 263, 524, 440, 557, 1], + [48, 506, 354, 587, 1], + [49, 121, 506, 356, 586, 1], + [50, 119, 506, 347, 536, 1], + [51, 146, 519, 405, 561, 1], + [52, 509, 397, 590, 1], + [53, 178, 520, 375, 574, 1], + [54, 120, 506, 358, 593, 1], + [55, 149, 519, 414, 596, 1], + [56, 506, 355, 597, 1], + [57, 179, 520, 365, 616, 1], + [58, 118, 506, 353, 594, 1], + [59, 161, 508, 430, 592, 1], + [60, 124, 506, 360, 588, 1], + [61, 147, 519, 402, 627, 1], + [62, 509, 396, 591, 1], + [63, 507, 343, 583, 1], + [64, 129, 507, 327, 530, 1], + [65, 131, 507, 342, 573, 1], + [66, 181, 520, 379, 584, 1], + [67, 508, 433, 585, 1], + [68, 508, 417, 617, 1], + [69, 192, 509, 387, 599, 1], + [70, 133, 507, 334, 581, 1], + [71, 128, 507, 329, 534, 1], + [72, 150, 519, 409, 609, 1], + [73, 180, 520, 377, 578, 1], + [74, 507, 333, 571, 1], + [75, 265, 524, 437, 538, 1], + [76, 160, 508, 423, 602, 1], + [77, 145, 519, 407, 605, 1], + [78, 209, 521, 494, 562, 1], + [79, 186, 509, 386, 560, 1], + [80, 264, 524, 446, 567, 1], + [81, 211, 521, 500, 565, 1], + [82, 173, 520, 366, 621, 1], + [83, 257, 524, 448, 564, 1], + [84, 144, 519, 410, 576, 1], + [85, 201, 521, 498, 611, 1], + [86, 174, 520, 378, 595, 1], + [87, 205, 521, 502, 603, 1], + [88, 259, 524, 443, 559, 1], + [89, 189, 509, 384, 552, 1], + [90, 247, 523, 463, 624, 1], + [91, 155, 508, 429, 575, 1], + [92, 239, 523, 467, 623, 1], + [93, 135, 519, 400, 546, 1], + [94, 184, 509, 381, 544, 1], + [95, 246, 523, 454, 526, 1], + [96, 167, 520, 362, 548, 1], + [97, 241, 523, 466, 550, 1], + [98, 139, 519, 403, 619, 1], + [99, 154, 508, 416, 542, 1], + [100, 229, 522, 480, 620, 1], + [101, 219, 522, 471, 527, 1], + [102, 228, 522, 476, 545, 1], + [103, 223, 522, 484, 541, 1], + [104, 166, 520, 368, 566, 1], + [105, 233, 523, 464, 553, 1], + [106, 199, 521, 489, 630, 1], + [107, 251, 524, 451, 601, 1], + [108, 217, 522, 477, 539, 1], + [109, 198, 521, 495, 606, 1], + [110, 214, 522, 486, 618, 1], + [111, 235, 523, 459, 549, 1], + [112, 250, 524, 445, 608, 1], + [0, 127, 525], + [0, 217, 526], + [0, 233, 527], + [0, 528], + [0, 235, 529], + [0, 11, 530], + [0, 114, 531], + [0, 214, 532], + [0, 252, 533], + [0, 534], + [0, 198, 535], + [0, 2, 536], + [0, 249, 537], + [0, 199, 538], + [0, 239, 539], + [0, 139, 540], + [0, 246, 541], + [0, 184, 542], + [0, 247, 543], + [0, 155, 544], + [0, 241, 545], + [0, 168, 546], + [0, 547], + [0, 135, 548], + [0, 222, 549], + [0, 229, 550], + [0, 165, 551], + [0, 154, 552], + [0, 226, 553], + [0, 223, 554], + [0, 143, 555], + [0, 257, 556], + [0, 205, 557], + [0, 188, 558], + [0, 202, 559], + [0, 160, 560], + [0, 173, 561], + [0, 259, 562], + [0, 186, 563], + [0, 211, 564], + [0, 263, 565], + [0, 145, 566], + [0, 207, 567], + [0, 159, 568], + [0, 172, 569], + [0, 265, 570], + [0, 571], + [0, 124, 572], + [0, 121, 573], + [0, 149, 574], + [0, 62, 575], + [0, 181, 576], + [0, 119, 577], + [0, 147, 578], + [0, 48, 579], + [0, 178, 580], + [0, 56, 581], + [0, 67, 582], + [0, 120, 583], + [0, 150, 584], + [0, 585], + [0, 586], + [0, 74, 587], + [0, 63, 588], + [0, 180, 589], + [0, 68, 590], + [0, 591], + [0, 52, 592], + [0, 131, 593], + [0, 129, 594], + [0, 146, 595], + [0, 179, 596], + [0, 597], + [0, 264, 598], + [0, 599], + [0, 144, 600], + [0, 206, 601], + [0, 189, 602], + [0, 260, 603], + [0, 209, 604], + [0, 174, 605], + [0, 256, 606], + [0, 140, 607], + [0, 204, 608], + [0, 170, 609], + [0, 201, 610], + [0, 254, 611], + [0, 185, 612], + [0, 242, 613], + [0, 156, 614], + [0, 240, 615], + [0, 134, 616], + [0, 182, 617], + [0, 243, 618], + [0, 166, 619], + [0, 236, 620], + [0, 137, 621], + [0, 152, 622], + [0, 228, 623], + [0, 220, 624], + [0, 224, 625], + [0, 219, 626], + [0, 167, 627], + [0, 230, 628], + [0, 194, 629], + [0, 250, 630], + [0, 212, 631], + [0, 195, 632], + [0, 215, 633], + [0, 231, 634], + [0, 251, 635], + [0, 2, 125, 267, 374, 578, 1], + [0, 2, 126, 268, 348, 528, 1], + [0, 3, 213, 288, 474, 1], + [0, 3, 214, 300, 396, 582, 1], + [0, 4, 230, 266, 475, 634, 1], + [0, 4, 232, 456, 633, 1], + [0, 5, 125, 507, 330, 531, 1], + [0, 5, 336, 581, 1], + [0, 6, 233, 290, 472, 1], + [0, 6, 234, 278, 471, 1], + [0, 7, 113, 276, 379, 595, 1], + [0, 7, 506, 352, 515, 1], + [0, 8, 115, 270, 328, 530, 1], + [0, 8, 268, 327, 534, 1], + [0, 9, 212, 266, 457, 631, 1], + [0, 9, 216, 483, 541, 1], + [0, 10, 248, 266, 493, 630, 1], + [0, 10, 250, 289, 491, 1], + [0, 11, 114, 274, 330, 510, 1], + [0, 11, 115, 506, 361, 516, 1], + [0, 7, 272, 347, 1], + [0, 11, 266, 344, 525, 1], + [0, 12, 194, 266, 439, 632, 1], + [0, 12, 196, 497, 562, 1], + [0, 13, 127, 271, 346, 525, 1], + [0, 13, 266, 326, 530, 1], + [0, 14, 248, 444, 610, 1], + [0, 14, 251, 279, 436, 1], + [0, 15, 197, 505, 598, 1], + [0, 15, 198, 291, 377, 584, 1], + [0, 2, 270, 367, 616, 1], + [0, 5, 269, 368, 555, 1], + [0, 16, 237, 465, 550, 1], + [0, 16, 238, 294, 466, 625, 1], + [0, 17, 135, 282, 334, 571, 1], + [0, 17, 136, 399, 546, 1], + [0, 18, 242, 268, 487, 618, 1], + [0, 18, 244, 461, 624, 1], + [0, 19, 182, 268, 463, 626, 1], + [0, 19, 280, 408, 1], + [0, 20, 245, 299, 484, 618, 1], + [0, 20, 246, 281, 483, 613, 1], + [0, 21, 153, 293, 360, 1], + [0, 21, 154, 287, 372, 1], + [0, 22, 236, 270, 469, 625, 1], + [0, 22, 239, 297, 478, 539, 1], + [0, 23, 164, 270, 403, 627, 1], + [0, 23, 166, 295, 401, 1], + [0, 24, 184, 287, 418, 1], + [0, 24, 509, 382, 544, 1], + [0, 25, 134, 270, 347, 528, 1], + [0, 25, 138, 401, 551, 1], + [0, 26, 218, 268, 385, 614, 1], + [0, 26, 219, 281, 462, 626, 1], + [0, 27, 224, 270, 481, 620, 1], + [0, 27, 225, 475, 628, 1], + [0, 28, 164, 372, 566, 1], + [0, 28, 167, 296, 400, 1], + [0, 29, 152, 268, 421, 617, 1], + [0, 29, 155, 280, 382, 1], + [0, 30, 227, 294, 504, 603, 1], + [0, 30, 228, 284, 465, 623, 1], + [0, 31, 218, 485, 613, 1], + [0, 31, 221, 292, 407, 1], + [0, 32, 141, 287, 383, 1], + [0, 32, 142, 412, 576, 1], + [0, 33, 254, 274, 499, 606, 1], + [0, 33, 255, 293, 498, 1], + [0, 34, 200, 501, 565, 1], + [0, 34, 201, 297, 341, 1], + [0, 35, 186, 295, 426, 1], + [0, 35, 187, 509, 380, 552, 1], + [0, 36, 200, 272, 427, 602, 1], + [0, 36, 203, 491, 630, 1], + [0, 37, 158, 272, 391, 517, 1], + [0, 37, 508, 427, 612, 1], + [0, 38, 170, 274, 409, 605, 1], + [0, 38, 171, 280, 419, 1], + [0, 39, 257, 286, 486, 1], + [0, 39, 258, 298, 495, 556, 1], + [0, 40, 185, 272, 445, 610, 1], + [0, 40, 189, 296, 423, 1], + [0, 41, 206, 274, 451, 604, 1], + [0, 41, 208, 286, 351, 594, 1], + [0, 42, 261, 294, 479, 1], + [0, 42, 262, 441, 608, 1], + [0, 43, 140, 274, 348, 1], + [0, 43, 144, 280, 369, 1], + [0, 44, 209, 281, 333, 1], + [0, 44, 210, 490, 533, 1], + [0, 45, 160, 283, 353, 587, 1], + [0, 45, 295, 364, 1], + [0, 46, 173, 299, 461, 554, 1], + [0, 46, 174, 287, 405, 1], + [0, 47, 260, 272, 505, 603, 1], + [0, 47, 264, 297, 501, 1], + [0, 48, 116, 286, 449, 1], + [0, 48, 117, 506, 357, 586, 1], + [0, 49, 119, 300, 361, 593, 1], + [0, 49, 120, 298, 357, 1], + [0, 50, 122, 506, 349, 536, 1], + [0, 50, 123, 292, 339, 572, 1], + [0, 48, 288, 355, 594, 1], + [0, 56, 282, 352, 1], + [0, 51, 147, 288, 337, 581, 1], + [0, 51, 148, 406, 561, 1], + [0, 67, 300, 432, 514, 1], + [0, 68, 279, 332, 1], + [0, 52, 191, 300, 455, 1], + [0, 52, 192, 279, 431, 585, 1], + [0, 53, 176, 374, 574, 1], + [0, 53, 177, 371, 600, 1], + [0, 52, 276, 433, 592, 1], + [0, 62, 289, 437, 1], + [0, 54, 122, 294, 358, 586, 1], + [0, 54, 124, 290, 393, 513, 1], + [0, 55, 146, 276, 344, 1], + [0, 55, 150, 278, 453, 1], + [0, 56, 116, 506, 351, 515, 1], + [0, 56, 118, 278, 350, 587, 1], + [0, 57, 176, 276, 397, 591, 1], + [0, 57, 180, 278, 411, 576, 1], + [0, 58, 117, 284, 352, 597, 1], + [0, 58, 280, 333, 579, 1], + [0, 59, 276, 415, 596, 1], + [0, 59, 162, 290, 356, 588, 1], + [0, 60, 121, 296, 365, 1], + [0, 60, 123, 506, 348, 511, 1], + [0, 61, 149, 301, 438, 1], + [0, 61, 151, 267, 326, 1], + [0, 62, 191, 509, 393, 590, 1], + [0, 62, 193, 267, 428, 575, 1], + [0, 64, 279, 355, 1], + [0, 74, 283, 388, 1], + [0, 63, 131, 291, 361, 1], + [0, 63, 132, 507, 341, 573, 1], + [0, 64, 507, 340, 572, 1], + [0, 64, 128, 282, 366, 1], + [0, 65, 507, 331, 510, 1], + [0, 65, 133, 292, 370, 1], + [0, 66, 177, 288, 414, 580, 1], + [0, 66, 179, 301, 376, 574, 1], + [0, 67, 161, 289, 350, 1], + [0, 67, 163, 508, 432, 592, 1], + [0, 63, 293, 339, 1], + [0, 65, 294, 441, 557, 1], + [0, 68, 162, 508, 420, 518, 1], + [0, 68, 163, 267, 392, 582, 1], + [0, 69, 290, 454, 1], + [0, 69, 193, 509, 391, 599, 1], + [0, 70, 132, 295, 340, 1], + [0, 70, 290, 338, 573, 1], + [0, 71, 281, 448, 604, 1], + [0, 71, 130, 278, 332, 571, 1], + [0, 72, 148, 291, 435, 1], + [0, 72, 151, 408, 609, 1], + [0, 73, 178, 291, 413, 589, 1], + [0, 73, 181, 267, 410, 580, 1], + [0, 74, 129, 280, 351, 1], + [0, 74, 130, 507, 332, 512, 1], + [0, 75, 261, 438, 538, 1], + [0, 75, 263, 285, 443, 1], + [0, 76, 159, 296, 390, 1], + [0, 76, 508, 428, 514, 1], + [0, 77, 141, 411, 589, 1], + [0, 77, 143, 292, 357, 516, 1], + [0, 78, 207, 298, 420, 1], + [0, 78, 211, 269, 404, 561, 1], + [0, 79, 188, 284, 424, 1], + [0, 79, 190, 271, 440, 1], + [0, 80, 262, 282, 442, 557, 1], + [0, 80, 265, 271, 500, 1], + [0, 81, 208, 499, 611, 1], + [0, 81, 210, 293, 417, 1], + [0, 82, 171, 364, 621, 1], + [0, 82, 175, 269, 446, 1], + [0, 83, 255, 449, 601, 1], + [0, 83, 259, 269, 494, 1], + [0, 37, 284, 335, 579, 1], + [0, 76, 271, 422, 563, 1], + [0, 84, 142, 299, 342, 1], + [0, 84, 145, 269, 327, 1], + [0, 85, 203, 282, 503, 570, 1], + [0, 85, 205, 271, 386, 568, 1], + [0, 86, 172, 292, 460, 1], + [0, 86, 175, 376, 595, 1], + [0, 87, 202, 285, 502, 1], + [0, 87, 204, 294, 340, 583, 1], + [0, 88, 256, 281, 497, 1], + [0, 88, 258, 439, 629, 1], + [0, 89, 187, 283, 425, 1], + [0, 89, 190, 509, 390, 517, 1], + [0, 90, 243, 286, 496, 611, 1], + [0, 90, 245, 455, 631, 1], + [0, 91, 153, 508, 426, 563, 1], + [0, 91, 157, 275, 330, 1], + [0, 92, 237, 284, 480, 1], + [0, 92, 241, 273, 464, 550, 1], + [0, 93, 137, 295, 387, 1], + [0, 93, 139, 273, 346, 1], + [0, 94, 183, 298, 450, 1], + [0, 94, 275, 458, 554, 1], + [0, 95, 244, 292, 485, 1], + [0, 95, 247, 275, 482, 541, 1], + [0, 96, 165, 285, 363, 1], + [0, 96, 169, 273, 398, 546, 1], + [0, 97, 238, 469, 623, 1], + [0, 97, 240, 283, 477, 615, 1], + [0, 98, 136, 296, 341, 577, 1], + [0, 98, 138, 285, 402, 1], + [0, 99, 156, 298, 342, 583, 1], + [0, 99, 157, 508, 418, 542, 1], + [0, 100, 225, 283, 468, 1], + [0, 100, 227, 478, 620, 1], + [0, 101, 221, 470, 527, 1], + [0, 101, 223, 275, 416, 547, 1], + [0, 102, 226, 297, 467, 1], + [0, 102, 229, 273, 476, 539, 1], + [0, 103, 220, 299, 406, 1], + [0, 103, 222, 286, 459, 1], + [0, 104, 168, 282, 399, 1], + [0, 104, 169, 367, 621, 1], + [0, 186, 509, 392, 513, 1], + [0, 24, 293, 447, 564, 1], + [0, 105, 231, 288, 456, 1], + [0, 105, 235, 277, 470, 529, 1], + [0, 106, 195, 301, 412, 596, 1], + [0, 106, 197, 279, 490, 1], + [0, 107, 249, 301, 492, 1], + [0, 107, 253, 447, 601, 1], + [0, 108, 213, 481, 615, 1], + [0, 108, 215, 290, 429, 585, 1], + [0, 109, 196, 289, 430, 575, 1], + [0, 109, 199, 277, 349, 1], + [0, 110, 216, 278, 375, 584, 1], + [0, 110, 217, 277, 452, 526, 1], + [0, 111, 232, 300, 473, 1], + [0, 111, 234, 458, 549, 1], + [0, 112, 252, 291, 489, 1], + [0, 112, 253, 277, 488, 537, 1], + [0, 49, 506, 1], + [0, 54, 506, 1], + [0, 56, 506, 1], + [0, 2, 507, 339, 577, 1], + [0, 21, 508, 424, 612, 1], + [0, 29, 508, 1], + [0, 40, 509, 385, 622, 1], + [0, 52, 517, 1], + [0, 94, 509, 1], + [0, 8, 328, 510, 1], + [0, 13, 346, 511, 1], + [0, 58, 335, 512, 1], + [0, 59, 394, 513, 1], + [0, 69, 431, 514, 1], + [0, 71, 350, 515, 1], + [0, 70, 359, 516, 1], + [0, 45, 388, 517, 1], + [0, 19, 421, 518, 1], + [0, 113, 277, 434, 538, 1], + [0, 114, 275, 380, 544, 1], + [0, 7, 273, 329, 1], + [0, 115, 271, 328, 1], + [0, 8, 269, 345, 536, 1], + [0, 11, 267, 349, 511, 1], + [0, 48, 289, 394, 591, 1], + [0, 116, 287, 336, 1], + [0, 117, 285, 353, 1], + [0, 56, 283, 334, 1], + [0, 58, 281, 354, 597, 1], + [0, 118, 279, 395, 590, 1], + [0, 119, 301, 343, 1], + [0, 120, 299, 360, 593, 1], + [0, 121, 297, 359, 588, 1], + [0, 122, 295, 359, 1], + [0, 123, 293, 384, 1], + [0, 124, 291, 338, 1], + [0, 125, 277, 331, 1], + [0, 126, 274, 373, 607, 1], + [0, 2, 272, 329, 531, 1], + [0, 127, 273, 362, 540, 1], + [0, 5, 275, 345, 1], + [0, 13, 276, 331, 534, 1], + [0, 64, 288, 378, 578, 1], + [0, 71, 287, 354, 1], + [0, 74, 285, 335, 1], + [0, 128, 284, 389, 1], + [0, 129, 286, 336, 512, 1], + [0, 130, 289, 337, 1], + [0, 131, 300, 343, 577, 1], + [0, 63, 299, 371, 1], + [0, 132, 297, 444, 1], + [0, 65, 296, 358, 1], + [0, 133, 298, 381, 1], + [0, 70, 301, 356, 1], + [0, 134, 307, 367, 1], + [0, 135, 306, 384, 622, 1], + [0, 136, 305, 401, 619, 1], + [0, 137, 304, 364, 540, 1], + [0, 138, 303, 381, 614, 1], + [0, 139, 302, 396, 1], + [0, 140, 313, 395, 1], + [0, 141, 312, 408, 569, 1], + [0, 142, 311, 371, 566, 1], + [0, 143, 310, 389, 599, 1], + [0, 144, 309, 440, 559, 1], + [0, 145, 308, 394, 1], + [0, 146, 319, 447, 1], + [0, 147, 318, 378, 1], + [0, 148, 317, 391, 1], + [0, 149, 316, 386, 1], + [0, 150, 315, 385, 1], + [0, 151, 314, 374, 1], + [0, 152, 315, 375, 1], + [0, 153, 306, 366, 548, 1], + [0, 154, 321, 419, 617, 1], + [0, 155, 320, 418, 518, 1], + [0, 156, 303, 363, 616, 1], + [0, 157, 318, 411, 1], + [0, 158, 317, 377, 1], + [0, 159, 323, 426, 612, 1], + [0, 37, 310, 370, 555, 1], + [0, 160, 311, 407, 569, 1], + [0, 45, 322, 451, 1], + [0, 76, 316, 376, 1], + [0, 59, 325, 428, 1], + [0, 67, 302, 362, 1], + [0, 68, 313, 373, 1], + [0, 161, 308, 368, 1], + [0, 162, 307, 393, 1], + [0, 163, 324, 442, 1], + [0, 164, 302, 403, 1], + [0, 165, 306, 420, 547, 1], + [0, 166, 305, 365, 548, 1], + [0, 167, 304, 400, 627, 1], + [0, 168, 303, 399, 619, 1], + [0, 169, 307, 432, 1], + [0, 170, 308, 409, 1], + [0, 171, 312, 445, 1], + [0, 172, 311, 388, 560, 1], + [0, 173, 310, 406, 609, 1], + [0, 174, 309, 405, 605, 1], + [0, 175, 313, 404, 1], + [0, 176, 314, 450, 567, 1], + [0, 177, 315, 414, 1], + [0, 178, 316, 413, 1], + [0, 179, 317, 459, 624, 1], + [0, 180, 318, 380, 1], + [0, 181, 319, 379, 1], + [0, 182, 318, 444, 559, 1], + [0, 183, 306, 452, 1], + [0, 19, 321, 383, 552, 1], + [0, 184, 320, 382, 622, 1], + [0, 24, 303, 457, 1], + [0, 94, 315, 441, 1], + [0, 185, 316, 462, 1], + [0, 186, 323, 446, 564, 1], + [0, 187, 310, 439, 1], + [0, 188, 311, 434, 1], + [0, 189, 322, 423, 558, 1], + [0, 190, 317, 422, 1], + [0, 52, 324, 433, 1], + [0, 191, 307, 398, 1], + [0, 192, 308, 431, 1], + [0, 62, 313, 467, 553, 1], + [0, 69, 302, 429, 1], + [0, 193, 325, 443, 608, 1], + [0, 194, 310, 425, 602, 1], + [0, 195, 321, 469, 1], + [0, 196, 304, 458, 1], + [0, 197, 305, 463, 1], + [0, 198, 320, 464, 1], + [0, 199, 311, 424, 558, 1], + [0, 200, 312, 372, 607, 1], + [0, 201, 318, 421, 1], + [0, 202, 325, 397, 1], + [0, 203, 324, 392, 1], + [0, 204, 315, 416, 1], + [0, 205, 309, 369, 600, 1], + [0, 206, 322, 387, 560, 1], + [0, 207, 314, 415, 1], + [0, 208, 307, 449, 567, 1], + [0, 209, 302, 448, 1], + [0, 210, 319, 410, 1], + [0, 211, 323, 390, 568, 1], + [0, 212, 303, 417, 542, 1], + [0, 213, 323, 456, 532, 1], + [0, 214, 312, 472, 527, 1], + [0, 215, 309, 505, 1], + [0, 216, 322, 474, 634, 1], + [0, 217, 306, 402, 551, 1], + [0, 218, 305, 436, 535, 1], + [0, 219, 316, 427, 1], + [0, 220, 325, 461, 1], + [0, 221, 324, 460, 549, 1], + [0, 222, 317, 412, 1], + [0, 223, 304, 437, 629, 1], + [0, 224, 321, 438, 632, 1], + [0, 225, 314, 468, 553, 1], + [0, 226, 313, 430, 1], + [0, 227, 308, 478, 1], + [0, 228, 319, 495, 1], + [0, 229, 320, 435, 535, 1], + [0, 230, 306, 475, 1], + [0, 231, 322, 453, 526, 1], + [0, 232, 309, 454, 633, 1], + [0, 233, 312, 500, 570, 1], + [0, 234, 323, 471, 628, 1], + [0, 235, 303, 470, 1], + [0, 236, 320, 481, 1], + [0, 237, 314, 480, 545, 1], + [0, 238, 313, 479, 545, 1], + [0, 239, 308, 466, 1], + [0, 240, 319, 465, 1], + [0, 241, 321, 476, 1], + [0, 242, 304, 487, 1], + [0, 243, 316, 486, 543, 1], + [0, 244, 325, 485, 543, 1], + [0, 245, 324, 484, 1], + [0, 246, 317, 483, 1], + [0, 247, 305, 482, 1], + [0, 248, 311, 493, 1], + [0, 249, 320, 492, 635, 1], + [0, 250, 305, 491, 537, 1], + [0, 251, 304, 490, 635, 1], + [0, 252, 321, 489, 533, 1], + [0, 253, 310, 488, 1], + [0, 254, 323, 499, 1], + [0, 255, 314, 498, 562, 1], + [0, 256, 307, 497, 606, 1], + [0, 257, 302, 496, 1], + [0, 258, 319, 477, 1], + [0, 259, 322, 494, 556, 1], + [0, 260, 309, 473, 529, 1], + [0, 261, 318, 504, 1], + [0, 262, 325, 503, 1], + [0, 263, 324, 502, 565, 1], + [0, 264, 315, 501, 598, 1], + [0, 265, 312, 455, 532, 1] + ] +} diff --git a/research/bit-boundary-persistence/NOTICE.md b/research/bit-boundary-persistence/NOTICE.md new file mode 100644 index 0000000000..e703c9d977 --- /dev/null +++ b/research/bit-boundary-persistence/NOTICE.md @@ -0,0 +1,28 @@ +# Notice + +New material is prepared for Ali Romman (@aliromman), with substantial +OpenAI Codex assistance. It is supplied under Apache-2.0, the repository +license. No independent human review is implied. + +The candidate starts from DreamingOfClouds's PR589 tuning of eumemic's PR555 +punctured word. The construction retains eumemic's PR543 L3 skeleton and +interleaved scalar interface, DreamingOfClouds's PR545 punctured-star geometry, +and the prior work identified in their source notices. + +The native exporter and legality checks come from Dylan Crow's PR370 lineage. +The multi-stage column checker comes from DaysSky's PR381. The parent and +pricing engines come from DreamingOfClouds's PR463/510 and PR315 lineage. +Whole-residual idle hosting comes from DaysSky's PR442, with the owner and +replica checks from chafreaky's PR443/472 lineage. The scalar interface also +uses Zhihao Chen's PR425 work. Jacob Sussman introduced the E8 unit. + +These tools are used from the two unchanged packages pinned in `SOURCES.json`. +Their source notices and licenses remain in those packages. The new builder +and independent record replay were written for this candidate. The new driver +uses the existing adapters and their existing supported parameters; it does +not change the pinned exporters, checkers or pricing engines. + +Source inlining and early helper retirement are prior ideas. The related +PR429/515 and PR433/437 work is acknowledged. PR953, PR980, PR997, PR1001 and PR1015 +were checked for overlap. This package claims one verified boundary and its +complete hosted invoice, not priority for a general circuit method. diff --git a/research/bit-boundary-persistence/PROOF.md b/research/bit-boundary-persistence/PROOF.md new file mode 100644 index 0000000000..560c21b5d4 --- /dev/null +++ b/research/bit-boundary-persistence/PROOF.md @@ -0,0 +1,185 @@ +# Source boundary and complete cost + +All gate indices and original register identifiers below are zero-based. +The object is the exact PR589 word pinned in `SOURCES.json`. + +## 1. The legal late read + +Let `x` be source77, `q` helper470, and `r` receiver444. In A, the only two +uses of q are: + +```text +A[230] at frame79: q += x +A[1993] at frame79: r += q +``` + +There is no B use of q. The copied totals do not include q. Before the second +operation, exact replay on all independent initial columns gives +`x = x_in` and `q = q_in + x_in` over F2. In particular, a borrowed helper is +not treated as initially zero. + +Source77 begins at frame79, the line `[77]`. A[426] reads it at frame186, +whose lines are `[33,77]` and whose rational dimension is two. Receiver444 +is still at frame0 before A[1993]. Its next gate is A[1994] at frame509, +which contains frame186 and has dimension four. The next source77 read is +B[35] at frame186. Thus the new gate + +```text +at frame186: r += x +``` + +has valid entry frames, common-frame operands, and valid next frames for both +operands. The original frame79 read of x at this time would be a descent +from frame186 and is invalid. The new gate does not move x early. + +Delete A[230], replace A[1993] as above, and remove q from the physical stock. +Subtract one from every old identifier greater than 470. Keep the E8 geometry, +all other A gates, B, scatter and all copied totals, subject to that renaming. + +The rational frame check and the native legality checker give these paths: + +| Old register | Old path | New path | +|---|---|---| +| 77 | `[79,186,509,386,560,1]` | same | +| 444 | `[0,79,509,392,513,1]` | `[0,186,509,392,513,1]` | +| 470 | `[0,79,1]` | removed | + +Every other surviving register path is equal under the renaming. The complete +lists are in `FRAME-PATHS.json`. All 636 original frames remain in the catalogue. + +## 2. Dirty state and literal restoration + +The removed read used to add both `x_in` and `q_in` to r. The new read adds +`x_in`. Thus deletion changes a dirty-helper column; it is not a free scalar +substitution inside the old compensated word. + +Rebuild D from the exact map of A, scatter and B. D contains only frame-zero +helper-to-target operations. In this case the rebuilt D is exactly the old D +with its 55 q operands deleted and all other identifiers renamed. It changes +from 18,085 to 18,030 scalar ADDs. Every remaining helper contribution is paid. + +Rebuild C as the literal reversed list of all A/B operations that write a +source or helper, at the full frame. Reuse of the old C would not restore the +changed basis. C has 2,573 gates instead of 2,574. The original interleaved +checker verifies H1-H5 and the conclusions `U_block_form`, `J_identity`, +`C_is_U_inverse`, and `K_equals_D` on the changed word. + +The complete order is D, A, nine COPY/scatter/ERASE episodes, B, C, then all +required final MOVEs. Exact F2 replay returns every source and helper to its +initial value and maps each target `y_i` to `y_i + x_i` for every dirty column. +The source checker also verifies the punctured-line geometry and rank-seven +copied totals. No decoder change is used. + +Removing A[230] and its C inverse saves two ADDs. The compensation change saves +55 more. The total is 57. The independent literal emitter and the unchanged +native exporter produce the same record list for each complete word. + +The signed native inverse uses negated ADDs and the original unchanged center +for reverse COPY/ERASE blocks. The existing native checkers and parent checker +replay this inverse. The cancellation-free forward and reverse bounds remain +49,347 and 1,113,070. Their charged precision bounds remain 93 local bits and +177 nine-stage bits, within the inherited 104/192 allowances. + +## 3. Local recursive charges + +Deletion of q removes rank-one and rank-seven MOVEs. Moving r first to the +rank-two frame changes its first two increments from `(1,3)` to `(2,2)`. +No other path changes. Therefore the exact profile difference is + +```text +rank 1: -2; rank 2: +2; rank 3: -1; rank 7: -1. +``` + +The complete profiles are: + +| Child rank | R439 | R438 | +|---|---:|---:| +| 1 | 1323 | 1321 | +| 2 | 1342 | 1344 | +| 3 | 79 | 78 | +| 4 | 44 | 44 | +| 5 | 102 | 102 | +| 6 | 11 | 11 | +| 7 | 19 | 18 | + +The paid rank mass falls from 5,129 to 5,121. It still satisfies +`8R + 63 + 14v`, with `R=438` and `v=111`. Each local call saves two children. +This local result alone is insufficient: the removed helper occupied an idle +window, whose remaining child must grow. + +## 4. Hosting and returned idle rank + +Use the same nine-stage parent, four DATA pairs and 32 replicas. Expand the +original frozen hosting plan. For each stage remove the width-eight slot for +old helper index `470 - 222 = 248`. Group the remaining widths by idle window +and copy, rebuild the integer pattern counts, and run the original deterministic +expander for R438. No search or objective improvement is used. + +These are the nine deleted slots per replica. The last column is the old +idle remainder before the eight units are returned. + +| Idle window | DATA copy | Offset | Stage | Old remainder | +|---|---:|---:|---:|---:| +| 2 | 82 | 16 | 0 | 4 | +| 2 | 155 | 0 | 1 | 4 | +| 4 | 47 | 24 | 2 | 2 | +| 4 | 135 | 16 | 4 | 2 | +| 4 | 185 | 32 | 5 | 2 | +| 6 | 49 | 24 | 3 | 2 | +| 6 | 174 | 32 | 7 | 2 | +| 7 | 86 | 0 | 6 | 4 | +| 8 | 31 | 0 | 8 | 6 | + +The expander can rename or reorder retained helper placements when it groups +patterns. The emitted candidate, rather than the old placement names, is the +object of the full hosting audit. That audit checks all 126,144 residual roles, +actual source-owner windows, disjoint offsets, call orientation and restoration. +There are no banks. Live DATA and physical stock do not increase. + +Per replica, the old remainder histogram is +`{2:435, 4:444, 6:444, 7:666, 42:9}`. The new histogram is +`{2:430, 4:441, 6:443, 7:666, 10:5, 12:3, 14:1, 42:9}`. +The new idle children carry exactly 72 more rank units per replica. Across +32 replicas this returns all 2,304 units removed by the 288 local words. +The complete hosted rank mass is therefore unchanged at 1,808,352. + +The final paid child profile is: + +```text +{1:380448, 2:400832, 3:22464, 4:26784, 5:29376, + 6:17344, 7:26496, 10:160, 12:96, 14:32, 42:288} +``` + +It contains 904,320 children, including idle remainders, instead of 904,896. +The deficit remains `64*28416 - 1808352 = 10272`. The maximum child is 42. +The two-level condition remains `2*42^2 = 3528 < 4096 = 64^2`. + +## 5. Exact supplier invoice + +The unchanged inherited invoice charges the emitted ADDs, bridges, COPY/ERASE +operations, selectors, data access, restored helper stock, every recursive +child, and the signed prefix bound. Its precision fields are: + +```text +prefix: 177 bits, charged 192 +coefficient: 177 bits +two-level coefficient: 393 bits, charged 512 +row coefficient: 18355 +``` + +Two independent exact moment engines accept + +```text +c = 433544072119966441673 / 250000000000000000000000 +``` + +and reject the next `10^-24` grid point + +```text +1734176288479865766693 / 1000000000000000000000000. +``` + +These checks use the complete profile above and the inherited surcharge. They +do not infer a supplier gain from the local ADD reduction. The smaller selected +complex value still binds. The full-theorem assumptions listed in the README +remain open; this is a finite conditional supplier construction. diff --git a/research/bit-boundary-persistence/README.md b/research/bit-boundary-persistence/README.md new file mode 100644 index 0000000000..7a8d91df5d --- /dev/null +++ b/research/bit-boundary-persistence/README.md @@ -0,0 +1,127 @@ +# R438 bit supplier from a legal source boundary + +This finite construction removes one helper from the selected PR589 R439 bit +word. At one late read, source77 is still unchanged and is available at +frame186. Receiver444 can enter that frame before its next operation. +The word reads source77 directly, removes helper470, and rebuilds the literal +cleanup and dirty-target compensation. + +The complete nine-stage hosted invoice improves bit `c` from +`0.001733427039589844234749` to **`0.001734176288479865766692`**. +This package does not claim a new kappa. The selected PR942 complex value +`0.001664727258740678855772` is smaller than both bit values. The selected +conditional kappa remains `0.001661960547713947` at the research base. + +| Complete charge | PR589 R439 | This R438 word | +|---|---:|---:| +| Local helper registers | 439 | 438 | +| Local native ADDs, including D and C | 24,305 | 24,248 | +| Local native records | 27,234 | 27,175 | +| Local paid rank mass | 5,129 | 5,121 | +| Hosted residual roles, nine stages and 32 replicas | 126,432 | 126,144 | +| Paid recursive children, including idle remainders | 904,896 | 904,320 | +| Emitted local records across all 288 calls | 7,843,392 | 7,826,400 | +| Hosted paid rank mass | 1,808,352 | 1,808,352 | +| Live DATA / physical registers | 28,416 / 28,425 | 28,416 / 28,425 | +| Prefix bits / charged bits | 177 / 192 | 177 / 192 | +| Two-level coefficient bits / charged bits | 393 / 512 | 393 / 512 | + +The same upstream word is used on both sides. No local circuit saving from +another PR is included. The source path is unchanged. The only surviving +register whose path changes is receiver444: +`[0,79,509,392,513,1]` becomes `[0,186,509,392,513,1]`. +The removed helper had path `[0,79,1]`. + +## Reproduce + +Use Python 3.11 or later with NumPy, SymPy and SciPy, a C++17 compiler, and +Boost headers. These are the inherited native pipeline requirements. +From the repository root, run the following command. The output directory +must not exist. Set `BOOST_INCLUDE` if the headers are outside `/usr/include`. + +```sh +BOOST_INCLUDE=/opt/homebrew/include python3 -I -B research/bit-boundary-persistence/verify.py --output /tmp/r438-source-boundary +``` + +The last line is: + +```text +PASS_R438_SOURCE_BOUNDARY R=439->438 ADDs=24305->24248 paid_calls=904896->904320 c=0.001734176288479865766692 controls=6 no_new_kappa +``` + +The command uses one worker. It rebuilds both words, checks all source pins, +compiles and runs the original native checkers, emits both complete hosted +schedules, audits them, and computes both invoices. It compares the new +certificate with `CERTIFICATE.json`. It retains the generated words, native +records, schedules, exact receipts, command list and logs in the output +directory. It does not run a hosting search. + +`SOURCES.json` pins the two complete dependency packages and two selected +context records at base `8bddbee377e2f3ce1f1247196c4b290d55767d20`. +The packages include source notices and unused historical controls. The selected +bit head is `a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46` (PR589). +Regenerated words are compared by canonical JSON, not gzip container bytes. +`FRAME-PATHS.json` gives each physical register path in register order. + +The recorded run used macOS 26.6.1 arm64, Python 3.14.7, NumPy 2.5.4, +SymPy 1.14.0 and SciPy 1.18.1. The command records the compiler command and +Boost version-header hash in `RESULT.json`. Remote CI is not claimed. + +## Verification and scope + +The local checker covers every arbitrary dirty input column: 661 before the +change and 660 after it. The original checker accepts H1-H5, the interleaved +interface, all nine rank-seven copied totals, and the exact full-frame inverse. +An independent literal record builder agrees with the original exporter. +The native C++ checker covers 5, 9 and 11 stages on both words; all 96 omitted +bridge controls reject. Each nine-stage parent audit rejects 17 mutations. +Each whole-residual hosting audit rejects 16 mutations. + +Six new controls reject a changed source77, another carrier use, the late +source read in frame79, omitted restoration, omitted compensation, and a +missing returned idle charge. A neutral ADD pair passes and is charged twice. +The [proof](PROOF.md) gives the boundary and complete invoice derivation. + +The caller uses a compressed exact cover schedule. It does not enumerate the +astronomical address cover. The all-size bit/Gaussian compiler, common labels, +mutable-source realization, whole-call correlated-helper hosting, common grid, +tape, precision and analytic contracts remain inherited assumptions. Finite +checks do not prove the full multiplication theorem or a practical speedup. + +The inherited `assemble9.py` also checks its historical PR548 outer arithmetic +against a cited complex receipt. This is not a replay of the selected PR942 +complex construction or its full outer assembly. The selected record is only +used for the stated comparison. The eleven-stage native scalar check is run; +an eleven-stage hosted invoice is not claimed. + +## Relation to other work + +The initial candidate was to retain a helper basis between adjacent native +calls. The selected caller alternates the DATA roles and advances to other +hosted slices. A scalar cancellation does not establish a legal retained +source and owner boundary there. This package instead changes one intra-call +source access. It makes no repeated-call cancellation claim. + +[PR953](https://github.com/CrocSwap/integer-mult-bounds/pull/953) batches dyadic +queries with a shared unchanged source and target. It does not provide this +selected caller boundary. [PR997](https://github.com/CrocSwap/integer-mult-bounds/pull/997) +has a signed Hadamard recursive interface. Its batch is not composed here. +[PR980](https://github.com/CrocSwap/integer-mult-bounds/pull/980), head +`ba1cf68bef0c97dfb120add04304e2de0db6f29c`, retains R439 and all frame paths. +[PR1001](https://github.com/CrocSwap/integer-mult-bounds/pull/1001), head +`fbf54e6c95c47a3891eb7e8ed063b5198e920f3f`, changes B at frame506. This word +leaves B unchanged after register renaming and changes helper stock and a +source-access frame. Their savings are not added to this result. +[PR1015](https://github.com/CrocSwap/integer-mult-bounds/pull/1015), head +`7588c797f4a4e9f2b9fc663cfa6e35afcac05e06`, changes all ten phase-B blocks +and their literal cleanup. Its pinned `candidate_word` changes B and C only. +It retains R439, A, D and the paid recursive profile. This candidate changes +A, C, D, one path and R, while it preserves every B gate under renaming. +No composition of the two words is tested or claimed. + +The full-frame obstruction in PR827 fixes A/scatter/B. The closed class in +PR933 fixes the helper stock and cleanup structure. This construction changes +those restrictions. Source inlining and early helper retirement are prior +ideas; PR429/515 and PR433/437 contain related work. No general mechanism +priority, circuit optimum, or absence of other valid boundaries is claimed. +See [NOTICE.md](NOTICE.md) for contributor credit and AI disclosure. diff --git a/research/bit-boundary-persistence/SOURCES.json b/research/bit-boundary-persistence/SOURCES.json new file mode 100644 index 0000000000..644667dc62 --- /dev/null +++ b/research/bit-boundary-persistence/SOURCES.json @@ -0,0 +1,177 @@ +{ + "base_commit": "8bddbee377e2f3ce1f1247196c4b290d55767d20", + "files": { + "certificates/selected-result.json": "1d35283cb0ce3f8db1f285683933517f9e87475d295e2b6316399ad9928c81c3", + "research/community-frontier942-audit/ASSEMBLY.json": "4b2894956e594e408e111d806c842f2ed2c32aefcadff93fad69ff0b46f1991a", + "research/e8-bit-carrier-skeleton/EXPECTED.json": "3494ba83280cc86548fe0cc6695c50d23e6b6ffca85aeb1a33337c1196e280cb", + "research/e8-bit-carrier-skeleton/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/e8-bit-carrier-skeleton/MANIFEST.sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297", + "research/e8-bit-carrier-skeleton/NOTICE.md": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "research/e8-bit-carrier-skeleton/README.md": "e5212e8058c92a2b02cc12b4e174a65ce1cef7b4d7977ae770e64f5ff91b7204", + "research/e8-bit-carrier-skeleton/SOURCE-pr370.json": "03de1d341196cfa8cf1d39f3cc8648b25bb5f39c3c602a728cfbd089e8253ac0", + "research/e8-bit-carrier-skeleton/SOURCE-pr381.json": "16b1977240ca9acb58fa64572fb4231a423bc10bbf3e7bb30f1c8201fe369ba5", + "research/e8-bit-carrier-skeleton/SOURCE-pr386.json": "87c659ba932525631a40be14dca28a6a2efade8641f23bb08d6e1567fc991131", + "research/e8-bit-carrier-skeleton/SOURCE-pr436.json": "4a4f99f5bdb7530a0dcf9433f7f02afbf2abf908e718f7c63ffa5503d4f49693", + "research/e8-bit-carrier-skeleton/SOURCE-pr445.json": "e6f4a272442bb71ef68aaa3545b271236f9c99297e444fa01c62b0b5fb6a170f", + "research/e8-bit-carrier-skeleton/SOURCE-pr448.json": "c771fa9be492408a78d6d970c839e68c4dfd1b66f4f4a4748e3d12726a43cf27", + "research/e8-bit-carrier-skeleton/SOURCE-pr451.json": "a639956eec858341987a815b7464ef472505300db754b5f9ac012dd01d18c8df", + "research/e8-bit-carrier-skeleton/SOURCE-pr458.json": "cbdea984a46ab5de354b95e73fd76c1918fdc6676c658398a552772c4dc3dcaf", + "research/e8-bit-carrier-skeleton/SOURCE-pr471.json": "499d861e090c9e646d978dd67890a8e58a9ff6bf08512684e66605179132076b", + "research/e8-bit-carrier-skeleton/SOURCE-pr472.json": "6753bcf50c91806b75dd4dbe3963a79699a614d0dab8ce32b261cc3e76b288b1", + "research/e8-bit-carrier-skeleton/SOURCE-pr473.json": "2515c4f23dfa22a21913d92597669770f7f44c2a5b3ef069ef68a0c89779a656", + "research/e8-bit-carrier-skeleton/SOURCE-pr478.json": "9c7c4ea678865a955b0c89f0952927159976fdf55cadc6a488dec5757f03fe7d", + "research/e8-bit-carrier-skeleton/SOURCE-pr483.json": "24e3eab4a985e115adb7f8665a401423e9636e9f16cc4373ec68cc86950445a8", + "research/e8-bit-carrier-skeleton/SOURCE-pr484.json": "b92f43fbcba3921a1aa37bcb9f05cf5fa612ff708785e05512438a6317bf0867", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/bit/independent/checkword.py": "11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad", + "research/e8-bit-carrier-skeleton/code/bit/independent/interface.py": "2c63a039f97e3a11ce5a6b83302d4f5beda160c1db14164a5a9b0855aeb19d3c", + "research/e8-bit-carrier-skeleton/code/bit/independent/mutate.py": "0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d", + "research/e8-bit-carrier-skeleton/code/bit/independent/mutate_mut.py": "3b002c19a5dcca76a5594f2a30fac7c01d2b45fc96b3e7cfbfd8b720f5ffb4e8", + "research/e8-bit-carrier-skeleton/code/bit/independent/relax.py": "d6e9f58de3fa41f538516b6227c249d61fb30f0f6843027cc8a07a1a372fa6b6", + "research/e8-bit-carrier-skeleton/code/bit/mutate_records.py": "b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e", + "research/e8-bit-carrier-skeleton/code/bit/mutate_records_mut.py": "a9e085ec60d5657cd5d77832e3d95004e81b9f4f249d9e0fc95e345366cb2d2e", + "research/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "research/e8-bit-carrier-skeleton/code/cited.py": "a4c2dd4755f2a45ceda327b36d9ee400c2804893000626ca8ff3f6ee296fd842", + "research/e8-bit-carrier-skeleton/code/eleven/adapt.py": "d8a8c13b484d985f0133a5d06de4a78b8477314f922b9f693ba73640b7184d6b", + "research/e8-bit-carrier-skeleton/code/eleven/assemble.py": "c47889a606701ae592374dd82a13cee8c5a4e8449b7facfdad2d90563a30a18c", + "research/e8-bit-carrier-skeleton/code/eleven/audit.py": "5ad832830c19ec6c904d1b64480f6b1e71c5673fdd38d487d17e179b1d197c09", + "research/e8-bit-carrier-skeleton/code/eleven/emit.py": "b0b25955875625ed63f82690f83aef976e3e9a978ae6620b23a23fc1207acd46", + "research/e8-bit-carrier-skeleton/code/eleven/local_audit.py": "95275473d7f9811011bda760dd0f04de5169c2a6922456dc9a5725a5d671f941", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/assemble.py": "abb60c35e448e0f94073f38a0352d11249aaf7bb8dbd7352414ae60a1d2b79c3", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/audit.py": "d28062127a9b0d3866a3b79aad98a307233b20ebdb94cfb9f197d726b82ffea5", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/emit.py": "98d77cefbc3a76f9f10bd7df3a2590ab88b411f6afe77b5f8d73f1602eb2bef3", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/local_audit.py": "23eda3fe3d774e7f2dbf4dbdd4ff90d69ae7d1762ff95c8629cdc7667aa3fe71", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/hosting.json": "765382d4fefd594e94c8c5826ec6300422ce9f79c816d7f7323ef85e99320f28", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/residual-isometries.json": "750221cc66badd0ed0a74e7aad2d59f91f89c107370af21c6d929fbdd4a08a9f", + "research/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/word.json.gz": "b2af02f593cd161bea64e6cd793508386914136be519f80726c071697379d5a9", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/bank_routes.py": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/e8core.py": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/tile_m.py": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/residual-isometries.json": "e12ed7ddd13cee101ba74a083b54665fd64d0b122b0bad5b83d817dcc8bae9d8", + "research/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/word.json.gz": "d8d6d3d3f336720302bc40b3c1504fe3c3583a7a8d707bb9bd7b21f85e5e69c6", + "research/e8-bit-carrier-skeleton/code/hub/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/emit.py": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/geometry.py": "9554182d67e434ea84b4430f909a2c400abc755d8487b51454a8e6968e62859d", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/row_bound.py": "de4a9b9cd797e1a05da56f62cfe725c8728cea3a4aa031b7d1b0a68f869760d6", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/data/selection.json": "52dbbb68e8c147690d15eaa1d952df05d074b0c121885a4159d9f6732f391872", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/code/emit.py": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/residual-isometries.json": "b23fda74a7979179e8fd83ee9870c1e232442cc90c05077adaabfe31d050d1e4", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/selection.json": "4d9c2cf6a3d31a6faa287731e0721cb16601b0bc5c1a186b9645bfb5760ce8db", + "research/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/word.json.gz": "41626789888ee070e1b435fa380b10ab9b88e3cf7d8d8e166ecef17269bbcf47", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "research/e8-bit-carrier-skeleton/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "research/e8-bit-carrier-skeleton/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "research/e8-bit-carrier-skeleton/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/provenance.py": "e28fd87d0e34a6f6f6f1fddb6c4891deac220662c954de855d7aa5a7f9cceca4", + "research/e8-bit-carrier-skeleton/code/skeleton/e8.py": "721d859a6517d665ca84d03ef89668da3aae7433ffb0ee47faf37f2aeb85450e", + "research/e8-bit-carrier-skeleton/code/skeleton/gen.py": "7cdcf48078ed4beacd2e240aa8145e4aa6984558748d07659cb1b252786e073a", + "research/e8-bit-carrier-skeleton/code/skeleton/geom.py": "bb356568fa05e7bfd5fcd9012903611cf742729a99b4dc3a13685355b2678ae3", + "research/e8-bit-carrier-skeleton/code/skeleton/wordkit.py": "2b6c12d96f24a4e81f2c807827c2b74cf80037367fc8034e8c871dd5ce008351", + "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "research/e8-bit-carrier-skeleton/data/bit/bitE8mut-r489.json.gz": "835eb96e147740fc7454f8cfb3dbd34ae89524b1dbd89a61e9288eae8ab6a5b9", + "research/e8-bit-carrier-skeleton/data/complex-b.json": "dce3f4b76aa3f6c3ba826ce556ffa61398b33e81e4d1a226dd2a36ce684fb02e", + "research/e8-bit-carrier-skeleton/data/complex/pr448/EXPECTED.json": "18b42250c3faf6f0df76fcab6c3a483582192ad7bb09cb1985f4b0bb91d67024", + "research/e8-bit-carrier-skeleton/data/complex/pr458/EXPECTED.json": "a4312cb0c53c2066a28b683a971a41e7d76c5f6d828a96481c3ae7b3c01bb2f3", + "research/e8-bit-carrier-skeleton/data/complex/pr471/EXPECTED.json": "188f9d1a7450496dbfd8d64381febd20b0597141537eb1a003435297df2d1720", + "research/e8-bit-carrier-skeleton/data/complex/pr473/EXPECTED.json": "70e515f0a5a2f9508cd030d35a99f90981a6eccc027c9ad5a3c77f5860310910", + "research/e8-bit-carrier-skeleton/data/complex/pr478/EXPECTED.json": "07bd05d14c71df8925b0b03510b2b337334b73ac425a94e03b2ec34ed2680164", + "research/e8-bit-carrier-skeleton/data/complex/pr483/EXPECTED.json": "799fa4ab2f785c478c3cdcb6c1c0428a5ce6e3ddbe4a4b2fd88630d811a593f6", + "research/e8-bit-carrier-skeleton/data/complex/pr484/EXPECTED.json": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be", + "research/e8-bit-carrier-skeleton/data/eleven/hosting.json": "61f790657c465d16d3455f48f90f816797b9ea08bf02dbd0c90d2cf41836257e", + "research/e8-bit-carrier-skeleton/data/eleven/residual-isometries.json": "0fa5b353a0321af2ce4e2045db1d4c2d6418a11663894e2afcdb1eaa1984bddc", + "research/e8-bit-carrier-skeleton/data/skeleton/d4part-pairs.json": "d69ffe3326140bc541b8f1639e02db43a5835ab8ca02cc742b5bee2bf2ef1ba9", + "research/e8-bit-carrier-skeleton/data/skeleton/plan-skB.json": "f6162bb4d8092bc233700fa7ebc6a0d79f2893135aee18e998369044abb3f44b", + "research/e8-bit-carrier-skeleton/discovery/README.md": "b09aa45d5651720e10326cde559c863ba3ea45fe2fb6b4aaa3bfaa66a8fcf69f", + "research/e8-bit-carrier-skeleton/discovery/d4part.py": "a64927c340a4772ce0682b349e0c90c80d1a766000ccf397fb41b36a31929179", + "research/e8-bit-carrier-skeleton/discovery/host_select.py": "2aaaac18e083d289d4341e734c32571c89c51fefba04b388d407c7372b906dc7", + "research/e8-bit-carrier-skeleton/discovery/plan.py": "40e8dea1b4b71c5afd5993625f57bcac089dd2f72dfbc4dbc23ce917e5a61010", + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99", + "research/e8-bit-carrier-skeleton/requirements.txt": "6023d480f929cdfa4e2f35e361eea003451cd6695af806935a32038b0115abb5", + "research/e8-bit-carrier-skeleton/verify.sh": "0f9248aa3611dfe2b5d59dbe992c6f7d21a0cc4f1de2b5ed05a6110191191224", + "research/e8-bit-p111-tuned/DEPENDS.json": "fa9253078c444b8f4a57e849048f727c3c8233c3dc3c7f651bef2cf7bb0178c5", + "research/e8-bit-p111-tuned/EXPECTED.json": "7c2675fd49afd7e328606399a4421fd49c43fe8a6c5b57154cc908c00588abe2", + "research/e8-bit-p111-tuned/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/e8-bit-p111-tuned/MANIFEST.sha256": "8d8fc2625b71b835176b666385c69fa4d1e4c5839e8e601924db2c9261761310", + "research/e8-bit-p111-tuned/NOTICE.md": "5b88eb2b7de76aa2a3288ee3c7a08d18a5eadfa82f5e7a99e207d232aed71221", + "research/e8-bit-p111-tuned/README.md": "a054ce8453e2936d45c4edd1c3678993903fcf6705ac241b9f1a4c4f9accda2d", + "research/e8-bit-p111-tuned/SOURCE-pr510.json": "5e84c26ba837ce029acd1b5089e5533d2ebde793deede84215322112e95e06f8", + "research/e8-bit-p111-tuned/SOURCE-pr535.json": "74254fde5cff5580d5c199b139ff3ce31a3defded3f653a3ba83cf0c9204ddc4", + "research/e8-bit-p111-tuned/SOURCE-pr544.json": "9ae1cfa69158f678499510e9cf24396b2bdd9b68979e906cbb8d4ee29b63e0b9", + "research/e8-bit-p111-tuned/SOURCE-pr545.json": "4b868b05c092eb821b257eab0f429f7c502fde946dd6508e8f5161a8758b4904", + "research/e8-bit-p111-tuned/SOURCE-pr548.json": "4480cd4e1dd0dc2bf55c26a1ae4a8bbb8587a96cea3053687e5d4c874148043e", + "research/e8-bit-p111-tuned/code/adapt9p.py": "14365d0eb8f4a7352edd28816196148fd28d5bbcb36044ebeeb15ca051bca9de", + "research/e8-bit-p111-tuned/code/cited.py": "8f7852571a897e131cf964d4b7826dc7bb2b7a42e81892d436f8ea092b26ef7d", + "research/e8-bit-p111-tuned/code/gen_p3.py": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd", + "research/e8-bit-p111-tuned/code/mutants.py": "e2fd3429e2db4389ae8a5ab47dda89f551b0d0952c42fad5ac8d38a85d670594", + "research/e8-bit-p111-tuned/code/mutants_p.py": "ee2a2cfb44072a214dd29eae5b96a71b258ac886a05456b84d600de94b339591", + "research/e8-bit-p111-tuned/code/mutrec_b.py": "231cbf26bfe5e6824347e4556959941d8b4dea1efa06d7f88d7a73cca8b03158", + "research/e8-bit-p111-tuned/code/nodeopt.py": "6a5896f60b1fe05c41ab28ce822dff782c635e12d0c74fad20b5ce2a4010fa3f", + "research/e8-bit-p111-tuned/code/planio.py": "c0a687f61aed29455cea953d8a3e49a32136edb3cd4213c46880c146a6ca7fa3", + "research/e8-bit-p111-tuned/code/provenance.py": "aade757c1e4e2714207cbc80a9a60793d84b5f009de2cac79ee8d3239986fd2a", + "research/e8-bit-p111-tuned/code/pwordl.py": "6d8fccd44508e4705b6446e0a64482a5221a3efc5663c5ca7ae90d44581ac50a", + "research/e8-bit-p111-tuned/code/receipt_kappa.py": "6ac4cb3c6015bd46f3b0a88dfffce741d8942a703cc68738ad61953fae485e9e", + "research/e8-bit-p111-tuned/code/summary.py": "c7599cafe1a2330a2fc8a956dca457f802dbb8b04e4dc4ffa9d90890e5efb428", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/data/bitE8mut-p111.json.gz": "1bc3c53d4baf4927c6a00c339ea3975516471a48074d4d97c6addaded2a4d858", + "research/e8-bit-p111-tuned/data/complex-b.json": "96943a080f371392381c70676638c7b3281ffc44f96b50d7ab064f59aa9897c0", + "research/e8-bit-p111-tuned/data/complex/pr535/EXACT-ASSEMBLY-PR493.json": "3f4be566309841e00e842d5686f7937a355ae1a6a2eaa3ccb07bdf8a9ca604fb", + "research/e8-bit-p111-tuned/data/complex/pr535/EXPECTED.json": "cb734055c36681d38cf431a6926b7713351a94073cfba37d70a5384a9ef0d178", + "research/e8-bit-p111-tuned/data/complex/pr544/EXACT-ASSEMBLY.json": "eaacbe5a9b971b20f59503a5e948c1ba76c5e082f81a012c9cc7394494bc4db5", + "research/e8-bit-p111-tuned/data/complex/pr544/EXPECTED.json": "8f48531cb1ccc6c1fe7c80ba5990f8aea4278dbe9394bcc4d3f471a3e8d75f1c", + "research/e8-bit-p111-tuned/data/complex/pr548/EXACT-ASSEMBLY.json": "8c40d6a7907c2ba71284d4f29a2d6e6bbe4dfc5da92a6da1bbac13488b916349", + "research/e8-bit-p111-tuned/data/complex/pr548/EXPECTED.json": "2e458dd9880d001b63153e37ef7954c6bcfceae378ab4b225cfa1c94ea8e23ce", + "research/e8-bit-p111-tuned/data/hosting11-p111.json": "1f5a1142e0119483cabf9a4d99094d988014d1adaa29370e93f4b4a63d9bfd7f", + "research/e8-bit-p111-tuned/data/plan-l3.json": "d5c2494b4baae801143049e172db303b3c8e25a002e9d9715a1d79dcb2d74c58", + "research/e8-bit-p111-tuned/data/punct.json": "dd371e1d6fe57602f242920b582ec4c133efc8ede4a849fd701ac90b7f6e1853", + "research/e8-bit-p111-tuned/data/selection9-p111.json": "4ab1ed4529683cd184987f8bc3031fb7408b9cd22c25ab9cf541a8aaf896eaf1", + "research/e8-bit-p111-tuned/discovery/choose.py": "18d77e8f62ffc671b3b3d3e50626c03481a2eaf6fb4abbc131e08226feebc180", + "research/e8-bit-p111-tuned/discovery/search.py": "edd876212edf0db3f6620534dcf50b5d2c23197c2d5f8af8c030ed5bc8447923", + "research/e8-bit-p111-tuned/requirements.txt": "e11a6f5c2a40b77fbf54a31a4c45bac575e9d2f765d35b657406d5f088fd0664", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d", + "research/e8-bit-p111-tuned/tune/apply.py": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/e8-bit-p111-tuned/tune/fastc.py": "ae51f1fbb22b8c8dac8aab787c798361f6aa5d4e1fefb29e43d0197899d4eab5", + "research/e8-bit-p111-tuned/tune/moves.json": "a113933002239eb2dd32726bd572ba8ca41b5bce0d438327dd770754c8d5e0f4", + "research/e8-bit-p111-tuned/tune/summary.py": "24841f9f5b039f05cfa934295203c982faf181cf28b9b1a71e50d1a35dc723d0", + "research/e8-bit-p111-tuned/tune/tune.py": "bdaf632852c514b257bcb1b81004a942fc022ab876565b4e5f6ff5a038d323c2", + "research/e8-bit-p111-tuned/tune/verify.sh": "efb1051d3e2c6119574a29a8e4efbe316307b5901d05079d029e12fae9ff1fb1", + "research/e8-bit-p111-tuned/tune/wlib.py": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-dead-totals/data/bitE8mut-r480.json.gz": "92e399e9a486b55229b5624632ac54f800dd9e022f2aee97f1e5f264bbc0ef5c", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/EXPECTED.json": "883f7a1a84f31d9e4430e348bc8d9c1ec10210b206ff602dbe126349056af13d", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/adapt.py": "27b6b77cc4ebf439f9019e63a22dedc1ef72ee65fe120aad3d17316b1df06d7b", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/data/selection9-r480.json": "8176db518bed23ea8121543bfb18085ec6633064142ba40ac5db00f63b06553d", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_hosted_k.py": "57e558c80a2fea6e291587b04afd76dfaee3550729997798b61f33daf90b8ec9", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_parent_k.py": "374e1d983589463bbfa06b6e9f2ffafb9d2c14acf97b1f858593a3cef90e93d2", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/bank_routes_k.py": "ea678a7befda10c6f1b9dd38a36fe1437c6468472bd649f60b9f01522047e0bf", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/emit_k.py": "298b16c3d4f58a468ad1a64564c8500cb281414a3f3c0428fd467908eeb4a4b4", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/hosting_k.py": "081c3b95b18d900d97ce82af64fb428f085b6adc6d8ca93ea920797dad7eb81e", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/bank_routes.py": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/config.py": "283d7fad45155ee91e704d63ec947cf4a60aeff5cc43510bc0e835f7da7d8767", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/e8core.py": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/tile_m.py": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "research/e8-bit-p111-tuned/vendor/pr545/EXPECTED.json": "dd078d075b153ea2ed02a4bbd1fe467315930f4d7dc90f2c34cd2c33e06a5029", + "research/e8-bit-p111-tuned/vendor/pr545/code/adapt.py": "b9a50303147a3003ad94fc4b1a822d4fca7f9b9e917d165e3c45152575302a0e", + "research/e8-bit-p111-tuned/vendor/pr545/code/punct_cfg.py": "7cedd3416d6a8ce2e6393cea32dc1d11032190787a593a0ad964a0b62fc407f3", + "research/e8-bit-p111-tuned/vendor/pr545/data/bitE8mut-v111-r489.json.gz": "c78317ab05ea175dc380f4dce2bafdbcd7e8b46f0c9d6baf350c2f604bb3ae4e", + "research/e8-bit-p111-tuned/vendor/pr545/data/hosting-v111-r489.json": "862155e5c341053668ac1a18db05591417c38b9fe5f395d64a3b0a17a1502042", + "research/e8-bit-p111-tuned/verify.sh": "3bb8abf984e98fccf77914ae56d51eb60aab284db677905c1c4aafeacc44eee0" + }, + "scope": "Complete immutable dependency packages; some files supply context or source notices only.", + "selected_bit_head": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46" +} diff --git a/research/bit-boundary-persistence/build.py b/research/bit-boundary-persistence/build.py new file mode 100644 index 0000000000..074d045cf6 --- /dev/null +++ b/research/bit-boundary-persistence/build.py @@ -0,0 +1,201 @@ +"""Remove one carrier after checking its source and frame lifetime. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +""" +import copy +import gzip +import hashlib +import json +from collections import Counter +from fractions import Fraction + +WORD = 'research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz' +BASE = '8bddbee377e2f3ce1f1247196c4b290d55767d20' +HELPER, SOURCE, RECEIVER = 470, 77, 444 +BIRTH, READ, FRAME = 230, 1993, 186 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def load(path): + return json.loads(gzip.decompress(path.read_bytes())) + + +def save(path, word): + path.write_bytes(gzip.compress(canonical(word), mtime=0)) + + +def bits(mask): + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit + + +def rank(rows): + basis = {} + for values in rows: + row = list(map(Fraction, values)) + for pivot, old in sorted(basis.items()): + value = row[pivot] + row = [a - value * b for a, b in zip(row, old)] + pivot = next((i for i, x in enumerate(row) if x), None) + if pivot is not None: + value = row[pivot] + basis[pivot] = [x / value for x in row] + return len(basis) + + +def lifetime(word): + v = word['v'] + require(word['R'] == 439 and v == 111, 'Wrong source word dimensions') + require(word['A'][BIRTH] == [79, HELPER, [SOURCE]], 'Carrier birth changed') + require(word['A'][READ] == [79, RECEIVER, [HELPER]], 'Carrier read changed') + occurrences = [(phase, i) for phase in ('A', 'B') + for i, (_, dst, sources) in enumerate(word[phase]) + if HELPER in [dst, *sources]] + require(occurrences == [('A', BIRTH), ('A', READ)], 'Carrier has another live use') + require(HELPER not in word['ret'], 'Carrier is a retained copy source') + masks = [sum(1 << x for x in frame) for frame in word['frames']] + current = word['start'][:] + values = [1 << i for i in range(2 * v + word['R'])] + for frame, dst, sources in word['A'][:READ]: + for row in [dst, *sources]: + current[row] = frame + for source in sources: + values[dst] ^= values[source] + require(values[SOURCE] == 1 << SOURCE, 'Source changed before the late read') + require(values[HELPER] == (1 << SOURCE) ^ (1 << HELPER), 'Carrier contents changed') + require(current[SOURCE] == FRAME, 'Source boundary frame changed') + used = [SOURCE, RECEIVER] + before = {str(row): current[row] for row in used} + following = {} + for row in used: + next_frame = next(frame for frame, dst, sources in word['A'][READ + 1:] + word['B'] + if row in [dst, *sources]) + require(masks[current[row]] & ~masks[FRAME] == 0, 'Illegal source access frame') + require(masks[FRAME] & ~masks[next_frame] == 0, 'Illegal later frame') + following[str(row)] = next_frame + return {'birth': BIRTH, 'read': READ, 'helper': HELPER, 'source': SOURCE, + 'receiver': RECEIVER, 'new_frame': FRAME, 'before': before, + 'next_frame': following, 'source_unchanged': True, + 'retained_copy_uses': 0} + + +def rebuild_compensation(word): + v = word['v'] + count = 2 * v + word['R'] + values = [1 << i for i in range(count)] + for frame, dst, sources in word['A']: + for source in sources: + values[dst] ^= values[source] + copied = [values[row] for row in word['ret']] + for target, row in enumerate(word['scatter']): + for index in row: + values[v + target] ^= copied[index] + for frame, dst, sources in word['B']: + for source in sources: + values[dst] ^= values[source] + result = [] + for target in range(v): + residue = values[v + target] ^ (1 << (v + target)) ^ (1 << target) + require(residue & ((1 << (2 * v)) - 1) == 0, 'Raw DATA map changed') + if residue: + result.append([0, v + target, list(bits(residue))]) + return result + + +def build(word): + lifetime(word) + result = copy.deepcopy(word) + result['A'] = [[FRAME, RECEIVER, [SOURCE]] if i == READ else gate + for i, gate in enumerate(word['A']) if i != BIRTH] + result['C'] = [[1, dst, sources[:]] for _, dst, sources in reversed(result['A'] + result['B']) + if dst < word['v'] or dst >= 2 * word['v']] + remap = lambda row: row - (row > HELPER) + for phase in ('A', 'B', 'C'): + result[phase] = [[frame, remap(dst), [remap(row) for row in sources]] + for frame, dst, sources in result[phase]] + result['start'].pop(HELPER) + result['final'].pop(HELPER) + result['ret'] = [remap(row) for row in result['ret']] + result['R'] -= 1 + result['stats']['extra_carriers'] -= 1 + result['D'] = rebuild_compensation(result) + return result + + +def replay(word): + v = word['v'] + count = 2 * v + word['R'] + masks = [sum(1 << x for x in frame) for frame in word['frames']] + dimensions = [rank(word['lines'][i] for i in frame) for frame in word['frames']] + values = [1 << i for i in range(count)] + current = word['start'][:] + profile, paths, records = Counter(), [[frame] for frame in current], [] + def move(row, frame): + previous = current[row] + require(masks[previous] & ~masks[frame] == 0, 'Frame descent') + if previous != frame: + delta = dimensions[frame] - dimensions[previous] + require(delta > 0, 'Invalid frame change') + profile[delta] += 1 + records.append([0, row, previous, frame, delta, 0]) + current[row] = frame + paths[row].append(frame) + def gates(phase, number): + for frame, dst, sources in word[phase]: + require(len(set([dst, *sources])) == 1 + len(sources), 'Invalid ADD operands') + for row in [dst, *sources]: + move(row, frame) + for source in sources: + values[dst] ^= values[source] + records.append([1, dst, source, 1, frame, number]) + gates('D', 1) + gates('A', 2) + for index, row in enumerate(word['ret']): + frame = current[row] + profile[dimensions[frame]] += 1 + records.append([2, row, count, frame, 0, dimensions[frame]]) + for target, subset in enumerate(word['scatter']): + if index in subset: + require(current[v + target] == 0, 'Scatter target frame changed') + values[v + target] ^= values[row] + records.append([1, v + target, count, 1, 0, 3]) + records.append([3, row, count, frame, 0, 0]) + gates('B', 4) + gates('C', 5) + for row, frame in enumerate(word['final']): + move(row, frame) + expected = [((1 << i) ^ (1 << (i - v))) if v <= i < 2 * v else (1 << i) + for i in range(count)] + require(values == expected, 'Wrong arbitrary-dirty endpoint') + bounds = [] + for reverse in (False, True): + positive = [1] * count + [0] + maximum = 1 + for op, dst, src, coefficient, frame, phase in reversed(records) if reverse else records: + if op == 1: + positive[dst] += positive[src] + maximum = max(maximum, positive[dst]) + elif op == (3 if reverse else 2): + positive[count] = positive[dst] + maximum = max(maximum, positive[count]) + elif op == (2 if reverse else 3): + positive[count] = 0 + bounds.append(maximum) + local = 64 * bounds[0] ** 3 * bounds[1] ** 2 + nine = 2 ** 18 * bounds[0] ** 5 * bounds[1] ** 4 + return {'registers': count, 'helpers': word['R'], 'adds': sum(z[0] == 1 for z in records), + 'records': len(records), 'profile': dict(sorted(profile.items())), + 'rank_mass': sum(k * value for k, value in profile.items()), + 'copies': len(word['ret']), 'forward_bound': bounds[0], 'reverse_bound': bounds[1], + 'local_bits': local.bit_length(), 'nine_stage_bits': nine.bit_length(), + 'paths': paths, 'word_sha256': hashlib.sha256(canonical(word)).hexdigest()}, records diff --git a/research/bit-boundary-persistence/pipeline.py b/research/bit-boundary-persistence/pipeline.py new file mode 100644 index 0000000000..a2f6eb503f --- /dev/null +++ b/research/bit-boundary-persistence/pipeline.py @@ -0,0 +1,200 @@ +"""Run the complete native and hosted checks on both supplier words. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The exporters, adapters, checkers and invoice engines are unchanged. +""" +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import platform +import shlex +import shutil +import struct +import subprocess +import sys +from collections import Counter, defaultdict + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + return json.loads(path.read_text()) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def load_module(path): + spec = importlib.util.spec_from_file_location('boundary_hosting', path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def selection(root, out, template): + package = root / 'research/e8-bit-p111-tuned' + source = package / 'vendor/pr510/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py' + engine = load_module(source) + schedule = [] + for event in template['schedule']: + if event['kind'] == 'local_cover_sweep': + schedule.append(dict(kind='local', stage=event['stage'], pair=event['pair'])) + elif event['kind'] in ('bridge', 'idle'): + schedule.append(event) + # The parent assigns idle indices only during hosted emission. + next_index = 0 + for event in schedule: + if event['kind'] == 'idle': + event['idx'] = next_index + next_index += 1 + windows = {i: w for i, w in engine.windows(schedule).items() if w[1] and w[2]} + ys, zs, _ = engine.load_selection(package / 'data/selection9-p111.json', 'bit') + slots, old_remaining = engine.expand(windows, ys, zs, + {s: [(h, 8) for h in range(439)] for s in range(9)}, 222) + removed = [slot for slot in slots if slot[5] == 248] + need(len(removed) == 9 and {x[4] for x in removed} == set(range(9)), 'Missing deleted owner') + pieces = defaultdict(list) + stages = Counter() + for index, copy, offset, width, stage, helper in slots: + if helper != 248: + pieces[index, copy].append(width) + stages[index, width, stage] += 1 + patterns = Counter((index, tuple(sorted(pieces[index, copy], reverse=True))) + for index in windows for copy in range(222)) + proxy = sum(count * (engine.cost(windows[index][1], 64) + - engine.cost(windows[index][1] - sum(pattern), 64)) + for (index, pattern), count in patterns.items()) + path = out / 'candidate-selection.json' + engine.save_selection(path, 'bit', patterns, stages, proxy) + new_slots, new_remaining = engine.expand(windows, patterns, stages, + {s: [(h, 8) for h in range(438)] for s in range(9)}, 222) + need(len(new_slots) == 9 * 438, 'Wrong hosted helper count') + need(sum(new_remaining.values()) - sum(old_remaining.values()) == 72, + 'Deleted residuals were not charged to idle children') + need(max(new_remaining.values()) == 42, 'Maximum child changed') + return {'removed_slots': removed, 'old_remainders': dict(Counter(old_remaining.values())), + 'new_remainders': dict(Counter(new_remaining.values())), + 'returned_idle_rank_per_replica': 72, 'hosted_helpers_per_replica': len(new_slots)} + + +def run(root, out, words, local_receipts, literal_records): + out.mkdir(parents=True, exist_ok=False) + predecessor = root / 'research/e8-bit-carrier-skeleton' + package = root / 'research/e8-bit-p111-tuned' + bit = predecessor / 'code/bit' + price = package / 'vendor/pr510/e8-r480-nine-stage' + code = price / 'vendor/e8-r715-eleven-stage-whole/code' + python = [sys.executable, '-E', '-s', '-B'] + commands = [] + environment = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', OMP_NUM_THREADS='1', + OPENBLAS_NUM_THREADS='1', MKL_NUM_THREADS='1', VECLIB_MAXIMUM_THREADS='1') + + def call(name, command): + command = list(map(str, command)) + print('RUN', name, flush=True) + commands.append({'name': name, 'command': command}) + with (out / (name + '.log')).open('w') as log: + result = subprocess.run(command, stdout=log, stderr=subprocess.STDOUT, env=environment) + write(out / 'COMMANDS.json', commands) + need(result.returncode == 0, 'Command failed: ' + str(out / (name + '.log'))) + + compiler = shlex.split(os.environ.get('CXX', 'c++')) + boost = Path(os.environ.get('BOOST_INCLUDE', '/usr/include')) + flags = ['-O2', '-std=c++17', '-DHDIM=8', '-DNCOPY=9', '-DVPORTS=111', + '-I' + str(bit / 'checkers'), '-I' + str(boost), + '-I' + str(predecessor / 'portable-include')] + binaries = out / 'bin' + binaries.mkdir() + call('compile-legality', compiler + flags + [bit / 'checkers/legality_h.cpp', '-o', binaries / 'legality']) + summary = {} + for name in ('baseline', 'candidate'): + base = out / name + base.mkdir() + word = out / (name + '.json.gz') + word.write_bytes(words[name].read_bytes()) + call(name + '-interface', python + [package / 'code/xcheck_p.py', word, '--json', base / 'interface.json']) + call(name + '-export', python + [bit / 'export_records.py', word, base / 'records']) + records = list(struct.iter_unpack('<6i', (base / 'records/249-records.bin').read_bytes())) + need(records == [tuple(row) for row in literal_records[name]], 'Independent record export differs') + call(name + '-stage', python + [bit / 'regression/stage_cohort.py', + base / 'records', base / 'records', base / 'cin', base / 'cout']) + call(name + '-legality', [binaries / 'legality', base / 'cin', base / 'cout', base / 'cout/legality.json']) + call(name + '-gram', python + [bit / 'checkers/gram_frames.py', base / 'records', '--gram', 'e8ham', '--h', '8', '--positive']) + local = local_receipts[name] + legality = read(base / 'cout/legality.json') + need(legality['common_frame_ADDs'] == local['adds'] and legality['rank_mass'] == local['rank_mass'], + 'Native legality disagrees') + columns = {} + for k in (2, 4, 5): + executable = binaries / (name + '-columns' + str(k)) + call(name + '-compile-' + str(k), compiler + flags + ['-DRHELP=' + str(local['helpers']), + '-DKPAIRS=' + str(k), bit / 'checkers/columns_k.cpp', '-o', executable]) + receipt = base / 'cout' / ('columns_k' + str(k) + '.json') + call(name + '-columns-' + str(k), [executable, base / 'cout/COHORT249-RECORDS.bin', receipt]) + result = read(receipt) + need(result['formal_columns_checked'] == 2 * k * 111 + local['helpers'], 'Native coverage changed') + need(len(result['negative_controls']) == 6 * (k - 1) + and all(x['rejected'] for x in result['negative_controls']), 'A bridge control failed') + need(result['local_scalar_additions'] == local['adds'], 'Native ADD price differs') + result.pop('seconds', None) + result.pop('local_scalar_stream', None) + columns[str(2 * k + 1)] = result + shutil.copy2(base / 'cout/columns_k2.json', base / 'cout/columns.json') + summary[name] = {'interface': read(base / 'interface.json'), 'legality': legality, 'columns': columns} + + call('parameterize-geometry', python + [package / 'vendor/pr545/code/adapt.py', predecessor, + out / 'baseline.json.gz', out / 'geometry-adapter']) + call('geometry', python + [out / 'geometry-adapter/nine_geometry.py', '--source', predecessor, + '--out', out / 'geometry', '--word', out / 'baseline.json.gz']) + call('parent-audit-adapter', python + [price / 'code/adapt.py', code, out / 'adapted']) + call('parameterize-supplier', python + [package / 'code/adapt9p.py', code, price / 'code', + out / 'adapted/audit_parent_k.py', out / 'a9p']) + assembly_root = out / 'assembly-root' + (assembly_root / 'data').mkdir(parents=True) + (assembly_root / 'code').symlink_to(predecessor / 'code', target_is_directory=True) + shutil.copy2(package / 'data/complex-b.json', assembly_root / 'data/complex-b.json') + hosting_receipt = None + for name in ('baseline', 'candidate'): + base = out / name + parent = base / 'nine' + parent.mkdir() + shutil.copy2(out / 'geometry/GEOMETRY.json', parent / 'GEOMETRY.json') + word = out / (name + '.json.gz') + call(name + '-parent', python + [out / 'a9p/global_k.py', '--word', word, + '--local-check', base, '--out', parent, '--isometries', predecessor / 'data/eleven/residual-isometries.json']) + call(name + '-parent-audit', python + [out / 'a9p/audit_parent_k.py', '--word', word, + '--local-check', base, '--out', parent]) + if name == 'baseline': + import gzip + template = json.loads(gzip.decompress((parent / 'GLOBAL-TEMPLATE.json.gz').read_bytes())) + hosting_receipt = selection(root, out, template) + plan = package / 'data/selection9-p111.json' + else: + plan = out / 'candidate-selection.json' + hosted = base / 'hosted' + call(name + '-hosted', python + [out / 'a9p/emit_k.py', parent, base, hosted, '--selection', plan, '--key', 'bit']) + call(name + '-hosted-audit', python + [out / 'a9p/audit_hosted_k.py', base, hosted, hosted / 'AUDIT.json']) + call(name + '-invoice', python + [out / 'a9p/assemble9.py', base, hosted, hosted / 'AUDIT.json', + assembly_root, base / 'PRICE.json', 'pr548']) + pg = read(parent / 'GLOBAL.json') + audit = read(hosted / 'AUDIT.json') + invoice = read(base / 'PRICE.json') + parent_audit = read(parent / 'AUDIT.json') + need(audit['hosted_residuals'] == 9 * 32 * local_receipts[name]['helpers'] + and audit['bank_assignments'] == 0, 'Whole residual hosting failed') + need(len(parent_audit['mutations_rejected']) == 17 and len(audit['mutations_rejected']) == 16, + 'Inherited audit coverage changed') + for item in (audit, pg, parent_audit): + item.pop('seconds', None) + summary[name]['hosted'] = {'parent': pg, 'parent_audit': parent_audit, 'audit': audit, 'invoice': invoice} + summary['hosting_change'] = hosting_receipt + summary['environment'] = {'python': sys.version, 'platform': platform.platform(), 'compiler': compiler, + 'boost_version_sha256': hashlib.sha256((boost / 'boost/version.hpp').read_bytes()).hexdigest()} + write(out / 'RESULT.json', summary) + return summary diff --git a/research/bit-boundary-persistence/verify.py b/research/bit-boundary-persistence/verify.py new file mode 100644 index 0000000000..8da708efb7 --- /dev/null +++ b/research/bit-boundary-persistence/verify.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Verify the source boundary, complete native words and hosted invoice. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import copy +import hashlib +import importlib.util +import json +from collections import Counter +from fractions import Fraction +from pathlib import Path +import tempfile + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parent.parent + + +def module(name): + spec = importlib.util.spec_from_file_location(name, PACKAGE / (name + '.py')) + value = importlib.util.module_from_spec(spec) + spec.loader.exec_module(value) + return value + + +build = module('build') +pipeline = module('pipeline') + + +def digest(value): + return hashlib.sha256(build.canonical(value)).hexdigest() + + +def boundary(word, local): + receipt = build.lifetime(word) + old, new = (local[name]['paths'] for name in ('baseline', 'candidate')) + changes = {} + for row, path in enumerate(old): + if row != build.HELPER and path != new[row - (row > build.HELPER)]: + changes[str(row)] = [path, new[row - (row > build.HELPER)]] + build.require(changes == {'444': [[0, 79, 509, 392, 513, 1], + [0, 186, 509, 392, 513, 1]]}, + 'Another surviving frame path changed') + receipt.update(changed_surviving_paths=changes, removed_path=old[build.HELPER], + source_path=old[build.SOURCE], + frames={str(f): {'lines': word['frames'][f], + 'rank': build.rank(word['lines'][i] for i in word['frames'][f])} + for f in (79, 186, 509)}, + all_paths_sha256=digest({'baseline': old, 'candidate': new})) + return receipt + + +def local_controls(original, candidate): + controls = [] + + def reject(name, action, reason): + try: + action() + except ValueError as error: + build.require(str(error) == reason, 'Control failed for another reason: ' + name) + controls.append({'name': name, 'rejection': reason}) + else: + raise ValueError('Control was accepted: ' + name) + + changed = copy.deepcopy(original) + changed['A'][426] = [186, 77, [292]] + reject('source77_changed_before_read', lambda: build.lifetime(changed), + 'Source changed before the late read') + changed = copy.deepcopy(original) + changed['A'][build.READ + 2][2].append(build.HELPER) + reject('another_live_carrier_use', lambda: build.lifetime(changed), + 'Carrier has another live use') + changed = copy.deepcopy(candidate) + changed['A'][build.READ - 1][0] = 79 + reject('late_source_read_in_old_line_frame', lambda: build.replay(changed), 'Frame descent') + changed = copy.deepcopy(candidate) + changed['C'].pop(0) + reject('omitted_literal_restoration', lambda: build.replay(changed), 'Wrong arbitrary-dirty endpoint') + changed = copy.deepcopy(candidate) + changed['D'][0][2].pop(0) + reject('omitted_dirty_target_compensation', lambda: build.replay(changed), 'Wrong arbitrary-dirty endpoint') + # A neutral pair is legal, but both native ADDs must be paid. + changed = copy.deepcopy(candidate) + duplicate = [0, changed['D'][0][1], [changed['D'][0][2][0]]] + changed['D'][0:0] = [copy.deepcopy(duplicate), duplicate] + positive, _ = build.replay(changed) + clean, _ = build.replay(candidate) + build.require(positive['adds'] == clean['adds'] + 2 and positive['profile'] == clean['profile'], + 'Neutral paid ADD pair was not accepted and charged') + return {'rejected': controls, 'accepted_paid_neutral_pair': {'extra_adds': 2, 'same_profile': True}} + + +def check_hosted_change(result, local): + change = result['hosting_change'] + actual = {} + for name in ('baseline', 'candidate'): + audit = result[name]['hosted']['audit'] + profile = {int(rank): count for rank, count in audit['profile'].items()} + build.require(sum(rank * count for rank, count in profile.items()) + == 64 * audit['live'] - audit['deficit'], 'Wrong hosted rank mass') + actual[name] = Counter(profile) + expected = actual['baseline'].copy() + for sign, name in ((-1, 'baseline'), (1, 'candidate')): + for rank, count in local[name]['profile'].items(): + expected[int(rank)] += sign * 288 * count + for sign, key in ((-1, 'old_remainders'), (1, 'new_remainders')): + for rank, count in change[key].items(): + expected[int(rank)] += sign * 32 * count + build.require(+expected == +actual['candidate'], 'Hosted profile differs from the complete recount') + build.require(sum(actual['baseline'].values()) - sum(actual['candidate'].values()) == 576, + 'Wrong paid recursive call saving') + return {'paid_calls': {name: sum(profile.values()) for name, profile in actual.items()}, + 'saved_calls': 576, 'returned_idle_rank': 32 * change['returned_idle_rank_per_replica']} + + +def idle_control(result, local): + changed = copy.deepcopy(result) + profile = changed['candidate']['hosted']['audit']['profile'] + delta = Counter() + for sign, key in ((-1, 'old_remainders'), (1, 'new_remainders')): + for rank, count in result['hosting_change'][key].items(): + delta[str(rank)] += sign * 32 * count + for rank, count in delta.items(): + profile[rank] = profile.get(rank, 0) - count + try: + check_hosted_change(changed, local) + except ValueError as error: + build.require(str(error) == 'Wrong hosted rank mass', 'Idle control failed for another reason') + return {'name': 'deleted_helper_without_returned_idle_charge', 'rejection': str(error)} + raise ValueError('Omitted idle charge was accepted') + + +def certificate(original, local, result, selected): + boundary_receipt = boundary(original, local) + controls = local_controls(original, build.build(original)) + controls['rejected'].append(idle_control(result, local)) + hosted = {} + for name in ('baseline', 'candidate'): + section = result[name]['hosted'] + # Container hashes and running times are not mathematical outputs. + audit = {key: value for key, value in section['audit'].items() + if key not in ('template_sha256', 'seconds')} + parent = section['parent'] + parent_keys = ('all_scalar_columns_restored', 'bridge_additions', 'copy_erase_episodes', + 'halving_integer_inequality', 'independent_unbanked_scalar_columns', + 'local_checks', 'local_invocations', 'scalar_stages', 'omitted_bridge_shears_rejected') + invoice = {key: value for key, value in section['invoice'].items() if key != 'kappa'} + hosted[name] = {'audit': audit, 'invoice': invoice, + 'parent': {key: parent[key] for key in parent_keys}, + 'parent_controls': section['parent_audit']['mutations_rejected']} + old_c = Fraction(hosted['baseline']['invoice']['bit_lower']) + new_c = Fraction(hosted['candidate']['invoice']['bit_lower']) + build.require(old_c == Fraction(selected['bit_lower']) and new_c > old_c > Fraction(selected['complex_lower']), + 'Selected supplier comparison changed') + return {'status': 'PASS_R438_SOURCE_BOUNDARY_AND_FULL_HOSTED_INVOICE', + 'base_commit': build.BASE, 'boundary': boundary_receipt, + 'local': {name: {key: value for key, value in item.items() if key != 'paths'} + for name, item in local.items()}, + 'native': {name: {key: result[name][key] for key in ('interface', 'legality', 'columns')} + for name in ('baseline', 'candidate')}, + 'hosting_change': result['hosting_change'], 'hosted': hosted, + 'paid_recount': check_hosted_change(result, local), 'controls': controls, + 'selected_context': {key: selected[key] for key in ('kappa', 'complex_lower', 'bit_lower', 'binding')}, + 'no_new_kappa': True} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', type=Path, required=True, help='New directory for the full replay') + args = parser.parse_args() + out = args.output.resolve() + build.require(not out.exists(), 'Output directory already exists') + manifest = pipeline.read(PACKAGE / 'SOURCES.json') + build.require(manifest['base_commit'] == build.BASE, 'Wrong source base') + for name, expected in manifest['files'].items(): + build.require(hashlib.sha256((ROOT / name).read_bytes()).hexdigest() == expected, + 'Source hash mismatch: ' + name) + original = build.load(ROOT / build.WORD) + candidate = build.build(original) + receipts, records = {}, {} + for name, word in (('baseline', original), ('candidate', candidate)): + receipts[name], records[name] = build.replay(word) + paths = {name: receipt['paths'] for name, receipt in receipts.items()} + build.require(paths == pipeline.read(PACKAGE / 'FRAME-PATHS.json'), 'Stored frame paths differ') + expected = pipeline.read(PACKAGE / 'CERTIFICATE.json') + for name in ('baseline', 'candidate'): + build.require(receipts[name]['word_sha256'] == expected['local'][name]['word_sha256'], + 'Constructed word differs from the certificate') + with tempfile.TemporaryDirectory(prefix='bit-boundary-') as temporary: + word_file = Path(temporary) / 'candidate.json.gz' + build.save(word_file, candidate) + result = pipeline.run(ROOT, out, {'baseline': ROOT / build.WORD, 'candidate': word_file}, receipts, records) + selected = pipeline.read(ROOT / 'research/community-frontier942-audit/ASSEMBLY.json') + observed = certificate(original, receipts, result, selected) + pipeline.write(out / 'CERTIFICATE.json', observed) + pipeline.write(out / 'FRAME-PATHS.json', paths) + # Compare JSON objects so histogram keys have the same string type. + build.require(build.canonical(pipeline.read(out / 'CERTIFICATE.json')) == build.canonical(expected), + 'Full certificate differs') + print('PASS_R438_SOURCE_BOUNDARY R=439->438 ADDs=24305->24248 ' + 'paid_calls=904896->904320 c=0.001734176288479865766692 controls=6 no_new_kappa') + + +if __name__ == '__main__': + main()