diff --git a/research/p104-live-helper-reads/PREDECESSORS.json b/research/p104-live-helper-reads/PREDECESSORS.json new file mode 100644 index 0000000000..f82bd4f541 --- /dev/null +++ b/research/p104-live-helper-reads/PREDECESSORS.json @@ -0,0 +1,22 @@ +[ + { + "pr": 2383, + "commit": "41f3d517b521500b114f3491f5f5b68a0550f410", + "path": "research/p104-private-code-relay-floor/README.md", + "author": "commdata2338", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2383", + "sha256": "eff162e2cff26fc6791cdce17e6e087e749aa87fce99b79049444328cbe13a80", + "git_blob": "b49d49730d66f44adb6f7a05884847d64f215a1c", + "usage": "Written predecessor and handoff only; no executable imported" + }, + { + "pr": 2353, + "commit": "2704eadf6b5205d4b965e9c6fc6dce28b89783cf", + "path": "research/p104-monotone-relay-floor-audit/README.md", + "author": "Hiroki Kumazaki / kumagi", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2353", + "sha256": "1994370aa479f01b44a55c5f8afadec5e918dc60efac08cd29adbfc5098357e3", + "git_blob": "a8da976c83eda0c8c5ec7bc2f0f5068edb167c03", + "usage": "Written predecessor and handoff only; no executable imported" + } +] diff --git a/research/p104-live-helper-reads/README.md b/research/p104-live-helper-reads/README.md new file mode 100644 index 0000000000..4e60ce5ff9 --- /dev/null +++ b/research/p104-live-helper-reads/README.md @@ -0,0 +1,217 @@ +# Actual-frame reads of unfinished P104 helpers retain the relay floor + +Allowing **read-only access to every original G/Q/D helper at its actual +chronological frame** still requires at least **208 new monotone correction-helper +lifetimes** in the model below. This includes unfinished helper values whose +source projections lie outside the root code K. It resolves the actual-frame +version of the explicit next question in [PR2383](https://github.com/CrocSwap/integer-mult-bounds/pull/2383). + +The number 208 and the original monotone-relay argument are predecessor results +of Philippe Van Velzen and Hiroki Kumazaki / [PR2353](https://github.com/CrocSwap/integer-mult-bounds/pull/2353). +commdata2338 / PR2383 proved the same floor with the whole root code supplied +freely at every frame, but excluded unfinished original G/Q/D rows outside K. +The new implication permits **all actual original helper reads** while keeping +the original word unchanged. It uses a new finite fact: none of the 72 original +G/Q/D helper paths ever visits any of the 104 target endpoint hyperplanes. + +This is a written proof with exact finite premises, not a new correction +construction, a simultaneous-register lower bound, an excess-rank invoice, +a favorable completed moment, an admitted supplier or a new kappa. It does not +claim that arbitrary-frame access to the original helper rows is harmless. + +## Exact model + +The frozen input is PR1972's 4,058-event word retained in PR1991. It has +104 immutable logical sources X, 104 additive targets Y, 32 G helpers, +8 Q helpers, 32 D helpers, and 8 sequential private C lifetimes. Every original +event, value and frame path is retained. Additional correction operations may +read X, G, Q, D and active C, but **cannot write any of those registers**. +The source and original-helper read must occur at that register's actual cut +and frame. Original events preserve their order; arbitrary extra operations +may be inserted between them. Their reads do not change the original trace. + +Targets accept additive writes only; they cannot be read, cleared or rescaled. +Every coefficient is an input-independent rational scalar. New helpers can mix, +copy, clear and relay at equal frames. Each new lifetime follows an increasing +binary-subspace path; discard/reinitialization starts another lifetime. Initial +source dependence can be in K, plus independent arbitrary dirt. Grant the whole +K freely at any frame and time. This last permission is favorable and already +belongs to PR2383's model. Dirty restoration is relaxed for the lower bound. + +All added operations must use the logical common-frame contract. A physical +operation that mixes different charts requires another argument. Writing new +source information into the original word, changing its paths, introducing new +descending lifetimes, target feedback or arbitrary-frame read oracles is outside +the theorem. The unchanged original private descents are included, with their +actual source rows checked to be in K. + +Let R have the doubled integer P104 root columns, in the frozen port order. +Then `R R^T = 104 I`, `G = R^T R/4`, and the additional correction is +`C = I - G/2`. For a binary frame V put + +``` +K = row_Q(R), +S(V) = {s : initial source label q_s lies in V}, +U(V) = span_Q {e_s : s in S(V)}. +``` + +K and U are spaces of source coefficient rows. The independent source inputs +are not constrained to belong to either space. + +## New finite evidence + +The independent replay imports no pending predecessor executable. It reconstructs +the P104 roots, executes all 4,058 events over all 280 independent input columns, +and maintains a second representation `source_row = alpha R + local`. At each +changed non-target state and every initial state, it checks this exact equality +and that the local part is supported on S(actual frame). Values do not change +between these checks. The complete private copies are checked to lie in K before +descent; their source projections and independent Q dirt are retained separately. + +| Check | Result | +| --- | --- | +| Original G/Q/D helper paths | 72 increasing paths | +| Distinct helper/register-frame pairs, including initial frames | 434 | +| Contacts with any of the 104 target endpoint hyperplanes | **0** | +| Explicit source-decomposition state checks | 2,458 | +| Original private lifetimes | 8, with exact code-valued source rows | +| Complete logical endpoint | original G/2 target map; all 72 dirty inputs restored | + +An actual unfinished example occurs at **cut 593**, immediately after event 592: +`G25 = initial_G25 - 2 X1`, in `V = span(8,64,416)`, a proper subspace of Y2's +endpoint. Its source row `-2 e_1` is outside K, as the exact code-projection test +checks. It is nevertheless in U(V). Reading it at V is allowed by the new model; +transporting it freely to ZERO would supply information outside `K + U(ZERO)` +and is not allowed. The dirty term has not been removed by this example. + +[RESULT.json](RESULT.json) contains all 72 frame paths, the private rows, +this example, a digest of all source-decomposition certificates, and the +104 target witnesses. [verify.py](verify.py) regenerates every proof-relevant +field from the two frozen JSON inputs and compares the complete canonical payload. + +For completeness, the replay also independently checks PR2383's inherited +finite premises: each target endpoint H is a distinct dimension-eight subspace; +`supp(C_t) = S(H)` has size 48; no original source path visits H; and after +granting every possible earlier target-frame contribution, the still-required +labels span H. Eight outside-root columns with nonzero integer determinant +certify `K intersect U(H) = {0}`. These numerical premises and the 208 floor +are credited to their predecessors, not presented as new discoveries. + +## Proof + +**1. The original read-only word supplies only `K + U(V)` at frame V.** +Initially sources have row e_s at a frame containing q_s; all independent +dirty helpers have zero source projection. Equal-frame additions preserve +the invariant. Every nonprivate original transport increases its frame, so +it preserves the invariant. Each of the eight private copies has a source +row in K before its descent, checked directly over all 104 source columns; +it therefore satisfies the invariant even at the smaller frame. Private +values remain unchanged until discard. This proves the claim at every +original cut, including unfinished captures outside K. The second representation +in the replay checks the induction's exact source binding and excludes accidental +use of a different word or a contaminated private copy. + +**2. New helpers obey the same invariant even when reading original helpers.** +At a read from an unchanged original register at frame V, step 1 supplies +an element of `K + U(V)`. This is the new case missing from PR2383's proof. +Initial K dependence, source reads, free code inputs, equal-frame mixing and +increasing new transports preserve the invariant exactly as before. Arbitrary +finite new-helper relay networks, rational cancellation and feedback among +new helpers are permitted. Reads do not modify the original word, so there +is no circular assumption about its future source rows. + +**3. Each target still needs at least two new proper-frame arrivals.** +Fix endpoint H. Since `K intersect U(H) = {0}`, every row in `K + U(H)` has +a unique U(H) component. For V contained in H this local component is supported +on S(V). Let E contain all source labels that lie in any proper earlier frame +of this target; grant their contributions for free. The required labels +`N = supp(C_t) minus E` span H by the finite witnesses. + +At H, no original source or G/Q/D helper is present: the new path-avoidance +certificate is essential here. An original C read, if available, supplies only +K, as does the free code oracle. A new helper born at H also starts with source +dependence in K. Thus nonzero local information at H can enter only through +a new helper that transports there from some proper subspace V of H. +Mixing at H cannot create missing local support. An increasing lifetime cannot +leave H and return. + +If at most one new lifetime entered H, all correction contributions would lie +in `K + span{e_s : s in E} + U(V)` for a single proper V (or no V). +The required correction C_t and the latter two spaces lie in U(H), so +injectivity removes the K component. Consequently every label in N would lie +in V. This contradicts their binary span H, since dim V is at most seven. + +**4. The count is 208 distinct new lifetimes.** Distinct dimension-eight +target endpoints are incomparable. One increasing new lifetime can enter at +most one of them. Two per endpoint therefore require at least `2*104 = 208`. +The original 72 helpers are not counted as new lifetimes; step 3 explains why +their additional read permission cannot replace one of the required arrivals. + +The argument is about source projections, so allowing arbitrary dirty state +and even relaxing restoration cannot invalidate the lower bound. Finite replay +certifies the pinned geometry and word premises. The written induction proves +the arbitrary-length implication; no enumeration of every correction network +or proof-assistant verification is claimed. + +## Reproduction and controls + +Python 3.12, standard library only, from the repository root: + +```sh +python3 -I -B research/p104-live-helper-reads/verify.py +python3 -I -O -B research/p104-live-helper-reads/verify.py +python3 -I -O -B research/p104-live-helper-reads/test_verify.py +python3 scripts/research_package.py --package research/p104-live-helper-reads +``` + +Expected marker: +`PASS_P104_LIVE_HELPER_READS original_helpers=72 endpoint_contacts=0 lifetimes=208 controls=8 no_new_kappa`. +Default replay is read-only and Git/network independent. Exact source hashes +are checked before parsing the inputs. The optional `--out NEW.json` writes +a verified receipt exclusively to a new path. + +Eight controls cover a wrong transport rank, missing query compensation, +missing dirty cleanup, the actual outside-K but frame-admissible example, +illegal arbitrary-frame access, a changed target creating an original-helper +endpoint contact, a zero-arrival countermodel with the correction row freely +supplied at the endpoint, and invertible code-basis changes for all 104 minors. +The exported-package tests exercise changed/missing sources, receipt drift, +duplicate JSON keys, and a read-only Git-free replay. The scope remains the +finite logical word: no native phase replay, physical scalar lowering, complete +moment, stock reserve, recursive precision, tape or all-size supplier is checked. + +## Open next questions + +The unchanged original paths have now been tested with all their read-only +helper information. A further escape must change another premise. Can one +original helper visit a target endpoint while preserving its required captures, +query availability and cleanup? First select the helper and endpoint, derive +the new path and price the extra transports; merely re-reading its current +unfinished row is insufficient. + +Alternatively, can a new update before an original private descent carry +useful information outside K? Specify the exact source row and legal read +chronology first, then test dirt restoration and a favorable completed bill. +This changes the read-only contract and is not ruled out here. Structured +versions and blockers are in [TASK.json](TASK.json). + +## Provenance and credit + +Main base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4. +The task card is explicitly changed from full correction construction to +the concrete PR2383 missing implication. Exact predecessor heads, README blobs +and SHA256s are in [PREDECESSORS.json](PREDECESSORS.json); those documents are +context, not imported code. [SOURCES.json](SOURCES.json) pins the two main-branch +scientific inputs and selected/task provenance. The selected frontier and all +frozen files remain unchanged. + +Credit Philippe Van Velzen for the original geometric screen; Hiroki Kumazaki +for PR2353's relay proof; commdata2338 for PR2383's quotient proof and explicit +unfinished-helper handoff; Rohan Arun / PR1972 for the word; Chafik Boukhalfa / +PR1991 for its retained native realization; Adam Gall / PR1940 for the schedule; +Josie Elliston / PR1071 for the fixture; Ali Romman / PR1125 and the retained +geometry/compiler lineage. The new proof extends, and relies on, those ideas. + +Prepared for **ywz65**, with substantial OpenAI Codex assistance in derivation, +implementation, checking and writing. Apache-2.0. No independent human review, +formal proof assistant or selected supplier cold replay is claimed. diff --git a/research/p104-live-helper-reads/RESULT.json b/research/p104-live-helper-reads/RESULT.json new file mode 100644 index 0000000000..efae4e6658 --- /dev/null +++ b/research/p104-live-helper-reads/RESULT.json @@ -0,0 +1,12835 @@ +{ + "claim": "actual-frame original helper reads preserve 208 new monotone lifetimes", + "controls": [ + "wrong native rank rejected", + "missing query compensation rejected", + "missing dirty cleanup rejected", + "actual unfinished outside-K read is quotient-admissible", + "free arbitrary-frame access violates local support", + "new endpoint contact rejected", + "outside-K endpoint oracle permits zero-entrance correction", + "all104 invertible code-basis controls" + ], + "helper_lifetime_floor": 208, + "limits": "read-only original word; no new descending helper, target feedback, arbitrary-frame oracle, supplier or kappa", + "schema_version": 1, + "sources": { + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e", + "research/p104-native-channel/inputs/P104-FIXTURE.json": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + "targets": [ + { + "early": [ + 34, + 91, + 96 + ], + "endpoint": [ + 1, + 2, + 4, + 16, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 3, + 6, + 8, + 14, + 22, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 4, + 5, + 7, + 9, + 15, + 24, + 37 + ], + "support": [ + 2, + 4, + 5, + 7, + 9, + 10, + 12, + 15, + 17, + 18, + 20, + 24, + 26, + 27, + 29, + 34, + 37, + 39, + 41, + 43, + 44, + 46, + 48, + 50, + 51, + 53, + 55, + 57, + 60, + 62, + 64, + 66, + 67, + 69, + 71, + 73, + 76, + 78, + 79, + 81, + 83, + 85, + 87, + 89, + 91, + 96, + 98, + 100 + ], + "target": 0 + }, + { + "early": [], + "endpoint": [ + 3, + 4, + 9, + 16, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 3, + 6, + 8, + 14, + 22, + 34 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 4, + 5, + 7, + 9, + 15, + 24, + 33 + ], + "support": [ + 2, + 4, + 5, + 7, + 9, + 10, + 12, + 15, + 17, + 18, + 20, + 24, + 26, + 27, + 29, + 33, + 35, + 36, + 38, + 40, + 42, + 45, + 47, + 49, + 52, + 54, + 56, + 58, + 59, + 61, + 63, + 65, + 68, + 70, + 72, + 74, + 75, + 77, + 80, + 82, + 84, + 86, + 88, + 90, + 92, + 96, + 98, + 100 + ], + "target": 1 + }, + { + "early": [ + 96 + ], + "endpoint": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 4, + 5, + 9, + 14, + 22, + 33, + 34 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 3, + 7, + 8, + 15, + 24, + 35 + ], + "support": [ + 0, + 1, + 3, + 6, + 7, + 8, + 11, + 12, + 15, + 16, + 19, + 20, + 24, + 25, + 28, + 29, + 35, + 36, + 39, + 40, + 43, + 44, + 47, + 50, + 51, + 54, + 55, + 58, + 59, + 62, + 63, + 66, + 67, + 70, + 71, + 74, + 75, + 78, + 79, + 82, + 85, + 86, + 89, + 92, + 96, + 97, + 99, + 100 + ], + "target": 2 + }, + { + "early": [], + "endpoint": [ + 2, + 4, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 3, + 6, + 7, + 15, + 22, + 34 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 4, + 5, + 8, + 13, + 14, + 23, + 33 + ], + "support": [ + 2, + 4, + 5, + 8, + 11, + 13, + 14, + 16, + 19, + 21, + 23, + 25, + 28, + 30, + 33, + 35, + 36, + 38, + 41, + 43, + 44, + 46, + 48, + 50, + 51, + 53, + 56, + 58, + 59, + 61, + 64, + 66, + 67, + 69, + 72, + 74, + 75, + 77, + 80, + 82, + 84, + 87, + 89, + 91, + 95, + 97, + 99, + 101 + ], + "target": 3 + }, + { + "early": [ + 91 + ], + "endpoint": [ + 2, + 5, + 8, + 17, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 4, + 5, + 7, + 8, + 15, + 22, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 3, + 9, + 13, + 14, + 23, + 35 + ], + "support": [ + 0, + 1, + 3, + 6, + 9, + 10, + 13, + 14, + 17, + 18, + 21, + 23, + 26, + 27, + 30, + 35, + 36, + 39, + 41, + 42, + 45, + 46, + 48, + 49, + 52, + 53, + 55, + 58, + 59, + 62, + 64, + 65, + 68, + 69, + 71, + 74, + 75, + 78, + 79, + 82, + 85, + 87, + 88, + 90, + 91, + 95, + 98, + 101 + ], + "target": 4 + }, + { + "early": [ + 34 + ], + "endpoint": [ + 1, + 6, + 8, + 18, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 4, + 5, + 7, + 8, + 15, + 22, + 35 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 3, + 9, + 13, + 14, + 23, + 33 + ], + "support": [ + 0, + 1, + 3, + 6, + 9, + 10, + 13, + 14, + 17, + 18, + 21, + 23, + 26, + 27, + 30, + 33, + 34, + 37, + 38, + 40, + 43, + 44, + 47, + 50, + 51, + 54, + 56, + 57, + 60, + 61, + 63, + 66, + 67, + 70, + 72, + 73, + 76, + 77, + 80, + 81, + 83, + 84, + 86, + 89, + 92, + 95, + 98, + 101 + ], + "target": 5 + }, + { + "early": [], + "endpoint": [ + 1, + 4, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 3, + 6, + 7, + 15, + 22, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 4, + 5, + 8, + 13, + 14, + 23, + 34 + ], + "support": [ + 2, + 4, + 5, + 8, + 11, + 13, + 14, + 16, + 19, + 21, + 23, + 25, + 28, + 30, + 34, + 37, + 39, + 40, + 42, + 45, + 47, + 49, + 52, + 54, + 55, + 57, + 60, + 62, + 63, + 65, + 68, + 70, + 71, + 73, + 76, + 78, + 79, + 81, + 83, + 85, + 86, + 88, + 90, + 92, + 95, + 97, + 99, + 101 + ], + "target": 6 + }, + { + "early": [], + "endpoint": [ + 2, + 5, + 9, + 17, + 33, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 7, + 12, + 14, + 23, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 2, + 8, + 13, + 15, + 22, + 34 + ], + "support": [ + 0, + 1, + 2, + 8, + 9, + 10, + 11, + 13, + 15, + 20, + 22, + 24, + 29, + 31, + 34, + 35, + 38, + 39, + 40, + 41, + 44, + 45, + 49, + 50, + 53, + 54, + 55, + 56, + 59, + 60, + 65, + 66, + 69, + 70, + 71, + 72, + 75, + 76, + 81, + 84, + 85, + 86, + 87, + 90, + 94, + 96, + 100, + 102 + ], + "target": 7 + }, + { + "early": [ + 68 + ], + "endpoint": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 8, + 11, + 14, + 23, + 34 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 2, + 3, + 6, + 7, + 9, + 16, + 22, + 33 + ], + "support": [ + 2, + 3, + 6, + 7, + 9, + 10, + 12, + 13, + 16, + 19, + 22, + 25, + 28, + 31, + 33, + 35, + 37, + 39, + 40, + 42, + 44, + 46, + 48, + 50, + 52, + 54, + 55, + 57, + 59, + 61, + 64, + 66, + 68, + 70, + 71, + 73, + 75, + 77, + 80, + 83, + 85, + 86, + 88, + 91, + 94, + 97, + 99, + 102 + ], + "target": 8 + }, + { + "early": [ + 56, + 91 + ], + "endpoint": [ + 1, + 2, + 4, + 24, + 40, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 9, + 10, + 14, + 23, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 4, + 7, + 8, + 17, + 22, + 35 + ], + "support": [ + 0, + 1, + 4, + 5, + 7, + 8, + 11, + 12, + 13, + 17, + 18, + 22, + 26, + 27, + 31, + 35, + 37, + 38, + 40, + 43, + 45, + 46, + 48, + 49, + 51, + 54, + 56, + 57, + 59, + 62, + 64, + 65, + 67, + 70, + 72, + 73, + 75, + 78, + 79, + 83, + 84, + 86, + 89, + 90, + 91, + 94, + 98, + 102 + ], + "target": 9 + }, + { + "early": [ + 34, + 68 + ], + "endpoint": [ + 3, + 4, + 9, + 17, + 33, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 9, + 10, + 14, + 23, + 35 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 4, + 7, + 8, + 17, + 22, + 33 + ], + "support": [ + 0, + 1, + 4, + 5, + 7, + 8, + 11, + 12, + 13, + 17, + 18, + 22, + 26, + 27, + 31, + 33, + 34, + 36, + 39, + 41, + 42, + 44, + 47, + 50, + 52, + 53, + 55, + 58, + 60, + 61, + 63, + 66, + 68, + 69, + 71, + 74, + 76, + 77, + 80, + 81, + 82, + 85, + 87, + 88, + 92, + 94, + 98, + 102 + ], + "target": 10 + }, + { + "early": [ + 56 + ], + "endpoint": [ + 3, + 5, + 8, + 17, + 33, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 8, + 11, + 14, + 23, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 2, + 3, + 6, + 7, + 9, + 16, + 22, + 34 + ], + "support": [ + 2, + 3, + 6, + 7, + 9, + 10, + 12, + 13, + 16, + 19, + 22, + 25, + 28, + 31, + 34, + 36, + 38, + 41, + 43, + 45, + 47, + 49, + 51, + 53, + 56, + 58, + 60, + 62, + 63, + 65, + 67, + 69, + 72, + 74, + 76, + 78, + 79, + 81, + 82, + 84, + 87, + 89, + 90, + 92, + 94, + 97, + 99, + 102 + ], + "target": 11 + }, + { + "early": [], + "endpoint": [ + 1, + 6, + 10, + 18, + 34, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 7, + 12, + 14, + 23, + 34 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 2, + 8, + 13, + 15, + 22, + 33 + ], + "support": [ + 0, + 1, + 2, + 8, + 9, + 10, + 11, + 13, + 15, + 20, + 22, + 24, + 29, + 31, + 33, + 36, + 37, + 42, + 43, + 46, + 47, + 48, + 51, + 52, + 57, + 58, + 61, + 62, + 63, + 64, + 67, + 68, + 73, + 74, + 77, + 78, + 79, + 80, + 82, + 83, + 88, + 89, + 91, + 92, + 94, + 96, + 100, + 102 + ], + "target": 12 + }, + { + "early": [ + 30 + ], + "endpoint": [ + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 13, + 15, + 24, + 36, + 40 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 3, + 4, + 5, + 7, + 8, + 14, + 22, + 33 + ], + "support": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 14, + 21, + 22, + 23, + 30, + 31, + 33, + 34, + 35, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 90, + 91, + 92, + 94, + 95, + 101, + 102 + ], + "target": 13 + }, + { + "early": [], + "endpoint": [ + 2, + 5, + 9, + 16, + 33, + 65, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 7, + 14, + 21, + 22, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 3, + 4, + 5, + 13, + 15, + 16, + 23, + 36 + ], + "support": [ + 3, + 4, + 5, + 6, + 13, + 15, + 16, + 17, + 18, + 19, + 20, + 23, + 30, + 32, + 36, + 37, + 38, + 39, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 93, + 95, + 101, + 103 + ], + "target": 14 + }, + { + "early": [ + 51 + ], + "endpoint": [ + 1, + 2, + 4, + 8, + 48, + 80, + 128, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 8, + 15, + 20, + 22, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 2, + 7, + 14, + 16, + 24, + 34 + ], + "support": [ + 0, + 1, + 2, + 7, + 12, + 14, + 16, + 17, + 18, + 19, + 21, + 24, + 29, + 32, + 34, + 35, + 38, + 39, + 42, + 43, + 46, + 47, + 48, + 51, + 52, + 55, + 56, + 59, + 60, + 65, + 66, + 69, + 70, + 73, + 74, + 77, + 78, + 79, + 80, + 82, + 83, + 86, + 87, + 90, + 93, + 96, + 100, + 103 + ], + "target": 15 + }, + { + "early": [ + 51, + 68 + ], + "endpoint": [ + 2, + 4, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 7, + 16, + 19, + 22, + 34 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 3, + 6, + 8, + 14, + 17, + 25, + 33 + ], + "support": [ + 2, + 3, + 6, + 8, + 11, + 14, + 15, + 17, + 18, + 20, + 21, + 25, + 28, + 32, + 33, + 35, + 37, + 39, + 41, + 43, + 45, + 47, + 49, + 51, + 53, + 55, + 57, + 59, + 61, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 79, + 81, + 82, + 84, + 86, + 88, + 91, + 93, + 97, + 99, + 103 + ], + "target": 16 + }, + { + "early": [ + 53, + 56, + 71, + 91 + ], + "endpoint": [ + 2, + 5, + 8, + 17, + 33, + 65, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 7, + 17, + 18, + 22, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 4, + 9, + 14, + 16, + 26, + 35 + ], + "support": [ + 0, + 1, + 4, + 5, + 9, + 10, + 14, + 15, + 16, + 19, + 20, + 21, + 26, + 27, + 32, + 35, + 37, + 38, + 41, + 42, + 44, + 47, + 50, + 52, + 53, + 56, + 57, + 59, + 62, + 64, + 65, + 67, + 70, + 71, + 74, + 76, + 77, + 80, + 81, + 82, + 85, + 86, + 89, + 90, + 91, + 93, + 98, + 103 + ], + "target": 17 + }, + { + "early": [ + 34, + 51, + 68, + 73 + ], + "endpoint": [ + 1, + 6, + 8, + 18, + 34, + 66, + 128, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 7, + 17, + 18, + 22, + 35 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 4, + 9, + 14, + 16, + 26, + 33 + ], + "support": [ + 0, + 1, + 4, + 5, + 9, + 10, + 14, + 15, + 16, + 19, + 20, + 21, + 26, + 27, + 32, + 33, + 34, + 36, + 39, + 40, + 43, + 45, + 46, + 48, + 49, + 51, + 54, + 55, + 58, + 60, + 61, + 63, + 66, + 68, + 69, + 72, + 73, + 75, + 78, + 79, + 83, + 84, + 87, + 88, + 92, + 93, + 98, + 103 + ], + "target": 18 + }, + { + "early": [ + 56, + 71 + ], + "endpoint": [ + 1, + 4, + 10, + 18, + 34, + 66, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 7, + 16, + 19, + 22, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 3, + 6, + 8, + 14, + 17, + 25, + 34 + ], + "support": [ + 2, + 3, + 6, + 8, + 11, + 14, + 15, + 17, + 18, + 20, + 21, + 25, + 28, + 32, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 63, + 65, + 67, + 69, + 71, + 73, + 75, + 77, + 80, + 83, + 85, + 87, + 89, + 90, + 92, + 93, + 97, + 99, + 103 + ], + "target": 19 + }, + { + "early": [ + 71 + ], + "endpoint": [ + 3, + 4, + 8, + 17, + 33, + 65, + 128, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 8, + 15, + 20, + 22, + 34 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 2, + 7, + 14, + 16, + 24, + 33 + ], + "support": [ + 0, + 1, + 2, + 7, + 12, + 14, + 16, + 17, + 18, + 19, + 21, + 24, + 29, + 32, + 33, + 36, + 37, + 40, + 41, + 44, + 45, + 49, + 50, + 53, + 54, + 57, + 58, + 61, + 62, + 63, + 64, + 67, + 68, + 71, + 72, + 75, + 76, + 81, + 84, + 85, + 88, + 89, + 91, + 92, + 93, + 96, + 100, + 103 + ], + "target": 20 + }, + { + "early": [ + 30, + 51, + 71 + ], + "endpoint": [ + 1, + 6, + 10, + 16, + 34, + 66, + 128, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 7, + 14, + 21, + 22, + 36 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 3, + 4, + 5, + 13, + 15, + 16, + 23, + 33 + ], + "support": [ + 3, + 4, + 5, + 6, + 13, + 15, + 16, + 17, + 18, + 19, + 20, + 23, + 30, + 32, + 33, + 34, + 35, + 40, + 41, + 42, + 43, + 51, + 52, + 53, + 54, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 71, + 72, + 73, + 74, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 95, + 101, + 103 + ], + "target": 21 + }, + { + "early": [ + 32, + 94, + 102 + ], + "endpoint": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 14, + 22, + 31, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 7, + 8, + 9, + 10, + 13, + 23, + 40, + 55 + ], + "support": [ + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 32, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 94, + 102 + ], + "target": 22 + }, + { + "early": [ + 32 + ], + "endpoint": [ + 1, + 2, + 4, + 8, + 16, + 96, + 160, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 7, + 15, + 23, + 30, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 3, + 4, + 5, + 13, + 14, + 22, + 24, + 36 + ], + "support": [ + 3, + 4, + 5, + 6, + 13, + 14, + 21, + 22, + 24, + 25, + 26, + 27, + 28, + 29, + 31, + 32, + 36, + 37, + 38, + 39, + 44, + 45, + 46, + 51, + 52, + 53, + 54, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 71, + 72, + 73, + 74, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 95, + 101 + ], + "target": 23 + }, + { + "early": [ + 32, + 50 + ], + "endpoint": [ + 2, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 8, + 14, + 24, + 29, + 33 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 2, + 7, + 15, + 22, + 23, + 34 + ], + "support": [ + 0, + 1, + 2, + 7, + 12, + 15, + 20, + 22, + 23, + 25, + 26, + 27, + 28, + 30, + 31, + 32, + 34, + 35, + 38, + 39, + 42, + 43, + 46, + 49, + 50, + 53, + 54, + 57, + 58, + 61, + 62, + 63, + 64, + 67, + 68, + 71, + 72, + 75, + 76, + 79, + 80, + 82, + 83, + 86, + 87, + 90, + 96, + 100 + ], + "target": 24 + }, + { + "early": [ + 32, + 45, + 50, + 65 + ], + "endpoint": [ + 1, + 2, + 8, + 20, + 36, + 68, + 132, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 7, + 14, + 25, + 28, + 34 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 2, + 3, + 6, + 8, + 16, + 22, + 26, + 33 + ], + "support": [ + 2, + 3, + 6, + 8, + 11, + 16, + 19, + 22, + 23, + 24, + 26, + 27, + 29, + 30, + 31, + 32, + 33, + 35, + 37, + 39, + 41, + 43, + 45, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 63, + 65, + 67, + 69, + 71, + 73, + 75, + 77, + 79, + 81, + 82, + 84, + 86, + 88, + 91, + 97, + 99 + ], + "target": 25 + }, + { + "early": [ + 17, + 18, + 25, + 28, + 32, + 48, + 61, + 63, + 78, + 80, + 91, + 98 + ], + "endpoint": [ + 1, + 2, + 4, + 24, + 40, + 72, + 136, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 7, + 14, + 26, + 27, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 4, + 9, + 22, + 35, + 38, + 49 + ], + "support": [ + 0, + 1, + 4, + 5, + 9, + 10, + 17, + 18, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 32, + 35, + 37, + 38, + 41, + 42, + 44, + 48, + 49, + 51, + 54, + 55, + 58, + 60, + 61, + 63, + 66, + 68, + 69, + 72, + 73, + 75, + 78, + 80, + 81, + 82, + 85, + 86, + 89, + 90, + 91, + 98 + ], + "target": 26 + }, + { + "early": [ + 17, + 18, + 25, + 28, + 32, + 34, + 45, + 50, + 59, + 65, + 76, + 98 + ], + "endpoint": [ + 3, + 4, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 7, + 14, + 26, + 27, + 35 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 4, + 9, + 22, + 33, + 36, + 47 + ], + "support": [ + 0, + 1, + 4, + 5, + 9, + 10, + 17, + 18, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 36, + 39, + 40, + 43, + 45, + 46, + 47, + 50, + 52, + 53, + 56, + 57, + 59, + 62, + 64, + 65, + 67, + 70, + 71, + 74, + 76, + 77, + 79, + 83, + 84, + 87, + 88, + 92, + 98 + ], + "target": 27 + }, + { + "early": [ + 32, + 61, + 78, + 80 + ], + "endpoint": [ + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 7, + 14, + 25, + 28, + 33 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 2, + 3, + 6, + 8, + 16, + 22, + 26, + 34 + ], + "support": [ + 2, + 3, + 6, + 8, + 11, + 16, + 19, + 22, + 23, + 24, + 26, + 27, + 29, + 30, + 31, + 32, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 47, + 49, + 51, + 53, + 55, + 57, + 59, + 61, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 80, + 83, + 85, + 87, + 89, + 90, + 92, + 97, + 99 + ], + "target": 28 + }, + { + "early": [ + 32, + 78 + ], + "endpoint": [ + 1, + 6, + 10, + 18, + 34, + 66, + 130, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 8, + 14, + 24, + 29, + 34 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 2, + 7, + 15, + 22, + 23, + 33 + ], + "support": [ + 0, + 1, + 2, + 7, + 12, + 15, + 20, + 22, + 23, + 25, + 26, + 27, + 28, + 30, + 31, + 32, + 33, + 36, + 37, + 40, + 41, + 44, + 45, + 47, + 48, + 51, + 52, + 55, + 56, + 59, + 60, + 65, + 66, + 69, + 70, + 73, + 74, + 77, + 78, + 81, + 84, + 85, + 88, + 89, + 91, + 92, + 96, + 100 + ], + "target": 29 + }, + { + "early": [ + 13, + 32, + 50, + 78 + ], + "endpoint": [ + 3, + 4, + 8, + 16, + 33, + 65, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 7, + 15, + 23, + 30, + 36 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 3, + 4, + 5, + 14, + 22, + 24, + 25, + 33 + ], + "support": [ + 3, + 4, + 5, + 6, + 13, + 14, + 21, + 22, + 24, + 25, + 26, + 27, + 28, + 29, + 31, + 32, + 33, + 34, + 35, + 40, + 41, + 42, + 43, + 47, + 48, + 49, + 50, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 75, + 76, + 77, + 78, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 95, + 101 + ], + "target": 30 + }, + { + "early": [ + 13, + 23, + 30, + 32, + 39, + 50, + 51, + 71, + 78, + 89, + 94, + 102 + ], + "endpoint": [ + 1, + 6, + 10, + 16, + 32, + 66, + 130, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 14, + 22, + 31, + 40 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 7, + 8, + 9, + 10, + 24, + 33, + 36, + 47 + ], + "support": [ + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 94, + 102 + ], + "target": 31 + }, + { + "early": [ + 23, + 30, + 39, + 89 + ], + "endpoint": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 7, + 32, + 47, + 63 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 14, + 15, + 16, + 17, + 18, + 22, + 24, + 33 + ], + "support": [ + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 103 + ], + "target": 32 + }, + { + "early": [ + 5, + 25, + 30, + 34, + 37, + 39, + 56, + 61, + 63, + 68, + 91, + 96 + ], + "endpoint": [ + 1, + 2, + 12, + 16, + 32, + 64, + 128, + 260 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 7, + 14, + 22, + 33, + 38 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 3, + 8, + 10, + 12, + 16, + 27, + 35 + ], + "support": [ + 1, + 3, + 5, + 8, + 10, + 12, + 13, + 16, + 18, + 20, + 21, + 25, + 27, + 29, + 30, + 31, + 32, + 34, + 35, + 36, + 37, + 39, + 40, + 41, + 43, + 45, + 47, + 48, + 50, + 52, + 56, + 61, + 63, + 64, + 66, + 68, + 72, + 77, + 80, + 84, + 88, + 91, + 92, + 93, + 94, + 95, + 96, + 99 + ], + "target": 33 + }, + { + "early": [ + 5, + 30, + 39, + 63 + ], + "endpoint": [ + 2, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 8, + 14, + 22, + 34, + 37 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 6, + 7, + 10, + 11, + 15, + 24, + 33 + ], + "support": [ + 0, + 5, + 6, + 7, + 10, + 11, + 13, + 15, + 18, + 19, + 21, + 24, + 27, + 28, + 30, + 31, + 32, + 33, + 35, + 36, + 38, + 39, + 40, + 42, + 43, + 46, + 47, + 49, + 50, + 53, + 57, + 60, + 63, + 65, + 66, + 69, + 73, + 76, + 81, + 83, + 87, + 90, + 92, + 93, + 94, + 95, + 97, + 100 + ], + "target": 34 + }, + { + "early": [ + 30, + 39 + ], + "endpoint": [ + 1, + 4, + 10, + 16, + 32, + 64, + 128, + 258 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 10, + 14, + 22, + 35, + 36 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 3, + 7, + 8, + 15, + 24, + 33 + ], + "support": [ + 1, + 2, + 3, + 4, + 7, + 8, + 9, + 13, + 15, + 16, + 17, + 21, + 24, + 25, + 26, + 30, + 31, + 32, + 33, + 34, + 37, + 38, + 39, + 41, + 42, + 43, + 48, + 49, + 50, + 54, + 58, + 59, + 64, + 65, + 66, + 70, + 74, + 75, + 82, + 86, + 90, + 91, + 93, + 94, + 95, + 98, + 99, + 100 + ], + "target": 35 + }, + { + "early": [ + 39, + 63 + ], + "endpoint": [ + 1, + 2, + 4, + 24, + 32, + 64, + 128, + 264 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 7, + 15, + 22, + 35, + 36 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 3, + 10, + 12, + 14, + 23, + 33 + ], + "support": [ + 1, + 2, + 3, + 4, + 10, + 11, + 12, + 14, + 18, + 19, + 20, + 23, + 27, + 28, + 29, + 31, + 32, + 33, + 34, + 37, + 38, + 39, + 40, + 44, + 45, + 46, + 47, + 51, + 52, + 53, + 58, + 59, + 63, + 67, + 68, + 69, + 74, + 75, + 82, + 87, + 88, + 89, + 92, + 93, + 94, + 96, + 97, + 101 + ], + "target": 36 + }, + { + "early": [ + 39 + ], + "endpoint": [ + 3, + 5, + 8, + 17, + 32, + 64, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 7, + 15, + 22, + 34, + 37 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 5, + 6, + 8, + 12, + 14, + 23, + 33 + ], + "support": [ + 0, + 5, + 6, + 8, + 9, + 12, + 14, + 16, + 17, + 20, + 23, + 25, + 26, + 29, + 31, + 32, + 33, + 35, + 36, + 38, + 39, + 41, + 44, + 45, + 48, + 51, + 52, + 54, + 57, + 60, + 64, + 67, + 68, + 70, + 73, + 76, + 81, + 83, + 86, + 88, + 89, + 91, + 93, + 94, + 96, + 98, + 99, + 101 + ], + "target": 37 + }, + { + "early": [ + 39, + 56, + 61 + ], + "endpoint": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 258 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 8, + 16, + 22, + 33, + 38 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 3, + 5, + 7, + 9, + 14, + 23, + 34 + ], + "support": [ + 1, + 3, + 5, + 7, + 9, + 11, + 14, + 15, + 17, + 19, + 23, + 24, + 26, + 28, + 31, + 32, + 34, + 35, + 36, + 37, + 39, + 42, + 44, + 46, + 49, + 51, + 53, + 54, + 56, + 61, + 65, + 67, + 69, + 70, + 72, + 77, + 80, + 84, + 86, + 87, + 89, + 90, + 93, + 94, + 97, + 98, + 100, + 101 + ], + "target": 38 + }, + { + "early": [ + 25, + 34, + 37, + 68 + ], + "endpoint": [ + 1, + 4, + 8, + 18, + 32, + 64, + 128, + 258 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 9, + 17, + 22, + 39, + 40 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 4, + 7, + 8, + 14, + 23, + 33 + ], + "support": [ + 0, + 2, + 4, + 6, + 7, + 8, + 10, + 14, + 15, + 16, + 18, + 23, + 24, + 25, + 27, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 43, + 45, + 46, + 50, + 52, + 53, + 54, + 55, + 62, + 66, + 68, + 69, + 70, + 71, + 78, + 79, + 85, + 86, + 87, + 88, + 93, + 94, + 99, + 100, + 101 + ], + "target": 39 + }, + { + "early": [ + 63 + ], + "endpoint": [ + 2, + 5, + 8, + 17, + 33, + 64, + 128, + 257 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 10, + 14, + 23, + 35, + 40 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 5, + 7, + 8, + 18, + 22, + 33 + ], + "support": [ + 1, + 2, + 5, + 6, + 7, + 8, + 9, + 18, + 19, + 20, + 21, + 22, + 27, + 28, + 29, + 30, + 32, + 33, + 34, + 36, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 54, + 55, + 56, + 57, + 59, + 63, + 70, + 71, + 72, + 73, + 75, + 83, + 84, + 85, + 86, + 92, + 93, + 95, + 96, + 97, + 102 + ], + "target": 40 + }, + { + "early": [], + "endpoint": [ + 1, + 4, + 10, + 18, + 34, + 64, + 128, + 258 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 8, + 14, + 23, + 34, + 41 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 3, + 4, + 7, + 10, + 16, + 22, + 33 + ], + "support": [ + 0, + 3, + 4, + 7, + 10, + 11, + 16, + 17, + 20, + 21, + 22, + 25, + 26, + 29, + 30, + 32, + 33, + 35, + 37, + 40, + 42, + 43, + 44, + 45, + 48, + 53, + 55, + 56, + 58, + 60, + 64, + 69, + 71, + 72, + 74, + 76, + 81, + 82, + 84, + 85, + 87, + 91, + 93, + 95, + 96, + 98, + 99, + 102 + ], + "target": 41 + }, + { + "early": [ + 61 + ], + "endpoint": [ + 3, + 4, + 8, + 17, + 33, + 64, + 128, + 257 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 7, + 14, + 23, + 33, + 42 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 4, + 6, + 8, + 12, + 15, + 22, + 34 + ], + "support": [ + 1, + 4, + 6, + 8, + 10, + 12, + 15, + 17, + 19, + 21, + 22, + 24, + 26, + 28, + 30, + 32, + 34, + 35, + 38, + 40, + 41, + 43, + 44, + 46, + 49, + 52, + 55, + 57, + 58, + 61, + 65, + 68, + 71, + 73, + 74, + 77, + 80, + 82, + 83, + 85, + 88, + 90, + 93, + 95, + 97, + 98, + 100, + 102 + ], + "target": 42 + }, + { + "early": [ + 25, + 34 + ], + "endpoint": [ + 3, + 5, + 9, + 17, + 33, + 64, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 7, + 14, + 23, + 36, + 43 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 3, + 9, + 12, + 15, + 22, + 33 + ], + "support": [ + 0, + 2, + 3, + 5, + 9, + 11, + 12, + 15, + 16, + 18, + 21, + 22, + 24, + 25, + 27, + 30, + 32, + 33, + 34, + 35, + 39, + 40, + 41, + 42, + 45, + 46, + 50, + 51, + 56, + 57, + 58, + 62, + 66, + 67, + 72, + 73, + 74, + 78, + 79, + 82, + 83, + 84, + 89, + 93, + 95, + 99, + 100, + 102 + ], + "target": 43 + }, + { + "early": [ + 61, + 96 + ], + "endpoint": [ + 1, + 6, + 10, + 16, + 34, + 64, + 128, + 258 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 9, + 15, + 24, + 33, + 44 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 3, + 7, + 8, + 14, + 22, + 36 + ], + "support": [ + 0, + 2, + 3, + 5, + 7, + 8, + 10, + 13, + 14, + 17, + 19, + 20, + 22, + 23, + 26, + 28, + 29, + 32, + 36, + 37, + 38, + 40, + 41, + 42, + 45, + 46, + 50, + 51, + 55, + 59, + 60, + 61, + 66, + 67, + 71, + 75, + 76, + 77, + 80, + 81, + 85, + 89, + 93, + 96, + 97, + 98, + 101, + 102 + ], + "target": 44 + }, + { + "early": [ + 25 + ], + "endpoint": [ + 1, + 4, + 8, + 16, + 34, + 64, + 128, + 258 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 8, + 15, + 24, + 34, + 45 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 4, + 6, + 7, + 9, + 14, + 22, + 33 + ], + "support": [ + 1, + 4, + 6, + 7, + 9, + 11, + 13, + 14, + 16, + 18, + 20, + 22, + 23, + 25, + 27, + 29, + 32, + 33, + 36, + 37, + 39, + 40, + 41, + 43, + 44, + 46, + 49, + 52, + 56, + 59, + 60, + 62, + 65, + 68, + 72, + 75, + 76, + 78, + 79, + 81, + 84, + 88, + 90, + 93, + 96, + 99, + 101, + 102 + ], + "target": 45 + }, + { + "early": [], + "endpoint": [ + 3, + 4, + 9, + 16, + 33, + 64, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 7, + 16, + 25, + 33, + 46 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 3, + 4, + 8, + 12, + 14, + 22, + 34 + ], + "support": [ + 0, + 3, + 4, + 8, + 9, + 12, + 13, + 14, + 15, + 18, + 19, + 22, + 23, + 24, + 27, + 28, + 32, + 34, + 36, + 38, + 39, + 40, + 42, + 43, + 44, + 45, + 48, + 53, + 57, + 59, + 61, + 62, + 64, + 69, + 73, + 75, + 77, + 78, + 79, + 80, + 83, + 87, + 91, + 93, + 97, + 100, + 101, + 102 + ], + "target": 46 + }, + { + "early": [ + 17, + 63, + 78 + ], + "endpoint": [ + 1, + 2, + 4, + 24, + 40, + 72, + 128, + 264 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 7, + 18, + 22, + 35, + 47 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 5, + 10, + 12, + 14, + 27, + 33 + ], + "support": [ + 1, + 2, + 5, + 6, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 27, + 28, + 29, + 30, + 31, + 33, + 34, + 36, + 40, + 48, + 49, + 50, + 51, + 52, + 53, + 55, + 56, + 57, + 59, + 63, + 70, + 74, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 86, + 92, + 94, + 95, + 96, + 97, + 103 + ], + "target": 47 + }, + { + "early": [ + 78 + ], + "endpoint": [ + 3, + 5, + 8, + 17, + 33, + 65, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 7, + 16, + 22, + 34, + 48 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 3, + 4, + 8, + 12, + 14, + 25, + 33 + ], + "support": [ + 0, + 3, + 4, + 8, + 9, + 12, + 13, + 14, + 15, + 18, + 19, + 25, + 26, + 29, + 30, + 31, + 33, + 35, + 37, + 41, + 46, + 47, + 49, + 50, + 51, + 52, + 54, + 55, + 56, + 58, + 60, + 64, + 69, + 73, + 75, + 77, + 78, + 79, + 80, + 83, + 87, + 91, + 94, + 95, + 96, + 98, + 99, + 103 + ], + "target": 48 + }, + { + "early": [ + 61, + 78 + ], + "endpoint": [ + 1, + 6, + 10, + 18, + 34, + 66, + 128, + 258 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 8, + 15, + 22, + 33, + 49 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 4, + 6, + 7, + 9, + 14, + 24, + 34 + ], + "support": [ + 1, + 4, + 6, + 7, + 9, + 11, + 13, + 14, + 16, + 18, + 20, + 24, + 26, + 28, + 30, + 31, + 34, + 35, + 38, + 42, + 45, + 47, + 48, + 50, + 51, + 53, + 54, + 55, + 57, + 58, + 61, + 65, + 68, + 72, + 75, + 76, + 78, + 79, + 81, + 84, + 88, + 90, + 94, + 95, + 97, + 98, + 100, + 103 + ], + "target": 49 + }, + { + "early": [ + 17, + 25, + 34, + 76 + ], + "endpoint": [ + 1, + 4, + 8, + 18, + 34, + 66, + 128, + 258 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 9, + 15, + 22, + 36, + 50 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 3, + 7, + 8, + 14, + 24, + 33 + ], + "support": [ + 0, + 2, + 3, + 5, + 7, + 8, + 10, + 13, + 14, + 17, + 19, + 20, + 24, + 25, + 27, + 30, + 31, + 33, + 34, + 35, + 39, + 43, + 44, + 47, + 48, + 49, + 52, + 53, + 54, + 56, + 57, + 58, + 62, + 66, + 67, + 71, + 75, + 76, + 77, + 80, + 81, + 85, + 89, + 94, + 95, + 99, + 100, + 103 + ], + "target": 50 + }, + { + "early": [ + 15, + 61, + 78, + 96 + ], + "endpoint": [ + 3, + 4, + 8, + 16, + 33, + 65, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 7, + 14, + 22, + 33, + 51 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 3, + 9, + 12, + 16, + 23, + 36 + ], + "support": [ + 0, + 2, + 3, + 5, + 9, + 11, + 12, + 15, + 16, + 18, + 21, + 23, + 26, + 28, + 29, + 31, + 36, + 37, + 38, + 43, + 44, + 47, + 48, + 49, + 52, + 53, + 54, + 55, + 59, + 60, + 61, + 66, + 67, + 72, + 73, + 74, + 78, + 79, + 82, + 83, + 84, + 89, + 94, + 96, + 97, + 98, + 101, + 103 + ], + "target": 51 + }, + { + "early": [ + 17, + 25 + ], + "endpoint": [ + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 7, + 14, + 22, + 34, + 52 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 4, + 6, + 8, + 12, + 15, + 23, + 33 + ], + "support": [ + 1, + 4, + 6, + 8, + 10, + 12, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 36, + 37, + 39, + 42, + 45, + 47, + 48, + 50, + 51, + 53, + 54, + 56, + 59, + 60, + 62, + 65, + 68, + 71, + 73, + 74, + 77, + 80, + 82, + 83, + 85, + 88, + 90, + 94, + 96, + 99, + 101, + 103 + ], + "target": 52 + }, + { + "early": [ + 17 + ], + "endpoint": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 258 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 8, + 14, + 22, + 33, + 53 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 3, + 4, + 7, + 10, + 16, + 23, + 34 + ], + "support": [ + 0, + 3, + 4, + 7, + 10, + 11, + 16, + 17, + 20, + 21, + 23, + 24, + 27, + 28, + 31, + 34, + 36, + 38, + 39, + 41, + 46, + 47, + 49, + 50, + 51, + 52, + 54, + 57, + 59, + 61, + 62, + 64, + 69, + 71, + 72, + 74, + 76, + 81, + 82, + 84, + 85, + 87, + 91, + 94, + 97, + 100, + 101, + 103 + ], + "target": 53 + }, + { + "early": [], + "endpoint": [ + 2, + 4, + 9, + 16, + 33, + 65, + 128, + 257 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 10, + 14, + 22, + 33, + 54 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 2, + 5, + 7, + 8, + 18, + 23, + 35 + ], + "support": [ + 1, + 2, + 5, + 6, + 7, + 8, + 9, + 18, + 19, + 20, + 21, + 23, + 24, + 25, + 26, + 31, + 35, + 37, + 38, + 39, + 40, + 48, + 49, + 50, + 51, + 52, + 53, + 58, + 60, + 61, + 62, + 63, + 70, + 71, + 72, + 73, + 75, + 83, + 84, + 85, + 86, + 92, + 94, + 98, + 99, + 100, + 101, + 103 + ], + "target": 54 + }, + { + "early": [ + 15, + 30, + 39, + 42, + 51, + 56, + 61, + 68, + 71, + 78, + 96, + 102 + ], + "endpoint": [ + 1, + 6, + 10, + 16, + 32, + 66, + 128, + 258 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 9, + 17, + 23, + 33, + 55 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 4, + 7, + 8, + 14, + 22, + 40 + ], + "support": [ + 0, + 2, + 4, + 6, + 7, + 8, + 10, + 14, + 15, + 16, + 18, + 22, + 26, + 28, + 29, + 30, + 39, + 40, + 41, + 42, + 44, + 47, + 48, + 49, + 51, + 56, + 57, + 58, + 59, + 60, + 61, + 66, + 68, + 69, + 70, + 71, + 78, + 79, + 85, + 86, + 87, + 88, + 95, + 96, + 97, + 98, + 102, + 103 + ], + "target": 55 + }, + { + "early": [ + 11, + 17, + 25, + 102 + ], + "endpoint": [ + 1, + 4, + 8, + 16, + 32, + 66, + 128, + 258 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 8, + 16, + 23, + 34, + 56 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 3, + 5, + 7, + 9, + 14, + 22, + 33 + ], + "support": [ + 1, + 3, + 5, + 7, + 9, + 11, + 14, + 15, + 17, + 19, + 22, + 25, + 27, + 29, + 30, + 33, + 38, + 40, + 41, + 43, + 45, + 47, + 48, + 50, + 52, + 55, + 57, + 58, + 59, + 60, + 62, + 65, + 67, + 69, + 70, + 72, + 77, + 80, + 84, + 86, + 87, + 89, + 90, + 95, + 96, + 99, + 102, + 103 + ], + "target": 56 + }, + { + "early": [ + 17, + 102 + ], + "endpoint": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 7, + 15, + 23, + 33, + 57 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 5, + 6, + 8, + 12, + 14, + 22, + 34 + ], + "support": [ + 0, + 5, + 6, + 8, + 9, + 12, + 14, + 16, + 17, + 20, + 22, + 24, + 27, + 28, + 30, + 34, + 37, + 40, + 42, + 43, + 46, + 47, + 49, + 50, + 53, + 55, + 56, + 58, + 59, + 61, + 62, + 64, + 67, + 68, + 70, + 73, + 76, + 81, + 83, + 86, + 88, + 89, + 91, + 95, + 97, + 100, + 102, + 103 + ], + "target": 57 + }, + { + "early": [ + 102 + ], + "endpoint": [ + 1, + 2, + 8, + 16, + 32, + 68, + 128, + 260 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 7, + 15, + 23, + 33, + 58 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 2, + 3, + 10, + 12, + 14, + 22, + 35 + ], + "support": [ + 1, + 2, + 3, + 4, + 10, + 11, + 12, + 14, + 18, + 19, + 20, + 22, + 24, + 25, + 26, + 30, + 35, + 36, + 41, + 42, + 43, + 48, + 49, + 50, + 54, + 55, + 56, + 57, + 60, + 61, + 62, + 63, + 67, + 68, + 69, + 74, + 75, + 82, + 87, + 88, + 89, + 92, + 95, + 98, + 99, + 100, + 102, + 103 + ], + "target": 58 + }, + { + "early": [ + 17, + 51, + 82, + 102 + ], + "endpoint": [ + 1, + 6, + 8, + 18, + 32, + 66, + 128, + 258 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 10, + 14, + 24, + 33, + 59 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 3, + 7, + 8, + 15, + 22, + 35 + ], + "support": [ + 1, + 2, + 3, + 4, + 7, + 8, + 9, + 13, + 15, + 16, + 17, + 21, + 22, + 23, + 27, + 28, + 29, + 35, + 36, + 40, + 44, + 45, + 46, + 47, + 51, + 52, + 53, + 55, + 56, + 57, + 60, + 61, + 62, + 64, + 65, + 66, + 70, + 74, + 75, + 82, + 86, + 90, + 91, + 96, + 97, + 101, + 102, + 103 + ], + "target": 59 + }, + { + "early": [ + 51, + 102 + ], + "endpoint": [ + 2, + 4, + 9, + 17, + 32, + 65, + 128, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 8, + 14, + 24, + 33, + 60 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 5, + 6, + 7, + 10, + 15, + 22, + 34 + ], + "support": [ + 0, + 5, + 6, + 7, + 10, + 11, + 13, + 15, + 18, + 19, + 21, + 22, + 23, + 25, + 26, + 29, + 34, + 37, + 41, + 44, + 45, + 48, + 51, + 52, + 54, + 55, + 56, + 58, + 59, + 61, + 62, + 63, + 65, + 66, + 69, + 73, + 76, + 81, + 83, + 87, + 90, + 92, + 96, + 98, + 99, + 101, + 102, + 103 + ], + "target": 60 + }, + { + "early": [ + 42, + 51, + 68, + 102 + ], + "endpoint": [ + 1, + 2, + 4, + 8, + 32, + 80, + 128, + 272 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 7, + 14, + 25, + 34, + 61 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 3, + 5, + 8, + 12, + 16, + 22, + 33 + ], + "support": [ + 1, + 3, + 5, + 8, + 10, + 12, + 13, + 16, + 18, + 20, + 21, + 22, + 23, + 24, + 26, + 28, + 33, + 38, + 42, + 44, + 46, + 49, + 51, + 53, + 54, + 55, + 57, + 58, + 59, + 60, + 62, + 63, + 64, + 66, + 68, + 72, + 77, + 80, + 84, + 88, + 91, + 92, + 97, + 98, + 100, + 101, + 102, + 103 + ], + "target": 61 + }, + { + "early": [ + 11, + 17, + 25, + 39, + 53, + 56, + 61, + 63, + 71, + 78, + 91, + 102 + ], + "endpoint": [ + 1, + 2, + 12, + 20, + 32, + 68, + 128, + 260 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 7, + 14, + 26, + 33, + 62 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 4, + 9, + 12, + 19, + 22, + 43 + ], + "support": [ + 0, + 2, + 4, + 6, + 9, + 11, + 12, + 13, + 17, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 27, + 39, + 43, + 45, + 46, + 50, + 52, + 53, + 54, + 56, + 57, + 58, + 59, + 60, + 61, + 63, + 64, + 65, + 67, + 71, + 78, + 79, + 85, + 89, + 90, + 91, + 92, + 99, + 100, + 101, + 102, + 103 + ], + "target": 62 + }, + { + "early": [ + 18, + 40, + 71, + 94 + ], + "endpoint": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 7, + 14, + 27, + 35, + 63 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 5, + 10, + 12, + 19, + 22, + 33 + ], + "support": [ + 1, + 2, + 5, + 6, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 33, + 34, + 36, + 40, + 47, + 54, + 58, + 60, + 61, + 62, + 64, + 65, + 66, + 67, + 68, + 69, + 71, + 72, + 73, + 75, + 79, + 80, + 81, + 82, + 86, + 92, + 93, + 94, + 95, + 96, + 97 + ], + "target": 63 + }, + { + "early": [ + 71, + 94 + ], + "endpoint": [ + 1, + 4, + 10, + 18, + 34, + 66, + 130, + 258 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 7, + 14, + 25, + 34, + 64 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 3, + 4, + 8, + 12, + 16, + 22, + 33 + ], + "support": [ + 0, + 3, + 4, + 8, + 9, + 12, + 13, + 16, + 17, + 20, + 21, + 22, + 23, + 24, + 27, + 28, + 33, + 35, + 37, + 41, + 46, + 48, + 53, + 57, + 59, + 61, + 62, + 63, + 65, + 66, + 67, + 68, + 70, + 71, + 72, + 74, + 76, + 79, + 80, + 83, + 87, + 91, + 93, + 94, + 95, + 96, + 98, + 99 + ], + "target": 64 + }, + { + "early": [ + 56, + 71, + 84, + 94 + ], + "endpoint": [ + 3, + 4, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 8, + 14, + 24, + 33, + 65 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 4, + 6, + 7, + 9, + 15, + 22, + 34 + ], + "support": [ + 1, + 4, + 6, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 22, + 23, + 25, + 27, + 29, + 34, + 35, + 38, + 42, + 45, + 49, + 52, + 56, + 59, + 60, + 62, + 63, + 64, + 66, + 67, + 69, + 70, + 71, + 73, + 74, + 77, + 79, + 81, + 84, + 88, + 90, + 93, + 94, + 95, + 97, + 98, + 100 + ], + "target": 65 + }, + { + "early": [ + 8, + 18, + 28, + 34, + 50, + 51, + 59, + 65, + 68, + 73, + 89, + 94 + ], + "endpoint": [ + 3, + 5, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 9, + 14, + 24, + 36, + 66 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 3, + 7, + 10, + 15, + 22, + 33 + ], + "support": [ + 0, + 2, + 3, + 5, + 7, + 8, + 10, + 13, + 15, + 16, + 18, + 21, + 22, + 23, + 26, + 28, + 29, + 33, + 34, + 35, + 39, + 43, + 44, + 50, + 51, + 55, + 59, + 60, + 61, + 63, + 64, + 65, + 68, + 69, + 70, + 72, + 73, + 74, + 78, + 80, + 81, + 85, + 89, + 93, + 94, + 95, + 99, + 100 + ], + "target": 66 + }, + { + "early": [ + 20, + 30, + 50, + 51, + 56, + 65, + 68, + 71, + 84, + 89, + 94, + 96 + ], + "endpoint": [ + 1, + 6, + 10, + 16, + 34, + 66, + 130, + 258 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 7, + 15, + 23, + 33, + 67 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 3, + 9, + 12, + 14, + 22, + 36 + ], + "support": [ + 0, + 2, + 3, + 5, + 9, + 11, + 12, + 14, + 17, + 19, + 20, + 22, + 24, + 25, + 27, + 30, + 36, + 37, + 38, + 43, + 44, + 50, + 51, + 56, + 57, + 58, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 75, + 76, + 77, + 79, + 82, + 83, + 84, + 89, + 93, + 94, + 96, + 97, + 98, + 101 + ], + "target": 67 + }, + { + "early": [ + 8, + 18, + 28, + 94 + ], + "endpoint": [ + 1, + 4, + 8, + 16, + 34, + 66, + 130, + 258 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 7, + 15, + 23, + 34, + 68 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 4, + 6, + 10, + 12, + 14, + 22, + 33 + ], + "support": [ + 1, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 33, + 36, + 37, + 39, + 42, + 45, + 49, + 52, + 55, + 57, + 58, + 61, + 63, + 64, + 66, + 67, + 69, + 70, + 72, + 75, + 76, + 78, + 80, + 82, + 83, + 85, + 88, + 90, + 93, + 94, + 96, + 99, + 101 + ], + "target": 68 + }, + { + "early": [ + 18, + 94 + ], + "endpoint": [ + 3, + 4, + 9, + 16, + 33, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 8, + 16, + 23, + 33, + 69 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 3, + 4, + 7, + 10, + 14, + 22, + 34 + ], + "support": [ + 0, + 3, + 4, + 7, + 10, + 11, + 14, + 15, + 18, + 19, + 22, + 25, + 26, + 29, + 30, + 34, + 36, + 38, + 39, + 41, + 46, + 48, + 53, + 55, + 56, + 58, + 60, + 63, + 65, + 66, + 67, + 68, + 70, + 73, + 75, + 77, + 78, + 81, + 82, + 84, + 85, + 87, + 91, + 93, + 94, + 97, + 100, + 101 + ], + "target": 69 + }, + { + "early": [ + 94 + ], + "endpoint": [ + 1, + 2, + 8, + 16, + 36, + 68, + 132, + 260 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 10, + 18, + 23, + 33, + 70 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 2, + 5, + 7, + 8, + 14, + 22, + 35 + ], + "support": [ + 1, + 2, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 22, + 27, + 28, + 29, + 30, + 35, + 37, + 38, + 39, + 40, + 47, + 54, + 55, + 56, + 57, + 59, + 64, + 65, + 66, + 67, + 68, + 69, + 74, + 76, + 77, + 78, + 83, + 84, + 85, + 86, + 92, + 93, + 94, + 98, + 99, + 100, + 101 + ], + "target": 70 + }, + { + "early": [ + 20, + 50, + 65, + 96 + ], + "endpoint": [ + 3, + 4, + 8, + 16, + 32, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 9, + 14, + 22, + 33, + 71 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 4, + 7, + 8, + 17, + 23, + 39 + ], + "support": [ + 0, + 2, + 4, + 6, + 7, + 8, + 10, + 17, + 19, + 20, + 21, + 23, + 24, + 25, + 27, + 31, + 39, + 40, + 41, + 42, + 44, + 50, + 52, + 53, + 54, + 55, + 62, + 63, + 64, + 65, + 67, + 72, + 73, + 74, + 75, + 76, + 77, + 79, + 85, + 86, + 87, + 88, + 93, + 95, + 96, + 97, + 98, + 102 + ], + "target": 71 + }, + { + "early": [ + 18, + 28 + ], + "endpoint": [ + 3, + 5, + 9, + 16, + 32, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 8, + 14, + 22, + 34, + 72 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 3, + 5, + 7, + 9, + 16, + 23, + 33 + ], + "support": [ + 1, + 3, + 5, + 7, + 9, + 11, + 16, + 18, + 20, + 21, + 23, + 24, + 26, + 28, + 31, + 33, + 38, + 40, + 41, + 43, + 45, + 49, + 51, + 53, + 54, + 56, + 61, + 63, + 64, + 66, + 68, + 71, + 73, + 74, + 75, + 76, + 78, + 80, + 84, + 86, + 87, + 89, + 90, + 93, + 95, + 96, + 99, + 102 + ], + "target": 72 + }, + { + "early": [ + 18 + ], + "endpoint": [ + 1, + 6, + 8, + 16, + 32, + 66, + 130, + 258 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 7, + 14, + 22, + 33, + 73 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 5, + 6, + 8, + 12, + 15, + 23, + 34 + ], + "support": [ + 0, + 5, + 6, + 8, + 9, + 12, + 15, + 18, + 19, + 21, + 23, + 25, + 26, + 29, + 31, + 34, + 37, + 40, + 42, + 43, + 46, + 48, + 51, + 52, + 54, + 57, + 60, + 63, + 65, + 66, + 69, + 71, + 72, + 74, + 75, + 77, + 78, + 81, + 83, + 86, + 88, + 89, + 91, + 93, + 95, + 97, + 100, + 102 + ], + "target": 73 + }, + { + "early": [], + "endpoint": [ + 2, + 4, + 9, + 16, + 32, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 7, + 14, + 22, + 33, + 74 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 2, + 3, + 10, + 12, + 15, + 23, + 35 + ], + "support": [ + 1, + 2, + 3, + 4, + 10, + 11, + 12, + 15, + 16, + 17, + 21, + 23, + 27, + 28, + 29, + 31, + 35, + 36, + 41, + 42, + 43, + 47, + 51, + 52, + 53, + 58, + 59, + 64, + 65, + 66, + 70, + 71, + 72, + 73, + 76, + 77, + 78, + 82, + 87, + 88, + 89, + 92, + 93, + 95, + 98, + 99, + 100, + 102 + ], + "target": 74 + }, + { + "early": [ + 18, + 50, + 59 + ], + "endpoint": [ + 3, + 4, + 9, + 17, + 32, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 10, + 15, + 22, + 33, + 75 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 3, + 7, + 8, + 14, + 24, + 35 + ], + "support": [ + 1, + 2, + 3, + 4, + 7, + 8, + 9, + 13, + 14, + 18, + 19, + 20, + 24, + 25, + 26, + 30, + 31, + 35, + 36, + 40, + 44, + 45, + 46, + 48, + 49, + 50, + 54, + 58, + 59, + 63, + 67, + 68, + 69, + 71, + 72, + 73, + 76, + 77, + 78, + 82, + 86, + 90, + 91, + 93, + 96, + 97, + 101, + 102 + ], + "target": 75 + }, + { + "early": [ + 50 + ], + "endpoint": [ + 1, + 2, + 8, + 20, + 32, + 68, + 132, + 260 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 8, + 15, + 22, + 33, + 76 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 5, + 6, + 7, + 10, + 14, + 24, + 34 + ], + "support": [ + 0, + 5, + 6, + 7, + 10, + 11, + 13, + 14, + 16, + 17, + 20, + 24, + 27, + 28, + 30, + 31, + 34, + 37, + 41, + 44, + 45, + 47, + 49, + 50, + 53, + 57, + 60, + 64, + 67, + 68, + 70, + 71, + 72, + 74, + 75, + 77, + 78, + 81, + 83, + 87, + 90, + 92, + 93, + 96, + 98, + 99, + 101, + 102 + ], + "target": 76 + }, + { + "early": [ + 50, + 65 + ], + "endpoint": [ + 2, + 5, + 9, + 17, + 32, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 7, + 16, + 22, + 34, + 77 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 3, + 5, + 8, + 12, + 14, + 25, + 33 + ], + "support": [ + 1, + 3, + 5, + 8, + 10, + 12, + 13, + 14, + 15, + 17, + 19, + 25, + 27, + 29, + 30, + 31, + 33, + 38, + 42, + 44, + 46, + 47, + 48, + 50, + 52, + 56, + 61, + 65, + 67, + 69, + 70, + 71, + 73, + 74, + 75, + 76, + 78, + 80, + 84, + 88, + 91, + 92, + 93, + 97, + 98, + 100, + 101, + 102 + ], + "target": 77 + }, + { + "early": [ + 18, + 28, + 48, + 91 + ], + "endpoint": [ + 2, + 4, + 8, + 17, + 32, + 65, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 7, + 17, + 22, + 33, + 78 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 4, + 9, + 12, + 14, + 26, + 39 + ], + "support": [ + 0, + 2, + 4, + 6, + 9, + 11, + 12, + 13, + 14, + 15, + 16, + 18, + 26, + 28, + 29, + 30, + 31, + 39, + 43, + 45, + 46, + 47, + 48, + 49, + 51, + 55, + 62, + 66, + 68, + 69, + 70, + 72, + 73, + 74, + 75, + 76, + 77, + 79, + 85, + 89, + 90, + 91, + 92, + 93, + 99, + 100, + 101, + 102 + ], + "target": 78 + }, + { + "early": [ + 65, + 96 + ], + "endpoint": [ + 1, + 6, + 10, + 16, + 32, + 64, + 130, + 258 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 7, + 17, + 26, + 33, + 79 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 2, + 4, + 9, + 12, + 14, + 22, + 39 + ], + "support": [ + 0, + 2, + 4, + 6, + 9, + 11, + 12, + 13, + 14, + 15, + 16, + 18, + 22, + 23, + 24, + 25, + 27, + 32, + 39, + 43, + 45, + 46, + 47, + 48, + 49, + 51, + 55, + 62, + 63, + 64, + 65, + 67, + 71, + 78, + 80, + 81, + 82, + 83, + 84, + 86, + 87, + 88, + 94, + 95, + 96, + 97, + 98, + 103 + ], + "target": 79 + }, + { + "early": [ + 28 + ], + "endpoint": [ + 1, + 4, + 8, + 16, + 32, + 64, + 130, + 258 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 7, + 16, + 25, + 34, + 80 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 3, + 5, + 8, + 12, + 14, + 22, + 33 + ], + "support": [ + 1, + 3, + 5, + 8, + 10, + 12, + 13, + 14, + 15, + 17, + 19, + 22, + 23, + 24, + 26, + 28, + 32, + 33, + 38, + 42, + 44, + 46, + 47, + 48, + 50, + 52, + 56, + 61, + 63, + 64, + 66, + 68, + 72, + 77, + 79, + 81, + 82, + 83, + 85, + 86, + 87, + 89, + 90, + 94, + 95, + 96, + 99, + 103 + ], + "target": 80 + }, + { + "early": [], + "endpoint": [ + 3, + 4, + 9, + 16, + 32, + 64, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 8, + 15, + 24, + 33, + 81 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 5, + 6, + 7, + 10, + 14, + 22, + 34 + ], + "support": [ + 0, + 5, + 6, + 7, + 10, + 11, + 13, + 14, + 16, + 17, + 20, + 22, + 23, + 25, + 26, + 29, + 32, + 34, + 37, + 41, + 44, + 45, + 47, + 49, + 50, + 53, + 57, + 60, + 63, + 65, + 66, + 69, + 73, + 76, + 79, + 80, + 82, + 84, + 85, + 86, + 88, + 89, + 91, + 94, + 95, + 97, + 100, + 103 + ], + "target": 81 + }, + { + "early": [ + 59 + ], + "endpoint": [ + 1, + 6, + 8, + 18, + 32, + 64, + 130, + 258 + ], + "outside_minor_columns": [ + 0, + 5, + 6, + 7, + 14, + 23, + 33, + 82 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 3, + 10, + 12, + 15, + 22, + 35 + ], + "support": [ + 1, + 2, + 3, + 4, + 10, + 11, + 12, + 15, + 16, + 17, + 21, + 22, + 24, + 25, + 26, + 30, + 32, + 35, + 36, + 41, + 42, + 43, + 47, + 51, + 52, + 53, + 58, + 59, + 63, + 67, + 68, + 69, + 74, + 75, + 79, + 80, + 81, + 83, + 84, + 85, + 86, + 90, + 91, + 94, + 96, + 97, + 101, + 103 + ], + "target": 82 + }, + { + "early": [], + "endpoint": [ + 2, + 4, + 9, + 17, + 32, + 64, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 3, + 7, + 14, + 23, + 33, + 83 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 5, + 6, + 8, + 12, + 15, + 22, + 34 + ], + "support": [ + 0, + 5, + 6, + 8, + 9, + 12, + 15, + 18, + 19, + 21, + 22, + 24, + 27, + 28, + 30, + 32, + 34, + 37, + 40, + 42, + 43, + 46, + 48, + 51, + 52, + 54, + 57, + 60, + 64, + 67, + 68, + 70, + 73, + 76, + 79, + 80, + 82, + 84, + 85, + 87, + 90, + 92, + 94, + 96, + 98, + 99, + 101, + 103 + ], + "target": 83 + }, + { + "early": [ + 65 + ], + "endpoint": [ + 1, + 2, + 4, + 8, + 32, + 64, + 144, + 272 + ], + "outside_minor_columns": [ + 0, + 2, + 4, + 8, + 14, + 23, + 34, + 84 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 3, + 5, + 7, + 9, + 16, + 22, + 33 + ], + "support": [ + 1, + 3, + 5, + 7, + 9, + 11, + 16, + 18, + 20, + 21, + 22, + 25, + 27, + 29, + 30, + 32, + 33, + 38, + 40, + 41, + 43, + 45, + 49, + 51, + 53, + 54, + 56, + 61, + 65, + 67, + 69, + 70, + 72, + 77, + 79, + 81, + 82, + 83, + 85, + 88, + 91, + 92, + 94, + 97, + 98, + 100, + 101, + 103 + ], + "target": 84 + }, + { + "early": [ + 28, + 91 + ], + "endpoint": [ + 1, + 2, + 12, + 20, + 32, + 64, + 132, + 260 + ], + "outside_minor_columns": [ + 1, + 3, + 5, + 9, + 14, + 23, + 33, + 85 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 4, + 7, + 8, + 17, + 22, + 39 + ], + "support": [ + 0, + 2, + 4, + 6, + 7, + 8, + 10, + 17, + 19, + 20, + 21, + 22, + 26, + 28, + 29, + 30, + 32, + 39, + 40, + 41, + 42, + 44, + 50, + 52, + 53, + 54, + 55, + 62, + 66, + 68, + 69, + 70, + 71, + 78, + 80, + 81, + 82, + 83, + 84, + 89, + 90, + 91, + 92, + 94, + 99, + 100, + 101, + 103 + ], + "target": 85 + }, + { + "early": [ + 59, + 89 + ], + "endpoint": [ + 3, + 4, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 10, + 18, + 22, + 33, + 86 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 2, + 5, + 7, + 8, + 14, + 23, + 35 + ], + "support": [ + 1, + 2, + 5, + 6, + 7, + 8, + 9, + 14, + 15, + 16, + 17, + 23, + 24, + 25, + 26, + 31, + 32, + 35, + 37, + 38, + 39, + 40, + 47, + 54, + 55, + 56, + 57, + 59, + 63, + 70, + 71, + 72, + 73, + 75, + 79, + 80, + 81, + 82, + 87, + 88, + 89, + 90, + 91, + 95, + 96, + 97, + 102, + 103 + ], + "target": 86 + }, + { + "early": [ + 89 + ], + "endpoint": [ + 1, + 2, + 8, + 20, + 36, + 64, + 132, + 260 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 8, + 16, + 22, + 33, + 87 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 3, + 4, + 7, + 10, + 14, + 23, + 34 + ], + "support": [ + 0, + 3, + 4, + 7, + 10, + 11, + 14, + 15, + 18, + 19, + 23, + 24, + 27, + 28, + 31, + 32, + 34, + 36, + 38, + 39, + 41, + 46, + 48, + 53, + 55, + 56, + 58, + 60, + 64, + 69, + 71, + 72, + 74, + 76, + 79, + 80, + 83, + 86, + 88, + 89, + 90, + 92, + 95, + 96, + 98, + 99, + 102, + 103 + ], + "target": 87 + }, + { + "early": [ + 65, + 68, + 89 + ], + "endpoint": [ + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 7, + 15, + 22, + 34, + 88 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 1, + 4, + 6, + 8, + 12, + 14, + 23, + 33 + ], + "support": [ + 1, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 23, + 25, + 27, + 29, + 31, + 32, + 33, + 36, + 37, + 39, + 42, + 45, + 49, + 52, + 55, + 57, + 58, + 61, + 65, + 68, + 71, + 73, + 74, + 77, + 79, + 81, + 84, + 86, + 87, + 89, + 91, + 92, + 95, + 97, + 98, + 100, + 102, + 103 + ], + "target": 88 + }, + { + "early": [ + 28, + 56, + 87, + 91 + ], + "endpoint": [ + 2, + 4, + 8, + 17, + 33, + 64, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 4, + 6, + 7, + 15, + 22, + 33, + 89 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 2, + 3, + 9, + 12, + 14, + 23, + 36 + ], + "support": [ + 0, + 2, + 3, + 5, + 9, + 11, + 12, + 14, + 17, + 19, + 20, + 23, + 26, + 28, + 29, + 31, + 32, + 36, + 37, + 38, + 43, + 44, + 50, + 51, + 56, + 57, + 58, + 62, + 66, + 67, + 72, + 73, + 74, + 78, + 80, + 81, + 85, + 86, + 87, + 88, + 90, + 91, + 92, + 95, + 99, + 100, + 102, + 103 + ], + "target": 89 + }, + { + "early": [ + 4, + 28, + 30, + 34, + 56, + 59, + 65, + 68, + 87, + 89, + 91, + 96 + ], + "endpoint": [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ], + "outside_minor_columns": [ + 0, + 2, + 3, + 8, + 14, + 22, + 33, + 90 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 6, + 7, + 9, + 11, + 15, + 24, + 35 + ], + "support": [ + 1, + 4, + 6, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 24, + 26, + 28, + 30, + 31, + 32, + 34, + 35, + 38, + 42, + 45, + 49, + 52, + 56, + 59, + 60, + 62, + 65, + 68, + 72, + 75, + 76, + 78, + 80, + 82, + 83, + 85, + 86, + 87, + 89, + 91, + 92, + 96, + 99, + 101, + 102, + 103 + ], + "target": 90 + }, + { + "early": [ + 4, + 30, + 59, + 89 + ], + "endpoint": [ + 2, + 5, + 8, + 16, + 33, + 64, + 129, + 257 + ], + "outside_minor_columns": [ + 1, + 2, + 5, + 7, + 14, + 22, + 34, + 91 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 3, + 8, + 9, + 12, + 16, + 25, + 33 + ], + "support": [ + 0, + 3, + 4, + 8, + 9, + 12, + 13, + 16, + 17, + 20, + 21, + 25, + 26, + 29, + 30, + 31, + 32, + 33, + 35, + 37, + 41, + 46, + 48, + 53, + 57, + 59, + 61, + 62, + 64, + 69, + 73, + 75, + 77, + 78, + 81, + 82, + 84, + 85, + 86, + 88, + 89, + 90, + 92, + 97, + 100, + 101, + 102, + 103 + ], + "target": 91 + }, + { + "early": [ + 30, + 89 + ], + "endpoint": [ + 1, + 4, + 10, + 16, + 34, + 64, + 130, + 258 + ], + "outside_minor_columns": [ + 0, + 3, + 4, + 7, + 14, + 22, + 35, + 92 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 1, + 2, + 5, + 10, + 12, + 18, + 27, + 33 + ], + "support": [ + 1, + 2, + 5, + 6, + 10, + 11, + 12, + 13, + 18, + 19, + 20, + 21, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 36, + 40, + 47, + 54, + 58, + 60, + 61, + 62, + 63, + 70, + 74, + 76, + 77, + 78, + 83, + 84, + 85, + 87, + 88, + 89, + 90, + 91, + 98, + 99, + 100, + 101, + 102, + 103 + ], + "target": 92 + }, + { + "early": [ + 17, + 18, + 32, + 39, + 40, + 63, + 70, + 71, + 78, + 94, + 98, + 102 + ], + "endpoint": [ + 1, + 2, + 12, + 20, + 32, + 68, + 132, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 7, + 22, + 47, + 93 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 14, + 15, + 16, + 19, + 33, + 35, + 41, + 64 + ], + "support": [ + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102 + ], + "target": 93 + }, + { + "early": [ + 39, + 63, + 70, + 98 + ], + "endpoint": [ + 2, + 4, + 8, + 17, + 32, + 64, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 14, + 23, + 40, + 94 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 7, + 8, + 9, + 10, + 13, + 22, + 33, + 47 + ], + "support": [ + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 22, + 31, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 93, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 103 + ], + "target": 94 + }, + { + "early": [ + 63, + 98 + ], + "endpoint": [ + 1, + 2, + 12, + 20, + 36, + 64, + 132, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 7, + 15, + 22, + 36, + 95 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 3, + 4, + 5, + 13, + 14, + 23, + 33, + 34 + ], + "support": [ + 3, + 4, + 5, + 6, + 13, + 14, + 21, + 23, + 30, + 33, + 34, + 35, + 40, + 41, + 42, + 43, + 47, + 48, + 49, + 50, + 55, + 56, + 57, + 58, + 63, + 64, + 65, + 66, + 71, + 72, + 73, + 74, + 79, + 80, + 81, + 86, + 87, + 88, + 89, + 93, + 94, + 96, + 97, + 98, + 99, + 100, + 102, + 103 + ], + "target": 95 + }, + { + "early": [ + 2, + 59, + 63, + 98 + ], + "endpoint": [ + 2, + 4, + 8, + 16, + 33, + 64, + 129, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 8, + 14, + 22, + 34, + 96 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 7, + 15, + 24, + 33, + 36, + 37 + ], + "support": [ + 0, + 1, + 2, + 7, + 12, + 15, + 20, + 24, + 29, + 33, + 36, + 37, + 40, + 41, + 44, + 45, + 47, + 48, + 51, + 52, + 55, + 56, + 59, + 60, + 63, + 64, + 67, + 68, + 71, + 72, + 75, + 76, + 79, + 80, + 82, + 83, + 86, + 87, + 90, + 93, + 94, + 95, + 97, + 98, + 99, + 101, + 102, + 103 + ], + "target": 96 + }, + { + "early": [ + 2, + 25, + 28, + 34, + 59, + 61, + 63, + 65, + 91, + 96, + 98, + 100 + ], + "endpoint": [ + 1, + 2, + 4, + 16, + 40, + 64, + 136, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 7, + 14, + 22, + 33, + 97 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 3, + 6, + 8, + 16, + 36, + 38, + 44, + 67 + ], + "support": [ + 2, + 3, + 6, + 8, + 11, + 16, + 19, + 25, + 28, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 47, + 49, + 51, + 53, + 55, + 57, + 59, + 61, + 63, + 65, + 67, + 69, + 71, + 73, + 75, + 77, + 79, + 81, + 82, + 84, + 86, + 88, + 91, + 93, + 94, + 95, + 96, + 98, + 100, + 101, + 102, + 103 + ], + "target": 97 + }, + { + "early": [ + 61, + 65, + 96, + 100 + ], + "endpoint": [ + 3, + 5, + 8, + 16, + 33, + 64, + 129, + 256 + ], + "outside_minor_columns": [ + 2, + 3, + 6, + 7, + 14, + 22, + 33, + 98 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 0, + 1, + 4, + 9, + 17, + 26, + 35, + 38 + ], + "support": [ + 0, + 1, + 4, + 5, + 9, + 10, + 17, + 18, + 26, + 27, + 35, + 37, + 38, + 41, + 42, + 44, + 48, + 49, + 51, + 54, + 55, + 58, + 60, + 61, + 64, + 65, + 67, + 70, + 71, + 74, + 76, + 77, + 79, + 83, + 84, + 87, + 88, + 92, + 93, + 94, + 95, + 96, + 97, + 99, + 100, + 101, + 102, + 103 + ], + "target": 98 + }, + { + "early": [ + 25, + 28, + 98 + ], + "endpoint": [ + 3, + 4, + 9, + 16, + 33, + 64, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 4, + 7, + 14, + 22, + 34, + 99 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 2, + 3, + 6, + 8, + 16, + 33, + 35, + 64 + ], + "support": [ + 2, + 3, + 6, + 8, + 11, + 16, + 19, + 25, + 28, + 33, + 35, + 37, + 39, + 41, + 43, + 45, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 80, + 83, + 85, + 87, + 89, + 90, + 92, + 93, + 94, + 95, + 96, + 98, + 100, + 101, + 102, + 103 + ], + "target": 99 + }, + { + "early": [ + 98 + ], + "endpoint": [ + 1, + 4, + 8, + 16, + 34, + 64, + 130, + 256 + ], + "outside_minor_columns": [ + 3, + 4, + 5, + 8, + 14, + 22, + 33, + 100 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 0, + 1, + 2, + 7, + 15, + 24, + 34, + 38 + ], + "support": [ + 0, + 1, + 2, + 7, + 12, + 15, + 20, + 24, + 29, + 34, + 35, + 38, + 39, + 42, + 43, + 46, + 49, + 50, + 53, + 54, + 57, + 58, + 61, + 62, + 65, + 66, + 69, + 70, + 73, + 74, + 77, + 78, + 81, + 84, + 85, + 88, + 89, + 91, + 92, + 93, + 94, + 95, + 97, + 98, + 99, + 101, + 102, + 103 + ], + "target": 100 + }, + { + "early": [ + 59, + 98 + ], + "endpoint": [ + 3, + 5, + 9, + 17, + 33, + 64, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 7, + 15, + 22, + 33, + 101 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 3, + 4, + 5, + 13, + 14, + 23, + 36, + 38 + ], + "support": [ + 3, + 4, + 5, + 6, + 13, + 14, + 21, + 23, + 30, + 36, + 37, + 38, + 39, + 44, + 45, + 46, + 51, + 52, + 53, + 54, + 59, + 60, + 61, + 62, + 67, + 68, + 69, + 70, + 75, + 76, + 77, + 78, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 94, + 96, + 97, + 98, + 99, + 100, + 102, + 103 + ], + "target": 101 + }, + { + "early": [ + 58, + 59, + 89, + 98 + ], + "endpoint": [ + 1, + 4, + 8, + 18, + 32, + 64, + 130, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 14, + 23, + 33, + 102 + ], + "outside_minor_determinant": -512, + "required_basis_sources": [ + 7, + 8, + 9, + 10, + 13, + 22, + 40, + 55 + ], + "support": [ + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 22, + 31, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 103 + ], + "target": 102 + }, + { + "early": [ + 17, + 18, + 32, + 50, + 51, + 58, + 59, + 82, + 89, + 94, + 98, + 102 + ], + "endpoint": [ + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 256 + ], + "outside_minor_columns": [ + 0, + 1, + 2, + 3, + 7, + 22, + 33, + 103 + ], + "outside_minor_determinant": 512, + "required_basis_sources": [ + 14, + 15, + 16, + 19, + 47, + 48, + 55, + 79 + ], + "support": [ + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 32, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102 + ], + "target": 103 + } + ], + "trace": { + "events": 4058, + "independent_inputs": 280, + "operations": { + "add": 2624, + "copy": 8, + "erase": 8, + "transport": 1410, + "zero": 8 + }, + "original_helper_frame_pairs": 434, + "original_helper_paths": { + "D0": [ + [], + [ + 243 + ], + [ + 243, + 261 + ], + [ + 127, + 140, + 261 + ], + [ + 54, + 73, + 140, + 261 + ], + [ + 5, + 51, + 73, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D1": [ + [], + [ + 243 + ], + [ + 243, + 277 + ], + [ + 95, + 172, + 277 + ], + [ + 53, + 95, + 153, + 277 + ], + [ + 16, + 37, + 79, + 137, + 261 + ], + [ + 2, + 16, + 37, + 77, + 137, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D10": [ + [], + [ + 447 + ], + [ + 127, + 447 + ], + [ + 52, + 75, + 395 + ], + [ + 52, + 75, + 140, + 263 + ], + [ + 18, + 38, + 75, + 140, + 263 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D11": [ + [], + [ + 447 + ], + [ + 89, + 153, + 294 + ], + [ + 51, + 89, + 153, + 277 + ], + [ + 16, + 35, + 73, + 137, + 261 + ], + [ + 6, + 16, + 35, + 73, + 137, + 259 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D12": [ + [], + [ + 502 + ], + [ + 2, + 241, + 261 + ], + [ + 2, + 120, + 137, + 261 + ], + [ + 2, + 49, + 73, + 137, + 261 + ], + [ + 2, + 5, + 49, + 73, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D13": [ + [], + [ + 502 + ], + [ + 16, + 79, + 425 + ], + [ + 16, + 79, + 137, + 288 + ], + [ + 2, + 16, + 77, + 137, + 288 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D14": [ + [], + [ + 502 + ], + [ + 127, + 393 + ], + [ + 54, + 73, + 393 + ], + [ + 54, + 73, + 137, + 256 + ], + [ + 16, + 38, + 73, + 137, + 256 + ], + [ + 6, + 16, + 32, + 73, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D15": [ + [], + [ + 502 + ], + [ + 2, + 125, + 393 + ], + [ + 2, + 52, + 73, + 393 + ], + [ + 2, + 20, + 32, + 73, + 393 + ], + [ + 2, + 20, + 32, + 73, + 140, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D16": [ + [], + [ + 486 + ], + [ + 18, + 139, + 365 + ], + [ + 18, + 109, + 139, + 256 + ], + [ + 2, + 16, + 109, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D17": [ + [], + [ + 486 + ], + [ + 95, + 441 + ], + [ + 6, + 32, + 89, + 409 + ], + [ + 6, + 18, + 32, + 75, + 395 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D18": [ + [], + [ + 486 + ], + [ + 16, + 227, + 261 + ], + [ + 16, + 111, + 140, + 261 + ], + [ + 16, + 38, + 73, + 140, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D19": [ + [], + [ + 486 + ], + [ + 18, + 75, + 139, + 294 + ], + [ + 6, + 18, + 33, + 75, + 139, + 257 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D2": [ + [], + [ + 243 + ], + [ + 6, + 89, + 170, + 275 + ], + [ + 6, + 32, + 89, + 138, + 275 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D20": [ + [], + [ + 127 + ], + [ + 127, + 395 + ], + [ + 127, + 140, + 263 + ], + [ + 18, + 109, + 140, + 263 + ], + [ + 18, + 32, + 77, + 140, + 263 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D21": [ + [], + [ + 127 + ], + [ + 32, + 95, + 393 + ], + [ + 16, + 32, + 79, + 393 + ], + [ + 16, + 32, + 79, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D22": [ + [], + [ + 127 + ], + [ + 38, + 89, + 153, + 256 + ], + [ + 21, + 38, + 76, + 140, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D23": [ + [], + [ + 500 + ], + [ + 2, + 32, + 93, + 393 + ], + [ + 2, + 16, + 32, + 77, + 393 + ], + [ + 2, + 16, + 32, + 77, + 140, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D24": [ + [], + [ + 500 + ], + [ + 18, + 225, + 263 + ], + [ + 18, + 77, + 172, + 263 + ], + [ + 6, + 18, + 75, + 170, + 257 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D25": [ + [], + [ + 500 + ], + [ + 2, + 16, + 225, + 261 + ], + [ + 2, + 5, + 16, + 104, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D26": [ + [], + [ + 500 + ], + [ + 139, + 383 + ], + [ + 75, + 139, + 308 + ], + [ + 20, + 75, + 139, + 288 + ], + [ + 2, + 20, + 73, + 137, + 288 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D27": [ + [], + [ + 383 + ], + [ + 153, + 383 + ], + [ + 106, + 153, + 277 + ], + [ + 16, + 106, + 137, + 261 + ], + [ + 5, + 16, + 106, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D28": [ + [], + [ + 383 + ], + [ + 192, + 383 + ], + [ + 127, + 191, + 256 + ], + [ + 32, + 95, + 159, + 256 + ], + [ + 6, + 32, + 89, + 153, + 256 + ], + [ + 6, + 18, + 32, + 75, + 139, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D29": [ + [], + [ + 383 + ], + [ + 95, + 159, + 288 + ], + [ + 22, + 73, + 137, + 288 + ], + [ + 22, + 37, + 73, + 137, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D3": [ + [], + [ + 243 + ], + [ + 32, + 95, + 140, + 261 + ], + [ + 16, + 32, + 79, + 140, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D30": [ + [], + [ + 383 + ], + [ + 127, + 139, + 256 + ], + [ + 2, + 125, + 137, + 256 + ], + [ + 2, + 32, + 93, + 137, + 256 + ], + [ + 2, + 20, + 32, + 73, + 137, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D31": [ + [], + [ + 383 + ], + [ + 7, + 120, + 139, + 256 + ], + [ + 7, + 51, + 75, + 139, + 256 + ], + [ + 7, + 18, + 33, + 75, + 139, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D4": [ + [], + [ + 243 + ], + [ + 243, + 263 + ], + [ + 120, + 139, + 263 + ], + [ + 51, + 75, + 139, + 263 + ], + [ + 20, + 39, + 75, + 139, + 263 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D5": [ + [], + [ + 95 + ], + [ + 95, + 447 + ], + [ + 32, + 95, + 415 + ], + [ + 20, + 32, + 75, + 395 + ], + [ + 20, + 32, + 75, + 140, + 263 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D6": [ + [], + [ + 95 + ], + [ + 95, + 425 + ], + [ + 95, + 172, + 261 + ], + [ + 2, + 93, + 172, + 261 + ], + [ + 2, + 37, + 93, + 137, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D7": [ + [], + [ + 95 + ], + [ + 95, + 153, + 288 + ], + [ + 18, + 77, + 139, + 288 + ], + [ + 18, + 32, + 77, + 139, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D8": [ + [], + [ + 447 + ], + [ + 22, + 73, + 425 + ], + [ + 22, + 73, + 172, + 261 + ], + [ + 2, + 20, + 73, + 172, + 261 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "D9": [ + [], + [ + 447 + ], + [ + 6, + 89, + 441 + ], + [ + 6, + 16, + 73, + 425 + ], + [ + 6, + 16, + 32, + 73, + 138, + 259 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G0": [ + [], + [ + 3, + 8, + 17, + 416 + ], + [ + 3, + 8, + 17, + 128, + 288 + ], + [ + 3, + 8, + 17, + 64, + 128, + 288 + ], + [ + 3, + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G1": [ + [], + [ + 8, + 64, + 384 + ], + [ + 3, + 8, + 64, + 384 + ], + [ + 1, + 2, + 8, + 64, + 384 + ], + [ + 1, + 2, + 8, + 64, + 128, + 256 + ], + [ + 1, + 2, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G10": [ + [], + [ + 1, + 8, + 128, + 288 + ], + [ + 1, + 8, + 16, + 128, + 288 + ], + [ + 1, + 8, + 16, + 36, + 128, + 260 + ], + [ + 1, + 2, + 8, + 16, + 36, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G11": [ + [], + [ + 3, + 8, + 384 + ], + [ + 3, + 8, + 32, + 384 + ], + [ + 1, + 2, + 8, + 32, + 384 + ], + [ + 1, + 2, + 8, + 32, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G12": [ + [], + [ + 8, + 17, + 416 + ], + [ + 8, + 17, + 32, + 384 + ], + [ + 8, + 17, + 32, + 64, + 384 + ], + [ + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G13": [ + [], + [ + 8, + 64, + 132, + 260 + ], + [ + 3, + 8, + 64, + 132, + 260 + ], + [ + 3, + 4, + 8, + 64, + 128, + 256 + ], + [ + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G14": [ + [], + [ + 3, + 8, + 260 + ], + [ + 3, + 8, + 164, + 260 + ], + [ + 3, + 8, + 17, + 164, + 260 + ], + [ + 3, + 8, + 17, + 36, + 128, + 260 + ], + [ + 3, + 8, + 17, + 36, + 64, + 128, + 260 + ], + [ + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G15": [ + [], + [ + 8, + 17, + 128 + ], + [ + 8, + 17, + 128, + 260 + ], + [ + 8, + 17, + 36, + 128, + 260 + ], + [ + 8, + 17, + 36, + 64, + 128, + 260 + ], + [ + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G16": [ + [], + [ + 8, + 64, + 164, + 260 + ], + [ + 1, + 8, + 64, + 164, + 260 + ], + [ + 1, + 8, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G17": [ + [], + [ + 1, + 8, + 128, + 260 + ], + [ + 1, + 2, + 8, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G18": [ + [], + [ + 3, + 8, + 128, + 288 + ], + [ + 3, + 8, + 64, + 128, + 288 + ], + [ + 3, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G19": [ + [], + [ + 1, + 8, + 384 + ], + [ + 1, + 8, + 32, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G2": [ + [], + [ + 1, + 2, + 8, + 128 + ], + [ + 1, + 2, + 8, + 128, + 256 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G20": [ + [], + [ + 1, + 8, + 64, + 128 + ], + [ + 1, + 8, + 64, + 128, + 288 + ], + [ + 1, + 8, + 16, + 64, + 128, + 288 + ], + [ + 1, + 8, + 16, + 36, + 64, + 128, + 260 + ], + [ + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G21": [ + [], + [ + 3, + 8, + 64, + 260 + ], + [ + 3, + 8, + 64, + 128, + 260 + ], + [ + 3, + 8, + 17, + 64, + 128, + 260 + ], + [ + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G22": [ + [], + [ + 1, + 2, + 8, + 416 + ], + [ + 1, + 2, + 8, + 164, + 260 + ], + [ + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G23": [ + [], + [ + 8, + 64, + 128 + ], + [ + 8, + 64, + 128, + 260 + ], + [ + 8, + 17, + 64, + 128, + 260 + ], + [ + 1, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G24": [ + [], + [ + 1, + 8, + 128, + 256 + ], + [ + 1, + 8, + 64, + 128, + 256 + ], + [ + 1, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G25": [ + [], + [ + 8, + 64, + 416 + ], + [ + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G26": [ + [], + [ + 8, + 17, + 132, + 260 + ], + [ + 1, + 8, + 16, + 132, + 260 + ], + [ + 1, + 8, + 16, + 32, + 132, + 260 + ], + [ + 1, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G27": [ + [], + [ + 3, + 8, + 64, + 416 + ], + [ + 3, + 8, + 32, + 64, + 384 + ], + [ + 1, + 2, + 8, + 32, + 64, + 384 + ], + [ + 1, + 2, + 8, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G28": [ + [], + [ + 1, + 8, + 260 + ], + [ + 1, + 2, + 8, + 260 + ], + [ + 1, + 2, + 8, + 16, + 260 + ], + [ + 1, + 2, + 8, + 16, + 164, + 260 + ], + [ + 1, + 2, + 8, + 16, + 32, + 132, + 260 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G29": [ + [], + [ + 3, + 8, + 17, + 384 + ], + [ + 3, + 8, + 17, + 132, + 260 + ], + [ + 1, + 2, + 8, + 16, + 132, + 260 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G3": [ + [], + [ + 3, + 8, + 64, + 128 + ], + [ + 3, + 8, + 17, + 64, + 128 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G30": [ + [], + [ + 8, + 17, + 260 + ], + [ + 8, + 17, + 64, + 260 + ], + [ + 8, + 17, + 64, + 164, + 260 + ], + [ + 1, + 8, + 16, + 64, + 164, + 260 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G31": [ + [], + [ + 1, + 8, + 416 + ], + [ + 1, + 8, + 16, + 416 + ], + [ + 1, + 8, + 16, + 64, + 416 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G4": [ + [], + [ + 1, + 8, + 16, + 384 + ], + [ + 1, + 8, + 16, + 32, + 384 + ], + [ + 1, + 8, + 16, + 32, + 64, + 384 + ], + [ + 1, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G5": [ + [], + [ + 1, + 8, + 16, + 128 + ], + [ + 1, + 8, + 16, + 128, + 260 + ], + [ + 1, + 2, + 8, + 16, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G6": [ + [], + [ + 8, + 17, + 64, + 384 + ], + [ + 8, + 17, + 64, + 128, + 256 + ], + [ + 3, + 8, + 17, + 64, + 128, + 256 + ], + [ + 3, + 4, + 8, + 17, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G7": [ + [], + [ + 1, + 8, + 64, + 260 + ], + [ + 1, + 8, + 64, + 132, + 260 + ], + [ + 1, + 2, + 8, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G8": [ + [], + [ + 8, + 17, + 128, + 256 + ], + [ + 3, + 8, + 17, + 128, + 256 + ], + [ + 3, + 4, + 8, + 17, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "G9": [ + [], + [ + 3, + 8, + 128 + ], + [ + 3, + 4, + 8, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q0": [ + [], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q1": [ + [], + [ + 1, + 2, + 4, + 8, + 16, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q2": [ + [], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q3": [ + [], + [ + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q4": [ + [], + [ + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q5": [ + [], + [ + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q6": [ + [], + [ + 1, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ], + "Q7": [ + [], + [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ], + [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + ] + }, + "outside_code_example": { + "code_coefficients": [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "cut": 593, + "frame": [ + 8, + 64, + 416 + ], + "full_input_row": { + "G25": "1", + "X1": "-2" + }, + "local_source_row": { + "1": "-2" + }, + "register": "G25", + "target": 2 + }, + "private_lifetimes": [ + { + "allocation_event": 2461, + "alpha": [ + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0" + ], + "copy_event": 2462, + "descent_event": 2463, + "erase_event": 2469, + "row": { + "Q0": "1", + "X0": "-2", + "X1": "-2", + "X100": "-2", + "X11": "2", + "X12": "-2", + "X15": "2", + "X16": "-2", + "X19": "2", + "X20": "-2", + "X24": "2", + "X25": "-2", + "X28": "2", + "X29": "-2", + "X3": "-2", + "X33": "2", + "X34": "-2", + "X37": "2", + "X38": "-2", + "X41": "2", + "X42": "-2", + "X45": "2", + "X46": "-2", + "X48": "2", + "X49": "-2", + "X52": "2", + "X53": "-2", + "X56": "2", + "X57": "-2", + "X6": "2", + "X60": "2", + "X61": "-2", + "X64": "2", + "X65": "-2", + "X68": "2", + "X69": "-2", + "X7": "2", + "X72": "2", + "X73": "-2", + "X76": "2", + "X77": "-2", + "X8": "-2", + "X80": "2", + "X81": "-2", + "X83": "2", + "X84": "-2", + "X87": "2", + "X88": "-2", + "X90": "2", + "X91": "-2", + "X96": "2", + "X97": "-2", + "X99": "2" + } + }, + { + "allocation_event": 2470, + "alpha": [ + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0" + ], + "copy_event": 2471, + "descent_event": 2472, + "erase_event": 2476, + "row": { + "Q1": "1", + "X10": "2", + "X101": "-2", + "X102": "2", + "X11": "2", + "X12": "2", + "X14": "2", + "X21": "-2", + "X22": "-2", + "X23": "2", + "X3": "-2", + "X30": "-2", + "X31": "2", + "X36": "-2", + "X37": "-2", + "X38": "-2", + "X39": "-2", + "X4": "-2", + "X40": "2", + "X41": "2", + "X42": "2", + "X43": "2", + "X5": "-2", + "X51": "-2", + "X52": "-2", + "X53": "-2", + "X54": "-2", + "X55": "2", + "X56": "2", + "X57": "2", + "X58": "2", + "X6": "-2", + "X67": "-2", + "X68": "-2", + "X69": "-2", + "X7": "2", + "X70": "-2", + "X71": "2", + "X72": "2", + "X73": "2", + "X74": "2", + "X8": "2", + "X82": "-2", + "X83": "-2", + "X84": "-2", + "X85": "-2", + "X86": "2", + "X87": "2", + "X88": "2", + "X89": "2", + "X9": "2", + "X94": "-2", + "X95": "2" + } + }, + { + "allocation_event": 2477, + "alpha": [ + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0" + ], + "copy_event": 2478, + "descent_event": 2479, + "erase_event": 2484, + "row": { + "Q2": "1", + "X10": "2", + "X102": "2", + "X103": "-2", + "X11": "2", + "X12": "2", + "X13": "2", + "X14": "-2", + "X15": "-2", + "X16": "-2", + "X17": "-2", + "X18": "-2", + "X19": "-2", + "X20": "-2", + "X21": "-2", + "X22": "-2", + "X31": "2", + "X32": "-2", + "X40": "2", + "X41": "2", + "X42": "2", + "X43": "2", + "X44": "2", + "X45": "2", + "X46": "2", + "X47": "-2", + "X48": "-2", + "X49": "-2", + "X50": "-2", + "X51": "-2", + "X52": "-2", + "X53": "-2", + "X54": "-2", + "X7": "2", + "X71": "2", + "X72": "2", + "X73": "2", + "X74": "2", + "X75": "2", + "X76": "2", + "X77": "2", + "X78": "2", + "X79": "-2", + "X8": "2", + "X80": "-2", + "X81": "-2", + "X82": "-2", + "X83": "-2", + "X84": "-2", + "X85": "-2", + "X9": "2", + "X93": "2", + "X94": "-2" + } + }, + { + "allocation_event": 2485, + "alpha": [ + "0", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0" + ], + "copy_event": 2486, + "descent_event": 2487, + "erase_event": 2492, + "row": { + "Q3": "1", + "X0": "-2", + "X1": "-2", + "X100": "-2", + "X101": "-2", + "X12": "-2", + "X13": "-2", + "X14": "2", + "X15": "2", + "X2": "-2", + "X20": "-2", + "X21": "-2", + "X23": "2", + "X24": "2", + "X29": "-2", + "X3": "-2", + "X30": "-2", + "X33": "2", + "X38": "-2", + "X39": "-2", + "X4": "-2", + "X40": "2", + "X41": "2", + "X46": "-2", + "X47": "2", + "X48": "2", + "X5": "-2", + "X53": "-2", + "X54": "-2", + "X55": "2", + "X56": "2", + "X6": "-2", + "X61": "-2", + "X62": "-2", + "X63": "2", + "X64": "2", + "X69": "-2", + "X7": "2", + "X70": "-2", + "X71": "2", + "X72": "2", + "X77": "-2", + "X78": "-2", + "X79": "2", + "X80": "2", + "X84": "-2", + "X85": "-2", + "X86": "2", + "X87": "2", + "X91": "-2", + "X92": "-2", + "X95": "2", + "X96": "2" + } + }, + { + "allocation_event": 2493, + "alpha": [ + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0" + ], + "copy_event": 2494, + "descent_event": 2495, + "erase_event": 2500, + "row": { + "Q4": "1", + "X0": "-2", + "X1": "-2", + "X100": "-2", + "X101": "2", + "X12": "-2", + "X13": "2", + "X14": "-2", + "X15": "2", + "X2": "-2", + "X20": "-2", + "X21": "2", + "X23": "-2", + "X24": "2", + "X29": "-2", + "X3": "2", + "X30": "2", + "X34": "-2", + "X35": "-2", + "X36": "2", + "X37": "2", + "X4": "2", + "X42": "-2", + "X43": "-2", + "X44": "2", + "X45": "2", + "X49": "-2", + "X5": "2", + "X50": "-2", + "X51": "2", + "X52": "2", + "X57": "-2", + "X58": "-2", + "X59": "2", + "X6": "2", + "X60": "2", + "X65": "-2", + "X66": "-2", + "X67": "2", + "X68": "2", + "X7": "2", + "X73": "-2", + "X74": "-2", + "X75": "2", + "X76": "2", + "X81": "-2", + "X82": "2", + "X83": "2", + "X88": "-2", + "X89": "-2", + "X90": "2", + "X95": "-2", + "X96": "2" + } + }, + { + "allocation_event": 2501, + "alpha": [ + "1/2", + "-1/2", + "-1/2", + "1/2", + "1/2", + "1/2", + "1/2", + "1/2" + ], + "copy_event": 2502, + "descent_event": 2503, + "erase_event": 2507, + "row": { + "Q5": "1", + "X1": "2", + "X10": "2", + "X100": "2", + "X101": "2", + "X102": "2", + "X11": "2", + "X12": "2", + "X13": "2", + "X14": "-2", + "X15": "-2", + "X16": "-2", + "X17": "-2", + "X2": "2", + "X22": "-2", + "X23": "-2", + "X24": "-2", + "X25": "-2", + "X26": "-2", + "X32": "-2", + "X35": "2", + "X37": "2", + "X38": "2", + "X39": "2", + "X41": "2", + "X42": "2", + "X43": "2", + "X44": "2", + "X45": "2", + "X46": "2", + "X47": "-2", + "X5": "2", + "X54": "2", + "X58": "2", + "X6": "2", + "X60": "2", + "X61": "2", + "X62": "2", + "X63": "-2", + "X70": "2", + "X74": "2", + "X76": "2", + "X77": "2", + "X78": "2", + "X79": "-2", + "X80": "-2", + "X81": "-2", + "X82": "-2", + "X86": "-2", + "X92": "2", + "X93": "2", + "X98": "2", + "X99": "2" + } + }, + { + "allocation_event": 2508, + "alpha": [ + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1" + ], + "copy_event": 2509, + "descent_event": 2510, + "erase_event": 2515, + "row": { + "Q6": "1", + "X0": "2", + "X1": "-2", + "X10": "-2", + "X11": "-2", + "X16": "2", + "X17": "2", + "X18": "-2", + "X19": "-2", + "X2": "-2", + "X25": "2", + "X26": "2", + "X27": "-2", + "X28": "-2", + "X3": "2", + "X34": "2", + "X35": "-2", + "X36": "2", + "X37": "-2", + "X4": "2", + "X40": "2", + "X41": "-2", + "X46": "2", + "X47": "2", + "X48": "-2", + "X5": "-2", + "X53": "2", + "X54": "-2", + "X57": "2", + "X58": "-2", + "X59": "2", + "X6": "-2", + "X60": "-2", + "X63": "2", + "X64": "-2", + "X69": "2", + "X70": "-2", + "X73": "2", + "X74": "-2", + "X75": "2", + "X76": "-2", + "X8": "2", + "X81": "2", + "X82": "2", + "X83": "-2", + "X86": "2", + "X87": "-2", + "X9": "2", + "X91": "2", + "X92": "-2", + "X97": "2", + "X98": "-2", + "X99": "-2" + } + }, + { + "allocation_event": 2516, + "alpha": [ + "1/2", + "1/2", + "1/2", + "-1/2", + "-1/2", + "1/2", + "1/2", + "1/2" + ], + "copy_event": 2517, + "descent_event": 2518, + "erase_event": 2524, + "row": { + "Q7": "1", + "X1": "2", + "X100": "2", + "X103": "2", + "X13": "-2", + "X14": "2", + "X18": "2", + "X19": "2", + "X2": "2", + "X20": "2", + "X22": "2", + "X23": "2", + "X27": "2", + "X28": "2", + "X29": "2", + "X3": "-2", + "X32": "2", + "X35": "2", + "X36": "-2", + "X4": "-2", + "X40": "-2", + "X44": "-2", + "X45": "-2", + "X46": "-2", + "X48": "2", + "X49": "2", + "X50": "2", + "X54": "2", + "X58": "2", + "X59": "-2", + "X64": "2", + "X65": "2", + "X66": "2", + "X7": "-2", + "X70": "2", + "X74": "2", + "X75": "-2", + "X79": "2", + "X8": "-2", + "X80": "2", + "X81": "2", + "X83": "2", + "X84": "2", + "X85": "2", + "X87": "2", + "X88": "2", + "X89": "2", + "X9": "-2", + "X92": "2", + "X94": "2", + "X95": "2", + "X98": "2", + "X99": "2" + } + } + ], + "rank_profile": { + "1": 1074, + "2": 58, + "3": 86, + "4": 104, + "5": 48, + "6": 24, + "7": 8, + "8": 8 + }, + "state_certificate_sha256": "0c3fe19557e688834f514130fe7dbfd052832e5c6b0bc5fe8213a6e9e3e52ef8", + "state_certificates": 2458, + "target_endpoint_contacts": 0 + } +} diff --git a/research/p104-live-helper-reads/SOURCES.json b/research/p104-live-helper-reads/SOURCES.json new file mode 100644 index 0000000000..3bb2451581 --- /dev/null +++ b/research/p104-live-helper-reads/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "usage": "input", + "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "usage": "input", + "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + } + ] +} diff --git a/research/p104-live-helper-reads/TASK.json b/research/p104-live-helper-reads/TASK.json new file mode 100644 index 0000000000..0887d0af12 --- /dev/null +++ b/research/p104-live-helper-reads/TASK.json @@ -0,0 +1,122 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "p104-side-correction", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ] + }, + "scope_status": "changed", + "actual_scope": "Extend the P104 monotone relay floor to read-only access to every original G/Q/D value at its actual chronological frame, including unfinished source rows outside K.", + "scope_change_reason": "PR2383 explicitly excludes unfinished original helper reads and asks whether they evade its quotient argument. The new finite endpoint-avoidance premise and coupled source-decomposition induction settle actual-frame read-only access without treating those rows as arbitrary-frame oracles.", + "bottleneck_link": "This rules out harvesting the existing unfinished helper information for a free correction arrival while retaining the original word. A changed schedule or writable descending path must be named before building an escape.", + "budget_minutes": 60, + "stop_rule": "Stop after the actual-frame helper-read implication and exact finite premises; do not synthesize a correction or infer a complete cost/supplier bound.", + "outcome": "negative-result", + "evidence": "Written arbitrary-length proof; exact 280-input event replay and source decomposition at every modified non-target state; all104 endpoint/source-support/minor witnesses; semantic controls.", + "author": "ywz65", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, checking and writing; no independent human or formal proof assistant review.", + "open_questions": [ + { + "question": "Can one changed original helper path create a target-endpoint contact with useful outside-code source information?", + "why_it_matters": "Actual-frame read-only use of all current paths cannot evade the 208-lifetime floor.", + "first_step": "Select one original helper and endpoint, change its path explicitly, then check all retained captures/cleanup and price the newly required transports before synthesis.", + "blocked_by": "No unchanged helper visits any target endpoint; a new contact must preserve all existing source and query contracts." + }, + { + "question": "Can writing new information into an original descending private lifetime improve a completed correction?", + "why_it_matters": "The theorem assumes the original word remains read-only; source information outside K carried down would violate its invariant.", + "first_step": "Specify one new pre-descent update and the exact source projection after it, then derive chronological capture and dirty-restoration requirements.", + "blocked_by": "Native/physical legality, restoration and full paid moment are not supplied by a source-row escape." + } + ], + "selection_nonce": "691d45d0f00693aa125dd9c581fbf5c9", + "freshness": { + "main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "checked_at": "2026-10-15T11:28:07.867641+00:00" + }, + "predecessors": [ + { + "pr": 2383, + "commit": "41f3d517b521500b114f3491f5f5b68a0550f410", + "path": "research/p104-private-code-relay-floor/README.md", + "author": "commdata2338", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2383", + "sha256": "eff162e2cff26fc6791cdce17e6e087e749aa87fce99b79049444328cbe13a80", + "git_blob": "b49d49730d66f44adb6f7a05884847d64f215a1c", + "usage": "Written predecessor and handoff only; no executable imported" + }, + { + "pr": 2353, + "commit": "2704eadf6b5205d4b965e9c6fc6dce28b89783cf", + "path": "research/p104-monotone-relay-floor-audit/README.md", + "author": "Hiroki Kumazaki / kumagi", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2353", + "sha256": "1994370aa479f01b44a55c5f8afadec5e918dc60efac08cd29adbfc5098357e3", + "git_blob": "a8da976c83eda0c8c5ec7bc2f0f5068edb167c03", + "usage": "Written predecessor and handoff only; no executable imported" + } + ], + "overlap": { + "open_prs": 660, + "prs_fetched": "2026-10-15T11:21:32.388775+00:00", + "discussion_records": 1186, + "discussions_fetched": "2026-10-15T11:25:11.056109+00:00", + "complete_pagination": true, + "warnings": [], + "limits": "Titles/bodies/discussion/comments and local README/TASK/ledger; not arbitrary diffs or unpublished work." + }, + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2383#issuecomment-6191012861", + "independent_agent_review": { + "reviewer": "stock_envelope_work", + "status": "no material blocker", + "scope": "Written arbitrary-length quotient/arrival proof, source-bound exact trace and optimized native CPython3.12.7 replay; AI review, no independent human review" + }, + "submission_refresh": { + "main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "utc": "2026-10-15T11:38:38.0043782Z", + "predecessor_heads_unchanged": true, + "decision": "Canonical main and both pinned predecessor heads unchanged; preserve source pins." + } +} diff --git a/research/p104-live-helper-reads/VERIFY.json b/research/p104-live-helper-reads/VERIFY.json new file mode 100644 index 0000000000..50839b85e7 --- /dev/null +++ b/research/p104-live-helper-reads/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-native-channel/inputs/P104-FIXTURE.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "All chronological source decompositions, 72 original helper path avoidance, 104 quotient/entrance premises, full 280-input endpoints and eight semantic controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 300, + "checks": "Read-only Git-free source export and changed/missing source or receipt rejection" + } + ] +} diff --git a/research/p104-live-helper-reads/test_verify.py b/research/p104-live-helper-reads/test_verify.py new file mode 100644 index 0000000000..ebad47e1fe --- /dev/null +++ b/research/p104-live-helper-reads/test_verify.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Behavior checks on a Git-free source export; no scientific input is rewritten.""" +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest +from hashlib import sha256 + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent + + +class ExportChecks(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temp = tempfile.TemporaryDirectory(prefix="p104-live-helper-") + cls.root = Path(cls.temp.name) + cls.package = cls.root / "research/p104-live-helper-reads" + shutil.copytree(HERE, cls.package, ignore=shutil.ignore_patterns("__pycache__")) + cls.inputs = [x["path"] for x in json.loads((HERE/"SOURCES.json").read_text())['files'] + if x['usage'] == 'input'] + for name in cls.inputs: + target = cls.root/name + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT/name, target) + + @classmethod + def tearDownClass(cls): + cls.temp.cleanup() + + def run_export(self): + return subprocess.run([sys.executable, "-I", "-O", "-B", str(self.package/"verify.py")], + cwd=self.root, capture_output=True, text=True, timeout=120) + + def test_read_only_export(self): + def snapshot(): + return {str(p.relative_to(self.root)): sha256(p.read_bytes()).hexdigest() + for p in self.root.rglob("*") if p.is_file()} + before = snapshot() + proc = self.run_export() + self.assertEqual(proc.returncode, 0, proc.stdout+proc.stderr) + self.assertIn("PASS_P104_LIVE_HELPER_READS", proc.stdout) + self.assertEqual(before, snapshot()) + + def test_source_drift(self): + p = self.root/self.inputs[0] + raw = p.read_bytes() + try: + p.write_bytes(raw+b"\n") + proc = self.run_export() + self.assertNotEqual(proc.returncode, 0) + self.assertIn("source hash", proc.stderr) + finally: + p.write_bytes(raw) + + def test_missing_source(self): + p = self.root/self.inputs[0] + raw = p.read_bytes() + try: + p.unlink() + proc = self.run_export() + self.assertNotEqual(proc.returncode, 0) + self.assertIn("FileNotFoundError", proc.stderr) + finally: + p.write_bytes(raw) + + def test_receipt_and_duplicate_keys(self): + p = self.package/"RESULT.json" + raw = p.read_bytes() + try: + result = json.loads(raw) + result["trace"]["target_endpoint_contacts"] = 1 + p.write_text(json.dumps(result), encoding="utf8") + proc = self.run_export() + self.assertNotEqual(proc.returncode, 0) + self.assertIn("receipt mismatch", proc.stderr) + p.write_text('{"x":1,"x":2}', encoding="utf8") + proc = self.run_export() + self.assertNotEqual(proc.returncode, 0) + self.assertIn("duplicate JSON key", proc.stderr) + finally: + p.write_bytes(raw) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/p104-live-helper-reads/verify.py b/research/p104-live-helper-reads/verify.py new file mode 100644 index 0000000000..b477514af2 --- /dev/null +++ b/research/p104-live-helper-reads/verify.py @@ -0,0 +1,384 @@ +#!/usr/bin/env python3 +"""Exact premises for actual-frame read-only access to original P104 helpers. + +Prepared for ywz65 with substantial OpenAI Codex assistance. Apache-2.0. +No pending predecessor code is imported. Default execution writes nothing. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as F +from hashlib import sha256 +from itertools import combinations, product +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +WORD = "research/p104-native-channel/inputs/LOWRANK-WITNESS.json" +FIXTURE = "research/p104-native-channel/inputs/P104-FIXTURE.json" + + +class Invalid(ValueError): + pass + + +def require(ok, why): + if not ok: + raise Invalid(why) + + +def canonical(x): + return json.dumps(x, sort_keys=True, separators=(",", ":")) + + +def unique(pairs): + out = {} + for k, v in pairs: + require(k not in out, "duplicate JSON key") + out[k] = v + return out + + +def read(path): + return json.loads(path.read_text(encoding="utf8"), object_pairs_hook=unique) + + +def span(basis): + out = {0} + for v in basis: + require(type(v) is int and 0 <= v < 512, "invalid binary generator") + out.update(w ^ v for w in tuple(out)) + return frozenset(out) + + +def binary_basis(vectors): + chosen, current = [], frozenset({0}) + for v in vectors: + if v not in current: + chosen.append(v) + current = span(chosen) + return chosen + + +def rational_basis(rows): + pivots, indices = {}, [] + for i, original in enumerate(rows): + row = list(map(F, original)) + for p in sorted(pivots): + a = row[p] + if a: + row = [x - a*y for x, y in zip(row, pivots[p])] + p = next((j for j, a in enumerate(row) if a), None) + if p is not None: + a = row[p] + pivots[p] = [x/a for x in row] + indices.append(i) + return indices + + +def determinant(rows): + """Integer Bareiss check, independent of rational pivot selection.""" + a = [list(row) for row in rows] + n, sign, previous = len(a), 1, 1 + require(all(len(row) == n for row in a), "nonsquare minor") + for k in range(n - 1): + p = next((i for i in range(k, n) if a[i][k]), None) + if p is None: + return 0 + if p != k: + a[k], a[p] = a[p], a[k] + sign *= -1 + pivot = a[k][k] + for i in range(k + 1, n): + for j in range(k + 1, n): + numerator = a[i][j]*pivot - a[i][k]*a[k][j] + require(numerator % previous == 0, "inexact minor division") + a[i][j] = numerator // previous + a[i][k] = 0 + previous = pivot + return sign*a[-1][-1] + + +def roots(fixture): + all_roots = set() + for i, j in combinations(range(8), 2): + for sign in (-1, 1): + v = [0]*8 + v[i], v[j] = 2, 2*sign + all_roots.add(tuple(v)) + all_roots.update((1, *v) for v in product((-1, 1), repeat=7) + if v.count(-1) % 2 == 0) + puncture = fixture["section4_explicit_P104"] + removed = {tuple(v) for v in puncture["F0"] + puncture["C"]} + require(len(all_roots) == 120 and len(removed) == 16 and removed <= all_roots, + "invalid root puncture") + r = sorted(all_roots - removed) + require([[sum(v[i]*v[j] for v in r) for j in range(8)] for i in range(8)] + == [[104*int(i == j) for j in range(8)] for i in range(8)], "root Gram") + return r + + +def plus(dst, src, a): + for k, v in tuple(src.items()): + v = dst.get(k, F(0)) + a*v + if v: + dst[k] = v + else: + dst.pop(k, None) + + +def code_coordinates(source, r): + alpha = [sum(source.get(f"X{s}", F(0))*r[s][j] for s in range(104))/104 + for j in range(8)] + require(all(source.get(f"X{s}", F(0)) == sum(alpha[j]*r[s][j] for j in range(8)) + for s in range(104)), "source outside K") + return alpha + + +def serialized(row): + return {k: str(v) for k, v in sorted(row.items())} + + +def trace(word, r): + names = ([f"X{i}" for i in range(104)] + [f"Y{i}" for i in range(104)] + + [f"G{i}" for i in range(32)] + [f"Q{i}" for i in range(8)] + + [f"D{i}" for i in range(32)]) + require(set(word["initial_frames"]) == set(names), "initial inventory") + frames = {k: span(v) for k, v in word["initial_frames"].items()} + ends = {f"Y{t}": span(word["final_frames"][f"Y{t}"]) for t in range(104)} + require(len(set(ends.values())) == 104, "distinct target endpoints") + labels = [next(iter(frames[f"X{s}"] - {0})) for s in range(104)] + require(all(len(frames[f"X{s}"]) == 2 for s in range(104)), "source lines") + values = {k: {k: F(1)} for k in names} + # Independent certificate representation: source projection = alpha R + local. + alpha = {k: [F(0)]*8 for k in names} + local = {k: ({int(k[1:]): F(1)} if k.startswith("X") else {}) for k in names} + paths = {k: [frames[k]] for k in names} + states, private, profile, counts = [], [], Counter(), Counter() + avoided = set() + example = None + active = None + + def certify(k, cut): + nonlocal example + if k.startswith("Y"): + return + require(all(labels[s] in frames[k] for s in local[k]), "local support leaves frame") + require(all(values[k].get(f"X{s}", F(0)) == local[k].get(s, F(0)) + + sum(alpha[k][j]*r[s][j] for j in range(8)) for s in range(104)), + "source decomposition identity") + state = [cut, k, sorted(frames[k]), list(map(str, alpha[k])), + {str(s): str(v) for s, v in sorted(local[k].items())}] + states.append(state) + if k[0] in "GQD": + require(frames[k] not in ends.values(), "original helper reaches target endpoint") + avoided.add((k, tuple(sorted(frames[k])))) + if example is None and local[k]: + compatible = [t for t in range(104) if frames[k] < ends[f"Y{t}"]] + if compatible: + try: + code_coordinates(values[k], r) + except Invalid: + example = {"cut": cut, "register": k, "frame": binary_basis(sorted(frames[k])), + "target": compatible[0], "full_input_row": serialized(values[k]), + "local_source_row": {str(s): str(v) for s, v in local[k].items()}, + "code_coefficients": list(map(str, alpha[k]))} + + for k in names: + certify(k, 0) + for i, event in enumerate(word["program"]): + op = event[0] + counts[op] += 1 + if op == "add": + _, dst, src, a, chart = event + require(dst in values and src in values and dst != src, "ADD inventory") + require(not dst.startswith("X") and not src.startswith("Y"), "data direction") + require(frames[dst] == frames[src] == span(chart), "ADD frame") + a = F(a) + plus(values[dst], values[src], a) + if not dst.startswith("Y"): + alpha[dst] = [x+a*y for x, y in zip(alpha[dst], alpha[src])] + plus(local[dst], local[src], a) + certify(dst, i+1) + elif op == "transport": + _, k, before, after, rank = event + a, b = span(before), span(after) + require(frames[k] == a and (a < b or b < a), "nested transport") + require(type(rank) is int and rank == abs(len(b).bit_length()-len(a).bit_length()), "transport rank") + profile[rank] += 1 + if k == "C": + require(active is not None and b < a and len(a) == 256 and len(b) == 2, + "private descent") + require(active["copy_event"] == i-1, "private copy chronology") + active["descent_event"] = i + else: + require(a < b, "original path descends") + paths[k].append(b) + frames[k] = b + certify(k, i+1) + elif op == "zero": + _, k, chart = event + require(k == "C" and k not in values and active is None, "private allocation") + values[k], frames[k], alpha[k], local[k] = {}, span(chart), [F(0)]*8, {} + active = {"allocation_event": i} + certify(k, i+1) + elif op == "copy": + _, dst, src, chart = event + require(dst == "C" and src == f"Q{len(private)}" and active is not None and not values[dst], + "private copy") + require(frames[dst] == frames[src] == span(chart), "COPY frame") + values[dst] = dict(values[src]) + alpha[dst], local[dst] = code_coordinates(values[src], r), {} + dirt = {k: v for k, v in values[src].items() if not k.startswith("X")} + require(dirt == {src: F(1)}, "private dirt") + active.update(copy_event=i, alpha=list(map(str, alpha[dst])), row=serialized(values[dst])) + certify(dst, i+1) + elif op == "erase": + _, k, chart = event + require(k == "C" and active is not None and frames[k] == span(chart), "private erase") + require(serialized(values[k]) == active["row"], "private value changed") + active["erase_event"] = i + private.append(active) + active = None + for state in (values, frames, alpha, local): + del state[k] + else: + raise Invalid("unknown event") + require(active is None and len(private) == 8, "private count") + require(frames == {k: span(v) for k, v in word["final_frames"].items()}, "final frames") + for k in names: + expected = {k: F(1)} + if k.startswith("Y"): + t = int(k[1:]) + expected.update({f"X{s}": F(sum(a*b for a, b in zip(r[t], r[s])), 8) + for s in range(104) if sum(a*b for a, b in zip(r[t], r[s]))}) + require(values[k] == expected, "endpoint row " + k) + require(example is not None, "missing outside-code example") + return {"events": len(word["program"]), "independent_inputs": len(names), + "state_certificates": len(states), "state_certificate_sha256": sha256(canonical(states).encode()).hexdigest(), + "original_helper_frame_pairs": len(avoided), "target_endpoint_contacts": 0, + "original_helper_paths": {k: [binary_basis(sorted(v)) for v in paths[k]] for k in paths if k[0] in "GQD"}, + "operations": dict(sorted(counts.items())), "rank_profile": {str(k): v for k, v in sorted(profile.items())}, + "private_lifetimes": private, "outside_code_example": example}, paths, labels + + +def geometry(paths, labels, r): + result = [] + for t in range(104): + h = paths[f"Y{t}"][-1] + require(len(h) == 256 and paths[f"Y{t}"][0] == {0}, "target dimensions") + support = {s for s in range(104) if F(s == t)-F(sum(a*b for a, b in zip(r[t], r[s])), 8)} + require(support == {s for s in range(104) if labels[s] in h}, "correction support") + early = {s for s in support if any(labels[s] in v for v in paths[f"Y{t}"][:-1])} + needed = sorted(support-early) + chosen_labels = binary_basis(labels[s] for s in needed) + require(span(chosen_labels) == h, "required support rank") + require(not any(h in paths[f"X{s}"] for s in range(104)), "direct source endpoint") + outside = [s for s in range(104) if s not in support] + chosen = [outside[i] for i in rational_basis([r[s] for s in outside])] + require(len(chosen) == 8 and determinant([r[s] for s in chosen]) != 0, "code quotient injectivity") + result.append({"target": t, "endpoint": binary_basis(sorted(h)), "support": sorted(support), + "early": sorted(early), "required_basis_sources": [labels.index(v) for v in chosen_labels], + "outside_minor_columns": chosen, "outside_minor_determinant": determinant([r[s] for s in chosen])}) + return result + + +def rejects(operation, expected): + try: + operation() + except Invalid as exc: + require(str(exc) == expected, "wrong rejection: " + str(exc)) + return + raise Invalid("mutation accepted: " + expected) + + +def controls(word, r, summary, paths, labels): + result = [] + bad = deepcopy(word) + event = next(e for e in bad["program"] if e[0] == "transport") + event[4] += 1 + rejects(lambda: trace(bad, r), "transport rank") + result.append("wrong native rank rejected") + bad = deepcopy(word) + next(e for e in bad["program"] if e[0] == "add" and e[1] == "Q0")[3] = 0 + rejects(lambda: trace(bad, r), "private dirt") + result.append("missing query compensation rejected") + bad = deepcopy(word) + last = max(i for i, e in enumerate(bad["program"]) if e[0] == "add") + bad["program"][last][3] = 0 + try: + trace(bad, r) + except Invalid as exc: + require(str(exc).startswith("endpoint row "), "missing cleanup rejection") + else: + raise Invalid("missing cleanup accepted") + result.append("missing dirty cleanup rejected") + # This actual unfinished row is outside K, but is supported in its actual frame. + example = summary["outside_code_example"] + row = {k: F(v) for k, v in example["full_input_row"].items()} + rejects(lambda: code_coordinates(row, r), "source outside K") + v = span(example["frame"]) + require(all(labels[int(s)] in v for s in example["local_source_row"]), "example support") + result.append("actual unfinished outside-K read is quotient-admissible") + # Moving that value freely to ZERO is a strictly stronger, unclaimed permission. + require(any(labels[int(s)] != 0 for s in example["local_source_row"]), "free-frame escape missing") + result.append("free arbitrary-frame access violates local support") + # A wrong endpoint frame must invalidate the new finite premise. + bad = deepcopy(word) + helper_frame = next(e[3] for e in word["program"] if e[0] == "transport" and e[1].startswith("G") and len(span(e[3])) == 256) + bad["final_frames"]["Y0"] = helper_frame + rejects(lambda: trace(bad, r), "original helper reaches target endpoint") + result.append("new endpoint contact rejected") + # A target-supported oracle at the endpoint removes the entrance conclusion. + # This is deliberately not an actual-frame original-helper read. + correction = {f"X{s}": F(s == 0)-F(sum(a*b for a, b in zip(r[0], r[s])), 8) + for s in range(104)} + correction = {k: v for k, v in correction.items() if v} + rejects(lambda: code_coordinates(correction, r), "source outside K") + require(len(correction) == 48 and span(labels[int(k[1:])] for k in correction) == paths["Y0"][-1], + "oracle countermodel target support") + arbitrary_target = {"Y0": F(1)} + plus(arbitrary_target, correction, F(1)) + require(arbitrary_target == {"Y0": F(1), **correction}, "zero-entrance oracle write") + result.append("outside-K endpoint oracle permits zero-entrance correction") + # Input-independent invertible code-coordinate changes preserve the quotient. + changed = [tuple([v[0]+v[1], *v[1:]]) for v in r] + for target in geometry(paths, labels, r): + cols = target["outside_minor_columns"] + require(determinant([changed[s] for s in cols]) == target["outside_minor_determinant"], "basis-change minor") + result.append("all104 invertible code-basis controls") + return result + + +def compute(): + sources = read(HERE/"SOURCES.json") + pins = {p["path"]: p["sha256"] for p in sources["files"] if p["usage"] == "input"} + require(set(pins) == {WORD, FIXTURE}, "source inventory") + for path, digest in pins.items(): + require(sha256((ROOT/path).read_bytes()).hexdigest() == digest, "source hash " + path) + word, fixture = read(ROOT/WORD), read(ROOT/FIXTURE) + r = roots(fixture) + summary, paths, labels = trace(word, r) + targets = geometry(paths, labels, r) + return {"schema_version": 1, "claim": "actual-frame original helper reads preserve 208 new monotone lifetimes", + "sources": pins, "trace": summary, "targets": targets, "helper_lifetime_floor": 208, + "controls": controls(word, r, summary, paths, labels), + "limits": "read-only original word; no new descending helper, target feedback, arbitrary-frame oracle, supplier or kappa"} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path) + args = parser.parse_args() + result = compute() + require(canonical(result) == canonical(read(HERE/"RESULT.json")), "receipt mismatch") + if args.out: + with args.out.open("x", encoding="utf8") as f: + json.dump(result, f, indent=2, sort_keys=True) + f.write("\n") + print(f"PASS_P104_LIVE_HELPER_READS original_helpers=72 endpoint_contacts=0 lifetimes=208 controls={len(result['controls'])} no_new_kappa") + + +if __name__ == "__main__": + main()