From baa90ee8176931e697d91a9024114ee2e9a189ea Mon Sep 17 00:00:00 2001 From: ywz65 <154373401+ywz65@users.noreply.github.com> Date: Thu, 15 Oct 2026 04:41:38 -0700 Subject: [PATCH] research: construct native QQ16 future query with restored sources --- research/qq16-future-x-query/PREDECESSOR.json | 10 + research/qq16-future-x-query/PROOF.md | 139 + research/qq16-future-x-query/README.md | 121 + research/qq16-future-x-query/RESULT.json | 9681 +++++++++++++++++ research/qq16-future-x-query/SOURCES.json | 48 + research/qq16-future-x-query/TASK.json | 90 + research/qq16-future-x-query/VERIFY.json | 47 + .../evidence/PR2443-README.md | 213 + research/qq16-future-x-query/test_package.py | 69 + research/qq16-future-x-query/verify.py | 316 + 10 files changed, 10734 insertions(+) create mode 100644 research/qq16-future-x-query/PREDECESSOR.json create mode 100644 research/qq16-future-x-query/PROOF.md create mode 100644 research/qq16-future-x-query/README.md create mode 100644 research/qq16-future-x-query/RESULT.json create mode 100644 research/qq16-future-x-query/SOURCES.json create mode 100644 research/qq16-future-x-query/TASK.json create mode 100644 research/qq16-future-x-query/VERIFY.json create mode 100644 research/qq16-future-x-query/evidence/PR2443-README.md create mode 100644 research/qq16-future-x-query/test_package.py create mode 100644 research/qq16-future-x-query/verify.py diff --git a/research/qq16-future-x-query/PREDECESSOR.json b/research/qq16-future-x-query/PREDECESSOR.json new file mode 100644 index 0000000000..2da8d505c1 --- /dev/null +++ b/research/qq16-future-x-query/PREDECESSOR.json @@ -0,0 +1,10 @@ +{ + "pr": 2443, + "head": "545c05e17243c962b112b91e7f84b4c1a41de7b8", + "path": "research/qq16-coordinate-cut-decoder/README.md", + "sha256": "91d68f5d01d89ee78802ee5f76e8b901199a686aaa62341090eb70c458fd070e", + "git_blob": "1ae3d3eb976ed85f795da2c211b58577ed7e8a82", + "usage": "Exact access handoff and observation-cut context; no pending code imported.", + "retained_copy": "evidence/PR2443-README.md", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/545c05e17243c962b112b91e7f84b4c1a41de7b8/research/qq16-coordinate-cut-decoder/README.md" +} diff --git a/research/qq16-future-x-query/PROOF.md b/research/qq16-future-x-query/PROOF.md new file mode 100644 index 0000000000..95b98d8b2a --- /dev/null +++ b/research/qq16-future-x-query/PROOF.md @@ -0,0 +1,139 @@ +# Future-X query at the post-B1 cut + +## Objects, available frames and extra storage + +Use the actual disjoint QQ16 A/T minors and their ordinary complement U of +size 96. Set `C=x2_U` immediately after `B_1_2`. The retained contract gives +each X source p at owner d the completed native frame + +``` +T_X(d) = F_(d U1), U1=L+E1. +``` + +The logical values C are arbitrary; in PR2443 they equal `-y_U^initial`. +No use is made of that equality, of selected endpoint values, or of a later +former-Y hole. The new word owns eight output arrays. It clears them before +use and returns them live in the common query frame. Those arrays are not +claimed to come free from the selected helper bank or to preserve dirty input. + +For p in U, let `q_p` be its actual nine-bit normal and let `rho_p=rho_2(p)`. +This involution fixes q_p and exchanges its eight chart axes with E2. Write +`delta_p=q_p+lift_2(beta_p)`. The source's future-Y alignment and inverse are + +``` +A_p = M(rho_p, delta_p), +A_p^-1 = M(rho_p, rho_p delta_p), +M(g,a) f(d,z_1,...,z_lambda) + = f(dg,z_1+d a,...,z_lambda+d a). +``` + +It changes owners and translates every payload layer. It does not apply g +to the payload address. All fields at different owner/port indices remain +independent. Every per-field map is a bijection of its full array. + +## The unavailable zero-line shortcut and the exact repair + +Let `T_c(d)=F_(d(E1+E2))` and let `D_p=M(rho_p,0)` be the logical route. +The retained bridge identity, for a Y-type source before chart 2, is + +``` +A_p [F_(d U1) C_(d q_p)^-1] = T_c(d) D_p. +``` + +Here `C_q=(1+i)I/2+(1-i)T_q/2` is the signed native rank-one line operator. +Since rho_p fixes q_p, omitting that inverse line leaves exactly C_q: + +``` +after A_p, the X source frame is T_c(d) C_(d q_p). +``` + +This residual is not the identity. At an identity-owner Fourier character +w with `q_p dot w=1`, its multiplier is i. The receipt supplies such a w for +each of the 96 actual ports. Therefore the future-Y scalar query cannot be +applied directly to these unnormalized X fields in its common output frame. +This does not exclude other physical implementations or other observation cuts. + +Normalize source p first with `C_(d q_p)^-1`. Native frames are products of +commuting address translations/line operators, so this changes its frame +to the required Y type while retaining its arbitrary logical value. Applying +A_p then puts it in frame T_c with logical content D_p C_p. All 96 source +fields now have exactly the same native frame at each common owner. + +Clear eight owned output arrays. Zero is compatible with T_c, so no native +line preparation of a nonzero dirty output is assumed. For each k, perform +the literal signed scalar additions + +``` +Q_k += R[k,p] * aligned_C_p, for p in U with R[k,p] != 0. +``` + +This yields `Q=R_U D_(2,U) C=B2 C`, in frame T_c. Scalar additions leave +every source field unchanged. Undo every A_p, then apply `C_(d q_p)` to each +source. Both physical and logical source endpoints are exactly restored. +The output arrays are intentionally retained; they are the requested observation. + +All normalization, alignment, accumulation, undo and restoration sweeps are +completed in that order before the next sweep. At a fixed owner, all ADDs +use different source and output fields in matching frames. Finishing each +full-cover sweep prevents reads from partially updated other owners. The +word can therefore be inserted before the next source-modifying operation, +subject to separate global scheduling and child-hosting obligations. + +## Literal rank-one kernels + +For every actual nonzero q in the nine-dimensional local block, choose an +invertible binary G with `G e0=q`. The verifier takes q as its first column +and the other eight coordinate axes except one pivot of q as the remaining +columns. Define P_G by sending the basis vector at address x to the basis +vector at address Gx. Then + +``` +P_G C_e0 P_G^-1 = C_q, +T_q P_G C_e0 P_G^-1 = C_q^-1. +``` + +The source rank-one primitive C_e0 has two Gaussian coefficients +`(1+i)/2` and `(1-i)/2`. Both signed words therefore use one rank-one child +and two monomial wrappers. The inverse translation is fused into the left +wrapper, exactly as in the retained QQ16 convention. The checker verifies +both Gaussian coefficients at every one of the 512 local basis addresses +for all 96 ports and both signs: 98,304 exact columns. External axes are +spectators. The identities lift ownerwise and to every positive tensor power. + +These are operator recipes and recursive rank counts. They do not themselves +assign available helper owners or bound the physical address implementation. + +## Phase and logical verification + +A field's Fourier phase is represented as a sum of binary parities with +integer coefficients modulo four. Such a function has a unique multilinear +polynomial of degree at most two modulo four: its linear coefficients are +modulo four and each cross coefficient is zero or two. Equality of these +polynomials is an identity on all 73-bit characters, not a random test. + +A native line appends the term `+/- (q dot w)`. A map M(g,a) changes each +phase axis v to gv and adds `2(a dot w)`. The checker applies exactly these +rules after every literal operation and requires matching phases for each +ADD. Alongside the phase it tracks an exact rational linear combination of +104 independent logical input arrays, carrying actual owner matrix products. +Native lines change frames; cover maps apply their logical owner routes. +Final checks require all 96 source rows to be the original independent input +and the eight output rows to be precisely R_U D_(2,U), with no dependence on +the discarded owned inputs. This jointly proves content and frame correctness +under the stated native semantics. + +## Complete local invoice and boundary + +There are 96 inverse and 96 positive lines, hence 192 rank-one children and +384 native wrapper maps. Each of 96 sources has one full-cover alignment and +one inverse, hence 192 full-cover maps. Each actual ordinary R column has +four signed unit coefficients, so there are 384 ADDs and eight CLEARs. +The retained per-real-component bounds are four primitives per ADD and one +per CLEAR; two components give `2*(384*4+8)=3088`. No SCALE or implicit COPY +is omitted. The eight owned output arrays are additional live storage. + +The result is a complete local operator read and an explicit local count, +not the complete PR2443 decoder or a favorable global bill. Other retained +cut arrays, query output conversions, stream/address costs, global child +delivery, storage lifetime, cleanup, precision and all-size supplier admission +remain open. This word alone does not change a moment or an exponent. diff --git a/research/qq16-future-x-query/README.md b/research/qq16-future-x-query/README.md new file mode 100644 index 0000000000..16d94b2a3e --- /dev/null +++ b/research/qq16-future-x-query/README.md @@ -0,0 +1,121 @@ +# A native local read of QQ16's future query B2 C + +This supplies one missing local access in [PR2443](https://github.com/CrocSwap/integer-mult-bounds/pull/2443): +read `B2 C` from its post-B1 ordinary target block `C=x2_U`, return all 96 +source arrays unchanged, and retain the eight query coordinates in explicitly +owned output arrays. The complete local word costs **192 rank-one children**. +It is not a zero-native-line use of the earlier X bridge. + +At that cut C has completed-X stage-1 frame `F_(L+E1)`, but the requested +chart is future chart 2. The retained bridge only promises its zero-line X +alignment at or after the queried chart. Applying the future-Y alignment to +this X frame leaves the exact port-specific factor `C_(q_p)`. One inverse +line per source removes it; one positive line per source restores it after +the read. This is a constructive local invoice, not an unrestricted lower +bound on every possible way of obtaining the query. + +## Exact interface and invoice + +The unchanged source contract places the 96 ordinary X fields in frame +`F_(d(L+E1))` after `B_1_2`. Their logical values C are arbitrary. Insert this +read before any following operation changes them. The eight new output arrays +are **owned**, so their arbitrary previous contents may be cleared. They are +not borrowed dirty helpers. The output is + +``` +Q_k(d, payload) = (B2 C)_k(d, payload), k=0,...,7, +native output frame F_(d(E1+E2)). +``` + +All original source contents, native frames and owner positions are restored. +All output arrays remain live. Their later retention, delivery and eventual +cleanup are separate controller obligations; this word does not hide them in +the original 480-helper stock. + +| Complete local quantity | Count | +| --- | ---: | +| Rank-one children / native rank mass | 192 / 192 | +| Native monomial wrapper maps | 384 | +| Full-cover maps, including undo | 192 | +| Signed scalar ADDs | 384 | +| Owned-output CLEARs | 8 | +| Real scalar primitive allowance | 3,088 | +| New live owned output arrays | 8 | +| Borrowed source arrays restored | 96 | +| Literal events before expanding line wrappers | 776 | + +The scalar allowance is `2*(4*384+8)` under the retained complex-to-real +ledger. It excludes the separately counted child and map costs. Map counts +are not a physical addressing-time bound. No complete favorable supplier +budget or new kappa is established. + +## Evidence and reproduction + +[PROOF.md](PROOF.md) derives the exact endpoint using the inherited native +frame conventions and full-cover action. [RESULT.json](RESULT.json) contains +the literal word, all 192 signed line recipes, the complete invoice and +rejection receipts. [SOURCES.json](SOURCES.json) pins the immutable archive, +QQ16 packet and consumed contracts. The R matrix is independently rebuilt +from the retained scalar prefix. Future route matrices and both payload +translations are rebuilt from phase geometry and compared with emitted maps. + +The motivating access handoff is retained verbatim in +[PR2443-README.md](evidence/PR2443-README.md), lines 188-191 and 202-212, from +PR2443 head `545c05e17243c962b112b91e7f84b4c1a41de7b8`. +[PREDECESSOR.json](PREDECESSOR.json) records its exact path, Git blob and +SHA-256. The tests bind that copy to both hashes. The runtime query is +independently defined from the base sources; no pending PR code is imported. + +The verifier tracks all 104 independent logical inputs with exact rational +coefficients and actual owner operators, alongside exact Z4 frame polynomials +after every event. Every ADD must have identical source/target native phases. +It checks all 98,304 low-block basis columns of the signed rank-one kernels; +the external coordinates are spectators. Eight controls reject missing +normalization/restoration, missing or incorrectly undone translations, an +uncleared dirty output, a wrong coefficient, an early query and an inverse +line with the wrong sign. The formal identities apply to arbitrary payloads; +no floating-point acceptance is used. + +```sh +python3.12 -I -B scripts/research_package.py --package research/qq16-future-x-query +python3.12 -I -O -B research/qq16-future-x-query/verify.py +``` + +Expected status: `PASS_QQ16_FUTURE_X_QUERY`. Replay compares the entire +recomputed receipt with the committed one and writes nothing. Explicit +`--write-result` creates a new receipt and refuses an existing path. + +## Limits + +This is a complete local native-operator sequence under the retained full-cover +view, signed rank-one primitive and sweep conventions. It does not assign its +new children to global helper owners, price physical map execution, prove +recursive precision, or retain the cut through the rest of the controller. +The other reads, scalar minor inverse, output gauge conversions, storage and +cleanup in PR2443 remain unpriced. It is not a full decoder implementation. + +## Open next questions + +1. Can the other two-cut records and this query be hosted and retained with a + favorable full invoice? Start with all added arrays, children and maps in + one chronological ledger; stop if the optimistic complete bill already + misses the supplier target. Global owner delivery is unresolved. +2. Can an earlier read or fusion with an existing native transition avoid + this standalone normalization cost? Specify a changed observation time or + word and check the full ordered decoder. This invoice does not exclude + such a different interface. + +## Credit + +`starship-s` / PR2443 supplies the exact `B2 C` access question and two-cut +decoder. Ali Romman / PR1969 supplies the QQ16 native words, signed line +conventions, full-cover maps and endpoint frames. The bridge review and its +underlying Rohan Arun, Jeremy Kothe, DreamingOfClouds and supplier lineage +retain credit in [the source notice](../joint-query/NOTICE.md). Gareth Davidson +/ PR2432, commdata2338 / PR2174 and the other coordinate-read predecessors +retain the attribution in PR2443. This author's PR2456 audited that decoder; +this package constructs one of its still-missing native reads. + +Prepared by ywz65 with substantial OpenAI Codex assistance in derivation, +implementation, checking and writing. No independent human or proof-assistant +review is claimed. New work is Apache-2.0; frozen sources remain unchanged. diff --git a/research/qq16-future-x-query/RESULT.json b/research/qq16-future-x-query/RESULT.json new file mode 100644 index 0000000000..212008cc18 --- /dev/null +++ b/research/qq16-future-x-query/RESULT.json @@ -0,0 +1,9681 @@ +{ + "controls": { + "inverse_line_without_translation": "kernel differs at address zero", + "omit_normalization": "unmatched native scalar frames at event 248", + "omit_output_clear": "exact future query or dirty output mismatch", + "omit_payload_translation": "unmatched native scalar frames at event 248", + "omit_restoration": "borrowed source frame not restored", + "query_before_alignment_and_output_preparation": "unmatched native scalar frames at event 96", + "wrong_inverse_translation": "borrowed source frame not restored", + "wrong_query_coefficient": "exact future query or dirty output mismatch" + }, + "formal_independent_inputs": 104, + "future_X_residuals": { + "1": { + "line": 19, + "nonzero_character": 1 + }, + "10": { + "line": 133, + "nonzero_character": 1 + }, + "100": { + "line": 439, + "nonzero_character": 1 + }, + "101": { + "line": 375, + "nonzero_character": 1 + }, + "102": { + "line": 247, + "nonzero_character": 1 + }, + "103": { + "line": 463, + "nonzero_character": 1 + }, + "104": { + "line": 431, + "nonzero_character": 1 + }, + "105": { + "line": 367, + "nonzero_character": 1 + }, + "106": { + "line": 239, + "nonzero_character": 1 + }, + "107": { + "line": 415, + "nonzero_character": 1 + }, + "108": { + "line": 351, + "nonzero_character": 1 + }, + "109": { + "line": 223, + "nonzero_character": 1 + }, + "11": { + "line": 261, + "nonzero_character": 1 + }, + "12": { + "line": 41, + "nonzero_character": 1 + }, + "13": { + "line": 73, + "nonzero_character": 1 + }, + "14": { + "line": 137, + "nonzero_character": 1 + }, + "15": { + "line": 265, + "nonzero_character": 1 + }, + "16": { + "line": 49, + "nonzero_character": 1 + }, + "17": { + "line": 81, + "nonzero_character": 1 + }, + "18": { + "line": 145, + "nonzero_character": 1 + }, + "19": { + "line": 273, + "nonzero_character": 1 + }, + "2": { + "line": 35, + "nonzero_character": 1 + }, + "22": { + "line": 193, + "nonzero_character": 1 + }, + "23": { + "line": 321, + "nonzero_character": 1 + }, + "24": { + "line": 385, + "nonzero_character": 1 + }, + "25": { + "line": 14, + "nonzero_character": 2 + }, + "26": { + "line": 22, + "nonzero_character": 2 + }, + "28": { + "line": 70, + "nonzero_character": 2 + }, + "29": { + "line": 134, + "nonzero_character": 2 + }, + "3": { + "line": 67, + "nonzero_character": 1 + }, + "30": { + "line": 262, + "nonzero_character": 2 + }, + "31": { + "line": 26, + "nonzero_character": 2 + }, + "32": { + "line": 74, + "nonzero_character": 2 + }, + "33": { + "line": 138, + "nonzero_character": 2 + }, + "34": { + "line": 266, + "nonzero_character": 2 + }, + "35": { + "line": 50, + "nonzero_character": 2 + }, + "38": { + "line": 98, + "nonzero_character": 2 + }, + "39": { + "line": 162, + "nonzero_character": 2 + }, + "4": { + "line": 131, + "nonzero_character": 1 + }, + "40": { + "line": 290, + "nonzero_character": 2 + }, + "41": { + "line": 194, + "nonzero_character": 2 + }, + "42": { + "line": 322, + "nonzero_character": 2 + }, + "43": { + "line": 386, + "nonzero_character": 2 + }, + "44": { + "line": 28, + "nonzero_character": 4 + }, + "45": { + "line": 44, + "nonzero_character": 4 + }, + "48": { + "line": 84, + "nonzero_character": 4 + }, + "49": { + "line": 148, + "nonzero_character": 4 + }, + "5": { + "line": 259, + "nonzero_character": 1 + }, + "50": { + "line": 276, + "nonzero_character": 4 + }, + "51": { + "line": 100, + "nonzero_character": 4 + }, + "52": { + "line": 164, + "nonzero_character": 4 + }, + "53": { + "line": 292, + "nonzero_character": 4 + }, + "54": { + "line": 196, + "nonzero_character": 4 + }, + "55": { + "line": 324, + "nonzero_character": 4 + }, + "56": { + "line": 388, + "nonzero_character": 4 + }, + "58": { + "line": 88, + "nonzero_character": 8 + }, + "59": { + "line": 152, + "nonzero_character": 8 + }, + "6": { + "line": 13, + "nonzero_character": 1 + }, + "60": { + "line": 280, + "nonzero_character": 8 + }, + "61": { + "line": 104, + "nonzero_character": 8 + }, + "62": { + "line": 168, + "nonzero_character": 8 + }, + "63": { + "line": 296, + "nonzero_character": 8 + }, + "64": { + "line": 200, + "nonzero_character": 8 + }, + "65": { + "line": 328, + "nonzero_character": 8 + }, + "66": { + "line": 392, + "nonzero_character": 8 + }, + "67": { + "line": 112, + "nonzero_character": 16 + }, + "68": { + "line": 176, + "nonzero_character": 16 + }, + "69": { + "line": 304, + "nonzero_character": 16 + }, + "70": { + "line": 208, + "nonzero_character": 16 + }, + "71": { + "line": 336, + "nonzero_character": 16 + }, + "72": { + "line": 400, + "nonzero_character": 16 + }, + "73": { + "line": 224, + "nonzero_character": 32 + }, + "74": { + "line": 352, + "nonzero_character": 32 + }, + "75": { + "line": 416, + "nonzero_character": 32 + }, + "77": { + "line": 508, + "nonzero_character": 4 + }, + "78": { + "line": 506, + "nonzero_character": 2 + }, + "79": { + "line": 502, + "nonzero_character": 2 + }, + "8": { + "line": 37, + "nonzero_character": 1 + }, + "80": { + "line": 494, + "nonzero_character": 2 + }, + "82": { + "line": 446, + "nonzero_character": 2 + }, + "83": { + "line": 382, + "nonzero_character": 2 + }, + "84": { + "line": 254, + "nonzero_character": 2 + }, + "85": { + "line": 505, + "nonzero_character": 1 + }, + "86": { + "line": 501, + "nonzero_character": 1 + }, + "88": { + "line": 477, + "nonzero_character": 1 + }, + "89": { + "line": 445, + "nonzero_character": 1 + }, + "9": { + "line": 69, + "nonzero_character": 1 + }, + "90": { + "line": 381, + "nonzero_character": 1 + }, + "91": { + "line": 253, + "nonzero_character": 1 + }, + "93": { + "line": 491, + "nonzero_character": 1 + }, + "94": { + "line": 475, + "nonzero_character": 1 + }, + "95": { + "line": 443, + "nonzero_character": 1 + }, + "96": { + "line": 379, + "nonzero_character": 1 + }, + "97": { + "line": 251, + "nonzero_character": 1 + }, + "98": { + "line": 487, + "nonzero_character": 1 + }, + "99": { + "line": 471, + "nonzero_character": 1 + } + }, + "invoice": { + "CLEAR_macros": 8, + "borrowed_source_arrays_restored": 96, + "full_cover_maps": 192, + "literal_events": 776, + "native_rank_mass": 192, + "native_wrapper_maps": 384, + "owned_live_query_outputs": 8, + "rank_one_children": 192, + "scalar_real_primitive_allowance": 3088, + "signed_ADD_macros": 384 + }, + "member_sha256": { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "native_kernel_basis_columns": 98304, + "native_recipes": { + "100:-1": { + "left_offset": 439, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 64, + 129, + 257 + ] + }, + "100:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 64, + 129, + 257 + ] + }, + "101:-1": { + "left_offset": 375, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 128, + 257 + ] + }, + "101:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 128, + 257 + ] + }, + "102:-1": { + "left_offset": 247, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 256 + ] + }, + "102:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 256 + ] + }, + "103:-1": { + "left_offset": 463, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 32, + 65, + 129, + 257 + ] + }, + "103:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 32, + 65, + 129, + 257 + ] + }, + "104:-1": { + "left_offset": 431, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 64, + 129, + 257 + ] + }, + "104:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 64, + 129, + 257 + ] + }, + "105:-1": { + "left_offset": 367, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257 + ] + }, + "105:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257 + ] + }, + "106:-1": { + "left_offset": 239, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 129, + 256 + ] + }, + "106:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 16, + 33, + 65, + 129, + 256 + ] + }, + "107:-1": { + "left_offset": 415, + "left_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 64, + 129, + 257 + ] + }, + "107:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 64, + 129, + 257 + ] + }, + "108:-1": { + "left_offset": 351, + "left_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 128, + 257 + ] + }, + "108:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 128, + 257 + ] + }, + "109:-1": { + "left_offset": 223, + "left_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 256 + ] + }, + "109:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 256 + ] + }, + "10:-1": { + "left_offset": 133, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 129, + 256 + ] + }, + "10:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 129, + 256 + ] + }, + "11:-1": { + "left_offset": 261, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ] + }, + "11:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ] + }, + "12:-1": { + "left_offset": 41, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 33, + 64, + 128, + 256 + ] + }, + "12:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 33, + 64, + 128, + 256 + ] + }, + "13:-1": { + "left_offset": 73, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ] + }, + "13:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ] + }, + "14:-1": { + "left_offset": 137, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 129, + 256 + ] + }, + "14:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 129, + 256 + ] + }, + "15:-1": { + "left_offset": 265, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257 + ] + }, + "15:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257 + ] + }, + "16:-1": { + "left_offset": 49, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 33, + 64, + 128, + 256 + ] + }, + "16:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 33, + 64, + 128, + 256 + ] + }, + "17:-1": { + "left_offset": 81, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 65, + 128, + 256 + ] + }, + "17:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 65, + 128, + 256 + ] + }, + "18:-1": { + "left_offset": 145, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 129, + 256 + ] + }, + "18:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 129, + 256 + ] + }, + "19:-1": { + "left_offset": 273, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 128, + 257 + ] + }, + "19:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 17, + 32, + 64, + 128, + 257 + ] + }, + "1:-1": { + "left_offset": 19, + "left_rows": [ + 1, + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ] + }, + "1:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ] + }, + "22:-1": { + "left_offset": 193, + "left_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 129, + 256 + ] + }, + "22:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 129, + 256 + ] + }, + "23:-1": { + "left_offset": 321, + "left_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 128, + 257 + ] + }, + "23:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 65, + 128, + 257 + ] + }, + "24:-1": { + "left_offset": 385, + "left_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 129, + 257 + ] + }, + "24:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 129, + 257 + ] + }, + "25:-1": { + "left_offset": 14, + "left_rows": [ + 2, + 1, + 5, + 9, + 16, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 16, + 32, + 64, + 128, + 256 + ] + }, + "25:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 9, + 16, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 16, + 32, + 64, + 128, + 256 + ] + }, + "26:-1": { + "left_offset": 22, + "left_rows": [ + 2, + 1, + 5, + 8, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 18, + 32, + 64, + 128, + 256 + ] + }, + "26:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 8, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 18, + 32, + 64, + 128, + 256 + ] + }, + "28:-1": { + "left_offset": 70, + "left_rows": [ + 2, + 1, + 5, + 8, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 16, + 32, + 66, + 128, + 256 + ] + }, + "28:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 8, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 16, + 32, + 66, + 128, + 256 + ] + }, + "29:-1": { + "left_offset": 134, + "left_rows": [ + 2, + 1, + 5, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 16, + 32, + 64, + 130, + 256 + ] + }, + "29:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 16, + 32, + 64, + 130, + 256 + ] + }, + "2:-1": { + "left_offset": 35, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 256 + ] + }, + "2:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 256 + ] + }, + "30:-1": { + "left_offset": 262, + "left_rows": [ + 2, + 1, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 16, + 32, + 64, + 128, + 258 + ] + }, + "30:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 16, + 32, + 64, + 128, + 258 + ] + }, + "31:-1": { + "left_offset": 26, + "left_rows": [ + 2, + 1, + 4, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 18, + 32, + 64, + 128, + 256 + ] + }, + "31:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 18, + 32, + 64, + 128, + 256 + ] + }, + "32:-1": { + "left_offset": 74, + "left_rows": [ + 2, + 1, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 16, + 32, + 66, + 128, + 256 + ] + }, + "32:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 16, + 32, + 66, + 128, + 256 + ] + }, + "33:-1": { + "left_offset": 138, + "left_rows": [ + 2, + 1, + 4, + 9, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 16, + 32, + 64, + 130, + 256 + ] + }, + "33:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 9, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 16, + 32, + 64, + 130, + 256 + ] + }, + "34:-1": { + "left_offset": 266, + "left_rows": [ + 2, + 1, + 4, + 9, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 16, + 32, + 64, + 128, + 258 + ] + }, + "34:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 9, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 16, + 32, + 64, + 128, + 258 + ] + }, + "35:-1": { + "left_offset": 50, + "left_rows": [ + 2, + 1, + 4, + 8, + 17, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 18, + 34, + 64, + 128, + 256 + ] + }, + "35:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 17, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 18, + 34, + 64, + 128, + 256 + ] + }, + "38:-1": { + "left_offset": 98, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 34, + 66, + 128, + 256 + ] + }, + "38:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 34, + 66, + 128, + 256 + ] + }, + "39:-1": { + "left_offset": 162, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 34, + 64, + 130, + 256 + ] + }, + "39:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 34, + 64, + 130, + 256 + ] + }, + "3:-1": { + "left_offset": 67, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 65, + 128, + 256 + ] + }, + "3:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 65, + 128, + 256 + ] + }, + "40:-1": { + "left_offset": 290, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 34, + 64, + 128, + 258 + ] + }, + "40:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 34, + 64, + 128, + 258 + ] + }, + "41:-1": { + "left_offset": 194, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 66, + 130, + 256 + ] + }, + "41:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 66, + 130, + 256 + ] + }, + "42:-1": { + "left_offset": 322, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 66, + 128, + 258 + ] + }, + "42:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 66, + 128, + 258 + ] + }, + "43:-1": { + "left_offset": 386, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 64, + 130, + 258 + ] + }, + "43:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 8, + 16, + 32, + 64, + 130, + 258 + ] + }, + "44:-1": { + "left_offset": 28, + "left_rows": [ + 2, + 4, + 1, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 12, + 20, + 32, + 64, + 128, + 256 + ] + }, + "44:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 12, + 20, + 32, + 64, + 128, + 256 + ] + }, + "45:-1": { + "left_offset": 44, + "left_rows": [ + 2, + 4, + 1, + 9, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 12, + 16, + 36, + 64, + 128, + 256 + ] + }, + "45:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 9, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 12, + 16, + 36, + 64, + 128, + 256 + ] + }, + "48:-1": { + "left_offset": 84, + "left_rows": [ + 2, + 4, + 1, + 8, + 17, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 20, + 32, + 68, + 128, + 256 + ] + }, + "48:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 17, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 20, + 32, + 68, + 128, + 256 + ] + }, + "49:-1": { + "left_offset": 148, + "left_rows": [ + 2, + 4, + 1, + 8, + 17, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 20, + 32, + 64, + 132, + 256 + ] + }, + "49:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 17, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 20, + 32, + 64, + 132, + 256 + ] + }, + "4:-1": { + "left_offset": 131, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256 + ] + }, + "4:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256 + ] + }, + "50:-1": { + "left_offset": 276, + "left_rows": [ + 2, + 4, + 1, + 8, + 17, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 20, + 32, + 64, + 128, + 260 + ] + }, + "50:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 17, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 20, + 32, + 64, + 128, + 260 + ] + }, + "51:-1": { + "left_offset": 100, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 36, + 68, + 128, + 256 + ] + }, + "51:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 36, + 68, + 128, + 256 + ] + }, + "52:-1": { + "left_offset": 164, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + "52:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 36, + 64, + 132, + 256 + ] + }, + "53:-1": { + "left_offset": 292, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ] + }, + "53:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ] + }, + "54:-1": { + "left_offset": 196, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 68, + 132, + 256 + ] + }, + "54:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 68, + 132, + 256 + ] + }, + "55:-1": { + "left_offset": 324, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 68, + 128, + 260 + ] + }, + "55:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 68, + 128, + 260 + ] + }, + "56:-1": { + "left_offset": 388, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ] + }, + "56:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ] + }, + "58:-1": { + "left_offset": 88, + "left_rows": [ + 2, + 4, + 8, + 1, + 17, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 24, + 32, + 72, + 128, + 256 + ] + }, + "58:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 17, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 24, + 32, + 72, + 128, + 256 + ] + }, + "59:-1": { + "left_offset": 152, + "left_rows": [ + 2, + 4, + 8, + 1, + 17, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 24, + 32, + 64, + 136, + 256 + ] + }, + "59:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 17, + 32, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 24, + 32, + 64, + 136, + 256 + ] + }, + "5:-1": { + "left_offset": 259, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 128, + 257 + ] + }, + "5:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 8, + 16, + 32, + 64, + 128, + 257 + ] + }, + "60:-1": { + "left_offset": 280, + "left_rows": [ + 2, + 4, + 8, + 1, + 17, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 24, + 32, + 64, + 128, + 264 + ] + }, + "60:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 17, + 32, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 24, + 32, + 64, + 128, + 264 + ] + }, + "61:-1": { + "left_offset": 104, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 40, + 72, + 128, + 256 + ] + }, + "61:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 40, + 72, + 128, + 256 + ] + }, + "62:-1": { + "left_offset": 168, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 40, + 64, + 136, + 256 + ] + }, + "62:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 40, + 64, + 136, + 256 + ] + }, + "63:-1": { + "left_offset": 296, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 40, + 64, + 128, + 264 + ] + }, + "63:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 40, + 64, + 128, + 264 + ] + }, + "64:-1": { + "left_offset": 200, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 32, + 72, + 136, + 256 + ] + }, + "64:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 32, + 72, + 136, + 256 + ] + }, + "65:-1": { + "left_offset": 328, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 32, + 72, + 128, + 264 + ] + }, + "65:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 32, + 72, + 128, + 264 + ] + }, + "66:-1": { + "left_offset": 392, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 32, + 64, + 136, + 264 + ] + }, + "66:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 1, + 16, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 8, + 1, + 2, + 4, + 16, + 32, + 64, + 136, + 264 + ] + }, + "67:-1": { + "left_offset": 112, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 48, + 80, + 128, + 256 + ] + }, + "67:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 33, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 48, + 80, + 128, + 256 + ] + }, + "68:-1": { + "left_offset": 176, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 48, + 64, + 144, + 256 + ] + }, + "68:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 33, + 64, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 48, + 64, + 144, + 256 + ] + }, + "69:-1": { + "left_offset": 304, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 48, + 64, + 128, + 272 + ] + }, + "69:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 33, + 64, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 48, + 64, + 128, + 272 + ] + }, + "6:-1": { + "left_offset": 13, + "left_rows": [ + 1, + 2, + 5, + 9, + 16, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 16, + 32, + 64, + 128, + 256 + ] + }, + "6:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 9, + 16, + 32, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 16, + 32, + 64, + 128, + 256 + ] + }, + "70:-1": { + "left_offset": 208, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 32, + 80, + 144, + 256 + ] + }, + "70:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 32, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 32, + 80, + 144, + 256 + ] + }, + "71:-1": { + "left_offset": 336, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 32, + 80, + 128, + 272 + ] + }, + "71:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 32, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 32, + 80, + 128, + 272 + ] + }, + "72:-1": { + "left_offset": 400, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 32, + 64, + 144, + 272 + ] + }, + "72:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 1, + 32, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 16, + 1, + 2, + 4, + 8, + 32, + 64, + 144, + 272 + ] + }, + "73:-1": { + "left_offset": 224, + "left_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 96, + 160, + 256 + ] + }, + "73:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 96, + 160, + 256 + ] + }, + "74:-1": { + "left_offset": 352, + "left_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 96, + 128, + 288 + ] + }, + "74:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 96, + 128, + 288 + ] + }, + "75:-1": { + "left_offset": 416, + "left_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 64, + 160, + 288 + ] + }, + "75:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 64, + 160, + 288 + ] + }, + "77:-1": { + "left_offset": 508, + "left_rows": [ + 2, + 4, + 1, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 12, + 20, + 36, + 68, + 132, + 260 + ] + }, + "77:1": { + "left_offset": 0, + "left_rows": [ + 2, + 4, + 1, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 4, + 1, + 2, + 12, + 20, + 36, + 68, + 132, + 260 + ] + }, + "78:-1": { + "left_offset": 506, + "left_rows": [ + 2, + 1, + 4, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 18, + 34, + 66, + 130, + 258 + ] + }, + "78:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 4, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 4, + 10, + 18, + 34, + 66, + 130, + 258 + ] + }, + "79:-1": { + "left_offset": 502, + "left_rows": [ + 2, + 1, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 18, + 34, + 66, + 130, + 258 + ] + }, + "79:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 8, + 18, + 34, + 66, + 130, + 258 + ] + }, + "80:-1": { + "left_offset": 494, + "left_rows": [ + 2, + 1, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 16, + 34, + 66, + 130, + 258 + ] + }, + "80:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 9, + 16, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 16, + 34, + 66, + 130, + 258 + ] + }, + "82:-1": { + "left_offset": 446, + "left_rows": [ + 2, + 1, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 18, + 34, + 64, + 130, + 258 + ] + }, + "82:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 18, + 34, + 64, + 130, + 258 + ] + }, + "83:-1": { + "left_offset": 382, + "left_rows": [ + 2, + 1, + 5, + 9, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 18, + 34, + 66, + 128, + 258 + ] + }, + "83:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 9, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 18, + 34, + 66, + 128, + 258 + ] + }, + "84:-1": { + "left_offset": 254, + "left_rows": [ + 2, + 1, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 18, + 34, + 66, + 130, + 256 + ] + }, + "84:1": { + "left_offset": 0, + "left_rows": [ + 2, + 1, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 2, + 1, + 6, + 10, + 18, + 34, + 66, + 130, + 256 + ] + }, + "85:-1": { + "left_offset": 505, + "left_rows": [ + 1, + 2, + 4, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 17, + 33, + 65, + 129, + 257 + ] + }, + "85:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 4, + 9, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 4, + 9, + 17, + 33, + 65, + 129, + 257 + ] + }, + "86:-1": { + "left_offset": 501, + "left_rows": [ + 1, + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ] + }, + "86:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ] + }, + "88:-1": { + "left_offset": 477, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 32, + 65, + 129, + 257 + ] + }, + "88:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 32, + 65, + 129, + 257 + ] + }, + "89:-1": { + "left_offset": 445, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ] + }, + "89:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257 + ] + }, + "8:-1": { + "left_offset": 37, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 33, + 64, + 128, + 256 + ] + }, + "8:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 33, + 64, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 33, + 64, + 128, + 256 + ] + }, + "90:-1": { + "left_offset": 381, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 128, + 257 + ] + }, + "90:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 128, + 257 + ] + }, + "91:-1": { + "left_offset": 253, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ] + }, + "91:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 9, + 17, + 33, + 65, + 129, + 256 + ] + }, + "93:-1": { + "left_offset": 491, + "left_rows": [ + 1, + 3, + 4, + 9, + 16, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + "93:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 9, + 16, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 16, + 33, + 65, + 129, + 257 + ] + }, + "94:-1": { + "left_offset": 475, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 32, + 65, + 129, + 257 + ] + }, + "94:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 32, + 65, + 129, + 257 + ] + }, + "95:-1": { + "left_offset": 443, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 64, + 129, + 257 + ] + }, + "95:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 64, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 64, + 129, + 257 + ] + }, + "96:-1": { + "left_offset": 379, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 128, + 257 + ] + }, + "96:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 128, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 128, + 257 + ] + }, + "97:-1": { + "left_offset": 251, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 129, + 256 + ] + }, + "97:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 129, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 4, + 9, + 17, + 33, + 65, + 129, + 256 + ] + }, + "98:-1": { + "left_offset": 487, + "left_rows": [ + 1, + 3, + 5, + 8, + 16, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 16, + 33, + 65, + 129, + 257 + ] + }, + "98:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 8, + 16, + 33, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 16, + 33, + 65, + 129, + 257 + ] + }, + "99:-1": { + "left_offset": 471, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 32, + 65, + 129, + 257 + ] + }, + "99:1": { + "left_offset": 0, + "left_rows": [ + 1, + 3, + 5, + 8, + 17, + 32, + 65, + 129, + 257 + ], + "rank": 1, + "right_rows": [ + 1, + 3, + 5, + 8, + 17, + 32, + 65, + 129, + 257 + ] + }, + "9:-1": { + "left_offset": 69, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256 + ] + }, + "9:1": { + "left_offset": 0, + "left_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256 + ], + "rank": 1, + "right_rows": [ + 1, + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256 + ] + } + }, + "output_frame": "F_(E1+E2)", + "program": [ + { + "op": "line", + "port": 1, + "sign": -1 + }, + { + "op": "line", + "port": 2, + "sign": -1 + }, + { + "op": "line", + "port": 3, + "sign": -1 + }, + { + "op": "line", + "port": 4, + "sign": -1 + }, + { + "op": "line", + "port": 5, + "sign": -1 + }, + { + "op": "line", + "port": 6, + "sign": -1 + }, + { + "op": "line", + "port": 8, + "sign": -1 + }, + { + "op": "line", + "port": 9, + "sign": -1 + }, + { + "op": "line", + "port": 10, + "sign": -1 + }, + { + "op": "line", + "port": 11, + "sign": -1 + }, + { + "op": "line", + "port": 12, + "sign": -1 + }, + { + "op": "line", + "port": 13, + "sign": -1 + }, + { + "op": "line", + "port": 14, + "sign": -1 + }, + { + "op": "line", + "port": 15, + "sign": -1 + }, + { + "op": "line", + "port": 16, + "sign": -1 + }, + { + "op": "line", + "port": 17, + "sign": -1 + }, + { + "op": "line", + "port": 18, + "sign": -1 + }, + { + "op": "line", + "port": 19, + "sign": -1 + }, + { + "op": "line", + "port": 22, + "sign": -1 + }, + { + "op": "line", + "port": 23, + "sign": -1 + }, + { + "op": "line", + "port": 24, + "sign": -1 + }, + { + "op": "line", + "port": 25, + "sign": -1 + }, + { + "op": "line", + "port": 26, + "sign": -1 + }, + { + "op": "line", + "port": 28, + "sign": -1 + }, + { + "op": "line", + "port": 29, + "sign": -1 + }, + { + "op": "line", + "port": 30, + "sign": -1 + }, + { + "op": "line", + "port": 31, + "sign": -1 + }, + { + "op": "line", + "port": 32, + "sign": -1 + }, + { + "op": "line", + "port": 33, + "sign": -1 + }, + { + "op": "line", + "port": 34, + "sign": -1 + }, + { + "op": "line", + "port": 35, + "sign": -1 + }, + { + "op": "line", + "port": 38, + "sign": -1 + }, + { + "op": "line", + "port": 39, + "sign": -1 + }, + { + "op": "line", + "port": 40, + "sign": -1 + }, + { + "op": "line", + "port": 41, + "sign": -1 + }, + { + "op": "line", + "port": 42, + "sign": -1 + }, + { + "op": "line", + "port": 43, + "sign": -1 + }, + { + "op": "line", + "port": 44, + "sign": -1 + }, + { + "op": "line", + "port": 45, + "sign": -1 + }, + { + "op": "line", + "port": 48, + "sign": -1 + }, + { + "op": "line", + "port": 49, + "sign": -1 + }, + { + "op": "line", + "port": 50, + "sign": -1 + }, + { + "op": "line", + "port": 51, + "sign": -1 + }, + { + "op": "line", + "port": 52, + "sign": -1 + }, + { + "op": "line", + "port": 53, + "sign": -1 + }, + { + "op": "line", + "port": 54, + "sign": -1 + }, + { + "op": "line", + "port": 55, + "sign": -1 + }, + { + "op": "line", + "port": 56, + "sign": -1 + }, + { + "op": "line", + "port": 58, + "sign": -1 + }, + { + "op": "line", + "port": 59, + "sign": -1 + }, + { + "op": "line", + "port": 60, + "sign": -1 + }, + { + "op": "line", + "port": 61, + "sign": -1 + }, + { + "op": "line", + "port": 62, + "sign": -1 + }, + { + "op": "line", + "port": 63, + "sign": -1 + }, + { + "op": "line", + "port": 64, + "sign": -1 + }, + { + "op": "line", + "port": 65, + "sign": -1 + }, + { + "op": "line", + "port": 66, + "sign": -1 + }, + { + "op": "line", + "port": 67, + "sign": -1 + }, + { + "op": "line", + "port": 68, + "sign": -1 + }, + { + "op": "line", + "port": 69, + "sign": -1 + }, + { + "op": "line", + "port": 70, + "sign": -1 + }, + { + "op": "line", + "port": 71, + "sign": -1 + }, + { + "op": "line", + "port": 72, + "sign": -1 + }, + { + "op": "line", + "port": 73, + "sign": -1 + }, + { + "op": "line", + "port": 74, + "sign": -1 + }, + { + "op": "line", + "port": 75, + "sign": -1 + }, + { + "op": "line", + "port": 77, + "sign": -1 + }, + { + "op": "line", + "port": 78, + "sign": -1 + }, + { + "op": "line", + "port": 79, + "sign": -1 + }, + { + "op": "line", + "port": 80, + "sign": -1 + }, + { + "op": "line", + "port": 82, + "sign": -1 + }, + { + "op": "line", + "port": 83, + "sign": -1 + }, + { + "op": "line", + "port": 84, + "sign": -1 + }, + { + "op": "line", + "port": 85, + "sign": -1 + }, + { + "op": "line", + "port": 86, + "sign": -1 + }, + { + "op": "line", + "port": 88, + "sign": -1 + }, + { + "op": "line", + "port": 89, + "sign": -1 + }, + { + "op": "line", + "port": 90, + "sign": -1 + }, + { + "op": "line", + "port": 91, + "sign": -1 + }, + { + "op": "line", + "port": 93, + "sign": -1 + }, + { + "op": "line", + "port": 94, + "sign": -1 + }, + { + "op": "line", + "port": 95, + "sign": -1 + }, + { + "op": "line", + "port": 96, + "sign": -1 + }, + { + "op": "line", + "port": 97, + "sign": -1 + }, + { + "op": "line", + "port": 98, + "sign": -1 + }, + { + "op": "line", + "port": 99, + "sign": -1 + }, + { + "op": "line", + "port": 100, + "sign": -1 + }, + { + "op": "line", + "port": 101, + "sign": -1 + }, + { + "op": "line", + "port": 102, + "sign": -1 + }, + { + "op": "line", + "port": 103, + "sign": -1 + }, + { + "op": "line", + "port": 104, + "sign": -1 + }, + { + "op": "line", + "port": 105, + "sign": -1 + }, + { + "op": "line", + "port": 106, + "sign": -1 + }, + { + "op": "line", + "port": 107, + "sign": -1 + }, + { + "op": "line", + "port": 108, + "sign": -1 + }, + { + "op": "line", + "port": 109, + "sign": -1 + }, + { + "inverse": false, + "op": "map", + "port": 1 + }, + { + "inverse": false, + "op": "map", + "port": 2 + }, + { + "inverse": false, + "op": "map", + "port": 3 + }, + { + "inverse": false, + "op": "map", + "port": 4 + }, + { + "inverse": false, + "op": "map", + "port": 5 + }, + { + "inverse": false, + "op": "map", + "port": 6 + }, + { + "inverse": false, + "op": "map", + "port": 8 + }, + { + "inverse": false, + "op": "map", + "port": 9 + }, + { + "inverse": false, + "op": "map", + "port": 10 + }, + { + "inverse": false, + "op": "map", + "port": 11 + }, + { + "inverse": false, + "op": "map", + "port": 12 + }, + { + "inverse": false, + "op": "map", + "port": 13 + }, + { + "inverse": false, + "op": "map", + "port": 14 + }, + { + "inverse": false, + "op": "map", + "port": 15 + }, + { + "inverse": false, + "op": "map", + "port": 16 + }, + { + "inverse": false, + "op": "map", + "port": 17 + }, + { + "inverse": false, + "op": "map", + "port": 18 + }, + { + "inverse": false, + "op": "map", + "port": 19 + }, + { + "inverse": false, + "op": "map", + "port": 22 + }, + { + "inverse": false, + "op": "map", + "port": 23 + }, + { + "inverse": false, + "op": "map", + "port": 24 + }, + { + "inverse": false, + "op": "map", + "port": 25 + }, + { + "inverse": false, + "op": "map", + "port": 26 + }, + { + "inverse": false, + "op": "map", + "port": 28 + }, + { + "inverse": false, + "op": "map", + "port": 29 + }, + { + "inverse": false, + "op": "map", + "port": 30 + }, + { + "inverse": false, + "op": "map", + "port": 31 + }, + { + "inverse": false, + "op": "map", + "port": 32 + }, + { + "inverse": false, + "op": "map", + "port": 33 + }, + { + "inverse": false, + "op": "map", + "port": 34 + }, + { + "inverse": false, + "op": "map", + "port": 35 + }, + { + "inverse": false, + "op": "map", + "port": 38 + }, + { + "inverse": false, + "op": "map", + "port": 39 + }, + { + "inverse": false, + "op": "map", + "port": 40 + }, + { + "inverse": false, + "op": "map", + "port": 41 + }, + { + "inverse": false, + "op": "map", + "port": 42 + }, + { + "inverse": false, + "op": "map", + "port": 43 + }, + { + "inverse": false, + "op": "map", + "port": 44 + }, + { + "inverse": false, + "op": "map", + "port": 45 + }, + { + "inverse": false, + "op": "map", + "port": 48 + }, + { + "inverse": false, + "op": "map", + "port": 49 + }, + { + "inverse": false, + "op": "map", + "port": 50 + }, + { + "inverse": false, + "op": "map", + "port": 51 + }, + { + "inverse": false, + "op": "map", + "port": 52 + }, + { + "inverse": false, + "op": "map", + "port": 53 + }, + { + "inverse": false, + "op": "map", + "port": 54 + }, + { + "inverse": false, + "op": "map", + "port": 55 + }, + { + "inverse": false, + "op": "map", + "port": 56 + }, + { + "inverse": false, + "op": "map", + "port": 58 + }, + { + "inverse": false, + "op": "map", + "port": 59 + }, + { + "inverse": false, + "op": "map", + "port": 60 + }, + { + "inverse": false, + "op": "map", + "port": 61 + }, + { + "inverse": false, + "op": "map", + "port": 62 + }, + { + "inverse": false, + "op": "map", + "port": 63 + }, + { + "inverse": false, + "op": "map", + "port": 64 + }, + { + "inverse": false, + "op": "map", + "port": 65 + }, + { + "inverse": false, + "op": "map", + "port": 66 + }, + { + "inverse": false, + "op": "map", + "port": 67 + }, + { + "inverse": false, + "op": "map", + "port": 68 + }, + { + "inverse": false, + "op": "map", + "port": 69 + }, + { + "inverse": false, + "op": "map", + "port": 70 + }, + { + "inverse": false, + "op": "map", + "port": 71 + }, + { + "inverse": false, + "op": "map", + "port": 72 + }, + { + "inverse": false, + "op": "map", + "port": 73 + }, + { + "inverse": false, + "op": "map", + "port": 74 + }, + { + "inverse": false, + "op": "map", + "port": 75 + }, + { + "inverse": false, + "op": "map", + "port": 77 + }, + { + "inverse": false, + "op": "map", + "port": 78 + }, + { + "inverse": false, + "op": "map", + "port": 79 + }, + { + "inverse": false, + "op": "map", + "port": 80 + }, + { + "inverse": false, + "op": "map", + "port": 82 + }, + { + "inverse": false, + "op": "map", + "port": 83 + }, + { + "inverse": false, + "op": "map", + "port": 84 + }, + { + "inverse": false, + "op": "map", + "port": 85 + }, + { + "inverse": false, + "op": "map", + "port": 86 + }, + { + "inverse": false, + "op": "map", + "port": 88 + }, + { + "inverse": false, + "op": "map", + "port": 89 + }, + { + "inverse": false, + "op": "map", + "port": 90 + }, + { + "inverse": false, + "op": "map", + "port": 91 + }, + { + "inverse": false, + "op": "map", + "port": 93 + }, + { + "inverse": false, + "op": "map", + "port": 94 + }, + { + "inverse": false, + "op": "map", + "port": 95 + }, + { + "inverse": false, + "op": "map", + "port": 96 + }, + { + "inverse": false, + "op": "map", + "port": 97 + }, + { + "inverse": false, + "op": "map", + "port": 98 + }, + { + "inverse": false, + "op": "map", + "port": 99 + }, + { + "inverse": false, + "op": "map", + "port": 100 + }, + { + "inverse": false, + "op": "map", + "port": 101 + }, + { + "inverse": false, + "op": "map", + "port": 102 + }, + { + "inverse": false, + "op": "map", + "port": 103 + }, + { + "inverse": false, + "op": "map", + "port": 104 + }, + { + "inverse": false, + "op": "map", + "port": 105 + }, + { + "inverse": false, + "op": "map", + "port": 106 + }, + { + "inverse": false, + "op": "map", + "port": 107 + }, + { + "inverse": false, + "op": "map", + "port": 108 + }, + { + "inverse": false, + "op": "map", + "port": 109 + }, + { + "op": "clear_output", + "query": 0 + }, + { + "op": "clear_output", + "query": 1 + }, + { + "op": "clear_output", + "query": 2 + }, + { + "op": "clear_output", + "query": 3 + }, + { + "op": "clear_output", + "query": 4 + }, + { + "op": "clear_output", + "query": 5 + }, + { + "op": "clear_output", + "query": 6 + }, + { + "op": "clear_output", + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 2, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 9, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 10, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 11, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 12, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 17, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 18, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 19, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 22, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 23, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 24, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 25, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 31, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 32, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 33, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 34, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 35, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 38, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 39, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 40, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 45, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 48, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 49, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 50, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 54, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 55, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 56, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 61, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 62, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 63, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 70, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 71, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 72, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 77, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 79, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 85, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 89, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 90, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 91, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 94, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 98, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 100, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 101, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 102, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 103, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 107, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 108, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 109, + "query": 0 + }, + { + "coefficient": 1, + "op": "add", + "port": 1, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 2, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 3, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 4, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 5, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 6, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 8, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 9, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 10, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 11, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 25, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 26, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 28, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 29, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 30, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 58, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 59, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 60, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 61, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 62, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 63, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 64, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 65, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 66, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 67, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 68, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 69, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 70, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 71, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 72, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 73, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 74, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 75, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 79, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 80, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 82, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 83, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 84, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 86, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 88, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 89, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 90, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 91, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 93, + "query": 1 + }, + { + "coefficient": -1, + "op": "add", + "port": 94, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 95, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 96, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 97, + "query": 1 + }, + { + "coefficient": 1, + "op": "add", + "port": 1, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 6, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 12, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 13, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 14, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 15, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 16, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 17, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 18, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 19, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 28, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 29, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 30, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 31, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 38, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 39, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 40, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 41, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 42, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 43, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 44, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 51, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 52, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 53, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 54, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 55, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 56, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 58, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 59, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 60, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 73, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 74, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 75, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 77, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 78, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 82, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 83, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 84, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 86, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 93, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 99, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 100, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 101, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 102, + "query": 2 + }, + { + "coefficient": -1, + "op": "add", + "port": 103, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 104, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 105, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 106, + "query": 2 + }, + { + "coefficient": 1, + "op": "add", + "port": 3, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 4, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 5, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 8, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 13, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 14, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 15, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 16, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 22, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 23, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 24, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 26, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 32, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 33, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 34, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 35, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 41, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 42, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 43, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 44, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 45, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 48, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 49, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 50, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 51, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 52, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 53, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 64, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 65, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 66, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 67, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 68, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 69, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 78, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 80, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 85, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 88, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 95, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 96, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 97, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 98, + "query": 3 + }, + { + "coefficient": 1, + "op": "add", + "port": 99, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 104, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 105, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 106, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 107, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 108, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 109, + "query": 3 + }, + { + "coefficient": -1, + "op": "add", + "port": 1, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 3, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 6, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 8, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 10, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 11, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 12, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 14, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 15, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 17, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 24, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 26, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 28, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 31, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 32, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 35, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 38, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 41, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 42, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 45, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 48, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 52, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 53, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 56, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 58, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 62, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 63, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 66, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 67, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 70, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 71, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 75, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 77, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 80, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 82, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 85, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 86, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 88, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 90, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 91, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 93, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 95, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 98, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 100, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 103, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 105, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 106, + "query": 4 + }, + { + "coefficient": 1, + "op": "add", + "port": 107, + "query": 4 + }, + { + "coefficient": -1, + "op": "add", + "port": 4, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 5, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 10, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 11, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 14, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 15, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 18, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 19, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 22, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 23, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 29, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 30, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 33, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 34, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 39, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 40, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 41, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 42, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 49, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 50, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 52, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 53, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 54, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 55, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 59, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 60, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 62, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 63, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 64, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 65, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 68, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 69, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 70, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 71, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 73, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 74, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 83, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 84, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 90, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 91, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 96, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 97, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 101, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 102, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 105, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 106, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 108, + "query": 5 + }, + { + "coefficient": -1, + "op": "add", + "port": 109, + "query": 5 + }, + { + "coefficient": 1, + "op": "add", + "port": 2, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 3, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 8, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 9, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 12, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 13, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 16, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 17, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 22, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 23, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 25, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 26, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 29, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 30, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 31, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 33, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 34, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 38, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 43, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 44, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 49, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 50, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 51, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 56, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 59, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 60, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 61, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 66, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 67, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 72, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 73, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 74, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 77, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 78, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 79, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 80, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 83, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 84, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 88, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 89, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 94, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 95, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 99, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 100, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 103, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 104, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 108, + "query": 6 + }, + { + "coefficient": 1, + "op": "add", + "port": 109, + "query": 6 + }, + { + "coefficient": -1, + "op": "add", + "port": 1, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 2, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 4, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 5, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 6, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 9, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 13, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 16, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 18, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 19, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 24, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 25, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 28, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 32, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 35, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 39, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 40, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 43, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 44, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 45, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 48, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 51, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 54, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 55, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 58, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 61, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 64, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 65, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 68, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 69, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 72, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 75, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 78, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 79, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 82, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 85, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 86, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 89, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 93, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 94, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 96, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 97, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 98, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 99, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 101, + "query": 7 + }, + { + "coefficient": 1, + "op": "add", + "port": 102, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 104, + "query": 7 + }, + { + "coefficient": -1, + "op": "add", + "port": 107, + "query": 7 + }, + { + "inverse": true, + "op": "map", + "port": 1 + }, + { + "inverse": true, + "op": "map", + "port": 2 + }, + { + "inverse": true, + "op": "map", + "port": 3 + }, + { + "inverse": true, + "op": "map", + "port": 4 + }, + { + "inverse": true, + "op": "map", + "port": 5 + }, + { + "inverse": true, + "op": "map", + "port": 6 + }, + { + "inverse": true, + "op": "map", + "port": 8 + }, + { + "inverse": true, + "op": "map", + "port": 9 + }, + { + "inverse": true, + "op": "map", + "port": 10 + }, + { + "inverse": true, + "op": "map", + "port": 11 + }, + { + "inverse": true, + "op": "map", + "port": 12 + }, + { + "inverse": true, + "op": "map", + "port": 13 + }, + { + "inverse": true, + "op": "map", + "port": 14 + }, + { + "inverse": true, + "op": "map", + "port": 15 + }, + { + "inverse": true, + "op": "map", + "port": 16 + }, + { + "inverse": true, + "op": "map", + "port": 17 + }, + { + "inverse": true, + "op": "map", + "port": 18 + }, + { + "inverse": true, + "op": "map", + "port": 19 + }, + { + "inverse": true, + "op": "map", + "port": 22 + }, + { + "inverse": true, + "op": "map", + "port": 23 + }, + { + "inverse": true, + "op": "map", + "port": 24 + }, + { + "inverse": true, + "op": "map", + "port": 25 + }, + { + "inverse": true, + "op": "map", + "port": 26 + }, + { + "inverse": true, + "op": "map", + "port": 28 + }, + { + "inverse": true, + "op": "map", + "port": 29 + }, + { + "inverse": true, + "op": "map", + "port": 30 + }, + { + "inverse": true, + "op": "map", + "port": 31 + }, + { + "inverse": true, + "op": "map", + "port": 32 + }, + { + "inverse": true, + "op": "map", + "port": 33 + }, + { + "inverse": true, + "op": "map", + "port": 34 + }, + { + "inverse": true, + "op": "map", + "port": 35 + }, + { + "inverse": true, + "op": "map", + "port": 38 + }, + { + "inverse": true, + "op": "map", + "port": 39 + }, + { + "inverse": true, + "op": "map", + "port": 40 + }, + { + "inverse": true, + "op": "map", + "port": 41 + }, + { + "inverse": true, + "op": "map", + "port": 42 + }, + { + "inverse": true, + "op": "map", + "port": 43 + }, + { + "inverse": true, + "op": "map", + "port": 44 + }, + { + "inverse": true, + "op": "map", + "port": 45 + }, + { + "inverse": true, + "op": "map", + "port": 48 + }, + { + "inverse": true, + "op": "map", + "port": 49 + }, + { + "inverse": true, + "op": "map", + "port": 50 + }, + { + "inverse": true, + "op": "map", + "port": 51 + }, + { + "inverse": true, + "op": "map", + "port": 52 + }, + { + "inverse": true, + "op": "map", + "port": 53 + }, + { + "inverse": true, + "op": "map", + "port": 54 + }, + { + "inverse": true, + "op": "map", + "port": 55 + }, + { + "inverse": true, + "op": "map", + "port": 56 + }, + { + "inverse": true, + "op": "map", + "port": 58 + }, + { + "inverse": true, + "op": "map", + "port": 59 + }, + { + "inverse": true, + "op": "map", + "port": 60 + }, + { + "inverse": true, + "op": "map", + "port": 61 + }, + { + "inverse": true, + "op": "map", + "port": 62 + }, + { + "inverse": true, + "op": "map", + "port": 63 + }, + { + "inverse": true, + "op": "map", + "port": 64 + }, + { + "inverse": true, + "op": "map", + "port": 65 + }, + { + "inverse": true, + "op": "map", + "port": 66 + }, + { + "inverse": true, + "op": "map", + "port": 67 + }, + { + "inverse": true, + "op": "map", + "port": 68 + }, + { + "inverse": true, + "op": "map", + "port": 69 + }, + { + "inverse": true, + "op": "map", + "port": 70 + }, + { + "inverse": true, + "op": "map", + "port": 71 + }, + { + "inverse": true, + "op": "map", + "port": 72 + }, + { + "inverse": true, + "op": "map", + "port": 73 + }, + { + "inverse": true, + "op": "map", + "port": 74 + }, + { + "inverse": true, + "op": "map", + "port": 75 + }, + { + "inverse": true, + "op": "map", + "port": 77 + }, + { + "inverse": true, + "op": "map", + "port": 78 + }, + { + "inverse": true, + "op": "map", + "port": 79 + }, + { + "inverse": true, + "op": "map", + "port": 80 + }, + { + "inverse": true, + "op": "map", + "port": 82 + }, + { + "inverse": true, + "op": "map", + "port": 83 + }, + { + "inverse": true, + "op": "map", + "port": 84 + }, + { + "inverse": true, + "op": "map", + "port": 85 + }, + { + "inverse": true, + "op": "map", + "port": 86 + }, + { + "inverse": true, + "op": "map", + "port": 88 + }, + { + "inverse": true, + "op": "map", + "port": 89 + }, + { + "inverse": true, + "op": "map", + "port": 90 + }, + { + "inverse": true, + "op": "map", + "port": 91 + }, + { + "inverse": true, + "op": "map", + "port": 93 + }, + { + "inverse": true, + "op": "map", + "port": 94 + }, + { + "inverse": true, + "op": "map", + "port": 95 + }, + { + "inverse": true, + "op": "map", + "port": 96 + }, + { + "inverse": true, + "op": "map", + "port": 97 + }, + { + "inverse": true, + "op": "map", + "port": 98 + }, + { + "inverse": true, + "op": "map", + "port": 99 + }, + { + "inverse": true, + "op": "map", + "port": 100 + }, + { + "inverse": true, + "op": "map", + "port": 101 + }, + { + "inverse": true, + "op": "map", + "port": 102 + }, + { + "inverse": true, + "op": "map", + "port": 103 + }, + { + "inverse": true, + "op": "map", + "port": 104 + }, + { + "inverse": true, + "op": "map", + "port": 105 + }, + { + "inverse": true, + "op": "map", + "port": 106 + }, + { + "inverse": true, + "op": "map", + "port": 107 + }, + { + "inverse": true, + "op": "map", + "port": 108 + }, + { + "inverse": true, + "op": "map", + "port": 109 + }, + { + "op": "line", + "port": 1, + "sign": 1 + }, + { + "op": "line", + "port": 2, + "sign": 1 + }, + { + "op": "line", + "port": 3, + "sign": 1 + }, + { + "op": "line", + "port": 4, + "sign": 1 + }, + { + "op": "line", + "port": 5, + "sign": 1 + }, + { + "op": "line", + "port": 6, + "sign": 1 + }, + { + "op": "line", + "port": 8, + "sign": 1 + }, + { + "op": "line", + "port": 9, + "sign": 1 + }, + { + "op": "line", + "port": 10, + "sign": 1 + }, + { + "op": "line", + "port": 11, + "sign": 1 + }, + { + "op": "line", + "port": 12, + "sign": 1 + }, + { + "op": "line", + "port": 13, + "sign": 1 + }, + { + "op": "line", + "port": 14, + "sign": 1 + }, + { + "op": "line", + "port": 15, + "sign": 1 + }, + { + "op": "line", + "port": 16, + "sign": 1 + }, + { + "op": "line", + "port": 17, + "sign": 1 + }, + { + "op": "line", + "port": 18, + "sign": 1 + }, + { + "op": "line", + "port": 19, + "sign": 1 + }, + { + "op": "line", + "port": 22, + "sign": 1 + }, + { + "op": "line", + "port": 23, + "sign": 1 + }, + { + "op": "line", + "port": 24, + "sign": 1 + }, + { + "op": "line", + "port": 25, + "sign": 1 + }, + { + "op": "line", + "port": 26, + "sign": 1 + }, + { + "op": "line", + "port": 28, + "sign": 1 + }, + { + "op": "line", + "port": 29, + "sign": 1 + }, + { + "op": "line", + "port": 30, + "sign": 1 + }, + { + "op": "line", + "port": 31, + "sign": 1 + }, + { + "op": "line", + "port": 32, + "sign": 1 + }, + { + "op": "line", + "port": 33, + "sign": 1 + }, + { + "op": "line", + "port": 34, + "sign": 1 + }, + { + "op": "line", + "port": 35, + "sign": 1 + }, + { + "op": "line", + "port": 38, + "sign": 1 + }, + { + "op": "line", + "port": 39, + "sign": 1 + }, + { + "op": "line", + "port": 40, + "sign": 1 + }, + { + "op": "line", + "port": 41, + "sign": 1 + }, + { + "op": "line", + "port": 42, + "sign": 1 + }, + { + "op": "line", + "port": 43, + "sign": 1 + }, + { + "op": "line", + "port": 44, + "sign": 1 + }, + { + "op": "line", + "port": 45, + "sign": 1 + }, + { + "op": "line", + "port": 48, + "sign": 1 + }, + { + "op": "line", + "port": 49, + "sign": 1 + }, + { + "op": "line", + "port": 50, + "sign": 1 + }, + { + "op": "line", + "port": 51, + "sign": 1 + }, + { + "op": "line", + "port": 52, + "sign": 1 + }, + { + "op": "line", + "port": 53, + "sign": 1 + }, + { + "op": "line", + "port": 54, + "sign": 1 + }, + { + "op": "line", + "port": 55, + "sign": 1 + }, + { + "op": "line", + "port": 56, + "sign": 1 + }, + { + "op": "line", + "port": 58, + "sign": 1 + }, + { + "op": "line", + "port": 59, + "sign": 1 + }, + { + "op": "line", + "port": 60, + "sign": 1 + }, + { + "op": "line", + "port": 61, + "sign": 1 + }, + { + "op": "line", + "port": 62, + "sign": 1 + }, + { + "op": "line", + "port": 63, + "sign": 1 + }, + { + "op": "line", + "port": 64, + "sign": 1 + }, + { + "op": "line", + "port": 65, + "sign": 1 + }, + { + "op": "line", + "port": 66, + "sign": 1 + }, + { + "op": "line", + "port": 67, + "sign": 1 + }, + { + "op": "line", + "port": 68, + "sign": 1 + }, + { + "op": "line", + "port": 69, + "sign": 1 + }, + { + "op": "line", + "port": 70, + "sign": 1 + }, + { + "op": "line", + "port": 71, + "sign": 1 + }, + { + "op": "line", + "port": 72, + "sign": 1 + }, + { + "op": "line", + "port": 73, + "sign": 1 + }, + { + "op": "line", + "port": 74, + "sign": 1 + }, + { + "op": "line", + "port": 75, + "sign": 1 + }, + { + "op": "line", + "port": 77, + "sign": 1 + }, + { + "op": "line", + "port": 78, + "sign": 1 + }, + { + "op": "line", + "port": 79, + "sign": 1 + }, + { + "op": "line", + "port": 80, + "sign": 1 + }, + { + "op": "line", + "port": 82, + "sign": 1 + }, + { + "op": "line", + "port": 83, + "sign": 1 + }, + { + "op": "line", + "port": 84, + "sign": 1 + }, + { + "op": "line", + "port": 85, + "sign": 1 + }, + { + "op": "line", + "port": 86, + "sign": 1 + }, + { + "op": "line", + "port": 88, + "sign": 1 + }, + { + "op": "line", + "port": 89, + "sign": 1 + }, + { + "op": "line", + "port": 90, + "sign": 1 + }, + { + "op": "line", + "port": 91, + "sign": 1 + }, + { + "op": "line", + "port": 93, + "sign": 1 + }, + { + "op": "line", + "port": 94, + "sign": 1 + }, + { + "op": "line", + "port": 95, + "sign": 1 + }, + { + "op": "line", + "port": 96, + "sign": 1 + }, + { + "op": "line", + "port": 97, + "sign": 1 + }, + { + "op": "line", + "port": 98, + "sign": 1 + }, + { + "op": "line", + "port": 99, + "sign": 1 + }, + { + "op": "line", + "port": 100, + "sign": 1 + }, + { + "op": "line", + "port": 101, + "sign": 1 + }, + { + "op": "line", + "port": 102, + "sign": 1 + }, + { + "op": "line", + "port": 103, + "sign": 1 + }, + { + "op": "line", + "port": 104, + "sign": 1 + }, + { + "op": "line", + "port": 105, + "sign": 1 + }, + { + "op": "line", + "port": 106, + "sign": 1 + }, + { + "op": "line", + "port": 107, + "sign": 1 + }, + { + "op": "line", + "port": 108, + "sign": 1 + }, + { + "op": "line", + "port": 109, + "sign": 1 + } + ], + "query": "R_U D_(2,U) C = B2 C", + "scope": "Complete local native operator read with restored sources and eight owned outputs; global delivery, retention, physical map cost, recursive precision and supplier invoice are open", + "source_cut": "post-B_1_2 X_U in completed frame F_(L+E1)", + "source_sha256": { + "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "research/joint-query/evidence/BRIDGE-REVIEW.md": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3", + "research/joint-query/evidence/CONSERVED-QQ16.md": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb", + "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb" + }, + "status": "PASS_QQ16_FUTURE_X_QUERY" +} diff --git a/research/qq16-future-x-query/SOURCES.json b/research/qq16-future-x-query/SOURCES.json new file mode 100644 index 0000000000..8059a45400 --- /dev/null +++ b/research/qq16-future-x-query/SOURCES.json @@ -0,0 +1,48 @@ +{ + "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/community-frontier1042-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/joint-query/evidence/BRIDGE-REVIEW.md", + "usage": "input", + "git_blob": "86139908c418235588045324f0873de6ac9f9707", + "sha256": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3" + }, + { + "path": "research/joint-query/evidence/CONSERVED-QQ16.md", + "usage": "input", + "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce", + "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb" + }, + { + "path": "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md", + "usage": "input", + "git_blob": "3dd1a990d7b9d57cfb20cf8e8dd45548f043a944", + "sha256": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb" + } + ] +} diff --git a/research/qq16-future-x-query/TASK.json b/research/qq16-future-x-query/TASK.json new file mode 100644 index 0000000000..1dd99a35cf --- /dev/null +++ b/research/qq16-future-x-query/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "joint-query-controller", + "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?", + "starting_points": [ + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Add one explicitly priced ordinary-to-selected observation and derive the ordered two-call map and inverse.", + "Change the first local pair or retained state, then test the existing lost-observation witness and price all new operations." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the fixed-first-pair QQ16 witness before designing a controller. The checked #1969 local words do not evade that witness or supply global placement.", + "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": "Apply the existing witness to one proposed extra observation or changed first pair. If it still loses the required record, stop. Otherwise derive one ordered two-call identity and charge the added read, chart maps and restoration before extending to more stages.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct and exactly check one native local read B2 C at the post-B1 completed-X stage1 cut, with 96 borrowed sources restored and 8 explicitly owned query outputs; enumerate the complete local bill.", + "scope_change_reason": "PR2443 supplies a positive two-cut algebraic decoder but leaves native B2 C access and its cost open. This contribution closes that exact local access with an explicit invoice; complete favorable controller/supplier budgeting remains open.", + "bottleneck_link": "The queried chart 2 is later than the completed-X source stage 1, outside the retained zero-line X bridge regime. The source-specific residual C_q requires an explicit normalization in this construction.", + "budget_minutes": 60, + "stop_rule": "Stop after exact source-bound local frames, content, signed child kernels, restored sources, complete local invoice and failure controls. Do not infer favorable supplier cost or implement a global controller.", + "outcome": "completed", + "evidence": "PROOF.md, verify.py, RESULT.json and test_package.py. Literal 776-event word; 104 independent input arrays; 98,304 exact signed native basis columns; 8 semantic controls.", + "author": "ywz65", + "ai_assistance": "Substantial OpenAI Codex assistance in source reading, derivation, implementation, validation and writing; no independent human review.", + "open_questions": [ + { + "question": "Can the other two-cut records and this query be retained and hosted with a favorable full invoice?", + "why_it_matters": "A legal local read is not yet a useful supplier and adds 192 rank-one children and 8 owned output arrays.", + "first_step": "Build a chronological ledger for all observations, output gauge conversions, children, maps, storage and cleanup; stop if the optimistic full bill misses the target.", + "blocked_by": "Global owner delivery, retention, address cost, precision and full supplier budget." + }, + { + "question": "Can earlier observation or fusion avoid this standalone normalization cost?", + "why_it_matters": "The 192-child construction is an upper bound for this word, not an unrestricted lower bound.", + "first_step": "Specify another observation time or fusion word and verify the full ordered decoder with its new native endpoint types.", + "blocked_by": "Changed retention contract and full billing must be proved." + } + ], + "freshness": { + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "checked_at_utc": "2026-10-15T11:17:56Z", + "priority_revision": 4, + "open_pr_snapshot_utc": "2026-10-15T11:18:07.451335+00:00", + "discussion_snapshot_utc": "2026-10-15T11:21:50.274076+00:00", + "open_pr_records": 659, + "discussion_records": 1185, + "complete_pagination": true, + "scope": "Open titles/bodies, Discussions and local package notes; not all diffs." + }, + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/pull/2443#issuecomment-6190900779", + "validation": { + "registered_python": "3.12.7", + "additional_python": "3.14.5", + "package": "Normal and optimized exact receipt replay and 5 source/phase/kernel tests passed.", + "baseline": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY; source bindings only." + } +} diff --git a/research/qq16-future-x-query/VERIFY.json b/research/qq16-future-x-query/VERIFY.json new file mode 100644 index 0000000000..93fc87f479 --- /dev/null +++ b/research/qq16-future-x-query/VERIFY.json @@ -0,0 +1,47 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1042-audit/selected-replay.tar.gz", + "research/joint-query/certificate.json.gz", + "research/joint-query/evidence/BRIDGE-REVIEW.md", + "research/joint-query/evidence/CONSERVED-QQ16.md", + "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact local native phase/content replay, restored sources, all 98,304 native kernel columns, complete local invoice and 8 semantic controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Optimized deterministic receipt replay" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 120, + "checks": "Exact predecessor copy, live-source corruption, independent phase evaluation, signed native inverse and translation controls" + } + ] +} diff --git a/research/qq16-future-x-query/evidence/PR2443-README.md b/research/qq16-future-x-query/evidence/PR2443-README.md new file mode 100644 index 0000000000..1ae3d3eb97 --- /dev/null +++ b/research/qq16-future-x-query/evidence/PR2443-README.md @@ -0,0 +1,213 @@ +# QQ16 coordinate decoding with two retained cuts + +**Scoped ordered proof; no supplier or new kappa.** For the unchanged conserved +`F0/B_1_2` pair, 88 ordinary coordinate arrays suffice to recover **all original +pair-0 inputs**, provided the selected fields and completed-X block listed below +are available at the two specified cuts. The inputs may be arbitrary, not just +members of the eight local-axis families tested by +[PR2432](https://github.com/CrocSwap/integer-mult-bounds/pull/2432). + +This answers a restricted version of PR2432's next question. It does **not** +show that the final controller exposes these cut values, that retaining them +is free, or that 88 reads are a favorable physical implementation. It supplies +an explicit decoder once those observations are granted. + +## Exact observation contract + +Write `(x1,y1)=F0(x,y)` and `(x2,y2)=B_1_2(x1,y1)`, with no intervening +modification. Use the retained disjoint selected sets + +```text +A = [0,7,20,27,36,46,57,111] +T = [21,37,47,76,81,87,92,110] +U = {0,...,111} \ (A union T) +J = [1,2,3,4,5,6,8,12] +S = U \ J +``` + +The decoder receives only: + +- `x1_A`, `x1_T`, `y1_A`, `y1_T`, retained immediately after complete F0; +- `y2_A` and the completed-X ordinary block `C=x2_U`, immediately after B1; +- `x1_S`, the 88 ordinary arrays read after F0. + +An array includes its complete owner and payload coordinates. Reads are +side-effect-free. No original selected input, initial dense ordinary query, +`y2_U`, or former-Y final endpoint is an observation. This is a two-cut +information contract, not a bound of 88 total stored arrays: the selected +records and the complete `C` block are additional granted observations. +Other bank pairs can have arbitrary initial values; they do not participate +in these first two events. No recovery claim for those other pairs is made. + +## Ordered proof + +All equations are over rational-valued owner/payload arrays. Let `D_(s,p)` be +the actual invertible cover map for port p in chart s. The scalar centre matrix +is R. For a port set V, write + +```text +B_(s,V) z = sum_(p in V) r_p D_(s,p) z_p +B_s = B_(s,U) +ell_(s,V) = B_(s,V), for V=A or T +P_(s,V) q = D_(s,V)^(-1) R_V^(-1) q, for V=A or T. +``` + +Here `D_(s,V)` is block diagonal in ports; its entries are operators, not +commuting scalar coefficients. The actual selected Grams are +`R_A R_A^T = R_T R_T^T = 4I`, so `R_V^(-1)=R_V^T/4`. +The source normalization is `K=R^T/4`; its routed restriction to U is `K_(s,U)`. +These are the conserved maps in the retained +[ordered contract](../joint-query/evidence/JOINT-QUERY-TRANSFER.md), sections +“A variant that preserves both selected pair sums” and +“A forward map with the same conserved inputs.” + +### Recover the missing post-F0 ordinary arrays + +The forward equations give + +```text +f = R_0 x +x1_U = x_U - K_(0,U) f +y1_U = y_U + x1_U +x1_A = P_(0,A) ell_(0,T) x_T +x1_T = P_(0,T) f. +``` + +The backward U target is an exact subtraction. Its future logger changes +only A, and its source output at A is that logger's output. Consequently, + +```text +C = x2_U = x1_U - y1_U = -y_U +q = ell_(2,A) (y2_A - y1_A) + = B_2 y1_U + ell_(2,T) y1_T +v = q - ell_(2,T) y1_T + B_2 C + = B_2 x1_U. +``` + +Every expression on the left is determined by the allowed observations. +Subtract the known coordinates: + +```text +w = v - B_(2,S) x1_S + = R_J D_(2,J) x1_J. +``` + +The actual rational `R_J` is invertible. The checker derives its inverse +from the pinned R, verifies both inverse orders, and records the matrices in +[RESULT.json](RESULT.json). Thus + +```text +x1_J = D_(2,J)^(-1) (R_J^(-1) w). +``` + +The order is essential: first apply the scalar inverse, then undo each +port's cover map. Moving the different port maps through `R_J^(-1)` is not +valid. This step recovers all of `x1_U`, with no hypothesis on how its +owner or payload values were generated. + +### Recover the original inputs + +Use the selected sections and the recovered ordinary block: + +```text +f = ell_(0,T) x1_T +t = P_(0,T) ell_(0,A) x1_A +x_U = x1_U + K_(0,U) f +x_T = t +x_A = P_(0,A) (f - B_0 x_U - ell_(0,T) t) +y_U = -C +y_V = x1_V + y1_V - x_V, V=A,T. +``` + +The first two formulas invert the two selected forward records. The third +inverts its ordinary update. The fourth and fifth recover the selected +components of `R_0 x=f`. Finally, the unchanged selected pair sums recover +the original Y values. Therefore this decoder composed with the stated +observation map is the identity on all 224 original port arrays. + +This is an ordered algebraic argument for arbitrary arrays under the inherited +local contract. The finite fixtures below check its source-specific premises +and implementation; they are not the proof of the arbitrary-array statement. + +## Evidence and reproduction + +From the repository root, with Python 3.12 and its standard library: + +```sh +python3.12 scripts/research_package.py --package research/qq16-coordinate-cut-decoder +``` + +The registered commands run the direct check and the optimized replay and +source-corruption controls. Direct entry point: + +```sh +python3.12 -I -B research/qq16-coordinate-cut-decoder/verify.py +``` + +Expected status: `PASS_QQ16_COORDINATE_CUT_DECODER`. + +The check binds the actual packet, two archive members, the first F0/B1 events, +selected Grams, `K=R^T/4`, the two-sided unread-minor inverse, and 224 registered +port-route/inverse pairs, including their payload-translation inverse equations. +It implements the conserved logical maps directly, rather than executing the +native words or importing a predecessor verifier. + +Finite execution covers each of the 224 input-port placements using nonconstant +owner bit-functions and one dense signed/dyadic fixture with every field dirty. +All five incorrect decoders have explicit nonzero residuals: wrong C sign, +missing future-T subtraction, missing old-A subtraction, missing forward K +correction, and reversed route/scalar inverse order. Each of the five external +source-file corruptions is rejected. Checks remain active under `-O`, and the +optimized replay must match the committed result without modifying package files. + +The finite functions are constant in payload. The universal proof uses the +inherited invertibility of the full cover maps, not an extrapolation from these +functions. Native kernels, the remaining 17 schedule events, a proof assistant, +and the selected full cold replay were not run. + +## Relation to earlier work and limits + +- Gareth Davidson's [PR2432](https://github.com/CrocSwap/integer-mult-bounds/pull/2432), + pinned at `cbede349fc764aa38379aa533befe3215916cfcd`, supplies the unread basis + and the eight-family threshold. This package adds arbitrary-input sufficiency + under the explicit two-cut contract. It does not reprove the threshold or + claim a new unrestricted read minimum. +- commdata2338's [PR2174](https://github.com/CrocSwap/integer-mult-bounds/pull/2174), + pinned at `f79470a7931f3943360c10d15b428e0e4e479c22`, uses two initial dense + queries and a post-B1 selected cut to recover pair-0 selected inputs. It + reconstructs a transient F0 record which this package explicitly retains. + The observation and retention contracts differ; neither cost nor controller + superiority follows from this comparison. +- commdata2338's PR2384 exact `Model.forward/backward` implementation, as + retained by PR2432, was consulted. Its owner-function representation informed + the finite checker; no predecessor executable is imported or vendored. +- Ali Romman / PR1969 supplies the conserved maps, native contract and cover + semantics. Adam Gall / PR2093, kyzer1023 / PR2354, PR2389 and its PR2419 audit + supply the hidden-family and coordinate-read lineage. The retained Rohan Arun, + Jeremy Kothe, DreamingOfClouds and supplier contributors retain their credit. + +No read, storage, chart-map, cleanup, hosting, precision, tape or recursive-child +cost is certified here. In particular, the `B_2 C` read must be legal at the +completed-X type; an algebraic formula alone does not establish that access. +The selected frontier and frozen predecessors are unchanged. + +Base and exact input pins are in [SOURCES.json](SOURCES.json); scope and overlap +are in [TASK.json](TASK.json). Coordination: +[Discussion 2424](https://github.com/CrocSwap/integer-mult-bounds/discussions/2424#discussioncomment-18946004). +New work is Apache-2.0, submitted by `starship-s` with substantial assistance from +Hermes Agent (`gpt-6-astra-900k`: derivation and proof) and Codex +(`gpt-6-astra`, max effort: implementation and review). No independent human or +proof-assistant verification is claimed. + +## Open next questions + +1. **Can an actual controller retain or reconstruct these two-cut records?** + This is necessary to turn the information lemma into a usable decoder. + First trace `x1_A/T`, `y1_A/T`, `y2_A` and `C` through the remaining schedule, + with their native endpoint types. The blocker is legal retention and access, + not the local inverse. +2. **Does a fully charged implementation have a favorable budget?** + First price the 88 reads, `B_2 C`, scalar minor inversion, per-port chart + maps, storage and cleanup together. No physical implementation or favorable + complete bill has been supplied; stop this route if even its optimistic bill + misses the declared supplier target. diff --git a/research/qq16-future-x-query/test_package.py b/research/qq16-future-x-query/test_package.py new file mode 100644 index 0000000000..8c6153c6dd --- /dev/null +++ b/research/qq16-future-x-query/test_package.py @@ -0,0 +1,69 @@ +"""Source-integrity and independent phase/kernel controls. Apache-2.0.""" +import importlib.util +import hashlib +import json +from pathlib import Path +import unittest +from unittest.mock import patch + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("future_query", HERE / "verify.py") +v = importlib.util.module_from_spec(spec) +spec.loader.exec_module(v) + + +class NativeReadTests(unittest.TestCase): + def test_handoff_copy_matches_exact_predecessor(self): + pin = json.loads((HERE / "PREDECESSOR.json").read_text(encoding="utf-8")) + raw = (HERE / pin["retained_copy"]).read_bytes() + self.assertEqual(hashlib.sha256(raw).hexdigest(), pin["sha256"]) + blob = b"blob " + str(len(raw)).encode() + b"\0" + raw + self.assertEqual(hashlib.sha1(blob).hexdigest(), pin["git_blob"]) + + def test_every_live_source_corruption_rejected(self): + import json + pins = json.loads((HERE / "SOURCES.json").read_text()) + original = Path.read_bytes + for item in pins["files"]: + if item["usage"] != "input": + continue + target = v.ROOT / item["path"] + with self.subTest(path=item["path"]): + def bad_read(path, target=target): + data = original(path) + return data + b"corruption" if path == target else data + with patch.object(Path, "read_bytes", bad_read): + with self.assertRaisesRegex(ValueError, "source hash"): + v.load_sources() + + def test_phase_polynomial_matches_direct_character(self): + # Independent pointwise parity evaluation for a mixed signed example. + terms = ((0b1101, -1), (0b1010, 1), (0b1111, 2), (0b10001, 3)) + linear, cross = v.phase(terms) + for character in range(32): + direct = sum(c * ((axis & character).bit_count() % 2) for axis, c in terms) % 4 + evaluated = sum(linear[i] for i in range(73) if (character >> i) & 1) + evaluated += 2 * sum((row & character).bit_count() for i, row in enumerate(cross) if (character >> i) & 1) + self.assertEqual(direct, evaluated % 4) + + def test_inverse_line_is_not_the_positive_line(self): + q = 0b10101 + positive = v.line_recipe(q, 1) + negative = v.line_recipe(q, -1) + self.assertNotEqual(v.kernel(positive, 7), v.kernel(negative, 7)) + # Multiply the two explicit Gaussian kernels independently. + composed = {} + for middle, (a, b) in v.kernel(positive, 7).items(): + for out, (c, d) in v.kernel(negative, middle).items(): + old = composed.get(out, (0, 0)) + composed[out] = (old[0] + a*c-b*d, old[1] + a*d+b*c) + self.assertEqual({x: z for x, z in composed.items() if z != (0, 0)}, {7: (4, 0)}) + + def test_wrong_map_translation_changes_native_phase(self): + identity = v.AXES + self.assertNotEqual(v.phase(v.move_frame(v.START, (identity, 1))), v.phase(v.START)) + self.assertEqual(v.phase(v.move_frame(v.move_frame(v.START, (identity, 1)), (identity, 1))), v.phase(v.START)) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/qq16-future-x-query/verify.py b/research/qq16-future-x-query/verify.py new file mode 100644 index 0000000000..58c9c9b315 --- /dev/null +++ b/research/qq16-future-x-query/verify.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""Exact local QQ16 future-chart read, with borrowed sources restored. + +By ywz65 with substantial OpenAI Codex assistance, Apache-2.0. Source +reconstruction shares this author's method from the independent PR2456 audit; +no pending predecessor code is imported. No global supplier is claimed. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from functools import lru_cache +import gzip +import hashlib +import io +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +AXES = tuple(1 << i for i in range(73)) +A = (0, 7, 20, 27, 36, 46, 57, 111) +T = (21, 37, 47, 76, 81, 87, 92, 110) +U = tuple(p for p in range(112) if p not in A + T) +START = tuple((e, 1) for e in AXES[:17]) +COMMON = tuple((e, 1) for e in AXES[9:25]) +MEMBERS = { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", +} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def act(columns, vector): + out = 0 + while vector: + bit = vector & -vector + out ^= columns[bit.bit_length() - 1] + vector ^= bit + return out + + +@lru_cache(None) +def multiply(g, h): + return tuple(act(g, v) for v in h) + + +def combine(a, b, coefficient=1): + result = dict(a) + for key, value in b.items(): + result[key] = result.get(key, Q(0)) + coefficient * value + return {key: value for key, value in result.items() if value} + + +def routed(g, row): + return {(variable, multiply(g, old)): value for (variable, old), value in row.items()} + + +@lru_cache(None) +def phase(terms): + linear, quadratic = [0] * 73, [0] * 73 + for vector, coefficient in terms: + bits = [i for i in range(73) if (vector >> i) & 1] + for i in bits: + linear[i] = (linear[i] + coefficient) % 4 + if coefficient % 2: + for j in bits: + if j > i: + quadratic[i] ^= 1 << j + return tuple(linear), tuple(quadratic) + + +def move_frame(terms, mapping): + g, shift = mapping + return tuple((act(g, vector), coefficient) for vector, coefficient in terms) + ((shift, 2),) + + +def load_sources(): + pins = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + raw = {} + for item in pins["files"]: + if item["usage"] == "input": + data = (ROOT / item["path"]).read_bytes() + need(sha(data) == item["sha256"], "source hash: " + item["path"]) + raw[item["path"]] = data + packet = json.loads(gzip.decompress(raw["research/joint-query/certificate.json.gz"])) + decoded = {} + with tarfile.open(fileobj=io.BytesIO(raw["research/community-frontier1042-audit/selected-replay.tar.gz"]), mode="r:gz") as archive: + for name, digest in MEMBERS.items(): + matches = [item for item in archive.getmembers() if item.name == name] + need(len(matches) == 1 and matches[0].isfile(), "unique source member") + data = archive.extractfile(matches[0]).read() + need(sha(data) == digest, "member hash: " + name) + decoded[name.rsplit("/", 1)[-1]] = json.loads(gzip.decompress(data) if name.endswith("gz") else data) + word, programs = decoded["CANONICAL-WORD.json.gz"], decoded["LOCAL-PROGRAMS.json.gz"] + need((word["v"], 2 * word["v"] + word["R"]) == (112, 704), "source geometry") + rows = [{i: Q(1)} for i in range(712)] + for event in programs["forward"]: + if event == ["phase", "centers"]: + break + if event[0] != "scalar": + continue + op = event[1] + at = op[1][1] + (704 if op[1][0] == "C" else 0) + if op[0] == "clear": + rows[at] = {} + elif op[0] == "scale": + rows[at] = {j: x * Q(op[2], op[3]) for j, x in rows[at].items()} + else: + source = op[2][1] + (704 if op[2][0] == "C" else 0) + need(op[0] in ("add", "copy"), "known source gate") + rows[at] = dict(rows[source]) if op[0] == "copy" else combine(rows[at], rows[source], Q(op[3], op[4])) + else: + raise ValueError("missing source centre boundary") + R = [[rows[c].get(p, Q(0)) for p in range(112)] for c in word["centers"]] + need(R == [[Q(row.get(str(p), 0)) for p in range(112)] for row in packet["R_rows"]], "actual R") + need(tuple(packet["U_ports"]) == U and tuple(packet["A_ports"]) == A and tuple(packet["T_ports"]) == T, "actual partition") + need(all(x in (-1, 0, 1) for row in R for x in row), "signed unit coefficients") + need(all(sum(R[k][p] ** 2 for k in range(8)) == 4 for p in U), "four terms per ordinary port") + phases = decoded["DATA-PHASES.json"] + program = packet["programs"]["B_1_2"] + records = {} + for p in U: + source = phases["recipes"][p] + need(source["port"] == p, "port binding") + q = source["q"] + basis = source["idle_children"][0]["orthogonal_axes"][:8] + need(q < 512 and q.bit_count() % 2 == 1, "actual odd local port") + need(all((q & b).bit_count() % 2 == 0 for b in basis), "port-normal chart") + swaps = [b ^ AXES[17 + i] for i, b in enumerate(basis)] + g = tuple(e ^ act(swaps, sum(((e & s).bit_count() % 2) << i for i, s in enumerate(swaps))) for e in AXES) + shift = q ^ sum((((b.bit_count() - 1) // 2) % 2) << (17 + i) for i, b in enumerate(basis)) + inverse_shift = act(g, shift) + names = [event[2] for event in program if event[0] == "cover_map" and event[1] == ["L", 112 + p]] + need(len(names) == 4, "actual Y map pair inventory") + entry, exit_map = [packet["map_registry"][name] for name in names[:2]] + need(tuple(entry["owner_right_matrix_columns"]) == tuple(exit_map["owner_right_matrix_columns"]) == g, "actual future owner action") + need(entry["payload_translation_at_identity_owner"] == shift and exit_map["payload_translation_at_identity_owner"] == inverse_shift, "actual future payload shifts") + need(multiply(g, g) == AXES and act(g, q) == q, "involutive route fixes port") + records[p] = {"q": q, "g": g, "shift": shift, "inverse_shift": inverse_shift, "entry_name": names[0], "exit_name": names[1]} + return R, records, {name: sha(data) for name, data in raw.items()} + + +def literal_program(R): + # Whole sweeps are explicit barriers: no ADD is interleaved with alignment. + return ([{"op": "line", "port": p, "sign": -1} for p in U] + + [{"op": "map", "port": p, "inverse": False} for p in U] + + [{"op": "clear_output", "query": k} for k in range(8)] + + [{"op": "add", "query": k, "port": p, "coefficient": int(R[k][p])} for k in range(8) for p in U if R[k][p]] + + [{"op": "map", "port": p, "inverse": True} for p in U] + + [{"op": "line", "port": p, "sign": 1} for p in U]) + + +def replay(program, R, records, fault=None): + frames = {p: START for p in U} + frames.update({112 + k: () for k in range(8)}) + rows = {p: {(p, AXES): Q(1)} for p in frames} + trace = Counter() + for index, event in enumerate(program): + op = event["op"] + trace[op] += 1 + if op == "line": + p, sign = event["port"], event["sign"] + if fault == "omit_normalization" and sign == -1 and p == U[0]: + continue + if fault == "omit_restoration" and sign == 1 and p == U[0]: + continue + frames[p] += ((records[p]["q"], sign),) + elif op == "map": + p = event["port"] + record = records[p] + shift = record["inverse_shift"] if event["inverse"] else record["shift"] + if fault == "omit_payload_translation" and p == U[0]: + shift = 0 + if fault == "wrong_inverse_translation" and event["inverse"] and p == U[0]: + shift = record["shift"] + frames[p] = move_frame(frames[p], (record["g"], shift)) + rows[p] = routed(record["g"], rows[p]) + elif op == "clear_output": + at = 112 + event["query"] + if fault == "omit_output_clear" and event["query"] == 0: + # Keep a matching declared frame to isolate the dirty-input fault. + frames[at] = COMMON + continue + rows[at] = {} + frames[at] = COMMON + else: + need(op == "add", "known query operation") + p, at = event["port"], 112 + event["query"] + need(phase(frames[p]) == phase(frames[at]), "unmatched native scalar frames at event " + str(index)) + coefficient = event["coefficient"] + if fault == "wrong_query_coefficient" and event == next(x for x in program if x["op"] == "add"): + coefficient = -coefficient + rows[at] = combine(rows[at], rows[p], coefficient) + for p in U: + need(phase(frames[p]) == phase(START), "borrowed source frame not restored") + need(rows[p] == {(p, AXES): Q(1)}, "borrowed source content not restored") + for k in range(8): + need(phase(frames[112 + k]) == phase(COMMON), "query output frame") + expected = {(p, records[p]["g"]): R[k][p] for p in U if R[k][p]} + need(rows[112 + k] == expected, "exact future query or dirty output mismatch") + return dict(trace) + + +def rows_from_columns(columns): + return [sum(((columns[j] >> i) & 1) << j for j in range(9)) for i in range(9)] + + +def linear_map(rows, address): + return sum(((row & address).bit_count() % 2) << i for i, row in enumerate(rows)) + + +def line_recipe(q, sign): + pivot = (q & -q).bit_length() - 1 + columns = (q,) + tuple(1 << j for j in range(9) if j != pivot) + images = {act(columns, address): address for address in range(512)} + need(len(images) == 512, "invertible native wrapper") + inverse_columns = tuple(images[1 << i] for i in range(9)) + return {"rank": 1, "left_rows": rows_from_columns(columns), "left_offset": 0 if sign == 1 else q, "right_rows": rows_from_columns(inverse_columns)} + + +def kernel(recipe, address): + middle = linear_map(recipe["right_rows"], address) + a = linear_map(recipe["left_rows"], middle) ^ recipe["left_offset"] + b = linear_map(recipe["left_rows"], middle ^ 1) ^ recipe["left_offset"] + need(a != b, "two native kernel terms") + return {a: (1, 1), b: (1, -1)} # Gaussian numerators, common denominator 2. + + +def calculate(): + R, records, pins = load_sources() + program = literal_program(R) + trace = replay(program, R, records) + need(trace == {"line": 192, "map": 192, "clear_output": 8, "add": 384}, "literal invoice") + need(len(program) == 776, "literal event count") + controls = {} + for fault in ("omit_normalization", "omit_restoration", "omit_payload_translation", "wrong_inverse_translation", "omit_output_clear", "wrong_query_coefficient"): + try: + replay(program, R, records, fault) + except ValueError as error: + controls[fault] = str(error) + else: + raise ValueError("ineffective fault: " + fault) + # A first ADD before the whole alignment sweep must be rejected. + reordered = deepcopy(program) + target = next(i for i, event in enumerate(reordered) if event["op"] == "add") + event = reordered.pop(target) + first_map = next(i for i, item in enumerate(reordered) if item["op"] == "map") + reordered.insert(first_map, event) + try: + replay(reordered, R, records) + except ValueError as error: + controls["query_before_alignment_and_output_preparation"] = str(error) + else: + raise ValueError("early query control ineffective") + recipe_columns = 0 + recipes = {} + for p in U: + q = records[p]["q"] + for sign in (-1, 1): + recipe = line_recipe(q, sign) + for address in range(512): + need(kernel(recipe, address) == {address: (1, sign), address ^ q: (1, -sign)}, "exact signed rank-one native kernel") + recipe_columns += 1 + recipes[f"{p}:{sign}"] = recipe + bad = deepcopy(recipes[f"{U[0]}:-1"]) + bad["left_offset"] = 0 + need(kernel(bad, 0) != {0: (1, -1), records[U[0]]["q"]: (1, 1)}, "inverse line sign control") + controls["inverse_line_without_translation"] = "kernel differs at address zero" + # The unnormalized X field has precisely the residual C_q at the legal Y alignment. + residuals = {} + for p, record in records.items(): + aligned = move_frame(START, (record["g"], record["shift"])) + need(phase(aligned) == phase(COMMON + ((record["q"], 1),)), "exact future-X residual") + witness = (record["q"] & -record["q"]) + need(sum(c * ((v & witness).bit_count() % 2) for v, c in aligned) % 4 != sum(c * ((v & witness).bit_count() % 2) for v, c in COMMON) % 4, "residual is nonzero") + residuals[str(p)] = {"line": record["q"], "nonzero_character": witness} + invoice = {"rank_one_children": 192, "native_rank_mass": 192, "native_wrapper_maps": 384, + "full_cover_maps": 192, "signed_ADD_macros": 384, "CLEAR_macros": 8, + "scalar_real_primitive_allowance": 2 * (4 * 384 + 8), "owned_live_query_outputs": 8, + "borrowed_source_arrays_restored": 96, "literal_events": 776} + return {"status": "PASS_QQ16_FUTURE_X_QUERY", "source_sha256": pins, "member_sha256": MEMBERS, + "source_cut": "post-B_1_2 X_U in completed frame F_(L+E1)", "output_frame": "F_(E1+E2)", + "query": "R_U D_(2,U) C = B2 C", "formal_independent_inputs": 104, + "future_X_residuals": residuals, "invoice": invoice, "controls": controls, + "native_kernel_basis_columns": recipe_columns, "program": program, "native_recipes": recipes, + "scope": "Complete local native operator read with restored sources and eight owned outputs; global delivery, retention, physical map cost, recursive precision and supplier invoice are open"} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = calculate() + encoded = json.dumps(result, sort_keys=True, indent=2, default=str) + "\n" + path = HERE / "RESULT.json" + if args.write_result: + with path.open("x", encoding="utf-8", newline="\n") as out: + out.write(encoded) + else: + need(path.read_text(encoding="utf-8") == encoded, "committed receipt mismatch") + print("PASS_QQ16_FUTURE_X_QUERY sources=96 outputs=8 children=192 cover_maps=192 native_columns=98304 controls=8 no_new_kappa") + + +if __name__ == "__main__": + main()