diff --git a/.github/workflows/multicut-kernel-composition.yml b/.github/workflows/multicut-kernel-composition.yml new file mode 100644 index 0000000000..5f14233f85 --- /dev/null +++ b/.github/workflows/multicut-kernel-composition.yml @@ -0,0 +1,32 @@ +name: multicut-kernel-composition + +on: + pull_request: + paths: + - 'research/multicut-kernel-composition/**' + - '.github/workflows/multicut-kernel-composition.yml' + push: + paths: + - 'research/multicut-kernel-composition/**' + - '.github/workflows/multicut-kernel-composition.yml' + +jobs: + verify: + runs-on: ubuntu-latest + timeout-minutes: 40 + strategy: + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install the native toolchain of PR 259's checkers + run: sudo apt-get update && sudo apt-get install -y g++ libboost-dev + - name: Install SymPy for the pinned upstream regeneration + run: python -m pip install -r research/multicut-kernel-composition/requirements.txt + - name: Regenerate PR 249's word, compile and run the seven checkers on the 883-pivot selection, compare receipts and price + run: python3 -I research/multicut-kernel-composition/verify.py --output /tmp/mkc-replay + - name: Require an unchanged tree + run: git diff --exit-code diff --git a/research/multicut-kernel-composition/BANK-PROOF.md b/research/multicut-kernel-composition/BANK-PROOF.md new file mode 100644 index 0000000000..f55c29d206 --- /dev/null +++ b/research/multicut-kernel-composition/BANK-PROOF.md @@ -0,0 +1,61 @@ +# General residual-bank construction for response-kernel entrances + +## Sufficient construction + +Suppose a literal scalar word has been independently checked to restore all arbitrary helper values and has no final data/helper block. Suppose it uses the inherited nested-frame address compiler, and each newly changed helper has initial nondegenerate frame E of dimension d and final frame I24. The changed helper then has actual residual partial swap D_P with P=I-sigma_E; this is an inherited compiler conclusion, not a conclusion of rank counting. Assume the old frame admissions remain unchanged. + +For the present pinned PR249 family, all newly changed helpers previously belonged to the zero-entrance rank24 residual family. There are 14,287 such helpers before new changes. The unchanged nonfull families are 2,200 rank4,22 rank6,5 rank7,48 rank11,23 rank12,2 rank15 helpers. All occur in40 replicas and5 stages. + +Let S be the sum of dimensions of the new entrances, m the number of changed helpers. If S is divisible by3, and the required rank4 filler does not exceed84,930 blocks per stage, there is an explicit complete stage-private bank allocation with + + banks_per_stage =117563-S/3, + literal_stock =869415-5S/3, + normalized_stock =173883-S/3. + +For each new helper of residual rank r=24-d, make ten banks containing four of its rank-r replica blocks and30-r existing rank4 blocks. Each bank has width4r+4(30-r)=120; all40 replicas are assigned. The filler consumption per changed helper is10(6+d). Keep the inherited rank11/rank4, rank7/rank4, rank6,rank12,andrank15 patterns; distribute the remaining rank4 blocks into pure30-block banks and unchanged rank24 blocks into pure5-block banks. All helper identities and intervals are explicitly enumerated. This is sufficient for arbitrary selected changed roles subject to the stated numerical conditions; it is not restricted to pair kernels. + +## Exact charts establish the actual projectors + +The checker constructs every new chart from the supplied basis U, not from its dimension. Put G=I-J/9, H=U G U^T. Compute a rational row basis V of ker(U G), and set B=[V^T | U^T]. Then B is invertible exactly when E is nondegenerate. Its first24-d columns span the actual G-orthogonal complement. The checker constructs the actual projector + + sigma=U^T H^-1 U G + +and checks B^-1(I-sigma)B=diag(I_(24-d),0_d), both inverse products, and U G V^T=0. It emits B and B^-1, exact determinants, and elementary row-operation counts. Every elimination pivot and intermediate coefficient is checked to have numerator and denominator of magnitude below2^80. Thus every relevant nonzero divisor is a unit at each admitted prime q>2^80, including over all inherited Z/q^w. The proof does not infer an orthogonal chart from dimension alone. + +For each assigned block b in stage i, use the inherited literal normalizer + + N_b=(b+1) Pi_b embed_i(B^-1), + +where Pi_b sends the first residual coordinates in the stage window to the assigned interval and matches ordered complements bijectively. The resulting conjugate of the actual projector is precisely the assigned coordinate projector. The unchanged old-chart factor ceiling548 remains valid if each checked new chart has at most548 factors; permutation/scaling retain the total787 bound. + +Distinct blocks in one bank have distinct route keys on a coordinate outside the current24-coordinate stage window. The embedded chart inverse fixes that coordinate. If the two permutations send it to different coordinates, the keys are distinct; if they send it to the same coordinate, the unequal scalars b+1 distinguish them. The scalars and their differences are units because their magnitudes are at most30 and q>2^80. Use the inherited full GL-cover route d*tau_i*N_b^-1; this argument does not justify replacing it by a projective quotient or removing its gates. + +## Completion and finite cost + +Complete each stage/replica cover sweep before proceeding. All assigned coordinate projectors in a bank annihilate each other and sum to I120. Their dirty partial swaps therefore compose to the full bank swap; arbitrary initial correlations are allowed. The checker independently executes all240 address basis columns in both orders for each distinct layout, and checks that each single-block omission or repetition fails on exactly twice that block's rank. + +The full explicit assignment has3,317,400 helper/replica/stage entries. For literal stock W the inherited conservative selector charge is + + 2*5*40*((W-1)+16587*120*787). + +The literal scalar word, its integer coefficient bill, global formal columns, and the47 strict pricing inequalities require their separate verifiers. This bank result does not delete actual scalar gates or certify an exponent by itself. + +## Current results + +Regression on the checked132 pair entrances reproduces W=869195,173839 normalized stock,and selector626938189600. The generic checker constructs all132 charts with at most30 factors and exact intermediate numerator/denominator bound4. + +Preflight for132 pairs and seven selected triples (dimensions4,3,9,9,9,12,14) gives S=192,139 charts,W=869095,173819 normalized stock,selector626938149600. Maximum chart cost144; every intermediate numerator and denominator has magnitude at most15. All assignments and6,240 endpoint columns plus6,240 nonzero control columns pass. This preflight installs the proposed initial frames synthetically. Re-run against the root worker's literal transformed word outputs before treating it as source-bound composition. + +No standalone kappa improvement or Lean certification is claimed here. + +## Source-bound collective result + +The actual collective156 outputs now pass the generic bank checker:156 actual charts, total entrance rank327, literal stock868870, normalized stock173774, selector626938059600. All3,317,400 helper/replica/stage assignments pass, as do6,720 endpoint and6,720 nonzero control columns. Every new chart uses at most156 factors and every exact intermediate numerator/denominator is at most135, preserving the inherited548/787 ceilings and2^80 prime guard. See `collective156/BANK-REVIEW.json` and `collective156/BANK-CHARTS.json`; `collective156/SOURCE-BINDING.json` binds the actual parent word and verifier inputs. + +## Source-bound pooled result + +The actual pooled word passes with252 charts and entrance rank1047. Literal stock867670; normalized stock173534; selector626937579600. Its largest chart costs200 factors; all rational intermediate numerators/denominators are at most704. All3,317,400 assignments and10,560 forward/backward endpoint columns plus10,560 nonzero controls pass. The inherited548/787 factor ceilings and2^80 prime guard are unchanged. `pooled/SOURCE-BINDING.json` pins the concrete input word and bank receipts. The original pre-admission fundamental word is superseded because it included singular frames. + +## Source-bound multiple-checkpoint result + +The actual multicut word passes with518 charts and entrance rank1344. Literal stock867175; normalized stock173435; selector626937381600. Largest chart200 factors; all exact intermediate numerators/denominators<=704. All3,317,400 assignments and10,560 endpoint columns plus10,560 nonzero controls pass. Banks depend on actual initial/final frames, so using different verified scalar checkpoint positions introduces no additional bank geometry obligation. The scalar word and global columns remain separate checks. See `multicut/SOURCE-BINDING.json`. diff --git a/research/multicut-kernel-composition/COPY-PROOF.md b/research/multicut-kernel-composition/COPY-PROOF.md new file mode 100644 index 0000000000..e771dfc027 --- /dev/null +++ b/research/multicut-kernel-composition/COPY-PROOF.md @@ -0,0 +1,7 @@ +# Copy-source lifetime + +A copy block copies a source, reads the copy as needed, and discards the copy when it again agrees with the source. The source must stay unchanged during the block. Reversing the block then creates the copy from that same source at the reverse entry and undoes the intervening gates. A source need not be globally excluded from a basis rewrite whose operations occur outside the block. + +Two selected helpers, streams 10233 and 10257, are sources of copy blocks. Both are kernel pivots. A square-zero donor += pivot basis shear never writes its pivot. The old blanket audit ban on selecting a COPY source was consequently stronger than necessary. The independent arbitrary-precision chronological checker verifies that no scalar gate writes the original source while any COPY/ERASE window is open, checks both endpoint frames and all temporary lifetimes, and requires all 24 windows to close. The actual full word is additionally checked on every arbitrary input column, forward and inverse. + +This replaces a conservative syntactic exclusion with the precise sufficient lifetime condition. It does not remove a required check or infer correctness from matching histograms. diff --git a/research/multicut-kernel-composition/FINITE-PROOF.md b/research/multicut-kernel-composition/FINITE-PROOF.md new file mode 100644 index 0000000000..9861e4f6f3 --- /dev/null +++ b/research/multicut-kernel-composition/FINITE-PROOF.md @@ -0,0 +1,9 @@ +# Finite invoice + +The pinned public routing, prime, recovery and analytic interfaces remain inherited. Every new chart is explicitly inverted and its residual projector identity checked; all intermediate rational coefficients and pivots are bounded by 704, below the retained prime guard. The maximum 200 factors remains below the inherited 548 chart and 787 normalizer bounds. + +The native finite-invoice checker rebuilds the complete histogram from the emitted word, scales through 40 replicas and five stages, and checks it against the exact pricing histogram. The literal stock is 867175 and the normalized stock is 173435. The endpoint deficit remains 176000 in literal units. All scalar gates, COPYs, routes, new selector factors and the rare-class fallback are charged. + +The full selector charge is 626937381600. The counted primitive coefficient is 62639910650427201 (56 bits). The cancellation-free signed prefix bound gives a 98-bit payload bound, below the inherited 104-bit guard. Positive finite cutoff witnesses and all 47 outer inequalities are checked exactly; the general cutoff formula explicitly allows inherited constants above the counted coefficient. + +See expected/COHORT-FINITE-INVOICE.json and code/cohort-finite-invoice.cpp. Neither this checker nor the saved expected receipts prove the retained all-size foundations. The top-level verifier executes all components and compares their fresh outputs. diff --git a/research/multicut-kernel-composition/KERNEL-PROOF.md b/research/multicut-kernel-composition/KERNEL-PROOF.md new file mode 100644 index 0000000000..2256294539 --- /dev/null +++ b/research/multicut-kernel-composition/KERNEL-PROOF.md @@ -0,0 +1,31 @@ +# Collective response-kernel condensation: sufficient rewrite + +Fix a checkpoint before any chosen helper is modified, after its initial target-correction reads. Let C be the selected helpers' complete accumulated prefix response into target data, and R their full suffix response into target data, over F2. Require that target input perturbations remain confined to targets through the prefix, with an invertible target matrix A. Correctness of the old scalar word then forces the suffix target-input block to be A^-1 on targets and zero on helpers, so R=A^-1 C. The selected helper prefix columns must consist only of their own unchanged helper value plus C: in particular there are no prefix reads of these helpers into another helper. No selected helper is a copied/source-owned role. These are actual trace prerequisites, not conclusions of a response hash. Target-to-target prefix changes are allowed. + +Partition chosen helper coordinates into pivots P and donors D. Choose kernel vectors v_p=e_p+sum_(d in D) a_dp e_d, with Rv_p=0 and no other pivot coordinate in v_p. Put N e_p=sum_d a_dp e_d and N e_d=0. Thus N²=0 and Q=I+N is invertible. Q^-1=I-N over the integer gate presentation; over F2 signs coincide. Each nonzero a_dp is one paid ADD donor_d += a_dp*pivot_p. The gates commute because a destination is never a source pivot. Distinct pivots may use the same donor without changing this fact. + +Remove the old initial target-correction reads from the pivot helpers only. At the checkpoint apply Q. Run the unchanged scalar suffix, including actual copied-center lifetimes. At its final full helper frame apply Q^-1. The suffix helper block is identity, so the final helper vector is exactly the original one. Each donor's old accumulated target correction still cancels R e_d. Removing all initial pivot correction reads removes precisely C e_p at the checkpoint; each pivot now contributes zero because this correction is absent and RQe_p=Rv_p=0. Input data behavior is unchanged. This proves correctness for all scalar inputs over F2, including arbitrary dirty-helper correlations. It does not assert the same cancellation over Z; the implementation still retains actual integer ADD coefficients for address/cost analysis. + +For physical legality, require every forward gate's endpoints to share a nondegenerate frame E contained in every affected helper's first positive frame. Give each pivot initial frame E; the donors retain zero entrance and move to E for the paid Q gates. The original future frame chains remain legal by containment. Q^-1 occurs at the final full frame. Normalizer charts must be supplied for every actual pivot residual I-sigma_E. When all frame moves remain nested and no COPY ownership changes, telescoping dimensions give raw movement-rank saving dim(E) per pivot; histograms and ADD invoices must still be recomputed from the literal word. The exponent requires the separate exact moment and outer-assembly checks. + +## Eight actual Pasch components + +The32 saved triple relations form8 groups, each with6 helper roles and4 triples. Label three of the triples + + (a,b,c), (a,d,e), (f,b,e). + +The fourth is their F2 sum. Choose pivots c,d,f and donors a,b,e. The six required forward gates are + + a+=c; b+=c; a+=d; e+=d; b+=f; e+=f. + +All commute, and their integer inverse subtracts the same contributions. The three response-kernel columns have unique pivots, so all three entrances are exposed simultaneously; disjoint-support matching would expose only one. + +The exact C++ rank check `pasch-intersection.cpp` reads the literal first positive frames from the pinned249 event stream. For every component, it verifies that the intersection of all6 first frames has dimension equal to the union of the4 candidate frame bases: respectively4,3,5,9,9,9,12,14. Thus each component admits its full common entrance E for all three pivots. This removes a potential geometric obstruction to shared donors; it is stronger than counting independent scalar relations. + +Three pivots per component give total entrance rank195 rather than65. Combined with the existing132 pair pivots this is327, divisible by3, so the unchanged40-replica bank construction applies without dropping any pairs. Predicted literal stock is868870, normalized173774. These are construction formulas, not a final price receipt: the collective literal word and the combined source-bound bank checker must pass before composition. + +## Sufficient compatibility beyond disjoint blocks + +Disjoint support between selected kernel blocks is stronger than necessary. A sufficient combination rule is: every pivot is unique and belongs to no selected donor set; for each shared donor, all entrance subspaces of blocks using it form a chain under exact subspace inclusion. Each block's entrance is contained in the first positive frames of its own pivots and donors. + +Order the forward kernel blocks by increasing entrance dimension. On any shared donor, this visits its chain monotonically; every pivot appears in just its own block. Therefore all paid gates are physically legal and lead into the original first positive frames. The same N²=0 proof applies because no destination donor is ever a pivot source, even across blocks. Gates with the same donor commute as usual. The inverse gates take place at full frames, where their order is unrestricted. This admits compatible nested-frame donor overlaps that disjoint-support packing rejects, without requiring a new address compiler. Actual histograms and simultaneous weighted-kernel independence remain subject to literal word replay; no estimated gains are added. diff --git a/research/multicut-kernel-composition/LICENSE b/research/multicut-kernel-composition/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/multicut-kernel-composition/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/multicut-kernel-composition/MANIFEST.json b/research/multicut-kernel-composition/MANIFEST.json new file mode 100644 index 0000000000..33fc5a53bd --- /dev/null +++ b/research/multicut-kernel-composition/MANIFEST.json @@ -0,0 +1,85 @@ +{ + "files": { + "BANK-PROOF.md": "a52cda22fc75ef825b7ec7c95e2028803058bfddb4d9c2a51c1bc4c0ab98393c", + "COPY-PROOF.md": "eab69c4fb9fedec2a5078073a7918fada7564d6e7215f50e239f899b2bca614e", + "FINITE-PROOF.md": "dd0e1ac3a212f484086d51454ebcf951ccb98eddfe4713310f688750d35d0069", + "KERNEL-PROOF.md": "4779181f679925da5c6663d4c5aec1a4a0aef76c993ab14b3a82782ac16bb883", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "4816e2b94bff1963abe80f33e379daafd3900a3c8803afe28b589d3e9ce71ae1", + "PROOF-PR259.md": "ffc502078acdfee7a89abe3ec51fae4b8c5a8be7440d6b55f3e24f138e1b1a3b", + "PROOF.md": "fe814b155c2c181a832ba81f541fcdc0195728f33f936f7d4e00b6c95a5b7ebf", + "README-PR259.md": "ed2f4f051a21af9c173c0a7af7cac440ce15cabdabfc721895edde2c837cce25", + "README.md": "9e88fe7b9c859303433c6332854ca4b82e64c6ef1578f3f7e4ffbe02afba5043", + "RESULT.json": "726077b5c93ded03c0a29ad6338b68284c29c6b04a62c560192ca6d426d5a22f", + "REVIEW.md": "823eea4cacf586ca90e43146fac48143f129f6ff8ca71c6a03b88c29fc528ff9", + "code/cleanup_sandwich.py": "8fb843c2b6974afc467e3c877b97d7c861be8a1ce4e6ab417f60b35ec6d19858", + "code/cohort-bank-review.cpp": "cdac6b0460b7d70b40b1a15e1e255995d7c86220b4498005319d971313bb2d81", + "code/cohort-finite-invoice.cpp": "dc0761a15c9b43ebdff3921dd2a49c80bb9158f544fb662ad45880a763cb5ab9", + "code/cohort-five-stage-columns.cpp": "cf9657e2407264120673f34659df79362dc132886d6e62dda96e44d085b61ed1", + "code/cohort-legality-independent.cpp": "4230ce06b6563f1902e9d6f6698dfffa4d31fe13a31b5cb7edb9a811f865bb53", + "code/cohort-prefix-independent.cpp": "81ea649c6bc8db9efead5330a49553b501a79114f0dd4d12a799adbe830b354d", + "code/cohort-price.cpp": "885424440ff82a145817f04ec6cf15e4117c4675ccac57b4e55a8fcf7823ec2a", + "code/cohort-transform.cpp": "afd916d0f539ccdb09e8231eade3b3f6b3e83bbb8107641e134943aa2b25af32", + "code/descent_retiming.py": "a07145a700d95642d54e35a33d5b50ac76ad665220d4f0599c07b22d939f5e10", + "code/export249.py": "6c9aedb8fb4f2d560aca6cfc32ec967e003c0e623cc345040f108101ec1b442f", + "code/plateau_retiming.py": "6cd5ad6d3674cf32057da500d73a6695bd60de15b538b3c41f780cd183bd6b97", + "code/sandwich/price-histogram.cpp": "3f7300f6434aa28639644260ea7e76d45dbdfc650cfbeba1d753af55cb1ed1c1", + "code/sandwich_endpoints.py": "44c1f25c65643c0c9e78147baaac297be77fa4c216737b7dfd7b0f88c6850ff7", + "code/target_prefix.py": "53cbd14a71215978dc9b8660d633b81d91bc3ee3c90ee4300c76dd4de5e8c1f8", + "code/verify_frame_tables.py": "8c0587858e496e8cce9c5aa2ab5938d21c49837af715941bee6d02625f4a3e95", + "code/verify_frames.py": "aea01c7275088611c18ae110a2b4abf7b52f8cc8f70c5932a25588ddec4acd19", + "code/verify_plateau_spans.py": "594f1ababb4efc9e597154970ea51f6b850774f4b55f8cf386dbf1eb7fc5322b", + "discovery/README.md": "4e28223a25e3758ff9ec223d81053d354212c35f10e0dbc4ffd324c6046af567", + "discovery/census2.py": "cea6fa83fa6f85dc0895bfcd9804c4a7b5c8bc06c0642e2c0321943b1b497121", + "discovery/census3.py": "02b2e94a5419bc343396ad954a083e09498b725561a7e0be7b0978a25950f3a0", + "discovery/census3b.py": "19cabd66e734e07ebbf74277b7962ca8e124b48c22f0c32d04978fa05936f962", + "discovery/chain_swap.py": "502eeee20b6cb4d504231e3bad9a81e70ca94195cc8bff9b57ce5b12af12e66f", + "discovery/chrono2.py": "fc2866441540a8d6fa887439f185d0f51f298e1411eecb5ad84aba0de83b5b82", + "discovery/compare259.py": "4c6d08cfb64891a804db677c15baf172d297109d9526d0c9d3764bd26a2dfa8f", + "discovery/finalize_swap.py": "54588aab9cc5c5a986df7aba2fc182fbb790420db0fd3d9953e5a8a2c3933391", + "discovery/gain.py": "b76253949941854bcfd1ff84ebb49b9eaa9fcf4784690295f4a9e773694ddcfd", + "discovery/gen_candidates.py": "6d7136a9c1c86463b1c25405481422ed98f6517d10aa1e99a038fccb6930d688", + "discovery/merge2.py": "cb7d72dc5f8431628281cbd3fb17562d75b3242b882c19cc85cd30ee27617cf1", + "discovery/merge259.py": "aba72c3e48314e842c06681fd62bb90e2a1f2a5dcb39794b1e22f54a6b74b850", + "discovery/rebind_target.py": "1498cbf88b6adbf6aa4b7ee327623c22b3dc0b385243b928a1b5e0131abbbe6b", + "discovery/retime.py": "5c82068777040e9e5fb9e9d5669d02a0f10c0651c8d2ccb362810c31bc31ad53", + "discovery/scan_sandwich.py": "52873b3795ff835b1b5d02df581abaa2ea68dbfc4b9d454ad3e6483320bdb540", + "discovery/twins.py": "c5b3f2065081002aa8da22584724938338fa46da2e25f3221225803e0f1b0ef7", + "expected/COHORT-BANK-REVIEW.json": "0893b75595be282eb5500845419cc69336fe1ba6d68f84266f69b43a4586c72e", + "expected/COHORT-EXACT-PRICE.json": "93d2656072c280af87901f8dede303581e21dce2448cd8b6eb76f7a966530f9d", + "expected/COHORT-FINITE-INVOICE.json": "6b6d20f03b2167438fbac3546eb82d2cb0ede6acaa1667ab88c56b97dd9cb7f6", + "expected/COHORT-FIVE-STAGE-COLUMNS.json": "972a4f35789bff0b34d491ff9999a6ce54f6018cef673ffbc08c4ce52e39927d", + "expected/COHORT249-REPLAY.json": "99b32893d55304e9cf24169453b44312b796547b4080bc8f5d8d1a52b2dbd4b1", + "expected/DESCENT-RETIMING.json": "25e64786cf3648ba6bf9ff9fef2ed338cc1a03e9946619bf9e1ad1a8c259f553", + "expected/FRAME-TABLE-AUDIT.json": "85c999e5ff201b573fb6e4267c2ea0ed5a58b81daccbc2c5311231f975f638fd", + "expected/INDEPENDENT-LEGALITY.json": "ebff85cdc7a93014db41951f9c8f3e692f3b1101f9659ba3454ae38cfff95800", + "expected/INDEPENDENT-PREFIX.json": "e06a1856db3e72ada0859d098fdf9e77e490fd75450312054e03ae039ac2cb94", + "expected/PLATEAU-RETIMING.json": "06e3833080c8b97ee8eb6b896ce9d3a072f038ad2779981101bc1147825efd85", + "expected/PLATEAU-SOURCE-SPANS.json": "080b1c5c8a0b5a8129eb692a07d771a12064e2acb48d0281cb0ae0b84862a25c", + "expected/TARGET-PREFIX.json": "86fdf1451d386c0c3b64bab0252e04ab3355c1913f50ef80256d5d9ae98f388a", + "expected-sandwich/CLEANUP-SANDWICH.json": "7b4fb6e6ff801fb04cc380852590164bbdfaf6f2919fa1aac1316d148662d8b8", + "expected-sandwich/COHORT-EXACT-PRICE.json": "c4e87e1c4feaa3abfa4770f8a210a1e5639b6bb9a2493d8ff332695d01a6e983", + "expected-sandwich/COHORT-FINITE-INVOICE.json": "8e746573999f57671bc3460cf1f5ee3668139ade25e8832247d14ab7690555e0", + "expected-sandwich/COHORT-FIVE-STAGE-COLUMNS.json": "0746b9779f51ab7940d8f41ec273bab6eac6afd1c3027ced9c01082942c7feb4", + "expected-sandwich/COHORT249-REPLAY.json": "b2089ebd9e21636cfccf74dc35c75d451d61e5e738d997536760ab980de51356", + "expected-sandwich/INDEPENDENT-LEGALITY.json": "a58a94ef35cea8e6b8704c9cdd5ee4a596b36f8a7fd5e33d8b0b6f57106dd926", + "expected-sandwich/INDEPENDENT-PREFIX.json": "e06a1856db3e72ada0859d098fdf9e77e490fd75450312054e03ae039ac2cb94", + "expected-sandwich/SANDWICH-BANK-INVOICE.json": "f2285919664c1d6f3211da10a794fcde72a20f021ae2908dbd461d5f9ad162a3", + "inputs/249-DONOR-OWNERSHIP.json.gz": "cd506a4bbefbc33fecfca3b0364e0b237ece493a96ef3085c39cf2465f2265d4", + "inputs/249-records.bin.gz": "6bc404d4af63218e714683d3e33fc1a53941e0155493747c3d0fb41b4a2de7b2", + "inputs/249-states.json.gz": "562bcd7de03bf9474ad8c5cbc50008c92b02bfad81e32c2e532ebd45f384e844", + "inputs/SNAPSHOTS.json": "3939f432a95db64073584e61a47e4983070450929ea1986c86a56552c0b03721", + "inputs/candidates.json.gz": "e459d51e442487a9fdef93cd1592280cfff603023f27f19f51bede00ef67f8b0", + "inputs/descent-selection.json": "e9009fdeaef6e5d59b935803f909453c3c1407200e60713ce3f214f378209991", + "inputs/frames.json.gz": "54678a046e1c86b4d9308f69ef6d572a3b3745229e0ecb73843db7889e487cce", + "inputs/plateau-selection.json": "89db6c272349921f88f7a93642ce51e4d17846431fb3aae8b7a61b6367237cf0", + "inputs/sandwich-selection.json": "ef16f27254d2bf5dfb5d9ad104b9772e62a6a4af903e49f26aa8c61c0aee689d", + "inputs/target-selection.json": "7ed2069ef80d0fc3405a30bc1ed7338ff98d506a7cd7c2d82815e0b27645acb1", + "requirements.txt": "25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc", + "vendor/PR249-SOURCE-MANIFEST.json": "f68fa82180cd352421b8bc3f7a5c89d51bde74e74cd8d62c222c28b0f23fcf31", + "vendor/UPSTREAM-NOTICE.md": "9a659cc2f96ae7e0eda99954941c42a4529bc885fb1de161c44ea801ff36e480", + "vendor/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/pr249-source.zip": "11e2b723f90c44e02f4aa78f5ae2160ae4b9b776d3f1c49e8bfec606959d692c", + "verify.py": "9851dae2e7e7d4a4ed1851555555f24f83e1c09e24483c7b861a4fd090ecd153" + } +} diff --git a/research/multicut-kernel-composition/NOTICE.md b/research/multicut-kernel-composition/NOTICE.md new file mode 100644 index 0000000000..2d1b3e6c12 --- /dev/null +++ b/research/multicut-kernel-composition/NOTICE.md @@ -0,0 +1,41 @@ +# Attribution and scope + +Prepared by Chafik Boukhalfa with substantial Anthropic Claude assistance. Apache-2.0. +This package claims no exclusive priority over concurrent work. + +What this package contributes: the censuses of twin dirty helpers at PR #259's earliest cut and of shared donors, +the 387 added kernel families (`inputs/candidates.json.gz`, rounds "union-early-cut", "headroom-2", "shared-donor"), +the pivot-role swap that exposes 128 cleanup sandwiches, the rebinding of the published retiming and target-prefix +selections to this transcript, the composition of the four levers in one verifier, the regenerated receipts, and the +discovery scripts in `discovery/`. Everything else is retained and credited: + +- Dugongue (OpenAI Codex assistance): PR #254 (the response-kernel pair rewrite, projector charts, native checkers), + PR #259 (multi-cut kernel condensation, the generic exact chart audit, the seven checkers, the pricer and the + finite invoice, used here unchanged except one `std::stable_sort`; its notes kept as README-PR259.md, + PROOF-PR259.md, KERNEL-PROOF.md, BANK-PROOF.md, COPY-PROOF.md, FINITE-PROOF.md, REVIEW.md), PR #267 (chronological + donor sharing, the idea behind the shared-donor families). +- rohanarun: PR #263 (the concave-descent frame retiming stage `code/descent_retiming.py` and its 25-gate selection, + used verbatim), PR #273 (the native target-prefix stage `code/target_prefix.py` and its 209-square selection, used + verbatim), PR #237/#209 (five-stage bit supplier, width-120 banks), PR #269. +- evmckinney9: PR #271 (the cleanup-sandwich rewrite, its endpoint charts and bank re-tiling and the price wrapper, + ported as `code/cleanup_sandwich.py`, `code/sandwich_endpoints.py`, `code/sandwich/price-histogram.cpp`). +- utcorvusvolat-dotcom: PR #270 (the 24 reuse pairs and two e = 2 planes, the plateau retiming stage + `code/plateau_retiming.py` with `verify_frames.py`, `verify_plateau_spans.py`, `verify_frame_tables.py` and the + 29-block selection, and the rebinding of PR #263's selection by scalar-core alignment, all used verbatim). +- eumemic (Anthropic Claude and OpenAI Codex assistance): PR #249/#244/#251 (the source527 bit word, entrance + banks, retimed source pairs, transported entrances) on PR #210's helper and PR #168's modules; PR #268 (the + target-prefix compression mechanism). +- hcg890 PR #234 (five-stage bit and complex suppliers); sennemmi PR #230/#261/#265; lydakis PR #275; DreamingOfClouds PR #276. +- The PR #249 lineage as credited in vendor/UPSTREAM-NOTICE.md and below. + +---- PR #259's notice follows unchanged ---- + +# Attribution and scope + +New response-kernel rewrite, native checks and packaging prepared with substantial OpenAI Codex assistance. No personal byline is added. + +Based on CrocSwap/integer-mult-bounds PR249 at commit 96495746c786d6d0339dbb38c7f553d4af3f88ed. The original sources and license notices are preserved in vendor/pr249-source.zip; see vendor/UPSTREAM-NOTICE.md for upstream contributors and mechanisms. Those historical public credits are retained. + +New code is distributed under Apache-2.0 (LICENSE). The vendored nlohmann JSON single header retains its own MIT license and attribution. Boost is an external build dependency, under the Boost Software License. Existing third-party files retain their original terms. + +This is a finite construction with exact checks, conditional on retained public all-size interfaces. It is not a Lean/kernel certificate or an unconditional integer-multiplication theorem. diff --git a/research/multicut-kernel-composition/PROOF-PR259.md b/research/multicut-kernel-composition/PROOF-PR259.md new file mode 100644 index 0000000000..e3782d04f0 --- /dev/null +++ b/research/multicut-kernel-composition/PROOF-PR259.md @@ -0,0 +1,61 @@ +# Multi-cut response-kernel condensation + +2026-10-09. Root and three agents; mathematical research and native C++ checks. Nothing published. No Lean/kernel certification. + +## Checked exponent + +The complete finite construction gives + + kappa = 142205877210807 / 200000000000000000 + = 0.000711029386054035. + +The previous delivered value was0.00071046520063283. The relative gain is about0.0794%. This is a real but modest exponent improvement, not a massive jump. It retains the same public all-size compiler, common weighted chart, restored-row, routing, prime, precision/recovery, complex correctness and analytic interfaces. Those general theorems are not newly proved here. + +## New sufficient mechanism + +The earlier construction only paired equal dirty-response columns. We now treat the actual target-response matrix as a linear code: its short dependencies provide several simultaneous cancellation coordinates. Choose distinct pivot helpers and donor helpers, with no pivot also a donor. At the chosen cut, each pivot's target-response column is the sum of its donors' columns over F2. Choose an explicitly nondegenerate common entrance frame contained in the first required frames of every participant. + +Delete that pivot's initial target compensation reads, raise its initial frame to the common entrance, and execute donor += pivot for every donor in its relation. After the retained word reaches the common full frame, execute the inverse shears. All shears form Q=I+N with N^2=0; therefore Q^-1=I-N. Full arbitrary dirty inputs are restored. Donors may be shared when their required entrance frames form a nested chain, executed in increasing dimension. Shared donors pay their frame lift once, instead of independently in every relation. + +For a cut whose prefix target map is A y+B x+R d and whose helpers are untouched, the zero-response condition gives exactly the target state of the old program on Q-transformed dirty inputs after removing the pivot compensation contribution. The invertibility of the target-only prefix map handles the actual target-to-target setup operations. The original helper word followed by Q^-1 restores the original arbitrary dirt. Gates at multiple cuts are admitted only with the corresponding untouched-prefix and response conditions at each actual cut. The actual combined whole word is independently checked on every input column in both directions, so no inference from separate local prices replaces composition. + +This turns independent pair rewrites into simultaneous kernel bases, higher-rank quartets, and temporally placed kernels. For eight six-role Pasch components, three independent kernel directions share the same donor setup; the old disjoint-triple choice exposed only one. The larger search then uses exact fundamental circuits, an exhaustive quartet-response search, and complete systematic kernel bases. A bounded weighted-packing search chooses compatible physical blocks. Heuristic scores only select candidates; the final exponent is computed with exact rational interval bounds. + +## Geometric repair + +Some attractive common intersections are degenerate in the address form. These were rejected by the exact Gram/chart audit, then replaced by explicit nondegenerate codimension-one subframes. The response relation remains valid, while the changed entrance dimension is fully repriced. This is a sufficient replacement construction, not an assumption that any rank-sized space is admissible. Every selected new chart is independently inverted and checked against its actual residual projector. + +## Final finite evidence + +The frozen word is lead/multicut/COHORT249-RECORDS.bin. + +- 518 pivot entrances at4 actual cuts, involving1194 distinct helpers. +- 1344 removed raw rank units, versus132 in the previous delivered construction. +- Raw rank mass434177 ->432833;27,772 initial reads removed;1,542 basis/inverse gates paid. +- Actual local ADD count760393;20,107 formal input columns checked forward and inverse; both omitted-basis controls fail nontrivially. +- 911,680 independent target-kernel equalities and23,649,283 non-target identity bits checked at the respective cuts. +- 518 actual projector charts; maximum200 factors and exact intermediate numerators/denominators at most704. +- All3,317,400 bank assignments,10,560 endpoint columns, and10,560 nonzero omission/repetition control columns checked. Literal stock867175, normalized173435. +- All23,627 global five-stage F2 columns pass;120 fresh center copies are charged. +- Selector bill626937381600. Payload prefix bound98bits below the inherited104bit guard; counted coefficient56bits below2^80. +- Exact rational recurrence price and all47 strict outer inequalities pass; adjacent-grid rejection and exact pinned-baseline regression pass. + +The legality audit initially rejected two selected COPY-source pivots under an old blanket exclusion. That exclusion is stronger than the actual copy lemma requires: the source must be immutable during its COPY/ERASE window. The two pivots are never written by the new basis gates. An independent literal-window check covers all24 copy windows, and the final arbitrary-precision frame/lifetime audit verifies the required condition directly. A separate copy-excluded construction also passes, at slightly smaller kappa0.000711028182167973; it is preserved in lead/multicut-nocopy. + +## Larger separate construction, not added to kappa + +The cube lane found a26-addition/10-carrier producer rather than30/13, with60 rather than62 standalone dirty roles and fully charged forward rankmass616 rather than624. It passes all220 inherited interfaces. + +A concrete whole-graph splice keeps all9216 outside carrier arcs, changes25900 nodes to25020, and removes440 raw dirty roles. All6624 original root interfaces match all1760 source columns; arbitrary dirty restoration and a custom exact frame-path emitter pass, including88402 frame comparisons and5720 new Gram checks. However, the fully charged ungauged route fails to beat the current supplier. Reusing the source527-specific borrow/reuse/gauge adapters on the smaller allocation remains necessary. No projected440-role gain is included in the checked exponent. + +## Search boundaries + +- Checked latest public PR metadata and pinned useful heads; see public/SUMMARY.md. Public higher numbers that remain unbuilt are not baseline certificates. +- Reused prior broad DAG/library retrieval and relevant saved circuit/assembly notes; this round was not an exhaustive new review of every Lean module. +- No new Lean work and no Jev proof-generation or kernel-closure claim. +- Pivot reorientation and exact nested-donor compatibility enlarged the selector to1617 blocks, but the bounded search found no gain beyond the252-pivot single-cut pool. These negative search results do not establish optimality. + + +## Packaged evidence + +`code/` contains the seven executed native checkers and the pinned-source exporter. `inputs/candidates.json.gz` freezes the final selection, including each cut; replay does not rerun heuristic discovery. `expected/` contains exact comparison receipts. `vendor/` includes the original pinned upstream sources and licenses. BANK-PROOF.md gives the generic residual allocation and COPY-PROOF.md gives the required copy-window condition. diff --git a/research/multicut-kernel-composition/PROOF.md b/research/multicut-kernel-composition/PROOF.md new file mode 100644 index 0000000000..4caebfb9a0 --- /dev/null +++ b/research/multicut-kernel-composition/PROOF.md @@ -0,0 +1,130 @@ +# Kernel families, two retimings, target-prefix compression and cleanup sandwiches, composed + +**Claim.** On PR #249's bit word (commit `96495746`), PR #259's multi-cut kernel condensation extended to 890 pivot +families (entrance rank 1,719), retimed by PR #263's 25 descent gates and PR #270's 29 plateau blocks, compressed by +PR #273's 209 target-prefix squares, is a legal word of the same model with κ = 712005174354669/10¹⁸ = +7.12005174354669·10⁻⁴, checked by PR #259's seven native checkers, the stages' own audits and PR #259's exact pricer; +and with 126 of its kernel pivots retired at dimension 4 by PR #271's cleanup-sandwich rewrite it is a legal word with +normalized stock 172,470 and κ = 142805349285993/(2·10¹⁷) = 7.14026746429965·10⁻⁴, checked as in section 5 — both +under the retained public all-size hypotheses of PR #249/#254/#259. + +## 1. The mechanism (PR #254/#259, unchanged) + +A dirty helper j untouched before a cut (initial frame ZERO, final frame FULL, no write, copy or non-initial read +before the cut) acts on the targets only through its initial zero-frame compensation reads, so its *complete target +response* R_j ∈ F₂^1760 is a column of the prefix's target map. Helpers a, b with R_a = R_b and a nondegenerate common +entrance subspace E inside both first required frames admit the rewrite: a (the pivot) starts at E and its initial +reads are deleted; b (the donor) moves ZERO → E at the cut and absorbs a there (Q = I + e_b e_aᵀ); the old word +resumes from E; Q⁻¹ is paid at the full frame; the omitted response R_a·a and the induced change R_b·a cancel. PR #259 +generalises this to several simultaneous zero-response directions at four cuts and admits any entrance through an +exact chart audit (B⁻¹(I − σ)B diagonal, factor count ≤ 548, intermediates below 2⁸⁰). + +## 2. The families added + +Cut 676,559 is the last initial compensation read (records 0..676,559 are the 676,560 initial reads; the first MOVE +follows). Among the 14,286 clean helpers live there, the responses form 985 twin classes of size two and 24 of size +nine. Three rounds, each admitted by the φ ledger (with the deficit pinned at 35,200 per replica the coarse exponent is +driven by Σ r·n·ln(120/r), φ(r) = r·ln(120/r); a pair with first ranks (r_a, r_b) and e = 1 changes it by +φ(r_a − 1) − φ(r_a) + φ(1) + φ(r_b − 1) − φ(r_b): −2.02 for (2, 2), −0.97 for (3, 3)): + +1. `union-early-cut`: 333 twin pairs disjoint from all 1,194 helpers of PR #259's families (319 with first frames + (2, 2) on lines u = eᵢ − eⱼ — norm 2, cleared Gram 9·uᵀu − (Σu)² = 18, excluded primes {2, 3} as for the ±1-four + lines of PR #254, which PR #254's `norm == 4` rule excluded and PR #259's generic audit admits — and 14 pairs + (3, 5), (3, 3), (3, 6) with ±1-four lines), two dropped for the mod-3 rule. +2. `headroom-2`: every response class of any size at twelve cuts from 676,559 to 727,593, pairs and XOR triples + R_c = R_a ⊕ R_b; 32 more disjoint net-positive families, all at 676,559 (28 (3, 3), two (3, 6), one (3, 5) with e = 1, + one (3, 5) on its full two-dimensional nondegenerate intersection); nothing at any later cut; no net-positive triple + (a partner costs φ(1) + φ(r − 1) − φ(r) > 0). +3. `shared-donor`: PR #259's transform only requires pivots to be unique and never donors; a partner may serve several + families, being moved to each family's entrance in increasing dimension at its cut, so a shared donor is legal when + its entrances form a nested chain and its own first use is after every cut it serves. For every current donor d and + every clean untouched helper p with R_p = R_d, the entrance is d's existing subspace when it lies inside F_p (the + lift already paid) or a nondegenerate line inside E_d ∩ F_p; greedy by gain, dissolving a plain pair when a + shared-donor alternative is strictly better and its donor serves no other family: 54 shared-donor families (51 on + the donor's existing entrance, 3 on nested lines; pivot ranks 49 × 3, 5 × 5), 26 pairs dissolved (11 of round 1, 15 of + PR #259's at 680,080 and 700,582, whose helpers re-enter as pivots or donors of better families), including all 24 + reuse pairs and the two e = 2 planes of PR #270. + +Total: 890 families (PR #259's remaining 503 + 387 added), entrance rank 1,719 ≡ 0 mod 3, 1,903 helpers, 96 shared +donors; 60,520 initial reads removed, 2,286 gates paid. + +## 3. The two retimings + +PR #263 (rohanarun) reassigns the frames of 25 internal ADD gates found by local descent on the concave paid-rank +objective Σ r·ln(120/r); its selection binds gates by ADD ordinal, scalar content and old basis and is gated by the +input transcript's sha256. PR #270 (utcorvusvolat-dotcom) ships the rebinding (full scalar-core alignment: every +ADD/COPY/ERASE event outside the kernel categories must be identical) together with its own stage, 29 connected +plateau blocks of 57 ADDs retimed jointly, with audits of the operand source spans and of all added frames. Both +selections rebind to this transcript (the core events are identical; 18 of the 25 descent gates touch registers that +are helpers here, and every self-check of the stage still passes, so disjointness from the pivots was sufficient, not +necessary). Histogram deltas: descent {2: −2, 4: +24, 5: −48, 6: +25, 11: −1, 13: +2, 17: −1} (one call removed); +plateau {1: +15, 2: −26, 3: +19, 4: −7, 5: −3, 6: +21, 7: −24, 8: +8, 9: −14, 10: −2, 11: +13, 12: −4, 13: +4} (calls +and mass unchanged). + +## 4. Target-prefix compression (PR #268, eumemic; native stage PR #273, rohanarun) + +On this word every target reads five rank-20 entrance helpers at a 20-dimensional frame right after the forward +phase. In each of 209 squares of four targets, each such helper is read by exactly two of the four, so the dependent +target's prefix response is the F₂ sum of its three square-mates' responses: its 1,057 frame-20 reads are omitted, it +receives t −= p_j at the zero frame at the cut and t += p_j at the square's common nondegenerate 21-dimensional frame. +PR #273's stage `code/target_prefix.py` (verbatim) recomputes every member's literal prefix response from the actual +word, so the selection is self-checking; its 209 squares bind to this transcript after remapping the cut (the first +record after the last Q pass, 669,371 here) and the 209 close records (`inputs/target-selection.json`, with a +`core_binding` block: the post-cut scalar events of the two words are identical, 84,975 compared). Histogram delta +{1: −209, 2: −7, 3: −1, 8: −1, 12: −1, 17: −1, 18: −7, 20: −200, 21: +209}; the seven native checkers run on the +compressed word. + +## 5. Cleanup sandwiches (PR #271, evmckinney9) + +A kernel pivot whose only gates after its cut are the full-frame cleanup t += a; a += b; t += a (F₂; t never a +control in between) equals a += b; t += b: the first gate moves to the cut, where a and b sit at frames whose sum is a +nondegenerate four-dimensional frame, and t += b keeps the middle gate's place; the helper then stops at dimension 4 +instead of climbing to the full frame (two rank-21 steps become two rank-1 steps and one rank-20 step; its banked +endpoint becomes a rank-3 partial swap instead of rank 23). The helpers are found on this word by +`discovery/scan_sandwich.py` (kernel pivots with entrance dimension 1 whose two post-cut gates are the family's pass +and the cleanup, with joint dimension 4 at the cut). A pair family has two members and the transform is symmetric in +cost, so in 83 two-member families of rounds 1 and 3 the pivot role is moved to the member with the sandwich shape +(`round` suffix `+pivot-swap`; the cohort histogram, entrance rank, removed reads and native receipts are unchanged); +the scan then finds 128 sandwiches, of which 126 are retired: each retired helper frees 20 width units in every one of +the 40 replicas, 800k must be a multiple of 120, so k ≡ 0 mod 3. Histogram delta {1: +252, 20: +126, 21: −252}; +the re-tiled banks lose 840 per stage (stock 173,310 → 172,470), the deficit stays 35,200. Because PR +#259's bank review and price driver assume every helper ends at the full frame, the stage is certified as PR #271 does: +native legality with the stage's final frames, native prefix and five-stage columns on the new word, exact endpoint +charts and bank re-tiling (`code/sandwich_endpoints.py`), the unchanged price engine through PR #271's wrapper +(`code/sandwich/price-histogram.cpp`, which first reproduces the native price bit for bit), and the native finite +invoice; receipts in `expected-sandwich/`. `RESULT.json` carries both κ values (the seven native checkers' word, and +the sandwich word). + +## 6. What is checked (receipts in `expected/` and `expected-sandwich/`) + +| stage | receipt | +|---|---| +| `cohort-transform` (all-column F₂ replay) | 890 pivots, entrance rank 1,719, 60,520 initial reads removed, 2,286 gates, raw mass 434,177 → 432,458; omitted-Q and omitted-Q⁻¹ controls fail nontrivially | +| `descent_retiming` → `plateau_retiming` → `target_prefix` | sha gates cohort 4458dce8… → descent a6d793d7… → plateau a1cf58b3… → native word eaff3c98…; spans and frame-table audits PASS; target-prefix delta {1: −209, 2: −7, 3: −1, 8: −1, 12: −1, 17: −1, 18: −7, 20: −200, 21: +209}, 1,057 reads deleted, 1,254 setup/restore additions | +| `cohort-legality-independent` | 1,903 helpers, 0 source-owner and 0 donor intersections, 24 COPY/ERASE windows, all final frames | +| `cohort-prefix-independent` | 890 cohorts, 4 cuts, 1,566,400 target-kernel equalities | +| `cohort-bank-review` | literal stock 866,550 (saved 2,865), 919 exact charts (at most 262 factors), 3,317,400 assignments, selector 626,937,131,600 | +| `cohort-five-stage-columns` | 23,627 columns, payload 98 bits | +| `cohort-price` (native word) | coarse exponent giving κ = 7.12005174354669·10⁻⁴, W 173,310, deficit 35,200, 47/47 constraints, adjacent grid rejected, pinned-baseline regression exact | +| `cohort-finite-invoice` | PASS, deficit 176,000, cutoffs positive | +| sandwich word (sha 9556bfe3…): native legality with the stage's final frames, native prefix, native five-stage columns | PASS (`expected-sandwich/`) | +| `sandwich_endpoints` (exact SymPy endpoint charts, bank re-tiling) + price wrapper + native finite invoice | 126 rank-3 partial swaps; W 172,470, rank mass 20,661,200, deficit 35,200, κ = 7.14026746429965·10⁻⁴, 47 constraints, adjacent grid rejected | + +Control: PR #259's own selection through the same transform reproduces its κ exactly, and the stable-sorted PR #259 +word is byte for byte the input PR #263's selection is bound to (sha 1ae06b18…), whose descent output is the input of +PR #270's plateau selection (80af525c…). + +Platform matters (so that one package verifies on Linux/g++ and macOS/clang alike): `code/cohort-transform.cpp` uses +`std::stable_sort` on the gauge order (the tie order of `std::sort` differs between libstdc++ and libc++ and changed the +transcript's sha256); `verify.py` drops `containment_pairs_checked` (a memo-cache miss counter) from the compared +receipt fields and normalizes both sides. Nothing else of PR #259's code changes; `discovery/README.md` lists the diff. + +## 7. Not claimed, not composed + +No Lean certificate; the public all-size interfaces of PR #249 are retained as hypotheses. The sandwich part is not +seen by PR #259's native bank review (hard-coded census, residual 24 − dim(initial frame)) nor by its native price +driver (stock from the entrance rank), which is why it is certified by the checks of section 6 instead, as PR #271 +does. Not composed: PR #272's frame-filtered collective kernels (925 families), PR #275's zero-frame target restores, +the fixed-prime refinement of PR #261/#265; the two sandwiches beyond 126 (mod-3 rule); 492 twin candidates whose +donor's entrance is not inside the new pivot's first frame and multi-donor relations R_p = R_d₁ ⊕ R_d₂ were not +searched. PR #276's new bit word (gen4) stands above every rung on this word. diff --git a/research/multicut-kernel-composition/README-PR259.md b/research/multicut-kernel-composition/README-PR259.md new file mode 100644 index 0000000000..cd7fb7e820 --- /dev/null +++ b/research/multicut-kernel-composition/README-PR259.md @@ -0,0 +1,30 @@ +# Multi-cut response-kernel condensation + +**Conditional kappa = 142205877210807 / 200000000000000000 = 0.000711029386054035.** + +This builds on pinned PR249 (`96495746c786d6d0339dbb38c7f553d4af3f88ed`) and extends the earlier 132-pair kernel construction. It raises the previous delivered 0.00071046520063283 by approximately 0.0794%. This is a modest checked exponent gain, not a claim of a huge jump or the latest leaderboard record. + +The new mechanism selects simultaneous zero-response helper directions, shares donor lifts, repairs singular common frames with explicit nondegenerate subframes, and places compatible basis changes at four actual cuts. The result has 518 pivot entrances, removes 1344 raw rank units and 27772 initial reads, and pays every added basis gate and inverse. Complete bank stock is 867175. + +## Reproduce + +Requires Python 3.11+, SymPy 1.14.0, GNU g++ with C++17 and Boost headers. Install `g++ libboost-dev` on Linux, then: + +``` +python -m pip install -r requirements.txt +python verify.py --output ../multicut-replay +``` + +MinGW-w64 is supported on Windows. Use `--cxx /path/to/g++` and optionally `--boost-include /path/to/boost-header-parent`. The output directory must be new and outside the package. Allow several minutes and a few GB of RAM. No network, credentials, Lean or GPU is required. New mathematical computation is C++; Python orchestrates it and runs the original upstream emitter. + +The default verifier checks hashes, regenerates pinned upstream data, compiles seven native checkers, emits the new word from the frozen candidate selection, and rechecks its complete semantics, geometry, bank assignment, finite invoice and exact exponent. It requires all 20107 local input columns in both directions, 23627 five-stage global columns, 911680 per-cut kernel equalities, all 3317400 bank assignments, exact chart identities, nonvacuous controls and all 47 strict outer inequalities. The bank label and mathematical receipts must match exactly; only elapsed time and runtime paths are excluded from comparisons. + +`--snapshots-only` explicitly skips upstream source regeneration and records that weaker provenance mode in its certificate. It still executes all seven native checkers. Discovery scans are not rerun: inputs/candidates.json.gz is the complete frozen final witness, including actual cut positions. + +## Scope and source handling + +Retains the public all-size compiler, common weighted chart, restored-row, routing, prime, precision/recovery, complex symbolic correctness and analytic interfaces. These foundations are not independently reproved. The actual cancellation is over F2 payload; odd-prime address geometry is separate. This is not an unconditional multiplication theorem, practical benchmark or Lean certificate. The public eight-stage Python command is not claimed to be replayed verbatim on the modified word. + +See PROOF.md, KERNEL-PROOF.md, BANK-PROOF.md, COPY-PROOF.md, FINITE-PROOF.md and REVIEW.md. Paths under lead/ or banks/ in research-derived proof notes identify the original evidence roles; the executable package uses code/, inputs/ and expected/. Native output logs can contain your chosen output path; they are not upload files. + +Original public sources, licenses and attributions are preserved in vendor/. No personal byline, binaries or local machine configuration is included. diff --git a/research/multicut-kernel-composition/README.md b/research/multicut-kernel-composition/README.md new file mode 100644 index 0000000000..bcda810d0d --- /dev/null +++ b/research/multicut-kernel-composition/README.md @@ -0,0 +1,90 @@ +# multicut-kernel-composition + +**Conditional κ = 142805349285993 / (2·10¹⁷) = 7.14026746429965·10⁻⁴** (+0.4216% over PR #259's 7.11029386054035·10⁻⁴; ++0.0510% over PR #271's 7.1366215638961·10⁻⁴ and +0.0472% over PR #275's 7.13690108083058·10⁻⁴, the best rungs on +PR #249's word before this one). With the seven native checkers alone (before the sandwich stage): +κ = 7.12005174354669·10⁻⁴. PR #276's new bit word (gen4, 7.2287·10⁻⁴) stands above every rung on this word. + +PR #259 (Dugongue) condenses response kernels of the PR #249 bit word with 518 pivot families at four cuts. This +package composes, on that word, with PR #259's seven native checkers and pricer unchanged, four levers published +by five authors: + +1. **372 more kernel families at its earliest cut** (record 676,559, the last initial compensation read): a census of + the twin dirty helpers live at that cut — helpers untouched before it whose complete F₂ target responses coincide + — gives 985 twin pairs; the net-positive ones disjoint from PR #259's helpers (first round 333, second round 32), + two e = 2 planes of PR #270, and **54 shared-donor families** (a new pivot whose twin partner is already a donor of + another family, lifted once on a nested entrance chain, as the 24 reuse pairs of PR #270 and the chronological donor + sharing of PR #267; 26 plain pairs are dissolved where a shared-donor family is strictly better). Result: **890 + families, entrance rank 1,719, 1,903 helpers, 96 donors shared by two or more families**, cuts {676,559: 488; + 680,080: 89; 700,582: 63; 727,593: 250}; 60,520 initial reads removed, 2,286 basis gates paid, raw rank mass + 434,177 → 432,458. +2. **PR #263's 25 concave-descent gate retimings** (rohanarun; stage `code/descent_retiming.py`, selection rebound to + this transcript by full scalar-core alignment; −1 local call) and **PR #270's 29 connected-block plateau + retimings of 57 ADDs** (utcorvusvolat-dotcom; stages `code/plateau_retiming.py`, `verify_plateau_spans.py`, + `verify_frame_tables.py`; calls and mass unchanged, rank distribution improved). +3. **eumemic's target-prefix compression** (PR #268) as rohanarun's native stage of PR #273 (`code/target_prefix.py`, + verbatim): 209 squares of four targets whose prefix responses are F₂-dependent; the dependent target's 1,057 + frame-20 reads are omitted and replaced by a zero-frame setup at the cut and a restoration at the square's + common 21-dimensional frame (+5.23·10⁻⁷). +4. **evmckinney9's cleanup sandwiches** (PR #271): kernel pivots whose only gates after their cut are the full-frame + cleanup t += a; a += b; t += a are rewritten to stop at dimension 4 instead of climbing to the full frame + (rank-23 banked endpoints become rank-3 partial swaps). On this word the pivot role of 83 two-member families is + assigned to the member with the sandwich shape (cost-neutral for the kernel transform), which raises the count of + admissible sandwiches from 45 to 128, of which 126 are retired (the bank re-tiling needs a multiple of 3): +2.02·10⁻⁶, + the largest single lever here. + +| stage (each on the previous word) | pivot families / entrance rank | normalized stock W | κ | +|---|---|---|---| +| PR #259 | 518 / 1,344 | 173,435 | 7.11029386054035·10⁻⁴ | +| kernel families: twins, headroom, shared donors | **890 / 1,719** | 173,310 | 7.11462218·10⁻⁴ | +| + PR #263 descent (25 gates) + PR #270 plateau (29 blocks) retimings | 890 / 1,719 | 173,310 | 7.11482139228173·10⁻⁴ | +| + target-prefix compression (209 squares) — seven native checkers' word | 890 / 1,719 | 173,310 | **7.12005174354669·10⁻⁴** | +| + 126 cleanup sandwiches (pivot roles swapped in 83 families) | 890 / 1,719 | **172,470** | **7.14026746429965·10⁻⁴** | + +For comparison, PR #270 (887 families, rank 1,716) is 7.11457853·10⁻⁴, PR #273 (target squares on #269) 7.11948954·10⁻⁴, +PR #271 (99 sandwiches on #272's word) 7.13662156·10⁻⁴ and PR #275 7.13690108·10⁻⁴. + +The deficit 120·W − mass = 35,200 per replica is invariant under all of these rewrites (a pivot's residual 24 → 23 +shrinks the bank capacity by exactly the mass it saves), so the exponent moves through the log-weighted mass +Σ r·n·ln(120/r) alone; every family and every retiming is admitted or rejected by PR #259's exact pricer on the whole +word, never added as an estimate. [PROOF.md](PROOF.md) states the delta and the checks; PR #259's notes are kept +unchanged as `README-PR259.md`, `PROOF-PR259.md`, `KERNEL-PROOF.md`, `BANK-PROOF.md`, `COPY-PROOF.md`, `FINITE-PROOF.md`, +`REVIEW.md`. + +Conditional, finite construction under the same retained public all-size hypotheses as PR #249/#254/#259 (no Lean +certificate, no unconditional theorem). κ is the bit-bound value: the complex supplier of this lineage stands at +7.5474·10⁻⁴ five-stage (PR #256, Lean-checked in jacobalansussman/wht-power-saving-lean#2), so the bit supplier binds. +The sandwich stage is certified as PR #271 certifies it (PROOF.md, section 5): PR #259's native bank review and +price driver assume every helper ends at the full frame, so that part rests on the native legality, prefix and +five-stage checkers on the new word, exact endpoint charts with the bank re-tiling, the unchanged price engine +through PR #271's histogram wrapper, and the native finite invoice; `RESULT.json` carries both κ values. Not composed: +PR #272's frame-filtered collective kernels, PR #275's zero-frame target restores, the fixed-prime refinement of +PR #261/#265 (+4·10⁻¹²). + +## Verify + + sudo apt-get install -y g++ libboost-dev # Linux; macOS: brew install boost, --cxx clang++ with a bits/stdc++.h shim + python -m pip install -r research/multicut-kernel-composition/requirements.txt # sympy 1.14.0 + python3 -I research/multicut-kernel-composition/verify.py --output /tmp/mkc-replay # fresh directory outside the package; about 4 minutes + +PR #259's verifier with the stages inserted (02b descent, 02c–02e plateau and its audits, 02f target prefix, then the +seven native checkers 03–08, then 09–17 the sandwich stage with its legality, prefix, five-stage, endpoint/bank, +price-wrapper and finite-invoice checks), every stage gated by the sha256 of the transcript it consumes: package +hashes against `MANIFEST.json`, regeneration of the pinned PR #249 word from `vendor/pr249-source.zip` (SymPy), the +checkers compiled and run, every receipt compared with `expected/` and `expected-sandwich/` (platform-independent +fields), then `PASS: kappa = 0.000714026746429965`. `--snapshots-only` skips the upstream +regeneration. `.github/workflows/multicut-kernel-composition.yml` runs it on Ubuntu (Python 3.11 and 3.13). + +## Files + +PR #259's package (`code/cohort-*.cpp`, `code/export249.py`, `inputs/249-*`, `inputs/frames.json.gz`, +`inputs/SNAPSHOTS.json`, `vendor/`, the proof notes, `requirements.txt`, `LICENSE`) with the frozen selection +`inputs/candidates.json.gz` (PR #259's 518 items, then ours with `round` = `union-early-cut`, `headroom-2`, +`shared-donor`, with `+pivot-swap` where the pivot role was moved), PR #263's and PR #270's stages +(`code/descent_retiming.py`, `code/plateau_retiming.py`, `code/verify_frames.py`, `code/verify_plateau_spans.py`, +`code/verify_frame_tables.py`; `inputs/descent-selection.json`, `inputs/plateau-selection.json`, rebound to this +transcript), PR #273's `code/target_prefix.py` with `inputs/target-selection.json` (rebound), PR #271's mechanism as +`code/cleanup_sandwich.py`, `code/sandwich_endpoints.py`, `code/sandwich/price-histogram.cpp` with +`inputs/sandwich-selection.json`, `verify.py` (PR #259's with the stages and sha gates), `expected/` (twelve receipts) +and `expected-sandwich/` (eight), `RESULT.json`, `MANIFEST.json`, `discovery/` (the censuses, merges, the rebinding +chain and the sandwich scan; not run by the verifier), `README.md`, `PROOF.md`, `NOTICE.md`. diff --git a/research/multicut-kernel-composition/RESULT.json b/research/multicut-kernel-composition/RESULT.json new file mode 100644 index 0000000000..f95eca42eb --- /dev/null +++ b/research/multicut-kernel-composition/RESULT.json @@ -0,0 +1,29 @@ +{ + "kappa": "142805349285993/200000000000000000", + "kappa_decimal": "0.000714026746429965", + "baseline_head": "96495746c786d6d0339dbb38c7f553d4af3f88ed", + "baseline_kappa": "0.000710392186446856", + "previous_delivery_kappa": "0.000712725850053909", + "new_record_sha256": "eaff3c9828ed15e1c24998331f0d3b482efc9984dd86bf5dbcefca0c76e717c6", + "status": "FINITE_CONSTRUCTION_UNDER_RETAINED_PUBLIC_ALL_SIZE_HYPOTHESES_SANDWICH_STAGE_BANKS_RETILED_OUTSIDE_NATIVE_BANK_REVIEW", + "lean_certificate": false, + "pivots": 890, + "entrance_rank": 1719, + "cohort_record_sha256": "4458dce8218c9a0e0e55f494e33b2ad320649e953d108470ba0c8ac077660505", + "descent_record_sha256": "a6d793d7fd4f902436fd64c1d0e9467adc93844e058578994400d30fcf4171c3", + "descent_retimed_gates": 25, + "plateau_retimed_blocks": 29, + "plateau_retimed_gates": 57, + "plateau_record_sha256": "a1cf58b3b0d23775a07fd0ebc276c40a9c52a41a2ea285b935d062d314699d7b", + "kappa_native_seven_checkers": "712005174354669/1000000000000000000", + "kappa_native_decimal": "0.000712005174354669", + "target_prefix_groups": 209, + "target_prefix_deleted_reads": 1057, + "target_prefix_setup_restore_additions": 1254, + "sandwich_record_sha256": "9556bfe3045eb23a2613a8f7b5cfc3824e321d4cbe2ec08f6993317a8bf816f7", + "sandwich_helpers_retired": 126, + "sandwich_normalized_stock": 172470, + "native_normalized_stock": 173310, + "pivot_role_swapped_pair_families": 83, + "sandwich_helpers_scanned": 128 +} diff --git a/research/multicut-kernel-composition/REVIEW.md b/research/multicut-kernel-composition/REVIEW.md new file mode 100644 index 0000000000..93c40a639a --- /dev/null +++ b/research/multicut-kernel-composition/REVIEW.md @@ -0,0 +1,9 @@ +# Independent review + +A separate worker freshly compiled and replayed the generalized compiler, checked all emitted artifacts against the primary run, and independently audited chronological geometry with arbitrary-precision integer dot products. The final legality checker validates shared donor supports, unique pivots disjoint from donors, source-owner exclusions, common gate frames, paid nested moves, final frames and immutable COPY windows. + +A separate own-cut prefix checker recomputes every relation from the original pinned word: 911680 target-kernel equalities and 23649283 non-target identity bits, involving 1194 distinct helpers at four cuts. The whole emitted word and five-stage composition are checked independently of those local conditions. New Gram charts, bank assignment, finite costs and exact outer assembly are separate executed checks. + +Expected receipts are comparison targets only. The verifier recompiles all seven native tools, regenerates the upstream baseline by default, and requires every freshly generated mathematical receipt field to match. Frozen source and input hashes bind this concrete result; general malformed-input hardening is outside the claim. + +No Lean/kernel certification or unconditional multiplication theorem is asserted. diff --git a/research/multicut-kernel-composition/code/cleanup_sandwich.py b/research/multicut-kernel-composition/code/cleanup_sandwich.py new file mode 100644 index 0000000000..7061ac3117 --- /dev/null +++ b/research/multicut-kernel-composition/code/cleanup_sandwich.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""Cleanup-sandwich cancellation (PR271's mechanism, evmckinney9) as a stage on the native six-int transcript. + +For each frozen helper a, the suffix of the word after the first kernel cut contains exactly three gates on a, + t += a, a += b, t += a (F2, in this order; the last is the family's Q^-1 pass) +and t is not a control strictly between the first and the last. Over F2 these equal a += b; t += b. The rewrite +emits a += b at the cut at the joint frame of a and b there (four-dimensional, nondegenerate for 9I - J), replaces +the middle gate by t += b at its frame and drops the first and last gates. The helper then has no gate after the +cut and ends at the joint frame instead of climbing to the full frame. Every MOVE is rebuilt from the actual +needs, every new connector is checked for exact rational inclusion, and the emitted word is replayed over F2 on +every formal source, target and dirty column with both omission controls. The stage writes the rewritten lead +directory, an export directory whose 249-states.json carries the new final frames (for the native legality +checker), and folds its histogram delta into the replay receipt. +usage: cleanup_sandwich.py EXPORT LEAD SELECTION OUTPUT +Adapted from research/cleanup-sandwich-263/sandwich263.py (Apache-2.0); Anthropic Claude assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from math import lcm +from pathlib import Path +import json, shutil, struct, sys +if not __debug__: raise SystemExit('assertions required') +H = 24; PRIME = 1000003 +X, L, SEL, O = map(Path, sys.argv[1:5]) +def load(p): return json.loads(Path(p).read_text()) +def rational_basis(rows): + basis = {} + for values in rows: + row = list(map(Q, values)) + for p, b in sorted(basis.items()): + if row[p]: row = [x - row[p]*y for x, y in zip(row, b)] + p = next((i for i, x in enumerate(row) if x), None) + if p is not None: basis[p] = [x/row[p] for x in row] + out = [] + for _, row in sorted(basis.items()): + d = lcm(*(x.denominator for x in row)); out.append([int(x*d) for x in row]) + return out +def rank_mod_prime(rows): + basis = {} + for row in rows: + row = [x % PRIME for x in row] + for p, b in sorted(basis.items()): + if row[p]: c = row[p]; row = [(x - c*y) % PRIME for x, y in zip(row, b)] + p = next((i for i, x in enumerate(row) if x), None) + if p is not None: inv = pow(row[p], -1, PRIME); basis[p] = [x*inv % PRIME for x in row] + return len(basis) +def annihilator(B): + pivots = [next(i for i, x in enumerate(row) if x) for row in B]; out = [] + for free in sorted(set(range(H)) - set(pivots)): + vec = [Q(i == free) for i in range(H)] + for p, row in reversed(list(zip(pivots, B))): vec[p] = -sum(Q(row[j])*vec[j] for j in range(p+1, H)) / row[p] + d = lcm(*(x.denominator for x in vec)); out.append([int(x*d) for x in vec]) + return out +def histogram(records): + h = Counter() + for op, a, b, c, f, z in records: + if op == 0 and f: h[f] += 1 + elif op == 2: h[z] += 1 + return h +sel = load(SEL); helpers = sel['helpers'] +frames = load(X/'frames.json')['frames']; lead_frames = load(L/'COHORT249-FRAMES.json'); frames.update(lead_frames) +states = load(X/'249-states.json'); n, v = states['n'], states['v'] +initial = {int(a): f for a, f in load(L/'COHORT249-INITIAL.json').items()} +blob = (L/'COHORT249-RECORDS.bin').read_bytes(); assert sha256(blob).hexdigest() == sel['input_record_sha256'] +old = list(struct.iter_unpack('<6i', blob)) +cut = next(i for i, r in enumerate(old) if r[0] == 1 and r[5] == 3) +zmax = max(r[5] for r in old if r[0] == 1); EARLY, SANDWICH = zmax + 1, zmax + 2 +at_cut = dict(initial) +for op, a, b, c, f, z in old[:cut]: + if op == 1: at_cut[a] = at_cut[b] = f + elif op == 2: at_cut[a], at_cut[b] = c, f + elif op == 3: del at_cut[b] +edits, skip, replace, new_frames = [], set(), {}, {} +next_id = max(int(k) for k in frames) + 1 +for a in helpers: + assert 2*v <= a < n and frames[str(initial[a])]['dim'] == 1 + gates = [(i, r) for i, r in enumerate(old) if i >= cut and r[0] == 1 and a in r[1:3]] + assert len(gates) == 3, ('helper must have exactly three gates after the cut', a) + (first, x), (middle, y), (last, w) = gates + t, b = x[1], y[2] + assert x[2] == a and y[1] == a and w[1:3] == (t, a), ('not a sandwich t+=a, a+=b, t+=a', a) + assert all(r[0] != 1 or r[2] != t for r in old[first+1:last]), ('t is a control inside the sandwich', a) + assert b not in helpers and t not in helpers, ('overlapping sandwiches', a) + B = rational_basis(frames[str(at_cut[a])]['B'] + frames[str(at_cut[b])]['B']) + assert len(B) == 4, ('the joint frame of a and b at the cut is not four-dimensional', a) + sums = [sum(u) for u in B] + gram = [[9*sum(p*q for p, q in zip(u, w2)) - su*sw for w2, sw in zip(B, sums)] for u, su in zip(B, sums)] + assert rank_mod_prime(gram) == 4, ('new frame is degenerate for 9I - J', a) + frame = next_id; next_id += 1; assert str(frame) not in frames + frames[str(frame)] = new_frames[str(frame)] = {'dim': 4, 'B': B, 'A': annihilator(B)} + skip.update((first, last)); replace[middle] = (1, t, b, y[3], y[4], SANDWICH) + edits.append({'helper': a, 'source': b, 'target': t, 'frame': frame, 'old_indices': [first, middle, last], 'entrance_frame': initial[a], 'cut_frames': [at_cut[a], at_cut[b]]}) +state, new, checked = dict(initial), [], set() +inherited = {(b, c) for op, a, b, c, f, z in old if op == 0} +def move(a, f): + before = state[a] + if before == f: return + if (before, f) not in inherited and (before, f) not in checked: + B, A = frames[str(before)]['B'], frames[str(f)]['A'] + assert all(sum(Q(p)*Q(q) for p, q in zip(u, w2)) == 0 for u in B for w2 in A), ('not nested', before, f) + checked.add((before, f)) + rank = frames[str(f)]['dim'] - frames[str(before)]['dim']; assert rank >= 0, ('frame retreats', a, before, f) + new.append((0, a, before, f, rank, 0)); state[a] = f +def emit(r): + op, a, b, c, f, z = r + if op == 1: move(a, f); move(b, f) + elif op == 2: move(a, c); state[b] = f + elif op == 3: assert state[a] == c and state[b] == f; del state[b] + new.append(r) +for i, r in enumerate(old): + if i == cut: + for e in edits: emit((1, e['helper'], e['source'], 1, e['frame'], EARLY)) + if r[0] != 0 and i not in skip: emit(replace.get(i, r)) +final = {int(a): f for a, f in states['final'].items()}; final.update({e['helper']: e['frame'] for e in edits}) +for a in range(n): move(a, final[a]) +assert state == final +def wrong_rows(records, omit=None): + rows = [1 << a for a in range(n)] + [0] + for op, a, b, c, f, z in records: + if op == 1 and c % 2 and z != omit: rows[a] ^= rows[b] + elif op == 2: rows[b] = rows[a] + elif op == 3: assert rows[a] == rows[b]; rows[b] = 0 + return sum(rows[a] != ((1 << a) ^ ((1 << (a - v)) if v <= a < 2*v else 0)) for a in range(n)) +assert wrong_rows(new) == 0, 'rewritten word fails the formal replay' +controls = {'omit early a += b': wrong_rows(new, EARLY), 'omit sandwich t += b': wrong_rows(new, SANDWICH)} +assert all(controls.values()), 'an omission control was accepted' +# chronological frame legality of the emitted word against the new final frames +st = dict(initial); copy = None; hist = Counter(); count = 0 +for op, a, b, c, f, z in new: + if op == 0: + assert st[a] == b and frames[str(c)]['dim'] - frames[str(b)]['dim'] == f; st[a] = c + if f: hist[f] += 1 + elif op == 1: assert st[a] == st[b] == f and a != b; count += 1 + elif op == 2: assert copy is None and st[a] == c; st[b] = f; hist[z] += 1; copy = (a, b, c) + else: assert copy == (a, b, c) and st[a] == c and st[b] == f; del st[b]; copy = None +assert st == final and copy is None +delta = Counter(hist); delta.subtract(histogram(old)); delta = {r: c for r, c in delta.items() if c} +assert sum(r*c for r, c in delta.items()) == -20*len(edits), 'endpoint rank mass must drop by 20 per helper' +assert delta == {int(k): c for k, c in sel['expected_local_histogram_delta'].items()}, ('histogram delta', delta) +data = b''.join(struct.pack('<6i', *r) for r in new) +# outputs: rewritten lead, export with the new final frames, folded replay receipt +O.mkdir(); (O/'export').mkdir() +for name in ('COHORT249-INITIAL.json', 'COHORT249-SELECTION.json', 'descent-selection.json', 'DESCENT-RETIMING.json', 'DESCENT-REBIND-EVIDENCE.json', 'PLATEAU-RETIMING.json', 'PLATEAU-SOURCE-SPANS.json', 'FRAME-TABLE-AUDIT.json', 'target-selection.json', 'TARGET-PREFIX.json'): + if (L/name).exists(): shutil.copy2(L/name, O/name) +(O/'COHORT249-RECORDS.bin').write_bytes(data); (O/'COHORT249-PRE-SANDWICH-RECORDS.bin').write_bytes(blob) +lead_frames.update(new_frames); (O/'COHORT249-FRAMES.json').write_text(json.dumps(lead_frames) + '\n') +for name in ('frames.json', '249-records.bin', '249-DONOR-OWNERSHIP.json'): shutil.copyfile(X/name, O/'export'/name) +states['final'].update({str(e['helper']): e['frame'] for e in edits}); (O/'export/249-states.json').write_text(json.dumps(states) + '\n') +replay = load(L/'COHORT249-REPLAY.json'); oldH = Counter({int(k): c for k, c in replay['histogram'].items()}); assert oldH == histogram(old) +total = Counter({int(k): c for k, c in replay['delta'].items()}); total.update(delta) +replay.update(status='CLEANUP_SANDWICH_CANCELLATION_NATIVE_BANK_REVIEW_NOT_APPLICABLE', pre_sandwich_records=len(old), new_records=len(new), pre_sandwich_histogram=replay['histogram'], + histogram={str(r): c for r, c in sorted(hist.items())}, delta={str(r): c for r, c in sorted(total.items()) if c}, sandwich_histogram_delta={str(r): c for r, c in sorted(delta.items())}, + sandwich_helpers_retired=len(edits), new_rank_mass=sum(r*c for r, c in hist.items())) +(O/'COHORT249-REPLAY.json').write_text(json.dumps(replay, indent=2) + '\n') +receipt = {'status': 'PASS_CLEANUP_SANDWICH_REWRITE_FORMAL_F2_COLUMNS_AND_FRAMES', 'helpers_retired': len(edits), 'cut_record': cut, 'input_sha256': sha256(blob).hexdigest(), 'output_sha256': sha256(data).hexdigest(), + 'formal_columns': n, 'omission_controls_wrong_rows': controls, 'new_connectors_checked': len(checked), 'new_frames': len(new_frames), 'histogram_delta': {str(r): c for r, c in sorted(delta.items()) if c}, + 'endpoint_rank_mass_drop': 20*len(edits), 'rank_mass': sum(r*c for r, c in hist.items()), 'paid_calls': sum(hist.values()), 'scalar_additions': count, 'early_category': EARLY, 'sandwich_category': SANDWICH, + 'selection_sha256': sha256(SEL.read_bytes()).hexdigest(), 'edits': edits} +(O/'CLEANUP-SANDWICH.json').write_text(json.dumps(receipt, indent=2) + '\n') +print('PASS cleanup sandwich', len(edits), 'helpers', 'controls', controls, 'delta', receipt['histogram_delta'], 'records', len(new), flush=True) diff --git a/research/multicut-kernel-composition/code/cohort-bank-review.cpp b/research/multicut-kernel-composition/code/cohort-bank-review.cpp new file mode 100644 index 0000000000..f560c6aee1 --- /dev/null +++ b/research/multicut-kernel-composition/code/cohort-bank-review.cpp @@ -0,0 +1,19 @@ +#include +#include +#include +using namespace std;using J=nlohmann::json;using Q=boost::multiprecision::cpp_rational;using Z=boost::multiprecision::cpp_int;using M=vector>; +J ld(string p){ifstream f(p);if(!f)throw runtime_error("missing "+p);J j;f>>j;return j;} +Q rat(J j){return j.is_string()?Q(j.get()):Q(j.get());}M eye(int n){M a(n,vector(n));for(int i=0;i(a.size()));for(int i=0;i(b[0].size()));for(int i=0;i=(Z(1)<<80)||d>=(Z(1)<<80))throw runtime_error("finite prime guard exceeded");} +M inverse(M a,int &ops,Q &det){int n=a.size();M b=eye(n);det=1;ops=0;for(int k=0;kpiv;for(int col=0;colv(n);v[free]=1;for(int i=0;iw;int count;}; +int main(int ac,char**av){if(ac!=6)throw runtime_error("args: baseline_export initial_json new_frames_json output_dir label");string inp=av[1],out=av[4];auto st=ld(inp+"/249-states.json"),fj=ld(inp+"/frames.json")["frames"],ini=ld(av[2]),nf=ld(av[3]);int n=st["n"],v=st["v"];mapdims;for(auto it=fj.begin();it!=fj.end();it++)dims[stoi(it.key())]=it.value()["dim"];for(auto it=nf.begin();it!=nf.end();it++)dims[stoi(it.key())]=it.value()["dim"]; +M G=eye(24);for(auto&r:G)for(auto&q:r)q-=Q(1)/9;J charts=J::array();int maxops=0;for(auto it=nf.begin();it!=nf.end();it++){int d=it.value()["dim"];M U;for(auto row:it.value()["B"]){vectorr;for(auto x:row)r.push_back(rat(x));U.push_back(r);}if(U.size()!=d)throw runtime_error("dim");auto UG=mul(U,G);auto V=nullspace(UG);M B=tr(V);for(int i=0;i<24;i++)for(int j=0;j548)throw runtime_error("inherited factor budget exceeded"); +map>fam,basefam;mapgauge,newfam;int sumdim=0,changed=0;for(int i=0;iexpectedbase{{4,2200},{6,22},{7,5},{11,48},{12,23},{15,2},{24,14287-changed}};for(auto[r,k]:expectedbase)if(basefam[r].size()!=k)throw runtime_error("base census mismatch");if(sumdim%3)throw runtime_error("need entrance rank sum divisible3 at40replicas"); +vectorpat;auto add=[&](vectorw,int count){if(count<0||accumulate(w.begin(),w.end(),0)!=120)throw runtime_error("pattern");if(count)pat.push_back({w,count});};auto repeated=[](int r,int n){return vector(n,r);};auto mix=[&](int r,int nr,int four){auto w=repeated(r,nr);w.insert(w.end(),four,4);return w;};add(mix(11,8,8),240);add(mix(7,4,23),50);add(repeated(6,20),44);add(repeated(12,10),92);add(repeated(15,8),10);int fill4=0;for(auto[r,k]:newfam){if(r<4||r>24)throw runtime_error("unsupported residual rank");fill4+=10*k*(30-r);add(mix(r,4,30-r),10*k);}if((84930-fill4)%30)throw runtime_error("rank4 remainder");add(repeated(4,30),(84930-fill4)/30);add(repeated(24,5),8*(14287-changed)); +struct Slot{int bank,off,r,block;};map>slots;int banks=0;J pj=J::array();for(auto pp:pat){pj.push_back({{"widths",pp.w},{"count",pp.count}});for(int b=0;b>(8*j))&255;hash*=1099511628211ull;}};long long assignments=0,mass=0,columns=0,controls=0;for(int stage=0;stage<5;stage++){vector>occ(banks);for(auto[r,rows]:fam)for(int i=0;is{};s[col]=1;vector>bl;int o=0;for(int r:pp.w){bl.push_back({o,r});o+=r;}if(rev)reverse(bl.begin(),bl.end());for(auto[o,r]:bl)for(int j=o;js{};s[col]=1;int o=0;for(int b=0;b +#include "json.hpp" +#include +#include +#include +#include +#include +#include +using namespace std;using namespace boost::multiprecision;using J=nlohmann::json;using I=cpp_int;using Q=cpp_rational; +void need(bool x,const char*s){if(!x)throw runtime_error(s);}J load(string p){ifstream f(p);need(bool(f),"missing input");J j;f>>j;return j;} +Q rat(string s){auto p=s.find('/');return p==string::npos?Q(I(s)):Q(I(s.substr(0,p)))/I(s.substr(p+1));}I ceilQ(Q x){return (numerator(x)+denominator(x)-1)/denominator(x);}struct E{int op,a,b,c,f,z;}; +int main(int argc,char**argv){try{need(argc==6,"usage RECORDS ROOT_PRICE BANK_RECEIPT FIVE_STAGE_RECEIPT OUTPUT");ifstream f(argv[1],ios::binary|ios::ate);size_t bytes=f.tellg();need(bytes%sizeof(E)==0,"ABI");vectorev(bytes/sizeof(E));f.seekg(0);f.read((char*)ev.data(),bytes);J price=load(argv[2])["cohort_candidate"],bank=load(argv[3]),global=load(argv[4]);mapH;I adds=0,units=0,copies=0;for(auto e:ev){if(e.op==0&&e.f)H[e.f]++;else if(e.op==1){adds++;units+=abs(e.c);}else if(e.op==2){H[e.z]++;copies++;}}need(copies==24&&adds>0&&units>=adds,"actualword inventory");int m=120,v=1760,R=16587,T=40,N=2*m,d=m*m,stock=bank["literal_stock"];need(stock==bank["normalized_stock"].get()*5&&bank["actual_role_replica_stage_assignments"]==3317400,"actualbanks");need(bank["new_exact_charts"].get()>0&&bank["max_new_chart_factors"]<=548&&I(bank["max_intermediate_denominator"].get())<(I(1)<<80)&&I(bank["max_intermediate_numerator"].get())<(I(1)<<80),"newchart invoice");mapL;for(auto[r,n]:H)L[r]+=200*n;for(int r:{4,23,46,50})L[r]+=40*2*v;I Ecount=0,mass=0;J hh=J::object();for(auto[r,n]:L){Ecount+=n;mass+=r*n;need(r<60,"half-shrink");hh[to_string(r)]=n.convert_to();need(n==5*price["histogram"][to_string(r)].get(),"fullH versusnormalizedprice");}need(m*I(stock)-mass==176000,"physicaldeficit");need(price["stock"].get()*5==stock,"literalstock notnormalized");Q mu=rat(price["moment_upper"]);need(mu<1,"strict moment");Q c=rat(price["coarse"]),deltaTau=1-mu,deltaLin=1-Q(mass)/(m*stock)-Q(32*m)*Ecount/(I("10000000000000000")*stock);need(deltaLin>0,"linear fallback");I Jroute=T*(24*v+10*R),good=8*m*m+8,high=16*I(d+1)*(d+1),K=2*5*T*(I(stock-1)+I(R)*120*787),weighted=T*(5*adds+6*v),unit=T*(5*units+6*v);need(K==bank["selector_charge"].get()&&K<(I(1)<<40),"all selector factors");I F=I(global["signed_lift_prefix"][0]["cancellation_free_signed_row_l1_upper"].get()),B=I(global["signed_lift_prefix"][1]["cancellation_free_signed_row_l1_upper"].get()),payload=64*F*F*F*B*B;need(payload<(I(1)<<104),"payload prefix");I coeff=unit+Jroute*high+Jroute*(stock+24)+Ecount*good+Ecount*(128*I(N)*N*N)+16*I(m)*m*m+120*T+Ecount+K+1;need(coeff<(I(1)<<80)&&2*I(m)*m*m*I("10000000000000000")<(I(1)<<80),"fixed coefficient below prime threshold");need(I(stock+24)<(I(1)<<80),"stocklessprime");Q previous=rat("384599/10000000000");J cuts=J::array();for(int stage=0;stage<3;stage++){Q a=(1-c)*c+c*previous;vectorgaps={c-a,1-a-c,1-a-c*(1-previous),1-c};Q gap=*min_element(gaps.begin(),gaps.end());need(gap>0,"ordinary cutoff gap");I L1=ceilQ(36/(gap*gap)),L2=ceilQ(2*(4+msb(coeff)+1)/gap),cut=max(I(1),max(L1,L2));need(Q(cut)*gap*gap>=36&&Q(cut)*gap>=2*(4+msb(coeff)+1),"cutoff inequality");cuts.push_back({{"stage",stage+1},{"minimum_gap",gap.str()},{"counted_coefficient_cutoff_log2",cut.convert_to()},{"general_rule","For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta))."}});previous=a;} +J out={{"status","PASS_COHORT_LITERAL_FIVE_STAGE_FINITE_INVOICE_AND_POSITIVE_CUTOFFS"},{"physical_replicas",T},{"literal_stock",stock},{"normalized_stock",price["stock"]},{"positive_rank_children",Ecount.convert_to()},{"literal_rank_mass",mass.convert_to()},{"literal_deficit",176000},{"literal_histogram",hh},{"global_weighted_additions",weighted.convert_to()},{"global_unit_expanded_additions",unit.convert_to()},{"route_families",Jroute.convert_to()},{"normalizer_factor_bound",787},{"new_chart_factor_max",bank["max_new_chart_factors"]},{"extra_selector_calls",K.convert_to()},{"full_counted_primitive_coefficient",coeff.convert_to()},{"primitive_coefficient_bits",msb(coeff)+1},{"payload_signed_prefix_upper",payload.convert_to()},{"payload_bits",msb(payload)+1},{"internal_row_coefficient",14401},{"external_complex_row_coefficient",20161},{"simultaneous_extra_work_streams",1},{"strict_moment_slack",deltaTau.str()},{"linear_moment_slack",deltaLin.str()},{"ordinary_cutoffs",cuts},{"scope","Sufficient finite invoice for the literal new cohort word, 40 physical replicas and fully admitted bank stock; original 48dim route, retained odd-prime rational address grid, common-ancestor compiler and complex recovery interfaces are inherited unchanged. No Lean or independent certification of those underlying public theorems asserted."}};ofstream(argv[5])< +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=1760,r=16587,loc=2*v+r,global=4*v+r,temp=global; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.srca((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +if(stage==1||stage==2||stage==4){int b=stage==1?0:stage==2?1:2;for(auto q:bridges[b])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<4;bank+=2)for(int i=0;i()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])< +#include +#include +using namespace std;using nlohmann::json;struct Ev{int k,a,b,c,f,z;};struct F{int d;vector>B,A;};json ld(string p){json j;ifstream(p)>>j;return j;}int main(int ac,char**av){if(ac!=4)return 2;string in=av[1],out=av[2];auto st=ld(in+"/249-states.json"),fj=ld(in+"/frames.json"),nf=ld(out+"/COHORT249-FRAMES.json"),ii=ld(out+"/COHORT249-INITIAL.json"),sel=ld(out+"/COHORT249-SELECTION.json"),own=ld(in+"/249-DONOR-OWNERSHIP.json");int n=st["n"],v=st["v"],zero=st["ZERO"];mapfs;long long maxabs=0;int oldmax=0;for(auto it=fj["frames"].begin();it!=fj["frames"].end();++it){int k=stoi(it.key());oldmax=max(oldmax,k);F f{it.value()["dim"],it.value()["B"],it.value()["A"]};for(auto M:{f.B,f.A})for(auto r:M)for(auto x:r)maxabs=max(maxabs,llabs(x));fs[k]=f;}for(auto it=nf.begin();it!=nf.end();++it){int k=stoi(it.key());if(fs.count(k))throw runtime_error("new frame collides");fs[k]={it.value()["dim"],it.value()["B"],it.value()["A"]};}map,bool>cache;long long contain=0;auto sub=[&](int a,int b){if(!fs.count(a)||!fs.count(b))throw runtime_error("unknown frame");auto k=make_pair(a,b);if(cache.count(k))return cache[k];contain++;bool ok=fs[a].d<=fs[b].d;for(auto r:fs[a].B)for(auto s:fs[b].A){boost::multiprecision::cpp_int d=0;for(int i=0;i<24;i++)d+=boost::multiprecision::cpp_int(r[i])*s[i];if(d)ok=false;}return cache[k]=ok;};setowners,donors,chosen;for(auto x:st["source_owned_roles"])owners.insert(x.get());for(auto x:own["donor_keys"])donors.insert(x.get());setpivots,partners;for(auto s:sel){int p=s["a"];if(!pivots.insert(p).second)throw runtime_error("repeated pivot");for(int r:s["partners"])partners.insert(r);}for(int p:pivots)if(partners.count(p))throw runtime_error("basis support is not square zero");for(auto s:sel){vectormembers=s["partners"].get>();members.push_back(s["a"]);for(int p:members){if(p<2*v||p>=n)throw runtime_error("invalid or overlapping helper");chosen.insert(p);int role=st["regs"][p-2*v];if(owners.count(role)||donors.count(role))throw runtime_error("source owner or donor selected");}int id=s["new_frame_id"];auto f=fs.at(id);if(f.d!=s["E_dimension"]||f.B.size()!=f.d||f.A.size()!=24-f.d)throw runtime_error("wrong new rank");for(auto r:f.A)for(auto b:f.B){boost::multiprecision::cpp_int d=0;for(int k=0;k<24;k++)d+=boost::multiprecision::cpp_int(r[k])*b[k];if(d)throw runtime_error("new ann mismatch");}} +vectorstate(n+1,zero);for(auto it=ii.begin();it!=ii.end();++it)state[stoi(it.key())]=it.value();bool copied=false;int copySource=-1;long long mov=0,adds=0,cop=0,era=0,mass=0;maphist;Ev e;ifstream f(out+"/COHORT249-RECORDS.bin",ios::binary);long long records=0;while(f.read((char*)&e,sizeof e)){records++;if(e.a<0||e.a>n||(e.k!=0&&(e.b<0||e.b>n)))throw runtime_error("bad role id");if(e.k==0){if(e.a==n&&!copied)throw runtime_error("move inactive temporary");if(state[e.a]!=e.b||!sub(e.b,e.c)||fs[e.c].d-fs[e.b].d!=e.f)throw runtime_error("illegal or mispriced MOVE");state[e.a]=e.c;if(e.f){hist[e.f]++;mass+=e.f;}mov++;}else if(e.k==1){if(state[e.a]!=e.f||state[e.b]!=e.f)throw runtime_error("ADD not in common frame");if((e.a==n||e.b==n)&&!copied)throw runtime_error("ADD inactive temporary");if(e.a==e.b)throw runtime_error("self ADD");if(copied&&(e.a==copySource||e.a==n))throw runtime_error("copied source or temporary mutated inside COPY window");adds++;}else if(e.k==2){if(copied||e.b!=n||state[e.a]!=e.c)throw runtime_error("invalid COPY lifecycle");if(e.z!=fs[e.c].d)throw runtime_error("COPY rank");copied=true;copySource=e.a;state[n]=e.f;hist[e.z]++;mass+=e.z;cop++;}else if(e.k==3){if(!copied||e.b!=n||e.a!=copySource||state[e.a]!=e.c||state[n]!=e.f)throw runtime_error("invalid ERASE lifecycle");copied=false;era++;}else throw runtime_error("unknown event");}if(copied||cop!=24||era!=24)throw runtime_error("unclosed COPY");for(int s=0;s +#include "json.hpp" +using namespace std;using J=nlohmann::json;struct E{int k,a,b,c,f,z;};J ld(string p){ifstream f(p);J j;f>>j;return j;} +int main(int ac,char**av){auto st=ld(string(av[1])+"/249-states.json"),sel=ld(string(av[2])+"/COHORT249-SELECTION.json");int n=st["n"],v=st["v"];mapidx;vectorroles;map>cuts;for(int i=0;i<(int)sel.size();i++){auto z=sel[i];vectorr=z["partners"].get>();r.push_back(z["a"]);for(int x:r)if(!idx.count(x)){idx[x]=roles.size();roles.push_back(x);}cuts[z["cut"].get()].push_back(i);}int W=(roles.size()+63)/64;vectorM((size_t)(n+1)*W);auto row=[&](int s){return &M[(size_t)s*W];};for(int j=0;j<(int)roles.size();j++)row(roles[j])[j/64]|=1ull<<(j%64);ifstream f(string(av[1])+"/249-records.bin",ios::binary);E e;long long equalities=0,identitybits=0,nonzero=0;int maxcut=cuts.rbegin()->first;for(int t=0;t<=maxcut;t++){if(!f.read((char*)&e,sizeof e))throw runtime_error("short stream");if(e.k==1&&(e.c&1))for(int w=0;wr=z["partners"].get>();r.push_back(z["a"]);for(int target=0;target>(c%64))&1;}if(parity)throw runtime_error("nonzero kernel response at own cut");equalities++;int c=idx.at(z["a"]);nonzero+=(row(v+target)[c/64]>>(c%64))&1;}for(int a:r){int c=idx.at(a);for(int s=0;s=2*v){bool bit=(row(s)[c/64]>>(c%64))&1;if(bit!=(s==a))throw runtime_error("non-target prefix influence");identitybits++;}}}} +J receipt={{"status","PASS_INDEPENDENT_MULTI_CUT_FULL_F2_KERNEL_AND_IDENTITY_COLUMNS"},{"cohorts",sel.size()},{"distinct_cuts",cuts.size()},{"distinct_helpers",roles.size()},{"target_kernel_equalities",equalities},{"non_target_identity_bits",identitybits},{"nonzero_pivot_target_entries",nonzero},{"scope","Original pinned-word response at every cohort own cut; combined emitted-word checks remain separate."}};ofstream(av[3])< +#include "json.hpp" +#include +#include +#include +#include +#include +using namespace std;using namespace boost::multiprecision;using J=nlohmann::json;using Q=cpp_rational;using I=cpp_int; +Q parse(string s){auto p=s.find('/');return p==string::npos?Q(I(s)):Q(I(s.substr(0,p)))/I(s.substr(p+1));} +Q get(J j){return j.is_string()?parse(j.get()):Q(j.get());} +J load(string p){ifstream f(p);if(!f)throw runtime_error(p);J j;f>>j;return j;} +Q down(Q x){I d=I(1)<<224;return Q(I(numerator(x)*d/denominator(x)))/d;} +Q up(Q x){I d=I(1)<<224;return Q(I((numerator(x)*d+denominator(x)-1)/denominator(x)))/d;} +pair logbase(Q x){Q z=(x-1)/(x+1),t=z,s=0;for(int i=0;i<48;i++){s+=2*t/(2*i+1);t*=z*z;}return {down(s),up(s+2*t/(97*(1-z*z)))};} +pair logbound_raw(Q x){int k=0;while(x>=2){x/=2;k++;}auto [l,u]=logbase(x);auto [a,b]=logbase(Q(2));return {down(l+k*a),up(u+k*b)};} +pair logbound(Q x){static map> cache;auto it=cache.find(x);if(it!=cache.end())return it->second;return cache[x]=logbound_raw(x);} +pair expbound(Q l,Q u){if(l<0||u>=Q(1)/10)throw runtime_error("exp domain");Q tl=1,tu=1,sl=1,su=1;for(int i=1;i<=32;i++){tl=down(tl*l/i);tu=up(tu*u/i);sl=down(sl+tl);su=up(su+tu);}return {sl,up(su+tu*u/33/(1-u/34))};} +pair moment(mapH,int m,int W,Q a){Q lo=0,hi=0;for(auto [r,n]:H){auto[l,u]=logbound(Q(m)/r);auto[e,f]=expbound(a*l,a*u);Q w=Q(r*n)/(m*W);lo+=w*e;hi+=w*f;}return {down(lo),up(hi)};} +map assembly(Q a,Q b,Q k,Q guard,Q rowgap){Q eta=Q(1)/parse("1000000000000"),beta=Q(1)/parse("1000000000"),tau=1-a,sigma=1-b,q=a*(1-2*eta),lp=1-q,lam=(tau+lp)/2,c=q+eta/4,eps=(1-eta)/(1+q),mi=eps*q,r=(mi+1-eps)/2,delta=eta/8,internal=tau+(1-beta)*max(Q(sigma-tau),Q(0)),leaf=sigma+beta*(1-sigma);maps={ +{"bit_positive",a},{"complex_above_bit",b-a},{"complex_below_1_32",Q(1)/32-b},{"beta_positive",beta},{"beta_below_one",1-beta},{"leaf_above_bit",(1-beta)*b-a}, +{"q_positive",q},{"q_below_internal",1-internal-q},{"q_below_leaf",1-leaf-q},{"c_positive",c},{"c_below_one",1-c},{"reservations",c-q},{"lambda_tau",lam-tau},{"lambda_sigma",lam-sigma},{"lambda_internal",lam-internal},{"lp_lambda",lp-lam},{"compact_leaf",lp-leaf},{"compact_reservations",lp-(1-c)},{"lp_below_one",q}, +{"eps_positive",eps},{"eps_below_one",1-eps},{"guard_width",1-eps},{"K_geometry",1-eps*(1+c)},{"K_log",eps*c},{"record_suffix",1-eps},{"phase_local",1-eps-delta},{"phase_boundary",r-delta},{"gamma_sublinear",1-eps-r},{"cell_band",eps-(1-r)/2},{"prime_pack",1-eps},{"alpha_positive",r},{"alpha_one",1-r},{"alpha_fourth",Q(1)/4-r},{"delta_positive",delta},{"delta_eighth",Q(1)/8-delta},{"record_fallback",eps-a},{"small_field",1-eps-mi},{"artificial",8-eps+r-delta-mi},{"literal_guard",guard},{"row_gap",rowgap}}; +vector margins={1-eps,a,mi,a,min(Q(1-eps-delta),Q(r-delta)),1-eps-delta,eps};for(int i=0;i<7;i++)s["margin"+to_string(i)]=margins[i]-k;return s;} + +pair momentbad(mapH,int m,int W,Q a){auto[l,u]=moment(H,m,W,a);long long N=0;for(auto[r,n]:H)N+=n;auto[fl,fu]=moment({{1,32LL*m*m*N}},m,W,a);return{l+fl/parse("10000000000000000"),u+fu/parse("10000000000000000")};} +J price(mapH,int W){long double l=.0007L,u=.00073L;auto app=[&](long double a){long double z=0,N=0;for(auto[r,n]:H){z+=(long double)n/W*pow((long double)r/120,1-a);N+=n;}return z+1e-16L*32*120*120*N/W*pow(1.L/120,1-a);};for(int i=0;i<80;i++){long double a=(l+u)/2;if(app(a)<1)l=a;else u=a;}long long proposal=(long long)(l*1e18L),low=proposal-10000,high=proposal+10000;Q grid=parse("1000000000000000000");if(momentbad(H,120,W,Q(low)/grid).second>=1||momentbad(H,120,W,Q(high)/grid).first<=1)throw runtime_error("proposal bracket");while(high-low>1){long long z=low+(high-low)/2;auto[a,b]=momentbad(H,120,W,Q(z)/grid);if(b<1)low=z;else if(a>1)high=z;else throw runtime_error("insufficient interval precision");}Q c=Q(low)/grid;auto[ml,mu]=momentbad(H,120,W,c);auto[nl,nu]=momentbad(H,120,W,c+1/grid);if(!(mu<1&&nl>1))throw runtime_error("coarse grid");Q bit=parse("384599/10000000000");J chain=J::array({bit.str()});for(int i=0;i<3;i++){bit=(1-c)*c+c*bit;chain.push_back(bit.str());}Q b=parse("747454944651775/1000000000000000000"),eta=parse("1/1000000000000"),q=bit*(1-2*eta),bound=(1-eta)*q/(1+q);I z=(numerator(bound)*I("1000000000000000000")-1)/denominator(bound);Q k=Q(z)/grid;auto constraints=assembly(bit,b,k,1,Q(1000000)-Q(51*20161)/25),adj=assembly(bit,b,k+1/grid,1,Q(1000000)-Q(51*20161)/25);int pass=0,fail=0;for(auto[name,x]:constraints)pass+=x>0;for(auto[name,x]:adj)fail+=x<=0;if(pass!=47||!fail)throw runtime_error("assembly");long long mass=0,count=0;J h=J::object();for(auto[r,n]:H){mass+=r*n;count+=n;h[to_string(r)]=n;}return{{"stock",W},{"histogram",h},{"rank_mass",mass},{"calls",count},{"deficit",120LL*W-mass},{"coarse",c.str()},{"coarse_decimal",c.convert_to()},{"moment_upper",mu.str()},{"next_coarse_moment_lower",nl.str()},{"bootstrap_chain",chain},{"ordinary_bit",bit.str()},{"kappa",k.str()},{"kappa_decimal",k.convert_to()},{"positive_constraints",pass},{"next_kappa_rejected",fail}};} +int main(int argc,char**argv){auto rec=load(argv[1]);if(rec["new_entrance_rank"].get()%3)throw runtime_error("40replica integrality");mapH;for(auto it=rec["histogram"].begin();it!=rec["histogram"].end();it++)H[stoi(it.key())]=40*it.value().get();for(int r:{4,23,46,50})H[r]+=16*1760;auto old=H;for(auto it=rec["delta"].begin();it!=rec["delta"].end();it++)old[stoi(it.key())]-=40*it.value().get();J baseline=price(old,173883),candidate=price(H,173883-rec["new_entrance_rank"].get()/3);if(baseline["kappa"]!="88799023305857/125000000000000000")throw runtime_error("baseline kappa mismatch");J out={{"status","PASS_EXACT_COHORT_CONDITIONAL_PRICING_47_AND_ADJACENT_CONTROLS"},{"baseline",baseline},{"cohort_candidate",candidate},{"bank_completion_required",true},{"finite_bill_and_all_size_interfaces_not_reproved",true},{"method","C++ exact rational 224-bit directed bounds; floating used only to propose a bracket verified exactly;32-degree exponential and48-term atanh logarithm"}};ofstream(argv[2])< +#include +#include +using Q=boost::multiprecision::cpp_rational; +#include +#include +#include +#include +#include +#include +#include "json.hpp" +using namespace std;using J=nlohmann::json;struct Ev{int k,a,b,c,f,z;};struct Frame{int d;vector>B,A;}; +int main(int argc,char**argv){string dir=argv[1],outdir=argv[3];J st,fj,cc;ifstream(dir+"/249-states.json")>>st;ifstream(dir+"/frames.json")>>fj;ifstream(argv[2])>>cc;mapfs;int nextid=200000;for(auto it=fj["frames"].begin();it!=fj["frames"].end();it++){Frame f;f.d=it.value()["dim"];f.B=it.value()["B"].get>>();f.A=it.value()["A"].get>>();fs[stoi(it.key())]=move(f);}fj.clear();map,bool>cache;auto sub=[&](int a,int b){auto key=make_pair(a,b);auto it=cache.find(key);if(it!=cache.end())return it->second;bool ok=fs[a].d<=fs[b].d;if(ok)for(auto&x:fs[a].B){for(auto&y:fs[b].A){__int128 t=0;for(int i=0;i<24;i++)t+=(__int128)x[i]*y[i];if(t){ok=false;break;}}if(!ok)break;}return cache[key]=ok;};vectorev;Ev x;ifstream in(dir+"/249-records.bin",ios::binary);while(in.read((char*)&x,sizeof x))ev.push_back(x);int n=st["n"],v=st["v"],zero=st["ZERO"],full=st["FULL"],cut=-1;for(int i=0;i<(int)ev.size();i++)if(ev[i].k==1&&ev[i].a==3491&&ev[i].b==3488&&ev[i].c==-1&&ev[i].z==25){if(cut>=0)throw runtime_error("ambiguous cut");cut=i;}if(cut<0)throw runtime_error("cut absent");vectorini(n+1,zero),fin(n+1,full);for(auto it=st["initial"].begin();it!=st["initial"].end();it++)ini[stoi(it.key())]=it.value();for(auto it=st["final"].begin();it!=st["final"].end();it++)fin[stoi(it.key())]=it.value();J chosen=J::array(),newframes=J::object();setused;struct Gauge{vectorpartners;int F;int cut;};mapgauges;long long totaldim=0,basisgates=0; +J candidates=cc.is_array()?cc:cc["candidates"];setbaseused;for(auto z:candidates){baseused.insert(z["a"].get());for(int r:z["partners"])baseused.insert(r);}for(int file=4;file>q;for(auto z:q["candidates"]){bool ok=true;for(int r:z["roles"])if(baseused.count(r))ok=false;if(!ok)continue;for(int r:z["roles"])baseused.insert(r);candidates.push_back(z);}} +int sd=0;for(auto z:candidates)sd+=z.contains("roles")?z["dim"].get():z["E_dimension"].get();int drop=sd%3;J filtered=J::array();for(auto z:candidates){if(drop&&(z.contains("roles")?z["dim"].get():z["E_dimension"].get())==1){drop--;continue;}filtered.push_back(z);}if(drop)throw runtime_error("cannot normalize40 replicas");candidates=filtered; +setpivotset,donorset;for(auto z:candidates){int a=z.contains("roles")?z["pivot"].get():z["a"].get();if(!pivotset.insert(a).second)throw runtime_error("duplicate pivot");vectorr=z.contains("roles")?z["roles"].get>():vector{a,z["b"].get()};for(int b:r)if(b!=a)donorset.insert(b);}for(int p:pivotset)if(donorset.count(p))throw runtime_error("non-nilpotent basis support"); + +for(auto z:candidates){int ci=z.value("cut",cut);bool triple=z.contains("roles");int a=triple?z["pivot"].get():z["a"].get();vectormembers=triple?z["roles"].get>():vector{a,z["b"].get()};int ed=triple?z["dim"].get():z["E_dimension"].get();bool skip=false;for(int r:members)if(ini[r]!=zero||fin[r]!=full)skip=true;if(skip)throw runtime_error("selected initial or final frame changed");if(!triple&&!z["new_targets"].empty())continue; +Frame f;f.d=ed;auto clearrow=[&](vector r){using I=boost::multiprecision::cpp_int;I d=1;for(auto x:r){I a=d,b=denominator(x);while(b!=0){I t=a%b;a=b;b=t;}d=d/a*denominator(x);}vectorv;for(auto x:r){Q q=x*d;I n=numerator(q);if(n>LLONG_MAX||n());}return v;};for(auto rr:z["basis"]){vectorr;for(auto vv:rr){string t=vv.is_string()?vv.get():to_string(vv.get());auto k=t.find('/');using I=boost::multiprecision::cpp_int;r.push_back(k==string::npos?Q(I(t)):Q(I(t.substr(0,k)))/I(t.substr(k+1)));}f.B.push_back(clearrow(r));} +// Exact ordinary annihilator. Frame nondegeneracy is independently audited by the bank checker. +vector>A;for(auto rr:f.B){vectorr;for(auto x:rr)r.push_back(Q(x));A.push_back(r);}vectorpiv;int rr=0;for(int c=0;c<24;c++){int k=rr;while(k<(int)A.size()&&A[k][c]==0)k++;if(k==(int)A.size())continue;swap(A[k],A[rr]);Q q=A[rr][c];for(int j=0;j<24;j++)A[rr][j]/=q;for(int i=0;i<(int)A.size();i++)if(i!=rr){q=A[i][c];for(int j=0;j<24;j++)A[i][j]-=q*A[rr][j];}piv.push_back(c);rr++;}if(rr!=ed)throw runtime_error("dependent entrance basis");for(int c=0;c<24;c++)if(find(piv.begin(),piv.end(),c)==piv.end()){vectorr(24);r[c]=1;for(int i=0;ipartners;for(int r:members){int first=-1;for(int i=ci+1;i<(int)ev.size();i++){auto e=ev[i];if(e.k==1&&(e.a==r||e.b==r)){first=e.f;break;}if(e.k==2&&e.a==r){first=e.c;break;}}if(first<0||!sub(F,first))throw runtime_error("false actual first-frame intersection");for(int i=0;i<=ci;i++){auto e=ev[i];if(e.k&&((e.k==1&&e.a==r)||(e.k!=1&&(e.a==r||e.b==r))))throw runtime_error("cohort touched before cut");if(e.k==1&&e.b==r&&!(e.z==4&&e.f==zero&&e.a>=v&&e.a<2*v))throw runtime_error("bad prefix read");}used.insert(r);if(r!=a)partners.push_back(r);} +gauges[a]={partners,F,ci};z["cut"]=ci;totaldim+=ed;basisgates+=2*partners.size();z["a"]=a;z["partners"]=partners;z["E_dimension"]=ed;z["new_frame_id"]=F;z["role_a"]=st["regs"][a-2*v];z["basis"]=J::array();for(auto r:f.B){J row=J::array();for(auto x:r)row.push_back(to_string(x));z["basis"].push_back(row);}chosen.push_back(z);newframes[to_string(F)]={{"B",f.B},{"A",f.A},{"dim",ed}};} +if(chosen.empty())throw runtime_error("no selected pairs");vectorgorder;for(auto[a,g]:gauges)gorder.push_back(a);stable_sort(gorder.begin(),gorder.end(),[&](int a,int b){return fs[gauges[a].F].dstate=ini;for(auto&[a,bf]:gauges)state[a]=bf.F;vectornewini=state;vectorout;long long removed=0,weighted=0;mapH,oldH;for(auto e:ev){if(e.k==0&&e.f)oldH[e.f]++;else if(e.k==2)oldH[e.z]++;}auto moveTo=[&](int s,int f){if(state[s]==f)return;if(!sub(state[s],f)){cerr<<"bad move "<&word,bool reverse,int omitcat){int words=(n+63)/64;vectorM((size_t)(n+1)*words);auto row=[&](int s){return &M[(size_t)s*words];};for(int s=0;s=v&&s<2*v&&(s-v)/64==j)expected^=1ull<<((s-v)%64);bad+=row(s)[j]!=expected;}return bad;};if(replay(out,false,-1)||replay(out,true,-1))throw runtime_error("full columns fail");auto badQ=replay(out,false,28),badQi=replay(out,false,29);if(!badQ||!badQi)throw runtime_error("vacuous control");long long mass=0,oldmass=0;J hist=J::object(),delta=J::object();for(auto[r,c]:H){hist[to_string(r)]=c;mass+=r*c;}for(auto[r,c]:oldH)oldmass+=r*c;setrs;for(auto[r,c]:H)rs.insert(r);for(auto[r,c]:oldH)rs.insert(r);for(int r:rs)if(H[r]!=oldH[r])delta[to_string(r)]=H[r]-oldH[r];if(oldmass-mass!=totaldim)throw runtime_error("rank bill mismatch");ofstream bout(outdir+"/COHORT249-RECORDS.bin",ios::binary);bout.write((char*)out.data(),out.size()*sizeof(Ev));J ii=J::object();for(int s=0;s "< 1: v = [x//g for x in v] + f = next((x for x in v if x), 0) + return tuple(-x for x in v) if f < 0 else tuple(v) + +def rank(rows): + M = [[Fraction(x) for x in r] for r in rows]; r = 0 + for c in range(len(M[0]) if M else 0): + p = next((i for i in range(r, len(M)) if M[i][c]), None) + if p is None: continue + M[r], M[p] = M[p], M[r]; pv = M[r][c]; M[r] = [x/pv for x in M[r]] + for i in range(len(M)): + if i != r and M[i][c]: + m = M[i][c]; M[i] = [x-m*y for x, y in zip(M[i], M[r])] + r += 1 + if r == len(M): break + return r + +frames = {} +for name in (X/'frames.json', LEAD/'COHORT249-FRAMES.json'): + j = json.loads(name.read_text()); j = j.get('frames', j) + for k, rec in j.items(): + frames[int(k)] = dict(B=[list(map(int, r)) for r in rec['B']], A=[list(map(int, r)) for r in rec['A']], d=int(rec['dim'])) +for f, fr in frames.items(): + assert len(fr['B']) == fr['d'] and len(fr['A']) + fr['d'] == H and all(dot(a, b) == 0 for a in fr['A'] for b in fr['B']) +by_key = {} +for f in sorted(frames): by_key.setdefault(rref_key(frames[f]['B']) if frames[f]['B'] else (), f) +canon = {f: by_key[rref_key(frames[f]['B']) if frames[f]['B'] else ()] for f in frames} +subcache = {} +def sub(f, g): + if f == g: return True + k = (f, g) + if k not in subcache: subcache[k] = frames[f]['d'] <= frames[g]['d'] and all(dot(a, b) == 0 for a in frames[g]['A'] for b in frames[f]['B']) + return subcache[k] +def nondeg(f): + B, A = frames[f]['B'], frames[f]['A'] + if not B or len(B) == H: return True + if len(B) <= len(A): + s = [sum(b) for b in B]; return rank([[9*dot(B[i], B[j]) - s[i]*s[j] for j in range(len(B))] for i in range(len(B))]) == len(B) + s = [sum(a) for a in A]; return rank([[(9-H)*dot(A[i], A[j]) + s[i]*s[j] for j in range(len(A))] for i in range(len(A))]) == len(A) + +st = json.loads((X/'249-states.json').read_text()); n, v = st['n'], st['v']; ZERO, FULL = st['ZERO'], st['FULL'] +initial = {int(k): f for k, f in json.loads((LEAD/'COHORT249-INITIAL.json').read_text()).items()} +sel = json.loads(SEL.read_text()) +old = array('i'); old.frombytes((LEAD/'COHORT249-RECORDS.bin').read_bytes()); assert old.itemsize == 4 and len(old) % 6 == 0 +assert hashlib.sha256(old.tobytes()).hexdigest() == sel['input_record_sha256'] and len(old)//6 == sel['input_record_count'] +final = dict(initial) +for k in range(0, len(old), 6): + if old[k] == 0: final[old[k+1]] = old[k+3] +assert all(final[i] == FULL for i in initial if i < v or i >= 2*v) +cov = [list(map(int, c)) for c in st['source_covectors']] +chi = {s: frames[initial[s]]['B'][0] for s in range(v)} +for s in range(v): assert frames[initial[s]]['d'] == 1 +# selected gates: bound by ADD ordinal among non-MOVE records and by scalar content +nonmove = [k//6 for k in range(0, len(old), 6) if old[k]] +chosen = {}; changed = [] +for r in sel['entries']: + i = nonmove[r['gate']]; assert i not in chosen + op, a, b, c, f, z = old[6*i:6*i+6] + assert op == 1 and b != n and [a, b, c, z] == r['scalar'] and frames[f]['d'] == r['old_dimension'] + assert rref_key(frames[f]['B']) == rref_key([list(map(int, x)) for x in r['old_basis']]), 'old frame basis mismatch' + g = by_key.get(rref_key([list(map(int, x)) for x in r['new_basis']])); assert g is not None, 'new frame absent from exported tables' + assert frames[g]['d'] == r['new_dimension'] and nondeg(g) and canon[g] != canon[f] + chosen[i] = g; changed.append(dict(record=i, gate=r['gate'], old_frame=f, new_frame=g, old_dimension=frames[f]['d'], new_dimension=frames[g]['d'])) +assert len(chosen) == sel['selected_gate_count'] > 0 +# exact integer source spans after each selected gate +columns = [{i: 1} if i < v else {} for i in range(n)]; center = None; spans = {} +for k in range(0, len(old), 6): + op, a, b, c, f, z = old[k:k+6] + if op == 0: continue + if op == 2: assert center is None; center = a; continue + if op == 3: assert center == a; center = None; continue + source = center if b == n else b; ca = columns[a] + for s, x in columns[source].items(): + y = ca.get(s, 0) + c*x + if y: ca[s] = y + else: del ca[s] + if k//6 in chosen: + need = set() + if not (v <= a < 2*v): need.update(ca) + if not (v <= b < 2*v) and b != n: need.update(columns[b]) + spans[k//6] = sorted(need) +assert center is None +for i, g in chosen.items(): + for s in spans[i]: assert all(dot(x, chi[s]) == 0 for x in frames[g]['A']), ('retimed frame omits operand source span', i, s) +# rebuild MOVEs from the retimed needs +state = dict(initial); out = array('i'); copy = None +def move(s, f): + before = state[s] + if before == f: return + assert sub(before, f), ('descent frame nesting', s, before, f) + gap = frames[f]['d'] - frames[before]['d']; assert gap >= 0 + out.extend((0, s, before, f, gap, 0)); state[s] = f +for k in range(0, len(old), 6): + op, a, b, c, f, z = old[k:k+6] + if op == 0: continue + if op == 1: + g = chosen.get(k//6, f) + if copy is not None and k//6 in chosen: assert a != copy[0] and b != copy[0] + move(a, g) + if b == n: assert g == f == ZERO and copy is not None + else: move(b, g) + out.extend((op, a, b, c, g, z)) + elif op == 2: + assert copy is None and b == n; move(a, c); state[b] = f; copy = (a, b, c); out.extend((op, a, b, c, f, z)) + else: + assert op == 3 and copy == (a, b, c) and state[a] == c and state[b] == f + out.extend((op, a, b, c, f, z)); del state[b]; copy = None +assert copy is None +for s in sorted(final): move(s, final[s]) +assert state == final +def projection(a): + return hashlib.sha256(b''.join(a[k:k+4].tobytes() + a[k+5:k+6].tobytes() for k in range(0, len(a), 6) if a[k])).hexdigest() +assert projection(old) == projection(out) +# independent census from needs and endpoints; ranks are exact dimension gaps +needs = {i: [] for i in initial}; copies = Counter(); copy = None +for k in range(0, len(out), 6): + op, a, b, c, f, z = out[k:k+6] + if op == 1: + assert c % 2; needs[a].append(f) + if b != n: needs[b].append(f) + else: assert copy is not None and f == ZERO + elif op == 2: assert copy is None; copy = (a, b, c); needs[a].append(c); copies[frames[c]['d']] += 1 + elif op == 3: assert copy == (a, b, c); copy = None +assert copy is None and copies == {22: 24} +census = Counter(copies); pairs = set() +for s, before in initial.items(): + for f in needs[s] + [final[s]]: + assert sub(before, f); r = frames[f]['d'] - frames[before]['d'] + if r: census[r] += 1 + pairs.add((before, f)); before = f +for f in {f for pair in pairs for f in pair}: assert nondeg(f) +for a, b in pairs: assert len(frames[b]['A']) <= len(frames[a]['A']) and all(dot(x, y) == 0 for x in frames[b]['A'] for y in frames[a]['B']) +for t in range(v): + f = final[v+t]; assert frames[f]['d'] == 23 and all(dot(cov[t], b) == 0 for b in frames[f]['B']) +hist = Counter(); state = dict(initial); copy = None; count = 0 +for k in range(0, len(out), 6): + op, a, b, c, f, z = out[k:k+6] + if op == 0: + assert state[a] == b and sub(b, c) and frames[c]['d'] - frames[b]['d'] == f; state[a] = c + if f: hist[f] += 1 + elif op == 1: assert state[a] == state[b] == f and a != b; count += 1 + elif op == 2: assert copy is None and state[a] == c and f == ZERO and z == 22; state[b] = f; hist[z] += 1; copy = (a, b, c) + else: assert copy == (a, b, c) and state[a] == c and state[b] == f == ZERO; del state[b]; copy = None +assert state == final and hist == census and copy is None +replay = json.loads((LEAD/'COHORT249-REPLAY.json').read_text()) +oldH = Counter({int(r): c for r, c in replay['histogram'].items()}) +delta = Counter(hist); delta.subtract(oldH); delta = {r: c for r, c in delta.items() if c} +assert delta == {int(r): c for r, c in sel['expected_local_histogram_delta'].items()}, ('histogram delta', delta) +assert sum(r*c for r, c in hist.items()) == sum(r*c for r, c in oldH.items()) == replay['new_rank_mass'] == sel['expected_rank_mass'] +assert sum(hist.values()) == sum(oldH.values()) - sel['expected_removed_calls'] and count == sel['expected_scalar_additions'] +(LEAD/'COHORT249-PRE-DESCENT-RECORDS.bin').write_bytes(old.tobytes()) +(LEAD/'COHORT249-RECORDS.bin').write_bytes(out.tobytes()) +# 'delta' stays the total change against the pinned PR249 baseline, which the price checker rebuilds from it. +combined = Counter({int(r): c for r, c in replay['delta'].items()}); combined.update(delta); combined = {r: c for r, c in combined.items() if c} +replay.update(status='PASS_FULL_CURRENT249_COHORT_REWRITE_AND_CONCAVE_DESCENT_RETIMING', cohort_rewrite_records=len(old)//6, new_records=len(out)//6, + cohort_rewrite_histogram=replay['histogram'], cohort_rewrite_delta=replay['delta'], histogram={str(r): c for r, c in sorted(hist.items())}, + delta={str(r): c for r, c in sorted(combined.items())}, descent_delta={str(r): c for r, c in sorted(delta.items())}, + descent_retimed_gates=len(changed), descent_removed_calls=sel['expected_removed_calls']) +(LEAD/'COHORT249-REPLAY.json').write_text(json.dumps(replay, indent=2) + '\n') +receipt = dict(status='PASS_CONCAVE_DESCENT_RETIMING_AND_BOTH_REFLECTED_LEDGERS', selected_gate_count=len(changed), changed_gates=changed, + removed_calls=sel['expected_removed_calls'], local_histogram_delta={str(r): c for r, c in sorted(delta.items())}, + rank_mass=sum(r*c for r, c in hist.items()), paid_calls=sum(hist.values()), scalar_additions=count, + identical_scalar_and_copy_projection=True, both_reflected_ledgers=True, unchanged_all_input_output_frames=True, + unchanged_copy_lifetimes=True, operand_source_spans_contained=True, checked_operand_spans=sum(len(s) for s in spans.values()), + unique_required_frame_pairs=len(pairs), input_record_sha256=sel['input_record_sha256'], output_record_sha256=hashlib.sha256(out.tobytes()).hexdigest(), + selection_sha256=hashlib.sha256(SEL.read_bytes()).hexdigest()) +(LEAD/'DESCENT-RETIMING.json').write_text(json.dumps(receipt, indent=2) + '\n') +print('PASS concave descent retiming', len(changed), 'gates', sum(hist.values()), 'paid calls', len(out)//6, 'records', flush=True) diff --git a/research/multicut-kernel-composition/code/export249.py b/research/multicut-kernel-composition/code/export249.py new file mode 100644 index 0000000000..9913c9d89d --- /dev/null +++ b/research/multicut-kernel-composition/code/export249.py @@ -0,0 +1,24 @@ +from pathlib import Path +import json,sys,importlib.util,time,hashlib,gzip +from collections import Counter +P=Path(sys.argv[1]).resolve();D=Path(sys.argv[2]).resolve();D.mkdir(parents=True,exist_ok=True);sys.dont_write_bytecode=True;sys.path.insert(0,str(P));start=time.monotonic() +def load(n): + s=importlib.util.spec_from_file_location('temporal249_'+n,P/(n+'.py'));m=importlib.util.module_from_spec(s);sys.modules[s.name]=m;s.loader.exec_module(m);return m +def save(n,j):(D/n).write_text(json.dumps(j,separators=(',',':'))+'\n',encoding='utf8') +def export(n,p): + records=p['records'];(D/(n+'-records.bin')).write_bytes(records.tobytes());(D/(n+'-records.bin.gz')).write_bytes(gzip.compress(records.tobytes(),mtime=0));final=dict(p['initial_state']);F=set(final.values()) + for k in range(0,len(records),6): + op,a,b,c,f,z=records[k:k+6] + if op==0:final[a]=c;F.update((b,c)) + elif op==1:F.add(f) + elif op in(2,3):F.update((c,f)) + save(n+'-states.json',dict(initial=p['initial_state'],final=final,ZERO=p['ZERO'],FULL=p['FULL'],n=20107,v=1760,record_count=len(records)//6,record_sha256=hashlib.sha256(records.tobytes()).hexdigest(),physical=p['physical'],regs=p['context']['regs'],borrowed=list(p['context']['borrow']),removed=list(p['context']['removed']),source_owned_roles=sorted(p['context']['borrow']),source_covectors=p['C'].cov)) + return F +c=load('prepare').prepare();print('PREPARED',time.monotonic()-start,flush=True) +p=load('code/physical527').run(c,c['SOURCE_TEXT']);p=load('parity_transform').run(p);p=load('retiming_transform').run(p);used=export('pre249',p);print('PRE249 exported',time.monotonic()-start,flush=True) +m=load('regauge_transform');selection=json.loads((P/'regauge-selection.json').read_text());out,initial,final,entries,execution_context,proof=m.transform(p,selection) +q=dict(p,records=out,initial_state=initial,context=execution_context,W=execution_context['W']);used.update(export('249',q));save('249-transport-proof.json',proof) +C=p['C'];save('frames.json',dict(h=24,frames={str(f):dict(B=C.B[f],A=C.A[f],dim=C.dimf[f])for f in sorted(used)})) +save('EXPORT-RECEIPT.json',dict(status='PASS_EXACT_EMITTER_AND_TRANSPORT_EXPORT_NOT_FULL8_REPLAY',head='96495746c786d6d0339dbb38c7f553d4af3f88ed',frames=len(used),pre_record_sha256=hashlib.sha256(p['records'].tobytes()).hexdigest(),new_record_sha256=hashlib.sha256(out.tobytes()).hexdigest(),seconds=time.monotonic()-start,scope='Fresh source observer, exact frame emitter, parity filter, retiming, and literal249 compensation transform. Does not rerun global geometry, bank, primes, final pricing or complete public8stages.')) +print('COMPLETE shared current249 export',len(used),'frames',time.monotonic()-start,flush=True) +save('REGENERATED-DONORS.json',dict(donor_keys=sorted(q['context']['W'].donor))) diff --git a/research/multicut-kernel-composition/code/plateau_retiming.py b/research/multicut-kernel-composition/code/plateau_retiming.py new file mode 100644 index 0000000000..1227805310 --- /dev/null +++ b/research/multicut-kernel-composition/code/plateau_retiming.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +import argparse,json,hashlib,shutil,sys +from pathlib import Path +from array import array +from collections import Counter +if not __debug__:raise SystemExit('assertions are required') +assert sys.byteorder=='little' and array('i').itemsize==4 +ap=argparse.ArgumentParser();ap.add_argument('export',type=Path);ap.add_argument('lead',type=Path);ap.add_argument('scan',type=Path);ap.add_argument('output',type=Path);args=ap.parse_args() +X,L,O=args.export,args.lead,args.output;O.mkdir() +for name in ('COHORT249-INITIAL.json','COHORT249-SELECTION.json','descent-selection.json', + 'DESCENT-RETIMING.json','DESCENT-REBIND-EVIDENCE.json'): + shutil.copy2(L/name,O/name) +fs={int(k):v for k,v in json.loads((X/'frames.json').read_text())['frames'].items()};new={int(k):v for k,v in json.loads((L/'COHORT249-FRAMES.json').read_text()).items()};fs.update(new) +scan=json.loads(args.scan.read_text());added={int(k):v for k,v in scan.get('newframes',{}).items()} +assert not set(added)&set(fs),'plateau frame ID collision' +from verify_frames import validate +for frame in added.values():validate(frame) +fs.update(added) +chosen=[];roles=set();mutations={};expected=Counter() +for c in scan['candidates']: + assert not set(c['roles'])&roles,'frozen plateau roles overlap' + chosen.append(c);roles.update(c['roles']);expected.update({int(k):v for k,v in c['delta'].items()}) + for g in c['gates']:assert g not in mutations;mutations[g]=(c['old_frame'],c['new_frame']) + if str(c['new_frame']) in scan.get('newframes',{}):new[c['new_frame']]=fs[c['new_frame']] +print('selected',len(chosen),'gates',len(mutations),'entropy_gain',sum(c['entropy_gain'] for c in chosen),'delta',dict(expected),flush=True) +raw=array('i');raw.frombytes((L/'COHORT249-RECORDS.bin').read_bytes());events=[tuple(raw[k:k+6]) for k in range(0,len(raw),6) if raw[k]] +assert len(raw)%6==0 +assert hashlib.sha256(raw.tobytes()).hexdigest()==scan['input_sha256'],'frozen plateau input mismatch' +st=json.loads((X/'249-states.json').read_text());n=st['n'];initial={int(k):v for k,v in json.loads((L/'COHORT249-INITIAL.json').read_text()).items()};final={int(k):v for k,v in st['final'].items()};state=dict(initial);out=array('i');cache={};hist=Counter();copy=None +def sub(a,b): + if a==b:return True + if (a,b) not in cache:cache[a,b]=fs[a]['dim']<=fs[b]['dim'] and all(sum(x*y for x,y in zip(u,v))==0 for u in fs[a]['B'] for v in fs[b]['A']) + return cache[a,b] +def move(s,f): + p=state[s] + if p==f:return + assert sub(p,f),(s,p,f) + r=fs[f]['dim']-fs[p]['dim'];out.extend((0,s,p,f,r,0));state[s]=f + if r:hist[r]+=1 +for i,(op,a,b,c,f,z) in enumerate(events): + if op==1: + if i in mutations: + old,fnew=mutations[i];assert old==f;f=fnew + move(a,f);move(b,f);out.extend((op,a,b,c,f,z)) + elif op==2: + assert copy is None and b==n;move(a,c);state[b]=f;copy=(a,b,c,f);hist[z]+=1;out.extend((op,a,b,c,f,z)) + else: + assert op==3 and copy==(a,b,c,f) and state[a]==c and state[b]==f;del state[b];copy=None;out.extend((op,a,b,c,f,z)) +for s in sorted(final):move(s,final[s]) +assert copy is None and state==final +def projection(a):return hashlib.sha256(b''.join(a[k:k+4].tobytes()+a[k+5:k+6].tobytes() for k in range(0,len(a),6) if a[k])).hexdigest() +assert projection(raw)==projection(out) +replay=json.loads((L/'COHORT249-REPLAY.json').read_text());oldH=Counter({int(k):v for k,v in replay['histogram'].items()});delta=Counter(hist);delta.subtract(oldH);delta={k:v for k,v in delta.items() if v};expected={k:v for k,v in expected.items() if v};assert delta==expected,(delta,expected) +assert delta=={int(k):v for k,v in scan['expected_delta'].items() if v} +assert set(mutations)<=set(range(len(events))) and all(events[g][0]==1 for g in mutations) +assert sum(k*v for k,v in hist.items())==sum(k*v for k,v in oldH.items()) +assert sum(hist.values())==sum(oldH.values()) +total=Counter({int(k):v for k,v in replay['delta'].items()});total.update(delta) +replay.update(status='EXPERIMENTAL_CONNECTED_PLATEAU_RETIMING',histogram={str(k):v for k,v in sorted(hist.items())},delta={str(k):v for k,v in sorted(total.items()) if v},plateau_histogram_delta=delta,new_records=len(out)//6) +(O/'COHORT249-REPLAY.json').write_text(json.dumps(replay,indent=2)+'\n');(O/'COHORT249-RECORDS.bin').write_bytes(out.tobytes());(O/'COHORT249-FRAMES.json').write_text(json.dumps(new)+'\n') +receipt=dict(status='FINITE_TRANSCRIPT_REWRITE_CHECKED_NATIVE_CHECKERS_PENDING',selected=chosen,delta=delta,unchanged_scalar_copy_projection=projection(raw),input_sha256=hashlib.sha256(raw.tobytes()).hexdigest(),output_sha256=hashlib.sha256(out.tobytes()).hexdigest(),paid_calls=sum(hist.values()),rank_mass=sum(k*v for k,v in hist.items())) +(O/'PLATEAU-RETIMING.json').write_text(json.dumps(receipt,indent=2)+'\n');print('wrote',O,'calls',sum(hist.values()),flush=True) diff --git a/research/multicut-kernel-composition/code/sandwich/price-histogram.cpp b/research/multicut-kernel-composition/code/sandwich/price-histogram.cpp new file mode 100644 index 0000000000..79db4e214d --- /dev/null +++ b/research/multicut-kernel-composition/code/sandwich/price-histogram.cpp @@ -0,0 +1,22 @@ +// Price a word histogram with the base package's exact rational interval engine and 47-constraint assembly, unchanged. +// Compile with -DPR254_PRICE_SOURCE naming the base package's code/cohort-price.cpp. A price alone is not a certificate: +// verify.py also runs the base finite invoice. +#define main inherited_pr254_main +#include PR254_PRICE_SOURCE +#undef main + +int main(int argc, char** argv) { + if (argc != 4) return 2; + auto word = load(argv[1]); + auto banks = load(argv[2]); + map H; + for (auto it = word["histogram"].begin(); it != word["histogram"].end(); ++it) + H[stoi(it.key())] = 40 * it.value().get(); + for (int r : {4, 23, 46, 50}) H[r] += 16 * 1760; + int stock = banks["literal_stock"]; + if (stock % 5) throw runtime_error("nonintegral normalized stock"); + auto result = price(H, stock / 5); + ofstream(argv[3]) << J{{"status", "PASS_REUSED_PR254_EXACT_PRICE_AND_OUTER47"}, + {"candidate", result}, {"finite_invoice_required", true}}.dump(2) << '\n'; + cout << "kappa " << result["kappa"] << '\n'; +} diff --git a/research/multicut-kernel-composition/code/sandwich_endpoints.py b/research/multicut-kernel-composition/code/sandwich_endpoints.py new file mode 100644 index 0000000000..21493ddb9c --- /dev/null +++ b/research/multicut-kernel-composition/code/sandwich_endpoints.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 +"""Exact rational checks of the shortened endpoints, the bank re-tiling and the new normalizers (SymPy), for the +cleanup-sandwich stage. Adapted from research/cleanup-sandwich-263/endpoints263.py (evmckinney9, Apache-2.0). + +Address geometry is over Q with G = 9I - J; a frame with row basis B has projector P = B^T (B G B^T)^-1 B G. +banks: each retired helper keeps its rank-one entrance S and now ends at its four-dimensional frame F; since +P_S P_F = P_F P_S = P_S its completed relative endpoint is the partial swap D_(P_F - P_S) of rank 3 (completed-core +identity, research/community-round8-audit/BANK-SCHEDULE.md), so its bank residual changes from width 23 to width 3. +The width-120 bank patterns of the native bank review (run on the pre-sandwich word, whose helper entrances are +unchanged) are re-tiled and must fill every slot exactly. +normalizers: every new frame Gram matrix, every connector touching a new frame and every new endpoint has an exact +chart reducing it to a coordinate projector by elementary factors, all entries below 2^80. +usage: sandwich_endpoints.py EXPORT LEAD BANK_REVIEW_JSON OUTPUT_DIR +""" +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path +import json, struct, sys, time +import sympy as sp +if not __debug__: raise SystemExit('assertions required') +H = 24; BOUND = 2 ** 80; MAX_FACTORS = 548; G = 9 * sp.eye(H) - sp.ones(H) +X, L, BANK, O = map(Path, sys.argv[1:5]); t0 = time.time() +def load(p): return json.loads(Path(p).read_text()) +receipt = load(L / 'CLEANUP-SANDWICH.json'); records = (L / 'COHORT249-RECORDS.bin').read_bytes() +frames = load(X / 'frames.json')['frames']; frames.update(load(L / 'COHORT249-FRAMES.json')) +new_frames = {str(e['frame']) for e in receipt['edits']} +def projector(f): + d = frames[str(f)]['dim'] + if d == H: return sp.eye(H), None + if d == 0: return sp.zeros(H), None + B = sp.Matrix(frames[str(f)]['B']); gram = B * G * B.T + return B.T * gram.inv() * B * G, gram +def make_guard(): + state = {'max': 1} + def guard(values): + for value in values: + x = Q(value); state['max'] = max(state['max'], abs(x.numerator), x.denominator) + assert state['max'] < BOUND, 'normalizer entry exceeds 2^80' + return guard, state +def chart(E, rank, guard): + C = sp.Matrix.hstack(*E.columnspace(), *E.nullspace()); inverse = C.inv() + assert inverse * E * C == sp.diag(*([1] * rank + [0] * (H - rank))), 'chart does not normalize the projector' + guard(list(E) + list(C) + list(inverse) + [C.det()]) + A = [[Q(x) for x in C.row(i)] for i in range(H)]; factors = 0 + for j in range(H): + k = next(k for k in range(j, H) if A[k][j]) + if k != j: A[j], A[k] = A[k], A[j]; factors += 1 + pivot = A[j][j]; guard([pivot, 1 / pivot]) + if pivot != 1: A[j] = [x / pivot for x in A[j]]; factors += 1 + for i in range(H): + if i != j and A[i][j]: + c = A[i][j]; guard([c]); A[i] = [x - c * y for x, y in zip(A[i], A[j])]; factors += 1 + assert A == [[Q(i == j) for j in range(H)] for i in range(H)] + assert factors <= MAX_FACTORS, 'chart exceeds the inherited factor bound' + return factors +# banks +guard, state = make_guard() +for e in receipt['edits']: + assert frames[str(e['entrance_frame'])]['dim'] == 1 and frames[str(e['frame'])]['dim'] == 4 + S, _ = projector(e['entrance_frame']); F, _ = projector(e['frame']) + assert S * F == F * S == S, 'entrance is not inside the new exit frame' + E = F - S; assert E * E == E and E.rank() == 3; chart(E, 3, guard) +bank = load(BANK); k = len(receipt['edits']); patterns = [dict(p) for p in bank['bank_patterns']] +# 40 replicas: k helpers x 40 width-23 residuals become width-3 residuals. 10k banks [23]*4+[4]*7 release their +# 40k width-23 slots; their 70k width-4 slots refill 7k/3 banks [4]*30 (k = 45: 105); the 40k width-3 residuals fill k banks [3]*40. +assert (70 * k) % 30 == 0, 'width-4 remainder' +next(p for p in patterns if p['widths'] == [23] * 4 + [4] * 7)['count'] -= 10 * k +next(p for p in patterns if p['widths'] == [4] * 30)['count'] += 70 * k // 30 +patterns.append({'widths': [3] * 40, 'count': k}) +family = Counter({int(r): c for r, c in bank['residual_families'].items()}); family[23] -= k; family[3] += k +slots, count = Counter(), 0 +for p in patterns: + assert p['count'] >= 0 and sum(p['widths']) == 120, 'bank pattern does not fill width 120' + count += p['count'] + for r in p['widths']: slots[r] += p['count'] +assert slots == Counter({r: 40 * c for r, c in family.items() if c}), 'residuals do not tile the banks exactly' +fewer = bank['banks_per_stage'] - count; assert fewer == 10 * k - 70 * k // 30 - k +banks = {'literal_stock': bank['literal_stock'] - 5 * fewer, 'banks_per_stage': count, 'banks_fewer_per_stage': fewer, + 'actual_role_replica_stage_assignments': bank['actual_role_replica_stage_assignments'], 'bank_patterns': patterns, + 'residual_families': {str(r): c for r, c in sorted(family.items()) if c}, 'endpoint_max_entry': state['max']} +# normalizers +guard, state = make_guard() +for f in new_frames: + _, gram = projector(f); guard(list(gram) + list(gram.inv()) + [gram.det()]) +pairs = {(b, c, r) for op, a, b, c, r, z in struct.iter_unpack('<6i', records) if op == 0 and (str(b) in new_frames or str(c) in new_frames)} +moves = len(pairs); pairs |= {(e['entrance_frame'], e['frame'], 3) for e in receipt['edits']}; most = 0 +for before, after, rank in sorted(pairs): + E = projector(after)[0] - projector(before)[0] + assert E * E == E and E.rank() == rank, ('connector is not a projector of its rank', before, after) + most = max(most, chart(E, rank, guard)) +norm = {'new_frames': len(new_frames), 'move_pairs': moves, 'charts': len(pairs), 'max_factors': most, 'max_numerator_denominator': state['max']} +M = max(norm['max_numerator_denominator'], int(bank['max_intermediate_numerator']), int(bank['max_intermediate_denominator'])); U = 40 * M * M; g = 2 * U * U; assert g < 2 ** 80 +invoice = dict(banks, normalized_stock=banks['literal_stock'] // 5, new_exact_charts=bank['new_exact_charts'] + k + norm['move_pairs'], + max_new_chart_factors=max(bank['max_new_chart_factors'], norm['max_factors']) + 24, max_intermediate_numerator=str(g), max_intermediate_denominator=str(g), + selector_charge=2 * 5 * 40 * (banks['literal_stock'] - 1 + 16587 * 120 * 787), routing_prime_guard={'normalized_scaled_chart_entry_bound': U, 'pairwise_difference_numerator_bound': g}, + status='PASS_SANDWICH_ENDPOINTS_EXACT_CHARTS_AND_BANK_RETILING', base_bank_review_sha256=__import__('hashlib').sha256(BANK.read_bytes()).hexdigest(), normalizers=norm) +assert banks['literal_stock'] % 5 == 0 +O.mkdir(parents=True, exist_ok=True); (O / 'SANDWICH-BANK-INVOICE.json').write_text(json.dumps(invoice, indent=2) + '\n') +print('PASS sandwich endpoints: %d helpers, %d charts, max factors %d, banks per stage %d (-%d), literal stock %d, %.0fs' % (k, norm['charts'], most, count, fewer, banks['literal_stock'], time.time() - t0), flush=True) diff --git a/research/multicut-kernel-composition/code/target_prefix.py b/research/multicut-kernel-composition/code/target_prefix.py new file mode 100644 index 0000000000..f3c1c73a45 --- /dev/null +++ b/research/multicut-kernel-composition/code/target_prefix.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +"""Exact F2 target-prefix compression (PR268's mechanism) on the cohort-rewritten native transcript. + +A group is one dependent target t with retained targets p_1..p_k, a cut and a close record, and a common close +frame F inside every member's cap. The dependent's reads in (cut, close] are omitted; at the cut it receives +t -= p_j at the zero frame, and at the close t += p_j at F, after moving every member to F. The transform +recomputes each member's literal prefix response from the actual transcript and requires the F2 dependency +R_t = sum_j R_pj before emitting anything; it then rebuilds every MOVE from the actual needs and checks nested +chains, fixed endpoints, COPY lifetimes, nondegenerate endpoint bases and forward/inverse all-column replays. +Prepared by Rohan Arun with Anthropic Claude assistance; Apache-2.0. +""" +from array import array +from collections import Counter, defaultdict +from fractions import Fraction +from pathlib import Path +import hashlib, json, sys +if not __debug__: raise SystemExit('assertions required') +X, LEAD, SEL = Path(sys.argv[1]), Path(sys.argv[2]), Path(sys.argv[3]) +H = 24 +def dot(x, y): return sum(p*q for p, q in zip(x, y)) +def rank(rows): + M = [[Fraction(x) for x in r] for r in rows]; r = 0 + for c in range(len(M[0]) if M else 0): + p = next((i for i in range(r, len(M)) if M[i][c]), None) + if p is None: continue + M[r], M[p] = M[p], M[r]; pv = M[r][c]; M[r] = [x/pv for x in M[r]] + for i in range(len(M)): + if i != r and M[i][c]: + m = M[i][c]; M[i] = [x-m*y for x, y in zip(M[i], M[r])] + r += 1 + if r == len(M): break + return r +frames = {} +for name in (X/'frames.json', LEAD/'COHORT249-FRAMES.json'): + j = json.loads(name.read_text()); j = j.get('frames', j) + for k, rec_ in j.items(): frames[int(k)] = dict(B=[list(map(int, r)) for r in rec_['B']], A=[list(map(int, r)) for r in rec_['A']], d=int(rec_['dim'])) +for f, fr in frames.items(): assert len(fr['B']) == fr['d'] and len(fr['A']) + fr['d'] == H and all(dot(a, b) == 0 for a in fr['A'] for b in fr['B']) +subcache = {} +def sub(f, g): + if f == g: return True + k = (f, g) + if k not in subcache: subcache[k] = frames[f]['d'] <= frames[g]['d'] and all(dot(a, b) == 0 for a in frames[g]['A'] for b in frames[f]['B']) + return subcache[k] +def nondeg(f): + B, A = frames[f]['B'], frames[f]['A'] + if not B or len(B) == H: return True + if len(B) <= len(A): + s = [sum(b) for b in B]; return rank([[9*dot(B[i], B[j]) - s[i]*s[j] for j in range(len(B))] for i in range(len(B))]) == len(B) + s = [sum(a) for a in A]; return rank([[(9-H)*dot(A[i], A[j]) + s[i]*s[j] for j in range(len(A))] for i in range(len(A))]) == len(A) +st = json.loads((X/'249-states.json').read_text()); n, v = st['n'], st['v']; ZERO, FULL = st['ZERO'], st['FULL'] +cov = [list(map(int, c)) for c in st['source_covectors']] +initial = {int(k): f for k, f in json.loads((LEAD/'COHORT249-INITIAL.json').read_text()).items()} +sel = json.loads(SEL.read_text()); cut = sel['cut_record'] +old = array('i'); old.frombytes((LEAD/'COHORT249-RECORDS.bin').read_bytes()); assert old.itemsize == 4 and len(old) % 6 == 0 +assert hashlib.sha256(old.tobytes()).hexdigest() == sel['input_record_sha256'] and len(old)//6 == sel['input_record_count'] +final = dict(initial) +for k in range(0, len(old), 6): + if old[k] == 0: final[old[k+1]] = old[k+3] +groups = []; owner = {}; atclose = defaultdict(list); dep_of = {} +for j, g in enumerate(sel['groups']): + t, ps, close, F = g['dependent'], list(g['retained']), g['close_after_record'], g['frame'] + assert close > cut and len(ps) >= 1 and t not in ps and len(set(ps)) == len(ps) + assert frames[F]['d'] == g['close_rank'] and nondeg(F) + for m in [t] + ps: + assert m not in owner; owner[m] = j + assert initial[v+m] == ZERO and all(dot(cov[m], b) == 0 for b in frames[F]['B']), 'close frame outside a member cap' + dep_of[t] = j; atclose[close].append(j); groups.append(dict(dependent=t, retained=ps, close=close, frame=F)) +assert len(groups) == sel['selected_groups'] > 0 +# literal prefix responses and member states from the actual transcript +cols = [1 << i for i in range(n)]; center = None; responses = {m: 0 for m in owner}; state = dict(initial); state_at_close = {} +for k in range(0, len(old), 6): + op, a, b, c, f, z = old[k:k+6]; i = k//6 + if op == 0: state[a] = c + elif op == 1: + src = center if b == n else b; assert src is not None + if i > cut: + if src - v in owner: assert i > groups[owner[src-v]]['close'], 'active group target used as a source' + if a - v in owner and i <= groups[owner[a-v]]['close']: + assert not (v <= src < 2*v), 'target source inside an active prefix'; responses[a-v] ^= cols[src] + assert c % 2; cols[a] ^= cols[src] + elif op == 2: assert center is None; center = a; state[b] = f + elif op == 3: assert center == a; center = None; del state[b] + for j in atclose.get(i, []): + g = groups[j]; R = responses[g['dependent']] + for p in g['retained']: R ^= responses[p] + assert R == 0, ('literal prefix dependency fails', j) + for m in [g['dependent']] + g['retained']: assert sub(state[v+m], g['frame']), ('member frame not inside close frame', j, m) +assert center is None +# emit +zmax = max(old[k+5] for k in range(0, len(old), 6) if old[k] == 1); SETUP, RESTORE = zmax + 1, zmax + 2 +state = dict(initial); out = array('i'); center = None; deleted = []; inserted = 0 +def move(s, f): + before = state[s] + if before == f: return + assert sub(before, f), ('nonnested actual use', s, before, f) + gap = frames[f]['d'] - frames[before]['d']; assert gap >= 0; out.extend((0, s, before, f, gap, 0)); state[s] = f +def add(a, b, c, f, z): move(a, f); move(b, f); out.extend((1, a, b, c, f, z)) +for k in range(0, len(old), 6): + op, a, b, c, f, z = old[k:k+6]; i = k//6 + if op == 1: + j = dep_of.get(a - v) + if j is not None and cut < i <= groups[j]['close']: assert not (v <= b < 2*v); deleted.append(i) + else: add(a, b, c, f, z) + elif op == 2: assert center is None; move(a, c); out.extend((op, a, b, c, f, z)); state[b] = f; center = (a, b, c) + elif op == 3: assert center == (a, b, c) and state[a] == c and state[b] == f; out.extend((op, a, b, c, f, z)); del state[b]; center = None + if i == cut: + assert center is None and all(state[v+m] == ZERO for m in owner) + for g in groups: + for p in g['retained']: add(v+g['dependent'], v+p, -1, ZERO, SETUP); inserted += 1 + for j in atclose.get(i, []): + g = groups[j] + for m in [g['dependent']] + g['retained']: move(v+m, g['frame']) + for p in g['retained']: add(v+g['dependent'], v+p, 1, g['frame'], RESTORE); inserted += 1 +for s in sorted(final): move(s, final[s]) +assert center is None and state == final +# census from needs, independent of emitted MOVEs +needs = {i: [] for i in initial}; copies = Counter(); copy = None +for k in range(0, len(out), 6): + op, a, b, c, f, z = out[k:k+6] + if op == 1: + assert c % 2; needs[a].append(f) + if b != n: needs[b].append(f) + else: assert copy is not None and f == ZERO + elif op == 2: assert copy is None; copy = (a, b, c); needs[a].append(c); copies[frames[c]['d']] += 1 + elif op == 3: assert copy == (a, b, c); copy = None +assert copy is None and copies == {22: 24} +census = Counter(copies); pairs = set() +for s, before in initial.items(): + for f in needs[s] + [final[s]]: + assert sub(before, f); r = frames[f]['d'] - frames[before]['d'] + if r: census[r] += 1 + pairs.add((before, f)); before = f +for f in {f for pair in pairs for f in pair}: assert nondeg(f) +for a, b in pairs: assert len(frames[b]['A']) <= len(frames[a]['A']) and all(dot(x, y) == 0 for x in frames[b]['A'] for y in frames[a]['B']) +for t in range(v): + f = final[v+t]; assert frames[f]['d'] == 23 and all(dot(cov[t], b) == 0 for b in frames[f]['B']) +hist = Counter(); state = dict(initial); copy = None; count = 0 +for k in range(0, len(out), 6): + op, a, b, c, f, z = out[k:k+6] + if op == 0: + assert state[a] == b and sub(b, c) and frames[c]['d'] - frames[b]['d'] == f; state[a] = c + if f: hist[f] += 1 + elif op == 1: assert state[a] == state[b] == f and a != b; count += 1 + elif op == 2: assert copy is None and state[a] == c and f == ZERO and z == 22; state[b] = f; hist[z] += 1; copy = (a, b, c) + else: assert copy == (a, b, c) and state[a] == c and state[b] == f == ZERO; del state[b]; copy = None +assert state == final and hist == census and copy is None +# forward and inverse all-column replays with arbitrary dirty contents +def replay(records, reverse=False, omit=None): + columns = [1 << i for i in range(n)]; wanted = columns[:]; center = None; cnt = 0 + for t in range(v): wanted[v+t] ^= 1 << t + for k in (range(len(records)-6, -1, -6) if reverse else range(0, len(records), 6)): + op, a, b, c, f, z = records[k:k+6] + if op == 1: + if b == n: assert center is not None; b = center + if k//6 == omit: continue + assert c % 2 and a != b; columns[a] ^= columns[b]; cnt += 1 + elif op == (3 if reverse else 2): assert center is None; center = a + elif op == (2 if reverse else 3): assert center == a; center = None + assert center is None and columns == wanted, 'all-column endpoint failure' + return cnt +assert replay(out) == replay(out, True) == count +first_setup = next(k//6 for k in range(0, len(out), 6) if out[k] == 1 and out[k+5] == SETUP) +try: replay(out, omit=first_setup) +except AssertionError: negative = 'omitted target-prefix setup rejected' +else: raise AssertionError('missing setup admitted') +replay_json = json.loads((LEAD/'COHORT249-REPLAY.json').read_text()) +oldH = Counter({int(r): c for r, c in replay_json['histogram'].items()}) +delta = Counter(hist); delta.subtract(oldH); delta = {r: c for r, c in delta.items() if c} +assert delta == {int(r): c for r, c in sel['expected_local_histogram_delta'].items()}, ('histogram delta', delta) +assert sum(r*c for r, c in hist.items()) == sum(r*c for r, c in oldH.items()) == replay_json['new_rank_mass'] +assert (len(deleted), inserted, count) == (sel["expected_deleted_reads"], sel["expected_inserted_additions"], sel["expected_scalar_additions"]), ("counts", len(deleted), inserted, count) +(LEAD/'COHORT249-PRE-TARGET-RECORDS.bin').write_bytes(old.tobytes()) +(LEAD/'COHORT249-RECORDS.bin').write_bytes(out.tobytes()) +combined = Counter({int(r): c for r, c in replay_json['delta'].items()}); combined.update(delta); combined = {r: c for r, c in combined.items() if c} +replay_json.update(status='PASS_FULL_CURRENT249_COHORT_REWRITE_AND_TARGET_PREFIX_COMPRESSION', pre_target_records=len(old)//6, new_records=len(out)//6, + pre_target_histogram=replay_json['histogram'], pre_target_delta=replay_json['delta'], histogram={str(r): c for r, c in sorted(hist.items())}, + delta={str(r): c for r, c in sorted(combined.items())}, target_prefix_delta={str(r): c for r, c in sorted(delta.items())}, + target_prefix_groups=len(groups), target_prefix_deleted_reads=len(deleted), target_prefix_setup_restore_additions=inserted) +(LEAD/'COHORT249-REPLAY.json').write_text(json.dumps(replay_json, indent=2) + '\n') +receipt = dict(status='PASS_EXACT_F2_TARGET_PREFIX_COMPRESSION', selected_groups=len(groups), targets=len(owner), cut_record=cut, deleted_prefix_adds=len(deleted), + inserted_setup_restore_adds=inserted, literal_prefix_dependencies_checked=True, remaining_payload_additions=count, + local_histogram_delta={str(r): c for r, c in sorted(delta.items())}, rank_mass=sum(r*c for r, c in hist.items()), paid_calls=sum(hist.values()), + both_reflected_ledgers=True, unchanged_all_input_output_frames=True, unchanged_copy_lifetimes=True, forward_and_inverse_all_columns=True, + negative_control=negative, unique_required_frame_pairs=len(pairs), setup_category=SETUP, restore_category=RESTORE, + input_record_sha256=sel['input_record_sha256'], output_record_sha256=hashlib.sha256(out.tobytes()).hexdigest(), selection_sha256=hashlib.sha256(SEL.read_bytes()).hexdigest()) +(LEAD/'TARGET-PREFIX.json').write_text(json.dumps(receipt, indent=2) + '\n') +print('PASS target prefix', len(groups), 'groups', count, 'ADDs', sum(hist.values()), 'paid calls', len(out)//6, 'records', flush=True) diff --git a/research/multicut-kernel-composition/code/verify_frame_tables.py b/research/multicut-kernel-composition/code/verify_frame_tables.py new file mode 100644 index 0000000000..f77ff72801 --- /dev/null +++ b/research/multicut-kernel-composition/code/verify_frame_tables.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Verify every added rational basis/annihilator table exactly. + +The native containment checker consumes A, while the bank checker constructs +weighted charts from B. This checker binds both descriptions of each subspace. +""" +from array import array +from fractions import Fraction as Q +from pathlib import Path +import argparse, hashlib, json, sys + +if not __debug__:raise SystemExit('assertions required') + +def rank(rows,width=24): + a=[list(map(Q,r)) for r in rows] + assert all(len(r)==width for r in a) + k=0 + for j in range(width): + p=next((i for i in range(k,len(a)) if a[i][j]),None) + if p is None:continue + a[k],a[p]=a[p],a[k] + scale=a[k][j];a[k]=[x/scale for x in a[k]] + for i in range(k+1,len(a)): + q=a[i][j] + if q:a[i]=[x-q*y for x,y in zip(a[i],a[k])] + k+=1 + if k==len(a):break + return k + +def verify(export,lead): + export,lead=Path(export),Path(lead) + original=json.loads((export/'frames.json').read_text())['frames'] + new_path=lead/'COHORT249-FRAMES.json' + new=json.loads(new_path.read_text()) + assert not set(new)&set(original), 'new frame id collision' + dimensions={} + for key,frame in new.items(): + d=frame['dim'];B=frame['B'];A=frame['A'] + assert isinstance(d,int) and 0<=d<=24 + assert len(B)==d and len(A)==24-d, ('table lengths',key) + assert rank(B)==d, ('B rank',key) + assert rank(A)==24-d, ('A rank',key) + assert all(sum(Q(x)*Q(y) for x,y in zip(a,b))==0 for a in A for b in B), ('A B transpose',key) + gram=[[sum(Q(x)*Q(y) for x,y in zip(u,v))-sum(map(Q,u))*sum(map(Q,v))/9 for v in B] for u in B] + assert rank(gram,d)==d, ('weighted Gram rank',key) + dimensions[key]=d + word=array('i');word.frombytes((lead/'COHORT249-RECORDS.bin').read_bytes()) + assert word.itemsize==4 and len(word)%6==0 + references=set() + for j in range(len(word)//6): + op,a,b,c,f,z=word[6*j:6*j+6] + if op==0:references.update((str(b),str(c))) + elif op==1:references.add(str(f)) + elif op in (2,3):references.update((str(c),str(f))) + else:raise AssertionError('unknown opcode') + assert references<=set(original)|set(new), 'unknown frame reference' + return dict(status='PASS_EXACT_ADDED_FRAME_BASES_AND_ANNIHILATORS', + frame_table_sha256=hashlib.sha256(new_path.read_bytes()).hexdigest(), + added_frames=len(new),used_added_frames=len(references&set(new)), + all_B_rank_equals_dimension=True,all_A_rank_equals_codimension=True, + all_A_B_transpose_zero=True,all_weighted_Gram_nondegenerate=True, + new_frame_ids_disjoint_from_original=True, + dimensions=dimensions) + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('export',type=Path);ap.add_argument('lead',type=Path) + ap.add_argument('--output',type=Path) + a=ap.parse_args();receipt=verify(a.export,a.lead) + if a.output: + assert not a.output.exists() + a.output.write_text(json.dumps(receipt,sort_keys=True,indent=2)+'\n') + print(json.dumps({k:v for k,v in receipt.items() if k!='dimensions'},sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/multicut-kernel-composition/code/verify_frames.py b/research/multicut-kernel-composition/code/verify_frames.py new file mode 100644 index 0000000000..890d9d54f0 --- /dev/null +++ b/research/multicut-kernel-composition/code/verify_frames.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +"""Independently validate exact bases and annihilators of every candidate frame.""" +import argparse +import hashlib +import json +from pathlib import Path +from sympy import Matrix, eye, ones, zeros + +if not __debug__: + raise SystemExit("assertions are required") + + +def validate(frame): + d = frame["dim"] + assert type(d) is int and 0 <= d <= 24 + b, a = frame["B"], frame["A"] + assert len(b) == d and len(a) == 24-d + assert all(len(row) == 24 and all(type(x) is int for x in row) for row in b+a) + B = Matrix(b) if b else zeros(0, 24) + A = Matrix(a) if a else zeros(0, 24) + assert B.rank() == d and A.rank() == 24-d + assert B*A.T == zeros(d, 24-d) + assert (B*(9*eye(24)-ones(24))*B.T).det() != 0 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("frames", type=Path) + parser.add_argument("output", type=Path) + args = parser.parse_args() + raw = args.frames.read_bytes() + frames = json.loads(raw) + seen = set() + for frame in frames.values(): + key = json.dumps(frame, sort_keys=True) + if key not in seen: + validate(frame) + seen.add(key) + result = dict(status="PASS_EXACT_BASES_ANNIHILATORS_AND_GRAM", + frames_checked=len(frames), distinct_frames_checked=len(seen), + frames_sha256=hashlib.sha256(raw).hexdigest()) + assert not args.output.exists() + args.output.write_text(json.dumps(result, sort_keys=True, indent=2)+"\n") + print(json.dumps(result)) + + +if __name__ == "__main__": + main() diff --git a/research/multicut-kernel-composition/code/verify_plateau_spans.py b/research/multicut-kernel-composition/code/verify_plateau_spans.py new file mode 100644 index 0000000000..49b3566e7a --- /dev/null +++ b/research/multicut-kernel-composition/code/verify_plateau_spans.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""Exact defining-integer source span audit for the frozen changed ADDs.""" +import argparse,json,time,hashlib,sys +from pathlib import Path +from array import array +if not __debug__:raise SystemExit('assertions are required') +assert sys.byteorder=='little' and array('i').itemsize==4 +ap=argparse.ArgumentParser();ap.add_argument('export',type=Path);ap.add_argument('lead',type=Path);ap.add_argument('receipt',type=Path);args=ap.parse_args() +t=time.time();X,L=args.export,args.lead +frames={int(k):r for k,r in json.loads((X/'frames.json').read_text())['frames'].items()};frames.update({int(k):r for k,r in json.loads((L/'COHORT249-FRAMES.json').read_text()).items()}) +st=json.loads((X/'249-states.json').read_text());n,v=st['n'],st['v'];initial={int(k):f for k,f in json.loads((L/'COHORT249-INITIAL.json').read_text()).items()};chi={s:frames[initial[s]]['B'][0] for s in range(v)} +assert all(frames[initial[s]]['dim']==1 for s in range(v)) +receipt=json.loads(args.receipt.read_text());pairs=[(g,c['new_frame']) for c in receipt['selected'] for g in c['gates']];chosen=dict(pairs) +assert len(pairs)==len(chosen),'duplicate selected gates' +columns=[{i:1} if i twins.pkl census of twin dirty helpers at PR #254's cut (record 727,593) + chrono2.py twins.pkl chrono.pkl the same census at any cut (at 676,560: 985 pairs, 24 size-9 classes) + gain.py log-weighted gain phi(r) = r ln(120/r) per pair and exact-grid price + gen_candidates.py, compare259.py, merge259.py round 1: candidates in PR #259's schema, the pairs disjoint from its helpers, the merge + census2.py, merge2.py round 2: every response class at twelve cuts, pairs and XOR triples, greedy packing + census3.py, census3b.py round 3: shared-donor families (partner = an existing donor, nested entrance chain) + retime.py the chain cohort -> descent (PR #263) -> plateau (PR #270) with the sha rebinding + rebind_target.py PR #273's 209 squares rebound to this transcript (post-cut scalar alignment) + scan_sandwich.py the cleanup-sandwich scan (pivots with the three-gate cleanup shape, joint dimension 4) + chain_swap.py, finalize_swap.py the pivot-role swap in 83 families, the full stage chain and the packaging + +Diff of this package against PR #259's (everything else byte for byte): + + inputs/candidates.json.gz 518 items of PR #259 (26 dissolved) + 387 appended (rounds union-early-cut, headroom-2, shared-donor; 83 with the pivot role swapped) + inputs/target-selection.json PR #273's 209 squares, rebound (core_binding block) + inputs/sandwich-selection.json the 126 retired helpers (128 scanned) + code/target_prefix.py PR #273's stage, verbatim + code/cleanup_sandwich.py, code/sandwich_endpoints.py, code/sandwich/price-histogram.cpp PR #271's mechanism, ported + inputs/descent-selection.json PR #263's 25 gates, rebound to this transcript (input sha gate) + inputs/plateau-selection.json PR #270's 29 blocks, rebound to the descent transcript + code/descent_retiming.py, code/plateau_retiming.py, code/verify_frames.py, code/verify_plateau_spans.py, code/verify_frame_tables.py + PR #263's and PR #270's stages, verbatim + code/cohort-transform.cpp std::sort -> std::stable_sort on the gauge order (platform-independent transcript) + verify.py stages 02b-02f and 09-17 inserted with sha gates; 'containment_pairs_checked' dropped from compared fields; normalize() on both sides + expected/*.json, expected-sandwich/*.json, RESULT.json regenerated receipts (twelve + eight) and result (890 pivots, rank 1719, kappa 7.12005174354669e-4 native, 7.14026746429965e-4 with sandwiches) + README.md, PROOF.md, NOTICE.md this package's notes; PR #259's README/PROOF kept as README-PR259.md, PROOF-PR259.md + MANIFEST.json regenerated diff --git a/research/multicut-kernel-composition/discovery/census2.py b/research/multicut-kernel-composition/discovery/census2.py new file mode 100644 index 0000000000..03f483116f --- /dev/null +++ b/research/multicut-kernel-composition/discovery/census2.py @@ -0,0 +1,142 @@ +"""Multi-cut twin/triple census excluding already-used helpers. usage: census2.py DATA USED.json OUT.json""" +import json, sys, collections, time, itertools, math +from array import array +from fractions import Fraction as Fr +from math import lcm, gcd +D, USED, OUT = sys.argv[1], sys.argv[2], sys.argv[3] +CUTS = [676559, 678000, 680080, 685000, 690000, 695000, 700582, 705000, 710000, 715000, 720000, 727593] +TRIPLE_CUTS = {676559, 690000, 700582, 727593} +t0 = time.time() +st = json.load(open(D + '/249-states.json')); n, v, ZERO, FULL = st['n'], st['v'], st['ZERO'], st['FULL']; H0 = 2*v +ini = [ZERO]*n; fin = [FULL]*n +for k, x in st['initial'].items(): ini[int(k)] = x +for k, x in st['final'].items(): fin[int(k)] = x +regs = st['regs']; borrowed = set(st['borrowed']); donor = set(json.load(open(D + '/249-DONOR-OWNERSHIP.json'))['donor_keys']); used = set(json.load(open(USED))) +rec = array('i'); rec.frombytes(open(D + '/249-records.bin', 'rb').read()); E = len(rec)//6 +fj = json.load(open(D + '/frames.json'))['frames'] +Tt = {}; first = {}; reads = collections.Counter() +for i in range(E): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 0: + if a >= H0 and a not in Tt: Tt[a] = i; first[a] = c + elif k == 1: + if a >= H0 and a not in Tt: Tt[a] = i; first[a] = None + if b >= H0: + if z == 4 and f == ZERO and v <= a < 2*v: reads[b] += 1 + elif b not in Tt: Tt[b] = i; first[b] = None + else: + for s in (a, b): + if s >= H0 and s not in Tt: Tt[s] = i; first[s] = None +base = [h for h in range(H0, n) if ini[h] == ZERO and fin[h] == FULL and regs[h-H0] not in borrowed and regs[h-H0] not in donor and h not in used and first.get(h) is not None] +print('base (unused, clean roles, MOVE-first)', len(base), time.time()-t0, flush=True) +phi = lambda r: 0.0 if r == 0 else r*math.log(120/r) +def nullspace(rows): + m = [[Fr(x) for x in r] for r in rows]; piv = []; r = 0 + for c in range(24): + p = next((i for i in range(r, len(m)) if m[i][c] != 0), None) + if p is None: continue + m[r], m[p] = m[p], m[r]; pv = m[r][c]; m[r] = [x/pv for x in m[r]] + for i in range(len(m)): + if i != r and m[i][c] != 0: + f = m[i][c]; m[i] = [a - f*b for a, b in zip(m[i], m[r])] + piv.append(c); r += 1 + if r == len(m): break + free = [c for c in range(24) if c not in piv]; basis = [] + for fcol in free: + vec = [Fr(0)]*24; vec[fcol] = Fr(1) + for i, pc in enumerate(piv): vec[pc] = -m[i][fcol] + basis.append(vec) + return basis +def prim(vec): + L = 1 + for x in vec: L = lcm(L, x.denominator) + iv = [int(x*L) for x in vec]; g = 0 + for x in iv: g = gcd(g, abs(x)) + return [x//g for x in iv] +def gramdet(basis): + k = len(basis); M = [[Fr(9*sum(a*b for a, b in zip(basis[i], basis[j])) - sum(basis[i])*sum(basis[j])) for j in range(k)] for i in range(k)]; det = Fr(1) + for c in range(k): + p = next((i for i in range(c, k) if M[i][c] != 0), None) + if p is None: return 0 + if p != c: M[c], M[p] = M[p], M[c]; det = -det + det *= M[c][c] + for i in range(c+1, k): + f = M[i][c]/M[c][c]; M[i] = [a - f*b for a, b in zip(M[i], M[c])] + return det +icache = {} +def entrance(frames): + """best (gain, e, basis_int_rows, pivot_index) for members' first frames (members ordered); returns None if no nondegenerate entrance""" + key = tuple(frames) + if key in icache: return icache[key] + rows = [] + for f in frames: rows += fj[str(f)]['A'] + basis = nullspace(rows); d = len(basis); res = None + if d: + dims = [fj[str(f)]['dim'] for f in frames] + # candidate entrance subspaces: single lines (each primitive basis vector, prefer small norm) and the full intersection + options = [] + lines = sorted((prim(b) for b in basis), key=lambda u: sum(x*x for x in u)) + for u in lines: + if 9*sum(x*x for x in u) - sum(u)**2 != 0: options.append((1, [u])); break + if d >= 2 and gramdet(basis) != 0: options.append((d, [prim(b) for b in basis])) + for e, B in options: + for p in range(len(frames)): + if dims[p] < e or any(dims[q] < e for q in range(len(frames))): continue + g = phi(dims[p]-e) - phi(dims[p]) + sum(phi(e) + phi(dims[q]-e) - phi(dims[q]) for q in range(len(frames)) if q != p) + if res is None or g < res[0]: res = (g, e, B, p) + icache[key] = res; return res +row = [1 << s for s in range(n+1)]; i = 0; cands = []; stats = collections.Counter() +for cut in CUTS: + while i <= cut: + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 1: + if c & 1: row[a] ^= row[b] + elif k == 2: row[b] = row[a] + i += 1 + live = [h for h in base if Tt[h] > cut] + contam = 0 + for s in range(n): + if v <= s < 2*v: continue + contam |= (row[s] ^ (1 << s)) >> H0 + resp = collections.defaultdict(int) + for t in range(v): + r = row[v+t] >> H0 + while r: + low = r & -r; idx = low.bit_length()-1; resp[H0+idx] |= 1 << t; r ^= low + live = [h for h in live if not (contam >> (h-H0)) & 1 and resp[h]] + cls = collections.defaultdict(list) + for h in live: cls[resp[h]].append(h) + sizes = collections.Counter(len(m) for m in cls.values() if len(m) >= 2) + npair = 0 + for m in cls.values(): + if len(m) < 2: continue + for a, b in itertools.combinations(m, 2): + r = entrance([first[a], first[b]]) + if r is None or r[0] >= 0: stats[('pair', 'rejected', cut)] += 1; continue + g, e, B, p = r; piv, par = (a, b) if p == 0 else (b, a) + cands.append(dict(gain=g, cut=cut, members=[piv, par], pivot=piv, e=e, basis=B, kind='pair', cls=len(m))); npair += 1 + ntri = 0 + if cut in TRIPLE_CUTS: + dl = sorted(cls); Sset = set(dl) + for x in range(len(dl)): + for y in range(x+1, len(dl)): + w = dl[x] ^ dl[y] + if w > dl[y] and w in Sset: + for a in cls[dl[x]]: + for b in cls[dl[y]]: + for c in cls[w]: + r = entrance([first[a], first[b], first[c]]) + if r is None or r[0] >= 0: stats[('triple', 'rejected', cut)] += 1; continue + g, e, B, p = r; mem = [a, b, c]; piv = mem[p] + cands.append(dict(gain=g, cut=cut, members=[piv] + [h for h in mem if h != piv], pivot=piv, e=e, basis=B, kind='triple')); ntri += 1 + print(f'cut {cut}: live {len(live)} class sizes {sorted(sizes.items())} positive pair-cands {npair} triple-cands {ntri} ({time.time()-t0:.0f}s)', flush=True) +# global greedy packing: best gain first, disjoint helpers; a helper may appear once +cands.sort(key=lambda z: z['gain']); taken = set(); chosen = [] +for z in cands: + if any(h in taken for h in z['members']): continue + taken |= set(z['members']); chosen.append(z) +S = sum(z['e'] for z in chosen) +print('chosen families', len(chosen), 'by kind', collections.Counter(z['kind'] for z in chosen), 'by cut', collections.Counter(z['cut'] for z in chosen), 'by e', collections.Counter(z['e'] for z in chosen), 'entrance rank', S, 'total gain', round(sum(z['gain'] for z in chosen), 1)) +print('chosen by (kind, e, frame dims) top:', collections.Counter((z['kind'], z['e'], tuple(fj[str(first[h])]['dim'] for h in z['members'])) for z in chosen).most_common(15)) +json.dump(dict(chosen=chosen, all_candidates=len(cands)), open(OUT, 'w')) +print('done', time.time()-t0) diff --git a/research/multicut-kernel-composition/discovery/census3.py b/research/multicut-kernel-composition/discovery/census3.py new file mode 100644 index 0000000000..374c346d43 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/census3.py @@ -0,0 +1,120 @@ +"""Shared-donor census at cut 676559: new pivot p (unused, untouched) twin with an existing donor d, entrance = d's existing entrance (or a nested line in it).""" +import json, sys, collections, math, gzip, time, itertools +from array import array +from fractions import Fraction as Fr +from math import lcm, gcd +D, WIT, C270, OUT = sys.argv[1:5]; CUT = 676559; t0 = time.time() +st = json.load(open(D + '/249-states.json')); n, v, ZERO, FULL = st['n'], st['v'], st['ZERO'], st['FULL']; H0 = 2*v +ini = [ZERO]*n; fin = [FULL]*n +for k, x in st['initial'].items(): ini[int(k)] = x +for k, x in st['final'].items(): fin[int(k)] = x +regs = st['regs']; borrowed = set(st['borrowed']); donor_keys = set(json.load(open(D + '/249-DONOR-OWNERSHIP.json'))['donor_keys']) +rec = array('i'); rec.frombytes(open(D + '/249-records.bin', 'rb').read()); E = len(rec)//6 +fj = json.load(open(D + '/frames.json'))['frames'] +wit = json.load(open(WIT)); c270 = json.load(open(C270)) +Tt = {}; first = {} +for i in range(E): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 0: + if a >= H0 and a not in Tt: Tt[a] = i; first[a] = c + elif k == 1: + if a >= H0 and a not in Tt: Tt[a] = i; first[a] = None + if b >= H0 and b not in Tt and not (z == 4 and f == ZERO and v <= a < 2*v): Tt[b] = i; first[b] = None + else: + for s in (a, b): + if s >= H0 and s not in Tt: Tt[s] = i; first[s] = None +pivots = {z['pivot'] for z in wit}; donors = collections.defaultdict(list) +for z in wit: + B = [[int(x) for x in r] for r in z['basis']] + for d in z['partners']: donors[d].append(dict(cut=z['cut'], dim=z['dim'], basis=B, pivot=z['pivot'])) +used = pivots | set(donors) +pool = [h for h in range(H0, n) if ini[h] == ZERO and fin[h] == FULL and regs[h-H0] not in borrowed and regs[h-H0] not in donor_keys and h not in used and first.get(h) is not None and Tt[h] > CUT] +print('witness families', len(wit), 'pivots', len(pivots), 'distinct donors', len(donors), 'pool of unused untouched helpers', len(pool), flush=True) +# responses at CUT +row = [1 << s for s in range(n+1)] +for i in range(CUT+1): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 1: + if c & 1: row[a] ^= row[b] + elif k == 2: row[b] = row[a] +contam = 0 +for s in range(n): + if v <= s < 2*v: continue + contam |= (row[s] ^ (1 << s)) >> H0 +resp = collections.defaultdict(int) +for t in range(v): + r = row[v+t] >> H0 + while r: + low = r & -r; idx = low.bit_length()-1; resp[H0+idx] |= 1 << t; r ^= low +pool = [h for h in pool if not (contam >> (h-H0)) & 1 and resp[h]] +byresp = collections.defaultdict(list) +for h in pool: byresp[resp[h]].append(h) +phi = lambda r: 0.0 if r == 0 else r*math.log(120/r) +def contained(B, F): # subspace rows B inside frame F (annihilator test) + return all(sum(x*y for x, y in zip(b, a)) == 0 for b in B for a in fj[str(F)]['A']) +def nullspace(rows): + m = [[Fr(x) for x in r] for r in rows]; piv = []; r = 0 + for c in range(24): + p = next((i for i in range(r, len(m)) if m[i][c] != 0), None) + if p is None: continue + m[r], m[p] = m[p], m[r]; pv = m[r][c]; m[r] = [x/pv for x in m[r]] + for i in range(len(m)): + if i != r and m[i][c] != 0: + f = m[i][c]; m[i] = [a - f*b for a, b in zip(m[i], m[r])] + piv.append(c); r += 1 + if r == len(m): break + free = [c for c in range(24) if c not in piv]; out = [] + for fcol in free: + vec = [Fr(0)]*24; vec[fcol] = Fr(1) + for i, pc in enumerate(piv): vec[pc] = -m[i][fcol] + out.append(vec) + return out +def prim(vec): + L = 1 + for x in vec: L = lcm(L, x.denominator) + iv = [int(x*L) for x in vec]; g = 0 + for x in iv: g = gcd(g, abs(x)) + return [x//g for x in iv] +def ann_of(B): # annihilator rows of span(B) as integer rows + return [prim(u) for u in nullspace(B)] +cands = []; stats = collections.Counter() +for d, fams in donors.items(): + if Tt.get(d, 0) <= CUT or d not in resp or resp[d] == 0 or (contam >> (d-H0)) & 1: stats['donor_touched_or_contaminated'] += 1; continue + twins = byresp.get(resp[d], []) + if not twins: continue + for fam in fams: + if fam['cut'] < CUT: continue + e, B = fam['dim'], fam['basis']; rp_all = [] + for p in twins: + Fp = first[p]; rp = fj[str(Fp)]['dim'] + if contained(B, Fp) and rp >= e: + g = phi(rp-e) - phi(rp); cands.append(dict(gain=g, pivot=p, donor=d, e=e, basis=B, cut=CUT, mode='same-entrance', donor_cut=fam['cut'], donor_pivot=fam['pivot'])); stats['same-entrance'] += 1 + elif e >= 2: + # line inside E_d ∩ F_p: nullspace of (ann(E_d) ∪ ann(F_p)) + inter = nullspace(ann_of(B) + fj[str(Fp)]['A']) + if inter: + u = prim(inter[0]) + if 9*sum(x*x for x in u) - sum(u)**2 != 0: + g = phi(rp-1) - phi(rp) + phi(1) + phi(e-1) - phi(e); cands.append(dict(gain=g, pivot=p, donor=d, e=1, basis=[u], cut=CUT, mode='nested-line', donor_cut=fam['cut'], donor_pivot=fam['pivot'])); stats['nested-line'] += 1 + else: stats['nested-line-degenerate'] += 1 + else: stats['no-line'] += 1 + else: stats['E_not_in_Fp'] += 1 +print('candidate stats', dict(stats), 'candidates', len(cands), f'({time.time()-t0:.0f}s)', flush=True) +cands.sort(key=lambda z: z['gain']); taken = set(); chosen = [] +for z in cands: + if z['gain'] >= 0: break + if z['pivot'] in taken: continue + taken.add(z['pivot']); chosen.append(z) +print('chosen shared-donor families', len(chosen), 'by mode', collections.Counter(z['mode'] for z in chosen), 'by e', collections.Counter(z['e'] for z in chosen), 'distinct donors', len({z['donor'] for z in chosen}), 'max pivots per donor', max(collections.Counter(z['donor'] for z in chosen).values()), 'phi gain', round(sum(z['gain'] for z in chosen), 1)) +print('by (pivot first dim, e):', collections.Counter((fj[str(first[z['pivot']])]['dim'], z['e']) for z in chosen).most_common(8)) +# cross-check with #270's 24 +sh270 = {(z['pivot'], z['partners'][0]) for z in c270 if z.get('kind') == 'reuse'} +mine = {(z['pivot'], z['donor']) for z in chosen} +print('#270 reuse pairs reproduced in my chosen set:', len(sh270 & mine), 'of 24; #270 pairs with pivot already used in union3:', sum(1 for p, d in sh270 if p in used)) +S = sum(z['dim'] for z in wit) + sum(z['e'] for z in chosen) +while S % 3: + for j in range(len(chosen)-1, -1, -1): + if chosen[j]['e'] == 1: S -= 1; chosen.pop(j); break +items = [dict(pivot=z['pivot'], a=z['pivot'], roles=[z['pivot'], z['donor']], partners=[z['donor']], dim=z['e'], E_dimension=z['e'], basis=[[str(x) for x in r] for r in z['basis']], cut=z['cut'], approx_slack_delta=z['gain'], kind='shared-donor %s (donor of pivot %d at cut %d)' % (z['mode'], z['donor_pivot'], z['donor_cut']), round='shared-donor') for z in chosen] +merged = wit + items; print('merged families', len(merged), 'entrance rank', S, 'mod 3', S % 3) +json.dump(merged, open(OUT, 'w'), indent=1); open(OUT + '.gz', 'wb').write(gzip.compress(json.dumps(merged, indent=1).encode(), mtime=0)) diff --git a/research/multicut-kernel-composition/discovery/census3b.py b/research/multicut-kernel-composition/discovery/census3b.py new file mode 100644 index 0000000000..b81ef15100 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/census3b.py @@ -0,0 +1,137 @@ +"""Shared-donor census at cut 676559: new pivot p (unused, untouched) twin with an existing donor d, entrance = d's existing entrance (or a nested line in it).""" +import json, sys, collections, math, gzip, time, itertools +from array import array +from fractions import Fraction as Fr +from math import lcm, gcd +D, WIT, C270, OUT = sys.argv[1:5]; CUT = 676559; t0 = time.time() +st = json.load(open(D + '/249-states.json')); n, v, ZERO, FULL = st['n'], st['v'], st['ZERO'], st['FULL']; H0 = 2*v +ini = [ZERO]*n; fin = [FULL]*n +for k, x in st['initial'].items(): ini[int(k)] = x +for k, x in st['final'].items(): fin[int(k)] = x +regs = st['regs']; borrowed = set(st['borrowed']); donor_keys = set(json.load(open(D + '/249-DONOR-OWNERSHIP.json'))['donor_keys']) +rec = array('i'); rec.frombytes(open(D + '/249-records.bin', 'rb').read()); E = len(rec)//6 +fj = json.load(open(D + '/frames.json'))['frames'] +wit = json.load(open(WIT)); c270 = json.load(open(C270)) +Tt = {}; first = {} +for i in range(E): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 0: + if a >= H0 and a not in Tt: Tt[a] = i; first[a] = c + elif k == 1: + if a >= H0 and a not in Tt: Tt[a] = i; first[a] = None + if b >= H0 and b not in Tt and not (z == 4 and f == ZERO and v <= a < 2*v): Tt[b] = i; first[b] = None + else: + for s in (a, b): + if s >= H0 and s not in Tt: Tt[s] = i; first[s] = None +pivots = {z['pivot'] for z in wit}; donors = collections.defaultdict(list) +for z in wit: + B = [[int(x) for x in r] for r in z['basis']] + for d in z['partners']: donors[d].append(dict(cut=z['cut'], dim=z['dim'], basis=B, pivot=z['pivot'])) +used = pivots | set(donors) +newpairs = {z['pivot']: z for z in wit if z.get('round') and len(z['roles']) == 2} +member_of = {} +for z in newpairs.values(): + for h in z['roles']: member_of[h] = z['pivot'] +donor_refs = collections.Counter(d for z in wit for d in z['partners']) +famgain = {z['pivot']: z['approx_slack_delta'] for z in newpairs.values()} +pool = [h for h in range(H0, n) if ini[h] == ZERO and fin[h] == FULL and regs[h-H0] not in borrowed and regs[h-H0] not in donor_keys and (h not in used or h in member_of) and first.get(h) is not None and Tt[h] > CUT] +print('witness families', len(wit), 'pivots', len(pivots), 'distinct donors', len(donors), 'pool of unused untouched helpers', len(pool), flush=True) +# responses at CUT +row = [1 << s for s in range(n+1)] +for i in range(CUT+1): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 1: + if c & 1: row[a] ^= row[b] + elif k == 2: row[b] = row[a] +contam = 0 +for s in range(n): + if v <= s < 2*v: continue + contam |= (row[s] ^ (1 << s)) >> H0 +resp = collections.defaultdict(int) +for t in range(v): + r = row[v+t] >> H0 + while r: + low = r & -r; idx = low.bit_length()-1; resp[H0+idx] |= 1 << t; r ^= low +pool = [h for h in pool if not (contam >> (h-H0)) & 1 and resp[h]] +byresp = collections.defaultdict(list) +for h in pool: byresp[resp[h]].append(h) +phi = lambda r: 0.0 if r == 0 else r*math.log(120/r) +def contained(B, F): # subspace rows B inside frame F (annihilator test) + return all(sum(x*y for x, y in zip(b, a)) == 0 for b in B for a in fj[str(F)]['A']) +def nullspace(rows): + m = [[Fr(x) for x in r] for r in rows]; piv = []; r = 0 + for c in range(24): + p = next((i for i in range(r, len(m)) if m[i][c] != 0), None) + if p is None: continue + m[r], m[p] = m[p], m[r]; pv = m[r][c]; m[r] = [x/pv for x in m[r]] + for i in range(len(m)): + if i != r and m[i][c] != 0: + f = m[i][c]; m[i] = [a - f*b for a, b in zip(m[i], m[r])] + piv.append(c); r += 1 + if r == len(m): break + free = [c for c in range(24) if c not in piv]; out = [] + for fcol in free: + vec = [Fr(0)]*24; vec[fcol] = Fr(1) + for i, pc in enumerate(piv): vec[pc] = -m[i][fcol] + out.append(vec) + return out +def prim(vec): + L = 1 + for x in vec: L = lcm(L, x.denominator) + iv = [int(x*L) for x in vec]; g = 0 + for x in iv: g = gcd(g, abs(x)) + return [x//g for x in iv] +def ann_of(B): # annihilator rows of span(B) as integer rows + return [prim(u) for u in nullspace(B)] +cands = []; stats = collections.Counter() +for d, fams in donors.items(): + if Tt.get(d, 0) <= CUT or d not in resp or resp[d] == 0 or (contam >> (d-H0)) & 1: stats['donor_touched_or_contaminated'] += 1; continue + twins = byresp.get(resp[d], []) + if not twins: continue + for fam in fams: + if fam['cut'] < CUT: continue + e, B = fam['dim'], fam['basis']; rp_all = [] + for p in twins: + Fp = first[p]; rp = fj[str(Fp)]['dim'] + if contained(B, Fp) and rp >= e: + g = phi(rp-e) - phi(rp); cands.append(dict(gain=g, pivot=p, donor=d, e=e, basis=B, cut=CUT, mode='same-entrance', donor_cut=fam['cut'], donor_pivot=fam['pivot'])); stats['same-entrance'] += 1 + elif e >= 2: + # line inside E_d ∩ F_p: nullspace of (ann(E_d) ∪ ann(F_p)) + inter = nullspace(ann_of(B) + fj[str(Fp)]['A']) + if inter: + u = prim(inter[0]) + if 9*sum(x*x for x in u) - sum(u)**2 != 0: + g = phi(rp-1) - phi(rp) + phi(1) + phi(e-1) - phi(e); cands.append(dict(gain=g, pivot=p, donor=d, e=1, basis=[u], cut=CUT, mode='nested-line', donor_cut=fam['cut'], donor_pivot=fam['pivot'])); stats['nested-line'] += 1 + else: stats['nested-line-degenerate'] += 1 + else: stats['no-line'] += 1 + else: stats['E_not_in_Fp'] += 1 +print('candidate stats', dict(stats), 'candidates', len(cands), f'({time.time()-t0:.0f}s)', flush=True) +cands.sort(key=lambda z: z['gain']); taken = set(); chosen = []; dissolved = set(); freed = set() +for z in cands: + if z['gain'] >= 0: break + p = z['pivot'] + if p in taken or z['donor'] in dissolved_donors if False else False: continue + if p in taken: continue + if p in member_of and member_of[p] not in dissolved and p not in freed: + fam = newpairs[member_of[p]]; dnr = fam['partners'][0] + # dissolve only if strictly better and the pair's donor is referenced by no other family (incl. chosen shared ones) + if z['gain'] - famgain[fam['pivot']] >= 0 or donor_refs[dnr] > 1 or any(c['donor'] == dnr for c in chosen) or z['donor'] in fam['roles']: continue + dissolved.add(fam['pivot']); freed |= set(fam['roles']); taken.add(fam['pivot']) if fam['pivot'] != p else None + elif p in member_of and member_of[p] in dissolved and p not in freed: continue + taken.add(p); chosen.append(z) +print('dissolved own pair families', len(dissolved)) +wit = [z for z in wit if z['pivot'] not in dissolved] +print('chosen shared-donor families', len(chosen), 'by mode', collections.Counter(z['mode'] for z in chosen), 'by e', collections.Counter(z['e'] for z in chosen), 'distinct donors', len({z['donor'] for z in chosen}), 'max pivots per donor', max(collections.Counter(z['donor'] for z in chosen).values()), 'phi gain', round(sum(z['gain'] for z in chosen), 1)) +print('by (pivot first dim, e):', collections.Counter((fj[str(first[z['pivot']])]['dim'], z['e']) for z in chosen).most_common(8)) +# cross-check with #270's 24 +sh270 = {(z['pivot'], z['partners'][0]) for z in c270 if z.get('kind') == 'reuse'} +mine = {(z['pivot'], z['donor']) for z in chosen} +print('#270 reuse pairs reproduced in my chosen set:', len(sh270 & mine), 'of 24; #270 pairs with pivot already used in union3:', sum(1 for p, d in sh270 if p in used)) +chosen = [z for z in chosen if z['donor'] not in {h for f in dissolved for h in newpairs[f]['roles']} or z['donor'] in {d for z2 in wit for d in z2['partners']}] +S = sum(z['dim'] for z in wit) + sum(z['e'] for z in chosen) +while S % 3: + for j in range(len(chosen)-1, -1, -1): + if chosen[j]['e'] == 1: S -= 1; chosen.pop(j); break +items = [dict(pivot=z['pivot'], a=z['pivot'], roles=[z['pivot'], z['donor']], partners=[z['donor']], dim=z['e'], E_dimension=z['e'], basis=[[str(x) for x in r] for r in z['basis']], cut=z['cut'], approx_slack_delta=z['gain'], kind='shared-donor %s (donor of pivot %d at cut %d)' % (z['mode'], z['donor_pivot'], z['donor_cut']), round='shared-donor') for z in chosen] +merged = wit + items; print('merged families', len(merged), 'entrance rank', S, 'mod 3', S % 3) +json.dump(merged, open(OUT, 'w'), indent=1); open(OUT + '.gz', 'wb').write(gzip.compress(json.dumps(merged, indent=1).encode(), mtime=0)) diff --git a/research/multicut-kernel-composition/discovery/chain_swap.py b/research/multicut-kernel-composition/discovery/chain_swap.py new file mode 100644 index 0000000000..1cf6aa5511 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/chain_swap.py @@ -0,0 +1,50 @@ +"""Chain with rebinding: new cohort lead -> rebound descent -> rebound plateau -> rebound target-prefix -> seven native checkers -> sandwich (k=126) + checks. +usage: chain_swap.py PKG LEAD_SRC X BIN W269WORD SEL273 OLD_PRE_DESCENT OLD_POST_DESCENT P270 OUT""" +import json, sys, subprocess, shutil, hashlib, time +from pathlib import Path +sys.dont_write_bytecode = True +PKG, LEADSRC, X, BIN, W269, SEL273, OLDPRE, OLDPOST, P270, W = map(Path, sys.argv[1:11]); PY = sys.executable; T0 = time.time(); tm = {} +HERE = Path(__file__).resolve().parent; SHIM = sys.argv[11] if len(sys.argv) > 11 else None +if W.exists(): shutil.rmtree(W) +W.mkdir(parents=True) +def sha(p): return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def run(label, cmd, cwd=None): + t = time.time(); log = W / (label + '.log') + with log.open('w') as lf: r = subprocess.run([str(c) for c in cmd], stdout=lf, stderr=subprocess.STDOUT, cwd=cwd or W) + tm[label] = round(time.time() - t, 1); print(f'{label}: exit {r.returncode} ({tm[label]}s)', flush=True) + if r.returncode: print(log.read_text()[-3000:]); raise SystemExit(label + ' FAILED') +lead = W / 'lead'; shutil.copytree(LEADSRC, lead) +sys.path.insert(0, str(P270)); from rebind_descent import rebind +al = rebind(OLDPRE, lead / 'COHORT249-RECORDS.bin', PKG / 'inputs/descent-selection.json', W / 'descent-selection.json') +print('rebind descent:', al['status'], al['events_compared'], flush=True) +shutil.copy(W / 'descent-selection.json', lead / 'descent-selection.json'); (lead / 'DESCENT-REBIND-EVIDENCE.json').write_text(json.dumps(al, indent=2) + '\n') +run('descent', [PY, '-B', PKG / 'code/descent_retiming.py', X, lead, lead / 'descent-selection.json']) +print('post-descent sha', sha(lead / 'COHORT249-RECORDS.bin'), json.load((lead / 'DESCENT-RETIMING.json').open())['local_histogram_delta'], flush=True) +run('rebind-plateaus', [PY, '-B', P270 / 'rebind_plateaus.py', OLDPOST, PKG / 'inputs/plateau-selection.json', lead / 'COHORT249-RECORDS.bin', W / 'plateau-selection.json']) +plateau = W / 'plateau' +run('plateau', [PY, '-B', PKG / 'code/plateau_retiming.py', X, lead, W / 'plateau-selection.json', plateau], cwd=PKG / 'code') +run('plateau-spans', [PY, '-B', PKG / 'code/verify_plateau_spans.py', X, plateau, plateau / 'PLATEAU-RETIMING.json'], cwd=PKG / 'code') +print('post-plateau sha', sha(plateau / 'COHORT249-RECORDS.bin'), flush=True) +bound = plateau / 'target-selection.json' +run('rebind-target', [PY, '-B', HERE / 'rebind_target.py', W269, SEL273, plateau / 'COHORT249-RECORDS.bin', bound]) +run('target-prefix', [PY, '-B', PKG / 'code/target_prefix.py', X, plateau, bound]) +print('post-target sha', sha(plateau / 'COHORT249-RECORDS.bin'), json.load((plateau / 'TARGET-PREFIX.json').open())['local_histogram_delta'], flush=True) +run('frame-tables', [PY, '-B', PKG / 'code/verify_frame_tables.py', X, plateau, '--output', plateau / 'FRAME-TABLE-AUDIT.json'], cwd=PKG / 'code') +bank = W / 'bank'; bank.mkdir() +run('c1-legality', [BIN / 'cohort-legality-independent', X, plateau, plateau / 'INDEPENDENT-LEGALITY.json']) +run('c2-prefix', [BIN / 'cohort-prefix-independent', X, plateau, plateau / 'INDEPENDENT-PREFIX.json']) +run('c3-bank', [BIN / 'cohort-bank-review', X, plateau / 'COHORT249-INITIAL.json', plateau / 'COHORT249-FRAMES.json', bank, 'actual_multicut']) +run('c4-five-stage', [BIN / 'cohort-five-stage-columns', plateau / 'COHORT249-RECORDS.bin', plateau / 'COHORT-FIVE-STAGE-COLUMNS.json']) +run('c5-price', [BIN / 'cohort-price', plateau / 'COHORT249-REPLAY.json', plateau / 'COHORT-EXACT-PRICE.json']) +run('c6-finite', [BIN / 'cohort-finite-invoice', plateau / 'COHORT249-RECORDS.bin', plateau / 'COHORT-EXACT-PRICE.json', bank / 'BANK-REVIEW.json', plateau / 'COHORT-FIVE-STAGE-COLUMNS.json', plateau / 'COHORT-FINITE-INVOICE.json']) +cc = json.load((plateau / 'COHORT-EXACT-PRICE.json').open())['cohort_candidate'] +print('NATIVE', json.dumps(dict(kappa=cc['kappa'], kappa_decimal=cc['kappa_decimal'], stock=cc['stock'], rank_mass=cc['rank_mass'], deficit=cc['deficit'], word_sha=sha(plateau / 'COHORT249-RECORDS.bin'))), flush=True) +# sandwiches: rescan, maximal set with k = 0 mod 3 +run('scan-sandwich', [PY, '-B', HERE / 'scan_sandwich.py', X, plateau, W / 'scan-sandwich.json']) +scan = json.load((W / 'scan-sandwich.json').open()); helpers = sorted(c['helper'] for c in scan['chosen']); k = len(helpers) - len(helpers) % 3; helpers = helpers[:k] +sel = dict(status='FROZEN_CLEANUP_SANDWICH_HELPERS', input_record_sha256=sha(plateau / 'COHORT249-RECORDS.bin'), helpers=helpers, expected_local_histogram_delta={'1': 2*k, '20': k, '21': -2*k}, + scanned_sandwich_helpers=len(scan['chosen']), provenance='Helpers with exactly the three-gate cleanup sandwich t += a; a += b; t += a after the first kernel cut, rescanned on this package word after the target-prefix stage (PR271 mechanism, evmckinney9); the largest subset with k = 0 mod 3 (each helper-replica frees 20 bank width units, 800k in total, which must tile width-120 banks), taken in helper-id order. Each joint cut frame of (a, b) is four-dimensional and nondegenerate for 9I - J.') +(PKG / 'inputs/sandwich-selection.json').write_text(json.dumps(sel, indent=1) + '\n'); print('sandwich helpers', len(scan['chosen']), '-> k', k, flush=True) +run('sandwich', [PY, '-B', PKG / 'code/cleanup_sandwich.py', X, plateau, PKG / 'inputs/sandwich-selection.json', plateau / 'sandwich']) +run('sandwich-verify', [PY, '-B', HERE / 'sandwich_verify.py', PKG, X, plateau / 'sandwich', bank / 'BANK-REVIEW.json', BIN, W / 'sandwich-verify', plateau / 'COHORT-EXACT-PRICE.json', 'clang++'] + ([SHIM] if SHIM else [])) +print((W / 'sandwich-verify.log').read_text()[-900:]); print('timings', tm, 'total', round(time.time() - T0, 1)) diff --git a/research/multicut-kernel-composition/discovery/chrono2.py b/research/multicut-kernel-composition/discovery/chrono2.py new file mode 100644 index 0000000000..1d858877fc --- /dev/null +++ b/research/multicut-kernel-composition/discovery/chrono2.py @@ -0,0 +1,101 @@ +import json, sys, collections, time, pickle, itertools +from array import array +from fractions import Fraction as Fr +from math import lcm, gcd +D = sys.argv[1]; T = pickle.load(open(sys.argv[2], 'rb')); C = pickle.load(open(sys.argv[3], 'rb')); CUT = int(sys.argv[4]) +t0 = time.time() +st = json.load(open(D + '/249-states.json')); n, v, ZERO, FULL = st['n'], st['v'], st['ZERO'], st['FULL'] +ini, fin, regs = T['ini'], T['fin'], st['regs']; borrowed = set(st['borrowed']); donor = set(json.load(open(D + '/249-DONOR-OWNERSHIP.json'))['donor_keys']) +rec = array('i'); rec.frombytes(open(D + '/249-records.bin', 'rb').read()); E = len(rec)//6; H0 = 2*v +Tt, kind = C['Tt'], C['kind'] +fj = json.load(open(D + '/frames.json'))['frames'] +# first MOVE destination frame after CUT for each helper +ff = {} +for i in range(CUT+1, E): + k,a,b,c,f,z = rec[6*i:6*i+6] + if k == 0 and a >= H0 and a not in ff: ff[a] = c +row = [1 << s for s in range(n+1)] +for i in range(CUT+1): + k,a,b,c,f,z = rec[6*i:6*i+6] + if k == 1: + if c & 1: row[a] ^= row[b] + elif k == 2: row[b] = row[a] +base = [h for h in range(H0, n) if ini[h] == ZERO and fin[h] == FULL and regs[h-H0] not in borrowed and regs[h-H0] not in donor and Tt[h] > CUT and kind[h][0] == 'MOVE'] +contam = 0 +for s in range(n): + if v <= s < 2*v: continue + contam |= (row[s] ^ (1 << s)) >> H0 +resp = collections.defaultdict(int) +for t in range(v): + r = row[v+t] >> H0 + while r: + low = r & -r; idx = low.bit_length()-1; resp[H0+idx] |= 1 << t; r ^= low +live = [h for h in base if not (contam >> (h-H0)) & 1 and resp[h]] +cls = collections.defaultdict(list) +for h in live: cls[resp[h]].append(h) +print(f'CUT {CUT}: base {len(base)} live(clean,nonzero resp) {len(live)} distinct responses {len(cls)} class sizes {sorted(collections.Counter(len(m) for m in cls.values()).items())}') +def nullspace(rows): + m = [[Fr(x) for x in r] for r in rows]; ncol = 24; piv = []; r = 0 + for c in range(ncol): + p = next((i for i in range(r, len(m)) if m[i][c] != 0), None) + if p is None: continue + m[r], m[p] = m[p], m[r]; pv = m[r][c]; m[r] = [x/pv for x in m[r]] + for i in range(len(m)): + if i != r and m[i][c] != 0: + f = m[i][c]; m[i] = [a - f*b for a, b in zip(m[i], m[r])] + piv.append(c); r += 1 + if r == len(m): break + free = [c for c in range(ncol) if c not in piv]; basis = [] + for fcol in free: + vec = [Fr(0)]*ncol; vec[fcol] = Fr(1) + for i, pc in enumerate(piv): vec[pc] = -m[i][fcol] + basis.append(vec) + return basis, free +def gramdet(basis): + k = len(basis); M = [[9*sum(a*b for a, b in zip(basis[i], basis[j])) - sum(basis[i])*sum(basis[j]) for j in range(k)] for i in range(k)] + det = Fr(1) + for c in range(k): + p = next((i for i in range(c, k) if M[i][c] != 0), None) + if p is None: return 0 + if p != c: M[c], M[p] = M[p], M[c]; det = -det + det *= M[c][c] + for i in range(c+1, k): + f = M[i][c]/M[c][c]; M[i] = [a - f*b for a, b in zip(M[i], M[c])] + return det +def shape4(u): return sorted(abs(x) for x in u) == [0]*20 + [1]*4 and sum(u) == 0 +def prim(vec): + L = 1 + for x in vec: L = lcm(L, x.denominator) + iv = [int(x*L) for x in vec]; g = 0 + for x in iv: g = gcd(g, abs(x)) + return [x//g for x in iv] +def classify(frames): + rows = [] + for f in frames: rows += fj[str(f)]['A'] + basis, free = nullspace(rows); d = len(basis) + if d == 0: return 'dim0', None + g = gramdet(basis) + if d == 1: u = prim(basis[0]); return (f'dim1_{"shape4" if shape4(u) else "other"}' + ('_degenerate' if g == 0 else ''), u) + if d <= 8: + for lam in itertools.product((-1, 0, 1), repeat=d): + if not any(lam): continue + u = [sum(l*b[i] for l, b in zip(lam, basis)) for i in range(24)] + if all(x.denominator == 1 for x in u) and shape4([int(x) for x in u]): return f'dim{d}_has_shape4' + ('_degenerate' if g == 0 else ''), [int(x) for x in u] + return f'dim{d}_no_shape4' + ('_degenerate' if g == 0 else ''), None + return f'dim{d}_unchecked', None +res = collections.Counter(); fdims = collections.Counter(); otheru = [] +final_pairs = {tuple(sorted(m)) for r, m in T['classes'].items() if r and len(m) == 2} +pairs = [tuple(sorted(m)) for m in cls.values() if len(m) == 2] +for p in pairs: + key, u = classify([ff[p[0]], ff[p[1]]]); res[(key, p in final_pairs)] += 1; fdims[(fj[str(ff[p[0]])]['dim'], fj[str(ff[p[1]])]['dim'])] += 1 + if key == 'dim1_other' and p in final_pairs: otheru.append(u) +print('twin pairs by (intersection class, is-final-cut-pair):'); [print(' ', k, c) for k, c in sorted(res.items(), key=lambda x: -x[1])] +print('first-frame dim pairs (top 12):', fdims.most_common(12)) +print('u vectors of final-cut dim1_other pairs:'); [print(' ', u, 'norm', sum(x*x for x in u), 'sum', sum(u)) for u in otheru] +big = [m for m in cls.values() if len(m) >= 3] +print('classes of size>=3:', [len(m) for m in big]) +bres = collections.Counter() +for m in big: + key, u = classify([ff[h] for h in m]); bres[(len(m), key)] += 1 +print('size>=3 classes common-intersection:', dict(bres)) +print('done', time.time()-t0) diff --git a/research/multicut-kernel-composition/discovery/compare259.py b/research/multicut-kernel-composition/discovery/compare259.py new file mode 100644 index 0000000000..bc7bf020fd --- /dev/null +++ b/research/multicut-kernel-composition/discovery/compare259.py @@ -0,0 +1,57 @@ +import json, sys, collections, math +from decimal import Decimal as Dc, getcontext +getcontext().prec = 50 +c259 = json.load(open(sys.argv[1])); mine = json.load(open(sys.argv[2]))['candidates']; rep = json.load(open(sys.argv[3])); fj = json.load(open(sys.argv[4]))['frames'] +items = c259 if isinstance(c259, list) else c259['candidates'] +print('PR259 candidates', len(items), 'item key sets', collections.Counter(tuple(sorted(z.keys())) for z in items).most_common(4)) +used = set(); piv = set(); cuts = collections.Counter(); dims = collections.Counter(); fam = collections.Counter() +for z in items: + if 'roles' in z: p = z['pivot']; roles = list(z['roles']); d = z['dim'] + else: p = z['a']; roles = [z['a'], z['b']]; d = z['E_dimension'] + piv.add(p); used |= set(roles); cuts[z.get('cut', 727593)] += 1; dims[d] += 1; fam[len(roles)] += 1 +print('pivots', len(piv), 'distinct helpers', len(used), 'cuts', dict(cuts), 'E dims', sorted(dims.items()), 'family sizes', sorted(fam.items())) +print('sum of dims (entrance rank)', sum((z['dim'] if 'roles' in z else z['E_dimension']) for z in items)) +my_used = {z['a'] for z in mine} | {z['b'] for z in mine} +print('my pairs', len(mine), 'my helpers', len(my_used), 'overlap helpers with PR259', len(my_used & used), 'my pivots that are PR259 pivots', len({z['a'] for z in mine} & piv)) +free = [z for z in mine if z['a'] not in used and z['b'] not in used] +half = [z for z in mine if (z['a'] in used) != (z['b'] in used)] +print('my pairs fully disjoint from PR259 helpers:', len(free), ' pairs with exactly one helper used by PR259:', len(half)) +print('free pairs by frame dims:', collections.Counter(tuple(z.get('frame_dims', [3, 3])) for z in free)) +print('free pairs by source:', collections.Counter(z.get('source', '?') for z in free)) +# price union: PR259 histogram (x40 + completions) and W=173435, then add free pairs e=1 (drop weakest to keep count = 0 mod 3) +LN = {} +def moment(H, W, a, m=120): + s = Dc(0); N = 0 + for r, n in H.items(): + if n == 0: continue + if r not in LN: LN[r] = (Dc(m)/Dc(r)).ln() + s += Dc(r*n)/(Dc(m)*W) * (LN[r]*a).exp(); N += n + if 'm' not in LN: LN['m'] = Dc(m).ln() + return s + Dc(32*m*m*N)/(Dc(m)*W) * (LN['m']*a).exp() / Dc(10)**16 +grid = Dc(10)**18 +def price(H, W): + lo, hi = Dc('0.0005'), Dc('0.001'); assert moment(H, W, lo) < 1 < moment(H, W, hi) + for _ in range(80): + mid = (lo+hi)/2 + if moment(H, W, mid) < 1: lo = mid + else: hi = mid + z = int(lo*grid); assert moment(H, W, Dc(z)/grid) < 1 and moment(H, W, Dc(z+1)/grid) > 1 + c = Dc(z)/grid; bit = Dc(384599)/Dc(10)**10 + for _ in range(3): bit = (1-c)*c + c*bit + eta = Dc(1)/Dc(10)**12; q = bit*(1-2*eta); bound = (1-eta)*q/(1+q) + return Dc(int(bound*grid))/grid, c +H = {int(k): 40*v for k, v in rep['histogram'].items()} +for r in (4, 23, 46, 50): H[r] = H.get(r, 0) + 16*1760 +k259, c259v = price(H, Dc(173435)); print('PR259 kappa reproduced:', k259, 'coarse', c259v) +free.sort(key=lambda z: z['approx_slack_delta']) +while len(free) % 3: free.pop() +H2 = dict(H) +for z in free: + ra, rb = z.get('frame_dims') or [fj[str(z['first_a'])]['dim'], fj[str(z['first_b'])]['dim']] + for r, dn in ((ra, -40), (rb, -40), (ra-1, 40), (1, 40), (rb-1, 40)): + if r > 0: H2[r] = H2.get(r, 0) + dn +W2 = Dc(173435) - Dc(len(free))/3 +k2, c2 = price(H2, W2) +print(f'UNION projection: PR259 + {len(free)} free e=1 pairs -> kappa={k2} coarse={c2} W={W2} mass={sum(r*n for r,n in H2.items())} deficit={120*W2-sum(r*n for r,n in H2.items())}') +print(f' dk vs PR259 = {k2-k259} dk vs PR263 (7.11032e-4 nominal) = {k2-Dc("0.000711032")}') +json.dump(dict(free=[(z['a'], z['b']) for z in free]), open(sys.argv[5], 'w')) diff --git a/research/multicut-kernel-composition/discovery/finalize_swap.py b/research/multicut-kernel-composition/discovery/finalize_swap.py new file mode 100644 index 0000000000..6863abd747 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/finalize_swap.py @@ -0,0 +1,32 @@ +"""Fill the swap package from chain_swap outputs. usage: finalize_swap.py PKG CHAIN_DIR""" +import json, hashlib, shutil, sys +from fractions import Fraction +from pathlib import Path +PKG, RUN = map(Path, sys.argv[1:3]); lead = RUN / 'lead'; plateau = RUN / 'plateau'; sand = plateau / 'sandwich'; SV = RUN / 'sandwich-verify' +def sha(p): return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def load(p): return json.loads(Path(p).read_text()) +exp = PKG / 'expected' +for name, src in {'COHORT249-REPLAY.json': plateau, 'INDEPENDENT-LEGALITY.json': plateau, 'INDEPENDENT-PREFIX.json': plateau, 'COHORT-BANK-REVIEW.json': RUN / 'bank', 'COHORT-FIVE-STAGE-COLUMNS.json': plateau, + 'COHORT-EXACT-PRICE.json': plateau, 'COHORT-FINITE-INVOICE.json': plateau, 'DESCENT-RETIMING.json': plateau, 'PLATEAU-RETIMING.json': plateau, 'PLATEAU-SOURCE-SPANS.json': plateau, 'FRAME-TABLE-AUDIT.json': plateau, 'TARGET-PREFIX.json': plateau}.items(): + shutil.copy(src / ('BANK-REVIEW.json' if name == 'COHORT-BANK-REVIEW.json' else name), exp / name) +exps = PKG / 'expected-sandwich' +for name, src in {'CLEANUP-SANDWICH.json': sand, 'COHORT249-REPLAY.json': sand, 'INDEPENDENT-LEGALITY.json': SV, 'INDEPENDENT-PREFIX.json': SV, 'COHORT-FIVE-STAGE-COLUMNS.json': SV, 'SANDWICH-BANK-INVOICE.json': SV, 'COHORT-EXACT-PRICE.json': SV, 'COHORT-FINITE-INVOICE.json': SV}.items(): + shutil.copy(src / name, exps / name) +shutil.copy(plateau / 'target-selection.json', PKG / 'inputs/target-selection.json') +shutil.copy(RUN / 'descent-selection.json', PKG / 'inputs/descent-selection.json'); shutil.copy(RUN / 'plateau-selection.json', PKG / 'inputs/plateau-selection.json') +res = load(PKG / 'RESULT.json'); native = load(plateau / 'COHORT-EXACT-PRICE.json')['cohort_candidate']; sw = load(SV / 'COHORT-EXACT-PRICE.json')['cohort_candidate'] +tp = load(plateau / 'TARGET-PREFIX.json'); cs = load(sand / 'CLEANUP-SANDWICH.json'); rep = load(lead / 'COHORT249-REPLAY.json') +def decimal(k): + x = Fraction(k); q, r = divmod(x.numerator * 10**18, x.denominator); assert r == 0; s = str(q).rjust(19, '0'); return s[:-18] + '.' + s[-18:] +res.update(previous_delivery_kappa=res['kappa_decimal'], cohort_record_sha256=sha(lead / 'COHORT249-PRE-DESCENT-RECORDS.bin'), descent_record_sha256=sha(lead / 'COHORT249-RECORDS.bin'), + plateau_record_sha256=sha(plateau / 'COHORT249-PRE-TARGET-RECORDS.bin'), new_record_sha256=sha(plateau / 'COHORT249-RECORDS.bin'), + kappa_native_seven_checkers=native['kappa'], kappa_native_decimal=decimal(native['kappa']), kappa=sw['kappa'], kappa_decimal=decimal(sw['kappa']), + pivots=rep['new_gauges'], entrance_rank=rep['new_entrance_rank'], pivot_role_swapped_pair_families=83, + target_prefix_groups=tp['selected_groups'], target_prefix_deleted_reads=tp['deleted_prefix_adds'], target_prefix_setup_restore_additions=tp['inserted_setup_restore_adds'], + sandwich_record_sha256=sha(sand / 'COHORT249-RECORDS.bin'), sandwich_helpers_retired=cs['helpers_retired'], sandwich_helpers_scanned=load(PKG / 'inputs/sandwich-selection.json')['scanned_sandwich_helpers'], + sandwich_normalized_stock=sw['stock'], native_normalized_stock=native['stock']) +(PKG / 'RESULT.json').write_text(json.dumps(res, indent=2) + '\n') +for p in PKG.rglob('__pycache__'): shutil.rmtree(p) +files = {p.relative_to(PKG).as_posix(): sha(p) for p in sorted(PKG.rglob('*')) if p.is_file() and p.name != 'MANIFEST.json'} +(PKG / 'MANIFEST.json').write_text(json.dumps({'files': files}, indent=2) + '\n') +print(json.dumps({k: res[k] for k in ('kappa', 'kappa_decimal', 'kappa_native_seven_checkers', 'kappa_native_decimal', 'cohort_record_sha256', 'descent_record_sha256', 'plateau_record_sha256', 'new_record_sha256', 'sandwich_record_sha256', 'sandwich_helpers_retired', 'sandwich_helpers_scanned')}, indent=1), 'files', len(files)) diff --git a/research/multicut-kernel-composition/discovery/gain.py b/research/multicut-kernel-composition/discovery/gain.py new file mode 100644 index 0000000000..d851c3608f --- /dev/null +++ b/research/multicut-kernel-composition/discovery/gain.py @@ -0,0 +1,79 @@ +import json, sys, collections, time, pickle, itertools, math +from array import array +from fractions import Fraction as Fr +from math import lcm, gcd +exec(open(sys.argv[5]).read().split("res = collections.Counter(); fdims")[0]) # chrono2 setup at CUT: cls, ff, fj, classify, nullspace, gramdet, prim +from decimal import Decimal as Dc, getcontext +getcontext().prec = 50 +rep = json.load(open(sys.argv[6])) +H = {int(k): 40*v for k, v in rep['histogram'].items()} +for r in (4, 23, 46, 50): H[r] = H.get(r, 0) + 16*1760 +exec(open(sys.argv[7]).read().split("print('baseline:')")[0].split("rep = json.load")[0].replace("import json, sys", "")) # moment/price defs? simpler: redefine +LN = {} +def moment(H, W, a, m=120): + s = Dc(0); N = 0 + for r, n in H.items(): + if n == 0: continue + if r not in LN: LN[r] = (Dc(m)/Dc(r)).ln() + s += Dc(r*n)/(Dc(m)*W) * (LN[r]*a).exp(); N += n + if 'm' not in LN: LN['m'] = Dc(m).ln() + return s + Dc(32*m*m*N)/(Dc(m)*W) * (LN['m']*a).exp() / Dc(10)**16 +grid = Dc(10)**18 +def price(H, W): + lo, hi = Dc('0.0005'), Dc('0.001'); assert moment(H, W, lo) < 1 < moment(H, W, hi) + for _ in range(80): + mid = (lo+hi)/2 + if moment(H, W, mid) < 1: lo = mid + else: hi = mid + z = int(lo*grid); assert moment(H, W, Dc(z)/grid) < 1 and moment(H, W, Dc(z+1)/grid) > 1 + c = Dc(z)/grid; bit = Dc(384599)/Dc(10)**10 + for _ in range(3): bit = (1-c)*c + c*bit + eta = Dc(1)/Dc(10)**12; q = bit*(1-2*eta); bound = (1-eta)*q/(1+q) + return Dc(int(bound*grid))/grid +kn = price(H, Dc(173839)); print('PR254 kappa reproduced', kn) +phi = lambda r: 0.0 if r == 0 else r*math.log(120/r) +def best(ra, rb, d): + # pivot p starts at E (dim e<=d), partner b raised to E; gain = phi(rp-e)-phi(rp) + phi(e)+phi(rb-e)-phi(rb) (negative = good) + out = None + for rp, rq in ((ra, rb), (rb, ra)): + for e in range(1, d+1): + g = phi(rp-e)-phi(rp) + phi(e)+phi(rq-e)-phi(rq) + if out is None or g < out[0]: out = (g, e, rp, rq) + return out +def inter_dim_nondeg(frames): + rows = [] + for f in frames: rows += fj[str(f)]['A'] + basis, free = nullspace(rows); d = len(basis) + if d == 0: return 0, False + return d, gramdet(basis) != 0 +pairs = [tuple(sorted(m)) for m in cls.values() if len(m) == 2] +tab = collections.Counter(); gains = []; H2 = dict(H); W2 = Dc(173839); npos = 0; totgain = 0.0 +strict_e1 = 0 +for a, b in pairs: + ra, rb = fj[str(ff[a])]['dim'], fj[str(ff[b])]['dim'] + d, nd = inter_dim_nondeg([ff[a], ff[b]]) + key = (tuple(sorted((ra, rb))), d, nd); tab[key] += 1 + if d == 0 or not nd: continue + g, e, rp, rq = best(ra, rb, d) + gains.append((g, e, rp, rq, a, b)) + if g < 0: + npos += 1; totgain += g + for r, dn in ((rp, -40), (rq, -40), (rp-e, 40), (e, 40), (rq-e, 40)): + if r > 0: H2[r] = H2.get(r, 0) + dn + W2 -= Dc(e)/3 +print('cross-tab (sorted first-frame dims, intersection dim, nondegenerate) -> count:'); [print(' ', k, c) for k, c in sorted(tab.items(), key=lambda x: -x[1])] +print('pairs with nonzero nondegenerate intersection:', len(gains), ' of which net-positive (log-weighted) with best pivot/e:', npos, ' total phi-gain', round(totgain, 1)) +print('gain histogram (e, frames) for positive pairs:', collections.Counter((e, (rp, rq)) for g, e, rp, rq, a, b in gains if g < 0).most_common(12)) +k2 = price(H2, W2); print(f'price: all net-positive pairs at cut {CUT} (single cut, e<=dim): kappa={k2} dk vs PR254={k2-kn} ({float((k2-kn)/kn*100):.4f}%) W2={W2} mass={sum(r*n for r,n in H2.items())} deficit={120*W2-sum(r*n for r,n in H2.items())}') +# restricted variant: e=1 only, nondegenerate line, any u (needs norm-2 charts) +H3 = dict(H); W3 = Dc(173839); n3 = 0 +for g, e, rp, rq, a, b in gains: + g1 = min(phi(rp-1)-phi(rp)+phi(1)+phi(rq-1)-phi(rq), phi(rq-1)-phi(rq)+phi(1)+phi(rp-1)-phi(rp)) + if g1 < 0: + n3 += 1 + for r, dn in ((rp, -40), (rq, -40), (rp-1, 40), (1, 40), (rq-1, 40)): + if r > 0: H3[r] = H3.get(r, 0) + dn + W3 -= Dc(1)/3 +k3 = price(H3, W3); print(f'price: e=1 only, {n3} net-positive pairs: kappa={k3} dk vs PR254={k3-kn}') +# the PR's own 132 (3,3) pairs: phi gain check +print('phi gain per (3,3) e=1 pair', round(best(3,3,1)[0],3), ' (2,2) e=1', round(best(2,2,1)[0],3), ' (2,2) e=2', round(best(2,2,2)[0],3), ' (1,1) e=1', round(best(1,1,1)[0],3), ' (5,5) e=1', round(best(5,5,1)[0],3), ' (5,5) e=3', round(best(5,5,3)[0],3), ' (3,3,3) triple e=1', round(2*(phi(1)+phi(2)-phi(3)) + phi(2)-phi(3),3)) diff --git a/research/multicut-kernel-composition/discovery/gen_candidates.py b/research/multicut-kernel-composition/discovery/gen_candidates.py new file mode 100644 index 0000000000..84d62b8c12 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/gen_candidates.py @@ -0,0 +1,139 @@ +"""Emit PR254-schema candidates for the response-twin rewrite at an early cut. +usage: gen_candidates.py DATA_DIR PR254_CANDIDATES_JSON CUT PHASE OUT_JSON +PHASE 1: u with sum 0, u.u = 4 (four +-1 entries), e=1. PHASE 2: additionally u = e_i - e_j (u.u = 2).""" +import json, sys, collections, time, itertools, math, gzip +from array import array +from fractions import Fraction as Fr +from math import lcm, gcd +D, PRC, CUT, PHASE, OUT = sys.argv[1], sys.argv[2], int(sys.argv[3]), int(sys.argv[4]), sys.argv[5] +t0 = time.time() +st = json.load(open(D + '/249-states.json')); n, v, ZERO, FULL = st['n'], st['v'], st['ZERO'], st['FULL']; H0 = 2*v +ini = [ZERO]*n; fin = [FULL]*n +for k, x in st['initial'].items(): ini[int(k)] = x +for k, x in st['final'].items(): fin[int(k)] = x +regs = st['regs']; borrowed = set(st['borrowed']); donor = set(json.load(open(D + '/249-DONOR-OWNERSHIP.json'))['donor_keys']) +rec = array('i'); rec.frombytes(open(D + '/249-records.bin', 'rb').read()); E = len(rec)//6 +fj = json.load(open(D + '/frames.json'))['frames'] +pr = json.load(open(PRC))['candidates']; prmap = {} +for z in pr: prmap[(z['a'], z['b'])] = z +# sanity on the cut: record CUT-1 is the last zero-frame initial read, none after +reads_after = sum(1 for i in range(CUT, E) if rec[6*i] == 1 and rec[6*i+5] == 4 and rec[6*i+4] == ZERO) +last_read = max(i for i in range(E) if rec[6*i] == 1 and rec[6*i+5] == 4 and rec[6*i+4] == ZERO) +print('cut', CUT, 'last initial read', last_read, 'reads after cut', reads_after); assert reads_after == 0 +# prefix census +bad = collections.Counter(); reads = collections.Counter(); row = [1 << s for s in range(n+1)] +for i in range(CUT+1): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 1: + if c & 1: row[a] ^= row[b] + if a >= H0: bad[a] += 1 + if b >= H0: + if z == 4 and f == ZERO and v <= a < 2*v: reads[b] += 1 + else: bad[b] += 1 + elif k == 2: + row[b] = row[a] + for s in (a, b): + if s >= H0: bad[s] += 1 + elif k == 3: + for s in (a, b): + if s >= H0: bad[s] += 1 + elif k == 0 and a >= H0: bad[a] += 1 +first = {} +for i in range(CUT+1, E): + k, a, b, c, f, z = rec[6*i:6*i+6] + if k == 0: + if a >= H0 and a not in first: first[a] = ('MOVE', c) + else: + for s in (a, b): + if s >= H0 and s not in first: first[s] = ('OTHER', None) +contam = 0 +for s in range(n): + if v <= s < 2*v: continue + contam |= (row[s] ^ (1 << s)) >> H0 +resp = collections.defaultdict(int) +for t in range(v): + r = row[v+t] >> H0 + while r: + low = r & -r; idx = low.bit_length()-1; resp[H0+idx] |= 1 << t; r ^= low +elig = [h for h in range(H0, n) if ini[h] == ZERO and fin[h] == FULL and not bad[h] and regs[h-H0] not in borrowed and regs[h-H0] not in donor and h in first and first[h][0] == 'MOVE' and not (contam >> (h-H0)) & 1 and resp[h]] +cls = collections.defaultdict(list) +for h in elig: cls[resp[h]].append(h) +pairs = [tuple(m) for m in cls.values() if len(m) == 2] +print('eligible', len(elig), 'twin pairs', len(pairs), 'classes>=3', sum(1 for m in cls.values() if len(m) > 2), time.time()-t0) +def nullspace(rows): + m = [[Fr(x) for x in r] for r in rows]; piv = []; r = 0 + for c in range(24): + p = next((i for i in range(r, len(m)) if m[i][c] != 0), None) + if p is None: continue + m[r], m[p] = m[p], m[r]; pv = m[r][c]; m[r] = [x/pv for x in m[r]] + for i in range(len(m)): + if i != r and m[i][c] != 0: + f = m[i][c]; m[i] = [a - f*b for a, b in zip(m[i], m[r])] + piv.append(c); r += 1 + if r == len(m): break + free = [c for c in range(24) if c not in piv]; basis = [] + for fcol in free: + vec = [Fr(0)]*24; vec[fcol] = Fr(1) + for i, pc in enumerate(piv): vec[pc] = -m[i][fcol] + basis.append(vec) + return basis +def prim(vec): + L = 1 + for x in vec: L = lcm(L, x.denominator) + iv = [int(x*L) for x in vec]; g = 0 + for x in iv: g = gcd(g, abs(x)) + return [x//g for x in iv] +def admissible(u): + s = sum(u); nrm = sum(x*x for x in u) + if s != 0: return False + if nrm == 4 and all(abs(x) <= 1 for x in u): return True + if PHASE >= 2 and nrm == 2: return True + return False +def find_u(basis): + d = len(basis) + if d == 1: + u = prim(basis[0]); return u if admissible(u) else None + best = None + for lam in itertools.product((-1, 0, 1), repeat=d): + if not any(lam): continue + u = [sum(l*b[i] for l, b in zip(lam, basis)) for i in range(24)] + if all(x.denominator == 1 for x in u): + u = prim([Fr(int(x)) for x in u]) + if admissible(u) and (best is None or sum(x*x for x in u) > sum(x*x for x in best)): best = u # prefer norm-4 (PR rule) + return best +phi = lambda r: 0.0 if r == 0 else r*math.log(120/r) +def annihilator(u): + sup = [i for i in range(24) if u[i]]; last = sup[-1]; rows = [] + for k in range(24): + if k == last: continue + r = [0]*24; r[k] = 1 + if u[k]: r[last] = -u[k]*u[last] # (e_k - (u_k/u_last) e_last), |u_last| = 1 + rows.append(r) + assert len(rows) == 23 and all(sum(x*y for x, y in zip(r, u)) == 0 for r in rows) + return rows +cands = []; stats = collections.Counter() +for a, b in pairs: + Fa, Fb = first[a][1], first[b][1]; ra, rb = fj[str(Fa)]['dim'], fj[str(Fb)]['dim'] + basis = nullspace(fj[str(Fa)]['A'] + fj[str(Fb)]['A']); d = len(basis) + if d == 0: stats['dim0'] += 1; continue + u = find_u(basis) + if u is None: stats[f'no_admissible_u_dim{d}'] += 1; continue + gain = min(phi(ra-1)-phi(ra)+phi(1)+phi(rb-1)-phi(rb), phi(rb-1)-phi(rb)+phi(1)+phi(ra-1)-phi(ra)) + if gain >= 0: stats[f'nonpositive_gain_{tuple(sorted((ra,rb)))}'] += 1; continue + if (a, b) in prmap or (b, a) in prmap: # keep PR254's own pair orientation and line verbatim + z = dict(prmap[(a, b)] if (a, b) in prmap else prmap[(b, a)]); z['approx_slack_delta'] = gain; z['source'] = 'PR254' + assert z['first_a'] == first[z['a']][1] and z['first_b'] == first[z['b']][1] + cands.append(z); stats['PR254_pair'] += 1; continue + # pivot = smaller first frame (its move shrinks); tie -> more initial reads removed + if (ra, -reads[a]) <= (rb, -reads[b]): p, q, Fp, Fq = a, b, Fa, Fb + else: p, q, Fp, Fq = b, a, Fb, Fa + fmt = lambda r: [str(x) for x in r] + cands.append(dict(E_dimension=1, a=p, annihilator=[fmt(r) for r in annihilator(u)], approx_slack_delta=gain, b=q, basis=[fmt(u)], first_a=Fp, first_b=Fq, new_targets=[], nondegeneracy_not_checked=True, source='early-cut', frame_dims=[fj[str(Fp)]['dim'], fj[str(Fq)]['dim']], u_norm=sum(x*x for x in u), pivot_initial_reads=reads[p])) + stats[f'new_pair_norm{sum(x*x for x in u)}_{(fj[str(Fp)]["dim"], fj[str(Fq)]["dim"])}'] += 1 +print('stats', dict(stats)) +# trim to P = 0 mod 3 by dropping the weakest gains +cands.sort(key=lambda z: z['approx_slack_delta']) +while len(cands) % 3: dropped = cands.pop(); print('dropped weakest pair', dropped['a'], dropped['b'], dropped['approx_slack_delta']) +out = dict(status='EXACT_INTERSECTION_EARLY_CUT_LOG_WEIGHTED_POSITIVE', cut_record=CUT, phase=PHASE, chart_rule='sum 0, norm 4 (four +-1)' if PHASE == 1 else 'sum 0, norm 4 or norm 2 (e_i - e_j)', approx_positive=len(cands), close_response_pairs=len(pairs), intersections=len(pairs)-stats['dim0'], max_response_symmetric_difference=0, no_kappa_claim=True, total_phi_gain=sum(z['approx_slack_delta'] for z in cands), candidates=cands) +json.dump(out, open(OUT, 'w'), indent=1); open(OUT + '.gz', 'wb').write(gzip.compress(json.dumps(out, indent=1).encode(), mtime=0)) +print('wrote', OUT, 'pairs', len(cands), 'P mod 3 =', len(cands) % 3, 'phi gain', round(out['total_phi_gain'], 2), 'removed reads', sum(reads[z['a']] for z in cands), time.time()-t0) diff --git a/research/multicut-kernel-composition/discovery/merge2.py b/research/multicut-kernel-composition/discovery/merge2.py new file mode 100644 index 0000000000..378820c7f4 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/merge2.py @@ -0,0 +1,21 @@ +import json, sys, gzip, collections +base = json.load(open(sys.argv[1])); cen = json.load(open(sys.argv[2])); half = json.load(open(sys.argv[3])); OUT = sys.argv[4] +used = {r for z in base for r in z['roles']} +chosen = sorted(cen['chosen'], key=lambda z: z['gain']) +# half-overlap free helpers +free_half = set() +for z in half: + pass +S_base = sum(z['dim'] for z in base); items = [] +for z in chosen: + assert not any(h in used for h in z['members']) + used |= set(z['members']) + items.append(dict(pivot=z['pivot'], a=z['pivot'], roles=list(z['members']), partners=[h for h in z['members'] if h != z['pivot']], dim=z['e'], E_dimension=z['e'], basis=[[str(x) for x in r] for r in z['basis']], cut=z['cut'], approx_slack_delta=z['gain'], kind='%s, e=%d, residual census at cut %d (excluding 851 helpers)' % (z['kind'], z['e'], z['cut']), round='headroom-2')) +S = S_base + sum(z['dim'] for z in items) +while S % 3: + for j in range(len(items)-1, -1, -1): + if items[j]['dim'] == 1: print('drop weakest dim-1', items[j]['roles'], items[j]['approx_slack_delta']); S -= 1; items.pop(j); break + else: raise SystemExit('cannot normalize mod 3') +merged = base + items +print('added', len(items), 'families; entrance rank', S, 'by cut', collections.Counter(z['cut'] for z in items), 'by e', collections.Counter(z['dim'] for z in items), 'gain', round(sum(z['approx_slack_delta'] for z in items), 2)) +json.dump(merged, open(OUT, 'w'), indent=1); open(OUT + '.gz', 'wb').write(gzip.compress(json.dumps(merged, indent=1).encode(), mtime=0)) diff --git a/research/multicut-kernel-composition/discovery/merge259.py b/research/multicut-kernel-composition/discovery/merge259.py new file mode 100644 index 0000000000..82a9905d85 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/merge259.py @@ -0,0 +1,13 @@ +import json, sys, gzip +c259 = json.load(open(sys.argv[1])); mine = json.load(open(sys.argv[2]))['candidates']; free = {tuple(p) for p in json.load(open(sys.argv[3]))['free']}; OUT = sys.argv[4] +used = set() +for z in c259: used |= set(z['roles']) +added = [] +for z in mine: + if (z['a'], z['b']) not in free: continue + assert z['a'] not in used and z['b'] not in used + item = dict(pivot=z['a'], a=z['a'], roles=[z['a'], z['b']], partners=[z['b']], dim=1, E_dimension=1, basis=z['basis'], cut=676559, first_frames=[z['first_a'], z['first_b']], approx_slack_delta=z['approx_slack_delta'], kind='early-cut equal-response pair (u sum 0, norm %d)' % sum(int(x)**2 for x in z['basis'][0]), round='union-early-cut') + added.append(item); used |= {z['a'], z['b']} +merged = c259 + added +S = sum(z['dim'] for z in merged); print('merged candidates', len(merged), 'added', len(added), 'entrance rank sum', S, 'mod 3 =', S % 3) +json.dump(merged, open(OUT, 'w'), indent=1); open(OUT + '.gz', 'wb').write(gzip.compress(json.dumps(merged, indent=1).encode(), mtime=0)) diff --git a/research/multicut-kernel-composition/discovery/rebind_target.py b/research/multicut-kernel-composition/discovery/rebind_target.py new file mode 100644 index 0000000000..cbfb6c69bf --- /dev/null +++ b/research/multicut-kernel-composition/discovery/rebind_target.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +"""Bind PR273's frozen target-prefix square groups to a different cohort transcript. + +The groups are identified by target ids and a close frame; only the cut record and each group's close record are +transcript-bound. After the kernel cut the two words carry the same scalar events (the kernel families only differ +in the pre-cut compensation reads and the Q/Q^-1 passes), so every post-cut non-MOVE event is aligned by its scalar +content (op, a, b, c, z), ignoring frames (descent/plateau retimings change frames only). The cut is the first record +after the last Q pass (category 28), as in PR273's word.""" +import hashlib, json, struct, sys +from pathlib import Path +if not __debug__: raise SystemExit('assertions required') +base, sel_path, cand, out = map(Path, sys.argv[1:5]) +E = struct.Struct('<6i') +sel = json.loads(sel_path.read_text()) +b = base.read_bytes(); n = cand.read_bytes() +assert hashlib.sha256(b).hexdigest() == sel['input_record_sha256'] +be = list(E.iter_unpack(b)); ne = list(E.iter_unpack(n)) +def cut_of(ev): + last = max(i for i, e in enumerate(ev) if e[0] == 1 and e[5] == 28); return last + 1 +cut_b, cut_n = cut_of(be), cut_of(ne) +assert cut_b == sel['cut_record'], (cut_b, sel['cut_record']) +def core(ev, cut): return [(i, (e[0], e[1], e[2], e[3], e[5])) for i, e in enumerate(ev) if i > cut and e[0] and not (e[0] == 1 and e[5] in (28, 29))] +cb, cn = core(be, cut_b), core(ne, cut_n) +assert [e for _, e in cb] == [e for _, e in cn], 'post-cut scalar event sequence differs' +mapping = {i: j for (i, _), (j, _) in zip(cb, cn)} +bindings = [] +for g in sel['groups']: + i = g['close_after_record']; j = mapping[i] + assert be[i][0] == 1 and (be[i][1], be[i][2], be[i][3], be[i][5]) == (ne[j][1], ne[j][2], ne[j][3], ne[j][5]) + bindings.append(dict(baseline_close=i, candidate_close=j, event=list(be[i]))) + g['close_after_record'] = j +adds = sum(e[0] == 1 for e in ne) +sel.update(baseline_input_record_sha256=sel['input_record_sha256'], baseline_cut_record=cut_b, input_record_sha256=hashlib.sha256(n).hexdigest(), + input_record_count=len(ne), cut_record=cut_n, expected_scalar_additions=adds - sel['expected_deleted_reads'] + sel['expected_inserted_additions'], + core_binding=dict(status='PASS_POST_CUT_SCALAR_EVENT_ALIGNMENT_FRAMES_IGNORED', events_compared=len(cb), cut_record=cut_n, bindings=bindings)) +out.write_text(json.dumps(sel, indent=2) + '\n') +print('bound', len(bindings), 'groups; cut', cut_b, '->', cut_n, 'post-cut events', len(cb), 'scalar additions expected', sel['expected_scalar_additions'], flush=True) diff --git a/research/multicut-kernel-composition/discovery/retime.py b/research/multicut-kernel-composition/discovery/retime.py new file mode 100644 index 0000000000..56f9fe743a --- /dev/null +++ b/research/multicut-kernel-composition/discovery/retime.py @@ -0,0 +1,46 @@ +"""Chain: PR259 word (stable_sort) -> #263 descent (baseline 80af) ; our 883 word -> rebound descent -> rebound plateaus -> native checkers.""" +import json, sys, subprocess, shutil, hashlib, time, os +from pathlib import Path +sys.dont_write_bytecode = True +S = Path(sys.argv[1]); W = S / sys.argv[3] +if W.exists(): shutil.rmtree(W) +W.mkdir(parents=True) +BIN = S / 'mc851/out-headroom/bin'; X = S / 'mc851/out-headroom/temporal/CURRENT249-EXPORT' +P263 = S / 'pr263/repo/research/multicut-kernel-condensation'; P270 = S / 'round3/r270/research/crosscut-response-pairs' +PY = S / 'build/venv/bin/python'; T0 = time.time(); tm = {} +def sha(p): return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def run(label, cmd, cwd=None): + t = time.time(); log = W / (label + '.log') + with log.open('w') as lf: r = subprocess.run([str(c) for c in cmd], stdout=lf, stderr=subprocess.STDOUT, cwd=cwd or W) + tm[label] = round(time.time() - t, 1); print(f'{label}: exit {r.returncode} ({tm[label]}s)', flush=True) + if r.returncode: print(log.read_text()[-2500:]); raise SystemExit(label + ' FAILED') +# a. baseline chain +base = W / 'base259'; (base / 'lead').mkdir(parents=True) +run('a1-pr259-transform-stable', [BIN / 'cohort-transform', X, S / 'pr259/data/candidates.json', base / 'lead']) +sel263 = json.load((P263 / 'inputs/descent-selection.json').open()) +print('pr259 stable-sort word sha', sha(base / 'lead/COHORT249-RECORDS.bin'), 'matches #263 selection input:', sha(base / 'lead/COHORT249-RECORDS.bin') == sel263['input_record_sha256'], flush=True) +run('a2-descent-on-pr259', [PY, '-B', P263 / 'code/descent_retiming.py', X, base / 'lead', P263 / 'inputs/descent-selection.json']) +plat = json.load((P270 / 'inputs/plateau-selection.json').open()) +print('post-descent pr259 sha', sha(base / 'lead/COHORT249-RECORDS.bin'), 'matches #270 plateau input:', sha(base / 'lead/COHORT249-RECORDS.bin') == plat['input_sha256'], flush=True) +# b. our word +lead = W / 'lead'; shutil.copytree(Path(sys.argv[2]) / 'lead', lead) +sys.path.insert(0, str(P270)); from rebind_descent import rebind +alignment = rebind(base / 'lead/COHORT249-PRE-DESCENT-RECORDS.bin', lead / 'COHORT249-RECORDS.bin', P263 / 'inputs/descent-selection.json', lead / 'descent-selection.json') +(lead / 'DESCENT-REBIND-EVIDENCE.json').write_text(json.dumps(alignment, indent=2) + '\n'); print('rebind descent:', alignment['status'], alignment['events_compared'], flush=True) +run('b1-descent-on-883', [PY, '-B', P263 / 'code/descent_retiming.py', X, lead, lead / 'descent-selection.json']) +print('883 post-descent sha', sha(lead / 'COHORT249-RECORDS.bin'), json.load((lead / 'DESCENT-RETIMING.json').open())['local_histogram_delta'], flush=True) +bound = W / 'bound-plateau-selection.json' +run('b2-rebind-plateaus', [PY, '-B', P270 / 'rebind_plateaus.py', base / 'lead/COHORT249-RECORDS.bin', P270 / 'inputs/plateau-selection.json', lead / 'COHORT249-RECORDS.bin', bound]) +plateau = W / 'plateau' +run('b3-plateau-retiming', [PY, '-B', P270 / 'plateau_retiming.py', X, lead, bound, plateau], cwd=P270) +run('b4-plateau-spans', [PY, '-B', P270 / 'verify_plateau_spans.py', X, plateau, plateau / 'PLATEAU-RETIMING.json'], cwd=P270) +run('b5-frame-tables', [PY, '-B', P270 / 'verify_frame_tables.py', X, plateau, '--output', plateau / 'FRAME-TABLE-AUDIT.json'], cwd=P270) +bank = W / 'bank'; bank.mkdir() +run('c1-legality', [BIN / 'cohort-legality-independent', X, plateau, plateau / 'INDEPENDENT-LEGALITY.json']) +run('c2-prefix', [BIN / 'cohort-prefix-independent', X, plateau, plateau / 'INDEPENDENT-PREFIX.json']) +run('c3-bank', [BIN / 'cohort-bank-review', X, plateau / 'COHORT249-INITIAL.json', plateau / 'COHORT249-FRAMES.json', bank, 'actual_multicut']) +run('c4-five-stage', [BIN / 'cohort-five-stage-columns', plateau / 'COHORT249-RECORDS.bin', plateau / 'COHORT-FIVE-STAGE-COLUMNS.json']) +run('c5-price', [BIN / 'cohort-price', plateau / 'COHORT249-REPLAY.json', plateau / 'COHORT-EXACT-PRICE.json']) +run('c6-finite', [BIN / 'cohort-finite-invoice', plateau / 'COHORT249-RECORDS.bin', plateau / 'COHORT-EXACT-PRICE.json', bank / 'BANK-REVIEW.json', plateau / 'COHORT-FIVE-STAGE-COLUMNS.json', plateau / 'COHORT-FINITE-INVOICE.json']) +cc = json.load((plateau / 'COHORT-EXACT-PRICE.json').open())['cohort_candidate']; rep = json.load((plateau / 'COHORT249-REPLAY.json').open()) +print(json.dumps(dict(kappa=cc['kappa'], kappa_decimal=cc['kappa_decimal'], coarse=cc['coarse'], stock=cc['stock'], calls=cc['calls'], rank_mass=cc['rank_mass'], deficit=cc['deficit'], constraints=cc['positive_constraints'], adjacent_rejected=cc['next_kappa_rejected'], word_sha=sha(plateau / 'COHORT249-RECORDS.bin'), records=rep['new_records'], plateau_delta=rep.get('plateau_histogram_delta'), timings=tm, total=round(time.time()-T0, 1)), indent=1)) diff --git a/research/multicut-kernel-composition/discovery/scan_sandwich.py b/research/multicut-kernel-composition/discovery/scan_sandwich.py new file mode 100644 index 0000000000..0709da2a7b --- /dev/null +++ b/research/multicut-kernel-composition/discovery/scan_sandwich.py @@ -0,0 +1,68 @@ +"""Scan a six-int word for cleanup-sandwich helpers (PR271 pattern) and check the frame conditions. usage: scan_sandwich.py X LEAD OUT.json""" +import json, struct, sys +from fractions import Fraction as Q +from math import lcm +from collections import Counter +from pathlib import Path +X, LEAD, OUT = map(Path, sys.argv[1:4]); H = 24; PRIME = 1000003 +frames = json.loads((X/'frames.json').read_text())['frames']; frames.update(json.loads((LEAD/'COHORT249-FRAMES.json').read_text())) +st = json.loads((X/'249-states.json').read_text()); n, v = st['n'], st['v'] +initial = {int(a): f for a, f in json.loads((LEAD/'COHORT249-INITIAL.json').read_text()).items()} +old = list(struct.iter_unpack('<6i', (LEAD/'COHORT249-RECORDS.bin').read_bytes())) +cut = next(i for i, r in enumerate(old) if r[0] == 1 and r[5] == 3) +at_cut = dict(initial) +for op, a, b, c, f, z in old[:cut]: + if op == 1: at_cut[a] = at_cut[b] = f + elif op == 2: at_cut[a], at_cut[b] = c, f + elif op == 3: del at_cut[b] +def rational_basis(rows): + basis = {} + for values in rows: + row = list(map(Q, values)) + for p, b in sorted(basis.items()): + if row[p]: row = [x - row[p]*y for x, y in zip(row, b)] + p = next((i for i, x in enumerate(row) if x), None) + if p is not None: basis[p] = [x/row[p] for x in row] + out = [] + for _, row in sorted(basis.items()): + d = lcm(*(x.denominator for x in row)); out.append([int(x*d) for x in row]) + return out +def rank_mod_prime(rows): + basis = {} + for row in rows: + row = [x % PRIME for x in row] + for p, b in sorted(basis.items()): + if row[p]: c = row[p]; row = [(x - c*y) % PRIME for x, y in zip(row, b)] + p = next((i for i, x in enumerate(row) if x), None) + if p is not None: inv = pow(row[p], -1, PRIME); basis[p] = [x*inv % PRIME for x in row] + return len(basis) +gates = {a: [] for a in range(2*v, n)} +for i in range(cut, len(old)): + r = old[i] + if r[0] == 1: + for x in (r[1], r[2]): + if 2*v <= x < n: gates[x].append((i, r)) +census = Counter(len(g) for g in gates.values()); print('cut', cut, 'helpers by post-cut gate count', sorted(census.items())[:12], flush=True) +cands = []; reasons = Counter() +for a, g in gates.items(): + if len(g) != 3: continue + (first, x), (middle, y), (last, w) = g + if not (x[2] == a and y[1] == a and w[1:3] == x[1:3] and x[1] == w[1]): reasons['not sandwich shape'] += 1; continue + t, b = x[1], y[2] + if any(r[0] == 1 and r[2] == t for r in old[first+1:last]): reasons['t control inside'] += 1; continue + B = rational_basis(frames[str(at_cut[a])]['B'] + frames[str(at_cut[b])]['B']) + if len(B) != 4: reasons['joint dim %d' % len(B)] += 1; continue + sums = [sum(u) for u in B] + gram = [[9*sum(p*q for p, q in zip(u, w2)) - su*sw for w2, sw in zip(B, sums)] for u, su in zip(B, sums)] + if rank_mod_prime(gram) != 4: reasons['degenerate'] += 1; continue + cands.append(dict(helper=a, source=b, target=t, indices=[first, middle, last], frames=[x[4], y[4], w[4]], cats=[x[5], y[5], w[5]], a_cut=at_cut[a], b_cut=at_cut[b], dims=[frames[str(at_cut[a])]['dim'], frames[str(at_cut[b])]['dim']], entrance_dim=frames[str(initial[a])]['dim'])) +print('rejections', dict(reasons), 'candidates', len(cands), flush=True) +# non-overlap: b and t of one may not be a selected helper; greedy in helper order +chosen, used = [], set() +for c in sorted(cands, key=lambda c: c['helper']): + if c['helper'] in used or c['source'] in {d['helper'] for d in chosen} or c['target'] in {d['helper'] for d in chosen}: continue + if any(c['helper'] in (d['source'], d['target']) for d in chosen): continue + chosen.append(c); used.add(c['helper']) +print('chosen', len(chosen), 'entrance dims', Counter(c['entrance_dim'] for c in chosen), 'cut dims', Counter(tuple(c['dims']) for c in chosen), 'frames', Counter(tuple(c['frames']) for c in chosen).most_common(3), 'cats', Counter(tuple(c['cats']) for c in chosen)) +print('sample', chosen[:2]) +OUT.write_text(json.dumps(dict(cut=cut, candidates=cands, chosen=chosen), indent=1) + '\n') diff --git a/research/multicut-kernel-composition/discovery/twins.py b/research/multicut-kernel-composition/discovery/twins.py new file mode 100644 index 0000000000..c4e273bd60 --- /dev/null +++ b/research/multicut-kernel-composition/discovery/twins.py @@ -0,0 +1,149 @@ +import json, sys, collections, time, pickle +from array import array +D = sys.argv[1] # data dir +OUT = sys.argv[2] +t0 = time.time() +st = json.load(open(D + '/249-states.json')) +n, v, ZERO, FULL = st['n'], st['v'], st['ZERO'], st['FULL'] +ini = [ZERO]*n; fin = [FULL]*n +for k, x in st['initial'].items(): ini[int(k)] = x +for k, x in st['final'].items(): fin[int(k)] = x +regs = st['regs']; borrowed = set(st['borrowed']); removed = set(st['removed']) +donor = set(json.load(open(D + '/249-DONOR-OWNERSHIP.json'))['donor_keys']) +rec = array('i'); rec.frombytes(open(D + '/249-records.bin', 'rb').read()) +E = len(rec)//6 +print('events', E, 'n', n, 'v', v, 'ZERO', ZERO, 'FULL', FULL, 'helpers', n-2*v) +cut = [i for i in range(E) if rec[6*i]==1 and rec[6*i+1]==3491 and rec[6*i+2]==3488 and rec[6*i+3]==-1 and rec[6*i+5]==25] +assert len(cut)==1; cut = cut[0]; print('cut', cut) +# per-helper prefix touch census +H0 = 2*v +init_reads = collections.Counter(); bad_touch = collections.Counter(); moves_before = collections.Counter() +row = [1 << s for s in range(n+1)] +kinds = collections.Counter() +for i in range(cut+1): + k,a,b,c,f,z = rec[6*i:6*i+6] + kinds[(k,z)] += 1 + if k == 1: + if c & 1: row[a] ^= row[b] + if a >= H0: bad_touch[a] += 1 + if b >= H0: + if z == 4 and f == ZERO and v <= a < 2*v: init_reads[b] += 1 + else: bad_touch[b] += 1 + elif k == 2: + row[b] = row[a] + if a >= H0: bad_touch[a] += 1 + if b >= H0: bad_touch[b] += 1 + elif k == 3: + assert row[a] == row[b] + if a >= H0: bad_touch[a] += 1 + if b >= H0: bad_touch[b] += 1 + elif k == 0: + if a >= H0: moves_before[a] += 1 +print('prefix replayed', time.time()-t0) +print('prefix event kinds (k,z) top', kinds.most_common(12)) +# responses +resp = [0]*n +for t in range(v): + r = row[v+t] >> H0 + h = H0 + while r: + low = r & -r + idx = low.bit_length()-1 + resp[H0+idx] |= 1 << t + r ^= low +contam = 0 +for s in range(n): + if v <= s < 2*v: continue + contam |= (row[s] ^ (1 << s)) >> H0 +contaminated = {H0+i for i in range(n-H0) if (contam >> i) & 1} +print('responses built', time.time()-t0, 'contaminating helpers', len(contaminated)) +# first use after cut +first = {} +for i in range(cut+1, E): + k,a,b,c,f,z = rec[6*i:6*i+6] + if k == 0: + if a >= H0 and a not in first: first[a] = (i, 'MOVE', b, c, z) + else: + fr = f if k == 1 else c + for s in (a, b): + if s >= H0 and s not in first: first[s] = (i, ('ADD','COPY','ERASE')[k-1], f if k==1 else None, fr, z) +print('first uses found', len(first)) +elig = []; reasons = collections.Counter() +for h in range(H0, n): + why = [] + if ini[h] != ZERO: why.append('ini!=ZERO') + if fin[h] != FULL: why.append('fin!=FULL') + if bad_touch[h]: why.append('touched') + if moves_before[h]: why.append('moved_before') + if h in contaminated: why.append('contaminates_nontarget') + if regs[h-H0] in borrowed: why.append('source_owner') + if regs[h-H0] in donor: why.append('donor') + if h not in first: why.append('never_used_after') + elif first[h][1] != 'MOVE': why.append('firstuse_not_MOVE') + if why: reasons[tuple(why)] += 1 + else: elig.append(h) +print('eligible helpers', len(elig)); print('ineligibility reasons', reasons.most_common(20)) +classes = collections.defaultdict(list) +for h in elig: classes[resp[h]].append(h) +sizes = collections.Counter(len(m) for m in classes.values()) +print('response classes among eligible: distinct responses', len(classes), 'size dist', sorted(sizes.items())) +print('zero-response eligible helpers', len(classes.get(0, []))) +wt = collections.Counter(bin(resp[h]).count('1') for h in elig); print('response weight dist (eligible)', sorted(wt.items())) +ir = collections.Counter(init_reads[h] for h in elig); print('initial read count dist (eligible)', sorted(ir.items())) +# helpers with a twin +twin_helpers = sum(len(m) for r, m in classes.items() if r != 0 and len(m) >= 2) +twin_pairs = sum(len(m)*(len(m)-1)//2 for r, m in classes.items() if r != 0 and len(m) >= 2) +print('eligible helpers with >=1 nonzero-response twin', twin_helpers, 'unordered twin pairs', twin_pairs) +# compare with candidates +cand = json.load(open(D + '/candidates.json'))['candidates'] +ok = 0; mism = [] +for z in cand: + a, b = z['a'], z['b'] + if resp[a] == resp[b] and a in set(elig) and b in set(elig): ok += 1 + else: mism.append((a, b, resp[a]==resp[b], a in elig, b in elig)) + if first.get(a, (0,0,0,None))[3] != z['first_a'] or first.get(b,(0,0,0,None))[3] != z['first_b']: mism.append(('frame', a, b, first.get(a), z['first_a'], first.get(b), z['first_b'])) +print('candidates confirmed twins & eligible', ok, 'mismatches', mism[:5], len(mism)) +# first-use frame dims and times +pickle.dump(dict(cut=cut, elig=elig, resp={h: resp[h] for h in range(H0, n)}, first=first, init_reads=dict(init_reads), classes={r: m for r, m in classes.items()}, ini=ini, fin=fin, contaminated=contaminated, bad_touch=dict(bad_touch), moves_before=dict(moves_before)), open(OUT, 'wb')) +# linear dependence among distinct nonzero responses of eligible helpers (F2 rank) +basis = {} +def reduce(x): + while x: + p = x.bit_length()-1 + if p in basis: x ^= basis[p] + else: return x + return 0 +distinct = [r for r in classes if r] +rank = 0; dependent = [] +for r in sorted(distinct): + y = reduce(r) + if y: basis[y.bit_length()-1] = y; rank += 1 + else: dependent.append(r) +print('distinct nonzero responses', len(distinct), 'F2 rank', rank, 'dependent responses', len(dependent)) +# close pairs: symmetric difference 1 or 2 among distinct responses of eligible helpers +# and triples R_a ^ R_b = R_c +S = set(distinct) +sd1 = 0; sd2 = 0 +dl = distinct +import itertools +# symmetric difference <=2 via bit flips +sdset = collections.Counter() +for r in dl: + bits = [i for i in range(v) if (r >> i) & 1] + # weight small, so enumerate flips of up to 2 bits among all v positions is 1760+1760^2/2 - too many; use flips of existing bits + adding 1 bit + for i in range(v): + if (r ^ (1 << i)) in S: sdset[1] += 1 + for i in range(v): + for j in bits: + if j != i and (r ^ (1 << i) ^ (1 << j)) in S: sdset[2] += 1 +print('ordered distinct-response pairs at sym diff 1:', sdset[1]//2, ' at sym diff 2 (both-in-weight-change or one-flip-one-add):', sdset[2]//2) +# triples: r_c = r_a ^ r_b with all three distinct eligible responses +tri = 0 +dl_sorted = sorted(dl) +Sset = S +for i in range(len(dl_sorted)): + for j in range(i+1, len(dl_sorted)): + x = dl_sorted[i] ^ dl_sorted[j] + if x in Sset and x != dl_sorted[i] and x != dl_sorted[j]: tri += 1 +print('XOR triples (a,b unordered, c=a^b in set), counted per pair:', tri, ' -> distinct triples', tri//3) +print('done', time.time()-t0) diff --git a/research/multicut-kernel-composition/expected-sandwich/CLEANUP-SANDWICH.json b/research/multicut-kernel-composition/expected-sandwich/CLEANUP-SANDWICH.json new file mode 100644 index 0000000000..67ae5b9124 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/CLEANUP-SANDWICH.json @@ -0,0 +1,2044 @@ +{ + "status": "PASS_CLEANUP_SANDWICH_REWRITE_FORMAL_F2_COLUMNS_AND_FRAMES", + "helpers_retired": 126, + "cut_record": 764480, + "input_sha256": "eaff3c9828ed15e1c24998331f0d3b482efc9984dd86bf5dbcefca0c76e717c6", + "output_sha256": "9556bfe3045eb23a2613a8f7b5cfc3824e321d4cbe2ec08f6993317a8bf816f7", + "formal_columns": 20107, + "omission_controls_wrong_rows": { + "omit early a += b": 126, + "omit sandwich t += b": 126 + }, + "new_connectors_checked": 378, + "new_frames": 126, + "histogram_delta": { + "1": 252, + "20": 126, + "21": -252 + }, + "endpoint_rank_mass_drop": 2520, + "rank_mass": 429938, + "paid_calls": 96352, + "scalar_additions": 728460, + "early_category": 32, + "sandwich_category": 33, + "selection_sha256": "ef16f27254d2bf5dfb5d9ad104b9772e62a6a4af903e49f26aa8c61c0aee689d", + "edits": [ + { + "helper": 10123, + "source": 3543, + "target": 10121, + "frame": 214257, + "old_indices": [ + 811775, + 816176, + 825213 + ], + "entrance_frame": 200340, + "cut_frames": [ + 126341, + 126349 + ] + }, + { + "helper": 10131, + "source": 3603, + "target": 10129, + "frame": 214258, + "old_indices": [ + 811723, + 816148, + 825217 + ], + "entrance_frame": 200510, + "cut_frames": [ + 126305, + 126313 + ] + }, + { + "helper": 10135, + "source": 3633, + "target": 10133, + "frame": 214259, + "old_indices": [ + 811697, + 816134, + 825219 + ], + "entrance_frame": 200511, + "cut_frames": [ + 126287, + 126295 + ] + }, + { + "helper": 10151, + "source": 3753, + "target": 10149, + "frame": 214260, + "old_indices": [ + 811581, + 816078, + 825227 + ], + "entrance_frame": 200341, + "cut_frames": [ + 126215, + 126223 + ] + }, + { + "helper": 10155, + "source": 3783, + "target": 10153, + "frame": 214261, + "old_indices": [ + 811551, + 816064, + 825229 + ], + "entrance_frame": 200342, + "cut_frames": [ + 126197, + 126205 + ] + }, + { + "helper": 10159, + "source": 3813, + "target": 10157, + "frame": 214262, + "old_indices": [ + 811521, + 816050, + 825231 + ], + "entrance_frame": 200344, + "cut_frames": [ + 126179, + 126187 + ] + }, + { + "helper": 10163, + "source": 3843, + "target": 10161, + "frame": 214263, + "old_indices": [ + 811489, + 816036, + 825233 + ], + "entrance_frame": 200345, + "cut_frames": [ + 126161, + 126169 + ] + }, + { + "helper": 10171, + "source": 3903, + "target": 10169, + "frame": 214264, + "old_indices": [ + 811439, + 816008, + 825237 + ], + "entrance_frame": 200347, + "cut_frames": [ + 126125, + 126133 + ] + }, + { + "helper": 10175, + "source": 3933, + "target": 10173, + "frame": 214265, + "old_indices": [ + 811413, + 815994, + 825239 + ], + "entrance_frame": 200524, + "cut_frames": [ + 126107, + 126115 + ] + }, + { + "helper": 10179, + "source": 3963, + "target": 10177, + "frame": 214266, + "old_indices": [ + 811383, + 815980, + 825241 + ], + "entrance_frame": 200525, + "cut_frames": [ + 126089, + 126097 + ] + }, + { + "helper": 10183, + "source": 3993, + "target": 10181, + "frame": 214267, + "old_indices": [ + 811351, + 815966, + 825243 + ], + "entrance_frame": 200527, + "cut_frames": [ + 126071, + 126079 + ] + }, + { + "helper": 10191, + "source": 4053, + "target": 10189, + "frame": 214268, + "old_indices": [ + 811281, + 815938, + 825247 + ], + "entrance_frame": 200530, + "cut_frames": [ + 126035, + 126043 + ] + }, + { + "helper": 10195, + "source": 4083, + "target": 10193, + "frame": 214269, + "old_indices": [ + 811247, + 815924, + 825249 + ], + "entrance_frame": 200350, + "cut_frames": [ + 126017, + 126025 + ] + }, + { + "helper": 10199, + "source": 4113, + "target": 10197, + "frame": 214270, + "old_indices": [ + 811209, + 815910, + 825251 + ], + "entrance_frame": 200533, + "cut_frames": [ + 125999, + 126007 + ] + }, + { + "helper": 10215, + "source": 4233, + "target": 10213, + "frame": 214271, + "old_indices": [ + 811067, + 815854, + 825259 + ], + "entrance_frame": 200355, + "cut_frames": [ + 125927, + 125935 + ] + }, + { + "helper": 10231, + "source": 4353, + "target": 10229, + "frame": 214272, + "old_indices": [ + 810923, + 815798, + 825267 + ], + "entrance_frame": 200543, + "cut_frames": [ + 125855, + 125863 + ] + }, + { + "helper": 10243, + "source": 4443, + "target": 10241, + "frame": 214273, + "old_indices": [ + 810815, + 815756, + 825273 + ], + "entrance_frame": 200322, + "cut_frames": [ + 125801, + 125809 + ] + }, + { + "helper": 10255, + "source": 4533, + "target": 10253, + "frame": 214274, + "old_indices": [ + 810709, + 815714, + 825279 + ], + "entrance_frame": 200323, + "cut_frames": [ + 125747, + 125755 + ] + }, + { + "helper": 10259, + "source": 4563, + "target": 10257, + "frame": 214275, + "old_indices": [ + 810673, + 815700, + 825281 + ], + "entrance_frame": 200324, + "cut_frames": [ + 125729, + 125737 + ] + }, + { + "helper": 10263, + "source": 4593, + "target": 10261, + "frame": 214276, + "old_indices": [ + 810637, + 815686, + 825283 + ], + "entrance_frame": 200325, + "cut_frames": [ + 125711, + 125719 + ] + }, + { + "helper": 10267, + "source": 4623, + "target": 10265, + "frame": 214277, + "old_indices": [ + 810603, + 815672, + 825285 + ], + "entrance_frame": 200327, + "cut_frames": [ + 125693, + 125701 + ] + }, + { + "helper": 10271, + "source": 4653, + "target": 10269, + "frame": 214278, + "old_indices": [ + 810567, + 815658, + 825287 + ], + "entrance_frame": 200556, + "cut_frames": [ + 125675, + 125683 + ] + }, + { + "helper": 10283, + "source": 4743, + "target": 10281, + "frame": 214279, + "old_indices": [ + 810455, + 815616, + 825293 + ], + "entrance_frame": 200560, + "cut_frames": [ + 125621, + 125629 + ] + }, + { + "helper": 10291, + "source": 4803, + "target": 10289, + "frame": 214280, + "old_indices": [ + 810381, + 815588, + 825297 + ], + "entrance_frame": 200321, + "cut_frames": [ + 125585, + 125593 + ] + }, + { + "helper": 10299, + "source": 4863, + "target": 10297, + "frame": 214281, + "old_indices": [ + 810311, + 815560, + 825301 + ], + "entrance_frame": 200566, + "cut_frames": [ + 125549, + 125557 + ] + }, + { + "helper": 10303, + "source": 4893, + "target": 10301, + "frame": 214282, + "old_indices": [ + 810273, + 815546, + 825303 + ], + "entrance_frame": 200567, + "cut_frames": [ + 125531, + 125539 + ] + }, + { + "helper": 10307, + "source": 4923, + "target": 10305, + "frame": 214283, + "old_indices": [ + 810237, + 815532, + 825305 + ], + "entrance_frame": 200569, + "cut_frames": [ + 125513, + 125521 + ] + }, + { + "helper": 10311, + "source": 4953, + "target": 10309, + "frame": 214284, + "old_indices": [ + 810203, + 815518, + 825307 + ], + "entrance_frame": 200571, + "cut_frames": [ + 125495, + 125503 + ] + }, + { + "helper": 10319, + "source": 5013, + "target": 10317, + "frame": 214285, + "old_indices": [ + 810131, + 815490, + 825311 + ], + "entrance_frame": 200575, + "cut_frames": [ + 125459, + 125467 + ] + }, + { + "helper": 10323, + "source": 5043, + "target": 10321, + "frame": 214286, + "old_indices": [ + 810095, + 815476, + 825313 + ], + "entrance_frame": 200577, + "cut_frames": [ + 125441, + 125449 + ] + }, + { + "helper": 10327, + "source": 5073, + "target": 10325, + "frame": 214287, + "old_indices": [ + 810059, + 815462, + 825315 + ], + "entrance_frame": 200334, + "cut_frames": [ + 125423, + 125431 + ] + }, + { + "helper": 10339, + "source": 5163, + "target": 10337, + "frame": 214288, + "old_indices": [ + 809955, + 815420, + 825321 + ], + "entrance_frame": 200582, + "cut_frames": [ + 125369, + 125377 + ] + }, + { + "helper": 10343, + "source": 5193, + "target": 10341, + "frame": 214289, + "old_indices": [ + 809922, + 815406, + 825323 + ], + "entrance_frame": 200336, + "cut_frames": [ + 143607, + 125359 + ] + }, + { + "helper": 10351, + "source": 5253, + "target": 10349, + "frame": 214290, + "old_indices": [ + 809865, + 815378, + 825327 + ], + "entrance_frame": 200587, + "cut_frames": [ + 125315, + 125323 + ] + }, + { + "helper": 10355, + "source": 5283, + "target": 10353, + "frame": 214291, + "old_indices": [ + 809833, + 815364, + 825329 + ], + "entrance_frame": 200588, + "cut_frames": [ + 125297, + 125305 + ] + }, + { + "helper": 10359, + "source": 5313, + "target": 10357, + "frame": 214292, + "old_indices": [ + 809801, + 815350, + 825331 + ], + "entrance_frame": 200338, + "cut_frames": [ + 125279, + 125287 + ] + }, + { + "helper": 10371, + "source": 5403, + "target": 10369, + "frame": 214293, + "old_indices": [ + 809708, + 815308, + 825337 + ], + "entrance_frame": 200594, + "cut_frames": [ + 125225, + 125233 + ] + }, + { + "helper": 10375, + "source": 5433, + "target": 10373, + "frame": 214294, + "old_indices": [ + 809680, + 815294, + 825339 + ], + "entrance_frame": 200369, + "cut_frames": [ + 125207, + 125215 + ] + }, + { + "helper": 10383, + "source": 5493, + "target": 10381, + "frame": 214295, + "old_indices": [ + 809615, + 815266, + 825343 + ], + "entrance_frame": 200392, + "cut_frames": [ + 125171, + 125179 + ] + }, + { + "helper": 10387, + "source": 5523, + "target": 10385, + "frame": 214296, + "old_indices": [ + 809581, + 815252, + 825345 + ], + "entrance_frame": 200600, + "cut_frames": [ + 125153, + 125161 + ] + }, + { + "helper": 10407, + "source": 5673, + "target": 10405, + "frame": 214297, + "old_indices": [ + 809412, + 815182, + 825355 + ], + "entrance_frame": 200387, + "cut_frames": [ + 125063, + 125071 + ] + }, + { + "helper": 10415, + "source": 5733, + "target": 10413, + "frame": 214298, + "old_indices": [ + 809343, + 815154, + 825359 + ], + "entrance_frame": 200608, + "cut_frames": [ + 125027, + 125035 + ] + }, + { + "helper": 10427, + "source": 5823, + "target": 10425, + "frame": 214299, + "old_indices": [ + 809237, + 815112, + 825365 + ], + "entrance_frame": 200384, + "cut_frames": [ + 124973, + 124981 + ] + }, + { + "helper": 10439, + "source": 5913, + "target": 10437, + "frame": 214300, + "old_indices": [ + 809133, + 815070, + 825371 + ], + "entrance_frame": 200382, + "cut_frames": [ + 124919, + 124927 + ] + }, + { + "helper": 10443, + "source": 5943, + "target": 10441, + "frame": 214301, + "old_indices": [ + 809097, + 815056, + 825373 + ], + "entrance_frame": 200617, + "cut_frames": [ + 124901, + 124909 + ] + }, + { + "helper": 10447, + "source": 5973, + "target": 10445, + "frame": 214302, + "old_indices": [ + 809063, + 815042, + 825375 + ], + "entrance_frame": 200618, + "cut_frames": [ + 124883, + 124891 + ] + }, + { + "helper": 10459, + "source": 6063, + "target": 10457, + "frame": 214303, + "old_indices": [ + 808956, + 815000, + 825381 + ], + "entrance_frame": 200624, + "cut_frames": [ + 124829, + 124837 + ] + }, + { + "helper": 10463, + "source": 6093, + "target": 10461, + "frame": 214304, + "old_indices": [ + 808919, + 814986, + 825383 + ], + "entrance_frame": 200626, + "cut_frames": [ + 124811, + 124819 + ] + }, + { + "helper": 10467, + "source": 6123, + "target": 10465, + "frame": 214305, + "old_indices": [ + 808883, + 814972, + 825385 + ], + "entrance_frame": 200628, + "cut_frames": [ + 124793, + 124801 + ] + }, + { + "helper": 10471, + "source": 6153, + "target": 10469, + "frame": 214306, + "old_indices": [ + 808845, + 814958, + 825387 + ], + "entrance_frame": 200360, + "cut_frames": [ + 124775, + 124783 + ] + }, + { + "helper": 10479, + "source": 6213, + "target": 10477, + "frame": 214307, + "old_indices": [ + 808778, + 814930, + 825391 + ], + "entrance_frame": 200633, + "cut_frames": [ + 124739, + 124747 + ] + }, + { + "helper": 10491, + "source": 6303, + "target": 10489, + "frame": 214308, + "old_indices": [ + 808672, + 814888, + 825397 + ], + "entrance_frame": 200362, + "cut_frames": [ + 124685, + 124693 + ] + }, + { + "helper": 10495, + "source": 6333, + "target": 10493, + "frame": 214309, + "old_indices": [ + 808638, + 814874, + 825399 + ], + "entrance_frame": 200363, + "cut_frames": [ + 124667, + 124675 + ] + }, + { + "helper": 10511, + "source": 6453, + "target": 10509, + "frame": 214310, + "old_indices": [ + 808502, + 814818, + 825407 + ], + "entrance_frame": 200644, + "cut_frames": [ + 124595, + 124603 + ] + }, + { + "helper": 10519, + "source": 6513, + "target": 10517, + "frame": 214311, + "old_indices": [ + 808440, + 814790, + 825411 + ], + "entrance_frame": 200366, + "cut_frames": [ + 124559, + 124567 + ] + }, + { + "helper": 10527, + "source": 6573, + "target": 10525, + "frame": 214312, + "old_indices": [ + 808377, + 814762, + 825415 + ], + "entrance_frame": 200651, + "cut_frames": [ + 124523, + 124531 + ] + }, + { + "helper": 10531, + "source": 6603, + "target": 10529, + "frame": 214313, + "old_indices": [ + 808345, + 814748, + 825417 + ], + "entrance_frame": 200653, + "cut_frames": [ + 124505, + 124513 + ] + }, + { + "helper": 10543, + "source": 6693, + "target": 10541, + "frame": 214314, + "old_indices": [ + 808241, + 814706, + 825423 + ], + "entrance_frame": 200367, + "cut_frames": [ + 124451, + 124459 + ] + }, + { + "helper": 10555, + "source": 6783, + "target": 10553, + "frame": 214315, + "old_indices": [ + 808127, + 814664, + 825429 + ], + "entrance_frame": 200663, + "cut_frames": [ + 124397, + 124405 + ] + }, + { + "helper": 10559, + "source": 6813, + "target": 10557, + "frame": 214316, + "old_indices": [ + 808091, + 814650, + 825431 + ], + "entrance_frame": 200357, + "cut_frames": [ + 124379, + 124387 + ] + }, + { + "helper": 10575, + "source": 6933, + "target": 10573, + "frame": 214317, + "old_indices": [ + 807948, + 814594, + 825439 + ], + "entrance_frame": 200371, + "cut_frames": [ + 124307, + 124315 + ] + }, + { + "helper": 10583, + "source": 6993, + "target": 10581, + "frame": 214318, + "old_indices": [ + 807875, + 814566, + 825443 + ], + "entrance_frame": 200674, + "cut_frames": [ + 124271, + 124279 + ] + }, + { + "helper": 10595, + "source": 7083, + "target": 10593, + "frame": 214319, + "old_indices": [ + 807767, + 814524, + 825449 + ], + "entrance_frame": 200679, + "cut_frames": [ + 124217, + 124225 + ] + }, + { + "helper": 10603, + "source": 7143, + "target": 10601, + "frame": 214320, + "old_indices": [ + 807694, + 814496, + 825453 + ], + "entrance_frame": 200683, + "cut_frames": [ + 124181, + 124189 + ] + }, + { + "helper": 10611, + "source": 7203, + "target": 10609, + "frame": 214321, + "old_indices": [ + 807618, + 814468, + 825457 + ], + "entrance_frame": 200687, + "cut_frames": [ + 124145, + 124153 + ] + }, + { + "helper": 10619, + "source": 7263, + "target": 10617, + "frame": 214322, + "old_indices": [ + 807546, + 814440, + 825461 + ], + "entrance_frame": 200373, + "cut_frames": [ + 124109, + 124117 + ] + }, + { + "helper": 10623, + "source": 7293, + "target": 10621, + "frame": 214323, + "old_indices": [ + 807510, + 814426, + 825463 + ], + "entrance_frame": 200374, + "cut_frames": [ + 124091, + 124099 + ] + }, + { + "helper": 10643, + "source": 7443, + "target": 10641, + "frame": 214324, + "old_indices": [ + 807319, + 814356, + 825473 + ], + "entrance_frame": 200375, + "cut_frames": [ + 124001, + 124009 + ] + }, + { + "helper": 10647, + "source": 7473, + "target": 10645, + "frame": 214325, + "old_indices": [ + 807284, + 814342, + 825475 + ], + "entrance_frame": 200701, + "cut_frames": [ + 123983, + 123991 + ] + }, + { + "helper": 10651, + "source": 7503, + "target": 10649, + "frame": 214326, + "old_indices": [ + 807248, + 814328, + 825477 + ], + "entrance_frame": 200377, + "cut_frames": [ + 123965, + 123973 + ] + }, + { + "helper": 10659, + "source": 7563, + "target": 10657, + "frame": 214327, + "old_indices": [ + 807180, + 814300, + 825481 + ], + "entrance_frame": 200379, + "cut_frames": [ + 123929, + 123937 + ] + }, + { + "helper": 10663, + "source": 7593, + "target": 10661, + "frame": 214328, + "old_indices": [ + 807146, + 814286, + 825483 + ], + "entrance_frame": 200706, + "cut_frames": [ + 123911, + 123919 + ] + }, + { + "helper": 10667, + "source": 7623, + "target": 10665, + "frame": 214329, + "old_indices": [ + 807113, + 814272, + 825485 + ], + "entrance_frame": 200380, + "cut_frames": [ + 123893, + 123901 + ] + }, + { + "helper": 10671, + "source": 7653, + "target": 10669, + "frame": 214330, + "old_indices": [ + 807083, + 814258, + 825487 + ], + "entrance_frame": 200295, + "cut_frames": [ + 123875, + 123883 + ] + }, + { + "helper": 10675, + "source": 7683, + "target": 10673, + "frame": 214331, + "old_indices": [ + 807053, + 814244, + 825489 + ], + "entrance_frame": 200293, + "cut_frames": [ + 123857, + 123865 + ] + }, + { + "helper": 10679, + "source": 7713, + "target": 10677, + "frame": 214332, + "old_indices": [ + 807017, + 814230, + 825491 + ], + "entrance_frame": 200707, + "cut_frames": [ + 123839, + 123847 + ] + }, + { + "helper": 10687, + "source": 7773, + "target": 10685, + "frame": 214333, + "old_indices": [ + 806949, + 814202, + 825495 + ], + "entrance_frame": 200290, + "cut_frames": [ + 123803, + 123811 + ] + }, + { + "helper": 10691, + "source": 7803, + "target": 10689, + "frame": 214334, + "old_indices": [ + 806913, + 814188, + 825497 + ], + "entrance_frame": 200289, + "cut_frames": [ + 123785, + 123793 + ] + }, + { + "helper": 10695, + "source": 7833, + "target": 10693, + "frame": 214335, + "old_indices": [ + 806877, + 814174, + 825499 + ], + "entrance_frame": 200712, + "cut_frames": [ + 123767, + 123775 + ] + }, + { + "helper": 10703, + "source": 7893, + "target": 10701, + "frame": 214336, + "old_indices": [ + 806807, + 814146, + 825503 + ], + "entrance_frame": 200715, + "cut_frames": [ + 123731, + 123739 + ] + }, + { + "helper": 10707, + "source": 7923, + "target": 10705, + "frame": 214337, + "old_indices": [ + 806772, + 814132, + 825505 + ], + "entrance_frame": 200716, + "cut_frames": [ + 123713, + 123721 + ] + }, + { + "helper": 10715, + "source": 7983, + "target": 10713, + "frame": 214338, + "old_indices": [ + 806699, + 814104, + 825509 + ], + "entrance_frame": 200719, + "cut_frames": [ + 123677, + 123685 + ] + }, + { + "helper": 10723, + "source": 8043, + "target": 10721, + "frame": 214339, + "old_indices": [ + 806625, + 814076, + 825513 + ], + "entrance_frame": 200272, + "cut_frames": [ + 123641, + 123649 + ] + }, + { + "helper": 10727, + "source": 8073, + "target": 10725, + "frame": 214340, + "old_indices": [ + 806588, + 814062, + 825515 + ], + "entrance_frame": 200723, + "cut_frames": [ + 123623, + 123631 + ] + }, + { + "helper": 10735, + "source": 8133, + "target": 10733, + "frame": 214341, + "old_indices": [ + 806519, + 814034, + 825519 + ], + "entrance_frame": 200726, + "cut_frames": [ + 123587, + 123595 + ] + }, + { + "helper": 10739, + "source": 8163, + "target": 10737, + "frame": 214342, + "old_indices": [ + 806481, + 814020, + 825521 + ], + "entrance_frame": 200274, + "cut_frames": [ + 123569, + 123577 + ] + }, + { + "helper": 10743, + "source": 8193, + "target": 10741, + "frame": 214343, + "old_indices": [ + 806446, + 814006, + 825523 + ], + "entrance_frame": 200275, + "cut_frames": [ + 123551, + 123559 + ] + }, + { + "helper": 10747, + "source": 8223, + "target": 10745, + "frame": 214344, + "old_indices": [ + 806413, + 813992, + 825525 + ], + "entrance_frame": 200730, + "cut_frames": [ + 123533, + 123541 + ] + }, + { + "helper": 10751, + "source": 8253, + "target": 10749, + "frame": 214345, + "old_indices": [ + 806377, + 813978, + 825527 + ], + "entrance_frame": 200277, + "cut_frames": [ + 123515, + 123523 + ] + }, + { + "helper": 10759, + "source": 8313, + "target": 10757, + "frame": 214346, + "old_indices": [ + 806309, + 813950, + 825531 + ], + "entrance_frame": 200734, + "cut_frames": [ + 123479, + 123487 + ] + }, + { + "helper": 10763, + "source": 8343, + "target": 10761, + "frame": 214347, + "old_indices": [ + 806275, + 813936, + 825533 + ], + "entrance_frame": 200736, + "cut_frames": [ + 123461, + 123469 + ] + }, + { + "helper": 10767, + "source": 8373, + "target": 10765, + "frame": 214348, + "old_indices": [ + 806243, + 813922, + 825535 + ], + "entrance_frame": 200738, + "cut_frames": [ + 123443, + 123451 + ] + }, + { + "helper": 10771, + "source": 8403, + "target": 10769, + "frame": 214349, + "old_indices": [ + 806207, + 813908, + 825537 + ], + "entrance_frame": 200740, + "cut_frames": [ + 123425, + 123433 + ] + }, + { + "helper": 10779, + "source": 8463, + "target": 10777, + "frame": 214350, + "old_indices": [ + 806137, + 813880, + 825541 + ], + "entrance_frame": 200744, + "cut_frames": [ + 123389, + 123397 + ] + }, + { + "helper": 10783, + "source": 8493, + "target": 10781, + "frame": 214351, + "old_indices": [ + 806101, + 813866, + 825543 + ], + "entrance_frame": 200745, + "cut_frames": [ + 123371, + 123379 + ] + }, + { + "helper": 10791, + "source": 8553, + "target": 10789, + "frame": 214352, + "old_indices": [ + 806033, + 813838, + 825547 + ], + "entrance_frame": 200749, + "cut_frames": [ + 123335, + 123343 + ] + }, + { + "helper": 10795, + "source": 8583, + "target": 10793, + "frame": 214353, + "old_indices": [ + 805994, + 813824, + 825549 + ], + "entrance_frame": 200751, + "cut_frames": [ + 123317, + 123325 + ] + }, + { + "helper": 10803, + "source": 8643, + "target": 10801, + "frame": 214354, + "old_indices": [ + 805919, + 813796, + 825553 + ], + "entrance_frame": 200280, + "cut_frames": [ + 123281, + 123289 + ] + }, + { + "helper": 10807, + "source": 8673, + "target": 10805, + "frame": 214355, + "old_indices": [ + 805884, + 813782, + 825555 + ], + "entrance_frame": 200755, + "cut_frames": [ + 123263, + 123271 + ] + }, + { + "helper": 10811, + "source": 8703, + "target": 10809, + "frame": 214356, + "old_indices": [ + 805847, + 813768, + 825557 + ], + "entrance_frame": 200282, + "cut_frames": [ + 123245, + 123253 + ] + }, + { + "helper": 10815, + "source": 8733, + "target": 10813, + "frame": 214357, + "old_indices": [ + 805812, + 813754, + 825559 + ], + "entrance_frame": 200284, + "cut_frames": [ + 123227, + 123235 + ] + }, + { + "helper": 10823, + "source": 8793, + "target": 10821, + "frame": 214358, + "old_indices": [ + 805738, + 813726, + 825563 + ], + "entrance_frame": 200309, + "cut_frames": [ + 123191, + 123199 + ] + }, + { + "helper": 10831, + "source": 8853, + "target": 10829, + "frame": 214359, + "old_indices": [ + 805672, + 813698, + 825567 + ], + "entrance_frame": 200763, + "cut_frames": [ + 123155, + 123163 + ] + }, + { + "helper": 10835, + "source": 8883, + "target": 10833, + "frame": 214360, + "old_indices": [ + 805637, + 813684, + 825569 + ], + "entrance_frame": 200320, + "cut_frames": [ + 123137, + 123145 + ] + }, + { + "helper": 10843, + "source": 8943, + "target": 10841, + "frame": 214361, + "old_indices": [ + 805566, + 813656, + 825573 + ], + "entrance_frame": 200767, + "cut_frames": [ + 123101, + 123109 + ] + }, + { + "helper": 10851, + "source": 9003, + "target": 10849, + "frame": 214362, + "old_indices": [ + 805494, + 813628, + 825577 + ], + "entrance_frame": 200771, + "cut_frames": [ + 123065, + 123073 + ] + }, + { + "helper": 10855, + "source": 9033, + "target": 10853, + "frame": 214363, + "old_indices": [ + 805455, + 813614, + 825579 + ], + "entrance_frame": 200773, + "cut_frames": [ + 123047, + 123055 + ] + }, + { + "helper": 10863, + "source": 9093, + "target": 10861, + "frame": 214364, + "old_indices": [ + 805380, + 813586, + 825583 + ], + "entrance_frame": 200317, + "cut_frames": [ + 143703, + 123019 + ] + }, + { + "helper": 10871, + "source": 9153, + "target": 10869, + "frame": 214365, + "old_indices": [ + 805300, + 813558, + 825587 + ], + "entrance_frame": 200316, + "cut_frames": [ + 122975, + 122983 + ] + }, + { + "helper": 10875, + "source": 9183, + "target": 10873, + "frame": 214366, + "old_indices": [ + 805264, + 813544, + 825589 + ], + "entrance_frame": 200780, + "cut_frames": [ + 122957, + 122965 + ] + }, + { + "helper": 10883, + "source": 9243, + "target": 10881, + "frame": 214367, + "old_indices": [ + 805187, + 813516, + 825593 + ], + "entrance_frame": 200784, + "cut_frames": [ + 122921, + 122929 + ] + }, + { + "helper": 10887, + "source": 9273, + "target": 10885, + "frame": 214368, + "old_indices": [ + 805150, + 813502, + 825595 + ], + "entrance_frame": 200786, + "cut_frames": [ + 122903, + 122911 + ] + }, + { + "helper": 10891, + "source": 9303, + "target": 10889, + "frame": 214369, + "old_indices": [ + 805116, + 813488, + 825597 + ], + "entrance_frame": 200314, + "cut_frames": [ + 122885, + 122893 + ] + }, + { + "helper": 10895, + "source": 9333, + "target": 10893, + "frame": 214370, + "old_indices": [ + 805081, + 813474, + 825599 + ], + "entrance_frame": 200313, + "cut_frames": [ + 122867, + 122875 + ] + }, + { + "helper": 10899, + "source": 9363, + "target": 10897, + "frame": 214371, + "old_indices": [ + 805044, + 813460, + 825601 + ], + "entrance_frame": 200312, + "cut_frames": [ + 122849, + 122857 + ] + }, + { + "helper": 10911, + "source": 9453, + "target": 10909, + "frame": 214372, + "old_indices": [ + 804934, + 813418, + 825607 + ], + "entrance_frame": 200793, + "cut_frames": [ + 122795, + 122803 + ] + }, + { + "helper": 10915, + "source": 9483, + "target": 10913, + "frame": 214373, + "old_indices": [ + 804901, + 813404, + 825609 + ], + "entrance_frame": 200795, + "cut_frames": [ + 122777, + 122785 + ] + }, + { + "helper": 10919, + "source": 9513, + "target": 10917, + "frame": 214374, + "old_indices": [ + 804869, + 813390, + 825611 + ], + "entrance_frame": 200310, + "cut_frames": [ + 122759, + 122767 + ] + }, + { + "helper": 10927, + "source": 9573, + "target": 10925, + "frame": 214375, + "old_indices": [ + 804791, + 813362, + 825615 + ], + "entrance_frame": 200799, + "cut_frames": [ + 122723, + 122731 + ] + }, + { + "helper": 10943, + "source": 9693, + "target": 10941, + "frame": 214376, + "old_indices": [ + 804646, + 813306, + 825623 + ], + "entrance_frame": 200306, + "cut_frames": [ + 122651, + 122659 + ] + }, + { + "helper": 10955, + "source": 9783, + "target": 10953, + "frame": 214377, + "old_indices": [ + 804545, + 813264, + 825629 + ], + "entrance_frame": 200303, + "cut_frames": [ + 122597, + 122605 + ] + }, + { + "helper": 10959, + "source": 9813, + "target": 10957, + "frame": 214378, + "old_indices": [ + 804513, + 813250, + 825631 + ], + "entrance_frame": 200808, + "cut_frames": [ + 122579, + 122587 + ] + }, + { + "helper": 10963, + "source": 9843, + "target": 10961, + "frame": 214379, + "old_indices": [ + 804477, + 813236, + 825633 + ], + "entrance_frame": 200301, + "cut_frames": [ + 122561, + 122569 + ] + }, + { + "helper": 10967, + "source": 9873, + "target": 10965, + "frame": 214380, + "old_indices": [ + 804441, + 813222, + 825635 + ], + "entrance_frame": 200811, + "cut_frames": [ + 122543, + 122551 + ] + }, + { + "helper": 10971, + "source": 9903, + "target": 10969, + "frame": 214381, + "old_indices": [ + 804405, + 813208, + 825637 + ], + "entrance_frame": 200300, + "cut_frames": [ + 122525, + 122533 + ] + }, + { + "helper": 10987, + "source": 10023, + "target": 10985, + "frame": 214382, + "old_indices": [ + 804268, + 813152, + 825645 + ], + "entrance_frame": 200818, + "cut_frames": [ + 122453, + 122461 + ] + } + ] +} diff --git a/research/multicut-kernel-composition/expected-sandwich/COHORT-EXACT-PRICE.json b/research/multicut-kernel-composition/expected-sandwich/COHORT-EXACT-PRICE.json new file mode 100644 index 0000000000..89d4cbba23 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/COHORT-EXACT-PRICE.json @@ -0,0 +1,99 @@ +{ + "status": "PASS_SANDWICH_PRICE_SAME_ENGINE_STOCK_FROM_RETILED_BANKS", + "pre_sandwich_reproduced": { + "bootstrap_chain": [ + "384599/10000000000", + "712032216292737875319682616334311/1000000000000000000000000000000000000", + "712512144979113939283526852907464342662615075472387/1000000000000000000000000000000000000000000000000000000", + "712512486934295937219336833887930744552113678895670560170594384155279/1000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "calls": 3961680, + "coarse": "712512487178117/1000000000000000000", + "coarse_decimal": 0.000712512487178117, + "deficit": 35200, + "histogram": { + "1": 1721440, + "10": 30680, + "11": 17680, + "12": 60360, + "13": 23560, + "14": 42680, + "15": 9640, + "16": 40000, + "17": 18720, + "18": 19200, + "19": 12920, + "2": 756160, + "20": 46320, + "21": 231920, + "22": 53760, + "23": 28160, + "3": 387000, + "4": 149440, + "46": 28160, + "5": 93720, + "50": 28160, + "6": 63040, + "7": 48080, + "8": 25640, + "9": 25240 + }, + "kappa": "712005174354669/1000000000000000000", + "kappa_decimal": 0.000712005174354669, + "moment_upper": "269599466671506397639788011780538617499682424117904849650337015167872657265238860693/269599466671506397946670150870196306736371444225405724811036102492160000000000000000", + "next_coarse_moment_lower": "269599466671506398280874426254636431178404393755656487247075432124227039215458038763/269599466671506397946670150870196306736371444225405724811036102492160000000000000000", + "next_kappa_rejected": 1, + "ordinary_bit": "712512486934295937219336833887930744552113678895670560170594384155279/1000000000000000000000000000000000000000000000000000000000000000000000000", + "positive_constraints": 47, + "rank_mass": 20762000, + "stock": 173310 + }, + "cohort_candidate": { + "bootstrap_chain": [ + "384599/10000000000", + "714053863142185421660912917149879/1000000000000000000000000000000000000", + "714536599988783480482476691917475953432506608432581/1000000000000000000000000000000000000000000000000000000", + "714536944922095169049602740507068552094394088510587975398805350285359/1000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "calls": 3966720, + "coarse": "714536945168739/1000000000000000000", + "coarse_decimal": 0.000714536945168739, + "deficit": 35200, + "histogram": { + "1": 1731520, + "10": 30680, + "11": 17680, + "12": 60360, + "13": 23560, + "14": 42680, + "15": 9640, + "16": 40000, + "17": 18720, + "18": 19200, + "19": 12920, + "2": 756160, + "20": 51360, + "21": 221840, + "22": 53760, + "23": 28160, + "3": 387000, + "4": 149440, + "46": 28160, + "5": 93720, + "50": 28160, + "6": 63040, + "7": 48080, + "8": 25640, + "9": 25240 + }, + "kappa": "142805349285993/200000000000000000", + "kappa_decimal": 0.000714026746429965, + "moment_upper": "134799733335753198656062899372059964900586471780536457779433568519665948658909916307/134799733335753198973335075435098153368185722112702862405518051246080000000000000000", + "next_coarse_moment_lower": "53919893334301279590902552940578103825789155746800232240588130250714201195886279809/53919893334301279589334030174039261347274288845081144962207220498432000000000000000", + "next_kappa_rejected": 1, + "ordinary_bit": "714536944922095169049602740507068552094394088510587975398805350285359/1000000000000000000000000000000000000000000000000000000000000000000000000", + "positive_constraints": 47, + "rank_mass": 20661200, + "stock": 172470 + } +} diff --git a/research/multicut-kernel-composition/expected-sandwich/COHORT-FINITE-INVOICE.json b/research/multicut-kernel-composition/expected-sandwich/COHORT-FINITE-INVOICE.json new file mode 100644 index 0000000000..a6fa4235f4 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/COHORT-FINITE-INVOICE.json @@ -0,0 +1,72 @@ +{ + "external_complex_row_coefficient": 20161, + "extra_selector_calls": "626935451600", + "full_counted_primitive_coefficient": "62727288085005201", + "global_unit_expanded_additions": "146642400", + "global_weighted_additions": "146114400", + "internal_row_coefficient": 14401, + "linear_moment_slack": "5371093722109/3158020019531250", + "literal_deficit": 176000, + "literal_histogram": { + "1": "8657600", + "10": "153400", + "11": "88400", + "12": "301800", + "13": "117800", + "14": "213400", + "15": "48200", + "16": "200000", + "17": "93600", + "18": "96000", + "19": "64600", + "2": "3780800", + "20": "256800", + "21": "1109200", + "22": "268800", + "23": "140800", + "3": "1935000", + "4": "747200", + "46": "140800", + "5": "468600", + "50": "140800", + "6": "315200", + "7": "240400", + "8": "128200", + "9": "126200" + }, + "literal_rank_mass": "103306000", + "literal_stock": 862350, + "new_chart_factor_max": 286, + "normalized_stock": 172470, + "normalizer_factor_bound": 787, + "ordinary_cutoffs": [ + { + "counted_coefficient_cutoff_log2": "154262633700570", + "general_rule": "For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta)).", + "minimum_gap": "483082026553578339087082850121/1000000000000000000000000000000000000", + "stage": 1 + }, + { + "counted_coefficient_cutoff_log2": "302142183821944412222", + "general_rule": "For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta)).", + "minimum_gap": "345179955519517523308082524046567493391567419/1000000000000000000000000000000000000000000000000000000", + "stage": 2 + }, + { + "counted_coefficient_cutoff_log2": "591782319896672068211435273", + "general_rule": "For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta)).", + "minimum_gap": "246643830950397259492931447905605911489412024601194649714641/1000000000000000000000000000000000000000000000000000000000000000000000000", + "stage": 3 + } + ], + "payload_bits": 98, + "payload_signed_prefix_upper": "306334506775192213700382759936", + "physical_replicas": 40, + "positive_rank_children": "19833600", + "primitive_coefficient_bits": 56, + "route_families": "8324400", + "scope": "Sufficient finite invoice for the literal new cohort word, 40 physical replicas and fully admitted bank stock; original 48dim route, retained odd-prime rational address grid, common-ancestor compiler and complex recovery interfaces are inherited unchanged. No Lean or independent certification of those underlying public theorems asserted.", + "simultaneous_extra_work_streams": 1, + "status": "PASS_COHORT_LITERAL_FIVE_STAGE_FINITE_INVOICE_AND_POSITIVE_CUTOFFS", + "strict_moment_slack": "317272176063038188467599250332166404626084482726414051341090083693/134799733335753198973335075435098153368185722112702862405518051246080000000000000000" +} diff --git a/research/multicut-kernel-composition/expected-sandwich/COHORT-FIVE-STAGE-COLUMNS.json b/research/multicut-kernel-composition/expected-sandwich/COHORT-FIVE-STAGE-COLUMNS.json new file mode 100644 index 0000000000..c7bf71da04 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/COHORT-FIVE-STAGE-COLUMNS.json @@ -0,0 +1,184 @@ +{ + "bridge_additions": 10560, + "copied_center_original_source_immutable": true, + "five_stage_additions": 3642300, + "formal_columns_checked": 23627, + "fresh_center_copies": 120, + "global_live_registers": 23627, + "independent_dirty_registers": 16587, + "local_odd_scalar_additions": 728460, + "local_raw_H": [ + [ + 1, + 43288 + ], + [ + 2, + 18904 + ], + [ + 3, + 9675 + ], + [ + 4, + 3032 + ], + [ + 5, + 2343 + ], + [ + 6, + 1576 + ], + [ + 7, + 1202 + ], + [ + 8, + 641 + ], + [ + 9, + 631 + ], + [ + 10, + 767 + ], + [ + 11, + 442 + ], + [ + 12, + 1509 + ], + [ + 13, + 589 + ], + [ + 14, + 1067 + ], + [ + 15, + 241 + ], + [ + 16, + 1000 + ], + [ + 17, + 468 + ], + [ + 18, + 480 + ], + [ + 19, + 323 + ], + [ + 20, + 1284 + ], + [ + 21, + 5546 + ], + [ + 22, + 1344 + ] + ], + "local_registers": 20107, + "local_scalar_additions": 728460, + "local_scalar_stream": "/private/tmp/claude-501/-Users-chafreaky-Documents-personal-integer-mult-research-20261008/5d8c8dbe-e8bc-42ba-8d10-c0561b637c5a/scratchpad/grand/run3-swap/plateau/sandwich/COHORT249-RECORDS.bin", + "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": 98, + "payload_prefix_upper": "306334506775192213700382759936", + "reverse_fresh_center_copies": 48, + "scope": "All 23627 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.", + "seconds": 0.277343708, + "signed_lift_prefix": [ + { + "bits": 17, + "cancellation_free_signed_row_l1_upper": "74391", + "reverse": false + }, + { + "bits": 22, + "cancellation_free_signed_row_l1_upper": "3409788", + "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": 24, + "scalar_additions": 728460, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 24, + "scalar_additions": 728460, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 24, + "scalar_additions": 728460, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 24, + "scalar_additions": 728460, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 24, + "scalar_additions": 728460, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" +} \ No newline at end of file diff --git a/research/multicut-kernel-composition/expected-sandwich/COHORT249-REPLAY.json b/research/multicut-kernel-composition/expected-sandwich/COHORT249-REPLAY.json new file mode 100644 index 0000000000..668540d260 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/COHORT249-REPLAY.json @@ -0,0 +1,224 @@ +{ + "added_Q_Qinverse_passes": 2286, + "bank_completion_not_replayed": true, + "cut_record": 727593, + "delta": { + "1": 1876, + "2": -181, + "3": -559, + "4": 122, + "5": -141, + "6": 49, + "7": -50, + "8": 12, + "9": 20, + "10": -6, + "11": -3, + "12": -16, + "13": 27, + "14": -13, + "15": -46, + "17": -36, + "18": -7, + "19": -8, + "20": -74, + "21": -43 + }, + "forward_formal_columns": 20107, + "global_kappa_claimed": false, + "histogram": { + "1": 43288, + "2": 18904, + "3": 9675, + "4": 3032, + "5": 2343, + "6": 1576, + "7": 1202, + "8": 641, + "9": 631, + "10": 767, + "11": 442, + "12": 1509, + "13": 589, + "14": 1067, + "15": 241, + "16": 1000, + "17": 468, + "18": 480, + "19": 323, + "20": 1284, + "21": 5546, + "22": 1344 + }, + "inverse_formal_columns": 20107, + "new_entrance_rank": 1719, + "new_gauges": 890, + "new_gram_audit_external": true, + "new_rank_mass": 429938, + "new_records": 828115, + "old_rank_mass": 434177, + "old_records": 885228, + "omitted_Q_nonzero_wrong_words": 38256, + "omitted_Qinverse_nonzero_wrong_words": 1090, + "removed_initial_reads": 60520, + "status": "CLEANUP_SANDWICH_CANCELLATION_NATIVE_BANK_REVIEW_NOT_APPLICABLE", + "cohort_rewrite_records": 828137, + "cohort_rewrite_histogram": { + "1": 43230, + "10": 769, + "11": 430, + "12": 1514, + "13": 583, + "14": 1067, + "15": 241, + "16": 1000, + "17": 470, + "18": 487, + "19": 323, + "2": 18939, + "20": 1358, + "21": 5589, + "22": 1344, + "3": 9657, + "4": 3015, + "5": 2394, + "6": 1530, + "7": 1226, + "8": 634, + "9": 645 + }, + "cohort_rewrite_delta": { + "1": 1818, + "10": -4, + "11": -15, + "12": -11, + "13": 21, + "14": -13, + "15": -46, + "17": -34, + "19": -8, + "2": -146, + "3": -577, + "4": 105, + "5": -90, + "6": 3, + "7": -26, + "8": 5, + "9": 34 + }, + "descent_delta": { + "2": -2, + "4": 24, + "5": -48, + "6": 25, + "11": -1, + "13": 2, + "17": -1 + }, + "descent_retimed_gates": 25, + "descent_removed_calls": 1, + "plateau_histogram_delta": { + "1": 15, + "2": -26, + "4": -7, + "3": 19, + "5": -3, + "6": 21, + "11": 13, + "12": -4, + "8": 8, + "9": -14, + "10": -2, + "13": 4, + "7": -24 + }, + "pre_target_records": 828136, + "pre_target_histogram": { + "1": 43245, + "2": 18911, + "3": 9676, + "4": 3032, + "5": 2343, + "6": 1576, + "7": 1202, + "8": 642, + "9": 631, + "10": 767, + "11": 442, + "12": 1510, + "13": 589, + "14": 1067, + "15": 241, + "16": 1000, + "17": 469, + "18": 487, + "19": 323, + "20": 1358, + "21": 5589, + "22": 1344 + }, + "pre_target_delta": { + "1": 1833, + "2": -174, + "3": -558, + "4": 122, + "5": -141, + "6": 49, + "7": -50, + "8": 13, + "9": 20, + "10": -6, + "11": -3, + "12": -15, + "13": 27, + "14": -13, + "15": -46, + "17": -35, + "19": -8 + }, + "target_prefix_delta": { + "1": -209, + "2": -7, + "3": -1, + "8": -1, + "12": -1, + "17": -1, + "18": -7, + "20": -200, + "21": 209 + }, + "target_prefix_groups": 209, + "target_prefix_deleted_reads": 1057, + "target_prefix_setup_restore_additions": 1254, + "pre_sandwich_records": 828115, + "pre_sandwich_histogram": { + "1": 43036, + "2": 18904, + "3": 9675, + "4": 3032, + "5": 2343, + "6": 1576, + "7": 1202, + "8": 641, + "9": 631, + "10": 767, + "11": 442, + "12": 1509, + "13": 589, + "14": 1067, + "15": 241, + "16": 1000, + "17": 468, + "18": 480, + "19": 323, + "20": 1158, + "21": 5798, + "22": 1344 + }, + "sandwich_histogram_delta": { + "1": 252, + "20": 126, + "21": -252 + }, + "sandwich_helpers_retired": 126 +} diff --git a/research/multicut-kernel-composition/expected-sandwich/INDEPENDENT-LEGALITY.json b/research/multicut-kernel-composition/expected-sandwich/INDEPENDENT-LEGALITY.json new file mode 100644 index 0000000000..008d6bda2e --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/INDEPENDENT-LEGALITY.json @@ -0,0 +1,110 @@ +{ + "all_final_frames_pass": true, + "common_frame_ADDs": 728460, + "containment_pairs_checked": 83070, + "copies": 24, + "donor_intersections": 0, + "erasures": 24, + "max_inherited_integer_abs": 7, + "nested_MOVEs": 99607, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 150370, + "paid_histogram": [ + [ + 1, + 43288 + ], + [ + 2, + 18904 + ], + [ + 3, + 9675 + ], + [ + 4, + 3032 + ], + [ + 5, + 2343 + ], + [ + 6, + 1576 + ], + [ + 7, + 1202 + ], + [ + 8, + 641 + ], + [ + 9, + 631 + ], + [ + 10, + 767 + ], + [ + 11, + 442 + ], + [ + 12, + 1509 + ], + [ + 13, + 589 + ], + [ + 14, + 1067 + ], + [ + 15, + 241 + ], + [ + 16, + 1000 + ], + [ + 17, + 468 + ], + [ + 18, + 480 + ], + [ + 19, + 323 + ], + [ + 20, + 1284 + ], + [ + 21, + 5546 + ], + [ + 22, + 1344 + ] + ], + "rank_mass": 429938, + "records": 828115, + "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": 1903, + "selected_pairs": 890, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" +} diff --git a/research/multicut-kernel-composition/expected-sandwich/INDEPENDENT-PREFIX.json b/research/multicut-kernel-composition/expected-sandwich/INDEPENDENT-PREFIX.json new file mode 100644 index 0000000000..03272faa33 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/INDEPENDENT-PREFIX.json @@ -0,0 +1,10 @@ +{ + "cohorts": 890, + "distinct_cuts": 4, + "distinct_helpers": 1903, + "non_target_identity_bits": 37299451, + "nonzero_pivot_target_entries": 60556, + "scope": "Original pinned-word response at every cohort own cut; combined emitted-word checks remain separate.", + "status": "PASS_INDEPENDENT_MULTI_CUT_FULL_F2_KERNEL_AND_IDENTITY_COLUMNS", + "target_kernel_equalities": 1566400 +} diff --git a/research/multicut-kernel-composition/expected-sandwich/SANDWICH-BANK-INVOICE.json b/research/multicut-kernel-composition/expected-sandwich/SANDWICH-BANK-INVOICE.json new file mode 100644 index 0000000000..198ababa55 --- /dev/null +++ b/research/multicut-kernel-composition/expected-sandwich/SANDWICH-BANK-INVOICE.json @@ -0,0 +1,600 @@ +{ + "literal_stock": 862350, + "banks_per_stage": 116150, + "banks_fewer_per_stage": 840, + "actual_role_replica_stage_assignments": 3317400, + "bank_patterns": [ + { + "count": 240, + "widths": [ + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 50, + "widths": [ + 7, + 7, + 7, + 7, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 44, + "widths": [ + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "count": 92, + "widths": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ] + }, + { + "count": 10, + "widths": [ + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15 + ] + }, + { + "count": 20, + "widths": [ + 7, + 7, + 7, + 7, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 40, + "widths": [ + 9, + 9, + 9, + 9, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 10, + "widths": [ + 10, + 10, + 10, + 10, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 70, + "widths": [ + 11, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 70, + "widths": [ + 12, + 12, + 12, + 12, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 190, + "widths": [ + 13, + 13, + 13, + 13, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 20, + "widths": [ + 14, + 14, + 14, + 14, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 180, + "widths": [ + 15, + 15, + 15, + 15, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 10, + "widths": [ + 16, + 16, + 16, + 16, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 10, + "widths": [ + 18, + 18, + 18, + 18, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 240, + "widths": [ + 19, + 19, + 19, + 19, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 190, + "widths": [ + 20, + 20, + 20, + 20, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 30, + "widths": [ + 21, + 21, + 21, + 21, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 440, + "widths": [ + 22, + 22, + 22, + 22, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 6120, + "widths": [ + 23, + 23, + 23, + 23, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 772, + "widths": [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 107176, + "widths": [ + 24, + 24, + 24, + 24, + 24 + ] + }, + { + "widths": [ + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ], + "count": 126 + } + ], + "residual_families": { + "3": 126, + "4": 2200, + "6": 22, + "7": 7, + "9": 4, + "10": 1, + "11": 55, + "12": 30, + "13": 19, + "14": 2, + "15": 20, + "16": 1, + "18": 1, + "19": 24, + "20": 19, + "21": 3, + "22": 44, + "23": 612, + "24": 13397 + }, + "endpoint_max_entry": 10, + "normalized_stock": 172470, + "new_exact_charts": 1423, + "max_new_chart_factors": 286, + "max_intermediate_numerator": "1517994138707428147200", + "max_intermediate_denominator": "1517994138707428147200", + "selector_charge": 626935451600, + "routing_prime_guard": { + "normalized_scaled_chart_entry_bound": 27549901440, + "pairwise_difference_numerator_bound": 1517994138707428147200 + }, + "status": "PASS_SANDWICH_ENDPOINTS_EXACT_CHARTS_AND_BANK_RETILING", + "base_bank_review_sha256": "0893b75595be282eb5500845419cc69336fe1ba6d68f84266f69b43a4586c72e", + "normalizers": { + "new_frames": 126, + "move_pairs": 378, + "charts": 504, + "max_factors": 155, + "max_numerator_denominator": 26244 + } +} diff --git a/research/multicut-kernel-composition/expected/COHORT-BANK-REVIEW.json b/research/multicut-kernel-composition/expected/COHORT-BANK-REVIEW.json new file mode 100644 index 0000000000..dc75eb60d9 --- /dev/null +++ b/research/multicut-kernel-composition/expected/COHORT-BANK-REVIEW.json @@ -0,0 +1,553 @@ +{ + "actual_helper_roles": 16587, + "actual_role_replica_stage_assignments": 3317400, + "assignment_fnv1a64": "6767162259695106595", + "bank_patterns": [ + { + "count": 240, + "widths": [ + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 50, + "widths": [ + 7, + 7, + 7, + 7, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 44, + "widths": [ + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "count": 92, + "widths": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ] + }, + { + "count": 10, + "widths": [ + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15 + ] + }, + { + "count": 20, + "widths": [ + 7, + 7, + 7, + 7, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 40, + "widths": [ + 9, + 9, + 9, + 9, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 10, + "widths": [ + 10, + 10, + 10, + 10, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 70, + "widths": [ + 11, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 70, + "widths": [ + 12, + 12, + 12, + 12, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 190, + "widths": [ + 13, + 13, + 13, + 13, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 20, + "widths": [ + 14, + 14, + 14, + 14, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 180, + "widths": [ + 15, + 15, + 15, + 15, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 10, + "widths": [ + 16, + 16, + 16, + 16, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 10, + "widths": [ + 18, + 18, + 18, + 18, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 240, + "widths": [ + 19, + 19, + 19, + 19, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 190, + "widths": [ + 20, + 20, + 20, + 20, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 30, + "widths": [ + 21, + 21, + 21, + 21, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 440, + "widths": [ + 22, + 22, + 22, + 22, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 7380, + "widths": [ + 23, + 23, + 23, + 23, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 478, + "widths": [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "count": 107176, + "widths": [ + 24, + 24, + 24, + 24, + 24 + ] + } + ], + "banks_per_stage": 116990, + "covered_address_rank_mass": 70194000, + "endpoint_address_columns": 10560, + "label": "actual_multicut", + "literal_stock": 866550, + "max_block_scalar": 30, + "max_intermediate_denominator": "704", + "max_intermediate_numerator": "704", + "max_new_chart_factors": 262, + "new_entrance_rank": 1719, + "new_exact_charts": 919, + "new_gauged_roles": 890, + "nonzero_omission_repeat_control_columns": 10560, + "normalized_stock": 173310, + "normalizer_factor_ceiling": 787, + "prime_guard": "every elimination pivot and emitted coefficient has numerator and denominator magnitude below2^80", + "residual_families": { + "10": 1, + "11": 55, + "12": 30, + "13": 19, + "14": 2, + "15": 20, + "16": 1, + "18": 1, + "19": 24, + "20": 19, + "21": 3, + "22": 44, + "23": 738, + "24": 13397, + "4": 2200, + "6": 22, + "7": 7, + "9": 4 + }, + "saved_literal_banks": 2865, + "scope": "Exact chart and role census, residual conjugacy, complete bank tiling, and finite selector charge. Full physical word, global columns, and pricing checked separately.", + "selector_charge": 626937131600, + "status": "PASS_GENERIC_EXACT_CHARTS_ACTUAL_BANK_ALLOCATION" +} diff --git a/research/multicut-kernel-composition/expected/COHORT-EXACT-PRICE.json b/research/multicut-kernel-composition/expected/COHORT-EXACT-PRICE.json new file mode 100644 index 0000000000..c0995078c2 --- /dev/null +++ b/research/multicut-kernel-composition/expected/COHORT-EXACT-PRICE.json @@ -0,0 +1,102 @@ +{ + "bank_completion_required": true, + "baseline": { + "bootstrap_chain": [ + "384599/10000000000", + "2775074877778189216668764722271/3906250000000000000000000000000000", + "173558804364146204827867868073291755898188480567/244140625000000000000000000000000000000000000000000", + "10847430454511196133215997344324346922256120566358658714942852559/15258789062500000000000000000000000000000000000000000000000000000000" + ], + "calls": 3929800, + "coarse": "44431075156777/62500000000000000", + "coarse_decimal": 0.000710897202508432, + "deficit": 35200, + "histogram": { + "1": 1656480, + "10": 30920, + "11": 17800, + "12": 61000, + "13": 22480, + "14": 43200, + "15": 11480, + "16": 40000, + "17": 20160, + "18": 19480, + "19": 13240, + "2": 763400, + "20": 54320, + "21": 223560, + "22": 53760, + "23": 28160, + "3": 409360, + "4": 144560, + "46": 28160, + "5": 99360, + "50": 28160, + "6": 61080, + "7": 50080, + "8": 25160, + "9": 24440 + }, + "kappa": "88799023305857/125000000000000000", + "kappa_decimal": 0.000710392186446856, + "moment_upper": "134799733335753198920057674536459842752067240396968383888154222763697620174862270833/134799733335753198973335075435098153368185722112702862405518051246080000000000000000", + "next_coarse_moment_lower": "26959946667150639848053762927394145538139961908949413445925020018093510574823910013/26959946667150639794667015087019630673637144422540572481103610249216000000000000000", + "next_kappa_rejected": 1, + "ordinary_bit": "10847430454511196133215997344324346922256120566358658714942852559/15258789062500000000000000000000000000000000000000000000000000000000", + "positive_constraints": 47, + "rank_mass": 20830760, + "stock": 173883 + }, + "cohort_candidate": { + "bootstrap_chain": [ + "384599/10000000000", + "712032216292737875319682616334311/1000000000000000000000000000000000000", + "712512144979113939283526852907464342662615075472387/1000000000000000000000000000000000000000000000000000000", + "712512486934295937219336833887930744552113678895670560170594384155279/1000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "calls": 3961680, + "coarse": "712512487178117/1000000000000000000", + "coarse_decimal": 0.000712512487178117, + "deficit": 35200, + "histogram": { + "1": 1721440, + "10": 30680, + "11": 17680, + "12": 60360, + "13": 23560, + "14": 42680, + "15": 9640, + "16": 40000, + "17": 18720, + "18": 19200, + "19": 12920, + "2": 756160, + "20": 46320, + "21": 231920, + "22": 53760, + "23": 28160, + "3": 387000, + "4": 149440, + "46": 28160, + "5": 93720, + "50": 28160, + "6": 63040, + "7": 48080, + "8": 25640, + "9": 25240 + }, + "kappa": "712005174354669/1000000000000000000", + "kappa_decimal": 0.000712005174354669, + "moment_upper": "269599466671506397639788011780538617499682424117904849650337015167872657265238860693/269599466671506397946670150870196306736371444225405724811036102492160000000000000000", + "next_coarse_moment_lower": "269599466671506398280874426254636431178404393755656487247075432124227039215458038763/269599466671506397946670150870196306736371444225405724811036102492160000000000000000", + "next_kappa_rejected": 1, + "ordinary_bit": "712512486934295937219336833887930744552113678895670560170594384155279/1000000000000000000000000000000000000000000000000000000000000000000000000", + "positive_constraints": 47, + "rank_mass": 20762000, + "stock": 173310 + }, + "finite_bill_and_all_size_interfaces_not_reproved": true, + "method": "C++ exact rational 224-bit directed bounds; floating used only to propose a bracket verified exactly;32-degree exponential and48-term atanh logarithm", + "status": "PASS_EXACT_COHORT_CONDITIONAL_PRICING_47_AND_ADJACENT_CONTROLS" +} diff --git a/research/multicut-kernel-composition/expected/COHORT-FINITE-INVOICE.json b/research/multicut-kernel-composition/expected/COHORT-FINITE-INVOICE.json new file mode 100644 index 0000000000..9027dda91f --- /dev/null +++ b/research/multicut-kernel-composition/expected/COHORT-FINITE-INVOICE.json @@ -0,0 +1,72 @@ +{ + "external_complex_row_coefficient": 20161, + "extra_selector_calls": "626937131600", + "full_counted_primitive_coefficient": "62682729451523601", + "global_unit_expanded_additions": "146667600", + "global_weighted_additions": "146139600", + "internal_row_coefficient": 14401, + "linear_moment_slack": "85937499554311/50774414062500000", + "literal_deficit": 176000, + "literal_histogram": { + "1": "8607200", + "10": "153400", + "11": "88400", + "12": "301800", + "13": "117800", + "14": "213400", + "15": "48200", + "16": "200000", + "17": "93600", + "18": "96000", + "19": "64600", + "2": "3780800", + "20": "231600", + "21": "1159600", + "22": "268800", + "23": "140800", + "3": "1935000", + "4": "747200", + "46": "140800", + "5": "468600", + "50": "140800", + "6": "315200", + "7": "240400", + "8": "128200", + "9": "126200" + }, + "literal_rank_mass": "103810000", + "literal_stock": 866550, + "new_chart_factor_max": 262, + "normalized_stock": 173310, + "normalizer_factor_bound": 787, + "ordinary_cutoffs": [ + { + "counted_coefficient_cutoff_log2": "156073791508775", + "general_rule": "For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta)).", + "minimum_gap": "480270885379124680317383665689/1000000000000000000000000000000000000", + "stage": 1 + }, + { + "counted_coefficient_cutoff_log2": "307429133387982740771", + "general_rule": "For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta)).", + "minimum_gap": "342199003060716473147092535657337384924527613/1000000000000000000000000000000000000000000000000000000", + "stage": 2 + }, + { + "counted_coefficient_cutoff_log2": "605564016495186821841335015", + "general_rule": "For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta)).", + "minimum_gap": "243821062780663166112069255447886321104329439829405615844721/1000000000000000000000000000000000000000000000000000000000000000000000000", + "stage": 3 + } + ], + "payload_bits": 98, + "payload_signed_prefix_upper": "313795846577713577429067853824", + "physical_replicas": 40, + "positive_rank_children": "19808400", + "primitive_coefficient_bits": 56, + "route_families": "8324400", + "scope": "Sufficient finite invoice for the literal new cohort word, 40 physical replicas and fully admitted bank stock; original 48dim route, retained odd-prime rational address grid, common-ancestor compiler and complex recovery interfaces are inherited unchanged. No Lean or independent certification of those underlying public theorems asserted.", + "simultaneous_extra_work_streams": 1, + "status": "PASS_COHORT_LITERAL_FIVE_STAGE_FINITE_INVOICE_AND_POSITIVE_CUTOFFS", + "strict_moment_slack": "306882139089657689236689020107500875160699087324287342734761139307/269599466671506397946670150870196306736371444225405724811036102492160000000000000000" +} diff --git a/research/multicut-kernel-composition/expected/COHORT-FIVE-STAGE-COLUMNS.json b/research/multicut-kernel-composition/expected/COHORT-FIVE-STAGE-COLUMNS.json new file mode 100644 index 0000000000..fee5d7787e --- /dev/null +++ b/research/multicut-kernel-composition/expected/COHORT-FIVE-STAGE-COLUMNS.json @@ -0,0 +1,184 @@ +{ + "bridge_additions": 10560, + "copied_center_original_source_immutable": true, + "five_stage_additions": 3642930, + "formal_columns_checked": 23627, + "fresh_center_copies": 120, + "global_live_registers": 23627, + "independent_dirty_registers": 16587, + "local_odd_scalar_additions": 728586, + "local_raw_H": [ + [ + 1, + 43036 + ], + [ + 2, + 18904 + ], + [ + 3, + 9675 + ], + [ + 4, + 3032 + ], + [ + 5, + 2343 + ], + [ + 6, + 1576 + ], + [ + 7, + 1202 + ], + [ + 8, + 641 + ], + [ + 9, + 631 + ], + [ + 10, + 767 + ], + [ + 11, + 442 + ], + [ + 12, + 1509 + ], + [ + 13, + 589 + ], + [ + 14, + 1067 + ], + [ + 15, + 241 + ], + [ + 16, + 1000 + ], + [ + 17, + 468 + ], + [ + 18, + 480 + ], + [ + 19, + 323 + ], + [ + 20, + 1158 + ], + [ + 21, + 5798 + ], + [ + 22, + 1344 + ] + ], + "local_registers": 20107, + "local_scalar_additions": 728586, + "local_scalar_stream": "/private/tmp/claude-501/-Users-chafreaky-Documents-personal-integer-mult-research-20261008/5d8c8dbe-e8bc-42ba-8d10-c0561b637c5a/scratchpad/grand/run3-swap/plateau/COHORT249-RECORDS.bin", + "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": 98, + "payload_prefix_upper": "313795846577713577429067853824", + "reverse_fresh_center_copies": 48, + "scope": "All 23627 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.", + "seconds": 0.301112792, + "signed_lift_prefix": [ + { + "bits": 17, + "cancellation_free_signed_row_l1_upper": "74391", + "reverse": false + }, + { + "bits": 22, + "cancellation_free_signed_row_l1_upper": "3451064", + "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": 24, + "scalar_additions": 728586, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 24, + "scalar_additions": 728586, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 24, + "scalar_additions": 728586, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 24, + "scalar_additions": 728586, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 24, + "scalar_additions": 728586, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" +} \ No newline at end of file diff --git a/research/multicut-kernel-composition/expected/COHORT249-REPLAY.json b/research/multicut-kernel-composition/expected/COHORT249-REPLAY.json new file mode 100644 index 0000000000..7964ef017b --- /dev/null +++ b/research/multicut-kernel-composition/expected/COHORT249-REPLAY.json @@ -0,0 +1,193 @@ +{ + "added_Q_Qinverse_passes": 2286, + "bank_completion_not_replayed": true, + "cut_record": 727593, + "delta": { + "1": 1624, + "2": -181, + "3": -559, + "4": 122, + "5": -141, + "6": 49, + "7": -50, + "8": 12, + "9": 20, + "10": -6, + "11": -3, + "12": -16, + "13": 27, + "14": -13, + "15": -46, + "17": -36, + "18": -7, + "19": -8, + "20": -200, + "21": 209 + }, + "forward_formal_columns": 20107, + "global_kappa_claimed": false, + "histogram": { + "1": 43036, + "2": 18904, + "3": 9675, + "4": 3032, + "5": 2343, + "6": 1576, + "7": 1202, + "8": 641, + "9": 631, + "10": 767, + "11": 442, + "12": 1509, + "13": 589, + "14": 1067, + "15": 241, + "16": 1000, + "17": 468, + "18": 480, + "19": 323, + "20": 1158, + "21": 5798, + "22": 1344 + }, + "inverse_formal_columns": 20107, + "new_entrance_rank": 1719, + "new_gauges": 890, + "new_gram_audit_external": true, + "new_rank_mass": 432458, + "new_records": 828115, + "old_rank_mass": 434177, + "old_records": 885228, + "omitted_Q_nonzero_wrong_words": 38256, + "omitted_Qinverse_nonzero_wrong_words": 1090, + "removed_initial_reads": 60520, + "status": "PASS_FULL_CURRENT249_COHORT_REWRITE_AND_TARGET_PREFIX_COMPRESSION", + "cohort_rewrite_records": 828137, + "cohort_rewrite_histogram": { + "1": 43230, + "10": 769, + "11": 430, + "12": 1514, + "13": 583, + "14": 1067, + "15": 241, + "16": 1000, + "17": 470, + "18": 487, + "19": 323, + "2": 18939, + "20": 1358, + "21": 5589, + "22": 1344, + "3": 9657, + "4": 3015, + "5": 2394, + "6": 1530, + "7": 1226, + "8": 634, + "9": 645 + }, + "cohort_rewrite_delta": { + "1": 1818, + "10": -4, + "11": -15, + "12": -11, + "13": 21, + "14": -13, + "15": -46, + "17": -34, + "19": -8, + "2": -146, + "3": -577, + "4": 105, + "5": -90, + "6": 3, + "7": -26, + "8": 5, + "9": 34 + }, + "descent_delta": { + "2": -2, + "4": 24, + "5": -48, + "6": 25, + "11": -1, + "13": 2, + "17": -1 + }, + "descent_retimed_gates": 25, + "descent_removed_calls": 1, + "plateau_histogram_delta": { + "1": 15, + "2": -26, + "4": -7, + "3": 19, + "5": -3, + "6": 21, + "11": 13, + "12": -4, + "8": 8, + "9": -14, + "10": -2, + "13": 4, + "7": -24 + }, + "pre_target_records": 828136, + "pre_target_histogram": { + "1": 43245, + "2": 18911, + "3": 9676, + "4": 3032, + "5": 2343, + "6": 1576, + "7": 1202, + "8": 642, + "9": 631, + "10": 767, + "11": 442, + "12": 1510, + "13": 589, + "14": 1067, + "15": 241, + "16": 1000, + "17": 469, + "18": 487, + "19": 323, + "20": 1358, + "21": 5589, + "22": 1344 + }, + "pre_target_delta": { + "1": 1833, + "2": -174, + "3": -558, + "4": 122, + "5": -141, + "6": 49, + "7": -50, + "8": 13, + "9": 20, + "10": -6, + "11": -3, + "12": -15, + "13": 27, + "14": -13, + "15": -46, + "17": -35, + "19": -8 + }, + "target_prefix_delta": { + "1": -209, + "2": -7, + "3": -1, + "8": -1, + "12": -1, + "17": -1, + "18": -7, + "20": -200, + "21": 209 + }, + "target_prefix_groups": 209, + "target_prefix_deleted_reads": 1057, + "target_prefix_setup_restore_additions": 1254 +} diff --git a/research/multicut-kernel-composition/expected/DESCENT-RETIMING.json b/research/multicut-kernel-composition/expected/DESCENT-RETIMING.json new file mode 100644 index 0000000000..6d41661097 --- /dev/null +++ b/research/multicut-kernel-composition/expected/DESCENT-RETIMING.json @@ -0,0 +1,229 @@ +{ + "status": "PASS_CONCAVE_DESCENT_RETIMING_AND_BOTH_REFLECTED_LEDGERS", + "selected_gate_count": 25, + "changed_gates": [ + { + "record": 669971, + "gate": 642629, + "old_frame": 143763, + "new_frame": 89922, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669975, + "gate": 642631, + "old_frame": 143783, + "new_frame": 88472, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669979, + "gate": 642633, + "old_frame": 143805, + "new_frame": 140026, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669983, + "gate": 642635, + "old_frame": 143830, + "new_frame": 140003, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669987, + "gate": 642637, + "old_frame": 143855, + "new_frame": 139980, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669991, + "gate": 642639, + "old_frame": 143882, + "new_frame": 139957, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669995, + "gate": 642641, + "old_frame": 143902, + "new_frame": 139932, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 669999, + "gate": 642643, + "old_frame": 143924, + "new_frame": 139907, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670003, + "gate": 642645, + "old_frame": 143945, + "new_frame": 139878, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670007, + "gate": 642647, + "old_frame": 143965, + "new_frame": 139850, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670011, + "gate": 642649, + "old_frame": 143987, + "new_frame": 139829, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670015, + "gate": 642651, + "old_frame": 144006, + "new_frame": 139808, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670019, + "gate": 642653, + "old_frame": 144027, + "new_frame": 139786, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670023, + "gate": 642655, + "old_frame": 144051, + "new_frame": 139762, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670027, + "gate": 642657, + "old_frame": 144072, + "new_frame": 139739, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670031, + "gate": 642659, + "old_frame": 144092, + "new_frame": 139717, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670035, + "gate": 642661, + "old_frame": 144113, + "new_frame": 139693, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670039, + "gate": 642663, + "old_frame": 144137, + "new_frame": 139668, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670043, + "gate": 642665, + "old_frame": 144160, + "new_frame": 139645, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670047, + "gate": 642667, + "old_frame": 144186, + "new_frame": 139623, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670051, + "gate": 642669, + "old_frame": 144212, + "new_frame": 59176, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670055, + "gate": 642671, + "old_frame": 144235, + "new_frame": 57582, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670059, + "gate": 642673, + "old_frame": 144260, + "new_frame": 55992, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670063, + "gate": 642675, + "old_frame": 144286, + "new_frame": 54398, + "old_dimension": 5, + "new_dimension": 6 + }, + { + "record": 670115, + "gate": 642700, + "old_frame": 148105, + "new_frame": 89511, + "old_dimension": 4, + "new_dimension": 15 + } + ], + "removed_calls": 1, + "local_histogram_delta": { + "2": -2, + "4": 24, + "5": -48, + "6": 25, + "11": -1, + "13": 2, + "17": -1 + }, + "rank_mass": 432458, + "paid_calls": 96444, + "scalar_additions": 728389, + "identical_scalar_and_copy_projection": true, + "both_reflected_ledgers": true, + "unchanged_all_input_output_frames": true, + "unchanged_copy_lifetimes": true, + "operand_source_spans_contained": true, + "checked_operand_spans": 193, + "unique_required_frame_pairs": 100298, + "input_record_sha256": "4458dce8218c9a0e0e55f494e33b2ad320649e953d108470ba0c8ac077660505", + "output_record_sha256": "a6d793d7fd4f902436fd64c1d0e9467adc93844e058578994400d30fcf4171c3", + "selection_sha256": "e9009fdeaef6e5d59b935803f909453c3c1407200e60713ce3f214f378209991" +} diff --git a/research/multicut-kernel-composition/expected/FRAME-TABLE-AUDIT.json b/research/multicut-kernel-composition/expected/FRAME-TABLE-AUDIT.json new file mode 100644 index 0000000000..86c94ec758 --- /dev/null +++ b/research/multicut-kernel-composition/expected/FRAME-TABLE-AUDIT.json @@ -0,0 +1,932 @@ +{ + "added_frames": 919, + "all_A_B_transpose_zero": true, + "all_A_rank_equals_codimension": true, + "all_B_rank_equals_dimension": true, + "all_weighted_Gram_nondegenerate": true, + "dimensions": { + "200000": 1, + "200001": 1, + "200002": 1, + "200003": 1, + "200004": 1, + "200005": 1, + "200006": 1, + "200007": 1, + "200008": 1, + "200009": 1, + "200010": 1, + "200011": 1, + "200012": 1, + "200013": 1, + "200014": 1, + "200015": 1, + "200016": 1, + "200017": 1, + "200018": 1, + "200019": 1, + "200020": 1, + "200021": 1, + "200022": 1, + "200023": 1, + "200024": 1, + "200025": 1, + "200026": 1, + "200027": 1, + "200028": 1, + "200029": 1, + "200030": 1, + "200031": 1, + "200032": 1, + "200033": 1, + "200034": 1, + "200035": 1, + "200036": 1, + "200037": 1, + "200038": 1, + "200039": 1, + "200040": 1, + "200041": 1, + "200042": 1, + "200043": 1, + "200044": 1, + "200045": 1, + "200046": 1, + "200047": 1, + "200048": 1, + "200049": 1, + "200050": 1, + "200051": 1, + "200052": 1, + "200053": 1, + "200054": 1, + "200055": 1, + "200056": 1, + "200057": 1, + "200058": 1, + "200059": 1, + "200060": 1, + "200061": 1, + "200062": 1, + "200063": 1, + "200064": 1, + "200065": 1, + "200066": 1, + "200067": 1, + "200068": 1, + "200069": 1, + "200070": 1, + "200071": 1, + "200072": 1, + "200073": 1, + "200074": 1, + "200075": 1, + "200076": 1, + "200077": 1, + "200078": 1, + "200079": 1, + "200080": 1, + "200081": 1, + "200082": 1, + "200083": 1, + "200084": 1, + "200085": 1, + "200086": 1, + "200087": 1, + "200088": 1, + "200089": 1, + "200090": 1, + "200091": 1, + "200092": 1, + "200093": 1, + "200094": 1, + "200095": 1, + "200096": 1, + "200097": 1, + "200098": 1, + "200099": 1, + "200100": 1, + "200101": 1, + "200102": 1, + "200103": 1, + "200104": 1, + "200105": 1, + "200106": 1, + "200107": 1, + "200108": 1, + "200109": 1, + "200110": 1, + "200111": 1, + "200112": 1, + "200113": 1, + "200114": 1, + "200115": 1, + "200116": 1, + "200117": 1, + "200118": 1, + "200119": 1, + "200120": 1, + "200121": 1, + "200122": 1, + "200123": 1, + "200124": 1, + "200125": 1, + "200126": 1, + "200127": 1, + "200128": 1, + "200129": 1, + "200130": 4, + "200131": 4, + "200132": 4, + "200133": 3, + "200134": 3, + "200135": 3, + "200136": 5, + "200137": 5, + "200138": 5, + "200139": 9, + "200140": 9, + "200141": 9, + "200142": 9, + "200143": 9, + "200144": 9, + "200145": 9, + "200146": 9, + "200147": 9, + "200148": 12, + "200149": 12, + "200150": 12, + "200151": 9, + "200152": 9, + "200153": 9, + "200154": 2, + "200155": 2, + "200156": 2, + "200157": 2, + "200158": 2, + "200159": 2, + "200160": 17, + "200161": 17, + "200162": 15, + "200163": 15, + "200164": 15, + "200165": 15, + "200166": 13, + "200167": 14, + "200168": 13, + "200169": 13, + "200170": 13, + "200171": 13, + "200172": 13, + "200173": 13, + "200174": 12, + "200175": 12, + "200176": 12, + "200177": 12, + "200178": 10, + "200179": 10, + "200180": 11, + "200181": 9, + "200182": 9, + "200183": 6, + "200184": 5, + "200185": 4, + "200186": 2, + "200187": 11, + "200188": 4, + "200189": 4, + "200190": 5, + "200191": 4, + "200192": 8, + "200193": 2, + "200194": 2, + "200195": 4, + "200196": 4, + "200197": 5, + "200198": 4, + "200199": 9, + "200200": 2, + "200201": 9, + "200202": 2, + "200203": 9, + "200204": 4, + "200205": 11, + "200206": 11, + "200207": 4, + "200208": 4, + "200209": 11, + "200210": 9, + "200211": 4, + "200212": 11, + "200213": 4, + "200214": 4, + "200215": 2, + "200216": 2, + "200217": 5, + "200218": 5, + "200219": 5, + "200220": 5, + "200221": 5, + "200222": 5, + "200223": 5, + "200224": 5, + "200225": 5, + "200226": 5, + "200227": 5, + "200228": 5, + "200229": 5, + "200230": 5, + "200231": 5, + "200232": 5, + "200233": 5, + "200234": 5, + "200235": 11, + "200236": 11, + "200237": 11, + "200238": 11, + "200239": 11, + "200240": 11, + "200241": 11, + "200242": 11, + "200243": 11, + "200244": 11, + "200245": 11, + "200246": 11, + "200247": 11, + "200248": 4, + "200249": 4, + "200250": 4, + "200251": 2, + "200252": 2, + "200253": 2, + "200254": 2, + "200255": 2, + "200256": 2, + "200257": 2, + "200258": 2, + "200259": 2, + "200260": 2, + "200261": 2, + "200262": 2, + "200263": 2, + "200264": 2, + "200265": 2, + "200266": 2, + "200267": 2, + "200268": 2, + "200269": 2, + "200270": 2, + "200271": 2, + "200272": 1, + "200273": 1, + "200274": 1, + "200275": 1, + "200276": 1, + "200277": 1, + "200278": 1, + "200279": 1, + "200280": 1, + "200281": 1, + "200282": 1, + "200283": 1, + "200284": 1, + "200285": 1, + "200286": 1, + "200287": 1, + "200288": 1, + "200289": 1, + "200290": 1, + "200291": 1, + "200292": 1, + "200293": 1, + "200294": 1, + "200295": 1, + "200296": 1, + "200297": 1, + "200298": 1, + "200299": 1, + "200300": 1, + "200301": 1, + "200302": 1, + "200303": 1, + "200304": 1, + "200305": 1, + "200306": 1, + "200307": 1, + "200308": 1, + "200309": 1, + "200310": 1, + "200311": 1, + "200312": 1, + "200313": 1, + "200314": 1, + "200315": 1, + "200316": 1, + "200317": 1, + "200318": 1, + "200319": 1, + "200320": 1, + "200321": 1, + "200322": 1, + "200323": 1, + "200324": 1, + "200325": 1, + "200326": 1, + "200327": 1, + "200328": 1, + "200329": 1, + "200330": 1, + "200331": 1, + "200332": 1, + "200333": 1, + "200334": 1, + "200335": 1, + "200336": 1, + "200337": 1, + "200338": 1, + "200339": 1, + "200340": 1, + "200341": 1, + "200342": 1, + "200343": 1, + "200344": 1, + "200345": 1, + "200346": 1, + "200347": 1, + "200348": 1, + "200349": 1, + "200350": 1, + "200351": 1, + "200352": 1, + "200353": 1, + "200354": 1, + "200355": 1, + "200356": 1, + "200357": 1, + "200358": 1, + "200359": 1, + "200360": 1, + "200361": 1, + "200362": 1, + "200363": 1, + "200364": 1, + "200365": 1, + "200366": 1, + "200367": 1, + "200368": 1, + "200369": 1, + "200370": 1, + "200371": 1, + "200372": 1, + "200373": 1, + "200374": 1, + "200375": 1, + "200376": 1, + "200377": 1, + "200378": 1, + "200379": 1, + "200380": 1, + "200381": 1, + "200382": 1, + "200383": 1, + "200384": 1, + "200385": 1, + "200386": 1, + "200387": 1, + "200388": 1, + "200389": 1, + "200390": 1, + "200391": 1, + "200392": 1, + "200393": 1, + "200394": 1, + "200395": 1, + "200396": 1, + "200397": 1, + "200398": 1, + "200399": 1, + "200400": 1, + "200401": 1, + "200402": 1, + "200403": 1, + "200404": 1, + "200405": 1, + "200406": 1, + "200407": 1, + "200408": 1, + "200409": 1, + "200410": 1, + "200411": 1, + "200412": 1, + "200413": 1, + "200414": 1, + "200415": 1, + "200416": 1, + "200417": 1, + "200418": 1, + "200419": 1, + "200420": 1, + "200421": 1, + "200422": 1, + "200423": 1, + "200424": 1, + "200425": 1, + "200426": 1, + "200427": 1, + "200428": 1, + "200429": 1, + "200430": 1, + "200431": 1, + "200432": 1, + "200433": 1, + "200434": 1, + "200435": 1, + "200436": 1, + "200437": 1, + "200438": 1, + "200439": 1, + "200440": 1, + "200441": 1, + "200442": 1, + "200443": 1, + "200444": 1, + "200445": 1, + "200446": 1, + "200447": 1, + "200448": 1, + "200449": 1, + "200450": 2, + "200451": 2, + "200452": 2, + "200453": 2, + "200454": 2, + "200455": 2, + "200456": 2, + "200457": 1, + "200458": 1, + "200459": 1, + "200460": 1, + "200461": 1, + "200462": 1, + "200463": 1, + "200464": 1, + "200465": 1, + "200466": 1, + "200467": 1, + "200468": 1, + "200469": 1, + "200470": 1, + "200471": 1, + "200472": 1, + "200473": 1, + "200474": 1, + "200475": 1, + "200476": 1, + "200477": 1, + "200478": 1, + "200479": 1, + "200480": 1, + "200481": 1, + "200482": 1, + "200483": 1, + "200484": 1, + "200485": 1, + "200486": 1, + "200487": 1, + "200488": 1, + "200489": 1, + "200490": 1, + "200491": 1, + "200492": 1, + "200493": 1, + "200494": 1, + "200495": 1, + "200496": 1, + "200497": 1, + "200498": 1, + "200499": 1, + "200500": 1, + "200501": 1, + "200502": 1, + "200503": 2, + "200504": 2, + "200505": 2, + "200506": 1, + "200507": 1, + "200508": 1, + "200509": 1, + "200510": 1, + "200511": 1, + "200512": 1, + "200513": 1, + "200514": 1, + "200515": 1, + "200516": 1, + "200517": 1, + "200518": 1, + "200519": 1, + "200520": 1, + "200521": 1, + "200522": 1, + "200523": 1, + "200524": 1, + "200525": 1, + "200526": 1, + "200527": 1, + "200528": 1, + "200529": 1, + "200530": 1, + "200531": 1, + "200532": 1, + "200533": 1, + "200534": 1, + "200535": 1, + "200536": 1, + "200537": 1, + "200538": 1, + "200539": 1, + "200540": 1, + "200541": 1, + "200542": 1, + "200543": 1, + "200544": 1, + "200545": 1, + "200546": 1, + "200547": 1, + "200548": 1, + "200549": 1, + "200550": 1, + "200551": 1, + "200552": 1, + "200553": 1, + "200554": 1, + "200555": 1, + "200556": 1, + "200557": 1, + "200558": 1, + "200559": 1, + "200560": 1, + "200561": 1, + "200562": 1, + "200563": 1, + "200564": 1, + "200565": 1, + "200566": 1, + "200567": 1, + "200568": 1, + "200569": 1, + "200570": 1, + "200571": 1, + "200572": 1, + "200573": 1, + "200574": 1, + "200575": 1, + "200576": 1, + "200577": 1, + "200578": 1, + "200579": 1, + "200580": 1, + "200581": 1, + "200582": 1, + "200583": 1, + "200584": 1, + "200585": 1, + "200586": 1, + "200587": 1, + "200588": 1, + "200589": 1, + "200590": 1, + "200591": 1, + "200592": 1, + "200593": 1, + "200594": 1, + "200595": 1, + "200596": 1, + "200597": 1, + "200598": 1, + "200599": 1, + "200600": 1, + "200601": 1, + "200602": 1, + "200603": 1, + "200604": 1, + "200605": 1, + "200606": 1, + "200607": 1, + "200608": 1, + "200609": 1, + "200610": 1, + "200611": 1, + "200612": 1, + "200613": 1, + "200614": 1, + "200615": 1, + "200616": 1, + "200617": 1, + "200618": 1, + "200619": 1, + "200620": 1, + "200621": 1, + "200622": 1, + "200623": 1, + "200624": 1, + "200625": 1, + "200626": 1, + "200627": 1, + "200628": 1, + "200629": 1, + "200630": 1, + "200631": 1, + "200632": 1, + "200633": 1, + "200634": 1, + "200635": 1, + "200636": 1, + "200637": 1, + "200638": 1, + "200639": 1, + "200640": 1, + "200641": 1, + "200642": 1, + "200643": 1, + "200644": 1, + "200645": 1, + "200646": 1, + "200647": 1, + "200648": 1, + "200649": 1, + "200650": 1, + "200651": 1, + "200652": 1, + "200653": 1, + "200654": 1, + "200655": 1, + "200656": 1, + "200657": 1, + "200658": 1, + "200659": 1, + "200660": 1, + "200661": 1, + "200662": 1, + "200663": 1, + "200664": 1, + "200665": 1, + "200666": 1, + "200667": 1, + "200668": 1, + "200669": 1, + "200670": 1, + "200671": 1, + "200672": 1, + "200673": 1, + "200674": 1, + "200675": 1, + "200676": 1, + "200677": 1, + "200678": 1, + "200679": 1, + "200680": 1, + "200681": 1, + "200682": 1, + "200683": 1, + "200684": 1, + "200685": 1, + "200686": 1, + "200687": 1, + "200688": 1, + "200689": 1, + "200690": 1, + "200691": 1, + "200692": 1, + "200693": 1, + "200694": 1, + "200695": 1, + "200696": 1, + "200697": 1, + "200698": 1, + "200699": 1, + "200700": 1, + "200701": 1, + "200702": 1, + "200703": 1, + "200704": 1, + "200705": 1, + "200706": 1, + "200707": 1, + "200708": 1, + "200709": 1, + "200710": 1, + "200711": 1, + "200712": 1, + "200713": 1, + "200714": 1, + "200715": 1, + "200716": 1, + "200717": 1, + "200718": 1, + "200719": 1, + "200720": 1, + "200721": 1, + "200722": 1, + "200723": 1, + "200724": 1, + "200725": 1, + "200726": 1, + "200727": 1, + "200728": 1, + "200729": 1, + "200730": 1, + "200731": 1, + "200732": 1, + "200733": 1, + "200734": 1, + "200735": 1, + "200736": 1, + "200737": 1, + "200738": 1, + "200739": 1, + "200740": 1, + "200741": 1, + "200742": 1, + "200743": 1, + "200744": 1, + "200745": 1, + "200746": 1, + "200747": 1, + "200748": 1, + "200749": 1, + "200750": 1, + "200751": 1, + "200752": 1, + "200753": 1, + "200754": 1, + "200755": 1, + "200756": 1, + "200757": 1, + "200758": 1, + "200759": 1, + "200760": 1, + "200761": 1, + "200762": 1, + "200763": 1, + "200764": 1, + "200765": 1, + "200766": 1, + "200767": 1, + "200768": 1, + "200769": 1, + "200770": 1, + "200771": 1, + "200772": 1, + "200773": 1, + "200774": 1, + "200775": 1, + "200776": 1, + "200777": 1, + "200778": 1, + "200779": 1, + "200780": 1, + "200781": 1, + "200782": 1, + "200783": 1, + "200784": 1, + "200785": 1, + "200786": 1, + "200787": 1, + "200788": 1, + "200789": 1, + "200790": 1, + "200791": 1, + "200792": 1, + "200793": 1, + "200794": 1, + "200795": 1, + "200796": 1, + "200797": 1, + "200798": 1, + "200799": 1, + "200800": 1, + "200801": 1, + "200802": 1, + "200803": 1, + "200804": 1, + "200805": 1, + "200806": 1, + "200807": 1, + "200808": 1, + "200809": 1, + "200810": 1, + "200811": 1, + "200812": 1, + "200813": 1, + "200814": 1, + "200815": 1, + "200816": 1, + "200817": 1, + "200818": 1, + "200819": 1, + "200820": 1, + "200821": 1, + "200822": 1, + "200823": 1, + "200824": 1, + "200825": 1, + "200826": 1, + "200827": 1, + "200828": 1, + "200829": 1, + "200830": 1, + "200831": 1, + "200832": 1, + "200833": 1, + "200834": 1, + "200835": 1, + "200836": 1, + "200837": 1, + "200838": 1, + "200839": 1, + "200840": 1, + "200841": 1, + "200842": 1, + "200843": 1, + "200844": 1, + "200845": 1, + "200846": 1, + "200847": 1, + "200848": 1, + "200849": 1, + "200850": 1, + "200851": 1, + "200852": 1, + "200853": 1, + "200854": 1, + "200855": 1, + "200856": 1, + "200857": 1, + "200858": 1, + "200859": 1, + "200860": 1, + "200861": 1, + "200862": 1, + "200863": 1, + "200864": 1, + "200865": 1, + "200866": 1, + "200867": 1, + "200868": 1, + "200869": 1, + "200870": 1, + "200871": 1, + "200872": 1, + "200873": 1, + "200874": 1, + "200875": 1, + "200876": 1, + "200877": 1, + "200878": 1, + "200879": 1, + "200880": 1, + "200881": 1, + "200882": 1, + "200883": 1, + "200884": 1, + "200885": 1, + "200886": 1, + "200887": 1, + "200888": 1, + "200889": 1, + "212428": 11, + "212447": 11, + "212465": 11, + "212484": 11, + "212999": 13, + "213015": 13, + "213023": 13, + "213039": 13, + "213047": 13, + "213061": 13, + "213082": 13, + "214022": 16, + "214044": 16, + "214064": 16, + "214085": 16, + "214110": 13, + "214113": 13, + "214125": 13, + "214132": 13, + "214135": 13, + "214171": 13, + "214199": 14, + "214214": 14, + "214217": 14, + "214239": 13, + "214242": 13, + "214244": 13, + "214253": 13, + "214256": 13 + }, + "frame_table_sha256": "b3bf53358abb1d530f43a3f11519b23dee5f84fbcdd08b65e11cecf1730464d4", + "new_frame_ids_disjoint_from_original": true, + "status": "PASS_EXACT_ADDED_FRAME_BASES_AND_ANNIHILATORS", + "used_added_frames": 919 +} diff --git a/research/multicut-kernel-composition/expected/INDEPENDENT-LEGALITY.json b/research/multicut-kernel-composition/expected/INDEPENDENT-LEGALITY.json new file mode 100644 index 0000000000..92bf2fa777 --- /dev/null +++ b/research/multicut-kernel-composition/expected/INDEPENDENT-LEGALITY.json @@ -0,0 +1,110 @@ +{ + "all_final_frames_pass": true, + "common_frame_ADDs": 728586, + "containment_pairs_checked": 82944, + "copies": 24, + "donor_intersections": 0, + "erasures": 24, + "max_inherited_integer_abs": 7, + "nested_MOVEs": 99481, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 150370, + "paid_histogram": [ + [ + 1, + 43036 + ], + [ + 2, + 18904 + ], + [ + 3, + 9675 + ], + [ + 4, + 3032 + ], + [ + 5, + 2343 + ], + [ + 6, + 1576 + ], + [ + 7, + 1202 + ], + [ + 8, + 641 + ], + [ + 9, + 631 + ], + [ + 10, + 767 + ], + [ + 11, + 442 + ], + [ + 12, + 1509 + ], + [ + 13, + 589 + ], + [ + 14, + 1067 + ], + [ + 15, + 241 + ], + [ + 16, + 1000 + ], + [ + 17, + 468 + ], + [ + 18, + 480 + ], + [ + 19, + 323 + ], + [ + 20, + 1158 + ], + [ + 21, + 5798 + ], + [ + 22, + 1344 + ] + ], + "rank_mass": 432458, + "records": 828115, + "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": 1903, + "selected_pairs": 890, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" +} diff --git a/research/multicut-kernel-composition/expected/INDEPENDENT-PREFIX.json b/research/multicut-kernel-composition/expected/INDEPENDENT-PREFIX.json new file mode 100644 index 0000000000..03272faa33 --- /dev/null +++ b/research/multicut-kernel-composition/expected/INDEPENDENT-PREFIX.json @@ -0,0 +1,10 @@ +{ + "cohorts": 890, + "distinct_cuts": 4, + "distinct_helpers": 1903, + "non_target_identity_bits": 37299451, + "nonzero_pivot_target_entries": 60556, + "scope": "Original pinned-word response at every cohort own cut; combined emitted-word checks remain separate.", + "status": "PASS_INDEPENDENT_MULTI_CUT_FULL_F2_KERNEL_AND_IDENTITY_COLUMNS", + "target_kernel_equalities": 1566400 +} diff --git a/research/multicut-kernel-composition/expected/PLATEAU-RETIMING.json b/research/multicut-kernel-composition/expected/PLATEAU-RETIMING.json new file mode 100644 index 0000000000..0144ba0481 --- /dev/null +++ b/research/multicut-kernel-composition/expected/PLATEAU-RETIMING.json @@ -0,0 +1,1649 @@ +{ + "status": "FINITE_TRANSCRIPT_REWRITE_CHECKED_NATIVE_CHECKERS_PENDING", + "selected": [ + { + "component": 690237, + "gates": [ + 657861, + 657862 + ], + "old_frame": 147267, + "new_frame": 214110, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4174, + 4204, + 17546 + ], + "boundaries": [ + [ + 4174, + -1, + 146572 + ], + [ + 4174, + 1, + 0 + ], + [ + 4204, + -1, + 146573 + ], + [ + 4204, + 1, + 147855 + ], + [ + 17546, + -1, + 200244 + ], + [ + 17546, + 1, + 147856 + ] + ] + }, + { + "component": 690241, + "gates": [ + 657865, + 657866 + ], + "old_frame": 147270, + "new_frame": 214113, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4160, + 4190, + 17547 + ], + "boundaries": [ + [ + 4160, + -1, + 146575 + ], + [ + 4160, + 1, + 0 + ], + [ + 4190, + -1, + 146576 + ], + [ + 4190, + 1, + 147857 + ], + [ + 17547, + -1, + 200244 + ], + [ + 17547, + 1, + 147858 + ] + ] + }, + { + "component": 690273, + "gates": [ + 657897, + 657898 + ], + "old_frame": 147298, + "new_frame": 214125, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4581, + 4731, + 17555 + ], + "boundaries": [ + [ + 4581, + -1, + 146599 + ], + [ + 4581, + 1, + 0 + ], + [ + 4731, + -1, + 146600 + ], + [ + 4731, + 1, + 147869 + ], + [ + 17555, + -1, + 200212 + ], + [ + 17555, + 1, + 147870 + ] + ] + }, + { + "component": 690297, + "gates": [ + 657921, + 657922 + ], + "old_frame": 147316, + "new_frame": 214132, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4671, + 4821, + 17561 + ], + "boundaries": [ + [ + 4671, + -1, + 146617 + ], + [ + 4671, + 1, + 0 + ], + [ + 4821, + -1, + 146618 + ], + [ + 4821, + 1, + 147880 + ], + [ + 17561, + -1, + 200209 + ], + [ + 17561, + 1, + 99313 + ] + ] + }, + { + "component": 690301, + "gates": [ + 657925, + 657926 + ], + "old_frame": 147319, + "new_frame": 214135, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4697, + 4847, + 17562 + ], + "boundaries": [ + [ + 4697, + -1, + 146620 + ], + [ + 4697, + 1, + 0 + ], + [ + 4847, + -1, + 146621 + ], + [ + 4847, + 1, + 50572 + ], + [ + 17562, + -1, + 200206 + ], + [ + 17562, + 1, + 147882 + ] + ] + }, + { + "component": 690393, + "gates": [ + 658017, + 658018 + ], + "old_frame": 147384, + "new_frame": 214171, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 6590, + 6620, + 17585 + ], + "boundaries": [ + [ + 6590, + -1, + 146689 + ], + [ + 6590, + 1, + 0 + ], + [ + 6620, + -1, + 146690 + ], + [ + 6620, + 1, + 147913 + ], + [ + 17585, + -1, + 200243 + ], + [ + 17585, + 1, + 95725 + ] + ] + }, + { + "component": 690629, + "gates": [ + 658253, + 658254 + ], + "old_frame": 147558, + "new_frame": 214239, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 1.396447433867337, + "delta": { + "11": 1, + "4": 1, + "9": -1, + "6": -1 + }, + "roles": [ + 8621, + 9071, + 17644 + ], + "boundaries": [ + [ + 8621, + -1, + 146866 + ], + [ + 8621, + 1, + 0 + ], + [ + 9071, + -1, + 146867 + ], + [ + 9071, + 1, + 148016 + ], + [ + 17644, + -1, + 200142 + ], + [ + 17644, + 1, + 148017 + ] + ] + }, + { + "component": 690633, + "gates": [ + 658257, + 658258 + ], + "old_frame": 147561, + "new_frame": 214242, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 1.396447433867337, + "delta": { + "11": 1, + "4": 1, + "9": -1, + "6": -1 + }, + "roles": [ + 8624, + 9074, + 17645 + ], + "boundaries": [ + [ + 8624, + -1, + 146869 + ], + [ + 8624, + 1, + 0 + ], + [ + 9074, + -1, + 146870 + ], + [ + 9074, + 1, + 39948 + ], + [ + 17645, + -1, + 200143 + ], + [ + 17645, + 1, + 148018 + ] + ] + }, + { + "component": 686536, + "gates": [ + 654160, + 654161 + ], + "old_frame": 148108, + "new_frame": 212428, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16349, + 16352, + 17076 + ], + "boundaries": [ + [ + 16349, + -1, + 121035 + ], + [ + 16349, + 1, + 146441 + ], + [ + 16352, + -1, + 121031 + ], + [ + 16352, + 1, + 0 + ], + [ + 17076, + -1, + 200178 + ], + [ + 17076, + 1, + 147173 + ] + ] + }, + { + "component": 686574, + "gates": [ + 654198, + 654199 + ], + "old_frame": 148109, + "new_frame": 212447, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16386, + 16389, + 17084 + ], + "boundaries": [ + [ + 16386, + -1, + 144181 + ], + [ + 16386, + 1, + 146462 + ], + [ + 16389, + -1, + 120957 + ], + [ + 16389, + 1, + 0 + ], + [ + 17084, + -1, + 200178 + ], + [ + 17084, + 1, + 113581 + ] + ] + }, + { + "component": 686612, + "gates": [ + 654236, + 654237 + ], + "old_frame": 148110, + "new_frame": 212465, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16423, + 16426, + 17092 + ], + "boundaries": [ + [ + 16423, + -1, + 120887 + ], + [ + 16423, + 1, + 146487 + ], + [ + 16426, + -1, + 144207 + ], + [ + 16426, + 1, + 0 + ], + [ + 17092, + -1, + 200178 + ], + [ + 17092, + 1, + 147203 + ] + ] + }, + { + "component": 686650, + "gates": [ + 654274, + 654275 + ], + "old_frame": 145558, + "new_frame": 212484, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16460, + 16463, + 17100 + ], + "boundaries": [ + [ + 16460, + -1, + 144229 + ], + [ + 16460, + 1, + 146511 + ], + [ + 16463, + -1, + 144231 + ], + [ + 16463, + 1, + 0 + ], + [ + 17100, + -1, + 200178 + ], + [ + 17100, + 1, + 113497 + ] + ] + }, + { + "component": 688024, + "gates": [ + 655648, + 655649 + ], + "old_frame": 146399, + "new_frame": 213061, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.9744269498501694, + "delta": { + "6": 2, + "11": 1, + "1": 1, + "5": 1, + "7": -2, + "3": -1, + "10": -1, + "2": -1 + }, + "roles": [ + 13802, + 15414, + 17223 + ], + "boundaries": [ + [ + 13802, + -1, + 144640 + ], + [ + 13802, + 1, + 113682 + ], + [ + 15414, + -1, + 142093 + ], + [ + 15414, + 1, + 0 + ], + [ + 17223, + -1, + 200176 + ], + [ + 17223, + 1, + 112446 + ] + ] + }, + { + "component": 688076, + "gates": [ + 655700, + 655701 + ], + "old_frame": 146421, + "new_frame": 213082, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.9744269498501694, + "delta": { + "6": 2, + "11": 1, + "1": 1, + "5": 1, + "7": -2, + "3": -1, + "10": -1, + "2": -1 + }, + "roles": [ + 13804, + 15417, + 17231 + ], + "boundaries": [ + [ + 13804, + -1, + 142110 + ], + [ + 13804, + 1, + 147164 + ], + [ + 15417, + -1, + 142109 + ], + [ + 15417, + 1, + 0 + ], + [ + 17231, + -1, + 200176 + ], + [ + 17231, + 1, + 112413 + ] + ] + }, + { + "component": 690473, + "gates": [ + 658097, + 658098 + ], + "old_frame": 147446, + "new_frame": 214199, + "old_dim": 15, + "new_dim": 14, + "entropy_gain": 0.6616910818484598, + "delta": { + "3": 3, + "10": 1, + "2": -1, + "4": -2, + "9": -1 + }, + "roles": [ + 7820, + 7850, + 17605 + ], + "boundaries": [ + [ + 7820, + -1, + 146749 + ], + [ + 7820, + 1, + 0 + ], + [ + 7850, + -1, + 146750 + ], + [ + 7850, + 1, + 147949 + ], + [ + 17605, + -1, + 200149 + ], + [ + 17605, + 1, + 147950 + ] + ] + }, + { + "component": 690525, + "gates": [ + 658149, + 658150 + ], + "old_frame": 147484, + "new_frame": 214214, + "old_dim": 15, + "new_dim": 14, + "entropy_gain": 0.6616910818484598, + "delta": { + "3": 3, + "10": 1, + "2": -1, + "4": -2, + "9": -1 + }, + "roles": [ + 8464, + 8494, + 17618 + ], + "boundaries": [ + [ + 8464, + -1, + 146788 + ], + [ + 8464, + 1, + 0 + ], + [ + 8494, + -1, + 146789 + ], + [ + 8494, + 1, + 147975 + ], + [ + 17618, + -1, + 200148 + ], + [ + 17618, + 1, + 147976 + ] + ] + }, + { + "component": 690529, + "gates": [ + 658153, + 658154 + ], + "old_frame": 147487, + "new_frame": 214217, + "old_dim": 15, + "new_dim": 14, + "entropy_gain": 0.6616910818484598, + "delta": { + "3": 3, + "10": 1, + "2": -1, + "4": -2, + "9": -1 + }, + "roles": [ + 8450, + 8480, + 17619 + ], + "boundaries": [ + [ + 8450, + -1, + 146791 + ], + [ + 8450, + 1, + 0 + ], + [ + 8480, + -1, + 146792 + ], + [ + 8480, + 1, + 147977 + ], + [ + 17619, + -1, + 200149 + ], + [ + 17619, + 1, + 147978 + ] + ] + }, + { + "component": 687920, + "gates": [ + 655544, + 655545 + ], + "old_frame": 146361, + "new_frame": 213015, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.6375911690600589, + "delta": { + "6": 2, + "8": 1, + "1": 1, + "5": 1, + "7": -3, + "3": -1, + "2": -1 + }, + "roles": [ + 13782, + 15354, + 17208 + ], + "boundaries": [ + [ + 13782, + -1, + 144612 + ], + [ + 13782, + 1, + 147124 + ], + [ + 15354, + -1, + 144611 + ], + [ + 15354, + 1, + 29810 + ], + [ + 17208, + -1, + 200176 + ], + [ + 17208, + 1, + 112512 + ] + ] + }, + { + "component": 687972, + "gates": [ + 655596, + 655597 + ], + "old_frame": 146382, + "new_frame": 213039, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.6375911690600589, + "delta": { + "6": 2, + "8": 1, + "1": 1, + "5": 1, + "7": -3, + "3": -1, + "2": -1 + }, + "roles": [ + 13784, + 15357, + 17216 + ], + "boundaries": [ + [ + 13784, + -1, + 144628 + ], + [ + 13784, + 1, + 113724 + ], + [ + 15357, + -1, + 144627 + ], + [ + 15357, + 1, + 29813 + ], + [ + 17216, + -1, + 200176 + ], + [ + 17216, + 1, + 112479 + ] + ] + }, + { + "component": 690009, + "gates": [ + 657633 + ], + "old_frame": 147198, + "new_frame": 214022, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16409, + 17518 + ], + "boundaries": [ + [ + 16409, + -1, + 59106 + ], + [ + 16409, + 1, + 58638 + ], + [ + 17518, + -1, + 200162 + ], + [ + 17518, + 1, + 58499 + ] + ] + }, + { + "component": 690063, + "gates": [ + 657687 + ], + "old_frame": 147212, + "new_frame": 214044, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16446, + 17524 + ], + "boundaries": [ + [ + 16446, + -1, + 57512 + ], + [ + 16446, + 1, + 57044 + ], + [ + 17524, + -1, + 200162 + ], + [ + 17524, + 1, + 56905 + ] + ] + }, + { + "component": 690117, + "gates": [ + 657741 + ], + "old_frame": 147225, + "new_frame": 214064, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16483, + 17530 + ], + "boundaries": [ + [ + 16483, + -1, + 55923 + ], + [ + 16483, + 1, + 55452 + ], + [ + 17530, + -1, + 200162 + ], + [ + 17530, + 1, + 55313 + ] + ] + }, + { + "component": 690171, + "gates": [ + 657795 + ], + "old_frame": 147242, + "new_frame": 214085, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16520, + 17536 + ], + "boundaries": [ + [ + 16520, + -1, + 54329 + ], + [ + 16520, + 1, + 147837 + ], + [ + 17536, + -1, + 200162 + ], + [ + 17536, + 1, + 147840 + ] + ] + }, + { + "component": 690637, + "gates": [ + 658261, + 658262 + ], + "old_frame": 147564, + "new_frame": 214244, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 0.2115082082543296, + "delta": { + "11": 1, + "8": 1, + "9": -1, + "10": -1 + }, + "roles": [ + 8651, + 9101, + 17646 + ], + "boundaries": [ + [ + 8651, + -1, + 146872 + ], + [ + 8651, + 1, + 0 + ], + [ + 9101, + -1, + 146873 + ], + [ + 9101, + 1, + 39820 + ], + [ + 17646, + -1, + 200230 + ], + [ + 17646, + 1, + 148020 + ] + ] + }, + { + "component": 690669, + "gates": [ + 658293, + 658294 + ], + "old_frame": 147588, + "new_frame": 214253, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 0.2115082082543296, + "delta": { + "11": 1, + "8": 1, + "9": -1, + "10": -1 + }, + "roles": [ + 8771, + 9221, + 17654 + ], + "boundaries": [ + [ + 8771, + -1, + 146896 + ], + [ + 8771, + 1, + 0 + ], + [ + 9221, + -1, + 146897 + ], + [ + 9221, + 1, + 148032 + ], + [ + 17654, + -1, + 200233 + ], + [ + 17654, + 1, + 94468 + ] + ] + }, + { + "component": 690673, + "gates": [ + 658297, + 658298 + ], + "old_frame": 147591, + "new_frame": 214256, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 0.2115082082543296, + "delta": { + "11": 1, + "8": 1, + "9": -1, + "10": -1 + }, + "roles": [ + 8774, + 9224, + 17655 + ], + "boundaries": [ + [ + 8774, + -1, + 146899 + ], + [ + 8774, + 1, + 0 + ], + [ + 9224, + -1, + 146900 + ], + [ + 9224, + 1, + 148033 + ], + [ + 17655, + -1, + 200234 + ], + [ + 17655, + 1, + 148034 + ] + ] + }, + { + "component": 687881, + "gates": [ + 655505, + 655522, + 655523 + ], + "old_frame": 68426, + "new_frame": 212999, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.07412559299066857, + "delta": { + "6": 1, + "3": 2, + "4": 1, + "8": 1, + "5": -1, + "1": 1, + "7": -2, + "2": -3 + }, + "roles": [ + 11160, + 11288, + 16753, + 17204 + ], + "boundaries": [ + [ + 11160, + -1, + 144597 + ], + [ + 11160, + 1, + 113801 + ], + [ + 11288, + -1, + 145386 + ], + [ + 11288, + 1, + 29898 + ], + [ + 16753, + -1, + 68652 + ], + [ + 16753, + 1, + 113763 + ], + [ + 17204, + -1, + 200177 + ], + [ + 17204, + 1, + 68196 + ] + ] + }, + { + "component": 687933, + "gates": [ + 655557, + 655574, + 655575 + ], + "old_frame": 146367, + "new_frame": 213023, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.07412559299066857, + "delta": { + "6": 1, + "3": 2, + "4": 1, + "8": 1, + "5": -1, + "1": 1, + "7": -2, + "2": -3 + }, + "roles": [ + 11161, + 11289, + 16758, + 17211 + ], + "boundaries": [ + [ + 11161, + -1, + 144614 + ], + [ + 11161, + 1, + 147127 + ], + [ + 11289, + -1, + 145411 + ], + [ + 11289, + 1, + 29901 + ], + [ + 16758, + -1, + 67081 + ], + [ + 16758, + 1, + 147140 + ], + [ + 17211, + -1, + 200177 + ], + [ + 17211, + 1, + 66625 + ] + ] + }, + { + "component": 687985, + "gates": [ + 655609, + 655626, + 655627 + ], + "old_frame": 146386, + "new_frame": 213047, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.07412559299066857, + "delta": { + "6": 1, + "3": 2, + "4": 1, + "8": 1, + "5": -1, + "1": 1, + "7": -2, + "2": -3 + }, + "roles": [ + 11162, + 11290, + 16763, + 17219 + ], + "boundaries": [ + [ + 11162, + -1, + 144630 + ], + [ + 11162, + 1, + 113717 + ], + [ + 11290, + -1, + 145434 + ], + [ + 11290, + 1, + 29964 + ], + [ + 16763, + -1, + 65510 + ], + [ + 16763, + 1, + 113679 + ], + [ + 17219, + -1, + 200177 + ], + [ + 17219, + 1, + 65052 + ] + ] + } + ], + "delta": { + "1": 15, + "2": -26, + "4": -7, + "3": 19, + "5": -3, + "6": 21, + "11": 13, + "12": -4, + "8": 8, + "9": -14, + "10": -2, + "13": 4, + "7": -24 + }, + "unchanged_scalar_copy_projection": "4bbf61229b8a3f4aafac1891d9150479b8e91b20ef5306944fad502fb24c965c", + "input_sha256": "a6d793d7fd4f902436fd64c1d0e9467adc93844e058578994400d30fcf4171c3", + "output_sha256": "a1cf58b3b0d23775a07fd0ebc276c40a9c52a41a2ea285b935d062d314699d7b", + "paid_calls": 96444, + "rank_mass": 432458 +} diff --git a/research/multicut-kernel-composition/expected/PLATEAU-SOURCE-SPANS.json b/research/multicut-kernel-composition/expected/PLATEAU-SOURCE-SPANS.json new file mode 100644 index 0000000000..9a08c8b02f --- /dev/null +++ b/research/multicut-kernel-composition/expected/PLATEAU-SOURCE-SPANS.json @@ -0,0 +1,66 @@ +{ + "status": "PASS_EXACT_INTEGER_SOURCE_SPANS_FOR_CHANGED_PLATEAU_GATES", + "changed_gates": 57, + "checked_operand_source_inclusions": 1728, + "distinct_inclusions": 984, + "spans": { + "654160": 16, + "654161": 16, + "654198": 16, + "654199": 16, + "654236": 16, + "654237": 16, + "654274": 16, + "654275": 16, + "655505": 32, + "655522": 56, + "655523": 56, + "655544": 20, + "655545": 20, + "655557": 32, + "655574": 56, + "655575": 56, + "655596": 20, + "655597": 20, + "655609": 32, + "655626": 56, + "655627": 56, + "655648": 20, + "655649": 20, + "655700": 20, + "655701": 20, + "657633": 84, + "657687": 84, + "657741": 84, + "657795": 84, + "657861": 24, + "657862": 24, + "657865": 24, + "657866": 24, + "657897": 24, + "657898": 24, + "657921": 24, + "657922": 24, + "657925": 24, + "657926": 24, + "658017": 24, + "658018": 24, + "658097": 24, + "658098": 24, + "658149": 24, + "658150": 24, + "658153": 24, + "658154": 24, + "658253": 24, + "658254": 24, + "658257": 24, + "658258": 24, + "658261": 24, + "658262": 24, + "658293": 24, + "658294": 24, + "658297": 24, + "658298": 24 + }, + "seconds": 1.4293630123138428 +} diff --git a/research/multicut-kernel-composition/expected/TARGET-PREFIX.json b/research/multicut-kernel-composition/expected/TARGET-PREFIX.json new file mode 100644 index 0000000000..2d312e85e1 --- /dev/null +++ b/research/multicut-kernel-composition/expected/TARGET-PREFIX.json @@ -0,0 +1,34 @@ +{ + "status": "PASS_EXACT_F2_TARGET_PREFIX_COMPRESSION", + "selected_groups": 209, + "targets": 836, + "cut_record": 669360, + "deleted_prefix_adds": 1057, + "inserted_setup_restore_adds": 1254, + "literal_prefix_dependencies_checked": true, + "remaining_payload_additions": 728586, + "local_histogram_delta": { + "1": -209, + "2": -7, + "3": -1, + "8": -1, + "12": -1, + "17": -1, + "18": -7, + "20": -200, + "21": 209 + }, + "rank_mass": 432458, + "paid_calls": 96226, + "both_reflected_ledgers": true, + "unchanged_all_input_output_frames": true, + "unchanged_copy_lifetimes": true, + "forward_and_inverse_all_columns": true, + "negative_control": "omitted target-prefix setup rejected", + "unique_required_frame_pairs": 100506, + "setup_category": 30, + "restore_category": 31, + "input_record_sha256": "a1cf58b3b0d23775a07fd0ebc276c40a9c52a41a2ea285b935d062d314699d7b", + "output_record_sha256": "eaff3c9828ed15e1c24998331f0d3b482efc9984dd86bf5dbcefca0c76e717c6", + "selection_sha256": "7ed2069ef80d0fc3405a30bc1ed7338ff98d506a7cd7c2d82815e0b27645acb1" +} diff --git a/research/multicut-kernel-composition/inputs/249-DONOR-OWNERSHIP.json.gz b/research/multicut-kernel-composition/inputs/249-DONOR-OWNERSHIP.json.gz new file mode 100644 index 0000000000..c548bf0b91 Binary files /dev/null and b/research/multicut-kernel-composition/inputs/249-DONOR-OWNERSHIP.json.gz differ diff --git a/research/multicut-kernel-composition/inputs/249-records.bin.gz b/research/multicut-kernel-composition/inputs/249-records.bin.gz new file mode 100644 index 0000000000..d858906d06 Binary files /dev/null and b/research/multicut-kernel-composition/inputs/249-records.bin.gz differ diff --git a/research/multicut-kernel-composition/inputs/249-states.json.gz b/research/multicut-kernel-composition/inputs/249-states.json.gz new file mode 100644 index 0000000000..1cd7d04cb1 Binary files /dev/null and b/research/multicut-kernel-composition/inputs/249-states.json.gz differ diff --git a/research/multicut-kernel-composition/inputs/SNAPSHOTS.json b/research/multicut-kernel-composition/inputs/SNAPSHOTS.json new file mode 100644 index 0000000000..35204388ca --- /dev/null +++ b/research/multicut-kernel-composition/inputs/SNAPSHOTS.json @@ -0,0 +1,6 @@ +{ + "249-records.bin": "2e0bc2a5c54cf8caf26fa30a1a2949702d842f620b28023ca2ba59140ecbed1a", + "249-states.json": "b04e5e4adede52f3f9008c4db471b475b5ff588c18934aca186a89646bd16a4f", + "frames.json": "1f9e0cdf9a9b1123aa524f69fb73a07af0d588ac162e34810e4c57064dea2b12", + "249-DONOR-OWNERSHIP.json": "ab96904508a21ddd0c3d4d779974e5dcfdb1f19a3938ade647724cc317c3270b" +} diff --git a/research/multicut-kernel-composition/inputs/candidates.json.gz b/research/multicut-kernel-composition/inputs/candidates.json.gz new file mode 100644 index 0000000000..762bbc7cf2 Binary files /dev/null and b/research/multicut-kernel-composition/inputs/candidates.json.gz differ diff --git a/research/multicut-kernel-composition/inputs/descent-selection.json b/research/multicut-kernel-composition/inputs/descent-selection.json new file mode 100644 index 0000000000..70ad7bc083 --- /dev/null +++ b/research/multicut-kernel-composition/inputs/descent-selection.json @@ -0,0 +1,7754 @@ +{ + "status": "FROZEN_CONCAVE_DESCENT_FRAME_SELECTION", + "input_record_sha256": "4458dce8218c9a0e0e55f494e33b2ad320649e953d108470ba0c8ac077660505", + "input_record_count": 828137, + "selected_gate_count": 25, + "expected_local_histogram_delta": { + "2": -2, + "4": 24, + "5": -48, + "6": 25, + "11": -1, + "13": 2, + "17": -1 + }, + "expected_rank_mass": 432458, + "expected_removed_calls": 1, + "expected_scalar_additions": 728389, + "entries": [ + { + "gate": 642629, + "scalar": [ + 15705, + 3760, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642631, + "scalar": [ + 15741, + 3775, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642633, + "scalar": [ + 15775, + 10152, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642635, + "scalar": [ + 15811, + 10153, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642637, + "scalar": [ + 15847, + 10188, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642639, + "scalar": [ + 15883, + 10189, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642641, + "scalar": [ + 15919, + 10220, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642643, + "scalar": [ + 15954, + 10221, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642645, + "scalar": [ + 15990, + 10248, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642647, + "scalar": [ + 16026, + 10249, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642649, + "scalar": [ + 16062, + 10272, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642651, + "scalar": [ + 16098, + 10273, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642653, + "scalar": [ + 16135, + 10292, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642655, + "scalar": [ + 16171, + 10293, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642657, + "scalar": [ + 16208, + 10308, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642659, + "scalar": [ + 16245, + 10309, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642661, + "scalar": [ + 16282, + 10320, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642663, + "scalar": [ + 16319, + 10321, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642665, + "scalar": [ + 16356, + 10328, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642667, + "scalar": [ + 16393, + 10329, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642669, + "scalar": [ + 16430, + 11104, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642671, + "scalar": [ + 16467, + 11105, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642673, + "scalar": [ + 16504, + 11106, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ] + ], + "new_basis": [ + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 0 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642675, + "scalar": [ + 16541, + 11107, + 1, + 12 + ], + "old_dimension": 5, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ] + ], + "new_basis": [ + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 1 + ] + ], + "new_dimension": 6 + }, + { + "gate": 642700, + "scalar": [ + 1784, + 378, + -1, + 10 + ], + "old_dimension": 4, + "old_basis": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0 + ] + ], + "new_basis": [ + [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 5, + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 2, + 2 + ] + ], + "new_dimension": 15 + } + ], + "provenance": "Local descent on the concave paid-rank objective sum r*ln(120/r), restricted to frames already on the operands' chains; the same twenty-five forward-gate frame changes are valid on the cohort-rewritten transcript because the selected registers are disjoint from every pivot and donor. Prepared by Rohan Arun with Anthropic Claude assistance." +} diff --git a/research/multicut-kernel-composition/inputs/frames.json.gz b/research/multicut-kernel-composition/inputs/frames.json.gz new file mode 100644 index 0000000000..7b3bad6915 Binary files /dev/null and b/research/multicut-kernel-composition/inputs/frames.json.gz differ diff --git a/research/multicut-kernel-composition/inputs/plateau-selection.json b/research/multicut-kernel-composition/inputs/plateau-selection.json new file mode 100644 index 0000000000..3bcec1a3c8 --- /dev/null +++ b/research/multicut-kernel-composition/inputs/plateau-selection.json @@ -0,0 +1,20637 @@ +{ + "status": "FROZEN_CONNECTED_PLATEAU_WITNESS", + "input_sha256": "a6d793d7fd4f902436fd64c1d0e9467adc93844e058578994400d30fcf4171c3", + "candidates": [ + { + "component": 690237, + "gates": [ + 657861, + 657862 + ], + "old_frame": 147267, + "new_frame": 214110, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4174, + 4204, + 17546 + ], + "boundaries": [ + [ + 4174, + -1, + 146572 + ], + [ + 4174, + 1, + 0 + ], + [ + 4204, + -1, + 146573 + ], + [ + 4204, + 1, + 147855 + ], + [ + 17546, + -1, + 200244 + ], + [ + 17546, + 1, + 147856 + ] + ] + }, + { + "component": 690241, + "gates": [ + 657865, + 657866 + ], + "old_frame": 147270, + "new_frame": 214113, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4160, + 4190, + 17547 + ], + "boundaries": [ + [ + 4160, + -1, + 146575 + ], + [ + 4160, + 1, + 0 + ], + [ + 4190, + -1, + 146576 + ], + [ + 4190, + 1, + 147857 + ], + [ + 17547, + -1, + 200244 + ], + [ + 17547, + 1, + 147858 + ] + ] + }, + { + "component": 690273, + "gates": [ + 657897, + 657898 + ], + "old_frame": 147298, + "new_frame": 214125, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4581, + 4731, + 17555 + ], + "boundaries": [ + [ + 4581, + -1, + 146599 + ], + [ + 4581, + 1, + 0 + ], + [ + 4731, + -1, + 146600 + ], + [ + 4731, + 1, + 147869 + ], + [ + 17555, + -1, + 200212 + ], + [ + 17555, + 1, + 147870 + ] + ] + }, + { + "component": 690297, + "gates": [ + 657921, + 657922 + ], + "old_frame": 147316, + "new_frame": 214132, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4671, + 4821, + 17561 + ], + "boundaries": [ + [ + 4671, + -1, + 146617 + ], + [ + 4671, + 1, + 0 + ], + [ + 4821, + -1, + 146618 + ], + [ + 4821, + 1, + 147880 + ], + [ + 17561, + -1, + 200209 + ], + [ + 17561, + 1, + 99313 + ] + ] + }, + { + "component": 690301, + "gates": [ + 657925, + 657926 + ], + "old_frame": 147319, + "new_frame": 214135, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 4697, + 4847, + 17562 + ], + "boundaries": [ + [ + 4697, + -1, + 146620 + ], + [ + 4697, + 1, + 0 + ], + [ + 4847, + -1, + 146621 + ], + [ + 4847, + 1, + 50572 + ], + [ + 17562, + -1, + 200206 + ], + [ + 17562, + 1, + 147882 + ] + ] + }, + { + "component": 690393, + "gates": [ + 658017, + 658018 + ], + "old_frame": 147384, + "new_frame": 214171, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 2.442943721396432, + "delta": { + "2": 1, + "11": 1, + "4": -1, + "9": -1 + }, + "roles": [ + 6590, + 6620, + 17585 + ], + "boundaries": [ + [ + 6590, + -1, + 146689 + ], + [ + 6590, + 1, + 0 + ], + [ + 6620, + -1, + 146690 + ], + [ + 6620, + 1, + 147913 + ], + [ + 17585, + -1, + 200243 + ], + [ + 17585, + 1, + 95725 + ] + ] + }, + { + "component": 690629, + "gates": [ + 658253, + 658254 + ], + "old_frame": 147558, + "new_frame": 214239, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 1.396447433867337, + "delta": { + "11": 1, + "4": 1, + "9": -1, + "6": -1 + }, + "roles": [ + 8621, + 9071, + 17644 + ], + "boundaries": [ + [ + 8621, + -1, + 146866 + ], + [ + 8621, + 1, + 0 + ], + [ + 9071, + -1, + 146867 + ], + [ + 9071, + 1, + 148016 + ], + [ + 17644, + -1, + 200142 + ], + [ + 17644, + 1, + 148017 + ] + ] + }, + { + "component": 690633, + "gates": [ + 658257, + 658258 + ], + "old_frame": 147561, + "new_frame": 214242, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 1.396447433867337, + "delta": { + "11": 1, + "4": 1, + "9": -1, + "6": -1 + }, + "roles": [ + 8624, + 9074, + 17645 + ], + "boundaries": [ + [ + 8624, + -1, + 146869 + ], + [ + 8624, + 1, + 0 + ], + [ + 9074, + -1, + 146870 + ], + [ + 9074, + 1, + 39948 + ], + [ + 17645, + -1, + 200143 + ], + [ + 17645, + 1, + 148018 + ] + ] + }, + { + "component": 686536, + "gates": [ + 654160, + 654161 + ], + "old_frame": 148108, + "new_frame": 212428, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16349, + 16352, + 17076 + ], + "boundaries": [ + [ + 16349, + -1, + 121035 + ], + [ + 16349, + 1, + 146441 + ], + [ + 16352, + -1, + 121031 + ], + [ + 16352, + 1, + 0 + ], + [ + 17076, + -1, + 200178 + ], + [ + 17076, + 1, + 147173 + ] + ] + }, + { + "component": 686574, + "gates": [ + 654198, + 654199 + ], + "old_frame": 148109, + "new_frame": 212447, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16386, + 16389, + 17084 + ], + "boundaries": [ + [ + 16386, + -1, + 144181 + ], + [ + 16386, + 1, + 146462 + ], + [ + 16389, + -1, + 120957 + ], + [ + 16389, + 1, + 0 + ], + [ + 17084, + -1, + 200178 + ], + [ + 17084, + 1, + 113581 + ] + ] + }, + { + "component": 686612, + "gates": [ + 654236, + 654237 + ], + "old_frame": 148110, + "new_frame": 212465, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16423, + 16426, + 17092 + ], + "boundaries": [ + [ + 16423, + -1, + 120887 + ], + [ + 16423, + 1, + 146487 + ], + [ + 16426, + -1, + 144207 + ], + [ + 16426, + 1, + 0 + ], + [ + 17092, + -1, + 200178 + ], + [ + 17092, + 1, + 147203 + ] + ] + }, + { + "component": 686650, + "gates": [ + 654274, + 654275 + ], + "old_frame": 145558, + "new_frame": 212484, + "old_dim": 12, + "new_dim": 11, + "entropy_gain": 1.0104487904686295, + "delta": { + "6": 3, + "3": 1, + "13": 1, + "1": 1, + "7": -2, + "2": -2, + "12": -1, + "5": -1 + }, + "roles": [ + 16460, + 16463, + 17100 + ], + "boundaries": [ + [ + 16460, + -1, + 144229 + ], + [ + 16460, + 1, + 146511 + ], + [ + 16463, + -1, + 144231 + ], + [ + 16463, + 1, + 0 + ], + [ + 17100, + -1, + 200178 + ], + [ + 17100, + 1, + 113497 + ] + ] + }, + { + "component": 688024, + "gates": [ + 655648, + 655649 + ], + "old_frame": 146399, + "new_frame": 213061, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.9744269498501694, + "delta": { + "6": 2, + "11": 1, + "1": 1, + "5": 1, + "7": -2, + "3": -1, + "10": -1, + "2": -1 + }, + "roles": [ + 13802, + 15414, + 17223 + ], + "boundaries": [ + [ + 13802, + -1, + 144640 + ], + [ + 13802, + 1, + 113682 + ], + [ + 15414, + -1, + 142093 + ], + [ + 15414, + 1, + 0 + ], + [ + 17223, + -1, + 200176 + ], + [ + 17223, + 1, + 112446 + ] + ] + }, + { + "component": 688076, + "gates": [ + 655700, + 655701 + ], + "old_frame": 146421, + "new_frame": 213082, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.9744269498501694, + "delta": { + "6": 2, + "11": 1, + "1": 1, + "5": 1, + "7": -2, + "3": -1, + "10": -1, + "2": -1 + }, + "roles": [ + 13804, + 15417, + 17231 + ], + "boundaries": [ + [ + 13804, + -1, + 142110 + ], + [ + 13804, + 1, + 147164 + ], + [ + 15417, + -1, + 142109 + ], + [ + 15417, + 1, + 0 + ], + [ + 17231, + -1, + 200176 + ], + [ + 17231, + 1, + 112413 + ] + ] + }, + { + "component": 690473, + "gates": [ + 658097, + 658098 + ], + "old_frame": 147446, + "new_frame": 214199, + "old_dim": 15, + "new_dim": 14, + "entropy_gain": 0.6616910818484598, + "delta": { + "3": 3, + "10": 1, + "2": -1, + "4": -2, + "9": -1 + }, + "roles": [ + 7820, + 7850, + 17605 + ], + "boundaries": [ + [ + 7820, + -1, + 146749 + ], + [ + 7820, + 1, + 0 + ], + [ + 7850, + -1, + 146750 + ], + [ + 7850, + 1, + 147949 + ], + [ + 17605, + -1, + 200149 + ], + [ + 17605, + 1, + 147950 + ] + ] + }, + { + "component": 690525, + "gates": [ + 658149, + 658150 + ], + "old_frame": 147484, + "new_frame": 214214, + "old_dim": 15, + "new_dim": 14, + "entropy_gain": 0.6616910818484598, + "delta": { + "3": 3, + "10": 1, + "2": -1, + "4": -2, + "9": -1 + }, + "roles": [ + 8464, + 8494, + 17618 + ], + "boundaries": [ + [ + 8464, + -1, + 146788 + ], + [ + 8464, + 1, + 0 + ], + [ + 8494, + -1, + 146789 + ], + [ + 8494, + 1, + 147975 + ], + [ + 17618, + -1, + 200148 + ], + [ + 17618, + 1, + 147976 + ] + ] + }, + { + "component": 690529, + "gates": [ + 658153, + 658154 + ], + "old_frame": 147487, + "new_frame": 214217, + "old_dim": 15, + "new_dim": 14, + "entropy_gain": 0.6616910818484598, + "delta": { + "3": 3, + "10": 1, + "2": -1, + "4": -2, + "9": -1 + }, + "roles": [ + 8450, + 8480, + 17619 + ], + "boundaries": [ + [ + 8450, + -1, + 146791 + ], + [ + 8450, + 1, + 0 + ], + [ + 8480, + -1, + 146792 + ], + [ + 8480, + 1, + 147977 + ], + [ + 17619, + -1, + 200149 + ], + [ + 17619, + 1, + 147978 + ] + ] + }, + { + "component": 687920, + "gates": [ + 655544, + 655545 + ], + "old_frame": 146361, + "new_frame": 213015, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.6375911690600589, + "delta": { + "6": 2, + "8": 1, + "1": 1, + "5": 1, + "7": -3, + "3": -1, + "2": -1 + }, + "roles": [ + 13782, + 15354, + 17208 + ], + "boundaries": [ + [ + 13782, + -1, + 144612 + ], + [ + 13782, + 1, + 147124 + ], + [ + 15354, + -1, + 144611 + ], + [ + 15354, + 1, + 29810 + ], + [ + 17208, + -1, + 200176 + ], + [ + 17208, + 1, + 112512 + ] + ] + }, + { + "component": 687972, + "gates": [ + 655596, + 655597 + ], + "old_frame": 146382, + "new_frame": 213039, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.6375911690600589, + "delta": { + "6": 2, + "8": 1, + "1": 1, + "5": 1, + "7": -3, + "3": -1, + "2": -1 + }, + "roles": [ + 13784, + 15357, + 17216 + ], + "boundaries": [ + [ + 13784, + -1, + 144628 + ], + [ + 13784, + 1, + 113724 + ], + [ + 15357, + -1, + 144627 + ], + [ + 15357, + 1, + 29813 + ], + [ + 17216, + -1, + 200176 + ], + [ + 17216, + 1, + 112479 + ] + ] + }, + { + "component": 690009, + "gates": [ + 657633 + ], + "old_frame": 147198, + "new_frame": 214022, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16409, + 17518 + ], + "boundaries": [ + [ + 16409, + -1, + 59106 + ], + [ + 16409, + 1, + 58638 + ], + [ + 17518, + -1, + 200162 + ], + [ + 17518, + 1, + 58499 + ] + ] + }, + { + "component": 690063, + "gates": [ + 657687 + ], + "old_frame": 147212, + "new_frame": 214044, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16446, + 17524 + ], + "boundaries": [ + [ + 16446, + -1, + 57512 + ], + [ + 16446, + 1, + 57044 + ], + [ + 17524, + -1, + 200162 + ], + [ + 17524, + 1, + 56905 + ] + ] + }, + { + "component": 690117, + "gates": [ + 657741 + ], + "old_frame": 147225, + "new_frame": 214064, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16483, + 17530 + ], + "boundaries": [ + [ + 16483, + -1, + 55923 + ], + [ + 16483, + 1, + 55452 + ], + [ + 17530, + -1, + 200162 + ], + [ + 17530, + 1, + 55313 + ] + ] + }, + { + "component": 690171, + "gates": [ + 657795 + ], + "old_frame": 147242, + "new_frame": 214085, + "old_dim": 17, + "new_dim": 16, + "entropy_gain": 0.5232481437645404, + "delta": { + "2": -2, + "3": 1, + "1": 1 + }, + "roles": [ + 16520, + 17536 + ], + "boundaries": [ + [ + 16520, + -1, + 54329 + ], + [ + 16520, + 1, + 147837 + ], + [ + 17536, + -1, + 200162 + ], + [ + 17536, + 1, + 147840 + ] + ] + }, + { + "component": 690637, + "gates": [ + 658261, + 658262 + ], + "old_frame": 147564, + "new_frame": 214244, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 0.2115082082543296, + "delta": { + "11": 1, + "8": 1, + "9": -1, + "10": -1 + }, + "roles": [ + 8651, + 9101, + 17646 + ], + "boundaries": [ + [ + 8651, + -1, + 146872 + ], + [ + 8651, + 1, + 0 + ], + [ + 9101, + -1, + 146873 + ], + [ + 9101, + 1, + 39820 + ], + [ + 17646, + -1, + 200230 + ], + [ + 17646, + 1, + 148020 + ] + ] + }, + { + "component": 690669, + "gates": [ + 658293, + 658294 + ], + "old_frame": 147588, + "new_frame": 214253, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 0.2115082082543296, + "delta": { + "11": 1, + "8": 1, + "9": -1, + "10": -1 + }, + "roles": [ + 8771, + 9221, + 17654 + ], + "boundaries": [ + [ + 8771, + -1, + 146896 + ], + [ + 8771, + 1, + 0 + ], + [ + 9221, + -1, + 146897 + ], + [ + 9221, + 1, + 148032 + ], + [ + 17654, + -1, + 200233 + ], + [ + 17654, + 1, + 94468 + ] + ] + }, + { + "component": 690673, + "gates": [ + 658297, + 658298 + ], + "old_frame": 147591, + "new_frame": 214256, + "old_dim": 15, + "new_dim": 13, + "entropy_gain": 0.2115082082543296, + "delta": { + "11": 1, + "8": 1, + "9": -1, + "10": -1 + }, + "roles": [ + 8774, + 9224, + 17655 + ], + "boundaries": [ + [ + 8774, + -1, + 146899 + ], + [ + 8774, + 1, + 0 + ], + [ + 9224, + -1, + 146900 + ], + [ + 9224, + 1, + 148033 + ], + [ + 17655, + -1, + 200234 + ], + [ + 17655, + 1, + 148034 + ] + ] + }, + { + "component": 687881, + "gates": [ + 655505, + 655522, + 655523 + ], + "old_frame": 68426, + "new_frame": 212999, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.07412559299066857, + "delta": { + "6": 1, + "3": 2, + "4": 1, + "8": 1, + "5": -1, + "1": 1, + "7": -2, + "2": -3 + }, + "roles": [ + 11160, + 11288, + 16753, + 17204 + ], + "boundaries": [ + [ + 11160, + -1, + 144597 + ], + [ + 11160, + 1, + 113801 + ], + [ + 11288, + -1, + 145386 + ], + [ + 11288, + 1, + 29898 + ], + [ + 16753, + -1, + 68652 + ], + [ + 16753, + 1, + 113763 + ], + [ + 17204, + -1, + 200177 + ], + [ + 17204, + 1, + 68196 + ] + ] + }, + { + "component": 687933, + "gates": [ + 655557, + 655574, + 655575 + ], + "old_frame": 146367, + "new_frame": 213023, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.07412559299066857, + "delta": { + "6": 1, + "3": 2, + "4": 1, + "8": 1, + "5": -1, + "1": 1, + "7": -2, + "2": -3 + }, + "roles": [ + 11161, + 11289, + 16758, + 17211 + ], + "boundaries": [ + [ + 11161, + -1, + 144614 + ], + [ + 11161, + 1, + 147127 + ], + [ + 11289, + -1, + 145411 + ], + [ + 11289, + 1, + 29901 + ], + [ + 16758, + -1, + 67081 + ], + [ + 16758, + 1, + 147140 + ], + [ + 17211, + -1, + 200177 + ], + [ + 17211, + 1, + 66625 + ] + ] + }, + { + "component": 687985, + "gates": [ + 655609, + 655626, + 655627 + ], + "old_frame": 146386, + "new_frame": 213047, + "old_dim": 14, + "new_dim": 13, + "entropy_gain": 0.07412559299066857, + "delta": { + "6": 1, + "3": 2, + "4": 1, + "8": 1, + "5": -1, + "1": 1, + "7": -2, + "2": -3 + }, + "roles": [ + 11162, + 11290, + 16763, + 17219 + ], + "boundaries": [ + [ + 11162, + -1, + 144630 + ], + [ + 11162, + 1, + 113717 + ], + [ + 11290, + -1, + 145434 + ], + [ + 11290, + 1, + 29964 + ], + [ + 16763, + -1, + 65510 + ], + [ + 16763, + 1, + 113679 + ], + [ + 17219, + -1, + 200177 + ], + [ + 17219, + 1, + 65052 + ] + ] + } + ], + "newframes": { + "212428": { + "B": [ + [ + 1, + 1, + -5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 7, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 1, + 1 + ] + ], + "dim": 11 + }, + "212447": { + "B": [ + [ + 1, + 1, + -5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 7, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 1, + 1 + ] + ], + "dim": 11 + }, + "212465": { + "B": [ + [ + 1, + 1, + -5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 7, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 1, + 1 + ] + ], + "dim": 11 + }, + "212484": { + "B": [ + [ + 1, + 1, + -5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 7, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 1, + 1 + ] + ], + "dim": 11 + }, + "212999": { + "B": [ + [ + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 5, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 13 + }, + "213015": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -2, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "213023": { + "B": [ + [ + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 5, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 13 + }, + "213039": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + -2, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "213047": { + "B": [ + [ + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 5, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 13 + }, + "213061": { + "B": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 3, + 1, + 1, + 4, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + -2, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "213082": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + -2, + 0, + 0, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "214022": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 0, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 16 + }, + "214044": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 0, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 16 + }, + "214064": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 16 + }, + "214085": { + "B": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "A": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 0, + 0, + -2 + ] + ], + "dim": 16 + }, + "214110": { + "B": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ] + ], + "dim": 13 + }, + "214113": { + "B": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ] + ], + "dim": 13 + }, + "214125": { + "B": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ] + ], + "dim": 13 + }, + "214132": { + "B": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + -1, + -1 + ] + ], + "dim": 13 + }, + "214135": { + "B": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ] + ], + "A": [ + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ] + ], + "dim": 13 + }, + "214171": { + "B": [ + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ] + ], + "dim": 13 + }, + "214199": { + "B": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 5, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 14 + }, + "214214": { + "B": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 14 + }, + "214217": { + "B": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 14 + }, + "214239": { + "B": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "214242": { + "B": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "214244": { + "B": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "214253": { + "B": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + }, + "214256": { + "B": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1 + ] + ], + "A": [ + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "dim": 13 + } + }, + "expected_delta": { + "1": 15, + "2": -26, + "4": -7, + "3": 19, + "5": -3, + "6": 21, + "11": 13, + "12": -4, + "8": 8, + "9": -14, + "10": -2, + "13": 4, + "7": -24 + }, + "baseline_input_sha256": "43a73a445f7eefa76f227d31e8195899a4c537ff8a561867f4a87c56fe8f0da6", + "core_binding": { + "status": "PASS_FULL_UNCHANGED_CORE_EVENT_ALIGNMENT", + "events_compared": 103751, + "bindings": [ + { + "baseline_gate": 657861, + "candidate_gate": 657861, + "event": [ + 1, + 4204, + 4174, + 1, + 147267, + 12 + ] + }, + { + "baseline_gate": 657862, + "candidate_gate": 657862, + "event": [ + 1, + 17546, + 4204, + 1, + 147267, + 12 + ] + }, + { + "baseline_gate": 657865, + "candidate_gate": 657865, + "event": [ + 1, + 4190, + 4160, + 1, + 147270, + 12 + ] + }, + { + "baseline_gate": 657866, + "candidate_gate": 657866, + "event": [ + 1, + 17547, + 4190, + 1, + 147270, + 12 + ] + }, + { + "baseline_gate": 657897, + "candidate_gate": 657897, + "event": [ + 1, + 4731, + 4581, + 1, + 147298, + 12 + ] + }, + { + "baseline_gate": 657898, + "candidate_gate": 657898, + "event": [ + 1, + 17555, + 4731, + 1, + 147298, + 12 + ] + }, + { + "baseline_gate": 657921, + "candidate_gate": 657921, + "event": [ + 1, + 4821, + 4671, + 1, + 147316, + 12 + ] + }, + { + "baseline_gate": 657922, + "candidate_gate": 657922, + "event": [ + 1, + 17561, + 4821, + 1, + 147316, + 12 + ] + }, + { + "baseline_gate": 657925, + "candidate_gate": 657925, + "event": [ + 1, + 4847, + 4697, + 1, + 147319, + 12 + ] + }, + { + "baseline_gate": 657926, + "candidate_gate": 657926, + "event": [ + 1, + 17562, + 4847, + 1, + 147319, + 12 + ] + }, + { + "baseline_gate": 658017, + "candidate_gate": 658017, + "event": [ + 1, + 6620, + 6590, + 1, + 147384, + 12 + ] + }, + { + "baseline_gate": 658018, + "candidate_gate": 658018, + "event": [ + 1, + 17585, + 6620, + 1, + 147384, + 12 + ] + }, + { + "baseline_gate": 658253, + "candidate_gate": 658253, + "event": [ + 1, + 9071, + 8621, + 1, + 147558, + 12 + ] + }, + { + "baseline_gate": 658254, + "candidate_gate": 658254, + "event": [ + 1, + 17644, + 9071, + 1, + 147558, + 12 + ] + }, + { + "baseline_gate": 658257, + "candidate_gate": 658257, + "event": [ + 1, + 9074, + 8624, + 1, + 147561, + 12 + ] + }, + { + "baseline_gate": 658258, + "candidate_gate": 658258, + "event": [ + 1, + 17645, + 9074, + 1, + 147561, + 12 + ] + }, + { + "baseline_gate": 654160, + "candidate_gate": 654160, + "event": [ + 1, + 16349, + 16352, + 1, + 148108, + 12 + ] + }, + { + "baseline_gate": 654161, + "candidate_gate": 654161, + "event": [ + 1, + 17076, + 16349, + 1, + 148108, + 12 + ] + }, + { + "baseline_gate": 654198, + "candidate_gate": 654198, + "event": [ + 1, + 16386, + 16389, + 1, + 148109, + 12 + ] + }, + { + "baseline_gate": 654199, + "candidate_gate": 654199, + "event": [ + 1, + 17084, + 16386, + 1, + 148109, + 12 + ] + }, + { + "baseline_gate": 654236, + "candidate_gate": 654236, + "event": [ + 1, + 16423, + 16426, + 1, + 148110, + 12 + ] + }, + { + "baseline_gate": 654237, + "candidate_gate": 654237, + "event": [ + 1, + 17092, + 16423, + 1, + 148110, + 12 + ] + }, + { + "baseline_gate": 654274, + "candidate_gate": 654274, + "event": [ + 1, + 16460, + 16463, + 1, + 145558, + 12 + ] + }, + { + "baseline_gate": 654275, + "candidate_gate": 654275, + "event": [ + 1, + 17100, + 16460, + 1, + 145558, + 12 + ] + }, + { + "baseline_gate": 655648, + "candidate_gate": 655648, + "event": [ + 1, + 13802, + 15414, + 1, + 146399, + 12 + ] + }, + { + "baseline_gate": 655649, + "candidate_gate": 655649, + "event": [ + 1, + 17223, + 13802, + 1, + 146399, + 12 + ] + }, + { + "baseline_gate": 655700, + "candidate_gate": 655700, + "event": [ + 1, + 13804, + 15417, + 1, + 146421, + 12 + ] + }, + { + "baseline_gate": 655701, + "candidate_gate": 655701, + "event": [ + 1, + 17231, + 13804, + 1, + 146421, + 12 + ] + }, + { + "baseline_gate": 658097, + "candidate_gate": 658097, + "event": [ + 1, + 7850, + 7820, + 1, + 147446, + 12 + ] + }, + { + "baseline_gate": 658098, + "candidate_gate": 658098, + "event": [ + 1, + 17605, + 7850, + 1, + 147446, + 12 + ] + }, + { + "baseline_gate": 658149, + "candidate_gate": 658149, + "event": [ + 1, + 8494, + 8464, + 1, + 147484, + 12 + ] + }, + { + "baseline_gate": 658150, + "candidate_gate": 658150, + "event": [ + 1, + 17618, + 8494, + 1, + 147484, + 12 + ] + }, + { + "baseline_gate": 658153, + "candidate_gate": 658153, + "event": [ + 1, + 8480, + 8450, + 1, + 147487, + 12 + ] + }, + { + "baseline_gate": 658154, + "candidate_gate": 658154, + "event": [ + 1, + 17619, + 8480, + 1, + 147487, + 12 + ] + }, + { + "baseline_gate": 655544, + "candidate_gate": 655544, + "event": [ + 1, + 13782, + 15354, + 1, + 146361, + 12 + ] + }, + { + "baseline_gate": 655545, + "candidate_gate": 655545, + "event": [ + 1, + 17208, + 13782, + 1, + 146361, + 12 + ] + }, + { + "baseline_gate": 655596, + "candidate_gate": 655596, + "event": [ + 1, + 13784, + 15357, + 1, + 146382, + 12 + ] + }, + { + "baseline_gate": 655597, + "candidate_gate": 655597, + "event": [ + 1, + 17216, + 13784, + 1, + 146382, + 12 + ] + }, + { + "baseline_gate": 657633, + "candidate_gate": 657633, + "event": [ + 1, + 17518, + 16409, + 1, + 147198, + 12 + ] + }, + { + "baseline_gate": 657687, + "candidate_gate": 657687, + "event": [ + 1, + 17524, + 16446, + 1, + 147212, + 12 + ] + }, + { + "baseline_gate": 657741, + "candidate_gate": 657741, + "event": [ + 1, + 17530, + 16483, + 1, + 147225, + 12 + ] + }, + { + "baseline_gate": 657795, + "candidate_gate": 657795, + "event": [ + 1, + 17536, + 16520, + 1, + 147242, + 12 + ] + }, + { + "baseline_gate": 658261, + "candidate_gate": 658261, + "event": [ + 1, + 9101, + 8651, + 1, + 147564, + 12 + ] + }, + { + "baseline_gate": 658262, + "candidate_gate": 658262, + "event": [ + 1, + 17646, + 9101, + 1, + 147564, + 12 + ] + }, + { + "baseline_gate": 658293, + "candidate_gate": 658293, + "event": [ + 1, + 9221, + 8771, + 1, + 147588, + 12 + ] + }, + { + "baseline_gate": 658294, + "candidate_gate": 658294, + "event": [ + 1, + 17654, + 9221, + 1, + 147588, + 12 + ] + }, + { + "baseline_gate": 658297, + "candidate_gate": 658297, + "event": [ + 1, + 9224, + 8774, + 1, + 147591, + 12 + ] + }, + { + "baseline_gate": 658298, + "candidate_gate": 658298, + "event": [ + 1, + 17655, + 9224, + 1, + 147591, + 12 + ] + }, + { + "baseline_gate": 655505, + "candidate_gate": 655505, + "event": [ + 1, + 11160, + 11288, + 1, + 68426, + 12 + ] + }, + { + "baseline_gate": 655522, + "candidate_gate": 655522, + "event": [ + 1, + 16753, + 11160, + 1, + 68426, + 12 + ] + }, + { + "baseline_gate": 655523, + "candidate_gate": 655523, + "event": [ + 1, + 17204, + 16753, + 1, + 68426, + 12 + ] + }, + { + "baseline_gate": 655557, + "candidate_gate": 655557, + "event": [ + 1, + 11161, + 11289, + 1, + 146367, + 12 + ] + }, + { + "baseline_gate": 655574, + "candidate_gate": 655574, + "event": [ + 1, + 16758, + 11161, + 1, + 146367, + 12 + ] + }, + { + "baseline_gate": 655575, + "candidate_gate": 655575, + "event": [ + 1, + 17211, + 16758, + 1, + 146367, + 12 + ] + }, + { + "baseline_gate": 655609, + "candidate_gate": 655609, + "event": [ + 1, + 11162, + 11290, + 1, + 146386, + 12 + ] + }, + { + "baseline_gate": 655626, + "candidate_gate": 655626, + "event": [ + 1, + 16763, + 11162, + 1, + 146386, + 12 + ] + }, + { + "baseline_gate": 655627, + "candidate_gate": 655627, + "event": [ + 1, + 17219, + 16763, + 1, + 146386, + 12 + ] + } + ] + } +} diff --git a/research/multicut-kernel-composition/inputs/sandwich-selection.json b/research/multicut-kernel-composition/inputs/sandwich-selection.json new file mode 100644 index 0000000000..1595941814 --- /dev/null +++ b/research/multicut-kernel-composition/inputs/sandwich-selection.json @@ -0,0 +1,139 @@ +{ + "status": "FROZEN_CLEANUP_SANDWICH_HELPERS", + "input_record_sha256": "eaff3c9828ed15e1c24998331f0d3b482efc9984dd86bf5dbcefca0c76e717c6", + "helpers": [ + 10123, + 10131, + 10135, + 10151, + 10155, + 10159, + 10163, + 10171, + 10175, + 10179, + 10183, + 10191, + 10195, + 10199, + 10215, + 10231, + 10243, + 10255, + 10259, + 10263, + 10267, + 10271, + 10283, + 10291, + 10299, + 10303, + 10307, + 10311, + 10319, + 10323, + 10327, + 10339, + 10343, + 10351, + 10355, + 10359, + 10371, + 10375, + 10383, + 10387, + 10407, + 10415, + 10427, + 10439, + 10443, + 10447, + 10459, + 10463, + 10467, + 10471, + 10479, + 10491, + 10495, + 10511, + 10519, + 10527, + 10531, + 10543, + 10555, + 10559, + 10575, + 10583, + 10595, + 10603, + 10611, + 10619, + 10623, + 10643, + 10647, + 10651, + 10659, + 10663, + 10667, + 10671, + 10675, + 10679, + 10687, + 10691, + 10695, + 10703, + 10707, + 10715, + 10723, + 10727, + 10735, + 10739, + 10743, + 10747, + 10751, + 10759, + 10763, + 10767, + 10771, + 10779, + 10783, + 10791, + 10795, + 10803, + 10807, + 10811, + 10815, + 10823, + 10831, + 10835, + 10843, + 10851, + 10855, + 10863, + 10871, + 10875, + 10883, + 10887, + 10891, + 10895, + 10899, + 10911, + 10915, + 10919, + 10927, + 10943, + 10955, + 10959, + 10963, + 10967, + 10971, + 10987 + ], + "expected_local_histogram_delta": { + "1": 252, + "20": 126, + "21": -252 + }, + "scanned_sandwich_helpers": 128, + "provenance": "Helpers with exactly the three-gate cleanup sandwich t += a; a += b; t += a after the first kernel cut, rescanned on this package word after the target-prefix stage (PR271 mechanism, evmckinney9); the largest subset with k = 0 mod 3 (each helper-replica frees 20 bank width units, 800k in total, which must tile width-120 banks), taken in helper-id order. Each joint cut frame of (a, b) is four-dimensional and nondegenerate for 9I - J." +} diff --git a/research/multicut-kernel-composition/inputs/target-selection.json b/research/multicut-kernel-composition/inputs/target-selection.json new file mode 100644 index 0000000000..2b1b6cace0 --- /dev/null +++ b/research/multicut-kernel-composition/inputs/target-selection.json @@ -0,0 +1,4840 @@ +{ + "status": "FROZEN_TARGET_PREFIX_GROUPS", + "cut_record": 669360, + "input_record_sha256": "a1cf58b3b0d23775a07fd0ebc276c40a9c52a41a2ea285b935d062d314699d7b", + "input_record_count": 828136, + "selected_groups": 209, + "groups": [ + { + "dependent": 12, + "retained": [ + 13, + 14, + 15 + ], + "close_after_record": 675825, + "frame": 25215, + "close_rank": 21 + }, + { + "dependent": 20, + "retained": [ + 21, + 22, + 23 + ], + "close_after_record": 675815, + "frame": 25237, + "close_rank": 21 + }, + { + "dependent": 28, + "retained": [ + 29, + 30, + 31 + ], + "close_after_record": 675809, + "frame": 25259, + "close_rank": 21 + }, + { + "dependent": 36, + "retained": [ + 37, + 38, + 39 + ], + "close_after_record": 675821, + "frame": 25281, + "close_rank": 21 + }, + { + "dependent": 52, + "retained": [ + 53, + 54, + 55 + ], + "close_after_record": 675823, + "frame": 25325, + "close_rank": 21 + }, + { + "dependent": 60, + "retained": [ + 61, + 62, + 63 + ], + "close_after_record": 675817, + "frame": 25347, + "close_rank": 21 + }, + { + "dependent": 68, + "retained": [ + 69, + 70, + 71 + ], + "close_after_record": 675827, + "frame": 25369, + "close_rank": 21 + }, + { + "dependent": 84, + "retained": [ + 85, + 86, + 87 + ], + "close_after_record": 675777, + "frame": 25413, + "close_rank": 21 + }, + { + "dependent": 92, + "retained": [ + 93, + 94, + 95 + ], + "close_after_record": 675759, + "frame": 25435, + "close_rank": 21 + }, + { + "dependent": 100, + "retained": [ + 101, + 102, + 103 + ], + "close_after_record": 675751, + "frame": 25457, + "close_rank": 21 + }, + { + "dependent": 108, + "retained": [ + 109, + 110, + 111 + ], + "close_after_record": 675773, + "frame": 25479, + "close_rank": 21 + }, + { + "dependent": 116, + "retained": [ + 117, + 118, + 119 + ], + "close_after_record": 675755, + "frame": 25501, + "close_rank": 21 + }, + { + "dependent": 124, + "retained": [ + 125, + 126, + 127 + ], + "close_after_record": 675775, + "frame": 25523, + "close_rank": 21 + }, + { + "dependent": 132, + "retained": [ + 133, + 134, + 135 + ], + "close_after_record": 675763, + "frame": 25545, + "close_rank": 21 + }, + { + "dependent": 140, + "retained": [ + 141, + 142, + 143 + ], + "close_after_record": 675785, + "frame": 25567, + "close_rank": 21 + }, + { + "dependent": 148, + "retained": [ + 149, + 150, + 151 + ], + "close_after_record": 675757, + "frame": 25589, + "close_rank": 21 + }, + { + "dependent": 156, + "retained": [ + 157, + 158, + 159 + ], + "close_after_record": 675675, + "frame": 25611, + "close_rank": 21 + }, + { + "dependent": 164, + "retained": [ + 165, + 166, + 167 + ], + "close_after_record": 675659, + "frame": 25633, + "close_rank": 21 + }, + { + "dependent": 172, + "retained": [ + 173, + 174, + 175 + ], + "close_after_record": 675691, + "frame": 25655, + "close_rank": 21 + }, + { + "dependent": 180, + "retained": [ + 181, + 182, + 183 + ], + "close_after_record": 675665, + "frame": 25677, + "close_rank": 21 + }, + { + "dependent": 188, + "retained": [ + 189, + 190, + 191 + ], + "close_after_record": 675693, + "frame": 25699, + "close_rank": 21 + }, + { + "dependent": 196, + "retained": [ + 197, + 198, + 199 + ], + "close_after_record": 675681, + "frame": 25721, + "close_rank": 21 + }, + { + "dependent": 204, + "retained": [ + 205, + 206, + 207 + ], + "close_after_record": 675709, + "frame": 25743, + "close_rank": 21 + }, + { + "dependent": 212, + "retained": [ + 213, + 214, + 215 + ], + "close_after_record": 675667, + "frame": 25765, + "close_rank": 21 + }, + { + "dependent": 228, + "retained": [ + 229, + 230, + 231 + ], + "close_after_record": 675577, + "frame": 25809, + "close_rank": 21 + }, + { + "dependent": 236, + "retained": [ + 237, + 238, + 239 + ], + "close_after_record": 675543, + "frame": 25831, + "close_rank": 21 + }, + { + "dependent": 244, + "retained": [ + 245, + 246, + 247 + ], + "close_after_record": 675581, + "frame": 25853, + "close_rank": 21 + }, + { + "dependent": 252, + "retained": [ + 253, + 254, + 255 + ], + "close_after_record": 675567, + "frame": 25875, + "close_rank": 21 + }, + { + "dependent": 260, + "retained": [ + 261, + 262, + 263 + ], + "close_after_record": 675601, + "frame": 25897, + "close_rank": 21 + }, + { + "dependent": 268, + "retained": [ + 269, + 270, + 271 + ], + "close_after_record": 675545, + "frame": 25919, + "close_rank": 21 + }, + { + "dependent": 276, + "retained": [ + 277, + 278, + 279 + ], + "close_after_record": 675439, + "frame": 25941, + "close_rank": 21 + }, + { + "dependent": 284, + "retained": [ + 285, + 286, + 287 + ], + "close_after_record": 675397, + "frame": 25963, + "close_rank": 21 + }, + { + "dependent": 292, + "retained": [ + 293, + 294, + 295 + ], + "close_after_record": 675443, + "frame": 25985, + "close_rank": 21 + }, + { + "dependent": 300, + "retained": [ + 301, + 302, + 303 + ], + "close_after_record": 675427, + "frame": 26007, + "close_rank": 21 + }, + { + "dependent": 308, + "retained": [ + 309, + 310, + 311 + ], + "close_after_record": 675465, + "frame": 26029, + "close_rank": 21 + }, + { + "dependent": 316, + "retained": [ + 317, + 318, + 319 + ], + "close_after_record": 675399, + "frame": 26051, + "close_rank": 21 + }, + { + "dependent": 324, + "retained": [ + 325, + 326, + 327 + ], + "close_after_record": 675229, + "frame": 26073, + "close_rank": 21 + }, + { + "dependent": 332, + "retained": [ + 333, + 334, + 335 + ], + "close_after_record": 675279, + "frame": 26095, + "close_rank": 21 + }, + { + "dependent": 340, + "retained": [ + 341, + 342, + 343 + ], + "close_after_record": 675261, + "frame": 26117, + "close_rank": 21 + }, + { + "dependent": 348, + "retained": [ + 349, + 350, + 351 + ], + "close_after_record": 675303, + "frame": 26139, + "close_rank": 21 + }, + { + "dependent": 356, + "retained": [ + 357, + 358, + 359 + ], + "close_after_record": 675231, + "frame": 26161, + "close_rank": 21 + }, + { + "dependent": 364, + "retained": [ + 365, + 366, + 367 + ], + "close_after_record": 675097, + "frame": 26183, + "close_rank": 21 + }, + { + "dependent": 372, + "retained": [ + 373, + 374, + 375 + ], + "close_after_record": 675077, + "frame": 26205, + "close_rank": 21 + }, + { + "dependent": 380, + "retained": [ + 381, + 382, + 383 + ], + "close_after_record": 675123, + "frame": 26227, + "close_rank": 21 + }, + { + "dependent": 388, + "retained": [ + 389, + 390, + 391 + ], + "close_after_record": 675043, + "frame": 26249, + "close_rank": 21 + }, + { + "dependent": 396, + "retained": [ + 397, + 398, + 399 + ], + "close_after_record": 674877, + "frame": 26271, + "close_rank": 21 + }, + { + "dependent": 404, + "retained": [ + 405, + 406, + 407 + ], + "close_after_record": 674927, + "frame": 26293, + "close_rank": 21 + }, + { + "dependent": 412, + "retained": [ + 413, + 414, + 415 + ], + "close_after_record": 674841, + "frame": 26315, + "close_rank": 21 + }, + { + "dependent": 420, + "retained": [ + 421, + 422, + 423 + ], + "close_after_record": 674717, + "frame": 26337, + "close_rank": 21 + }, + { + "dependent": 428, + "retained": [ + 429, + 430, + 431 + ], + "close_after_record": 674629, + "frame": 26359, + "close_rank": 21 + }, + { + "dependent": 436, + "retained": [ + 437, + 438, + 439 + ], + "close_after_record": 674413, + "frame": 26381, + "close_rank": 21 + }, + { + "dependent": 444, + "retained": [ + 445, + 446, + 447 + ], + "close_after_record": 675779, + "frame": 26403, + "close_rank": 21 + }, + { + "dependent": 452, + "retained": [ + 453, + 454, + 455 + ], + "close_after_record": 675761, + "frame": 26425, + "close_rank": 21 + }, + { + "dependent": 460, + "retained": [ + 461, + 462, + 463 + ], + "close_after_record": 675765, + "frame": 26447, + "close_rank": 21 + }, + { + "dependent": 468, + "retained": [ + 469, + 470, + 471 + ], + "close_after_record": 675771, + "frame": 26469, + "close_rank": 21 + }, + { + "dependent": 476, + "retained": [ + 477, + 478, + 479 + ], + "close_after_record": 675783, + "frame": 26491, + "close_rank": 21 + }, + { + "dependent": 484, + "retained": [ + 485, + 486, + 487 + ], + "close_after_record": 675767, + "frame": 26513, + "close_rank": 21 + }, + { + "dependent": 492, + "retained": [ + 493, + 494, + 495 + ], + "close_after_record": 675753, + "frame": 26535, + "close_rank": 21 + }, + { + "dependent": 500, + "retained": [ + 501, + 502, + 503 + ], + "close_after_record": 675781, + "frame": 26557, + "close_rank": 21 + }, + { + "dependent": 508, + "retained": [ + 509, + 510, + 511 + ], + "close_after_record": 675787, + "frame": 26579, + "close_rank": 21 + }, + { + "dependent": 516, + "retained": [ + 517, + 518, + 519 + ], + "close_after_record": 675679, + "frame": 26601, + "close_rank": 21 + }, + { + "dependent": 524, + "retained": [ + 525, + 526, + 527 + ], + "close_after_record": 675683, + "frame": 26623, + "close_rank": 21 + }, + { + "dependent": 532, + "retained": [ + 533, + 534, + 535 + ], + "close_after_record": 675689, + "frame": 26645, + "close_rank": 21 + }, + { + "dependent": 540, + "retained": [ + 541, + 542, + 543 + ], + "close_after_record": 675707, + "frame": 26667, + "close_rank": 21 + }, + { + "dependent": 548, + "retained": [ + 549, + 550, + 551 + ], + "close_after_record": 675685, + "frame": 26689, + "close_rank": 21 + }, + { + "dependent": 556, + "retained": [ + 557, + 558, + 559 + ], + "close_after_record": 675661, + "frame": 26711, + "close_rank": 21 + }, + { + "dependent": 564, + "retained": [ + 565, + 566, + 567 + ], + "close_after_record": 675703, + "frame": 26733, + "close_rank": 21 + }, + { + "dependent": 572, + "retained": [ + 573, + 574, + 575 + ], + "close_after_record": 675711, + "frame": 26755, + "close_rank": 21 + }, + { + "dependent": 580, + "retained": [ + 581, + 582, + 583 + ], + "close_after_record": 675569, + "frame": 26777, + "close_rank": 21 + }, + { + "dependent": 588, + "retained": [ + 589, + 590, + 591 + ], + "close_after_record": 675575, + "frame": 26799, + "close_rank": 21 + }, + { + "dependent": 596, + "retained": [ + 597, + 598, + 599 + ], + "close_after_record": 675595, + "frame": 26821, + "close_rank": 21 + }, + { + "dependent": 604, + "retained": [ + 605, + 606, + 607 + ], + "close_after_record": 675571, + "frame": 26843, + "close_rank": 21 + }, + { + "dependent": 612, + "retained": [ + 613, + 614, + 615 + ], + "close_after_record": 675539, + "frame": 26865, + "close_rank": 21 + }, + { + "dependent": 620, + "retained": [ + 621, + 622, + 623 + ], + "close_after_record": 675591, + "frame": 26887, + "close_rank": 21 + }, + { + "dependent": 628, + "retained": [ + 629, + 630, + 631 + ], + "close_after_record": 675603, + "frame": 26909, + "close_rank": 21 + }, + { + "dependent": 636, + "retained": [ + 637, + 638, + 639 + ], + "close_after_record": 675437, + "frame": 26931, + "close_rank": 21 + }, + { + "dependent": 644, + "retained": [ + 645, + 646, + 647 + ], + "close_after_record": 675457, + "frame": 26953, + "close_rank": 21 + }, + { + "dependent": 652, + "retained": [ + 653, + 654, + 655 + ], + "close_after_record": 675433, + "frame": 26975, + "close_rank": 21 + }, + { + "dependent": 660, + "retained": [ + 661, + 662, + 663 + ], + "close_after_record": 675391, + "frame": 26997, + "close_rank": 21 + }, + { + "dependent": 668, + "retained": [ + 669, + 670, + 671 + ], + "close_after_record": 675453, + "frame": 27019, + "close_rank": 21 + }, + { + "dependent": 676, + "retained": [ + 677, + 678, + 679 + ], + "close_after_record": 675467, + "frame": 27041, + "close_rank": 21 + }, + { + "dependent": 684, + "retained": [ + 685, + 686, + 687 + ], + "close_after_record": 675295, + "frame": 27063, + "close_rank": 21 + }, + { + "dependent": 692, + "retained": [ + 693, + 694, + 695 + ], + "close_after_record": 675269, + "frame": 27085, + "close_rank": 21 + }, + { + "dependent": 700, + "retained": [ + 701, + 702, + 703 + ], + "close_after_record": 675221, + "frame": 27107, + "close_rank": 21 + }, + { + "dependent": 708, + "retained": [ + 709, + 710, + 711 + ], + "close_after_record": 675291, + "frame": 27129, + "close_rank": 21 + }, + { + "dependent": 716, + "retained": [ + 717, + 718, + 719 + ], + "close_after_record": 675305, + "frame": 27151, + "close_rank": 21 + }, + { + "dependent": 724, + "retained": [ + 725, + 726, + 727 + ], + "close_after_record": 675085, + "frame": 27173, + "close_rank": 21 + }, + { + "dependent": 732, + "retained": [ + 733, + 734, + 735 + ], + "close_after_record": 675033, + "frame": 27195, + "close_rank": 21 + }, + { + "dependent": 740, + "retained": [ + 741, + 742, + 743 + ], + "close_after_record": 675111, + "frame": 27217, + "close_rank": 21 + }, + { + "dependent": 748, + "retained": [ + 749, + 750, + 751 + ], + "close_after_record": 675125, + "frame": 27239, + "close_rank": 21 + }, + { + "dependent": 756, + "retained": [ + 757, + 758, + 759 + ], + "close_after_record": 674831, + "frame": 27261, + "close_rank": 21 + }, + { + "dependent": 764, + "retained": [ + 765, + 766, + 767 + ], + "close_after_record": 674915, + "frame": 27283, + "close_rank": 21 + }, + { + "dependent": 772, + "retained": [ + 773, + 774, + 775 + ], + "close_after_record": 674929, + "frame": 27305, + "close_rank": 21 + }, + { + "dependent": 780, + "retained": [ + 781, + 782, + 783 + ], + "close_after_record": 674705, + "frame": 27327, + "close_rank": 21 + }, + { + "dependent": 788, + "retained": [ + 789, + 790, + 791 + ], + "close_after_record": 674721, + "frame": 27349, + "close_rank": 21 + }, + { + "dependent": 796, + "retained": [ + 797, + 798, + 799 + ], + "close_after_record": 674505, + "frame": 27371, + "close_rank": 21 + }, + { + "dependent": 804, + "retained": [ + 805, + 806, + 807 + ], + "close_after_record": 675705, + "frame": 27393, + "close_rank": 21 + }, + { + "dependent": 812, + "retained": [ + 813, + 814, + 815 + ], + "close_after_record": 675673, + "frame": 27415, + "close_rank": 21 + }, + { + "dependent": 820, + "retained": [ + 821, + 822, + 823 + ], + "close_after_record": 675701, + "frame": 27437, + "close_rank": 21 + }, + { + "dependent": 828, + "retained": [ + 829, + 830, + 831 + ], + "close_after_record": 675663, + "frame": 27459, + "close_rank": 21 + }, + { + "dependent": 836, + "retained": [ + 837, + 838, + 839 + ], + "close_after_record": 675669, + "frame": 27481, + "close_rank": 21 + }, + { + "dependent": 844, + "retained": [ + 845, + 846, + 847 + ], + "close_after_record": 675699, + "frame": 27503, + "close_rank": 21 + }, + { + "dependent": 852, + "retained": [ + 853, + 854, + 855 + ], + "close_after_record": 675677, + "frame": 27525, + "close_rank": 21 + }, + { + "dependent": 860, + "retained": [ + 861, + 862, + 863 + ], + "close_after_record": 675671, + "frame": 27547, + "close_rank": 21 + }, + { + "dependent": 924, + "retained": [ + 925, + 926, + 927 + ], + "close_after_record": 675451, + "frame": 27723, + "close_rank": 21 + }, + { + "dependent": 932, + "retained": [ + 933, + 934, + 935 + ], + "close_after_record": 675395, + "frame": 27745, + "close_rank": 21 + }, + { + "dependent": 940, + "retained": [ + 941, + 942, + 943 + ], + "close_after_record": 675401, + "frame": 27767, + "close_rank": 21 + }, + { + "dependent": 948, + "retained": [ + 949, + 950, + 951 + ], + "close_after_record": 675449, + "frame": 27789, + "close_rank": 21 + }, + { + "dependent": 956, + "retained": [ + 957, + 958, + 959 + ], + "close_after_record": 675421, + "frame": 27811, + "close_rank": 21 + }, + { + "dependent": 964, + "retained": [ + 965, + 966, + 967 + ], + "close_after_record": 675407, + "frame": 27833, + "close_rank": 21 + }, + { + "dependent": 972, + "retained": [ + 973, + 974, + 975 + ], + "close_after_record": 675227, + "frame": 27855, + "close_rank": 21 + }, + { + "dependent": 980, + "retained": [ + 981, + 982, + 983 + ], + "close_after_record": 675233, + "frame": 27877, + "close_rank": 21 + }, + { + "dependent": 988, + "retained": [ + 989, + 990, + 991 + ], + "close_after_record": 675285, + "frame": 27899, + "close_rank": 21 + }, + { + "dependent": 996, + "retained": [ + 997, + 998, + 999 + ], + "close_after_record": 675255, + "frame": 27921, + "close_rank": 21 + }, + { + "dependent": 1004, + "retained": [ + 1005, + 1006, + 1007 + ], + "close_after_record": 675241, + "frame": 27943, + "close_rank": 21 + }, + { + "dependent": 1012, + "retained": [ + 1013, + 1014, + 1015 + ], + "close_after_record": 675045, + "frame": 27965, + "close_rank": 21 + }, + { + "dependent": 1020, + "retained": [ + 1021, + 1022, + 1023 + ], + "close_after_record": 675105, + "frame": 27987, + "close_rank": 21 + }, + { + "dependent": 1028, + "retained": [ + 1029, + 1030, + 1031 + ], + "close_after_record": 675069, + "frame": 28009, + "close_rank": 21 + }, + { + "dependent": 1036, + "retained": [ + 1037, + 1038, + 1039 + ], + "close_after_record": 675053, + "frame": 28031, + "close_rank": 21 + }, + { + "dependent": 1044, + "retained": [ + 1045, + 1046, + 1047 + ], + "close_after_record": 674909, + "frame": 28053, + "close_rank": 21 + }, + { + "dependent": 1052, + "retained": [ + 1053, + 1054, + 1055 + ], + "close_after_record": 674869, + "frame": 28075, + "close_rank": 21 + }, + { + "dependent": 1060, + "retained": [ + 1061, + 1062, + 1063 + ], + "close_after_record": 674851, + "frame": 28097, + "close_rank": 21 + }, + { + "dependent": 1068, + "retained": [ + 1069, + 1070, + 1071 + ], + "close_after_record": 674659, + "frame": 28119, + "close_rank": 21 + }, + { + "dependent": 1076, + "retained": [ + 1077, + 1078, + 1079 + ], + "close_after_record": 674639, + "frame": 28141, + "close_rank": 21 + }, + { + "dependent": 1084, + "retained": [ + 1085, + 1086, + 1087 + ], + "close_after_record": 674423, + "frame": 28163, + "close_rank": 21 + }, + { + "dependent": 1092, + "retained": [ + 1093, + 1094, + 1095 + ], + "close_after_record": 675579, + "frame": 28185, + "close_rank": 21 + }, + { + "dependent": 1100, + "retained": [ + 1101, + 1102, + 1103 + ], + "close_after_record": 675597, + "frame": 28207, + "close_rank": 21 + }, + { + "dependent": 1108, + "retained": [ + 1109, + 1110, + 1111 + ], + "close_after_record": 675599, + "frame": 28229, + "close_rank": 21 + }, + { + "dependent": 1116, + "retained": [ + 1117, + 1118, + 1119 + ], + "close_after_record": 675563, + "frame": 28251, + "close_rank": 21 + }, + { + "dependent": 1124, + "retained": [ + 1125, + 1126, + 1127 + ], + "close_after_record": 675559, + "frame": 28273, + "close_rank": 21 + }, + { + "dependent": 1132, + "retained": [ + 1133, + 1134, + 1135 + ], + "close_after_record": 675549, + "frame": 28295, + "close_rank": 21 + }, + { + "dependent": 1140, + "retained": [ + 1141, + 1142, + 1143 + ], + "close_after_record": 675553, + "frame": 28317, + "close_rank": 21 + }, + { + "dependent": 1148, + "retained": [ + 1149, + 1150, + 1151 + ], + "close_after_record": 675461, + "frame": 28339, + "close_rank": 21 + }, + { + "dependent": 1156, + "retained": [ + 1157, + 1158, + 1159 + ], + "close_after_record": 675463, + "frame": 28361, + "close_rank": 21 + }, + { + "dependent": 1164, + "retained": [ + 1165, + 1166, + 1167 + ], + "close_after_record": 675423, + "frame": 28383, + "close_rank": 21 + }, + { + "dependent": 1172, + "retained": [ + 1173, + 1174, + 1175 + ], + "close_after_record": 675419, + "frame": 28405, + "close_rank": 21 + }, + { + "dependent": 1180, + "retained": [ + 1181, + 1182, + 1183 + ], + "close_after_record": 675403, + "frame": 28427, + "close_rank": 21 + }, + { + "dependent": 1188, + "retained": [ + 1189, + 1190, + 1191 + ], + "close_after_record": 675413, + "frame": 28449, + "close_rank": 21 + }, + { + "dependent": 1196, + "retained": [ + 1197, + 1198, + 1199 + ], + "close_after_record": 675301, + "frame": 28471, + "close_rank": 21 + }, + { + "dependent": 1204, + "retained": [ + 1205, + 1206, + 1207 + ], + "close_after_record": 675257, + "frame": 28493, + "close_rank": 21 + }, + { + "dependent": 1212, + "retained": [ + 1213, + 1214, + 1215 + ], + "close_after_record": 675253, + "frame": 28515, + "close_rank": 21 + }, + { + "dependent": 1220, + "retained": [ + 1221, + 1222, + 1223 + ], + "close_after_record": 675237, + "frame": 28537, + "close_rank": 21 + }, + { + "dependent": 1228, + "retained": [ + 1229, + 1230, + 1231 + ], + "close_after_record": 675247, + "frame": 28559, + "close_rank": 21 + }, + { + "dependent": 1236, + "retained": [ + 1237, + 1238, + 1239 + ], + "close_after_record": 675071, + "frame": 28581, + "close_rank": 21 + }, + { + "dependent": 1244, + "retained": [ + 1245, + 1246, + 1247 + ], + "close_after_record": 675067, + "frame": 28603, + "close_rank": 21 + }, + { + "dependent": 1252, + "retained": [ + 1253, + 1254, + 1255 + ], + "close_after_record": 675049, + "frame": 28625, + "close_rank": 21 + }, + { + "dependent": 1260, + "retained": [ + 1261, + 1262, + 1263 + ], + "close_after_record": 675059, + "frame": 28647, + "close_rank": 21 + }, + { + "dependent": 1268, + "retained": [ + 1269, + 1270, + 1271 + ], + "close_after_record": 674867, + "frame": 28669, + "close_rank": 21 + }, + { + "dependent": 1276, + "retained": [ + 1277, + 1278, + 1279 + ], + "close_after_record": 674847, + "frame": 28691, + "close_rank": 21 + }, + { + "dependent": 1284, + "retained": [ + 1285, + 1286, + 1287 + ], + "close_after_record": 674859, + "frame": 28713, + "close_rank": 21 + }, + { + "dependent": 1292, + "retained": [ + 1293, + 1294, + 1295 + ], + "close_after_record": 674635, + "frame": 28735, + "close_rank": 21 + }, + { + "dependent": 1300, + "retained": [ + 1301, + 1302, + 1303 + ], + "close_after_record": 674649, + "frame": 28757, + "close_rank": 21 + }, + { + "dependent": 1308, + "retained": [ + 1309, + 1310, + 1311 + ], + "close_after_record": 674433, + "frame": 28779, + "close_rank": 21 + }, + { + "dependent": 1316, + "retained": [ + 1317, + 1318, + 1319 + ], + "close_after_record": 675393, + "frame": 28801, + "close_rank": 21 + }, + { + "dependent": 1324, + "retained": [ + 1325, + 1326, + 1327 + ], + "close_after_record": 675409, + "frame": 28823, + "close_rank": 21 + }, + { + "dependent": 1332, + "retained": [ + 1333, + 1334, + 1335 + ], + "close_after_record": 675411, + "frame": 28845, + "close_rank": 21 + }, + { + "dependent": 1340, + "retained": [ + 1341, + 1342, + 1343 + ], + "close_after_record": 675405, + "frame": 28867, + "close_rank": 21 + }, + { + "dependent": 1348, + "retained": [ + 1349, + 1350, + 1351 + ], + "close_after_record": 675459, + "frame": 28889, + "close_rank": 21 + }, + { + "dependent": 1356, + "retained": [ + 1357, + 1358, + 1359 + ], + "close_after_record": 675429, + "frame": 28911, + "close_rank": 21 + }, + { + "dependent": 1364, + "retained": [ + 1365, + 1366, + 1367 + ], + "close_after_record": 675243, + "frame": 28933, + "close_rank": 21 + }, + { + "dependent": 1372, + "retained": [ + 1373, + 1374, + 1375 + ], + "close_after_record": 675245, + "frame": 28955, + "close_rank": 21 + }, + { + "dependent": 1380, + "retained": [ + 1381, + 1382, + 1383 + ], + "close_after_record": 675239, + "frame": 28977, + "close_rank": 21 + }, + { + "dependent": 1388, + "retained": [ + 1389, + 1390, + 1391 + ], + "close_after_record": 675297, + "frame": 28999, + "close_rank": 21 + }, + { + "dependent": 1396, + "retained": [ + 1397, + 1398, + 1399 + ], + "close_after_record": 675265, + "frame": 29021, + "close_rank": 21 + }, + { + "dependent": 1404, + "retained": [ + 1405, + 1406, + 1407 + ], + "close_after_record": 675057, + "frame": 29043, + "close_rank": 21 + }, + { + "dependent": 1412, + "retained": [ + 1413, + 1414, + 1415 + ], + "close_after_record": 675051, + "frame": 29065, + "close_rank": 21 + }, + { + "dependent": 1420, + "retained": [ + 1421, + 1422, + 1423 + ], + "close_after_record": 675117, + "frame": 29087, + "close_rank": 21 + }, + { + "dependent": 1428, + "retained": [ + 1429, + 1430, + 1431 + ], + "close_after_record": 675081, + "frame": 29109, + "close_rank": 21 + }, + { + "dependent": 1436, + "retained": [ + 1437, + 1438, + 1439 + ], + "close_after_record": 674849, + "frame": 29131, + "close_rank": 21 + }, + { + "dependent": 1444, + "retained": [ + 1445, + 1446, + 1447 + ], + "close_after_record": 674921, + "frame": 29153, + "close_rank": 21 + }, + { + "dependent": 1452, + "retained": [ + 1453, + 1454, + 1455 + ], + "close_after_record": 674881, + "frame": 29175, + "close_rank": 21 + }, + { + "dependent": 1460, + "retained": [ + 1461, + 1462, + 1463 + ], + "close_after_record": 674711, + "frame": 29197, + "close_rank": 21 + }, + { + "dependent": 1468, + "retained": [ + 1469, + 1470, + 1471 + ], + "close_after_record": 674671, + "frame": 29219, + "close_rank": 21 + }, + { + "dependent": 1476, + "retained": [ + 1477, + 1478, + 1479 + ], + "close_after_record": 674455, + "frame": 29241, + "close_rank": 21 + }, + { + "dependent": 1484, + "retained": [ + 1485, + 1486, + 1487 + ], + "close_after_record": 675307, + "frame": 29263, + "close_rank": 21 + }, + { + "dependent": 1492, + "retained": [ + 1493, + 1494, + 1495 + ], + "close_after_record": 675235, + "frame": 29285, + "close_rank": 21 + }, + { + "dependent": 1500, + "retained": [ + 1501, + 1502, + 1503 + ], + "close_after_record": 675223, + "frame": 29307, + "close_rank": 21 + }, + { + "dependent": 1508, + "retained": [ + 1509, + 1510, + 1511 + ], + "close_after_record": 675263, + "frame": 29329, + "close_rank": 21 + }, + { + "dependent": 1516, + "retained": [ + 1517, + 1518, + 1519 + ], + "close_after_record": 675289, + "frame": 29351, + "close_rank": 21 + }, + { + "dependent": 1524, + "retained": [ + 1525, + 1526, + 1527 + ], + "close_after_record": 675047, + "frame": 29373, + "close_rank": 21 + }, + { + "dependent": 1532, + "retained": [ + 1533, + 1534, + 1535 + ], + "close_after_record": 675035, + "frame": 29395, + "close_rank": 21 + }, + { + "dependent": 1540, + "retained": [ + 1541, + 1542, + 1543 + ], + "close_after_record": 675079, + "frame": 29417, + "close_rank": 21 + }, + { + "dependent": 1548, + "retained": [ + 1549, + 1550, + 1551 + ], + "close_after_record": 675109, + "frame": 29439, + "close_rank": 21 + }, + { + "dependent": 1556, + "retained": [ + 1557, + 1558, + 1559 + ], + "close_after_record": 674833, + "frame": 29461, + "close_rank": 21 + }, + { + "dependent": 1564, + "retained": [ + 1565, + 1566, + 1567 + ], + "close_after_record": 674879, + "frame": 29483, + "close_rank": 21 + }, + { + "dependent": 1572, + "retained": [ + 1573, + 1574, + 1575 + ], + "close_after_record": 674913, + "frame": 29505, + "close_rank": 21 + }, + { + "dependent": 1580, + "retained": [ + 1581, + 1582, + 1583 + ], + "close_after_record": 674669, + "frame": 29527, + "close_rank": 21 + }, + { + "dependent": 1588, + "retained": [ + 1589, + 1590, + 1591 + ], + "close_after_record": 674703, + "frame": 29549, + "close_rank": 21 + }, + { + "dependent": 1596, + "retained": [ + 1597, + 1598, + 1599 + ], + "close_after_record": 674487, + "frame": 29571, + "close_rank": 21 + }, + { + "dependent": 1604, + "retained": [ + 1605, + 1606, + 1607 + ], + "close_after_record": 675089, + "frame": 29593, + "close_rank": 21 + }, + { + "dependent": 1612, + "retained": [ + 1613, + 1614, + 1615 + ], + "close_after_record": 675063, + "frame": 29615, + "close_rank": 21 + }, + { + "dependent": 1620, + "retained": [ + 1621, + 1622, + 1623 + ], + "close_after_record": 675073, + "frame": 29637, + "close_rank": 21 + }, + { + "dependent": 1628, + "retained": [ + 1629, + 1630, + 1631 + ], + "close_after_record": 675101, + "frame": 29659, + "close_rank": 21 + }, + { + "dependent": 1636, + "retained": [ + 1637, + 1638, + 1639 + ], + "close_after_record": 674863, + "frame": 29681, + "close_rank": 21 + }, + { + "dependent": 1644, + "retained": [ + 1645, + 1646, + 1647 + ], + "close_after_record": 674873, + "frame": 29703, + "close_rank": 21 + }, + { + "dependent": 1652, + "retained": [ + 1653, + 1654, + 1655 + ], + "close_after_record": 674905, + "frame": 29725, + "close_rank": 21 + }, + { + "dependent": 1660, + "retained": [ + 1661, + 1662, + 1663 + ], + "close_after_record": 674663, + "frame": 29747, + "close_rank": 21 + }, + { + "dependent": 1668, + "retained": [ + 1669, + 1670, + 1671 + ], + "close_after_record": 674695, + "frame": 29769, + "close_rank": 21 + }, + { + "dependent": 1676, + "retained": [ + 1677, + 1678, + 1679 + ], + "close_after_record": 674479, + "frame": 29791, + "close_rank": 21 + }, + { + "dependent": 1684, + "retained": [ + 1685, + 1686, + 1687 + ], + "close_after_record": 674853, + "frame": 29813, + "close_rank": 21 + }, + { + "dependent": 1692, + "retained": [ + 1693, + 1694, + 1695 + ], + "close_after_record": 674895, + "frame": 29835, + "close_rank": 21 + }, + { + "dependent": 1700, + "retained": [ + 1701, + 1702, + 1703 + ], + "close_after_record": 674889, + "frame": 29857, + "close_rank": 21 + }, + { + "dependent": 1708, + "retained": [ + 1709, + 1710, + 1711 + ], + "close_after_record": 674685, + "frame": 29879, + "close_rank": 21 + }, + { + "dependent": 1716, + "retained": [ + 1717, + 1718, + 1719 + ], + "close_after_record": 674679, + "frame": 29901, + "close_rank": 21 + }, + { + "dependent": 1724, + "retained": [ + 1725, + 1726, + 1727 + ], + "close_after_record": 674463, + "frame": 29923, + "close_rank": 21 + }, + { + "dependent": 1732, + "retained": [ + 1733, + 1734, + 1735 + ], + "close_after_record": 674719, + "frame": 29945, + "close_rank": 21 + }, + { + "dependent": 1740, + "retained": [ + 1741, + 1742, + 1743 + ], + "close_after_record": 674643, + "frame": 29967, + "close_rank": 21 + }, + { + "dependent": 1748, + "retained": [ + 1749, + 1750, + 1751 + ], + "close_after_record": 674427, + "frame": 29989, + "close_rank": 21 + }, + { + "dependent": 1756, + "retained": [ + 1757, + 1758, + 1759 + ], + "close_after_record": 674401, + "frame": 30011, + "close_rank": 21 + } + ], + "expected_local_histogram_delta": { + "1": -209, + "2": -7, + "3": -1, + "8": -1, + "12": -1, + "17": -1, + "18": -7, + "20": -200, + "21": 209 + }, + "expected_deleted_reads": 1057, + "expected_inserted_additions": 1254, + "expected_scalar_additions": 728586, + "provenance": "Square target groups over the symmetric frame-20 compensation reads: each dependent target's prefix response equals the F2 sum of three retained square-mates; close at the common 21-dimensional frame after the frame-20 block. Prepared by Rohan Arun with Anthropic Claude assistance.", + "baseline_input_record_sha256": "1b68fdfc82a233f5472df6046748dbd1850b2f52bd694ebdae5d8d68a5334e61", + "baseline_cut_record": 670678, + "core_binding": { + "status": "PASS_POST_CUT_SCALAR_EVENT_ALIGNMENT_FRAMES_IGNORED", + "events_compared": 84975, + "cut_record": 669360, + "bindings": [ + { + "baseline_close": 677119, + "candidate_close": 675825, + "event": [ + 1, + 1773, + 17908, + -1, + 127241, + 4 + ] + }, + { + "baseline_close": 677109, + "candidate_close": 675815, + "event": [ + 1, + 1781, + 17913, + -1, + 127251, + 4 + ] + }, + { + "baseline_close": 677103, + "candidate_close": 675809, + "event": [ + 1, + 1789, + 17916, + -1, + 127257, + 4 + ] + }, + { + "baseline_close": 677115, + "candidate_close": 675821, + "event": [ + 1, + 1797, + 17910, + -1, + 127245, + 4 + ] + }, + { + "baseline_close": 677117, + "candidate_close": 675823, + "event": [ + 1, + 1813, + 17909, + -1, + 127243, + 4 + ] + }, + { + "baseline_close": 677111, + "candidate_close": 675817, + "event": [ + 1, + 1821, + 17912, + -1, + 127249, + 4 + ] + }, + { + "baseline_close": 677121, + "candidate_close": 675827, + "event": [ + 1, + 1829, + 17907, + -1, + 127239, + 4 + ] + }, + { + "baseline_close": 677071, + "candidate_close": 675777, + "event": [ + 1, + 1845, + 17932, + -1, + 127269, + 4 + ] + }, + { + "baseline_close": 677053, + "candidate_close": 675759, + "event": [ + 1, + 1853, + 17941, + -1, + 127285, + 4 + ] + }, + { + "baseline_close": 677045, + "candidate_close": 675751, + "event": [ + 1, + 1861, + 17945, + -1, + 127293, + 4 + ] + }, + { + "baseline_close": 677067, + "candidate_close": 675773, + "event": [ + 1, + 1869, + 17934, + -1, + 127273, + 4 + ] + }, + { + "baseline_close": 677049, + "candidate_close": 675755, + "event": [ + 1, + 1877, + 17943, + -1, + 127289, + 4 + ] + }, + { + "baseline_close": 677069, + "candidate_close": 675775, + "event": [ + 1, + 1885, + 17933, + -1, + 127271, + 4 + ] + }, + { + "baseline_close": 677057, + "candidate_close": 675763, + "event": [ + 1, + 1893, + 17939, + -1, + 127281, + 4 + ] + }, + { + "baseline_close": 677079, + "candidate_close": 675785, + "event": [ + 1, + 1901, + 17928, + -1, + 127261, + 4 + ] + }, + { + "baseline_close": 677051, + "candidate_close": 675757, + "event": [ + 1, + 1909, + 17942, + -1, + 127287, + 4 + ] + }, + { + "baseline_close": 676969, + "candidate_close": 675675, + "event": [ + 1, + 1917, + 17983, + -1, + 127325, + 4 + ] + }, + { + "baseline_close": 676953, + "candidate_close": 675659, + "event": [ + 1, + 1925, + 17991, + -1, + 127341, + 4 + ] + }, + { + "baseline_close": 676985, + "candidate_close": 675691, + "event": [ + 1, + 1933, + 17975, + -1, + 127311, + 4 + ] + }, + { + "baseline_close": 676959, + "candidate_close": 675665, + "event": [ + 1, + 1941, + 17988, + -1, + 127335, + 4 + ] + }, + { + "baseline_close": 676987, + "candidate_close": 675693, + "event": [ + 1, + 1949, + 17974, + -1, + 127309, + 4 + ] + }, + { + "baseline_close": 676975, + "candidate_close": 675681, + "event": [ + 1, + 1957, + 17980, + -1, + 127319, + 4 + ] + }, + { + "baseline_close": 677003, + "candidate_close": 675709, + "event": [ + 1, + 1965, + 17966, + -1, + 127297, + 4 + ] + }, + { + "baseline_close": 676961, + "candidate_close": 675667, + "event": [ + 1, + 1973, + 17987, + -1, + 127333, + 4 + ] + }, + { + "baseline_close": 676871, + "candidate_close": 675577, + "event": [ + 1, + 1989, + 18032, + -1, + 127363, + 4 + ] + }, + { + "baseline_close": 676837, + "candidate_close": 675543, + "event": [ + 1, + 1997, + 18049, + -1, + 127391, + 4 + ] + }, + { + "baseline_close": 676875, + "candidate_close": 675581, + "event": [ + 1, + 2005, + 18030, + -1, + 127359, + 4 + ] + }, + { + "baseline_close": 676861, + "candidate_close": 675567, + "event": [ + 1, + 2013, + 18037, + -1, + 127371, + 4 + ] + }, + { + "baseline_close": 676895, + "candidate_close": 675601, + "event": [ + 1, + 2021, + 18020, + -1, + 127345, + 4 + ] + }, + { + "baseline_close": 676839, + "candidate_close": 675545, + "event": [ + 1, + 2029, + 18048, + -1, + 127389, + 4 + ] + }, + { + "baseline_close": 676733, + "candidate_close": 675439, + "event": [ + 1, + 2037, + 18101, + -1, + 127419, + 4 + ] + }, + { + "baseline_close": 676691, + "candidate_close": 675397, + "event": [ + 1, + 2045, + 18122, + -1, + 127451, + 4 + ] + }, + { + "baseline_close": 676737, + "candidate_close": 675443, + "event": [ + 1, + 2053, + 18099, + -1, + 127417, + 4 + ] + }, + { + "baseline_close": 676721, + "candidate_close": 675427, + "event": [ + 1, + 2061, + 18107, + -1, + 127427, + 4 + ] + }, + { + "baseline_close": 676759, + "candidate_close": 675465, + "event": [ + 1, + 2069, + 18088, + -1, + 127401, + 4 + ] + }, + { + "baseline_close": 676693, + "candidate_close": 675399, + "event": [ + 1, + 2077, + 18121, + -1, + 127449, + 4 + ] + }, + { + "baseline_close": 676523, + "candidate_close": 675229, + "event": [ + 1, + 2085, + 18206, + -1, + 127511, + 4 + ] + }, + { + "baseline_close": 676573, + "candidate_close": 675279, + "event": [ + 1, + 2093, + 18181, + -1, + 127477, + 4 + ] + }, + { + "baseline_close": 676555, + "candidate_close": 675261, + "event": [ + 1, + 2101, + 18190, + -1, + 127485, + 4 + ] + }, + { + "baseline_close": 676597, + "candidate_close": 675303, + "event": [ + 1, + 2109, + 18169, + -1, + 127463, + 4 + ] + }, + { + "baseline_close": 676525, + "candidate_close": 675231, + "event": [ + 1, + 2117, + 18205, + -1, + 127509, + 4 + ] + }, + { + "baseline_close": 676391, + "candidate_close": 675097, + "event": [ + 1, + 2125, + 18272, + -1, + 127533, + 4 + ] + }, + { + "baseline_close": 676371, + "candidate_close": 675077, + "event": [ + 1, + 2133, + 18282, + -1, + 127543, + 4 + ] + }, + { + "baseline_close": 676417, + "candidate_close": 675123, + "event": [ + 1, + 2141, + 18259, + -1, + 127521, + 4 + ] + }, + { + "baseline_close": 676337, + "candidate_close": 675043, + "event": [ + 1, + 2149, + 18299, + -1, + 127569, + 4 + ] + }, + { + "baseline_close": 676171, + "candidate_close": 674877, + "event": [ + 1, + 2157, + 18382, + -1, + 127597, + 4 + ] + }, + { + "baseline_close": 676221, + "candidate_close": 674927, + "event": [ + 1, + 2165, + 18357, + -1, + 127577, + 4 + ] + }, + { + "baseline_close": 676135, + "candidate_close": 674841, + "event": [ + 1, + 2173, + 18400, + -1, + 127617, + 4 + ] + }, + { + "baseline_close": 676011, + "candidate_close": 674717, + "event": [ + 1, + 2181, + 18462, + -1, + 127627, + 4 + ] + }, + { + "baseline_close": 675923, + "candidate_close": 674629, + "event": [ + 1, + 2189, + 18506, + -1, + 127657, + 4 + ] + }, + { + "baseline_close": 675707, + "candidate_close": 674413, + "event": [ + 1, + 2197, + 18614, + -1, + 127675, + 4 + ] + }, + { + "baseline_close": 677073, + "candidate_close": 675779, + "event": [ + 1, + 2205, + 17931, + -1, + 127267, + 4 + ] + }, + { + "baseline_close": 677055, + "candidate_close": 675761, + "event": [ + 1, + 2213, + 17940, + -1, + 127283, + 4 + ] + }, + { + "baseline_close": 677059, + "candidate_close": 675765, + "event": [ + 1, + 2221, + 17938, + -1, + 127279, + 4 + ] + }, + { + "baseline_close": 677065, + "candidate_close": 675771, + "event": [ + 1, + 2229, + 17935, + -1, + 127275, + 4 + ] + }, + { + "baseline_close": 677077, + "candidate_close": 675783, + "event": [ + 1, + 2237, + 17929, + -1, + 127263, + 4 + ] + }, + { + "baseline_close": 677061, + "candidate_close": 675767, + "event": [ + 1, + 2245, + 17937, + -1, + 127277, + 4 + ] + }, + { + "baseline_close": 677047, + "candidate_close": 675753, + "event": [ + 1, + 2253, + 17944, + -1, + 127291, + 4 + ] + }, + { + "baseline_close": 677075, + "candidate_close": 675781, + "event": [ + 1, + 2261, + 17930, + -1, + 127265, + 4 + ] + }, + { + "baseline_close": 677081, + "candidate_close": 675787, + "event": [ + 1, + 2269, + 17927, + -1, + 127259, + 4 + ] + }, + { + "baseline_close": 676973, + "candidate_close": 675679, + "event": [ + 1, + 2277, + 17981, + -1, + 127321, + 4 + ] + }, + { + "baseline_close": 676977, + "candidate_close": 675683, + "event": [ + 1, + 2285, + 17979, + -1, + 127317, + 4 + ] + }, + { + "baseline_close": 676983, + "candidate_close": 675689, + "event": [ + 1, + 2293, + 17976, + -1, + 127313, + 4 + ] + }, + { + "baseline_close": 677001, + "candidate_close": 675707, + "event": [ + 1, + 2301, + 17967, + -1, + 127299, + 4 + ] + }, + { + "baseline_close": 676979, + "candidate_close": 675685, + "event": [ + 1, + 2309, + 17978, + -1, + 127315, + 4 + ] + }, + { + "baseline_close": 676955, + "candidate_close": 675661, + "event": [ + 1, + 2317, + 17990, + -1, + 127339, + 4 + ] + }, + { + "baseline_close": 676997, + "candidate_close": 675703, + "event": [ + 1, + 2325, + 17969, + -1, + 127303, + 4 + ] + }, + { + "baseline_close": 677005, + "candidate_close": 675711, + "event": [ + 1, + 2333, + 17965, + -1, + 127295, + 4 + ] + }, + { + "baseline_close": 676863, + "candidate_close": 675569, + "event": [ + 1, + 2341, + 18036, + -1, + 127369, + 4 + ] + }, + { + "baseline_close": 676869, + "candidate_close": 675575, + "event": [ + 1, + 2349, + 18033, + -1, + 127365, + 4 + ] + }, + { + "baseline_close": 676889, + "candidate_close": 675595, + "event": [ + 1, + 2357, + 18023, + -1, + 127351, + 4 + ] + }, + { + "baseline_close": 676865, + "candidate_close": 675571, + "event": [ + 1, + 2365, + 18035, + -1, + 127367, + 4 + ] + }, + { + "baseline_close": 676833, + "candidate_close": 675539, + "event": [ + 1, + 2373, + 18051, + -1, + 127395, + 4 + ] + }, + { + "baseline_close": 676885, + "candidate_close": 675591, + "event": [ + 1, + 2381, + 18025, + -1, + 127353, + 4 + ] + }, + { + "baseline_close": 676897, + "candidate_close": 675603, + "event": [ + 1, + 2389, + 18019, + -1, + 127343, + 4 + ] + }, + { + "baseline_close": 676731, + "candidate_close": 675437, + "event": [ + 1, + 2397, + 18102, + -1, + 127421, + 4 + ] + }, + { + "baseline_close": 676751, + "candidate_close": 675457, + "event": [ + 1, + 2405, + 18092, + -1, + 127409, + 4 + ] + }, + { + "baseline_close": 676727, + "candidate_close": 675433, + "event": [ + 1, + 2413, + 18104, + -1, + 127423, + 4 + ] + }, + { + "baseline_close": 676685, + "candidate_close": 675391, + "event": [ + 1, + 2421, + 18125, + -1, + 127457, + 4 + ] + }, + { + "baseline_close": 676747, + "candidate_close": 675453, + "event": [ + 1, + 2429, + 18094, + -1, + 127411, + 4 + ] + }, + { + "baseline_close": 676761, + "candidate_close": 675467, + "event": [ + 1, + 2437, + 18087, + -1, + 127399, + 4 + ] + }, + { + "baseline_close": 676589, + "candidate_close": 675295, + "event": [ + 1, + 2445, + 18173, + -1, + 127469, + 4 + ] + }, + { + "baseline_close": 676563, + "candidate_close": 675269, + "event": [ + 1, + 2453, + 18186, + -1, + 127479, + 4 + ] + }, + { + "baseline_close": 676515, + "candidate_close": 675221, + "event": [ + 1, + 2461, + 18210, + -1, + 127517, + 4 + ] + }, + { + "baseline_close": 676585, + "candidate_close": 675291, + "event": [ + 1, + 2469, + 18175, + -1, + 127471, + 4 + ] + }, + { + "baseline_close": 676599, + "candidate_close": 675305, + "event": [ + 1, + 2477, + 18168, + -1, + 127461, + 4 + ] + }, + { + "baseline_close": 676379, + "candidate_close": 675085, + "event": [ + 1, + 2485, + 18278, + -1, + 127537, + 4 + ] + }, + { + "baseline_close": 676327, + "candidate_close": 675033, + "event": [ + 1, + 2493, + 18304, + -1, + 127573, + 4 + ] + }, + { + "baseline_close": 676405, + "candidate_close": 675111, + "event": [ + 1, + 2501, + 18265, + -1, + 127525, + 4 + ] + }, + { + "baseline_close": 676419, + "candidate_close": 675125, + "event": [ + 1, + 2509, + 18258, + -1, + 127519, + 4 + ] + }, + { + "baseline_close": 676125, + "candidate_close": 674831, + "event": [ + 1, + 2517, + 18405, + -1, + 127621, + 4 + ] + }, + { + "baseline_close": 676209, + "candidate_close": 674915, + "event": [ + 1, + 2525, + 18363, + -1, + 127581, + 4 + ] + }, + { + "baseline_close": 676223, + "candidate_close": 674929, + "event": [ + 1, + 2533, + 18356, + -1, + 127575, + 4 + ] + }, + { + "baseline_close": 675999, + "candidate_close": 674705, + "event": [ + 1, + 2541, + 18468, + -1, + 127631, + 4 + ] + }, + { + "baseline_close": 676015, + "candidate_close": 674721, + "event": [ + 1, + 2549, + 18460, + -1, + 127623, + 4 + ] + }, + { + "baseline_close": 675799, + "candidate_close": 674505, + "event": [ + 1, + 2557, + 18568, + -1, + 127659, + 4 + ] + }, + { + "baseline_close": 676999, + "candidate_close": 675705, + "event": [ + 1, + 2565, + 17968, + -1, + 127301, + 4 + ] + }, + { + "baseline_close": 676967, + "candidate_close": 675673, + "event": [ + 1, + 2573, + 17984, + -1, + 127327, + 4 + ] + }, + { + "baseline_close": 676995, + "candidate_close": 675701, + "event": [ + 1, + 2581, + 17970, + -1, + 127305, + 4 + ] + }, + { + "baseline_close": 676957, + "candidate_close": 675663, + "event": [ + 1, + 2589, + 17989, + -1, + 127337, + 4 + ] + }, + { + "baseline_close": 676963, + "candidate_close": 675669, + "event": [ + 1, + 2597, + 17986, + -1, + 127331, + 4 + ] + }, + { + "baseline_close": 676993, + "candidate_close": 675699, + "event": [ + 1, + 2605, + 17971, + -1, + 127307, + 4 + ] + }, + { + "baseline_close": 676971, + "candidate_close": 675677, + "event": [ + 1, + 2613, + 17982, + -1, + 127323, + 4 + ] + }, + { + "baseline_close": 676965, + "candidate_close": 675671, + "event": [ + 1, + 2621, + 17985, + -1, + 127329, + 4 + ] + }, + { + "baseline_close": 676745, + "candidate_close": 675451, + "event": [ + 1, + 2685, + 18095, + -1, + 127413, + 4 + ] + }, + { + "baseline_close": 676689, + "candidate_close": 675395, + "event": [ + 1, + 2693, + 18123, + -1, + 127453, + 4 + ] + }, + { + "baseline_close": 676695, + "candidate_close": 675401, + "event": [ + 1, + 2701, + 18120, + -1, + 127447, + 4 + ] + }, + { + "baseline_close": 676743, + "candidate_close": 675449, + "event": [ + 1, + 2709, + 18096, + -1, + 127415, + 4 + ] + }, + { + "baseline_close": 676715, + "candidate_close": 675421, + "event": [ + 1, + 2717, + 18110, + -1, + 127431, + 4 + ] + }, + { + "baseline_close": 676701, + "candidate_close": 675407, + "event": [ + 1, + 2725, + 18117, + -1, + 127441, + 4 + ] + }, + { + "baseline_close": 676521, + "candidate_close": 675227, + "event": [ + 1, + 2733, + 18207, + -1, + 127513, + 4 + ] + }, + { + "baseline_close": 676527, + "candidate_close": 675233, + "event": [ + 1, + 2741, + 18204, + -1, + 127507, + 4 + ] + }, + { + "baseline_close": 676579, + "candidate_close": 675285, + "event": [ + 1, + 2749, + 18178, + -1, + 127475, + 4 + ] + }, + { + "baseline_close": 676549, + "candidate_close": 675255, + "event": [ + 1, + 2757, + 18193, + -1, + 127489, + 4 + ] + }, + { + "baseline_close": 676535, + "candidate_close": 675241, + "event": [ + 1, + 2765, + 18200, + -1, + 127499, + 4 + ] + }, + { + "baseline_close": 676339, + "candidate_close": 675045, + "event": [ + 1, + 2773, + 18298, + -1, + 127567, + 4 + ] + }, + { + "baseline_close": 676399, + "candidate_close": 675105, + "event": [ + 1, + 2781, + 18268, + -1, + 127529, + 4 + ] + }, + { + "baseline_close": 676363, + "candidate_close": 675069, + "event": [ + 1, + 2789, + 18286, + -1, + 127549, + 4 + ] + }, + { + "baseline_close": 676347, + "candidate_close": 675053, + "event": [ + 1, + 2797, + 18294, + -1, + 127559, + 4 + ] + }, + { + "baseline_close": 676203, + "candidate_close": 674909, + "event": [ + 1, + 2805, + 18366, + -1, + 127585, + 4 + ] + }, + { + "baseline_close": 676163, + "candidate_close": 674869, + "event": [ + 1, + 2813, + 18386, + -1, + 127601, + 4 + ] + }, + { + "baseline_close": 676145, + "candidate_close": 674851, + "event": [ + 1, + 2821, + 18395, + -1, + 127611, + 4 + ] + }, + { + "baseline_close": 675953, + "candidate_close": 674659, + "event": [ + 1, + 2829, + 18491, + -1, + 127647, + 4 + ] + }, + { + "baseline_close": 675933, + "candidate_close": 674639, + "event": [ + 1, + 2837, + 18501, + -1, + 127653, + 4 + ] + }, + { + "baseline_close": 675717, + "candidate_close": 674423, + "event": [ + 1, + 2845, + 18609, + -1, + 127673, + 4 + ] + }, + { + "baseline_close": 676873, + "candidate_close": 675579, + "event": [ + 1, + 2853, + 18031, + -1, + 127361, + 4 + ] + }, + { + "baseline_close": 676891, + "candidate_close": 675597, + "event": [ + 1, + 2861, + 18022, + -1, + 127349, + 4 + ] + }, + { + "baseline_close": 676893, + "candidate_close": 675599, + "event": [ + 1, + 2869, + 18021, + -1, + 127347, + 4 + ] + }, + { + "baseline_close": 676857, + "candidate_close": 675563, + "event": [ + 1, + 2877, + 18039, + -1, + 127373, + 4 + ] + }, + { + "baseline_close": 676853, + "candidate_close": 675559, + "event": [ + 1, + 2885, + 18041, + -1, + 127377, + 4 + ] + }, + { + "baseline_close": 676843, + "candidate_close": 675549, + "event": [ + 1, + 2893, + 18046, + -1, + 127385, + 4 + ] + }, + { + "baseline_close": 676847, + "candidate_close": 675553, + "event": [ + 1, + 2901, + 18044, + -1, + 127381, + 4 + ] + }, + { + "baseline_close": 676755, + "candidate_close": 675461, + "event": [ + 1, + 2909, + 18090, + -1, + 127405, + 4 + ] + }, + { + "baseline_close": 676757, + "candidate_close": 675463, + "event": [ + 1, + 2917, + 18089, + -1, + 127403, + 4 + ] + }, + { + "baseline_close": 676717, + "candidate_close": 675423, + "event": [ + 1, + 2925, + 18109, + -1, + 127429, + 4 + ] + }, + { + "baseline_close": 676713, + "candidate_close": 675419, + "event": [ + 1, + 2933, + 18111, + -1, + 127433, + 4 + ] + }, + { + "baseline_close": 676697, + "candidate_close": 675403, + "event": [ + 1, + 2941, + 18119, + -1, + 127445, + 4 + ] + }, + { + "baseline_close": 676707, + "candidate_close": 675413, + "event": [ + 1, + 2949, + 18114, + -1, + 127435, + 4 + ] + }, + { + "baseline_close": 676595, + "candidate_close": 675301, + "event": [ + 1, + 2957, + 18170, + -1, + 127465, + 4 + ] + }, + { + "baseline_close": 676551, + "candidate_close": 675257, + "event": [ + 1, + 2965, + 18192, + -1, + 127487, + 4 + ] + }, + { + "baseline_close": 676547, + "candidate_close": 675253, + "event": [ + 1, + 2973, + 18194, + -1, + 127491, + 4 + ] + }, + { + "baseline_close": 676531, + "candidate_close": 675237, + "event": [ + 1, + 2981, + 18202, + -1, + 127503, + 4 + ] + }, + { + "baseline_close": 676541, + "candidate_close": 675247, + "event": [ + 1, + 2989, + 18197, + -1, + 127493, + 4 + ] + }, + { + "baseline_close": 676365, + "candidate_close": 675071, + "event": [ + 1, + 2997, + 18285, + -1, + 127547, + 4 + ] + }, + { + "baseline_close": 676361, + "candidate_close": 675067, + "event": [ + 1, + 3005, + 18287, + -1, + 127551, + 4 + ] + }, + { + "baseline_close": 676343, + "candidate_close": 675049, + "event": [ + 1, + 3013, + 18296, + -1, + 127563, + 4 + ] + }, + { + "baseline_close": 676353, + "candidate_close": 675059, + "event": [ + 1, + 3021, + 18291, + -1, + 127555, + 4 + ] + }, + { + "baseline_close": 676161, + "candidate_close": 674867, + "event": [ + 1, + 3029, + 18387, + -1, + 127603, + 4 + ] + }, + { + "baseline_close": 676141, + "candidate_close": 674847, + "event": [ + 1, + 3037, + 18397, + -1, + 127615, + 4 + ] + }, + { + "baseline_close": 676153, + "candidate_close": 674859, + "event": [ + 1, + 3045, + 18391, + -1, + 127607, + 4 + ] + }, + { + "baseline_close": 675929, + "candidate_close": 674635, + "event": [ + 1, + 3053, + 18503, + -1, + 127655, + 4 + ] + }, + { + "baseline_close": 675943, + "candidate_close": 674649, + "event": [ + 1, + 3061, + 18496, + -1, + 127649, + 4 + ] + }, + { + "baseline_close": 675727, + "candidate_close": 674433, + "event": [ + 1, + 3069, + 18604, + -1, + 127669, + 4 + ] + }, + { + "baseline_close": 676687, + "candidate_close": 675393, + "event": [ + 1, + 3077, + 18124, + -1, + 127455, + 4 + ] + }, + { + "baseline_close": 676703, + "candidate_close": 675409, + "event": [ + 1, + 3085, + 18116, + -1, + 127439, + 4 + ] + }, + { + "baseline_close": 676705, + "candidate_close": 675411, + "event": [ + 1, + 3093, + 18115, + -1, + 127437, + 4 + ] + }, + { + "baseline_close": 676699, + "candidate_close": 675405, + "event": [ + 1, + 3101, + 18118, + -1, + 127443, + 4 + ] + }, + { + "baseline_close": 676753, + "candidate_close": 675459, + "event": [ + 1, + 3109, + 18091, + -1, + 127407, + 4 + ] + }, + { + "baseline_close": 676723, + "candidate_close": 675429, + "event": [ + 1, + 3117, + 18106, + -1, + 127425, + 4 + ] + }, + { + "baseline_close": 676537, + "candidate_close": 675243, + "event": [ + 1, + 3125, + 18199, + -1, + 127497, + 4 + ] + }, + { + "baseline_close": 676539, + "candidate_close": 675245, + "event": [ + 1, + 3133, + 18198, + -1, + 127495, + 4 + ] + }, + { + "baseline_close": 676533, + "candidate_close": 675239, + "event": [ + 1, + 3141, + 18201, + -1, + 127501, + 4 + ] + }, + { + "baseline_close": 676591, + "candidate_close": 675297, + "event": [ + 1, + 3149, + 18172, + -1, + 127467, + 4 + ] + }, + { + "baseline_close": 676559, + "candidate_close": 675265, + "event": [ + 1, + 3157, + 18188, + -1, + 127481, + 4 + ] + }, + { + "baseline_close": 676351, + "candidate_close": 675057, + "event": [ + 1, + 3165, + 18292, + -1, + 127557, + 4 + ] + }, + { + "baseline_close": 676345, + "candidate_close": 675051, + "event": [ + 1, + 3173, + 18295, + -1, + 127561, + 4 + ] + }, + { + "baseline_close": 676411, + "candidate_close": 675117, + "event": [ + 1, + 3181, + 18262, + -1, + 127523, + 4 + ] + }, + { + "baseline_close": 676375, + "candidate_close": 675081, + "event": [ + 1, + 3189, + 18280, + -1, + 127539, + 4 + ] + }, + { + "baseline_close": 676143, + "candidate_close": 674849, + "event": [ + 1, + 3197, + 18396, + -1, + 127613, + 4 + ] + }, + { + "baseline_close": 676215, + "candidate_close": 674921, + "event": [ + 1, + 3205, + 18360, + -1, + 127579, + 4 + ] + }, + { + "baseline_close": 676175, + "candidate_close": 674881, + "event": [ + 1, + 3213, + 18380, + -1, + 127593, + 4 + ] + }, + { + "baseline_close": 676005, + "candidate_close": 674711, + "event": [ + 1, + 3221, + 18465, + -1, + 127629, + 4 + ] + }, + { + "baseline_close": 675965, + "candidate_close": 674671, + "event": [ + 1, + 3229, + 18485, + -1, + 127641, + 4 + ] + }, + { + "baseline_close": 675749, + "candidate_close": 674455, + "event": [ + 1, + 3237, + 18593, + -1, + 127667, + 4 + ] + }, + { + "baseline_close": 676601, + "candidate_close": 675307, + "event": [ + 1, + 3245, + 18167, + -1, + 127459, + 4 + ] + }, + { + "baseline_close": 676529, + "candidate_close": 675235, + "event": [ + 1, + 3253, + 18203, + -1, + 127505, + 4 + ] + }, + { + "baseline_close": 676517, + "candidate_close": 675223, + "event": [ + 1, + 3261, + 18209, + -1, + 127515, + 4 + ] + }, + { + "baseline_close": 676557, + "candidate_close": 675263, + "event": [ + 1, + 3269, + 18189, + -1, + 127483, + 4 + ] + }, + { + "baseline_close": 676583, + "candidate_close": 675289, + "event": [ + 1, + 3277, + 18176, + -1, + 127473, + 4 + ] + }, + { + "baseline_close": 676341, + "candidate_close": 675047, + "event": [ + 1, + 3285, + 18297, + -1, + 127565, + 4 + ] + }, + { + "baseline_close": 676329, + "candidate_close": 675035, + "event": [ + 1, + 3293, + 18303, + -1, + 127571, + 4 + ] + }, + { + "baseline_close": 676373, + "candidate_close": 675079, + "event": [ + 1, + 3301, + 18281, + -1, + 127541, + 4 + ] + }, + { + "baseline_close": 676403, + "candidate_close": 675109, + "event": [ + 1, + 3309, + 18266, + -1, + 127527, + 4 + ] + }, + { + "baseline_close": 676127, + "candidate_close": 674833, + "event": [ + 1, + 3317, + 18404, + -1, + 127619, + 4 + ] + }, + { + "baseline_close": 676173, + "candidate_close": 674879, + "event": [ + 1, + 3325, + 18381, + -1, + 127595, + 4 + ] + }, + { + "baseline_close": 676207, + "candidate_close": 674913, + "event": [ + 1, + 3333, + 18364, + -1, + 127583, + 4 + ] + }, + { + "baseline_close": 675963, + "candidate_close": 674669, + "event": [ + 1, + 3341, + 18486, + -1, + 127643, + 4 + ] + }, + { + "baseline_close": 675997, + "candidate_close": 674703, + "event": [ + 1, + 3349, + 18469, + -1, + 127633, + 4 + ] + }, + { + "baseline_close": 675781, + "candidate_close": 674487, + "event": [ + 1, + 3357, + 18577, + -1, + 127661, + 4 + ] + }, + { + "baseline_close": 676383, + "candidate_close": 675089, + "event": [ + 1, + 3365, + 18276, + -1, + 127535, + 4 + ] + }, + { + "baseline_close": 676357, + "candidate_close": 675063, + "event": [ + 1, + 3373, + 18289, + -1, + 127553, + 4 + ] + }, + { + "baseline_close": 676367, + "candidate_close": 675073, + "event": [ + 1, + 3381, + 18284, + -1, + 127545, + 4 + ] + }, + { + "baseline_close": 676395, + "candidate_close": 675101, + "event": [ + 1, + 3389, + 18270, + -1, + 127531, + 4 + ] + }, + { + "baseline_close": 676157, + "candidate_close": 674863, + "event": [ + 1, + 3397, + 18389, + -1, + 127605, + 4 + ] + }, + { + "baseline_close": 676167, + "candidate_close": 674873, + "event": [ + 1, + 3405, + 18384, + -1, + 127599, + 4 + ] + }, + { + "baseline_close": 676199, + "candidate_close": 674905, + "event": [ + 1, + 3413, + 18368, + -1, + 127587, + 4 + ] + }, + { + "baseline_close": 675957, + "candidate_close": 674663, + "event": [ + 1, + 3421, + 18489, + -1, + 127645, + 4 + ] + }, + { + "baseline_close": 675989, + "candidate_close": 674695, + "event": [ + 1, + 3429, + 18473, + -1, + 127635, + 4 + ] + }, + { + "baseline_close": 675773, + "candidate_close": 674479, + "event": [ + 1, + 3437, + 18581, + -1, + 127663, + 4 + ] + }, + { + "baseline_close": 676147, + "candidate_close": 674853, + "event": [ + 1, + 3445, + 18394, + -1, + 127609, + 4 + ] + }, + { + "baseline_close": 676189, + "candidate_close": 674895, + "event": [ + 1, + 3453, + 18373, + -1, + 127589, + 4 + ] + }, + { + "baseline_close": 676183, + "candidate_close": 674889, + "event": [ + 1, + 3461, + 18376, + -1, + 127591, + 4 + ] + }, + { + "baseline_close": 675979, + "candidate_close": 674685, + "event": [ + 1, + 3469, + 18478, + -1, + 127637, + 4 + ] + }, + { + "baseline_close": 675973, + "candidate_close": 674679, + "event": [ + 1, + 3477, + 18481, + -1, + 127639, + 4 + ] + }, + { + "baseline_close": 675757, + "candidate_close": 674463, + "event": [ + 1, + 3485, + 18589, + -1, + 127665, + 4 + ] + }, + { + "baseline_close": 676013, + "candidate_close": 674719, + "event": [ + 1, + 3493, + 18461, + -1, + 127625, + 4 + ] + }, + { + "baseline_close": 675937, + "candidate_close": 674643, + "event": [ + 1, + 3501, + 18499, + -1, + 127651, + 4 + ] + }, + { + "baseline_close": 675721, + "candidate_close": 674427, + "event": [ + 1, + 3509, + 18607, + -1, + 127671, + 4 + ] + }, + { + "baseline_close": 675695, + "candidate_close": 674401, + "event": [ + 1, + 3517, + 18620, + -1, + 127677, + 4 + ] + } + ] + } +} diff --git a/research/multicut-kernel-composition/requirements.txt b/research/multicut-kernel-composition/requirements.txt new file mode 100644 index 0000000000..1ca5fd0616 --- /dev/null +++ b/research/multicut-kernel-composition/requirements.txt @@ -0,0 +1 @@ +sympy==1.14.0 diff --git a/research/multicut-kernel-composition/vendor/PR249-SOURCE-MANIFEST.json b/research/multicut-kernel-composition/vendor/PR249-SOURCE-MANIFEST.json new file mode 100644 index 0000000000..ffc0219425 --- /dev/null +++ b/research/multicut-kernel-composition/vendor/PR249-SOURCE-MANIFEST.json @@ -0,0 +1,140 @@ +{ + "repository": "https://github.com/CrocSwap/integer-mult-bounds", + "pull_request": 249, + "head": "96495746c786d6d0339dbb38c7f553d4af3f88ed", + "path": "research/five-stage-source527-banks", + "files": { + "BANK-PROOF.md": "e75edfcb4efe4cad1bd38a5e18a6c5fd323e6e2b34840e9ed09863da85ec37cc", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "MANIFEST.json": "86e8bc5182079c00877077c8e4c7b2690ba2486bec385c0857f1794cd2e6bedb", + "NOTICE.md": "9a659cc2f96ae7e0eda99954941c42a4529bc885fb1de161c44ea801ff36e480", + "PR-STATEMENT.md": "fbb2b3cda4d6030c09162a87aee7c9c4473a2d3ac8fd9aa5ec0332ab6880bd08", + "PROOF.md": "69c3066adbe1664aacb03744328c79738649d576529a25f962035d4e479faf81", + "README.md": "571bb4d1b658eceb4f692c2746ffff9817ac57f8cbac2ae38034adb698192866", + "UPSTREAM-PR234-NOTICE.md": "ce978c8dfc8a2b36eed7a53014b1a792248b22ef4cee3edd8adab825a571c429", + "UPSTREAM-PR234-PROOF.md": "c9722b07256758cd3b307dd46689f99984c66e16c3dd934f9c34e551620bfc0f", + "bank_check.py": "3fb3ac24c3d671d0bc97a526996c760d5d63e3f8e0478155135c813bf1e162cc", + "bank_template.py": "60af020ddacc634d284aa54b7ac2db7894369fa96b4878cac60cda1ce748f64d", + "base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "code/complex_labels.py": "ff5d5e914ef1be0f0cc30283a1ee39089b77e4b572f09543e7313d126bd26256", + "code/complex_scalars.py": "fa035447c1f3a5e878dfc18a900942aa180d8bfde03cdce2d21d9bf8b8409429", + "code/complex_splice.py": "ed8f7f55530bab64e25b98ee614e1152ded8a6259c48d32b3ae26bab4b93848c", + "code/geometry527.py": "bff96140e93c0cea01ed618b49b913f913c12d99ebb0e4e4342336cf5a102800", + "code/global_lowering.py": "3a851ce132e4b08127c4f51b3d10c91ea24d0140260306cfccee9e6206225a3d", + "code/physical527.py": "1723a5c53ec236529e46980c8eb2c45134c61275ac7fb85c8ad92223784de07c", + "finite_check.py": "286618567a721052b6fde92d6742c3a43784e7b2994770ac3f9807cafacd55b0", + "inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "inputs/complex/gcert1-p11-pr193.json.gz": "15251deb0c11e0504d7b297c9786818888a93f08b92b03c6c122784b70488633", + "inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "inputs/complex/source-pins.json": "de0daf6847185d7a6911535e3012c1a91de1e32b5da8204beec26b37523ad569", + "inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "loader/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "loader/MANIFEST.json": "a1b6da7191f3bc0109dac63ae96122dd9f5174743909daf5e0bdcc8e9cfbbffc", + "loader/NOTICE.md": "ee632728cc4d89565292d288f8289f483ac794b5d02cc6e42c2b2c43c43ff1d8", + "loader/README.md": "4c36794b0f702ed521c0a7eaeacb1b7cc258760d59193cc8eb29be590e709dcd", + "loader/SOURCE_PINS.json": "5a4fa413ea0ecc74050359329e90521723151e421cc0c19f774b92bd608a3ac9", + "loader/expected_ledger.json": "4910004287e016f7f2db10f0a54eed24bf1912aa148b347b3cb4795fa3ac63f5", + "loader/expected_semantics.json": "b7de3178436c824b6be6d99842270a82e1821b8008dda66d8b18519ad347da2d", + "loader/raw_ledger.py": "89ba53114488a77a12b941db2787850c2c41612ad0332c47699a011c0c596b32", + "loader/source_inputs/base_bit/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "loader/source_inputs/base_bit/NOTICE": "c9850418622aea8d1382a230306c940947b5da818f4854b4b272ed60cf239f6c", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/bit/base_word.py": "9fe3a81b7561d2b09c086f63fac4626e88a32369ef8bc5579c94878de1218a89", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/bit/word.py": "85822e9cca5b1b2335c3704a3df2f3c6ef01e42d8328daacb33701d30cee80ab", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/references/pr168-v4/research/paired-cube-bit/check_paired_cube_bit.py": "4d7c86cd999a1519e0dfb6dcf33a8f26e442a353c3665a0f06881216a260fbf3", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/selected/bit/frames_p12.json.gz": "ad8e2705652b68476713d7647a8592505e222f2b3ccd1728dedce153aac6d462", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/selected/bit/graph_p12.json": "31a09a55920e64c8bfbac8b845dc01754c112aa6e207812e2fd1f4939d8f64cb", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/selected/bit/kchron_p12.json": "0fab548e84cf5ca7c04e8bd19b5810850463f36e0f92180efe73aeff17105e39", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/selected/bit/profile_p12.json": "c44ef8640cbcbcc9bac3a30e13373bd79efddde55d7cea514354ca2cdb60d66d", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/selected/bit/sinks.json": "c00ff70c564829d4b97740f92796fc6ce14fbcd5ca519663828650552b80249d", + "loader/source_inputs/base_bit/research/paired-cube-diagonal-bit-168/selected/bit/word_p12.json.gz": "1cb7e8ed45cf542e304fddc4b12247dbb248a0dc84dedbd832f336b2d172793a", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/NOTICE": "9fc5561c0995892dbdde777c713899486920c32d3562392f5f72377a4953bf98", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/borrow/selection.json": "6932749407e14b199651f0a7deff02c6de74e2c1be0a1300263f1e164927fb8b", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/frames/opframe-bases.json": "687496f3c15818e7cad1beb5fdf3812b8e38825ea302bfd60aea7ac23f3516b4", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/gaugeb/selection.json": "b0f9f0e67f94a3c21069f393ea27f9483d315bff2f53f77270163065a6345d1c", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/joint/joint-selection.json": "13f6420d6c341c22235c9d136d5f7c32896974bb165a893fecd7e583b790d133", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/joint/joint_word.py": "de37cbed753fc6f13a7e5dc25c8346279cfee5f1868df8c12a5fcb6ca8f631c0", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/joint/pairs.json": "da54b863601b5cbc21d27fc5cd623bf805f974a3e47b81ed29a85aa5bad0fa05", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/newg/replay.py": "0cbec81a11e758156e9303f63dc8c617601da69523073fdf2a77394d76acf56a", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/newg/schedule.json": "ab39d61fff7a2cfcb13e2c10d65f2c603e76a91013d197260d6c7b645ccb27a1", + "loader/source_inputs/pr210/research/coordinated-crossover-pr200/newg/selection.json": "d94ef4e0b8ca98a7385b364cf245816a7cad08f850a60ce8b67aab4c3a89f3f4", + "loader/source_loader.py": "e5e19ee6d6899fce8273d0f06a49caf7cd8bfe940a2a9a103dbc9d3a62b6b291", + "loader/test_public.py": "2103c953b37cf447d1a2bbb86c26f96fa5569a3ab018567e93884c12ebde8a2d", + "math_check.py": "33dba4c0d203212cf5731a2094237774443725e832d419dc89c528187e52d671", + "moment.py": "9d465c716c6b910ff66e1453e3bf0057608a787b5f5361be93781f42cb3370f7", + "outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "parity_transform.py": "ef6f5224b91c409c30fc0886143787a0839a13cc6b148e42ca5db858d502ec4d", + "portable_bit.py": "2bdf814013e46c3245fc67c5d152c3b13245d562a247410671575008f2007af1", + "portable_complex.py": "797e144c0040d78a4731a6eaa61c0edb9803a08462f885ed014cbca9d9991d82", + "prepare.py": "fc109fe81d7d9d3f53483ce7d648dc9fcf6d9fb71b8fde1c867ece5283fadbcc", + "prime_check.py": "22df1899dfb3b61e394bf1bca178b2a8846e1434ce12df3bf58fdee77f3283cf", + "prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "proof/FINITE_BIT_ACCOUNTING.md": "602923520af184670170bf159fde7b4c72e79a72570eddd7746b7c97bc51fc5b", + "proof/INTEGRATED_PROOF.md": "cff22391e71a50bad27a1e832d5c0a2c8b2446df55adb1297c8b1485b3761257", + "proof/PARITY-CONTRACT.md": "a9246be656e31f1a21d5ec714e002f51be0aa07c36e1528066a25b2c7a02db91", + "proof/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "proof/primary/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "proof/primary/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "proof/primary/PROVENANCE.md": "dd9054c58aa92c44b0ef5f691ad4dc52b8ead2f20a9843d4399d6c300d616023", + "proof/primary/UPSTREAM-README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "proof/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "proof/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "raw_ledger.py": "d5dae7b56d403adb778251e4b42903695632d522c1392505723e2125162cef78", + "regauge-selection.json": "135e314f37bd611a021776991c9d786377b3829f84ca576d5006696c2d8bfbed", + "regauge_transform.py": "baa1c7390f449722e7e700fa1ce9afc3d00cd4c0f7faa5f41693ff88ec02fd61", + "requirements.txt": "25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc", + "retiming-selection.json": "b173080a2884d5bfb28e35ed5b4256e233cafc6275cbfe5a76619b406f2ce989", + "retiming_transform.py": "483cb8da83a1444cbc8b1bbe60473e571a27e6e589fa64f9a26910ca0d678407", + "scalar_check.py": "d87c3cd39313d37cc1403a24e01ad383c146c295968fd41a68c345a4b5adba80", + "source527/echelon/selection.json": "8e6ce5e257aa7656898ab46bc3421df4a619497b1e9f5956d2c546b3014050a7", + "source527/extra/selection.json": "791f6ddeb19add7026ba37461256c13efe3d35bba0bccf1cb9787a01fc16f0f2", + "source527/extra/upstream_setup.py": "a7789d13eda75e78108cee84206692c913f63aafdb9e3e633fddd14640e4678a", + "source527/fresh/selection.json": "4df5f96064349415882ece4ac9abd19cc778f18c0306a27b3d65027dcb04b6c7", + "source527/fresh/upstream_setup.py": "dba4e53f235ca446095eb834313c59f80b5aa0e4fdfb24c5c2eebc26ac11d412", + "source527/paired-selection.json": "67a24896e5ff6a16735efdff57fbb875aa411aba00cbabb22c43a91cdf63e084", + "source527/pr230/NOTICE": "7dfbad087ee49b74fd5075d517eaa263c5dd3d4fbd4c69bfba34ee1cb55e837f", + "source527/pr230/PROVENANCE.json": "19957e28a8ad26281bfe8bfaf8ae16191be53e729a8870a6154671b3384959d4", + "source527/pr230/active-opframe-bases.json": "9a2bba5c72aebc9ee4f21e59b10ce810b2da98a1fa1748fbc44c50a080e584ff", + "source527/rank/selection.json": "5c97c6413f1eb56c7b8f9ba9e839329d212fae7ac3a08c29e9efdee42f5048a0", + "source527/targetagg/selection.json": "b7a4d5eb2a6d2f7df867f9be5af7da1d1aa99cfbd5214195967b0ff60642d77a", + "source527/targetagg/upstream_setup.py": "fd7adf0b12d0769e06438b2ee4322bfcb180d8f73a1104a3eb805ab88c5cc393", + "source527/word.py": "e675d4eb9d90ff0b44279fae0b46f1a8b39f65421cc38454b70a6b75d0e10b42", + "verify.py": "4fc103389c1c62bd0ea5b39f9d41128db30dde4475370394bab600a0acd52e9a" + } +} diff --git a/research/multicut-kernel-composition/vendor/UPSTREAM-NOTICE.md b/research/multicut-kernel-composition/vendor/UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..a317749fa3 --- /dev/null +++ b/research/multicut-kernel-composition/vendor/UPSTREAM-NOTICE.md @@ -0,0 +1,13 @@ +# Attribution and licence + +Apache-2.0 applies. Original headers, licences, notices and AI assistance disclosures are preserved. `UPSTREAM-PR234-NOTICE.md` contains the complete inherited five-stage credits; the individual source roots retain their original notices. Credits do not imply review or endorsement. + +The five-stage architecture and finite interface package come from Henry Grant / hcg890's PR234. Rohan Arun's PR237 published the width-120 bank extension before this integration; no exclusive priority for that bank extension is claimed. The stage-private bank assignment and address adapter in this package were developed independently and are checked explicitly. + +The source527 construction builds on eumemic's PR210 source reuse and target transforms, sennemmi's PR230 operation-frame changes, Dugongue's PR216 and PR207, Rohan Arun's PR211, Chafik Boukhalfa's PR200, Evan McKinney's completed bank work, and their retained dependencies. The complex input preserves Jacob Sussman's published five-stage certificate and Avi Eisenberg / ikeboy's PR193 helper, with the original Claude assistance disclosures. + +The 31 new zero-response source aliases, 48 retained dirty-anchor paths, physical event tagging and source527 integration were prepared by eumemic with substantial OpenAI Codex assistance. All earlier contributor notices and assistance disclosures remain in the supplied source material. + +The parity-filtered common-frame retiming (PR244) and exact reconstruction were prepared by eumemic with substantial OpenAI Codex assistance. The 353 unborrowed pair mixes use their existing common delivery frames; source527 and all earlier construction credits remain retained. + +The twenty-one additional F2 gauge entrances, exact compensation transport, cloned producer/execution contexts and new completed-bank charts were prepared by eumemic with substantial OpenAI Codex assistance. diff --git a/research/multicut-kernel-composition/vendor/json.hpp b/research/multicut-kernel-composition/vendor/json.hpp new file mode 100644 index 0000000000..82d69f7c5d --- /dev/null +++ b/research/multicut-kernel-composition/vendor/json.hpp @@ -0,0 +1,25526 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_DIAGNOSTIC_POSITIONS + #define JSON_DIAGNOSTIC_POSITIONS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_DIAGNOSTIC_POSITIONS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#ifdef JSON_HAS_CPP_17 + #include // optional +#endif +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) + #define JSON_HAS_CPP_23 + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows calling any std function as if (e.g., with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // char_traits +#include // tuple +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& +is_complete_type < +detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template