diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 582e416aaf..50e8120dc0 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -2,6 +2,18 @@ ## Current selected-family replay +Resolve the [selected record](../certificates/selected-result.json) before +running a historical checkpoint. The current cold replay is +`make frontier4359-verify`, using the +[proof review](research/pr-intake-evidence/pr4359/PROOF-REVIEW.md), +[validation](research/pr-intake-evidence/pr4359/VALIDATION.json) and +[source manifest](../certificates/frontier4359-source.json). +The [frontier4359 workflow](../.github/workflows/frontier4359.yml) provides +hosted replay evidence. Metadata and source-pin checks are separate from +operator replay and do not discharge the inherited theorem assumptions. + +## Historical frontier1094 replay + Start with the [selected record](../certificates/selected-result.json). Its `reproduce`, `review`, `source_manifest` and `validation` fields identify the replay command, scoped assessment, source bindings and integration evidence. diff --git a/docs/research/current-status.md b/docs/research/current-status.md index 62a8cbb097..532af84312 100644 --- a/docs/research/current-status.md +++ b/docs/research/current-status.md @@ -1,12 +1,14 @@ # Current reviewed status -Selected conditional κ: **0.0023 = 23/10000**, zxv’s #4359 productive-helper construction, using Jacob Alan Sussman’s mixed-target recursion and the credited cumulative native/outer lineage. +Selected conditional κ: **0.0023** (= 23/10000), zxv’s #4359 productive-helper construction, using Jacob Alan Sussman’s mixed-target recursion and the credited cumulative native/outer lineage. [Selected record](../../certificates/selected-result.json) · [Proof review](pr-intake-evidence/pr4359/PROOF-REVIEW.md) · [Integration receipt](pr-intake-evidence/pr4359/INTEGRATION.json) · [Contributors](community-productive4359-contributors.md). Cold replay: `make frontier4359-verify`. The fresh 23-stage replay and 59 normalized artifacts pass; the changed interfaces have an AI-assisted proof review under retained analytic/native/fixed-tape hypotheses. Winning uniform templates are not materialized. This is not a complete formal or independent human verification. #4404 independently checks a narrower arithmetic/flow scope. -## Historical selected status through #1094 +All sections below are a historical snapshot; the selected-result.json record above is authoritative. + +## Historical checkpoint through #1094 Historical selected conditional κ: **0.001672660197076918**, Rohan Arun's #1094 on Jeremy Kothe's #1087 packing and the cumulative k8/slot/T16 construction. The bit supplier remains #589 on #555. diff --git a/research/d8-mixed-target-seeda97c8e/SOURCES.json b/research/d8-mixed-target-seeda97c8e/SOURCES.json index 9384463ff4..5dcfa9dd60 100644 --- a/research/d8-mixed-target-seeda97c8e/SOURCES.json +++ b/research/d8-mixed-target-seeda97c8e/SOURCES.json @@ -4,25 +4,25 @@ "files": [ { "path": "autoresearch.md", - "usage": "input", + "usage": "provenance", "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" }, { "path": "certificates/selected-result.json", - "usage": "input", + "usage": "provenance", "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" }, { "path": "docs/research/agent-task-catalog.json", - "usage": "input", + "usage": "provenance", "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" }, { "path": "docs/research/current-status.md", - "usage": "input", + "usage": "provenance", "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" }, diff --git a/research/d8-mixed-target-seeda97c8e/VERIFY.json b/research/d8-mixed-target-seeda97c8e/VERIFY.json index caff4adf82..2726200ed3 100644 --- a/research/d8-mixed-target-seeda97c8e/VERIFY.json +++ b/research/d8-mixed-target-seeda97c8e/VERIFY.json @@ -4,10 +4,6 @@ "python": "3.12", "requirements": [], "inputs": [ - "autoresearch.md", - "certificates/selected-result.json", - "docs/research/agent-task-catalog.json", - "docs/research/current-status.md", "research/bit-three-register-lower-bound/README.md", "research/d8-mixed-target-seeda97c8e/verify.py" ], diff --git a/research/fresh-helper-boundary/ARITHMETIC-RESULT.json b/research/fresh-helper-boundary/ARITHMETIC-RESULT.json new file mode 100644 index 0000000000..686c36fb19 --- /dev/null +++ b/research/fresh-helper-boundary/ARITHMETIC-RESULT.json @@ -0,0 +1,219 @@ +{ + "BIT": { + "admitted": "273/100000", + "gap": "118653797/10000000000000", + "inherited_unrelaxed_saving": "27418653797/10000000000000" + }, + "compiler": { + "H": 349300000000, + "N": "2^349300000000", + "eta": { + "lower": "0.140815224484524968848722108625", + "upper": "0.140815224484524968848722108626" + }, + "gap": "1/700000000", + "integer_test_exponent": 499, + "logarithm_power": 13, + "theta_upper": "6/7", + "uniform_saving": "952437/350000000", + "word_materialized": false + }, + "fixed_profile_ceiling": { + "decreasing_C_interval": [ + "0", + "1/20" + ], + "negative_derivative_upper": { + "lower": "-178315.972608883259749333049784629374", + "upper": "-178315.972608883259749333049784629373" + }, + "negative_moment_upper": { + "lower": "-8137.901782546330185425252976230749", + "upper": "-8137.901782546330185425252976230748" + }, + "remaining_C_interval": [ + "1/20", + "1" + ] + }, + "gain_over_PR4416": "3477/100000000", + "headroom_from_declared_to_root": [ + "8051/400000000000", + "50319/2500000000000" + ], + "kappa": "68031/25000000", + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform_gap": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT_relaxation": [ + "actual_bit_above_effective" + ], + "unfunded_outer": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "outer": { + "functional_checks": { + "fixed_halo_explicit_metadata_branch": "13475000001/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899997009/700000000000", + "new_semantic_group_guard": "3/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "1333410398095129/490000000000000000", + "fused_gaussian": "1333410394285387/490000000000000000", + "global_coordinate_router": "238109/87500000", + "group_bit_router": "166676386785673/61250000000000000", + "group_scans": "349999999/350000000", + "main_transform": "1333409698095129/490000000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "200395910398095129/490000000000000000" + }, + "parameters": { + "a": "238109/87500000", + "b": "1904873/700000000", + "beta": "699999997/700000000", + "bit_saving": "273/100000", + "cap_xi": "445395909698095129/490000000000000000", + "complex_uniform_saving": "952437/350000000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "68031/25000000", + "lambda_": "199455751/200000000", + "lambda_prime": "698095129/700000000", + "layout": "1/700000000", + "q": "1904871/700000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "2177/800000" + }, + "strict_checks": { + "actual_bit_above_effective": "383/43750000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "44604091351904871/245000000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "2798095129/490000000000000000", + "cap_above_band": "200395909698095129/490000000000000000", + "cap_below_cell": "44604089601904871/490000000000000000", + "cap_below_phase_cell_power": "534604090301904871/490000000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "19970127/700000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2794285387/490000000000000000", + "gaussian_above_main": "348095129/245000000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "436785673/61250000000000000", + "group_gauge_power_slack": "44604091316904871/245000000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "69809513/70000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "495134790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000", + "lambda_above_sigma": "3/1400000000", + "lambda_above_tau": "1/1400000000", + "lambda_prime_above_lambda": "1/1400000000", + "lambda_prime_above_leaf": "1398095127/490000000000000000", + "leaf_saving_above_effective": "698095127/490000000000000000", + "main_transform_above_kappa": "2098095129/490000000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "1684315473/21875000", + "microbox_halo_volume": "55300000003/700000000", + "new_complex_uniform_saving_above_b": "1/700000000", + "new_semantic_guard_with_C1_one": "1/700000000", + "polynomial_products_above_kappa": "698095131/700000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "1398095127/490000000000000000", + "q_positive": "1904871/700000000", + "short_record_fallback": "698095127/700000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "199062502798095129/490000000000000000", + "stop_below_one": "699999999/700000000", + "stop_positive": "1/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000", + "union_tag_work_per_visit_fits_record": "3/700000000" + } + }, + "paid": { + "1": 33795, + "16": 448, + "2": 7725, + "3": 6675, + "32": 448, + "4": 1530, + "48": 448, + "5": 600, + "8": 1464 + }, + "paid_calls": 53133, + "productive_fields": 7688, + "relative_gain_over_PR4416": "1159/89549", + "root_bracket": [ + "1088504051/400000000000", + "6803150319/2500000000000" + ], + "status": "PASS_CHANGED_NATIVE_PROFILE_STRICTIFICATION_AND_COMPLETE_OUTER", + "strictification": { + "alpha": { + "lower": "0.999999983026163231936831206184", + "upper": "0.999999983026163231936831206185" + }, + "cutoff_base": 10, + "delta": { + "lower": "0.864870069524004068270352709182", + "upper": "0.864870069524004068270352709183" + }, + "gamma": { + "lower": "0.910935673068185945998089027910", + "upper": "0.910935673068185945998089027911" + }, + "gap": { + "lower": "0.000000705775426641554341705594", + "upper": "0.000000705775426641554341705595" + }, + "normalized_paid_upper": "312500529444649842944287051245464084985300648225953097729364854469515503029278664568874151635979493066877292627151728507225829268936433948299379518726558518343844530884174444838473561069623983608689185814338090148572417036912296673977860237369051387753314848294993638501683424262073636500572764166420861283708720335677094583332070847074689861555558356543552667138912721443073650953550760942655945597474686732201711464952735742366374988690440592748048891939/312500750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "rational_upper_limits": [ + "62499999/62500000", + "911/1000", + "173/200" + ], + "tail_offset": "3/10", + "target_floor_base": 15, + "tensor_power": 150 + }, + "targets": { + "121": 224, + "25": 448, + "4": 390, + "41": 448, + "5": 30, + "57": 448, + "7": 435, + "8": 630, + "9": 4635 + }, + "tested_saving": "2177/800000" +} diff --git a/research/fresh-helper-boundary/ATTEMPTS.md b/research/fresh-helper-boundary/ATTEMPTS.md new file mode 100644 index 0000000000..61dd1812f5 --- /dev/null +++ b/research/fresh-helper-boundary/ATTEMPTS.md @@ -0,0 +1,44 @@ +# Scope of discovery + +The new contribution changes helper entrances and exits jointly with scalar +contact frames. The old choice was optimized for a hosted owner fill. Once +all helper fields are fresh independent inputs, that objective is different: +price the paid moment minus the actual productive helper moment. + +Exploratory checks before this pivot (compiled C++ discovery, not registered +proofs or global optimality certificates): + +- All 262,144 paired p7 masks: 256 modular candidates; none passes the numerical test C=.00268649. + The old rank profile and root were reproduced. +- All 2,097,152 paired p8 masks: 576 modular candidates; none passes C=.00268649. +- 2,391,496 masks within six individual-bank toggles of the selected p7 mask: + 6,278 modular candidates; none passes the numerical test C=.00268649. +- No untouched consecutive native transports fuse. Single common-frame + components, and alpha expansions over the 1,159 existing frame spaces with + all boundaries fixed, gave no improvement at C=.003. + +The rank-sum modular test is a discovery filter. If a polynomial matrix A has +invertible A(1), a constant-basis diagonal monomial factorization implies that +the sum of ranks of its nonzero coefficient matrices equals the dimension. +A necessary mod-2 screen is particularly cheap here because A(1) stays +invertible mod 2. Scientific acceptance of the selected word uses rational +Laurent replay and full native replay, not this filter. + +Allowing helper boundary frames changes the result. A binary alpha-expansion +cut changes a selected set of scalar contacts to one frame, while hard +constraints preserve every nested chronological path and every warp contact. +The energy is the complete paid moment minus productive helper moment. Entry +and exit moves are optimized separately because their joint concave reward +is not a submodular binary cost. The submitted finite choices are recorded +explicitly in CHANGES.json; replay needs no optimizer or C++ compiler. + +The optimizer is a discovery aid. Passing every tested label does not prove +global optimality. In particular, simultaneous different-label moves, changed +scalar order, new operators, center sharing and new geometry remain open. + +A subsequent scan added all binary lines, all hyperplanes and all coordinate +subspaces of F2^9: 1,264 new distinct labels, for 2,423 tested spaces. Separate +entry and exit alpha-expansion sweeps from the submitted profile found no +negative move at C=.003. The registered proof uses only the final finite +choices and exact native/moment replay; no claim of global optimality or +exact mathematical acceptance is drawn from floating discovery costs. diff --git a/research/fresh-helper-boundary/CHANGES.json b/research/fresh-helper-boundary/CHANGES.json new file mode 100644 index 0000000000..45744fedd0 --- /dev/null +++ b/research/fresh-helper-boundary/CHANGES.json @@ -0,0 +1,562 @@ +{ + "entrances": [ + [448, 114, 0], + [449, 114, 0], + [450, 115, 0], + [451, 115, 0], + [452, 115, 0], + [453, 115, 0], + [454, 114, 0], + [455, 114, 0], + [457, 116, 0], + [458, 116, 0], + [460, 117, 0], + [462, 117, 0], + [473, 114, 0], + [474, 118, 0], + [475, 118, 0], + [476, 119, 0], + [477, 119, 0], + [478, 120, 0], + [480, 120, 0], + [482, 114, 0], + [483, 114, 0], + [484, 121, 0], + [485, 121, 0], + [486, 122, 0], + [487, 122, 0], + [492, 115, 0], + [493, 115, 0], + [502, 115, 0], + [503, 115, 0], + [504, 115, 0], + [513, 115, 0], + [514, 115, 0], + [515, 115, 0], + [516, 123, 0], + [517, 123, 0], + [518, 124, 0], + [519, 124, 0], + [520, 125, 0], + [521, 125, 0], + [522, 126, 0], + [523, 126, 0], + [524, 115, 0], + [525, 115, 0], + [526, 115, 0], + [527, 115, 0], + [528, 127, 0], + [529, 127, 0], + [530, 128, 0], + [531, 128, 0], + [532, 129, 0], + [533, 129, 0], + [534, 130, 0], + [535, 130, 0], + [536, 115, 0], + [537, 115, 0], + [538, 131, 114], + [539, 114, 0], + [544, 132, 0], + [545, 132, 0], + [546, 133, 0], + [547, 133, 0], + [548, 114, 0], + [549, 114, 0], + [550, 114, 0], + [551, 114, 0], + [553, 134, 0], + [555, 134, 0], + [556, 135, 0], + [557, 135, 0], + [558, 136, 0], + [559, 136, 0], + [563, 134, 0], + [565, 134, 0], + [570, 134, 0], + [571, 134, 0], + [572, 134, 0], + [573, 134, 0], + [578, 114, 0], + [579, 114, 0], + [580, 115, 0], + [581, 115, 0], + [582, 115, 0], + [583, 115, 0], + [585, 114, 0], + [586, 137, 0], + [587, 137, 0], + [588, 137, 0], + [589, 137, 0], + [590, 138, 0], + [591, 137, 0], + [592, 137, 0], + [593, 137, 0], + [596, 137, 0], + [597, 137, 0], + [598, 114, 0], + [599, 114, 0], + [600, 114, 0], + [601, 114, 0], + [606, 115, 0], + [607, 115, 0], + [608, 115, 0], + [609, 115, 0], + [610, 115, 0], + [611, 115, 0], + [612, 115, 0], + [614, 115, 0], + [615, 115, 0], + [616, 115, 0], + [617, 115, 0], + [618, 115, 0], + [619, 115, 0], + [620, 115, 0], + [621, 140, 0], + [622, 114, 0], + [623, 114, 0], + [624, 114, 0], + [625, 114, 0] + ], + "exits": [ + [277, 256, 299], + [282, 257, 299], + [293, 258, 301], + [298, 258, 301], + [307, 261, 303], + [309, 261, 303], + [311, 262, 1], + [314, 263, 303], + [323, 265, 304], + [325, 266, 304], + [327, 267, 1], + [330, 268, 304], + [337, 270, 305], + [339, 270, 305], + [341, 271, 305], + [346, 271, 305], + [353, 272, 307], + [355, 272, 307], + [357, 273, 307], + [362, 273, 307], + [369, 275, 308], + [371, 275, 308], + [373, 275, 308], + [378, 276, 308], + [385, 277, 309], + [387, 277, 309], + [389, 278, 309], + [394, 278, 309], + [494, 262, 1], + [495, 262, 1], + [505, 267, 1], + [506, 267, 1], + [548, 285, 1], + [560, 285, 1], + [566, 286, 279], + [567, 286, 279], + [568, 287, 280], + [569, 287, 280], + [574, 288, 279], + [575, 288, 279], + [576, 289, 281], + [577, 289, 281] + ], + "gates": [ + ["A", 626, 115, 0], + ["A", 627, 115, 0], + ["A", 628, 115, 0], + ["A", 629, 114, 0], + ["A", 630, 114, 0], + ["A", 631, 114, 0], + ["A", 632, 114, 0], + ["A", 633, 114, 0], + ["A", 1762, 134, 0], + ["A", 1763, 134, 0], + ["A", 1764, 134, 0], + ["A", 1765, 134, 0], + ["A", 1766, 134, 0], + ["A", 1767, 134, 0], + ["A", 1768, 134, 0], + ["A", 1769, 134, 0], + ["A", 1770, 134, 0], + ["A", 1771, 134, 0], + ["A", 1772, 134, 0], + ["A", 1773, 134, 0], + ["A", 1774, 134, 0], + ["A", 1775, 134, 0], + ["A", 1776, 134, 0], + ["A", 1777, 134, 0], + ["A", 1778, 134, 0], + ["A", 1779, 134, 0], + ["A", 1780, 134, 0], + ["A", 1781, 134, 0], + ["A", 1782, 134, 0], + ["A", 1783, 134, 0], + ["A", 1784, 134, 0], + ["A", 1785, 134, 0], + ["A", 1786, 134, 0], + ["A", 1787, 116, 0], + ["A", 1788, 119, 0], + ["A", 1789, 119, 0], + ["A", 1790, 119, 0], + ["A", 1791, 119, 0], + ["A", 1792, 117, 0], + ["A", 1793, 124, 0], + ["A", 1794, 124, 0], + ["A", 1795, 120, 0], + ["A", 1796, 124, 0], + ["A", 1797, 124, 0], + ["A", 1798, 125, 0], + ["A", 1799, 125, 0], + ["A", 1800, 125, 0], + ["A", 1801, 125, 0], + ["A", 1802, 135, 0], + ["A", 1803, 135, 0], + ["A", 1804, 117, 0], + ["A", 1805, 128, 0], + ["A", 1806, 128, 0], + ["A", 1807, 128, 0], + ["A", 1808, 128, 0], + ["A", 1809, 120, 0], + ["A", 1810, 130, 0], + ["A", 1811, 130, 0], + ["A", 1812, 130, 0], + ["A", 1813, 130, 0], + ["A", 1814, 133, 0], + ["A", 1815, 133, 0], + ["A", 1816, 116, 0], + ["A", 1817, 122, 0], + ["A", 1818, 122, 0], + ["A", 1819, 122, 0], + ["A", 1820, 122, 0], + ["A", 1821, 129, 0], + ["A", 1822, 129, 0], + ["A", 1823, 129, 0], + ["A", 1824, 129, 0], + ["A", 1825, 132, 0], + ["A", 1826, 132, 0], + ["A", 1827, 126, 0], + ["A", 1828, 126, 0], + ["A", 1829, 126, 0], + ["A", 1830, 126, 0], + ["A", 1831, 136, 0], + ["A", 1832, 136, 0], + ["A", 1833, 118, 0], + ["A", 1834, 118, 0], + ["A", 1835, 118, 0], + ["A", 1836, 118, 0], + ["A", 1837, 127, 0], + ["A", 1838, 127, 0], + ["A", 1839, 127, 0], + ["A", 1840, 127, 0], + ["A", 1841, 123, 0], + ["A", 1842, 123, 0], + ["A", 1843, 123, 0], + ["A", 1844, 123, 0], + ["A", 1845, 121, 0], + ["A", 1846, 121, 0], + ["A", 1847, 121, 0], + ["A", 1848, 121, 0], + ["A", 4031, 620, 621], + ["A", 4037, 622, 280], + ["B", 0, 115, 0], + ["B", 1, 115, 0], + ["B", 2, 115, 0], + ["B", 3, 115, 0], + ["B", 4, 115, 0], + ["B", 5, 115, 0], + ["B", 6, 115, 0], + ["B", 7, 115, 0], + ["B", 8, 114, 0], + ["B", 9, 114, 0], + ["B", 10, 114, 0], + ["B", 15, 114, 0], + ["B", 16, 114, 0], + ["B", 17, 114, 0], + ["B", 18, 114, 0], + ["B", 19, 115, 0], + ["B", 20, 115, 0], + ["B", 21, 115, 0], + ["B", 22, 115, 0], + ["B", 23, 115, 0], + ["B", 24, 115, 0], + ["B", 25, 115, 0], + ["B", 26, 115, 0], + ["B", 27, 114, 0], + ["B", 28, 114, 0], + ["B", 29, 114, 0], + ["B", 30, 114, 0], + ["B", 32, 114, 0], + ["B", 33, 114, 0], + ["B", 34, 114, 0], + ["B", 35, 115, 0], + ["B", 36, 115, 0], + ["B", 37, 115, 0], + ["B", 38, 115, 0], + ["B", 39, 115, 0], + ["B", 40, 115, 0], + ["B", 41, 115, 0], + ["B", 42, 115, 0], + ["B", 43, 114, 0], + ["B", 44, 114, 0], + ["B", 45, 114, 0], + ["B", 46, 114, 0], + ["B", 47, 114, 0], + ["B", 48, 114, 0], + ["B", 49, 115, 0], + ["B", 50, 115, 0], + ["B", 51, 115, 0], + ["B", 52, 115, 0], + ["B", 53, 115, 0], + ["B", 54, 115, 0], + ["B", 55, 115, 0], + ["B", 56, 115, 0], + ["B", 57, 114, 0], + ["B", 60, 114, 0], + ["B", 61, 137, 0], + ["B", 62, 137, 0], + ["B", 63, 137, 0], + ["B", 64, 137, 0], + ["B", 65, 137, 0], + ["B", 66, 137, 0], + ["B", 67, 137, 0], + ["B", 68, 137, 0], + ["B", 69, 137, 0], + ["B", 70, 137, 0], + ["B", 71, 137, 0], + ["B", 72, 137, 0], + ["B", 73, 137, 0], + ["B", 74, 137, 0], + ["B", 75, 137, 0], + ["B", 76, 137, 0], + ["B", 77, 137, 0], + ["B", 78, 137, 0], + ["B", 79, 137, 0], + ["B", 80, 137, 0], + ["B", 81, 137, 0], + ["B", 82, 137, 0], + ["B", 83, 137, 0], + ["B", 84, 137, 0], + ["B", 85, 137, 0], + ["B", 86, 137, 0], + ["B", 87, 137, 0], + ["B", 88, 137, 0], + ["B", 89, 137, 0], + ["B", 90, 137, 0], + ["B", 91, 137, 0], + ["B", 92, 137, 0], + ["B", 93, 137, 0], + ["B", 94, 137, 0], + ["B", 95, 137, 0], + ["B", 96, 137, 0], + ["B", 97, 114, 0], + ["B", 98, 114, 0], + ["B", 99, 114, 0], + ["B", 100, 114, 0], + ["B", 101, 114, 0], + ["B", 102, 114, 0], + ["B", 103, 114, 0], + ["B", 104, 114, 0], + ["B", 105, 114, 0], + ["B", 106, 114, 0], + ["B", 107, 114, 0], + ["B", 108, 114, 0], + ["B", 109, 114, 0], + ["B", 110, 114, 0], + ["B", 111, 114, 0], + ["B", 112, 114, 0], + ["B", 113, 114, 0], + ["B", 114, 114, 0], + ["B", 135, 115, 0], + ["B", 136, 115, 0], + ["B", 137, 115, 0], + ["B", 138, 115, 0], + ["B", 139, 115, 0], + ["B", 140, 115, 0], + ["B", 141, 115, 0], + ["B", 142, 115, 0], + ["B", 143, 115, 0], + ["B", 144, 115, 0], + ["B", 145, 115, 0], + ["B", 146, 115, 0], + ["B", 147, 115, 0], + ["B", 148, 115, 0], + ["B", 149, 115, 0], + ["B", 150, 115, 0], + ["B", 151, 115, 0], + ["B", 152, 115, 0], + ["B", 153, 115, 0], + ["B", 154, 115, 0], + ["B", 155, 115, 0], + ["B", 156, 115, 0], + ["B", 157, 115, 0], + ["B", 158, 115, 0], + ["B", 159, 115, 0], + ["B", 160, 115, 0], + ["B", 161, 115, 0], + ["B", 162, 115, 0], + ["B", 163, 115, 0], + ["B", 164, 115, 0], + ["B", 165, 115, 0], + ["B", 166, 115, 0], + ["B", 167, 115, 0], + ["B", 168, 115, 0], + ["B", 169, 115, 0], + ["B", 170, 115, 0], + ["B", 171, 115, 0], + ["B", 172, 115, 0], + ["B", 173, 115, 0], + ["B", 174, 115, 0], + ["B", 175, 115, 0], + ["B", 176, 115, 0], + ["B", 177, 115, 0], + ["B", 178, 115, 0], + ["B", 179, 115, 0], + ["B", 180, 115, 0], + ["B", 181, 115, 0], + ["B", 182, 115, 0], + ["B", 183, 115, 0], + ["B", 184, 115, 0], + ["B", 185, 115, 0], + ["B", 186, 115, 0], + ["B", 187, 115, 0], + ["B", 188, 115, 0], + ["B", 189, 115, 0], + ["B", 190, 115, 0], + ["B", 191, 115, 0], + ["B", 192, 115, 0], + ["B", 193, 115, 0], + ["B", 194, 115, 0], + ["B", 195, 115, 0], + ["B", 196, 115, 0], + ["B", 197, 115, 0], + ["B", 198, 115, 0], + ["B", 199, 114, 0], + ["B", 200, 114, 0], + ["B", 201, 114, 0], + ["B", 202, 114, 0], + ["B", 203, 114, 0], + ["B", 204, 114, 0], + ["B", 205, 114, 0], + ["B", 206, 114, 0], + ["B", 207, 114, 0], + ["B", 208, 114, 0], + ["B", 209, 114, 0], + ["B", 210, 114, 0], + ["B", 211, 114, 0], + ["B", 212, 114, 0], + ["B", 213, 114, 0], + ["B", 214, 114, 0], + ["B", 234, 114, 0], + ["B", 235, 114, 0], + ["B", 236, 114, 0], + ["B", 237, 114, 0], + ["B", 474, 138, 0], + ["B", 475, 731, 360], + ["B", 503, 743, 371], + ["B", 504, 744, 372], + ["B", 505, 745, 373], + ["B", 506, 746, 374], + ["B", 507, 747, 375], + ["B", 508, 748, 376], + ["B", 509, 749, 377], + ["B", 510, 750, 378], + ["B", 511, 751, 391], + ["B", 512, 752, 392], + ["B", 513, 753, 393], + ["B", 514, 754, 394], + ["B", 515, 755, 395], + ["B", 516, 756, 396], + ["B", 517, 757, 397], + ["B", 518, 758, 398], + ["B", 521, 256, 299], + ["B", 526, 257, 299], + ["B", 533, 765, 411], + ["B", 534, 766, 412], + ["B", 535, 767, 413], + ["B", 536, 768, 414], + ["B", 537, 769, 415], + ["B", 538, 770, 416], + ["B", 539, 771, 417], + ["B", 540, 772, 418], + ["B", 559, 779, 431], + ["B", 560, 780, 432], + ["B", 561, 781, 433], + ["B", 562, 782, 434], + ["B", 563, 783, 435], + ["B", 564, 784, 436], + ["B", 565, 785, 437], + ["B", 566, 786, 438], + ["B", 571, 261, 303], + ["B", 575, 263, 303], + ["B", 576, 263, 303], + ["B", 601, 268, 304], + ["B", 602, 268, 304], + ["B", 622, 271, 305], + ["B", 624, 270, 305], + ["B", 627, 271, 305], + ["B", 629, 270, 305], + ["B", 630, 140, 0], + ["B", 635, 801, 491], + ["B", 636, 802, 492], + ["B", 637, 803, 493], + ["B", 638, 804, 494], + ["B", 639, 805, 495], + ["B", 640, 806, 496], + ["B", 641, 807, 497], + ["B", 642, 808, 498], + ["B", 661, 813, 511], + ["B", 662, 814, 512], + ["B", 663, 815, 513], + ["B", 664, 816, 514], + ["B", 665, 817, 515], + ["B", 666, 818, 516], + ["B", 667, 819, 517], + ["B", 668, 820, 518], + ["B", 673, 275, 308], + ["B", 678, 276, 308], + ["B", 684, 131, 114], + ["cleanup_tail", 0, 286, 279], + ["cleanup_tail", 1, 286, 279], + ["cleanup_tail", 2, 286, 279], + ["cleanup_tail", 3, 287, 280], + ["cleanup_tail", 4, 287, 280], + ["cleanup_tail", 5, 287, 280], + ["cleanup_tail", 6, 288, 279], + ["cleanup_tail", 7, 288, 279], + ["cleanup_tail", 8, 288, 279], + ["cleanup_tail", 9, 289, 281], + ["cleanup_tail", 10, 289, 281], + ["cleanup_tail", 11, 289, 281], + ["cleanup_tail", 12, 262, 1], + ["cleanup_tail", 13, 262, 1], + ["cleanup_tail", 14, 262, 1], + ["cleanup_tail", 15, 267, 1], + ["cleanup_tail", 16, 267, 1], + ["cleanup_tail", 17, 267, 1], + ["cleanup_tail", 18, 267, 1], + ["cleanup_tail", 19, 267, 1], + ["cleanup_tail", 40, 262, 1], + ["cleanup_tail", 41, 262, 1], + ["cleanup_tail", 42, 262, 1], + ["cleanup_tail", 43, 262, 1], + ["cleanup_tail", 44, 262, 1], + ["cleanup_tail", 45, 262, 1], + ["cleanup_tail", 46, 262, 1], + ["cleanup_tail", 53, 267, 1], + ["cleanup_tail", 54, 267, 1], + ["cleanup_tail", 67, 285, 1], + ["cleanup_tail", 68, 285, 1], + ["cleanup_tail", 69, 285, 1], + ["cleanup_tail", 77, 285, 1], + ["cleanup_tail", 78, 285, 1], + ["cleanup_tail", 112, 267, 1], + ["cleanup_tail", 113, 267, 1], + ["cleanup_tail", 114, 267, 1], + ["cleanup_tail", 115, 267, 1], + ["cleanup_tail", 118, 262, 1], + ["cleanup_tail", 119, 262, 1], + ["cleanup_tail", 120, 262, 1] + ] +} diff --git a/research/fresh-helper-boundary/FRONTIER-CHECKS.json b/research/fresh-helper-boundary/FRONTIER-CHECKS.json new file mode 100644 index 0000000000..df86354352 --- /dev/null +++ b/research/fresh-helper-boundary/FRONTIER-CHECKS.json @@ -0,0 +1,21 @@ +{ + "schema": "frontier-watch/1", + "started_utc": "2026-10-21T19:32:20Z", + "interval_minutes": 20, + "checks": [ + { + "utc": "2026-10-21T19:52:05Z", + "latest_pr": 4437, + "highest_conditional_claim_pr": 4416, + "kappa": "0.00268647", + "action": "No stronger new claim found. Continue from p7 and PR4433 tail theorem." + }, + { + "utc": "2026-10-21T20:12:23Z", + "latest_pr": 4442, + "highest_conditional_claim_pr": 4440, + "kappa": "0.00296", + "action": "Audited exact head 40e22a83; registered replay passed. Switched to the stronger query-thinned construction and combined the verified helper retiming. New result is in research/fresh-helper-thinned." + } + ] +} diff --git a/research/fresh-helper-boundary/NATIVE-RESULT.json.gz b/research/fresh-helper-boundary/NATIVE-RESULT.json.gz new file mode 100644 index 0000000000..e6fdb31624 Binary files /dev/null and b/research/fresh-helper-boundary/NATIVE-RESULT.json.gz differ diff --git a/research/fresh-helper-boundary/PROOF.md b/research/fresh-helper-boundary/PROOF.md new file mode 100644 index 0000000000..4fe9fa7eec --- /dev/null +++ b/research/fresh-helper-boundary/PROOF.md @@ -0,0 +1,224 @@ +# Proof and conditional transfer + +## 1. Boundary contract + +Use the source full-identity native unit with 632 independent persistent +fields: 224 main fields and 408 helpers. Its two orientations give the source +main shears, while every helper is autonomous in its own logical reference. +The separately owned C0 field is cleared before each use and at return. No +arbitrary persistent input is overwritten or cleared. + +A field at frame f has physical value `C_f z`, where z denotes its logical +value and `C_f` is the source canonical Fourier frame. At entry this means +`z=C_start^-1 x` for an arbitrary physical input x. It does **not** require +precomputing a Fourier transform of x for free. The helper's actual final +operator is `C_end C_start^-1`, not merely `C_end`. + +For nested frame spaces S0` and `F(.0027212601276)<0`. To establish a fixed-profile +ceiling, arithmetic.py encloses `sum (T_r-P_r) r^(1-C) log r` on each of 16 +closed intervals covering `[0,1/20]`, and proves a strictly positive lower +bound throughout. Thus F is strictly decreasing there. On 128 further closed +intervals covering `[1/20,1]`, it bounds F directly strictly below zero. These +are interval implications for every real C in the covered intervals, not +extrapolation from point samples. The positive rank-one surplus at C=0 then +gives the unique relevant crossing and excludes any later positive region. + +A chronological tensor power multiplies both moments. Paid completion of a +rank-K target by D axes changes its moment by `(K+D)^t-K^t <= D^t`, which is +at most the added paid charge. Splitting a paid job on disjoint axes increases +or preserves its t-charge. Hence tensoring, this paid completion and paid +splitting cannot pass the raw fixed-profile ceiling. This is not a ceiling +on different native profiles or other algorithms. + +## 5. Pay both strictification tails + +Let `C=.00272125`, `t=1-C`, `u=3/10`, `v=150`, `J=10^v` and `L=15^v`. +Use the chronological native product of PR4416 and PR4433, restoring every +whole-job matcher and center before resuming a suspended caller. The product +has target and paid moments `T_t^v` and `P_t^v`, respectively; it is a +substitution of whole array programs, not the tensor power of a sum. + +Canonicalize each complete raw job with both recorded monomial factors; these +need not be an inverse pair. Subsequent placement on specified disjoint axes +is coordinate conjugation. No raw Clifford endpoint is assumed conjugate to +a canonical Fourier transform merely because its rank agrees. + +After the product finishes, complete every productive rank KJ, its split charge is at most +`2 R J^-C <= 2 R^(t+u) J^-u`, since `t+u>=1`. A completion has charge below +`2 L J^-C`. Therefore the complete normalized paid moment is bounded by + +``` +alpha^v + 2 gamma^v + 2 delta^v, +alpha=P_t/T_t, +gamma=P_(t+u)/(10^u T_t), +delta=7688*15/(10^C T_t). +``` + +The interval engine certifies `alpha<1-16/10^9`, `gamma<911/1000` and +`delta<173/200`. Bernoulli's inequality and an exact rational power test give + +``` +1/(1+150*16/10^9) + 2*(911/1000)^150 + 2*(173/200)^150 < 1. +``` + +Both original tails and every completion are paid. The product ambient rank +is `m=121^150`, with no need to materialize its immense word. + +## 6. Uniform compiler, BIT and outer bill + +Use the inherited finite integer mixed-target compiler only after strict +separation. Its fields, source complements, owned centers, integral batching, +matcher restoration and final exits are those of the specified new unit. +The new logarithmic majorant of PR4433 applies with `theta=6/7` and power 13: +`10^7<15^6`, `2*(10^150)^7 <= (121^150)^6`, and +`eta=t*121^(-150*C) > theta^13`. Its base-range condition is checked as well. +For declared `kappa=.00272124`, put `d=(C-kappa)/7=1/700000000` and uniform +saving `C-d`. The explicit integer comparison at `H=349300000000` is + +``` +(H+1)^13 < 2^499, d*H=499. +``` + +It specifies a finite uniform supplier at `N=2^H` with the required strict +saving. The instruction list and integer width B_N are generated by the +source finite algorithm rather than emitted here. + +The source BIT all-size parameter proof gives, before its last relaxation, +`(1-.003)*.00275 + .003*.0000384599 = .0027418653797`. Admit this unchanged +supplier at `.00273`; both the atom/adapter and borrowed-stock inequalities +remain strict. No BIT native word, cover or precision premise is weakened. +The old `.0027` relaxation fails the new outer bill and is a rejection control. + +Set `b=kappa+5d`, `a=kappa+4d`, `q=kappa+3d`, `epsilon=1-d`, `beta=1-3d`, +`r0=d/10`, `stop=d` and `layout=d`. The complete retained ledger recomputes all +nine cost rows, 54 current strict predicates and three functional guards. +Every one is strictly positive at this point. Closed uniform/epsilon gaps, +the insufficient old BIT relaxation and the unfunded tested endpoint fail. + +## 7. Costs and the precise conditional boundary + +Replace the old finite-unit constants by counts of the actual new word: +3363 paid local calls, the complete unchanged scalar lists and coefficients, +new serialized monomial/phase generators, 632 persistent fields and one owned +C0, all 408 helper normalizers, the unchanged p7 bridges and whole idles, the +150-fold chronological substitution, every completion and split, and finally +every integer-compiler unit, route, owned bank and rank-one leaf. A literal +finite recursive enumeration defines their counts and coefficient heights; +no p3 raw count is substituted for the compiled word. The new transport and +helper recipes are available explicitly in NATIVE-RESULT.json.gz. Internal +normalizers are restored before resuming a caller. + +Apply the source finite-template precision and stock argument with these new +constants. The native fixed coefficients and generators are finite, semantic +prefix bounds are rechecked, and all changed movement/scalar/normalizer work +enters the finite constants. The positive outer spare powers absorb those +constants after an effective threshold, under the inherited semantic, +all-column, physical primitive and fixed-tape hypotheses. This is the same +conditional transfer mechanism used by PR4416/4433, not a proof that local +savings are automatically a multiplication theorem. + +Analytic decomposition, permitted physical movement and whole-job frame +realization, source all-column correctness, finite-template closure, fine-prime +padding, fixed-tape execution and exact recovery remain stated source premises. +There is no formal verification or independent human mathematical review of +the complete theorem, no practical implementation claim, and no selected-result +change. Source files and contributor attribution are retained. diff --git a/research/fresh-helper-boundary/README.md b/research/fresh-helper-boundary/README.md new file mode 100644 index 0000000000..cbcfab9ccd --- /dev/null +++ b/research/fresh-helper-boundary/README.md @@ -0,0 +1,155 @@ +# Conditional κ = 0.00272124 from fresh-helper boundary retiming + +This changes the complete native p7 paid profile and proposes + +``` +T(n) = O(n (log n)^(1 - 0.00272124)). +``` + +The conditional saving exceeds [PR4416](https://github.com/CrocSwap/integer-mult-bounds/pull/4416)'s +`0.00268647` by **0.00003477 (about 1.2943%)**, and the pinned selected +`0.0023` by **18.31%**. This is a conditional construction submitted for review; +it does not change the selected record or establish an unconditional theorem. + +The new lever is to optimize helper entrances and exits for **fresh independent +helper inputs**, rather than retain frames selected for a hosted owner fill. +Changing those boundaries together with scalar contact frames saves recursive +calls without changing the scalar order, coefficients, main operator, warp +contacts or owned center program. The exact finite patch changes **117 helper +entrances, 42 helper exits and 395 scalar contact frames**. + +| Complete raw p7 invoice | PR4416 | This construction | +| --- | ---: | ---: | +| Independent productive fields | 7,688 | 7,688 | +| Paid calls | 55,998 | **53,133** | +| Productive rank mass | 131,723 | 133,718 | +| Paid rank mass | 131,115 | 133,110 | +| Rank-one surplus | 608 | 608 | +| Proposed conditional κ | 0.00268647 | **0.00272124** | + +The call reduction is **2,865 (about 5.12%)**. These are finite instruction +counts, not measured runtime speedups. The changed masses illustrate why +counting calls or rank-one mass alone does not establish the saving: the exact +concave moment and complete consumer are checked separately. + +## Native unit and exact evidence + +For each forward or backward local invocation, the new productive helper +profile and complete paid profile are + +``` +H = {4:26, 5:2, 7:29, 8:42, 9:309}, +P = {1:2253, 2:515, 3:445, 4:102, 5:40, 8:8}. +``` + +Every one of the 408 helpers has an independent arbitrary input. The center +remains separately owned, explicitly cleared, reused and uncredited. The +source p7 controller is unchanged: `pairs=7, keep_idle_mask=232127`. Its full +rational Laurent word is replayed; all 2,688 main idle calls are retained. +The complete new raw profiles are + +``` +T = {4:390, 5:30, 7:435, 8:630, 9:4635, + 25:448, 41:448, 57:448, 121:224}, +P = {1:33795, 2:7725, 3:6675, 4:1530, 5:600, + 8:1464, 16:448, 32:448, 48:448}. +``` + +[PROOF.md](PROOF.md) proves the retiming equivalence and explains the complete +transfer. [CHANGES.json](CHANGES.json) is the explicit circuit patch; +`native.py` resynthesizes every transport and replays both orientations on all +632 arbitrary inputs using two retained literal interpreters. All new transport +edges and every distinct helper boundary are independently lowered and decoded +as exact Clifford operations, including their absolute phase. Unchanged +transport phase evidence and the original all-column/native model remain +inherited source premises. + +`arithmetic.py` uses the unchanged interval engine of +[PR4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433). It certifies + +``` +0.0027212601275 < fixed-profile mixed root < 0.0027212601276. +``` + +An interval argument covers all real `0 0 and margin(ROOT_HIGH)[1] < 0, 'Certified changed-profile root bracket') + need(KAPPA < TESTED < ROOT_LOW, 'Strict supplier and outer headroom') + # An interval proof over real C, rather than signs only at a finite mesh. + signed = {r: targets[r]-paid[r] for r in targets.keys() | paid.keys()} + derivative_lower = None + for i in range(16): + left, right = Q(i, 320), Q(i+1, 320) + lower = Q(0) + for r, count in signed.items(): + power = E.power(r, 1-right if count > 0 else 1-left) + term = E.mul(power, E.log_bounds(r)) + lower += count*term[0 if count > 0 else 1] + derivative_lower = lower if derivative_lower is None else min(derivative_lower, lower) + need(derivative_lower > 0, 'Moment is strictly decreasing on [0,1/20]') + negative_upper = None + for i in range(128): + left, right = Q(1,20)+Q(19*i,2560), Q(1,20)+Q(19*(i+1),2560) + upper = sum(count*E.power(r, 1-left if count > 0 else 1-right)[1 if count > 0 else 0] + for r, count in signed.items()) + negative_upper = upper if negative_upper is None else max(negative_upper, upper) + need(negative_upper < 0, 'Every C in [1/20,1] has negative moment') + t, v, c, b, u = 1-TESTED, 150, 10, 15, Q(3,10) + target = E.moment(targets, t) + alpha = E.divide(E.moment(paid,t), target) + gamma = E.divide(E.moment(paid,t+u), E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(targets.values())*b),)*2, E.mul(E.power(c,TESTED),target)) + limits = (1-Q(16,10**9), Q(911,1000), Q(173,200)) + for bounds, limit in zip((alpha,gamma,delta),limits): + need(0 < bounds[0] <= bounds[1] < limit < 1, 'Certified complete tail limit') + a, g, d = limits + normalized_upper = 1/(1+v*(1-a))+2*g**v+2*d**v + need(normalized_upper < 1, 'All product, original paid tail and padding charges fit') + need(1 < c < b < 121 and t+u >= 1, 'Strictification hypotheses') + # PR4433's logarithmic majorant, rebound to this changed complete invoice. + theta, power = Q(6,7), 13 + eta = E.scale(E.exp_interval(E.scale(E.log_bounds(121),-v*TESTED)),t) + need(10**7 < 15**6 and 2*(10**v)**7 <= (121**v)**6, 'Actual exit cutoff and shifted logarithm') + need(eta[0] > theta**power, 'Strict exit versus complement contraction') + need(E.exp_interval(E.scale(E.log_bounds(121),v*TESTED))[1] < 2**power, 'Full initial rank range') + gap = (TESTED-KAPPA)/7 + need(gap.numerator == 1, 'Explicit integer grid for the uniform rank') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + lo, hi = 1, 2 + while not wins(hi): + lo, hi = hi, 2*hi + while hi-lo > 1: + mid = (hi+lo)//2 + if wins(mid): hi = mid + else: lo = mid + H = step*hi + need(H > 7*v and wins(hi) and not wins(hi-1), 'Strict finite uniform-rank integer test') + # The original BIT proof already supplies the stronger, unrelaxed value. + bit = native.read(ROOT/'research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json') + bit_raw = (1-Q(bit['atom_power']))*Q(bit['C1_after_cover'])+Q(bit['atom_power'])*Q(bit['old_ordinary_saving']) + bit_admitted = Q('.00273') + need(bit_raw == Q(bit['ordinary_saving_before_final_relaxation']) > bit_admitted > KAPPA, 'Retain the existing stronger BIT conversion') + need(Q(bit['atom_power']) > bit_raw and 1-bit_raw-Q(bit['atom_power']) > 0, 'Both BIT adapter/stock gaps') + O = native.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'fresh_boundary_outer') + params = {'kappa': KAPPA, 'tested_saving': TESTED, + 'complex_uniform_saving': KAPPA+6*gap, 'b': KAPPA+5*gap, + 'a': KAPPA+4*gap, 'q': KAPPA+3*gap, 'bit_saving': bit_admitted, + 'epsilon': 1-gap, 'beta': 1-3*gap, 'r0': gap/10, + 'stop': gap, 'layout': gap, 'd': gap} + outer = O.ledger(params) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 3, 'Complete consumer predicate inventory') + need(all(value > 0 for group in ('strict_checks','functional_checks') for value in outer[group].values()), 'Every inherited consumer predicate') + controls = {} + for label, patch in [('old_BIT_relaxation', {'bit_saving': Q('.0027')}), + ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('closed_epsilon', {'epsilon': Q(1)}), + ('unfunded_outer', {'kappa': TESTED})]: + bad = O.ledger(dict(params,**patch)) + failed = [key for key,value in bad['strict_checks'].items() if value <= 0] + need(failed, 'Reject '+label); controls[label] = failed + return encode({'status':'PASS_CHANGED_NATIVE_PROFILE_STRICTIFICATION_AND_COMPLETE_OUTER', + 'kappa':KAPPA, 'tested_saving':TESTED, 'gain_over_PR4416':KAPPA-PREVIOUS, + 'relative_gain_over_PR4416':(KAPPA-PREVIOUS)/PREVIOUS, + 'targets':dict(sorted(targets.items())), 'paid':dict(sorted(paid.items())), + 'productive_fields':sum(targets.values()), 'paid_calls':sum(paid.values()), + 'root_bracket':[ROOT_LOW,ROOT_HIGH], 'headroom_from_declared_to_root':[ROOT_LOW-KAPPA,ROOT_HIGH-KAPPA], + 'fixed_profile_ceiling':{'decreasing_C_interval':['0','1/20'], + 'negative_derivative_upper':E.display((-derivative_lower,)*2), + 'remaining_C_interval':['1/20','1'], 'negative_moment_upper':E.display((negative_upper,)*2)}, + 'strictification':{'tensor_power':v,'cutoff_base':c,'target_floor_base':b,'tail_offset':u, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta), + 'rational_upper_limits':limits, 'normalized_paid_upper':normalized_upper, + 'gap':E.display((1-normalized_upper,)*2)}, + 'compiler':{'theta_upper':theta,'logarithm_power':power,'eta':E.display(eta), + 'uniform_saving':params['complex_uniform_saving'],'gap':gap,'H':H, + 'N':'2^'+str(H), 'integer_test_exponent':hi, 'word_materialized':False}, + 'BIT':{'inherited_unrelaxed_saving':bit_raw,'admitted':bit_admitted,'gap':bit_raw-bit_admitted}, + 'outer':outer, 'negative_controls':controls}) + +if __name__ == '__main__': + result = run(native.read(HERE/'NATIVE-RESULT.json.gz')) + (HERE/'ARITHMETIC-RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({k:result[k] for k in ('status','kappa','gain_over_PR4416','root_bracket','compiler')},sort_keys=True)) diff --git a/research/fresh-helper-boundary/discover-cut.cpp b/research/fresh-helper-boundary/discover-cut.cpp new file mode 100644 index 0000000000..5caa077ea0 --- /dev/null +++ b/research/fresh-helper-boundary/discover-cut.cpp @@ -0,0 +1,35 @@ +// Optional floating-point discovery, never a proof checker. Apache-2.0. +// Prepared with substantial OpenAI Codex assistance. +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +struct Arc{int v,rev;double cap;}; +struct Flow{vector> a;vector level,ptr;Flow(int n):a(n),level(n),ptr(n){};void edge(int u,int v,double c){Arc x{v,int(a[v].size()),c},y{u,int(a[u].size()),0};a[u].push_back(x);a[v].push_back(y);}double send(int u,int t,double f){if(u==t)return f;for(int&i=ptr[u];i1e-8&&level[e.v]==level[u]+1){double z=send(e.v,t,min(f,e.cap));if(z>1e-8){e.cap-=z;a[e.v][e.rev].cap+=z;return z;}}}return 0;}vectorcut(int s,int t){while(true){fill(level.begin(),level.end(),-1);queueq;level[s]=0;q.push(s);while(!q.empty()){int u=q.front();q.pop();for(auto e:a[u])if(e.cap>1e-8&&level[e.v]<0){level[e.v]=level[u]+1;q.push(e.v);}}if(level[t]<0){vectorv(level.size());for(int i=0;i=0;return v;}fill(ptr.begin(),ptr.end(),0);while(send(s,t,1e15)>1e-8){}}}}; +struct Node{bool mut;int oldf,newf;}; +int main(int argc,char**argv){if(argc!=3){cerr<<"usage: discover-cut entry|exit output-file"<>F>>N>>E;vectordim(F);vector>space(F);for(int f=0;f>dim[f];for(auto&x:space[f])cin>>x;}vector>sub(F,vector(F,true));for(int i=0;inodes(N);vectoridx(N,-1),rev;for(int i=0;i>m>>nodes[i].oldf>>nodes[i].newf;nodes[i].mut=m;if(m){idx[i]=rev.size();rev.push_back(i);}}vector>edges(E);for(auto&[a,b]:edges)cin>>a>>b; + int H;cin>>H;vector>helpers(H);for(auto&[i,f]:helpers)cin>>i>>f; + vectorcandidates;for(int f=0;funary(V,0);int s=V,t=V+1; + for(auto[a,b]:edges){int fa=nodes[a].newf,fb=nodes[b].oldf;double e0=powers[dim[fb]-dim[fa]];int i=idx[a],j=idx[b]; + double e10=sub[g][fb]?powers[dim[fb]-dim[g]]:INF;double e01=sub[fa][g]?powers[dim[g]-dim[fa]]:INF; + if(i>=0&&j>=0){double w=e10+e01-e0;if(w<-1e-7){cerr<<"nonsubmodular"<=0)unary[i]+=e10-e0;else if(j>=0)unary[j]+=e01-e0; + } + for(auto[i,f]:helpers){int old=nodes[i].newf;double delta=(entry?(sub[g][f] && dim[g]dim[f]))?(entry?powers[dim[f]-dim[old]]-powers[dim[f]-dim[g]]:powers[dim[old]-dim[f]]-powers[dim[g]-dim[f]]):INF;unary[idx[i]]+=delta;} + for(int i=0;i=0&&reach[idx[a]]?g:fa,gb=idx[b]>=0&&reach[idx[b]]?g:fb;if(!sub[ga][gb]){legal=false;break;}delta+=powers[dim[gb]-dim[ga]]-powers[dim[fb]-dim[fa]];} + for(auto[i,f]:helpers)if(reach[idx[i]]){int old=nodes[i].newf;if(entry?(!sub[g][f]||dim[g]>=dim[f]):(!sub[f][g]||dim[g]<=dim[f])){legal=false;break;}delta+=entry?powers[dim[f]-dim[old]]-powers[dim[f]-dim[g]]:powers[dim[old]-dim[f]]-powers[dim[g]-dim[f]];} + if(legal&&delta < -1e-8){int count=0;for(int i=0;i=-1e-8){cerr<<"NO_GAIN round "<= 224: + continue + out.append(e) + for r, f in enumerate(c['final']): + climb(r, f) + return out + +def run(changes=None, phase_check=True): + c = read(BASE/'THREE-base-FULL-IDENTITY-CANONICAL.json.gz') + original = read(BASE/'THREE-base-FULL-IDENTITY-NATIVE.json.gz') + changes = read(HERE/'CHANGES.json') if changes is None else changes + for key, frame_key in (('entrances', 'start'), ('exits', 'final')): + seen = set() + for role, old, new in changes[key]: + need(role not in seen and 224 <= role < 632 and c[frame_key][role] == old, 'Bound unique helper boundary') + seen.add(role); c[frame_key][role] = new + maps = {d: gates(p) for d, p in original.items()} + need(set(maps['forward']) == set(maps['backward']), 'Both scalar orientations have the same contact inventory') + for key in maps['forward']: + f = original['forward'][maps['forward'][key]] + b = original['backward'][maps['backward'][key]] + need(b[1] == dual(f[1]) and b[2] == f[2], 'Actual inverse-transpose scalar correspondence') + changed = deepcopy(original) + seen = set() + for phase, ordinal, old, new in changes['gates']: + key = (phase, ordinal) + need(key not in seen and key in maps['forward'], 'Bound unique retimed scalar contact') + seen.add(key) + for d in changed: + e = changed[d][maps[d][key]] + need(e[2] == old, 'Original scalar frame pin') + e[2] = new + programs = {d: synthesize(c, p) for d, p in changed.items()} + V = load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py', 'fresh_boundary_rows') + X = load(ROOT/'research/kappa-rebuild/complex/native_extensions.py', 'fresh_boundary_literal') + checks = {} + profiles = {} + for d, p in programs.items(): + rows, receipt = X.literal_replay(V, c, p, d == 'backward') + for r in range(632): + need(rows['L', r] == V.expected(('L', r), [], d == 'backward', False), 'Every actual arbitrary-input endpoint, role '+str(r)) + profiles[d] = Counter({int(k): v for k, v in receipt['paid_profile'].items()}) + rebound = deepcopy(c) + rebound['local_profile'] = dict(profiles[d]) + receipt['second_literal'] = V.replay(p, rebound, [], d == 'backward', False) + checks[d] = receipt + need(profiles['forward'] == profiles['backward'], 'Same complete native tariff in both orientations') + H = Counter() + for r in range(224, 632): + a, b = c['start'][r], c['final'][r] + need(span(c['frames'][a]) <= span(c['frames'][b]), 'Nested productive helper boundary') + width = len(c['frames'][b])-len(c['frames'][a]) + need(width > 0, 'Every declared helper is independently productive') + H[width] += 1 + physical = [] + if phase_check: + ce = load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py', 'fresh_boundary_clifford') + P = load(ROOT/'research/kappa-function-composition/complex/prune_native.py', 'fresh_boundary_lowering') + N = X.N + old_edges = {(e[3], e[4]) for e in original['forward'] if e[0] == 'climb'} + new_edges = {(e[3], e[4]) for e in programs['forward'] if e[0] == 'climb'} + helper_edges = {(c['start'][r], c['final'][r]) for r in range(224, 632)} + for a, b in sorted((new_edges-old_edges) | helper_edges): + op = ce.canonical_frame(9, c['frames'][a]).adjoint().then(ce.canonical_frame(9, c['frames'][b])) + want = len(c['frames'][b])-len(c['frames'][a]) + directions = {} + for d in ('forward', 'backward'): + actual = P.conjugate(ce, op) if d == 'backward' else op + rec = N.lower_exact(P, ce, actual) + need(rec['rank'] == want, 'New physical Fourier rank including phase') + directions[d] = rec + physical.append({'old': a, 'new': b, 'rank': want, 'recipes': directions}) + return {'status': 'PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS', + 'helpers': dict(sorted(H.items())), 'paid': dict(sorted(profiles['forward'].items())), + 'changed_entrances': len(changes['entrances']), 'changed_exits': len(changes['exits']), + 'changed_scalar_frames': len(changes['gates']), 'native': checks, + 'new_physical_edges_and_boundaries': physical}, c, programs + +if __name__ == '__main__': + import argparse + p = argparse.ArgumentParser(); p.add_argument('--skip-phase', action='store_true'); p.add_argument('--write-result', action='store_true'); args = p.parse_args() + result, _, _ = run(phase_check=not args.skip_phase) + if args.write_result: + need(not args.skip_phase, 'Do not replace a complete phase receipt with a diagnostic') + (HERE/'NATIVE-RESULT.json.gz').write_bytes(gzip.compress((json.dumps(result, indent=2, sort_keys=True)+'\n').encode(),mtime=0)) + print(json.dumps({k: v for k, v in result.items() if k not in ('native', 'new_physical_edges_and_boundaries')}, sort_keys=True)) diff --git a/research/fresh-helper-boundary/verify.py b/research/fresh-helper-boundary/verify.py new file mode 100644 index 0000000000..e434dbf7c6 --- /dev/null +++ b/research/fresh-helper-boundary/verify.py @@ -0,0 +1,99 @@ +"""Replay the changed native unit and its conditional multiplication endpoint. + +Standard library only. Apache-2.0; substantial OpenAI Codex assistance. +""" +import argparse +import gzip +from copy import deepcopy +from hashlib import sha256, sha1 +import json +from pathlib import Path +import native +import arithmetic + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + +def need(ok, why): + if not ok: + raise ValueError(why) + +def authenticate(): + manifest = native.read(HERE/'SOURCES.json') + seen = set() + for row in manifest['files']: + if row['usage'] != 'input': + continue + path = Path(row['path']) + need(not path.is_absolute() and '..' not in path.parts and str(path) not in seen, 'Canonical unique input') + seen.add(str(path)) + actual = ROOT + for part in path.parts: + actual /= part + need(not actual.is_symlink(), 'No source alias') + data = actual.read_bytes() + need(sha256(data).hexdigest() == row['sha256'], 'Changed source: '+str(path)) + need(sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == row['git_blob'], 'Changed source Git blob') + return len(seen) + +def controls(result, c, programs): + # This is a literal original-word control, not a second mathematical review. + baseline, _, _ = native.run({'entrances':[], 'exits':[], 'gates':[]}, phase_check=False) + need(baseline['helpers'] == {5:28,6:18,7:56,8:93,9:213}, 'Recover the actual predecessor helper profile') + need(baseline['paid'] == {1:2487,2:713,3:224,4:102,5:20,8:8}, 'Recover the actual predecessor paid profile') + V = native.load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py','boundary_control_rows') + rebound = deepcopy(c); rebound['local_profile'] = result['paid'] + bad = deepcopy(programs['forward']) + bad.pop(next(i for i, e in enumerate(bad) if e[0] == 'center')) + rejected = False + try: + V.replay(bad, rebound, [], False, False) + except (ValueError, AssertionError): + rejected = True + need(rejected, 'A missing paid center is rejected at the actual frame contact') + # A pure global-phase corruption has an unchanged Pauli tableau. + ce = native.load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py','boundary_control_phase') + P = native.load(ROOT/'research/kappa-function-composition/complex/prune_native.py','boundary_control_decode') + row = result['new_physical_edges_and_boundaries'][0] + rec = deepcopy(row['recipes']['forward']) + def decode(r): + left = P.monomial(ce, r['left'],9) + if r['rank']: + return P.monomial(ce,r['right'],9).then(ce.fourier(9,range(r['rank']))).then(left) + return left + original = decode(rec) + rec['left']['phase'] = (rec['left']['phase']+1)%4 + changed = decode(rec) + need(changed.tab == original.tab and changed.zero_state() != original.zero_state(), 'Absolute phase corruption is detected beyond tableau equality') + return {'predecessor_recovered':True,'omitted_center_rejected':True,'global_phase_only_corruption_rejected':True} + +def verify(write=False): + count = authenticate() + result, c, programs = native.run() + math = arithmetic.run(result) + checks = controls(result,c,programs) + artifacts = {'NATIVE-RESULT.json.gz': result, 'ARITHMETIC-RESULT.json': math} + for name, value in artifacts.items(): + normalized = json.loads(json.dumps(value)) + if write: + data = (json.dumps(normalized,indent=2,sort_keys=True)+'\n').encode() + (HERE/name).write_bytes(gzip.compress(data,mtime=0) if name.endswith('.gz') else data) + else: + need(normalized == native.read(HERE/name), 'Exact receipt replay: '+name) + receipt = {'status':'PASS_FRESH_HELPER_BOUNDARY_CONDITIONAL_KAPPA', + 'kappa_decimal':'0.00272124', 'source_inputs':count, + 'physical_edges_and_boundaries':len(result['new_physical_edges_and_boundaries']), + 'changed_entrances':result['changed_entrances'], 'changed_exits':result['changed_exits'], + 'changed_scalar_frames':result['changed_scalar_frames'], + 'controls':checks, 'scientific_receipts':{name:sha256(gzip.decompress((HERE/name).read_bytes()) if name.endswith('.gz') else (HERE/name).read_bytes()).hexdigest() for name in artifacts}} + if write: + (HERE/'RESULT.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + else: + need(receipt == native.read(HERE/'RESULT.json'), 'Final checked receipt') + return receipt + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--write-receipts', action='store_true', help='Author receipts explicitly; ordinary replay does not write.') + args = parser.parse_args() + print(json.dumps(verify(args.write_receipts),sort_keys=True)) diff --git a/research/fresh-helper-thinned/AUDIT-4440.md b/research/fresh-helper-thinned/AUDIT-4440.md new file mode 100644 index 0000000000..64c4a98675 --- /dev/null +++ b/research/fresh-helper-thinned/AUDIT-4440.md @@ -0,0 +1,44 @@ +# Audit of PR4440 at 40e22a83ed660d3d6074c4f2dbf14bfb621eee51 + +The 20:12 UTC frontier check found PR4440's conditional 0.00296 above the first +helper-retiming result. Work switched to that source. Its complete registered +Python 3.12.15 replay passed before this combination was developed. Normal +combined replay repeats its full verifier and compares its saved receipt. + +No blocking defect was found **under its stated native, arbitrary-column, +owned-erasure and transfer contracts**. This is an AI-assisted source/proof +and finite-replay audit, not independent human or formal theorem acceptance. + +- **Paid query primitive.** Clear an owned stream, copy the donor, pay one + rank-one Q or Q^-1 job, add/subtract into the target, and erase only the owned + stream. The donor is retained; copied data create no productive input. + The inverse complex Gaussian is normalized with its actual Pauli translation, + not an order-two assumption. Literal arbitrary X/Y/Z columns reject omitted + clear/erase steps. Arbitrary-column physical lowering and owned erasure remain + explicit retained contracts rather than consequences of the finite test. +- **Actual controller.** Rational Laurent and binary coefficient checks replay + every emitted LOCAL, QUERY_SHEAR, IDLE, bridge and boundary program. Replacing + even stages also removes exactly those stage factors from idle operators and + target monomials. Lost helper inventories are charged. A wrong query direction + or altered coefficient changes the checked operator. +- **Native geometry.** Complex forward/inverse contact phases use the same + old-nine/fresh-eight chart on all 112 ports; the central q is fixed. Removing + inactive spectator blocks does not remove an active transform. BIT separately + checks all 111 rational charts and the original native child/copy bills. +- **Chronology and owners.** Full calls return their center before the next + query call. The one sequential owned stream can be reused at raw level; + nested products allocate the distinct centers required by suspended callers. + All full-call helpers are fresh independent fields. No copy, center or inactive + stage receives productive credit. +- **Complete costs.** The literal and closed-form invoices agree. Paid products, + completion and splitting charge both tails; the strict compiler is used only + after separation. The stronger BIT conversion pays its delayed cover fallback + and changes its atom power to 0.004; retaining 0.003 fails the adapter comparison. + Nine outer rows, 54 predicates and four guards are recomputed, with controls. +- **Limits.** The huge winning words and widths are finite algorithmic + specifications. Source all-column, owned-erasure, legal matcher, tape, + precision, analytic and recovery obligations remain conditional. + +The combination below makes no edit to PR4440. Its full and query main operators +stay fixed. It replaces only each full unit by an all-input-equivalent native +unit, then independently rebuilds the complete paid/productive invoice. diff --git a/research/fresh-helper-thinned/PROOF.md b/research/fresh-helper-thinned/PROOF.md new file mode 100644 index 0000000000..bf68dc2b98 --- /dev/null +++ b/research/fresh-helper-thinned/PROOF.md @@ -0,0 +1,132 @@ +# Conditional combination proof + +## 1. Exact unit substitution + +Use the source full-identity main shears and autonomous helpers in both +orientations. The retiming lemma of `fresh-helper-boundary/PROOF.md` changes +helper entrance/exit gauges and scalar contact frames while preserving every +logical row, main boundary, warp contact, scalar order/coefficient and owned +center. Both actual native words are replayed on all 632 arbitrary input +columns; 320 distinct new transport edges/helper boundaries are lowered and +decoded with absolute phase. Every helper boundary is normalized with its +recorded input and output monomials around the complete local job. These +factors need not be an inverse pair. + +Consequently a full LOCAL call in PR4440's complex word can be replaced by +this unit without changing its physical main operator. Allocate its 408 fresh +helper fields on the same distinct owner slots. Their new target profile is +`{4:26,5:2,7:29,8:42,9:309}` and paid profile is +`{1:2253,2:515,3:445,4:102,5:40,8:8}`. Each center remains owned and uncredited. +The same formal gauge equivalence applies under the retained all-column block +lifts; no sum of operators is tensor-powered. + +The source p17 controller has 19 full calls and 16 copied query shears. Every +thin query, full-call phase contact, main boundary and whole idle is unchanged. +The copied-query primitive and its zero/erase and physical Q contracts are +those audited in AUDIT-4440.md. Substitution therefore preserves the entire +main word. The normal verifier freshly executes both source verifiers before +using this implication. + +## 2. Entire changed invoice + +Count the actual emitted source events. Each LOCAL contributes one new H and +P; each QUERY_SHEAR contributes 112 paid rank-one jobs and no productive field; +each nonzero IDLE contributes 224 jobs of rank eight times its listed active +stage count. Each actual main diagonal monomial contributes 112 independent +rank `1+8*number_of_active_stages` fields. This gives + +``` +T={4:494,5:38,7:551,8:798,9:5871,17:448,25:448,33:448, + 41:448,49:448,57:448,65:448,73:448,153:224}, +P={1:44599,2:9785,3:8455,4:1938,5:760,8:152,16:448, + 24:448,32:448,40:448,48:448,56:448,64:448,72:448}. +``` + +There are 11,560 independent productive fields, 69,273 paid calls and rank +masses 260,798 and 259,998. Surplus 800 is preserved. An independent subtraction +of nineteen old helper/paid inventories and addition of nineteen new ones to +the source invoice must agree exactly with these event counts. + +At C=.003001052 the strict raw moment is checked by two rational interval +engines. Root signs at .0030010541830 and .0030010541834 enclose the new root. +As in the source helper package, interval derivatives prove strict decrease +on [0,1/20], and 128 closed interval enclosures exclude any positive moment on +[1/20,1]. This is a fixed-profile ceiling, not a global optimum. Chronological +products multiply the moments; paid completion loses moment by concavity and +splitting increases paid charge. Those operations cannot beat this raw ceiling. + +## 3. Pay both tails and specify a finite uniform rank + +Use t=1-C, u=1/5, v=1024, cutoff J=20^v and floor L=21^v. Apply the source +chronological product and whole-job completion/splitting algorithm, preserving +all spectators, restored matchers, distinct productive fields and owned banks. +Exactly the same charged theorem bounds the normalized paid moment by + +``` +alpha^v + 2 gamma^v + 2 delta^v, +alpha=P_t/T_t, +gamma=P_(t+u)/(20^u*T_t), +delta=11560*21/(20^C*T_t). +``` + +The new exact limits are `alpha<1-10^-9`, `gamma<97/100`, `delta<19/20`. +The old gamma limit 31/32 fails on this changed invoice and is explicitly +rejected. Both new tail limits to power 128 are strictly below 1/16. Hence +both tails at v=1024 are below 2^-32, and the exact rational inequality is + +``` +1/(1+1024/10^9) + 4/2^32 < 1. +``` + +Every completion and original paid tail is included. Final paid ranks are +at most 20^v and every productive target is at least 21^v. The maximum target +and ambient rank is m=153^v. + +Use PR4433's general logarithmic majorant, not an uncharged direct compiler. +Put theta=63/64 and p=1000. Check `20^64<21^63`, +`2*(20^v)^64 <= (153^v)^63`, and `eta=t*153^(-v*C)>theta^1000`. +The complete base range satisfies `153^(v*C)<2^1000` as well. These are precisely +the shifted exit, complement and base-range hypotheses of that majorant. + +For declared kappa=.00300105, set d=(C-kappa)/7=1/3500000000 and uniform +saving C-d. Let H be the reported multiple of 3500000000 satisfying +`(H+1)^1000 < 2^(d*H)`, and reject the previous grid point. RESULT.json +records the exact integers, giving the explicit sufficient rank N=2^H. +The source integer mixed flow supplies its integral widths, complements, owned +centers and exit jobs. The massive word is algorithmically specified, not emitted. + +## 4. Nonrecursive work, BIT and outer bill + +The complete local scalar lists retain the checked maximum allowance 158,168. +Bound each paid-job and helper monomial pair by 1000 elementary fixed +nine-coordinate records: Gaussian elimination, swaps, quadratic/linear phases, +offsets and global phase fit this conservative bound. The resulting local +scalar plus route allowance is below 10^7. The remaining 240 fixed warp +events and 448 main boundary adapters contribute fewer than 688,000 further +elementary records, also within that 10^7 local budget. Nineteen such units, all source query +records, bridges, boundary words and fixed chart records fit the retained raw +10^9 record bound; the verifier checks that larger substituted allowance. + +Update every product/compiler count from this actual word. The source finite +record bound and precision/stock prescription include the new normalizers, +every paid query and copied stream, all completions/splits, source complements, +owned banks, routes and rank-one leaves. No small predecessor constant is +substituted for the final compiled word. Fixed constants are absorbed only +through the positive spare powers of the inherited conditional transfer. + +Retain PR4440's entire BIT construction: pre-cover saving .003459, covered +saving .00345 and atom power .004. Its ordinary saving is .0034363538396, +admitted at .0034, strictly above the new complex endpoint. Its adapter, stock, +cover, owned queries and effective compiler remain unchanged. Normal replay +freshly checks that complete source construction. + +Set b=kappa+5d, a=kappa+4d, q=kappa+3d, epsilon=1-d, beta=1-3d, +r0=d/10 and stop=layout=d. Recompute all nine outer rows, 54 strict predicates +and four functional guards, including the actual new BIT atom. Every check +passes. Old BIT admission, a closed uniform/epsilon gap and the unfunded tested +endpoint are rejected. + +The source arbitrary-column native, owned-erasure, permitted physical matching, +finite-template precision, analytic decomposition, fixed-tape, prime and exact +recovery contracts remain conditional premises. These finite exact checks are +not formal verification or independent human acceptance of the complete theorem. diff --git a/research/fresh-helper-thinned/README.md b/research/fresh-helper-thinned/README.md new file mode 100644 index 0000000000..344616d665 --- /dev/null +++ b/research/fresh-helper-thinned/README.md @@ -0,0 +1,92 @@ +# Conditional κ = 0.00300105: fresh helper retiming on query-thinned controllers + +This builds on the stronger [PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440) +found during the requested 20-minute frontier check. After auditing its exact +head, replace all 19 full complex native calls by the verified fresh-helper +unit of `research/fresh-helper-boundary`. The main controller, 16 paid query +shears and stronger ordinary BIT supplier stay those of PR4440. The proposed +conditional bound is + +``` +T(n) = O(n (log n)^(1 - 0.00300105)). +``` + +The gain is **0.00004105 (about 1.39%) over PR4440's 0.00296**, +**about 11.71% over PR4416's 0.00268647**, and **30.48% over the pinned +selected 0.0023**. The new result is author-checked and awaits review; it +retains the conditional source implementation and transfer contracts. + +| Complete complex raw invoice | PR4440 | Combined construction | +| --- | ---: | ---: | +| Full native calls / paid query shears | 19 / 16 | 19 / 16 | +| Independent productive fields | 11,560 | 11,560 | +| Paid calls | 72,902 | **69,273** | +| Productive / paid rank mass | 258,271 / 257,471 | 260,798 / 259,998 | +| Rank-one surplus | 800 | 800 | +| Proposed conditional κ | 0.00296 | **0.00300105** | + +The native retiming removes **3,629 paid calls**. It changes 117 helper +entrances, 42 exits and 395 scalar frames in each full invocation, with exactly +the same main operator and complete owned-center program. Thus substitution +is a native operator equivalence, not merely replacement of a histogram. +Every helper is still a distinct arbitrary original input; query copies and +centers receive no productive credit. [PROOF.md](PROOF.md) gives the join. + +The exact changed-profile root is enclosed by + +``` +0.0030010541830 < root < 0.0030010541834. +``` + +An interval proof covers every real `0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "871499999253/875000000000", + "fixed_halo_explicit_metadata_branch": "67375000001/875000000", + "new_BIT_row_stock_sublinear_in_active_group": "3489499997009/3500000000000", + "new_semantic_group_guard": "3/3500000000" + }, + "margins": { + "boundary_algebraic_matrix": "18381438244748161/6125000000000000000", + "fused_gaussian": "18381438234244483/6125000000000000000", + "global_coordinate_router": "10503679/3500000000", + "group_bit_router": "36762879968488963/12250000000000000000", + "group_scans": "1749999999/1750000000", + "main_transform": "18381436494748161/6125000000000000000", + "microbox_face_corrections": "67375000001/875000000", + "polynomial_products": "3499999999/3500000000", + "sparse_union_movement": "2506662688244748161/6125000000000000000" + }, + "parameters": { + "a": "10503679/3500000000", + "b": "8206/2734375", + "beta": "3499999997/3500000000", + "bit_saving": "17/5000", + "cap_xi": "5569162686494748161/6125000000000000000", + "complex_uniform_saving": "10503681/3500000000", + "d": "1/3500000000", + "epsilon": "3499999999/3500000000", + "kappa": "60021/20000000", + "lambda_": "996998949/1000000000", + "lambda_prime": "1744748161/1750000000", + "layout": "1/3500000000", + "q": "5251839/1750000000", + "r0": "1/35000000000", + "stop": "1/3500000000", + "tested_saving": "750263/250000000" + }, + "strict_checks": { + "actual_bit_above_effective": "1396321/3500000000", + "actual_logarithmic_gamma_guard": "1/3500000000", + "actual_logarithmic_group_guard": "555837316130251839/3062500000000000000", + "alpha_logarithm_absorption": "1/35000000000", + "boundary_algebraic_matrix_above_kappa": "6994748161/6125000000000000000", + "cap_above_band": "2506662686494748161/6125000000000000000", + "cap_below_cell": "555837311755251839/6125000000000000000", + "cap_below_phase_cell_power": "6680837313505251839/6125000000000000000", + "complex_above_effective": "1/3500000000", + "complex_below_one_over_32": "2471783/87500000", + "complex_endpoint": "1/1750000000", + "epsilon_below_one": "1/3500000000", + "epsilon_positive": "3499999999/3500000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "6984244483/6125000000000000000", + "gaussian_above_main": "869748161/3062500000000000000", + "global_coordinate_router_above_kappa": "1/875000000", + "global_gamma_power_slack": "9/35000000000", + "group_below_dimension": "1/1750000000", + "group_bit_router_above_kappa": "17468488963/12250000000000000000", + "group_gauge_power_slack": "555837316042751839/3062500000000000000", + "group_key_fits_record": "1/1750000000", + "group_positive": "3499999997/3500000000", + "group_scans_above_kappa": "3489496323/3500000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "635039790400418148631/500000000000000000000000", + "lambda_above_internal": "1/7000000000", + "lambda_above_sigma": "3/7000000000", + "lambda_above_tau": "1/7000000000", + "lambda_prime_above_lambda": "1/7000000000", + "lambda_prime_above_leaf": "85321/149536132812500", + "leaf_saving_above_effective": "2726169/9570312500000000", + "main_transform_above_kappa": "5244748161/6125000000000000000", + "membership_arithmetic_fits_record": "1/3500000000", + "microbox_face_corrections_above_kappa": "269489496329/3500000000", + "microbox_halo_volume": "276500000003/3500000000", + "new_complex_uniform_saving_above_b": "1/3500000000", + "new_semantic_guard_with_C1_one": "1/3500000000", + "polynomial_products_above_kappa": "872374081/875000000", + "positive_layout_slack": "1/3500000000", + "q_below_effective": "1/3500000000", + "q_below_internal": "1/3500000000", + "q_below_leaf": "85321/149536132812500", + "q_positive": "5251839/1750000000", + "short_record_fallback": "2726169/2734375", + "source_axis_superpolynomial": "1/3500000000", + "sparse_union_movement_above_kappa": "2488281256994748161/6125000000000000000", + "stop_below_one": "3499999999/3500000000", + "stop_positive": "1/3500000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/3500000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/3500000000", + "union_tag_work_per_visit_fits_record": "3/3500000000" + } + }, + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 69273, + "productive_fields": 11560, + "query_shears": 16, + "scope": "Author-checked conditional construction; retained native/all-column, owned-erasure, whole-job, analytic, precision, tape, prime and recovery contracts. No selected promotion or formal/human acceptance.", + "source_heads": { + "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", + "helper_retiming": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9" + }, + "source_inputs": 41, + "status": "PASS_CONDITIONAL_FRESH_HELPER_QUERY_THINNED_KAPPA", + "strictification": { + "alpha": { + "lower": "0.999999997758999184602267590366", + "upper": "0.999999997758999184602267590367" + }, + "cutoff": 20, + "delta": { + "lower": "0.932537400874663431699700098660", + "upper": "0.932537400874663431699700098661" + }, + "floor": 21, + "gamma": { + "lower": "0.969126930833863729265427869330", + "upper": "0.969126930833863729265427869331" + }, + "limits": [ + "999999999/1000000000", + "97/100", + "19/20" + ], + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "tail_offset": "1/5", + "tested": "750263/250000000" + }, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + } +} diff --git a/research/fresh-helper-thinned/SOURCES.json b/research/fresh-helper-thinned/SOURCES.json new file mode 100644 index 0000000000..4089ad3711 --- /dev/null +++ b/research/fresh-helper-thinned/SOURCES.json @@ -0,0 +1,278 @@ +{ + "schema_version": 1, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/fresh-helper-boundary/ARITHMETIC-RESULT.json", + "usage": "input", + "git_blob": "686c36fb19680db327f797ebdfe612487d8c53f8", + "sha256": "5d25fec9ac4b036c93846a50dccfa4af030e2982f5cec02e28702193bf157cf7", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/ARITHMETIC-RESULT.json" + }, + { + "path": "research/fresh-helper-boundary/CHANGES.json", + "usage": "input", + "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/CHANGES.json" + }, + { + "path": "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "usage": "input", + "git_blob": "e6fdb31624e4eb8c7c770bb4422cd07ea99ab152", + "sha256": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/NATIVE-RESULT.json.gz" + }, + { + "path": "research/fresh-helper-boundary/RESULT.json", + "usage": "input", + "git_blob": "e26608e20be115d28f8853a8c1a12bebfc8e8ec3", + "sha256": "34163eeeef1cd712de457d7fd3b0435f98a12ac456b82256b078f33225456fbd", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/RESULT.json" + }, + { + "path": "research/fresh-helper-boundary/SOURCES.json", + "usage": "input", + "git_blob": "0b40275502f4263a19905f4fb50e346a3629c712", + "sha256": "01998e9b86222d10811fc0114dcd5c946ff9e95025a7cacd00e67a3eefe543d0", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/SOURCES.json" + }, + { + "path": "research/fresh-helper-boundary/arithmetic.py", + "usage": "input", + "git_blob": "4822f04ae09d84a16e8fa8656a533e23fd4068f0", + "sha256": "212bae96d0ddcbc25076afe2589a47736c66b77420057f28c44c937ad087fc07", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/arithmetic.py" + }, + { + "path": "research/fresh-helper-boundary/native.py", + "usage": "input", + "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/native.py" + }, + { + "path": "research/fresh-helper-boundary/verify.py", + "usage": "input", + "git_blob": "e434dbf7c68afa0390a307fd15f32348b0e87207", + "sha256": "4c18851214400cf955e10565d89357029d9e765140233831472ce23f0c3ee7bf", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/verify.py" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "usage": "input", + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "research/kappa-function-composition/complex/prune_native.py", + "usage": "input", + "git_blob": "8c3e11b2408fa96eefa3ebe7952d1b11b90b772b", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "usage": "input", + "git_blob": "fbe6da7241357d89cf5c55b2e7ce2d0d046be32a", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef" + }, + { + "path": "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "usage": "input", + "git_blob": "e8c5e4f077fea0bef355e6c3013c7f252d3606cf", + "sha256": "9ece46fdfda6182e757e9a3b1f513fb3d029d730f3bafdcd6ed59180a14175b0" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "input", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "usage": "input", + "git_blob": "6a139eedbc1015c13df6f2a4333e1a89b5edd18d", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf" + }, + { + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "usage": "input", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "usage": "input", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "usage": "input", + "git_blob": "f97a23d7d21bd7f79c9d0cb14d8c6b44fddd3f23", + "sha256": "c4aa88c4943ef041e9542c519b7600ecf26ed6caff92558fdb07ac88ace64c17" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "usage": "input", + "git_blob": "c6edcbdc43bf36bb11201235027d0ec170d07fc8", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "usage": "input", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "usage": "input", + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "research/kappa-rebuild/complex/native_extensions.py", + "usage": "input", + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "research/kappa-rebuild/complex/power_two_balance.py", + "usage": "input", + "git_blob": "a55ae0ce78a1861965f899a82604b276260f636c", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "path": "research/kappa-rebuild/complex/rebuild_native.py", + "usage": "input", + "git_blob": "78a7b1b0e6e43a1347fb361f45c6e0eaff8dd27b", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "path": "research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "usage": "input", + "git_blob": "0f3a4067a4b4e20d0e6ca0f84f41851c5168f76d", + "sha256": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + }, + { + "path": "research/pr4359-p7-padding/P7-FACTOR.json", + "usage": "input", + "git_blob": "04c7ef620e760cc8f1764bbf0ccd7f32c6a5bd86", + "sha256": "6f96f6be5d8441f71cbe6ebb1657c69b543eb085b848b92b591b7ac01d6e6598" + }, + { + "path": "research/pr4359-p7-padding/TENSOR.md", + "usage": "input", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/pr4359-p7-padding/native_inventory.py", + "usage": "input", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "path": "research/query-thinned-controllers/BIT-CONTROLLER.json", + "usage": "input", + "git_blob": "89c400d5970024b3debe870c36ce43889beed001", + "sha256": "39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/BIT-CONTROLLER.json" + }, + { + "path": "research/query-thinned-controllers/COMPLEX-CONTROLLER.json", + "usage": "input", + "git_blob": "39318f6ad9baf0838a274ca1042b1e3ba0e74bf9", + "sha256": "bf1143325d8380fab40cd5a85449f9a5412f0340deba7f4693714c92ae320088", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/COMPLEX-CONTROLLER.json" + }, + { + "path": "research/query-thinned-controllers/RESULT.json", + "usage": "input", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/RESULT.json" + }, + { + "path": "research/query-thinned-controllers/SOURCES.json", + "usage": "input", + "git_blob": "0f061c87ff87c43ff1ea0fc418582e9ccea3bc1d", + "sha256": "74b73563d9f78a4562d376b6f33528d652e41097f65747667f112a3e1fa81d29", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/SOURCES.json" + }, + { + "path": "research/query-thinned-controllers/controller.py", + "usage": "input", + "git_blob": "d4557e08cfb9fe57cc1ae4024705a72dc95f3583", + "sha256": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/controller.py" + }, + { + "path": "research/query-thinned-controllers/verify.py", + "usage": "input", + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "pin": "head:40e22a83ed660d3d6074c4f2dbf14bfb621eee51:research/query-thinned-controllers/verify.py" + }, + { + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + ] +} diff --git a/research/fresh-helper-thinned/TASK.json b/research/fresh-helper-thinned/TASK.json new file mode 100644 index 0000000000..ee8b8e27d1 --- /dev/null +++ b/research/fresh-helper-thinned/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Combine the exact-head PR4440 query-thinned complex controller and stronger BIT supplier with the verified helper boundary retiming; certify a new complete conditional kappa beyond both predecessors.", + "scope_change_reason": "The explicit user task is to beat the strongest current kappa and switch to any stronger PR found in 20-minute checks. PR4440 at head 40e22a83 appeared during this run; its query-thinned native construction supersedes the first p7 result. This package audits and builds on that exact head, combining it with the independently replayed fresh helper retiming.", + "bottleneck_link": "Changing the complete nineteen-call native paid/productive profile improves the binding complex moment while retaining all copied-query charges and the stronger BIT consumer.", + "budget_minutes": 60, + "stop_rule": "Do not continue a superseded lesser kappa. Audit the stronger exact source, check actual unit substitution and the entire outer bill; no root digit-only or selected-frontier promotion.", + "outcome": "completed", + "evidence": "README.md; PROOF.md; AUDIT-4440.md; RESULT.json; SOURCES.json; VALIDATION.md", + "author": "1337isnot1337 with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance. No subagents or independent human mathematical review.", + "open_questions": [ + { + "question": "Can another simultaneous multi-frame or query/native topology change beat the new fixed-profile root?", + "why_it_matters": "Only about 4.18e-9 headroom remains in this invoice; another substantial improvement requires a changed profile.", + "first_step": "Start from the two pinned native units and emit a literal changed chronological word with all helper, owned-query and idle charges before a new root claim.", + "blocked_by": "No global optimum or complete multi-frame search is supplied." + }, + { + "question": "Can the owned-query and helper-retiming interfaces be independently proved at arbitrary column multiplicity?", + "why_it_matters": "The finite replays inherit source native, owned-erasure and whole-job contracts.", + "first_step": "Audit AUDIT-4440.md and the block-lift/whole-job clauses of both pinned source proofs.", + "blocked_by": "Finite phase/operator evidence is not formal or human acceptance of the entire source stack." + } + ] +} diff --git a/research/fresh-helper-thinned/VALIDATION.md b/research/fresh-helper-thinned/VALIDATION.md new file mode 100644 index 0000000000..ed9998e51a --- /dev/null +++ b/research/fresh-helper-thinned/VALIDATION.md @@ -0,0 +1,26 @@ +# Validation and limits + +- Source PR4440 head 40e22a83ed660d3d6074c4f2dbf14bfb621eee51: the unchanged + registered CPython 3.12.15 replay passed during the frontier audit. +- Helper retiming head ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9: complete + CPython 3.12.15 registered replay, 320 phase/boundary checks, all 632 arbitrary + columns in both native orientations, negative controls and separate Git-free + replay passed before composition. Its published optimizer reproduces its patch. +- New arithmetic authoring freshly authenticates all pinned inputs, counts the + actual combined event word, and checks the full changed moment, root ceiling, + both tail bounds, logarithmic rank, enlarged scalar/route budget and outer bill. + The authoring path uses previously checked source receipts. Normal registered + replay freshly executes both full source verifiers and compares the combined + receipt. That normal registered CPython 3.12.15 replay passed, freshly + executing both complete source verifiers before the new arithmetic checks. + +No source package was edited. Both exact predecessor commits are retained in +publication ancestry. The selected record is unchanged. No Lean, Docker, +all-history suite, formal theorem acceptance or independent human review is +claimed. Native all-column, owned-erasure, whole-job, physical/tape, analytic, +precision, prime and exact-recovery premises remain conditional. + +The first hosted plan run at predecessor ccdae89 failed four pre-existing +selected-status navigation tests before reaching research replay. The submission +repairs only the two navigation documents, retaining selected kappa 0.0023 and +all historical content. The six targeted navigation/locale tests pass. diff --git a/research/fresh-helper-thinned/VERIFY.json b/research/fresh-helper-thinned/VERIFY.json new file mode 100644 index 0000000000..5af213891f --- /dev/null +++ b/research/fresh-helper-thinned/VERIFY.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/fresh-helper-boundary/ARITHMETIC-RESULT.json", + "research/fresh-helper-boundary/CHANGES.json", + "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "research/fresh-helper-boundary/RESULT.json", + "research/fresh-helper-boundary/SOURCES.json", + "research/fresh-helper-boundary/arithmetic.py", + "research/fresh-helper-boundary/native.py", + "research/fresh-helper-boundary/verify.py", + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/verify.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "research/kappa-function-composition/complex/prune_native.py", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "research/kappa-rebuild/bit/bit_native_binding.py", + "research/kappa-rebuild/bit/complex_controller_factor.py", + "research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/kappa-rebuild/complex/native_extensions.py", + "research/kappa-rebuild/complex/power_two_balance.py", + "research/kappa-rebuild/complex/rebuild_native.py", + "research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "research/pr4359-p7-padding/P7-FACTOR.json", + "research/pr4359-p7-padding/TENSOR.md", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/native_inventory.py", + "research/query-thinned-controllers/BIT-CONTROLLER.json", + "research/query-thinned-controllers/COMPLEX-CONTROLLER.json", + "research/query-thinned-controllers/RESULT.json", + "research/query-thinned-controllers/SOURCES.json", + "research/query-thinned-controllers/controller.py", + "research/query-thinned-controllers/verify.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Freshly replay both exact-head source constructions; independently count the combined native/query/idle invoice; certify changed root and all-C fixed-profile ceiling, both charged tails with repaired gamma limit, logarithmic compiler rank, complete stronger BIT and all 54 outer predicates plus four guards." + } + ] +} diff --git a/research/fresh-helper-thinned/verify.py b/research/fresh-helper-thinned/verify.py new file mode 100644 index 0000000000..9ba85a59aa --- /dev/null +++ b/research/fresh-helper-thinned/verify.py @@ -0,0 +1,180 @@ +"""Combine the exact helper retiming with audited PR4440 query thinning. + +Apache-2.0; substantial OpenAI Codex assistance. Source notices retained. +Normal replay freshly executes both source verifiers, then this new ledger. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import argparse +import gzip +import importlib.util +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +KAPPA, TESTED = Q('.00300105'), Q('.003001052') +ROOT_LOW, ROOT_HIGH = Q('.0030010541830'), Q('.0030010541834') + +def need(ok, why): + if not ok: raise ValueError(why) + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + +def load(path,name): + spec = importlib.util.spec_from_file_location(name,path) + module = importlib.util.module_from_spec(spec) + sys.modules[name]=module;spec.loader.exec_module(module) + return module + +def encode(x): + if isinstance(x,Q): return str(x) + if isinstance(x,dict): return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): return [encode(v) for v in x] + return x + +def authenticate(): + seen=set() + for row in read(HERE/'SOURCES.json')['files']: + if row['usage']!='input': continue + p=Path(row['path']);need(not p.is_absolute() and '..' not in p.parts and str(p) not in seen,'Canonical input') + seen.add(str(p));actual=ROOT + for part in p.parts: + actual/=part;need(not actual.is_symlink(),'No source aliases') + b=actual.read_bytes() + need(sha256(b).hexdigest()==row['sha256'],'Changed source: '+str(p)) + need(sha1(b'blob '+str(len(b)).encode()+b'\0'+b).hexdigest()==row['git_blob'],'Changed Git source blob') + return len(seen) + +def ceiling(E,T,P): + signed={r:T[r]-P[r] for r in T.keys()|P.keys()} + def margin(c): + a,b=E.moment(T,1-c),E.moment(P,1-c) + return a[0]-b[1],a[1]-b[0] + need(margin(ROOT_LOW)[0]>0 and margin(ROOT_HIGH)[1]<0,'New complete profile root bracket') + derivative=None + for i in range(16): + l,r=Q(i,320),Q(i+1,320);low=Q(0) + for rank,n in signed.items(): + term=E.mul(E.power(rank,1-r if n>0 else 1-l),E.log_bounds(rank)) + low+=n*term[0 if n>0 else 1] + derivative=low if derivative is None else min(derivative,low) + upper=None + for i in range(128): + l,r=Q(1,20)+Q(19*i,2560),Q(1,20)+Q(19*(i+1),2560) + hi=sum(n*E.power(rank,1-l if n>0 else 1-r)[1 if n>0 else 0] for rank,n in signed.items()) + upper=hi if upper is None else max(hi,upper) + need(derivative>0 and upper<0,'Fixed-profile ceiling for every real 00,'No nonzero charge for erased idle stage') + P[rank]+=224;idle+=224 + for term in word['diagonal']: + need(term[0] in (-1,1) and all(x in (0,1) for x in term[1:]),'Actual normalized main target') + T[1+8*sum(term[1:])]+=112 + need((full,thin,idle)==(19,16,3584),'Every full, copied-query and whole-idle event') + need(sum(T.values())==11560 and sum(P.values())==69273,'Complete new productive/call counts') + need((sum(r*n for r,n in T.items()),sum(r*n for r,n in P.items()))==(260798,259998),'Preserve the exact surplus 800') + # Independent substitution into the source invoice must give the same ledger. + oldH={5:28,6:18,7:56,8:93,9:213};oldP={1:2487,2:713,3:224,4:102,5:20,8:8} + ref=source_query['complex_invoice'] + for key,new,old_unit,new_unit in [('targets',T,oldH,H),('paid',P,oldP,N)]: + check=Counter({int(k):v for k,v in ref[key].items()}) + check.subtract({k:19*v for k,v in old_unit.items()});check.update({k:19*v for k,v in new_unit.items()}) + need(+check==new,'Literal event count equals whole-call substitution: '+key) + E=S.C.load(ROOT/'research/higher-moment-strictification/verify.py','combined_exact_intervals') + root=ceiling(E,T,P) + t,u,v,c,b=1-TESTED,Q(1,5),1024,20,21 + target=E.moment(T,t);alpha=E.divide(E.moment(P,t),target) + other=S.C.load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','combined_separate_intervals') + tl,th=other.moment(T,TESTED);pl,ph=other.moment(P,TESTED) + need(tl>ph and max(tl,target[0])<=min(th,target[1]),'Independent exact raw-moment engine') + gamma=E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta=E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + alpha_gap=Q(1,1000000000);g,d=Q(97,100),Q(19,20) + need(alpha[1]<1-alpha_gap and gamma[1]Q(31,32),'The previous gamma limit fails and is explicitly replaced') + # Apply PR4433's general logarithmic majorant at the actual new ambient rank. + theta,power=Q(63,64),1000 + eta=E.scale(E.power(153,-v*TESTED),t) + need(2*(20**v)**64<=(153**v)**63 and eta[0]>theta**power,'Shifted exit and complement capacity') + need(E.power(153,v*TESTED)[1]<2**power,'Initial compiler range') + gap=(TESTED-KAPPA)/7;need(gap.numerator==1,'Integer compiler grid') + step=gap.denominator + def passes(j):return (step*j+1)**power<2**j + lo,hi=1,2 + while not passes(hi):lo,hi=hi,2*hi + while hi-lo>1: + mid=(lo+hi)//2 + if passes(mid):hi=mid + else:lo=mid + height=step*hi + need(height>8*v and passes(hi) and not passes(hi-1),'Effective uniform rank integer inequality') + # The changed local list is charged under an explicit larger fixed bound. + local_scalar=max(x['real_scalar_allowance'] for x in local['native'].values()) + local_routes=(sum(N.values())+2*408)*1000 + need(local_scalar+local_routes<10**7,'Every new local scalar and monomial route fits') + scalar_upper=19*10**7+16*1792+32*112*(len(word['physical_events'])+sum(len(word['boundaries'][k+'_program']) for k in ('left','right'))) + need(scalar_upper<10**9,'Retain the complete raw nonrecursive bound') + bit=source_query['ordinary_BIT'];atom=Q(bit['atom']);ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']);need(atom==Q('.004') and atom>ordinary>admitted>TESTED and atom<1-ordinary,'Complete stronger source BIT admission') + L=S.C.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','combined_outer_ledger') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=L.ledger(params);outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'Complete outer predicate inventory') + need(all(x>0 for key in ('strict_checks','functional_checks') for x in outer[key].values()),'Every complete outer inequality') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}),('unfunded_endpoint',{'kappa':TESTED}),('closed_epsilon',{'epsilon':Q(1)})]: + bad=L.ledger(dict(params,**patch));failed=[k for k,x in bad['strict_checks'].items() if x<=0] + need(failed,'Reject '+name);controls[name]=failed + return encode({'status':'PASS_CONDITIONAL_FRESH_HELPER_QUERY_THINNED_KAPPA', 'kappa':KAPPA,'kappa_decimal':'0.00300105', + 'source_inputs':count,'source_heads':{'PR4440':'40e22a83ed660d3d6074c4f2dbf14bfb621eee51','helper_retiming':'ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9'}, + 'gain_over_PR4440':KAPPA-Q('.00296'),'gain_over_PR4416':KAPPA-Q('.00268647'), + 'targets':dict(sorted(T.items())),'paid':dict(sorted(P.items())),'full_calls':full,'query_shears':thin, + 'paid_calls':sum(P.values()),'productive_fields':sum(T.values()),'fixed_profile_ceiling':root, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta), + 'limits':[1-alpha_gap,g,d],'normalized_paid_upper':bound}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'uniform_saving':params['complex_uniform_saving'], + 'gap':gap,'H':height,'N':'2^'+str(height),'integer_test_exponent':hi,'word_materialized':False}, + 'nonrecursive':{'local_scalar_allowance':local_scalar,'local_route_bound':local_routes,'raw_upper':scalar_upper,'raw_budget':10**9}, + 'ordinary_BIT':bit,'outer':outer,'negative_controls':controls, + 'scope':'Author-checked conditional construction; retained native/all-column, owned-erasure, whole-job, analytic, precision, tape, prime and recovery contracts. No selected promotion or formal/human acceptance.'}) + +if __name__=='__main__': + parser=argparse.ArgumentParser() + parser.add_argument('--write',action='store_true',help='Author the new arithmetic receipt from already-audited dependency receipts; normal replay freshly reruns both dependencies.') + args=parser.parse_args();result=run(execute_sources=not args.write) + if args.write:(HERE/'RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + else:need(result==read(HERE/'RESULT.json'),'Exact combined receipt replay') + print(json.dumps({k:result[k] for k in ('status','kappa_decimal','gain_over_PR4440','compiler')},sort_keys=True)) diff --git a/research/historical-1042-link/RESULT.json b/research/historical-1042-link/RESULT.json index a9d58d2881..30ec98c793 100644 --- a/research/historical-1042-link/RESULT.json +++ b/research/historical-1042-link/RESULT.json @@ -2,8 +2,9 @@ "historical_href": "../../certificates/selected-result.json", "checkpoint": "certificates/checkpoints/frontier1042.json", "historical_kappa": "1672188119205421/1000000000000000000", - "live_kappa": "836330098538459/500000000000000000", + "live_kappa": "23/10000", "same_href": true, "kappas_differ": true, - "no_new_kappa": true + "no_new_kappa": true, + "intermediate_checkpoint": "certificates/checkpoints/frontier1094.json" } diff --git a/research/historical-1042-link/SOURCES.json b/research/historical-1042-link/SOURCES.json index c6119ca5a8..66f468626e 100644 --- a/research/historical-1042-link/SOURCES.json +++ b/research/historical-1042-link/SOURCES.json @@ -11,20 +11,29 @@ { "path": "docs/research/current-status.md", "usage": "input", - "git_blob": "4e0a8b7cdacc1d9680f7f81d03624118bb20416d", - "sha256": "00a08925c51b26d168b8099ddeed659ac4381f7e04f3c7fd0e9de8e71f206823" + "git_blob": "532af84312cbfeb39a1e4659d8398deb560f1e4a", + "sha256": "54c843968d0b178369a7e56161be44c4692935c3f46ce261678aeedadb309891", + "pin": "head:7d05d73f96c27a9d360011e04af69b23fa903757:docs/research/current-status.md" }, { "path": "certificates/selected-result.json", "usage": "input", - "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", - "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9", + "pin": "head:7d05d73f96c27a9d360011e04af69b23fa903757:certificates/selected-result.json" }, { "path": "certificates/checkpoints/frontier1042.json", "usage": "input", "git_blob": "f451ced6626a1f03aba6915ce23a136b01ebe51d", "sha256": "207d1f49f113c585024b9d3c17eadbb8b1be17c1321e3d190aabe2f18ce1c5b7" + }, + { + "path": "certificates/checkpoints/frontier1094.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "pin": "head:7d05d73f96c27a9d360011e04af69b23fa903757:certificates/checkpoints/frontier1094.json" } ] } diff --git a/research/historical-1042-link/VERIFY.json b/research/historical-1042-link/VERIFY.json index 5cff7b26c9..5138c1b017 100644 --- a/research/historical-1042-link/VERIFY.json +++ b/research/historical-1042-link/VERIFY.json @@ -6,16 +6,25 @@ "inputs": [ "docs/research/current-status.md", "certificates/selected-result.json", - "certificates/checkpoints/frontier1042.json" + "certificates/checkpoints/frontier1042.json", + "certificates/checkpoints/frontier1094.json" ], "commands": [ { - "argv": ["{python}", "-B", "{package}/verify.py"], + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], "timeout_seconds": 30, "checks": "Compare the #1042 status link with the live record and the frontier1042 checkpoint." }, { - "argv": ["{python}", "-B", "{package}/test_verify.py"], + "argv": [ + "{python}", + "-B", + "{package}/test_verify.py" + ], "timeout_seconds": 30, "checks": "Check the printed decimal and the historical section cut." } diff --git a/research/historical-1042-link/verify.py b/research/historical-1042-link/verify.py index 12170922e5..2ffd4a8ce4 100644 --- a/research/historical-1042-link/verify.py +++ b/research/historical-1042-link/verify.py @@ -2,7 +2,8 @@ """Separate the #1042 status link from the live selected record. The historical section states the #1042 kappa and links to the live record. -The matching checkpoint is the selected record's previous_record field. +The matching checkpoint is reached through the selected record's historical +previous_record chain (currently via frontier1094). """ import hashlib @@ -16,6 +17,7 @@ MARKER = "PASS_HISTORICAL_1042_LINK kappas_differ=true no_new_kappa" HREF = "../../certificates/selected-result.json" CHECKPOINT = "certificates/checkpoints/frontier1042.json" +INTERMEDIATE = "certificates/checkpoints/frontier1094.json" SHOWN = "0.001672188119205421" @@ -43,6 +45,7 @@ def authenticate(): "docs/research/current-status.md", "certificates/selected-result.json", "certificates/checkpoints/frontier1042.json", + "certificates/checkpoints/frontier1094.json", } require(set(pinned) == expected, "input inventory changed") for path, row in pinned.items(): @@ -64,12 +67,15 @@ def evaluate(): require(HREF in section, "the historical section lost the live-record link") require(SHOWN in section, "the historical kappa sentence moved") require(Fraction(SHOWN) == Fraction(old["kappa"]), "the checkpoint kappa left the printed decimal") - require(live["previous_record"] == CHECKPOINT, "the previous-record pointer moved") + require(live["previous_record"] == INTERMEDIATE, "the live previous-record pointer moved") + intermediate = json.loads((ROOT / INTERMEDIATE).read_text(encoding="utf-8")) + require(intermediate["previous_record"] == CHECKPOINT, "the checkpoint ancestry link moved") require(Fraction(live["kappa"]) != Fraction(old["kappa"]), "the live and historical kappas agree") require(text.index(HREF) < text.index("# Historical status through #1042"), "the live section lost its record link") return { "historical_href": HREF, "checkpoint": CHECKPOINT, + "intermediate_checkpoint": INTERMEDIATE, "historical_kappa": old["kappa"], "live_kappa": live["kappa"], "same_href": True, diff --git a/research/kappa-hybrid-controller/EXTERNAL-SOURCES.json b/research/kappa-hybrid-controller/EXTERNAL-SOURCES.json new file mode 100644 index 0000000000..8e7ef41117 --- /dev/null +++ b/research/kappa-hybrid-controller/EXTERNAL-SOURCES.json @@ -0,0 +1,259 @@ +{ + "BIT_default": "repository root", + "BIT_interval_dependency": { + "bytes": 29992, + "fallback_path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "preferred_path": "research/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + "complex_default": "research/pr4359-p7-padding/source", + "existing_BIT_source_files": [ + { + "bytes": 13061, + "path": "notes/three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "bytes": 4815, + "path": "notes/three-stage-cover-rows.tex", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8" + }, + { + "bytes": 6385, + "path": "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "sha256": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca" + }, + { + "bytes": 16874, + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "bytes": 50703, + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf" + }, + { + "bytes": 8380, + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "bytes": 28173, + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "bytes": 42353, + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "bytes": 653616, + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/249-records.bin", + "sha256": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a" + }, + { + "bytes": 112648, + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + } + ], + "existing_p7_package_files": [ + { + "bytes": 10730, + "path": "research/pr4359-p7-padding/EXPORTED-SOURCES.json", + "sha256": "0305d4730e2dfede834a241099aa6ceeee29444f305dfeb25ae9a1bb8b2df0b6" + }, + { + "bytes": 11603, + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "bytes": 6511, + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/template_bound.py", + "sha256": "25d409726cd867f7584fbd52e1b846335debdab42d24377e00c5653aaf12c0fb" + }, + { + "bytes": 10249, + "path": "research/pr4359-p7-padding/dependencies/tensor-strictification/native_inventory.py", + "sha256": "e1ba009d546981e75f0e6468723b9af4c065f5eb6e08390084fbbf9a579cedf1" + }, + { + "bytes": 29992, + "path": "research/pr4359-p7-padding/source/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "bytes": 814141, + "path": "research/pr4359-p7-padding/source/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "bytes": 15898, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "bytes": 7318, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/identity_mixed_certificate.py", + "sha256": "e1795294fa4d3100352bfda787ecb1efc2468ff11cbcbaca2476eb642b8d2a0a" + }, + { + "bytes": 16190, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/mixed_forest_search.py", + "sha256": "2dcec76840b437c67125af5b6d3529577f8c38851c792d0ffd9fa928c473e23b" + }, + { + "bytes": 12298, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/mixed_target_probe.py", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "bytes": 4138, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef" + }, + { + "bytes": 12901, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/complex_controller_factor.py", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "bytes": 28173, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/mixed_productive_bit.py", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "bytes": 25720, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/fresh-certificates/THREE-base-HELPER-BOUNDARIES.json.gz", + "sha256": "f90517e395bde58c72cacd5d3481c4ea31d459fe4535384ac16547ac40460555" + }, + { + "bytes": 75462, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6" + }, + { + "bytes": 82793, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "bytes": 198063, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "bytes": 9996, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full_identity_rebuild.py", + "sha256": "9af2ffbb0038c92e2a7d281081b0daaeadce75b11b566e5427845dc1af91e33d" + }, + { + "bytes": 176694, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/controller/P3-NATIVE-COVER.json.gz", + "sha256": "facfc6d6ecde151afb7e6a167776f3fdaac1c816e785a21a39f7f0bfd9140f3f" + }, + { + "bytes": 16380, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/controller/p3_native_cover.py", + "sha256": "fae71fcbbd20b9ee73b049cf6f43ea1d048217fb15feb6055a007e47da3363fe" + }, + { + "bytes": 15369, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "bytes": 20800, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/OUTER-TRANSFER-AUDIT.md", + "sha256": "67569961d068633c6ff3ac9dfde47a0c17f0da6d20432799dcc920cff92b5779" + }, + { + "bytes": 10467, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/p3_cover_audit.py", + "sha256": "a0fe9a26f77556e83b31b0c91fea909d6f3d8209d0f9f7ad4e5bc1375d33615e" + }, + { + "bytes": 14209, + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "sha256": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + } + ], + "note": "Existing repository inputs; no duplicate baseline vendor. PR4441 is an intact ancestry-bound live dependency. Its complete phase/native receipt is regenerated against pinned original sources at the repository root. The local supplier also authenticates the p7 source export and original center phase gate. Original p7-only wrapper/factor receipts are not read. The p6 BIT validator reuses pinned p3 arithmetic/native gates. Written copy/cover notes retain the inherited contracts.", + "retimed_source_default": "repository root", + "retimed_supplier_head": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9", + "retimed_supplier_live_files": [ + { + "bytes": 8228, + "path": "research/fresh-helper-boundary/native.py", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "source_commit": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9" + }, + { + "bytes": 13176, + "path": "research/fresh-helper-boundary/CHANGES.json", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "source_commit": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9" + }, + { + "bytes": 29131, + "path": "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "sha256": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "source_commit": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9" + } + ], + "retimed_supplier_original_sources": [ + { + "bytes": 17028, + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "bytes": 13794, + "path": "research/kappa-function-composition/complex/prune_native.py", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "bytes": 12470, + "path": "research/kappa-rebuild/complex/native_extensions.py", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "bytes": 25306, + "path": "research/kappa-rebuild/complex/rebuild_native.py", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "bytes": 7152, + "path": "research/kappa-rebuild/complex/power_two_balance.py", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "bytes": 6824, + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "bytes": 82793, + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "bytes": 198063, + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + } + ], + "schema": "hybrid-retimed-external-inputs/2", + "written_proof_source_files": [ + { + "bytes": 5328, + "git_blob": "8933aaf508aa9d4c75ba1290913e02f6868d351d", + "path": "notes/copied-centers-lemma.tex", + "sha256": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "used_for": "Retained complete-stream owned copy/transform/read/discard contract including complex inverse transforms; not imported by runtime." + } + ] +} diff --git a/research/kappa-hybrid-controller/NATIVE.md b/research/kappa-hybrid-controller/NATIVE.md new file mode 100644 index 0000000000..ea4cfb4a55 --- /dev/null +++ b/research/kappa-hybrid-controller/NATIVE.md @@ -0,0 +1,280 @@ +# Exact native and direct physical controller + +The complete raw unit has 17 main pairs, 19 native supplier invocations, +and 16 directly paid shears. Its productive and paid profiles are the +integer dictionaries in `parameters.py`. Their rank masses are 260798 +and 259998. This note proves the new physical construction and identifies +the finite source gates. `PROOF.md` supplies the conditional transfer. + +## 1. Source-bound local supplier + +The local source is the arbitrary-input `THREE-base` reconstruction in +PR4359, retained by the committed PR4416 source export. It has 224 main +fields and 408 autonomous helper fields. Every input is arbitrary, and +every helper has a distinct physical owner. + +The final supplier incorporates the fresh-helper boundary retiming from +[PR4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441), pinned +at head `ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9`. Its source package is +retained at [../fresh-helper-boundary/](../fresh-helper-boundary/). +The updated PR4441 head +`5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39` retains these same native +source bytes and also combines the retimed supplier with the p17 +native/direct controller at conditional saving `0.00300105`. That +updated head and its complete dependency changes are retained in the +publication ancestry. + +`local_supplier.py` authenticates and regenerates the modification: +117 helper entrances, 42 helper exits and 395 scalar contact frames change. +Scalar order and coefficients, all main boundaries, every warp's physical +entry and exit, and the owned center program remain fixed. + +Here is why this retiming preserves the main operator. A field in frame +$S$ has physical value $C_S z$. A paid nested transport +$C_T C_S^{-1}$ changes its frame without changing its logical value $z$. +At a common frame, scalar addition satisfies + +\[ +C_S z_i+aC_S z_j=C_S(z_i+az_j). +\] + +The generator inserts the required positive nested transport before each +next contact and completes each field to its declared final frame. +Induction through the unchanged scalar actions and warp words preserves +every logical row for arbitrary inputs. Main entrance and exit frames +stay fixed, so their physical forward and backward operators stay fixed. +No finite-order relation on the free warp symbols is used. + +A helper with new entrance $S$ and exit $T$ implements +$C_T C_S^{-1}$ on its arbitrary physical input. Its productive width is +$\dim T-\dim S$. The exact Clifford compiler verifies that this is the +Gaussian rank of the complete boundary operator and provides both +monomial factors around a standard positive Gaussian child. Those factors +need not be an inverse pair. Apply their inverses at the input and output +boundaries of the complete local invocation. Every helper has a fresh +independent owner, so these normalizers attach to its whole job without +changing any other field's boundary. + +Two independent retained interpreters replay both resulting orientations +on all 632 arbitrary persistent input columns, together with an arbitrary +owned-center entry column that is legally cleared. Every helper remains +logically autonomous. The phase compiler checks all 320 distinct new +transport or helper-boundary recipes in both orientations, retaining the +absolute phase through exact tableaux and Gaussian dyadic state vectors. +Unchanged edges retain their authenticated source phase evidence. + +The same gauge induction applies at each permitted column multiplicity +under the source all-column contract. Every new fixed coordinate and +phase generator uses its permitted block lift. This is a chronological +identity of frame transports and scalar actions; the argument does not +infer an all-column implementation by taking the tensor power of a sum. + +This retiming replaces the preliminary fifteen-tail-pruned supplier. +It subsumes all fifteen earlier terminal-climb deletions; no additional +pruning gain is applied. The final local productive helper profile is + +``` +H = {4:26, 5:2, 7:29, 8:42, 9:309}. +``` + +The eight original center paths retain their complete rank-eight requests. +The inherited center recipes verify their products including phase. +Every remaining query is counted: + +``` +L = {1:2253, 2:515, 3:445, 4:102, 5:40, 8:8}. +``` + +The pointwise real-scalar allowances are 158120 forward and 158168 +backward. These counts are regenerated from the unchanged scalar words. +The ideal formal prefix row-$\ell_1$ maxima remain 457 and 169. +Every new transport and helper boundary monomial contributes its actual +movement and phase records to the finite program. A rank-zero normalizer +is still a paid finite operation. + +## 2. Literal direct shear + +For a source port let $q\in\mathbf F_2^9$ be its specified odd vector. +The complete source phase data supplies eight vectors $b_1,\ldots,b_8$ +orthonormal and perpendicular to $q$. Thus the matrix with columns + +\[ +P=(q,b_1,\ldots,b_8) +\] + +is orthogonal over $\mathbf F_2$. All 112 actual port choices are checked; +their $q$ weights are three or seven. + +Write $X_q$ for address translation by $q$, and define the physical +Gaussian line operator by its exact kernel + +\[ +C_q=\frac{1+i}{2}I+\frac{1-i}{2}X_q. +\] + +If $\Pi_P$ is the address permutation induced by $P$, then + +\[ +C_q=\Pi_P C_{e_0}\Pi_P^{-1},\qquad +C_q^2=X_q,\qquad C_q^{-1}=X_q C_q. +\] + +These are literal equalities with global phase one. In particular the +inverse uses the same positive Gaussian child and one extra translation. +`native_geometry.py` checks both kernels using exact tableaux and the +absolute phase, independently lowers them to rank one, and checks the +two nonzero coefficients of all 512 coordinate columns. Omitting the +inverse translation is rejected at all 112 ports. + +The direct forward stage acts on arbitrary physical arrays as follows: + +1. Allocate an owned zero work stream and copy the complete source $X$. +2. Apply the input route $\Pi_P^{-1}$ to that copy. +3. Pay one rank-one Gaussian request on the copy. +4. Apply $\Pi_P$, then translate by $q$, giving $C_q^{-1}X$. +5. Add the copy to $Y$, retaining $X$, and release the copy. + +The resulting main map is exactly + +\[ +S_y(Q^{-1}):(X,Y)\longmapsto(X,Y+C_q^{-1}X). +\] + +The dual construction copies $Y$, applies $C_q$, subtracts it from +$X$, and releases the copy. It implements $S_x(-Q)$. The selected +controller uses only direct forward stages, but both kernel orientations +are checked. + +The work stream includes the original field's complete control and +spectator ranges. It receives no productive output credit. Its transformed +value can be discarded after the read under the retained +[copy/transform/read/discard contract](https://github.com/CrocSwap/integer-mult-bounds/blob/da637c87c89482bc4c86be36bd0071b3d400dbed/notes/copied-centers-lemma.tex). +That source explicitly covers complex inverse transforms and nonzero +temporary erasure. No inverse query is required to uncompute an owned +stream that is discarded through this interface. + +For $f$ columns the address space has dimension $9f$. The address map +is $P\otimes I_f$, or its column-order version $I_f\otimes P$. Its +induced permutation on value arrays is the product of the per-column +permutations. The single recursive request has rank **$f$**, with active +span of the vectors $q\otimes e_j$ for $1\le j\le f$ over +$\mathbf F_2$. The inverse translation repeats $q$ in every column. +The request has the full current ancestor weight. Its invoice contains +one rank-$f$ request, with every whole-field route charged. + +Each of the 1792 direct episodes is charged one paid request, 64 +pointwise real-scalar primitives per full field volume, and an allowance +of eight nonrecursive full-stream movement/control records. Those records +cover initialization, copy, the two routes, inverse translation, read/add, +and release. The copy remains owned across the recursive call. Its bank +is included in the expanded stock bound until release. + +## 3. Specialize the exact controller + +The original complex local operators are + +\[ +F_s=D_sS_y(Q^{-1}),\qquad B_s=D_sS_x(-Q). +\] + +The coefficient operators $Q,D_0,\ldots,D_{34}$ commute. Their symbols +form the rational Laurent ring used to factor the full p17 controller. +The exact retained-idle mask is 280378328416255, and the scalar boundary +words come from the source factorization. The pinned original rational +controller code is replayed by `controller/make_direct_case.py`. + +[PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440), +at head `40e22a83ed660d3d6074c4f2dbf14bfb621eee51`, independently gives +the same query-thinning mechanism and p17 schedule. The combination of +that interface with the retimed supplier is also present in updated +PR4441. This package contributes an independent source-bound physical +certificate, the bounded controller search, a separately replayed p6 +BIT supplier, and a refinement of the certified endpoint. + +Set $D_s=I$ for the internal even stages + +\[ +s=2,4,\ldots,32. +\] + +Leave $D_0$, every odd stage, and $D_{34}$ unchanged. This ring +homomorphism preserves the exact factorization. The sixteen specialized +local stages become the directly paid shears just proved. They have no +native helpers. The nineteen retained stages each receive 408 fresh +arbitrary helper owners. + +The factory verifies every collapsed Laurent coefficient over the +rationals. A separate event interpreter replays the actual right boundary, +specialized local/idle/scalar word, and left boundary on every one of +the 34 main input columns. It compares all 1156 entries with the exact +diagonal, including the signs of every $Q$ power. Wrong native reverse +sign and wrong direct orientation controls are rejected. + +## 4. Surviving native contacts on the full carrier + +The proof keeps all original 281 address axes. Stage $s>0$ has its +original fresh eight-axis block. Unused even-stage axes remain arbitrary +spectators; they receive no productive rank from a deleted $D_s$. + +The contact compiler keeps the original full-prefix reference frames at +each surviving native stage. These are invertible coordinate gauges used +to prove the physical operator identity on arbitrary inputs. They do not +assert that the incoming numerical values were previously produced by +every reference-frame transform. + +For example, let $A_X,A_Y$ denote the reference entry frames and +$B_X,B_Y$ the exit frames. The exact contact checks prove + +\[ +B_XA_X^{-1}=B_YA_Y^{-1}=D_s, +\] + +and prove that the cross term is $D_sQ^{-1}$ forward or $D_sQ$ +backward, with the latter's scalar minus sign in the native word. Every +old spectator factor cancels in these quotients. Therefore changing +earlier stages to direct shears does not invalidate a surviving local map. + +`native_geometry.py` checks all 8512 entry/exit contacts over the full +281-axis carrier. Each route is explicitly orthogonal and involutive, +fixes the actual $q$, and has the required complete quadratic phase and +physical translation. Both orientations are checked by exact polynomial +identities, retaining their inverse translations. + +## 5. Idle and endpoint phases after specialization + +Every literal idle window is specialized with the same stage mask. +An empty stage list is identity and incurs no Gaussian query. All sixteen +middle windows disappear this way. The initial and terminal windows have +positive ranks $16,24,\ldots,72$, each appearing 448 times in the paid +invoice. Each complete positive window is paid once per physical owner. + +For a window containing stage zero, use the source's eight $q$-orthogonal +old axes and its exact `translation_after`. Append only the fresh axes +whose stage factors remain active. Other windows use only their selected +fresh axes. The verifier checks the complete Gaussian phase and the +independence of every such axis set. No old split tariff is substituted +for a complete idle request. + +For a specialized output monomial + +\[ +Q^{\epsilon}\prod_sD_s^{a_s},\qquad +\epsilon\in\{-1,1\},\quad a_s\in\{0,1\}, +\] + +the target width is $1+8\sum_s a_s$. If $a_0=1$, its positive old +axes are all nine old coordinates; otherwise its old axis is $q$. +Append the selected active fresh blocks. A negative $Q$ power requires +translation by $q$, which is explicitly checked and charged. + +The resulting 3808 main targets have ranks $17,25,\ldots,73$, each with +multiplicity 448, and rank 153 with multiplicity 224. The nineteen local +suppliers contribute 7752 additional distinct targets. The complete +census is 11560 independent productive fields and 69273 paid requests. +Their scalar allowance is 3500584, including every direct episode. +Their rank-one surplus is exactly 800. + +`certificates/HYBRID-GEOMETRY.json.gz` contains the full contact, route, +kernel, endpoint and idle recipes. The native gate regenerates its +canonical JSON payload and compares the payload exactly; it does not +depend on the gzip implementation's stream encoding. diff --git a/research/kappa-hybrid-controller/PROOF.md b/research/kappa-hybrid-controller/PROOF.md new file mode 100644 index 0000000000..205fb6c16a --- /dev/null +++ b/research/kappa-hybrid-controller/PROOF.md @@ -0,0 +1,424 @@ +# Conditional saving 0.003001053 from the hybrid controller + +Subject to the inherited native and transfer hypotheses stated below, +the construction gives + +\[ +T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad +\kappa=0.003001053. +\] + +The physical change is proved in `NATIVE.md`. It specializes sixteen +transverse factors of the source Laurent controller to identity and pays +for their remaining $Q^{-1}$ shears directly. The final raw controller +has nineteen source-bound native invocations, 1792 directly paid Gaussian +requests, and 11560 independent productive fields. The native supplier +uses [PR4441's fresh-helper boundary retiming](https://github.com/CrocSwap/integer-mult-bounds/pull/4441), +with unchanged local source bytes pinned at +`ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9`. The query-thinning +mechanism and p17 schedule were independently given in +[PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440), +at head `40e22a83ed660d3d6074c4f2dbf14bfb621eee51`. + +Updated PR4441, at +`5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`, also combines this +retimed supplier with the same p17 profile and admits `0.00300105`. +That updated head and its complete dependency changes remain in the +publication ancestry. The contribution here is an independent +source-bound physical certificate, the bounded controller search, +the separately replayed p6 BIT supplier, and the endpoint refinement +to `0.003001053`. The combined raw profile is shared with updated +PR4441. + +The retimed supplier replaces the preliminary lifetime-pruned local word. +Its construction subsumes the fifteen earlier terminal-climb deletions. +The final invoice uses the retimed profile directly and adds no separate +pruning gain. Its complete local source and boundary proof are retained +at [../fresh-helper-boundary/](../fresh-helper-boundary/). + +This theorem remains conditional on the admitted all-column native +semantics, permitted whole-job matchers, spectator law, mixed compiler, +fine-prime/analytic estimates, precision, stock, fixed-tape realization, +and exact recovery used by the PR4359/PR4416 line. The scripts check the +finite native modifications and exact arithmetic inputs. They are not a +formal verification of the complete multiplication theorem. + +## 1. Complete raw moments + +Use the productive and paid multiplicities $T_k,P_r$ in +`parameters.py`, including all local helper outputs, direct queries and +specialized whole idle requests. Put + +\[ +T_\tau=\sum_kT_k k^\tau,\qquad +P_\tau=\sum_rP_r r^\tau,\qquad \tau=1-C. +\] + +The exact rank-one moments and number of productive owners are + +\[ +T_1=260798,\qquad P_1=259998,\qquad B=11560. +\] + +Thus the complete rank-one surplus is 800. The raw ranks overlap: +the smallest productive rank is four and the largest paid rank is 72. +A positive raw moment therefore still requires a strictification step. + +The numerical discovery root is approximately 0.003001054183175. The +certificate uses the strictly smaller rational point + +\[ +C=C_{\rm test}=0.003001054=\frac{1500527}{500000000}. +\] + +All later inequalities use rational interval bounds. No floating-point +root or search score is used as acceptance evidence. + +## 2. Chronological native tensor substitution + +The hybrid unit retains the same all-column request interface as its +native components. At a direct paid position with $f$ columns it makes +one rank-$f$ request on a complete owned copy. The surrounding address +route is $P\otimes I_f$, with the inverse route and repeated $q$ +translation. Every field includes its full control and spectator ranges. +The query retains the current complete ancestor weight. + +Apply the chronological tensor construction of the admitted native rule. +Suppose units $U,V$ have productive ranks $k_i,h_j$, and paid ranks +$r_\ell,s_a$. Run copies of $U$ on the distinct $j$-indexed owners +at column count $h_j$. At each common paid position $\ell$, pause +those copies. Normalize their complete current jobs, run one full $V$ +unit at column count $r_\ell$, restore the whole-job matchers, and resume +the paused $U$ copies. Canonicalization uses both recorded monomial +boundary factors of each complete physical job. These factors need not +be an inverse pair. Placement on the desired disjoint coordinates then +uses coordinate conjugation; Fourier rank alone does not supply an +unrecorded normalizer. + +The resulting productive ranks are $k_i h_j$. The remaining paid ranks +are $r_\ell s_a$. Arbitrary-input correctness permits correlated current +values, while physical owners remain distinct. Every suspended owned +center or direct-copy bank remains allocated until its own release. +No copy or zero-initialized work stream receives productive credit. +Every unused coordinate remains an arbitrary spectator. + +This is chronological replacement of complete physical requests. It does +not expand a scalar sum and assign rank products without a program. The +copied-stream interface and the arbitrary-input native gates provide the +same closure at direct and native paid positions. + +After $v$ copies the raw productive and paid moments are +$T_\tau^v,P_\tau^v$. There are $B^v=11560^v$ productive owners. +The conservative ambient rank is $m=281^v$; unused stage coordinates +are retained in this bound. Raw productive ranks are at most $153^v$. + +## 3. Paid completion and complete split tails + +Choose + +\[ +v=17160,\qquad J=18^v,\qquad L=19^v. +\] + +After the entire native product has finished, normalize each productive +job of rank $KJ$, write $R=qJ+r$. Its split moment is at most + +\[ +qJ^\tau+r^\tau\le RJ^{-C}+J^\tau\le2RJ^{-C}. +\] + +Keeping unsplit requests of rank at most $J$, the full original paid +part is bounded by + +\[ +P_\tau^v+2P_1^vJ^{-C}. +\] + +A completion request $D0, +\] + +because completion adds equal productive and paid rank and splitting +preserves paid rank. + +## 4. Explicit finite uniform compiler + +Apply the inherited integer whole-job compiler, attributed in the source +to Jacob Alan Sussman's Theorem 1G. Select + +\[ +\kappa=0.003001053,\qquad +d=\frac{C-\kappa}{7}=\frac1{7000000000},\qquad +u=\kappa+6d=\frac{21007377}{7000000000}. +\] + +Here $u$ is the uniform complex saving. Put + +\[ +t=1-C,\qquad z=1-u,\qquad z_0=(t+z)/2, +\qquad \Delta=z_0-t=\frac1{14000000000}. +\] + +The exact inequality $18^{55}<19^{54}$ bounds the exit exponent by +$54/55$; use $h=1/55$. Retaining the full ambient $281^v$, the bounds +$18<2^5$, $281<2^9$ give + +\[ +\frac{mE(x)}x<2^{A}x^{-h},\qquad +A=(5+9h)v=88608. +\] + +The complement coefficient $\eta=z_0m^{z_0-1}$ satisfies + +\[ +-\log_2\eta<1+9v(1-z_0)=\frac{32513793811}{70000000}. +\] + +The following integers are sufficient: + +\[ +\begin{aligned} +H_0&=\left\lceil\frac{A\Delta+1+9v(1-z_0)}{h\Delta}\right\rceil + =357651736794440,\\ +H_1&=\left\lfloor\frac{H_0(1-z_0)}{z-z_0}\right\rfloor+1 + =15026650096742881962201,\\ +N&=2^{H_1}. +\end{aligned} +\] + +`endpoint.py` checks $H_0\ge9v$, the complete exit/complement +inequality, and the final strict power inequality. The last inequality's +gap is exactly $1/14000000000$. Reducing either threshold by one fails +its stated sufficient bound. Strong induction below and above the +threshold gives the admitted uniform saving $u$ at rank $N$. + +These are sufficient finite values. The enormous tensor and uniform +programs are specified by finite recipes; they are not materialized and +are not claimed to be practical or minimal. + +## 5. Ordinary BIT input and the outer ledger + +The ordinary BIT supplier is the separately source-bound six-pair +construction in `bit/BIT-P6-TENSOR.md`. It has thirteen native invocations, +7039 arbitrary input columns, 5707 independent helper owners, and 117 +owned-copy episodes. The complete source rational charts are embedded in +the 92-dimensional carrier. Every whole idle and endpoint is regenerated. + +Its exact raw profiles are + +``` +T_BIT = {8:5707, 22:444, 36:444, 50:222, 92:222}, +P_BIT = {1:17199, 2:17446, 3:1027, 4:572, 5:1326, + 6:143, 7:1357, 14:444, 28:444, 42:222}. +``` + +The BIT proof uses tested saving 0.00314, a native tensor power of 6000, +uniform saving 0.003135, and covered saving 0.00313. Its normalized paid +moment is bounded by $1653/1696<1$. All native tensor substitutions +and whole-job matchers precede one delayed global cover, with one common +external weight. Internal queries are not separately lowered to +incompatible covered weights. The inherited two-call ordinary wrapper +has fixed multiplicity. + +With atom exponent 0.0032 and the inherited old ordinary saving +$384599/10^{10}$, the exact conversion gives + +\[ +(1-0.0032)\,0.00313+0.0032\frac{384599}{10^{10}} +=\frac{9750334599}{3125000000000} +=0.00312010707168>0.00312. +\] + +The complex outer ledger uses this certified ordinary saving 0.00312 and + +\[ +b=\kappa+5d,\quad a=\kappa+4d,\quad q=\kappa+3d, +\quad\epsilon=1-d,\quad\beta=1-3d, +\quad r_0=d/10,\quad\mathrm{stop}=\mathrm{layout}=d. +\] + +The authenticated outer ledger checks all 54 strict predicates and the +three inherited functional predicates. A fourth functional predicate +binds the actual BIT atom exponent $\delta_{\rm BIT}=0.0032$: + +\[ +\beta(1-\delta_{\rm BIT}) +=\beta\frac{623}{625} +=\frac{622999999733}{625000000000}>0. +\] + +The inherited BIT stock predicate uses the old atom $0.003$; retaining +that predicate does not replace this check for the actual supplier. +The new inequality also follows from the BIT certificate's stronger +$\delta_{\rm BIT}<1-a_{\rm ordinary}$ and the outer $\beta>0$. +It is a stock condition for the BIT atom, while copied-query work is +charged by the finite envelope in the next section. + +Every strict and functional value is positive. The limiting +main-transform margin above $\kappa$ is exactly + +\[ +\frac{10489496313}{24500000000000000000}. +\] + +Mutation controls reject closed precision/uniform gaps, a final endpoint +equal to the tested raw saving, and an insufficient ordinary BIT premise. + +## 6. Full finite costs, owned stock and precision + +The raw hybrid scalar invoice is 3500584. It includes the source native +words in two forward and seventeen backward orientations, both literal +controller boundary programs, all scalar bridges and signed swaps, and +64 pointwise real-scalar operations per direct port episode. In +particular it includes initialization, complete-stream copying, read/add, +and release of each of the 1792 owned direct copies. + +Movement is charged separately. Each direct episode has an allowance of +eight full-stream movement/control records, covering its two coordinate +routes, inverse translation, and the associated stream operations. Thus +the raw direct contribution is 14336 such records. All 8512 surviving +native contacts, every helper input/output normalizer, endpoint +normalizer, idle route, and whole-job matching route also belong to the +complete movement inventory. They are not absorbed by declaring a +rank-zero operation free. + +Use separate owned banks for every suspended native center and every +suspended direct copy. A raw hybrid invocation has 19 native center-bank +episodes and 1792 direct-copy episodes, for 1811 owned-bank episodes. Within +a direct stage the ports can be processed sequentially, but no such +reuse is needed to justify the conservative bound that counts every +episode. A copied stream remains allocated while its recursive request +executes. It is released only after its destination read/add is complete. +Distinct productive helpers retain their independent arbitrary inputs. + +After tensor substitution, target completion, disjoint splitting and +uniform compilation, count all actual expanded records. Let $U$ be the +number of raw hybrid instances in that finite recipe, and let $R$ count +all nonrecursive movement/normalization records, including every inherited +and new route. The conservative scalar envelope can use + +\[ +G=3500584\,U+8R. +\] + +Count every complete owned work-bank volume, with separate entries for +nested suspended copies and centers. Let $O$ be their conservative +total in the same complete-stream units used by the inherited closure, +$W$ the final productive width, and $P$ the final paid rank-one leaf +count. Completion and compiler temporaries, if allocated, also enter +$O$; they are not inferred from the raw 1811 figure alone. Substitute +these enlarged fixed counts in the retained envelope + +\[ +\begin{aligned} +Z&=W+O,\\ +E&=64(Z+N+P+G+1)^3,\\ +B_{\rm const}&=P+E,\\ +C_0&=32N B_{\rm const}^2. +\end{aligned} +\] + +All these counts are finite and specified by the complete chronological +recipe. In particular, both monomial boundary factors of every retimed +helper and every new internal transport recipe enter the movement count. +The fixed-template precision, recurrence and eventual absorption +arguments use these new constants. Numerical allowances from the old +small p7 word are not substituted for the expanded program. Coordinate +permutations and unit phases have zero coefficient height but still have +movement and owned-stock costs. + +This use of the enlarged constants retains the inherited all-column +physical, fine-prime, analytic, stock, fixed-tape and recovery hypotheses. +The finite scripts certify their explicit arithmetic inputs and the +modified native contracts. The final theorem is conditional on those +written premises. + +## 7. Reproduction and source separation + +From the repository root run + +```sh +python3 -I -O -B research/kappa-hybrid-controller/verify.py +``` + +The default complex source root is the existing +`research/pr4359-p7-padding/source` export. The default BIT source root is +the repository root. The retained `../fresh-helper-boundary/` package +provides the pinned PR4441 retiming and its complete phase recipes. +Explicit source-root arguments allow independent source preparation. +The verifier authenticates the exact original bytes, regenerates the +retimed local supplier and rational controller, checks the required +physical phases, and uses two independent rational interval engines. + +The default command compares the full regenerated receipt with +`RESULT.json`. `--write-result` writes those receipts when deliberately +rebuilding a changed construction. Geometry gzip files are compared by +their canonical uncompressed JSON payload; the original source gzip +files retain their exact byte pins. + +The discovery program under `search/` is separate. Its floating scores +found the selected parameters. The positive construction receives exact +certificates; no global optimality or obstruction outside the searched +minimal-cut path family is claimed. diff --git a/research/kappa-hybrid-controller/README.md b/research/kappa-hybrid-controller/README.md new file mode 100644 index 0000000000..53df775133 --- /dev/null +++ b/research/kappa-hybrid-controller/README.md @@ -0,0 +1,295 @@ +# Retimed hybrid p17 controller: conditional kappa 0.003001053 + +This package constructs a conditional integer-multiplication exponent saving + +\[ +\boxed{\kappa=0.003001053},\qquad +T(n)=O\!\left(n(\log n)^{0.996998947}\right). +\] + +The increase over the conditional `0.00268647` proposal in +[PR4416](https://github.com/CrocSwap/integer-mult-bounds/pull/4416) is +`0.000314583`, or about **11.7099% in kappa**. It is also **1.3869% above** +the concurrent `0.00296` proposal in +[PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440). +These compare asymptotic exponent savings, not practical running times. + +The hybrid mechanism replaces selected full native invocations with directly +paid rank-one shears. Those stages produce no native helper outputs. Their +replacement also removes their transverse stage transform from every +productive endpoint and every idle request. A balanced controller with +17 main pairs gives the stronger complete moment after all these changes +are charged. The final construction uses the improved helper boundaries +from [PR4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441), +whose complete local native receipt is independently replayed here. The +updated PR4441 also certifies this same combined profile at `0.00300105`; +our final endpoint exceeds that value by `0.000000003`. +A separate native BIT construction admits saving `0.00312`, which supplies +the ordinary BIT premise of the outer proof. + +The frontier refresh found PR4440's independently developed query-thinning +construction and PR4441's helper retiming while this work was in progress. +The p17 schedule agrees with PR4440. After checking compatibility, we +replaced our initial fifteen-tail helper pruning with PR4441's stronger +supplier. A later refresh at 20:27 UTC found PR4441 had already combined the same +profile at a stronger endpoint than our initial certificate. We audited +that update, adopted it as the publication parent, and tightened our exact +endpoint. The complete updated PR4441 branch is retained unchanged as an +explicit source dependency. This package adds independent physical and +phase evidence, a broader bounded controller search, its own p6 BIT +supplier, and the small endpoint refinement. The combined profile itself +is concurrent work, not claimed as a new discovery unique to this package. + +This is a source-bound finite certificate and a conditional transfer proof. +It retains the PR4359/PR4416 line's stated native, whole-job matching, +spectator, mixed-compiler, precision, storage, analytic, fixed-tape and +exact-recovery premises. The scripts do not formally verify the full +multiplication theorem. The selected record at this package's base commit +still has kappa `0.0023`; this package does not change that record. + +## Construction + +The source complex controller uses local operators + +\[ +F_s=D_sS_y(Q^{-1}),\qquad B_s=D_sS_x(-Q). +\] + +Here `Q` is the central rank-one transform and `D_s` acts on the eight +transverse axes of stage `s`. The complete controller has an exact +factorization over the rational Laurent ring in `Q,D_0,...,D_34`. +Substituting `D_s=I` preserves that identity, including both `Q` and its +inverse. This substitution has a physical implementation: copy the source +into an owned scratch field, make its rank-one query, add the result into +the other main field, and erase the scratch field. The original source +field is preserved. Copies and scratch fields receive no productive credit. + +The selected controller has these exact parameters: + +| Parameter | Value | +| --- | ---: | +| Main pairs | 17 | +| Balanced cut | 8 | +| Original local stage positions | 35 | +| Retained-idle mask | 280378328416255 | +| Native-stage mask | 28633115307 | +| Native invocations | 19 | +| Direct shears | 16 | +| Paid direct rank-one queries | 1792 | +| Ambient rank retained for the proof | 281 | + +Stages `0`, all odd stages `1,3,...,33`, and stage `34` are native. Every +internal even stage `2,4,...,32` is a direct forward shear. Stage zero +therefore retains the original source geometry. All sixteen middle idle +requests become identity maps. The remaining initial and terminal idle +requests have ranks `16,24,...,72`; each rank occurs on 448 physical fields. + +The retimed native supplier changes 117 helper entrances, 42 helper exits +and 395 scalar contact frames. It preserves the logical scalar actions, +their order and coefficients, every warp contact, all main boundaries, +and the owned center program. Its 408 independent helper outputs have +profile `{4:26,5:2,7:29,8:42,9:309}`. The complete local paid profile is +`{1:2253,2:515,3:445,4:102,5:40,8:8}`. + +Two retained literal interpreters replay both orientations on all 632 +arbitrary local input columns. All 320 changed transport or helper-boundary +recipes are lowered with their exact absolute phases. The retiming +subsumes our original fifteen deleted helper tails; no extra lifetime +deletion remains. Relative to that earlier version, the final controller +saves 3344 paid calls. + +The nineteen native invocations have 7752 distinct helper inputs; the +seventeen main pairs contribute 3808 more inputs. The complete unit +therefore has **11560 independent productive fields** and **69273 paid +requests**. + +See [NATIVE.md](NATIVE.md) for the physical construction and source binding, +and [PROOF.md](PROOF.md) for the complete conditional transfer. + +## Complete rank invoice + +The table gives the productive and paid multiplicities of the complete +raw unit. A blank entry means zero. + +| Rank | Productive multiplicity | Paid multiplicity | +| ---: | ---: | ---: | +| 1 | | 44599 | +| 2 | | 9785 | +| 3 | | 8455 | +| 4 | 494 | 1938 | +| 5 | 38 | 760 | +| 7 | 551 | | +| 8 | 798 | 152 | +| 9 | 5871 | | +| 16 | | 448 | +| 17 | 448 | | +| 24 | | 448 | +| 25 | 448 | | +| 32 | | 448 | +| 33 | 448 | | +| 40 | | 448 | +| 41 | 448 | | +| 48 | | 448 | +| 49 | 448 | | +| 56 | | 448 | +| 57 | 448 | | +| 64 | | 448 | +| 65 | 448 | | +| 72 | | 448 | +| 73 | 448 | | +| 153 | 224 | | + +The rank-one moments are `T_1=260798` and `P_1=259998`, with surplus +`800`. Writing `T_tau` and `P_tau` for the two moments at `tau=1-C`, +the numerical discovery root of `T_tau-P_tau` is about +`0.003001054183175`. The proof uses the exact rational tested saving +`C=0.003001054` and the smaller final saving `kappa=0.003001053`. + +## Turning the raw moment into an admitted rule + +The raw productive and paid ranks overlap. The proof composes complete +native units chronologically before applying any global cover. It uses +distinct productive owners, preserves every paid position, and retains +separate owned scratch banks for suspended invocations. + +Take `v=17160` native factors, a paid cutoff `18^v`, and a productive floor +`19^v`. After the complete product, raise each smaller productive endpoint +to that floor with an explicitly paid transform on disjoint coordinates. +Split every oversized paid request, including these completion requests, +at the same cutoff. Thus every final paid rank is strictly smaller than +every final productive rank. + +The exact interval calculation certifies + +\[ +\alpha=\frac{P_\tau}{T_\tau}<1-\frac1{10000000000},\qquad +\gamma=\frac{259998}{18^C T_\tau}<\frac{9991}{10000},\qquad +\delta=\frac{11560\cdot19}{18^C T_\tau}<\frac67. +\] + +The full paid moment, including both original tails and paid productive +completion, is bounded by + +\[ +\alpha^v+2\gamma^v+2\delta^v +<\frac{262144250000429}{262144449839104}<1. +\] + +The proof then derives sufficient finite uniform-compiler parameters from +this enlarged word and checks the complete outer inequality ledger. It +recomputes the scalar, movement, owned-bank and precision envelopes for the +expanded finite program. The enormous tensor and uniform words are given +as finite recipes; they are not materialized or claimed to be practical. + +The BIT side uses six main pairs and thirteen native invocations. It keeps +the complete original idle operators, tensors the native program before a +single delayed cover, and obtains the exact ordinary saving + +\[ +\frac{9750334599}{3125000000000}=0.00312010707168>0.00312. +\] + +The native replay covers all 7039 arbitrary BIT input columns and all 117 +owned-copy episodes. The BIT proof is in the `bit/` directory. + +## Reproduction and evidence + +From the repository root, using Python 3.12: + +```sh +python3 -I -O -B research/kappa-hybrid-controller/verify.py +``` + +The verifier authenticates the retained source inputs, reconstructs the +complex Laurent factor and the integer invoice, replays the changed native +helper boundaries and direct query phases, and checks the complete +strictification and outer arithmetic. It preserves all 54 outer predicates +and adds an explicit fourth functional guard for the actual BIT atom +exponent `0.0032`. It uses independently implemented +rational interval calculations and compares regenerated receipts with +the committed result. Acceptance guards remain active under `-O`. + +The separate historical frontier audit is reproducible with +`python3 -I -O -B research/kappa-hybrid-controller/frontier/audit.py`. +Its independent outward integer interval engine checks updated PR4441 +and the fixed-profile ceiling; [frontier/REPORT.md](frontier/REPORT.md) +states its exact scope. + +`VERIFY.json` registers both replays and their 51 live input paths. `SOURCES.json` +pins repository provenance; `EXTERNAL-SOURCES.json` records the retained +source closure used by the native gates. `RESULT.json` and `certificates/` +contain the exact receipts. Explicit `--source-root`, `--bit-source-root` and `--retimed-source-root` +arguments allow separately prepared source checkouts. The default paths +use the already committed PR4416 source export and the original BIT files. +The retimed supplier additionally uses the unchanged PR4441 package and +its original source dependencies in the repository root. + +The search is a separate discovery artifact under `search/`. Its dynamic +program considers all cuts and native-count states in the stated +minimal-cut path family through `p=120`. Its scores use floating-point +arithmetic. Only the selected positive construction is promoted to exact +Laurent, native, phase and interval certificates. No global optimality or +barrier for other controllers is claimed. + +## Open next questions + +1. **Allow more local choices than native or direct.** A partly executed + supplier could retain some helper outputs while removing transverse + work. First derive its arbitrary-input operator and complete paid + invoice, then add that proven choice to the controller search. A local + tariff alone does not establish a valid supplier. +2. **Search beyond the minimal-cut path family.** Other idle masks, + controller graphs or asymmetric directions could improve the balance. + First produce an exact Laurent factorization and price every physical + idle before attempting a transfer. The present finite search gives no + obstruction outside its stated family. +3. **Reduce the sufficient tensor power.** The higher-moment method in + [PR4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433) + reduced the predecessor's finite constants without changing kappa. + Updated PR4441 already applies it to this invoice using power 1024. + To port that smaller sufficient power into this independent proof, + rederive the compiler constants with the ambient rank 281 retained + here and include every paid completion tail. A smaller power does + not itself improve the limiting kappa. +4. **Independently review the inherited transfer premises.** Replay the + exact native and arithmetic gates first, then check the all-column + matching, common-weight cover, precision and effective recovery + arguments against this enlarged program. Finite checks alone do not + settle those asymptotic premises. + +The same questions, including first steps and blockers, are recorded in +`TASK.json`. + +## Sources and credit + +Prepared for Cinna Davis (`1337isnot1337`) with substantial OpenAI +assistance. The final contribution supplies an independent source-bound native, +phase and conditional-transfer certificate for the retimed p17 profile, +with a slightly larger certified endpoint. The work also includes +the bounded controller search and a separately replayed p6 ordinary BIT +supplier. Our initial helper-tail pruning is subsumed by PR4441. + +Credit the concurrent +[PR4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440) +for the independently developed query-thinning mechanism and identical +p17 schedule, and +[PR4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441) +at `ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9` for the helper retiming +used in the final supplier. The combined result in updated PR4441 at +`5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39` is the publication parent +and is credited for the already combined profile. Both were prepared for the same contributor +in parallel sessions. Neither source is presented here as an uncredited +new invention. + +This work builds on zxv's +[PR4359](https://github.com/CrocSwap/integer-mult-bounds/pull/4359) +native reconstruction and delayed cover; the user's compiler refill and +native tensor work in +[PR4405](https://github.com/CrocSwap/integer-mult-bounds/pull/4405), +[PR4412](https://github.com/CrocSwap/integer-mult-bounds/pull/4412), +[PR4414](https://github.com/CrocSwap/integer-mult-bounds/pull/4414), and +[PR4416](https://github.com/CrocSwap/integer-mult-bounds/pull/4416); +and Jacob Alan Sussman's finite mixed compiler, Theorem 1G / PR4268. +The BIT local word retains DreamingOfClouds's PR589 and eumemic's +PR555/PR543 lineage. Retained source files preserve their own notices. +New contributions are under the repository's Apache-2.0 license. diff --git a/research/kappa-hybrid-controller/REPLAY.json b/research/kappa-hybrid-controller/REPLAY.json new file mode 100644 index 0000000000..f444629bc5 --- /dev/null +++ b/research/kappa-hybrid-controller/REPLAY.json @@ -0,0 +1,17 @@ +{ + "command": [ + "python3", + "-I", + "-O", + "-B", + "research/kappa-hybrid-controller/verify.py" + ], + "python": "3.12.14 (main, Aug 25 2026, 14:00:49) [Clang 22.1.3 ]", + "start_utc": "2026-10-21T20:45:02.127245+00:00", + "finish_utc": "2026-10-21T20:47:08.800859+00:00", + "duration_seconds": 126.674, + "exit_code": 0, + "stdout": "{\"kappa\": \"3001053/1000000000\", \"ordinary_BIT\": \"39/12500\", \"status\": \"PASS_SOURCE_BOUND_HYBRID_P17_AND_ORDINARY_BIT_P6\", \"tensor_power\": 17160, \"tested_saving\": \"1500527/500000000\", \"uniform_rank_exponent\": 15026650096742881962201}\n", + "stderr": "", + "scope": "Independent final default-path comparison with committed-style saved receipts; registered Git metadata runner not executed in this partial staging tree." +} diff --git a/research/kappa-hybrid-controller/RESULT.json b/research/kappa-hybrid-controller/RESULT.json new file mode 100644 index 0000000000..01ee7a03f7 --- /dev/null +++ b/research/kappa-hybrid-controller/RESULT.json @@ -0,0 +1,54143 @@ +{ + "endpoint": { + "BIT_validator_sha256": "9993c4b695740d41f56bfac0f4d016e7c62c6fef692fc09b0c01b6d67da7da7c", + "compiler": { + "H0": 357651736794440, + "H1": 15026650096742881962201, + "N_encoding": "2^15026650096742881962201", + "ambient_rank_encoding": "281^17160", + "delta": "1/14000000000", + "exit_coefficient_log2_upper": "88608", + "final_strict_power_gap": "1/14000000000", + "h": "1/55", + "materialized_tensor_rule_or_uniform_word": false, + "negative_log2_eta_upper": "32513793811/70000000", + "paid_max_bound_encoding": "18^17160", + "rank_one_induction": "260798^n > 259998^n; target padding adds equal paid and target rank, and splitting preserves rank", + "t": "498499473/500000000", + "target_max_encoding": "153^17160", + "target_min_encoding": "19^17160", + "tensor_power": 17160, + "theta_upper": "54/55", + "z": "6978992623/7000000000", + "z0": "2791597049/2800000000" + }, + "gain_over_PR4359": "701053/1000000000", + "gain_over_PR4405": "695963/1000000000", + "gain_over_PR4414": "321183/1000000000", + "gain_over_PR4416": "314583/1000000000", + "gain_over_allfresh_p3": "523503/1000000000", + "kappa": "3001053/1000000000", + "ledger_source_sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "minimum_outer_margin": "10489496313/24500000000000000000", + "negative_controls": { + "closed_epsilon": { + "actual_logarithmic_gamma_guard": "0", + "epsilon_below_one": "0", + "gaussian_above_main": "-31511061/24500000000000000000", + "global_gamma_power_slack": "-1/70000000000", + "new_semantic_guard_with_C1_one": "0", + "source_axis_superpolynomial": "0" + }, + "closed_uniform_gap": { + "new_complex_uniform_saving_above_b": "0" + }, + "insufficient_BIT": { + "actual_bit_above_effective": "-39259/56000000" + }, + "unfunded_outer_point": { + "boundary_algebraic_matrix_above_kappa": "-10510503687/24500000000000000000", + "fused_gaussian_above_kappa": "-10531511061/24500000000000000000", + "global_coordinate_router_above_kappa": "-3/7000000000", + "group_bit_router_above_kappa": "-112504177/392000000000000000", + "main_transform_above_kappa": "-14010503687/24500000000000000000" + } + }, + "ordinary_BIT_certificate": { + "admitted_BIT_saving": "39/12500", + "alpha_upper": "99999/100000", + "arithmetic_dependency_sha256": "7ac72da26df21a0bef1ed15cb500468cf94b328e86efd1ed60a7a0016db415c0", + "compiled_uniform_saving": "627/200000", + "complete_normalized_paid_moment_upper": "1653/1696", + "cover": { + "complete_moment_upper": "800001/800002", + "gap": "1/200000", + "prime_coefficient_times_N5": "51200000" + }, + "covered_saving": "313/100000", + "cutoff_encoding": "7^6000", + "gamma_upper": "999/1000", + "materialized_tensor_or_uniform_word": false, + "native_source": { + "COPY_or_ERASE_records": 234, + "all_arbitrary_columns": 7039, + "ambient_rank": 92, + "common_weight_contract": "All original port charts and every product/compiler matcher are fixed rational right routes in one final cover. No intermediate covered child is lowered.", + "exact_factorization": { + "boundary_unit_ADDs_per_port": 48, + "coefficient_projectors": { + "14337": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1024, + 2048 + ], + "15": [ + 5, + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "15873": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 256, + 512, + 0, + 0 + ], + "16383": [ + 64, + 0, + 64, + 0, + 64, + 0, + 64, + 170, + 0, + 0, + 0, + 0 + ], + "255": [ + 80, + 0, + 80, + 0, + 80, + 42, + 0, + 42, + 0, + 0, + 0, + 0 + ], + "63": [ + 20, + 0, + 20, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "diagonal_monomials": [ + 15, + 15, + 63, + 63, + 255, + 255, + 14337, + 14337, + 15873, + 15873, + 16383, + 16383 + ], + "full_coefficient_endpoint_sha256": "bf485e1f07f44b15757bccec1a7c23e2887a8dbef22943b5ff2426fa21fbb0a6", + "left_program": [ + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 7, + 10 + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 2, + 6 + ], + [ + "ADD", + 0, + 6 + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 10, + 5 + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 0, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 10, + 3 + ], + [ + "ADD", + 4, + 3 + ], + [ + "ADD", + 0, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 10, + 1 + ], + [ + "ADD", + 4, + 1 + ], + [ + "ADD", + 2, + 1 + ] + ], + "left_rows": [ + 5, + 2, + 10, + 20, + 42, + 80, + 1024, + 2048, + 256, + 512, + 170, + 64 + ], + "right_program": [ + [ + "ADD", + 5, + 11 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 7, + 11 + ], + [ + "SWAP", + 6, + 10 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 7, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 0, + 3 + ], + [ + "ADD", + 5, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 1 + ] + ], + "right_rows": [ + 2089, + 2, + 2088, + 6, + 2080, + 20, + 2048, + 1040, + 256, + 512, + 64, + 128 + ] + }, + "expanded_chart_identity": "Gamma=I-EE^t+E rho E^t; Gamma^2=I92, active identity on im(E), identity on its orthogonal complement", + "helper_owners": [ + { + "first": 1332, + "last_exclusive": 1771, + "stage": 0 + }, + { + "first": 1771, + "last_exclusive": 2210, + "stage": 1 + }, + { + "first": 2210, + "last_exclusive": 2649, + "stage": 2 + }, + { + "first": 2649, + "last_exclusive": 3088, + "stage": 3 + }, + { + "first": 3088, + "last_exclusive": 3527, + "stage": 4 + }, + { + "first": 3527, + "last_exclusive": 3966, + "stage": 5 + }, + { + "first": 3966, + "last_exclusive": 4405, + "stage": 6 + }, + { + "first": 4405, + "last_exclusive": 4844, + "stage": 7 + }, + { + "first": 4844, + "last_exclusive": 5283, + "stage": 8 + }, + { + "first": 5283, + "last_exclusive": 5722, + "stage": 9 + }, + { + "first": 5722, + "last_exclusive": 6161, + "stage": 10 + }, + { + "first": 6161, + "last_exclusive": 6600, + "stage": 11 + }, + { + "first": 6600, + "last_exclusive": 7039, + "stage": 12 + } + ], + "independent_dirty_helpers": 5707, + "keep": 25279, + "local_all_f_lift": "Every head projector and chart is tensor-multiplied by I_f; the reversed tail block uses C_(Nf). Polynomial identities remain exact, and routes change only cover coordinates.", + "local_audit": "PASS_FULL_LOCAL_COLUMNS_AND_EXACT_PROJECTORS", + "main_endpoints": [ + { + "central_q": true, + "rank": 22, + "role": 0, + "stages": [ + 0, + 1, + 2 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 1, + "stages": [ + 0, + 1, + 2 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 2, + "stages": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 3, + "stages": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "central_q": true, + "rank": 50, + "role": 4, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "central_q": true, + "rank": 50, + "role": 5, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 6, + "stages": [ + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 7, + "stages": [ + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 8, + "stages": [ + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 9, + "stages": [ + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 92, + "role": 10, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 92, + "role": 11, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12 + ] + } + ], + "nonidentity_port_routes_including_inverses": 5328, + "original_p3_audit": "PASS_FIXED_RATIONAL_PORTS_AND_PHYSICAL_ENDPOINTS", + "owned_COPY_episodes": 117, + "paid": { + "1": 17199, + "14": 444, + "2": 17446, + "28": 444, + "3": 1027, + "4": 572, + "42": 222, + "5": 1326, + "6": 143, + "7": 1357 + }, + "pairs": 6, + "scalar_ADD_allowance": 326621, + "source_generator_sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "source_port_audit_sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "source_sha256": { + "DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "MIXED-PRODUCTIVE-BIT.json": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf", + "bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "sources/pr589-regenerated/WORD.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "sources/pr589-regenerated/records/249-records.bin": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a", + "sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "stage_chart_embeddings": [ + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ], + "spectator_axes": [ + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 1 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 15, + 16, + 17, + 18, + 19, + 20, + 21 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 2 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 22, + 23, + 24, + 25, + 26, + 27, + 28 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 3 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 29, + 30, + 31, + 32, + 33, + 34, + 35 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 4 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 36, + 37, + 38, + 39, + 40, + 41, + 42 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 5 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 43, + 44, + 45, + 46, + 47, + 48, + 49 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 6 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 50, + 51, + 52, + 53, + 54, + 55, + 56 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 7 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 8 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 9 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 71, + 72, + 73, + 74, + 75, + 76, + 77 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 10 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 78, + 79, + 80, + 81, + 82, + 83, + 84 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 11 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84 + ], + "stage": 12 + } + ], + "stages": 13, + "status": "PASS_P6_EXACT_NATIVE_PORTS_ARBITRARY_COLUMNS_AND_WHOLE_IDLES", + "targets": { + "22": 444, + "36": 444, + "50": 222, + "8": 5707, + "92": 222 + }, + "whole_idle_windows": [ + { + "index": 0, + "kind": "initial", + "pair": 1, + "rank": 14, + "retained": true, + "stages": [ + 0, + 1 + ] + }, + { + "index": 1, + "kind": "middle", + "pair": 1, + "rank": 7, + "retained": true, + "stages": [ + 2 + ] + }, + { + "index": 2, + "kind": "initial", + "pair": 2, + "rank": 28, + "retained": true, + "stages": [ + 0, + 1, + 2, + 3 + ] + }, + { + "index": 3, + "kind": "middle", + "pair": 2, + "rank": 7, + "retained": true, + "stages": [ + 4 + ] + }, + { + "index": 4, + "kind": "initial", + "pair": 3, + "rank": 42, + "retained": true, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + }, + { + "index": 5, + "kind": "middle", + "pair": 3, + "rank": 7, + "retained": true, + "stages": [ + 6 + ] + }, + { + "index": 7, + "kind": "middle", + "pair": 4, + "rank": 7, + "retained": true, + "stages": [ + 8 + ] + }, + { + "index": 9, + "kind": "middle", + "pair": 5, + "rank": 7, + "retained": true, + "stages": [ + 10 + ] + }, + { + "index": 13, + "kind": "terminal", + "pair": 3, + "rank": 28, + "retained": true, + "stages": [ + 9, + 10, + 11, + 12 + ] + }, + { + "index": 14, + "kind": "terminal", + "pair": 4, + "rank": 14, + "retained": true, + "stages": [ + 11, + 12 + ] + } + ] + }, + "ordinary": { + "admission_gap": "334599/3125000000000", + "atom_power": "2/625", + "linear_adapter_gap": "249665401/3125000000000", + "old_saving": "384599/10000000000", + "stock_absorption_gap": "3105249665401/3125000000000" + }, + "ordinary_saving": "9750334599/3125000000000", + "paid": { + "1": 17199, + "14": 444, + "2": 17446, + "28": 444, + "3": 1027, + "4": 572, + "42": 222, + "5": 1326, + "6": 143, + "7": 1357 + }, + "paid_rank_mass": 102419, + "positive_rank_surplus": 513, + "status": "PASS_EXACT_P6_BIT_TENSOR_AND_ORDINARY_ARITHMETIC", + "strictification_margin": "43/1696", + "target_rank_mass": 102932, + "targets": { + "22": 444, + "36": 444, + "50": 222, + "8": 5707, + "92": 222 + }, + "tensor_power": 6000, + "tested_saving": "157/50000", + "uniform_compiler": { + "H0": 850090000, + "H1": 1066862950001, + "N_encoding": "2^1066862950001", + "delta": "1/400000", + "exit_log2_upper": "20625", + "h": "1/16", + "negative_log2_eta_upper": "5311/40", + "theta_upper": "15/16" + }, + "verifier_sha256": "9993c4b695740d41f56bfac0f4d016e7c62c6fef692fc09b0c01b6d67da7da7c" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "622999999733/625000000000", + "fixed_halo_explicit_metadata_branch": "134750000001/1750000000", + "new_BIT_row_stock_sublinear_in_active_group": "6978999997009/7000000000000", + "new_semantic_group_guard": "3/7000000000" + }, + "margins": { + "boundary_algebraic_matrix": "73525812489496313/24500000000000000000", + "fused_gaussian": "73525812468488939/24500000000000000000", + "global_coordinate_router": "168059/56000000", + "group_bit_router": "1176413055495823/392000000000000000", + "group_scans": "3499999999/3500000000", + "main_transform": "73525808989496313/24500000000000000000", + "microbox_face_corrections": "134750000001/1750000000", + "polynomial_products": "6999999999/7000000000", + "sparse_union_movement": "10026650812489496313/24500000000000000000" + }, + "parameters": { + "a": "168059/56000000", + "b": "1312961/437500000", + "beta": "6999999997/7000000000", + "bit_saving": "39/12500", + "cap_xi": "22276650808989496313/24500000000000000000", + "complex_uniform_saving": "21007377/7000000000", + "d": "1/7000000000", + "epsilon": "6999999999/7000000000", + "kappa": "3001053/1000000000", + "lambda_": "1993997893/2000000000", + "lambda_prime": "3489496313/3500000000", + "layout": "1/7000000000", + "q": "10503687/3500000000", + "r0": "1/70000000000", + "stop": "1/7000000000", + "tested_saving": "1500527/500000000" + }, + "strict_checks": { + "actual_bit_above_effective": "6661/56000000", + "actual_logarithmic_gamma_guard": "1/7000000000", + "actual_logarithmic_group_guard": "2223349196260503687/12250000000000000000", + "alpha_logarithm_absorption": "1/70000000000", + "boundary_algebraic_matrix_above_kappa": "13989496313/24500000000000000000", + "cap_above_band": "10026650808989496313/24500000000000000000", + "cap_below_cell": "2223349187510503687/24500000000000000000", + "cap_below_phase_cell_power": "26723349191010503687/24500000000000000000", + "complex_above_effective": "1/7000000000", + "complex_below_one_over_32": "6179457/218750000", + "complex_endpoint": "1/3500000000", + "epsilon_below_one": "1/7000000000", + "epsilon_positive": "6999999999/7000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "13968488939/24500000000000000000", + "gaussian_above_main": "1739496313/12250000000000000000", + "global_coordinate_router_above_kappa": "1/1750000000", + "global_gamma_power_slack": "9/70000000000", + "group_below_dimension": "1/3500000000", + "group_bit_router_above_kappa": "279495823/392000000000000000", + "group_gauge_power_slack": "2223349196085503687/12250000000000000000", + "group_key_fits_record": "1/3500000000", + "group_positive": "6999999997/7000000000", + "group_scans_above_kappa": "6978992627/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "635041290400418148631/500000000000000000000000", + "lambda_above_internal": "1/14000000000", + "lambda_above_sigma": "3/14000000000", + "lambda_above_tau": "1/14000000000", + "lambda_prime_above_lambda": "1/14000000000", + "lambda_prime_above_leaf": "873687039/3062500000000000000", + "leaf_saving_above_effective": "436187039/3062500000000000000", + "main_transform_above_kappa": "10489496313/24500000000000000000", + "membership_arithmetic_fits_record": "1/7000000000", + "microbox_face_corrections_above_kappa": "538978992633/7000000000", + "microbox_halo_volume": "553000000003/7000000000", + "new_complex_uniform_saving_above_b": "1/7000000000", + "new_semantic_guard_with_C1_one": "1/7000000000", + "polynomial_products_above_kappa": "1744748157/1750000000", + "positive_layout_slack": "1/7000000000", + "q_below_effective": "1/7000000000", + "q_below_internal": "1/7000000000", + "q_below_leaf": "873687039/3062500000000000000", + "q_positive": "10503687/3500000000", + "short_record_fallback": "436187039/437500000", + "source_axis_superpolynomial": "1/7000000000", + "sparse_union_movement_above_kappa": "9953125013989496313/24500000000000000000", + "stop_below_one": "6999999999/7000000000", + "stop_positive": "1/7000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/7000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/7000000000", + "union_tag_work_per_visit_fits_record": "3/7000000000" + } + }, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "schema": "hybrid-p17-padding-outer-endpoint/1", + "scope": "Source-bound PR4441 retimed arbitrary-input local word, p17 native/direct geometry, a finite tensor recipe with target padding, exact moment and outer inequalities, and a specified finite uniform rank. Native tensor closure and the PR4359 inherited precision, storage, analytic, fixed-tape and recovery hypotheses are written premises, not a full formal theorem certificate.", + "status": "PASS_CONDITIONAL_HYBRID_P17_OUTER_POINT", + "strictification_source_sha256": "8028ebd0f83e59bbba1c5f0dd760adb3050c4dce660d675f48eb227ff4649904", + "tested_saving": "1500527/500000000" + }, + "implementation_sha256": { + "bit/bit_p6_tensor_extension.py": "9993c4b695740d41f56bfac0f4d016e7c62c6fef692fc09b0c01b6d67da7da7c", + "bit/bit_tensor_extension.py": "7ac72da26df21a0bef1ed15cb500468cf94b328e86efd1ed60a7a0016db415c0", + "controller/make_direct_case.py": "f527528ff19b107427d593bf35481e127154831563179eed3f43f365177d4585", + "endpoint.py": "79c469fc7fedd0740ee167266390413a1bc8a5c7ef003065d1f55681d724b5de", + "local_supplier.py": "8542575d046c9488574dbf1ca258bbdc6ff7dc66db778cba3b0027b7b4673653", + "native_geometry.py": "fe4e7d689df8af865dc0ae16bcbac9cb50e988efd24f3ff99ac52b498cd6c60a", + "native_inventory.py": "d23bc658af0196f26a5bcd101e11b496f0430b96c0a5974d92e485002d0f68d8", + "parameters.py": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "strictification.py": "8028ebd0f83e59bbba1c5f0dd760adb3050c4dce660d675f48eb227ff4649904", + "verify.py": "537bacce0287d28e4296047468cac429250b9fc600800706fc5a806edacf67fd" + }, + "independent_interval_crosscheck": true, + "schema": "hybrid-p17-complete-conditional-certificate/1", + "scope": "Fresh finite retimed native replay, all helper phases, full native/direct p17 geometry, two independent interval engines, explicit uniform ranks, native BIT and all outer inequalities. All-column tensor, route-cost, precision, stock, analytic, fixed-tape and recovery assumptions remain the inherited written premises.", + "status": "PASS_SOURCE_BOUND_HYBRID_P17_AND_ORDINARY_BIT_P6", + "strictification": { + "alpha_interval": { + "lower": "0.99999999981197332875426410809243316", + "upper": "0.99999999981197332875426410809243317" + }, + "alpha_upper": "9999999999/10000000000", + "ambient_rank_encoding": "281^17160", + "completion_decay_block_length": 5, + "controls": { + "one_decay_block_rejected": true, + "undamped_completion_rejected": true, + "unpadded_rank_one_tail_rejected": true + }, + "cutoff_base": 18, + "cutoff_encoding": "18^17160", + "decay_block_count": 22, + "decay_block_length": 780, + "delta_interval": { + "lower": "0.84399113766577138522456189514008497", + "upper": "0.84399113766577138522456189514008498" + }, + "delta_upper": "6/7", + "exponent": 17160, + "gamma_interval": { + "lower": "0.99907124299228386730839393376721823", + "upper": "0.99907124299228386730839393376721824" + }, + "gamma_upper": "9991/10000", + "materialized_tensor_or_completed_word": false, + "native_inventory": { + "all_column_direct_recipe": "At f columns the address map is P tensor I_f (or I_f tensor P in column order), with its induced per-column array permutation. Use one Gaussian child of rank f, inverse route and repeated q translation for C_q inverse. The request has the complete ancestor weight.", + "artifact_hash_encoding": "Uncompressed UTF-8 JSON, sort_keys=True, separators=(comma,colon)", + "artifact_sha256": "a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034", + "case_sha256": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "dimension": 281, + "direct_nonrecursive_movement_records_allowance": 14336, + "direct_owned_copy_episodes": 1792, + "direct_owned_release_episodes": 1792, + "direct_paid_queries": 1792, + "direct_productive_scratch_endpoints": 0, + "direct_query_rank_for_f_columns": "f, with the same ancestor weight; never f rank-one column queries", + "direct_scalar_allowance": 114688, + "direct_scratch_ownership": "Copy source to an owned zero array; query that copy; add to destination; release. No arbitrary helper or productive scratch credit.", + "direct_stage_indices": [ + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32 + ], + "direct_stages": 16, + "factor_factory": { + "artifacts": { + "P17-DIRECT-CASE.json": "00247ee53b39cf01e176d93b8035bbdb18e7669f969b4ab576130205ae02d0df", + "P17-FULL-LAURENT-CASE.json": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33" + }, + "direct_rank1_children": 1792, + "incorrect_backward_sign_rejected": true, + "native_invocations": 19, + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + "status": "PASS_EXACT_P17_LAURENT_SPECIALIZATION" + }, + "factor_factory_source_sha256": "f527528ff19b107427d593bf35481e127154831563179eed3f43f365177d4585", + "fresh_helper_fields": 7752, + "geometry_payload_sha256": "a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034", + "geometry_source_sha256": "fe4e7d689df8af865dc0ae16bcbac9cb50e988efd24f3ff99ac52b498cd6c60a", + "keep": 280378328416255, + "laurent": { + "input_columns": 34, + "literal_events": 341, + "matrix_entries": 1156 + }, + "limits": "Complete finite native/direct controller admission. The common-column tensor rule, expanded fixed route/scalar/owned-stock bounds and inherited precision, analytic, fixed-tape and exact-recovery premises are written separately in PROOF.md.", + "local_profiles": "Independently audited PR4441 retimed local supplier; the enclosing native_inventory reruns its complete literal and phase gate.", + "local_supplier": { + "all_408_helpers_arbitrary": true, + "all_scalar_actions_and_order_unchanged": true, + "all_warp_contacts_unchanged": true, + "authenticated_original_files": 23, + "boundary_movement_allowance": "Every new whole-helper left/right monomial and transport recipe contributes its full finite route and phase cost.", + "distinct_physical_edge_and_boundary_recipes": 320, + "external_main_boundaries_unchanged": true, + "fresh_arbitrary_input_fields": 632, + "inherited_native_gate": { + "ambient_rank": 57, + "controls": { + "raw_rule_not_strictly_separated": true, + "whole_idle_missing_phase_rejected_count": 224, + "wrong_intermediate_center_rejected": true + }, + "fresh_helper_fields": 2856, + "main_fields": 672, + "native_scalar_allowance": 1147304, + "paid": { + "1": 17409, + "16": 448, + "2": 4991, + "3": 1568, + "4": 714, + "5": 140, + "8": 504 + }, + "paid_calls": 25774, + "productive_fields": 3528, + "rank_surplus": 224, + "restored_native_centers": 56, + "schema": "native-all-fresh-full-idle-inventory/1", + "scope": "Exact finite all-fresh controller inventory. Native all-column closure is inherited; the raw rule requires the separate tensor strictification before the old strict compiler applies.", + "source_head": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/kappa-rebuild/complex/fresh-certificates/THREE-base-HELPER-BOUNDARIES.json.gz": "f90517e395bde58c72cacd5d3481c4ea31d459fe4535384ac16547ac40460555", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "research/kappa-rebuild/complex/full_identity_rebuild.py": "9af2ffbb0038c92e2a7d281081b0daaeadce75b11b566e5427845dc1af91e33d", + "research/kappa-rebuild/controller/P3-NATIVE-COVER.json.gz": "facfc6d6ecde151afb7e6a167776f3fdaac1c816e785a21a39f7f0bfd9140f3f", + "research/kappa-rebuild/controller/p3_native_cover.py": "fae71fcbbd20b9ee73b049cf6f43ea1d048217fb15feb6055a007e47da3363fe", + "research/kappa-rebuild/transfer-audit/p3_cover_audit.py": "a0fe9a26f77556e83b31b0c91fea909d6f3d8209d0f9f7ad4e5bc1375d33615e" + }, + "status": "PASS_ACTUAL_ARBITRARY_HELPERS_AND_COMPLETE_PHASE_CORRECT_IDLE_JOBS", + "targets": { + "25": 448, + "5": 196, + "57": 224, + "6": 126, + "7": 392, + "8": 651, + "9": 1491 + }, + "whole_idle_profile": { + "16": 448, + "8": 448 + } + }, + "local_helper_profile": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "local_paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "local_replays": { + "backward": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + }, + "forward": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + }, + "retimed_artifact_sha256": { + "CHANGES.json": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "NATIVE-RESULT.json.gz": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29" + }, + "retimed_native_receipt": { + "changed_entrances": 117, + "changed_exits": 42, + "changed_scalar_frames": 395, + "helpers": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "native": { + "backward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 6396, + "role": [ + "L", + 225 + ] + }, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158168, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + }, + "forward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 19099, + "role": [ + "L", + 224 + ] + }, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158120, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + } + }, + "new_physical_edges_and_boundaries": [ + { + "new": 1, + "old": 0, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 139, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 8, + 17, + 33, + 64, + 3, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 65, + 33, + 2, + 100, + 104, + 16, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 108, + 0, + 109, + 109, + 0, + 13, + 13, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 8, + 17, + 33, + 64, + 3, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 65, + 33, + 2, + 100, + 104, + 16, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 108, + 0, + 109, + 109, + 0, + 13, + 13, + 0, + 0 + ] + } + } + } + }, + { + "new": 140, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 19, + 35, + 2, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 173, + 14, + 257, + 18, + 276, + 280, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 429, + 30, + 435, + 435, + 14, + 429, + 0, + 429, + 173 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 19, + 35, + 2, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 173, + 14, + 257, + 18, + 276, + 280, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 429, + 30, + 435, + 435, + 14, + 429, + 0, + 429, + 173 + ] + } + } + } + }, + { + "new": 141, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 35, + 65, + 136, + 258, + 3, + 1, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 6, + 19, + 384, + 264, + 97, + 34, + 68, + 392, + 112 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 115, + 53, + 70, + 136, + 115, + 19, + 21, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 35, + 65, + 136, + 258, + 3, + 1, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 6, + 19, + 384, + 264, + 97, + 34, + 68, + 392, + 112 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 115, + 53, + 70, + 136, + 115, + 19, + 21, + 136, + 0 + ] + } + } + } + }, + { + "new": 254, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 264, + 4, + 10, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 4, + 34, + 16, + 64, + 128, + 256, + 42 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 264, + 4, + 10, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 4, + 34, + 16, + 64, + 128, + 256, + 42 + ], + "offset": 245, + "phase": 2, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 255, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 133, + 260, + 1, + 7, + 8, + 3, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 3, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 15, + 16, + 64, + 128, + 256, + 45, + 42 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 34, + 39, + 38, + 40, + 0, + 15, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 133, + 260, + 1, + 7, + 8, + 3, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 15, + 16, + 64, + 128, + 256, + 45, + 42 + ], + "offset": 125, + "phase": 2, + "quadratic_rows": [ + 34, + 39, + 38, + 40, + 0, + 15, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 259, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 127, + "phase": 3, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 260, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 294, + 6, + 8, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 98, + 8, + 16, + 70, + 128, + 256, + 102 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 66, + 36, + 0, + 0, + 36, + 2, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 294, + 6, + 8, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 98, + 8, + 16, + 70, + 128, + 256, + 102 + ], + "offset": 219, + "phase": 2, + "quadratic_rows": [ + 0, + 66, + 36, + 0, + 0, + 36, + 2, + 0, + 0 + ] + } + } + } + }, + { + "new": 264, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 267, + 3, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 73, + 4, + 67, + 16, + 32, + 128, + 256, + 75 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 10, + 0, + 10, + 0, + 0, + 1, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 267, + 3, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 73, + 4, + 67, + 16, + 32, + 128, + 256, + 75 + ], + "offset": 245, + "phase": 2, + "quadratic_rows": [ + 65, + 10, + 0, + 10, + 0, + 0, + 1, + 0, + 0 + ] + } + } + } + }, + { + "new": 269, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 274, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 258, + 3, + 1, + 4, + 8, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 5, + 8, + 16, + 32, + 64, + 128, + 256, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 258, + 3, + 1, + 4, + 8, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 5, + 8, + 16, + 32, + 64, + 128, + 256, + 7 + ], + "offset": 252, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 272, + 8, + 20, + 4, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 48, + 8, + 36, + 64, + 128, + 256, + 52 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 272, + 8, + 20, + 4, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 48, + 8, + 36, + 64, + 128, + 256, + 52 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 318, + 3, + 5, + 9, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 126, + 125, + 123, + 119, + 111, + 95, + 128, + 256, + 127 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 318, + 3, + 5, + 9, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 126, + 125, + 123, + 119, + 111, + 95, + 128, + 256, + 127 + ], + "offset": 192, + "phase": 2, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 264, + 12, + 16, + 32, + 4, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 72, + 68, + 16, + 32, + 128, + 256, + 76 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 264, + 12, + 16, + 32, + 4, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 72, + 68, + 16, + 32, + 128, + 256, + 76 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 282, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 132, + 262, + 2, + 7, + 3, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 2, + 15, + 32, + 64, + 128, + 256, + 25, + 30 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 23, + 17, + 21, + 24, + 15, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 132, + 262, + 2, + 7, + 3, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 2, + 15, + 32, + 64, + 128, + 256, + 25, + 30 + ], + "offset": 126, + "phase": 2, + "quadratic_rows": [ + 23, + 17, + 21, + 24, + 15, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 283, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 139, + 3, + 264, + 4, + 9, + 1, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 2, + 3, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 8, + 23, + 64, + 128, + 256, + 51, + 52 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 21, + 38, + 39, + 0, + 49, + 22, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 139, + 3, + 264, + 4, + 9, + 1, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 8, + 23, + 64, + 128, + 256, + 51, + 52 + ], + "offset": 125, + "phase": 2, + "quadratic_rows": [ + 21, + 38, + 39, + 0, + 49, + 22, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 284, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 285, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 290, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 132, + 266, + 12, + 2, + 16, + 6, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 68, + 32, + 128, + 256, + 82, + 76 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 0, + 26, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 132, + 266, + 12, + 2, + 16, + 6, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 68, + 32, + 128, + 256, + 82, + 76 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 0, + 26, + 0, + 0 + ] + } + } + } + }, + { + "new": 291, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 144, + 270, + 6, + 10, + 2, + 17, + 1, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 2, + 12, + 12, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 0, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 96, + 2, + 26, + 22, + 65, + 128, + 256, + 97, + 30 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 12, + 12, + 2, + 33, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 144, + 270, + 6, + 10, + 2, + 17, + 1, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 2, + 12, + 12, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 0, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 96, + 2, + 26, + 22, + 65, + 128, + 256, + 97, + 30 + ], + "offset": 98, + "phase": 3, + "quadratic_rows": [ + 33, + 18, + 12, + 12, + 2, + 33, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 293, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 67, + 131, + 2, + 1, + 264, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 3, + 0 + ], + "matrix_rows": [ + 13, + 14, + 384, + 320, + 33, + 18, + 52, + 56, + 448 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 45, + 30, + 51, + 51, + 14, + 13, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 67, + 131, + 2, + 1, + 264, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 3, + 0 + ], + "matrix_rows": [ + 13, + 14, + 384, + 320, + 33, + 18, + 52, + 56, + 448 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 45, + 30, + 51, + 51, + 14, + 13, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 294, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 45, + 67, + 10, + 4, + 135, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 10, + 12, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 1, + 1, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 509, + 507, + 258, + 321, + 266, + 276, + 288, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 326, + 15, + 275, + 250, + 252, + 248, + 249, + 248, + 5 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 45, + 67, + 10, + 4, + 135, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 10, + 12, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 1, + 1, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 509, + 507, + 258, + 321, + 266, + 276, + 288, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 326, + 15, + 275, + 250, + 252, + 248, + 249, + 248, + 5 + ] + } + } + } + }, + { + "new": 296, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 60, + 6, + 82, + 8, + 138, + 16, + 282, + 26 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 28, + 30, + 22, + 14, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 1, + 252, + 258, + 246, + 222, + 262, + 280, + 352, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 46, + 470, + 306, + 476, + 330, + 500, + 468, + 252 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 60, + 6, + 82, + 8, + 138, + 16, + 282, + 26 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 28, + 30, + 22, + 14, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 3, + 2, + 3, + 1, + 0 + ], + "matrix_rows": [ + 1, + 252, + 258, + 246, + 222, + 262, + 280, + 352, + 384 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 0, + 46, + 470, + 306, + 476, + 330, + 500, + 468, + 252 + ] + } + } + } + }, + { + "new": 298, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 37, + 68, + 7, + 130, + 1, + 272, + 3, + 24, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 24, + 24, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 3, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 1, + 28, + 23, + 384, + 288, + 85, + 70, + 88, + 416 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 66, + 83, + 28, + 76, + 22, + 160, + 11, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 37, + 68, + 7, + 130, + 1, + 272, + 3, + 24, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 24, + 24, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 1, + 28, + 23, + 384, + 288, + 85, + 70, + 88, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 66, + 83, + 28, + 76, + 22, + 160, + 11, + 160, + 0 + ] + } + } + } + }, + { + "new": 299, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 1, + 3, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 301, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 35, + 69, + 128, + 270, + 3, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 390, + 19, + 21, + 145, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 35, + 69, + 128, + 270, + 3, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 2, + 2, + 0, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 390, + 19, + 21, + 145, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ] + } + } + } + }, + { + "new": 303, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 1, + 2, + 3, + 3, + 1, + 2 + ], + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ] + } + } + } + }, + { + "new": 304, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 45, + 70, + 141, + 6, + 256, + 3, + 10, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 4, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 389, + 14, + 138, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 462, + 351, + 411, + 351, + 14, + 0, + 11, + 389, + 143 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 45, + 70, + 141, + 6, + 256, + 3, + 10, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 4, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 1, + 2, + 0, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 389, + 14, + 138, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 462, + 351, + 411, + 351, + 14, + 0, + 11, + 389, + 143 + ] + } + } + } + }, + { + "new": 305, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ] + } + } + } + }, + { + "new": 307, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 46, + 78, + 131, + 3, + 261, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 424, + 14, + 38, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 46, + 78, + 131, + 3, + 261, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 424, + 14, + 38, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ] + } + } + } + }, + { + "new": 308, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ] + } + } + } + }, + { + "new": 309, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 46, + 64, + 131, + 261, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 408, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 379, + 379, + 0, + 467, + 427, + 19, + 11, + 408, + 155 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 46, + 64, + 131, + 261, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 408, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 379, + 379, + 0, + 467, + 427, + 19, + 11, + 408, + 155 + ] + } + } + } + }, + { + "new": 314, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 60, + 2, + 5, + 81, + 137, + 8, + 16, + 281, + 25 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 0, + 29, + 21, + 13, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 2, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 252, + 2, + 257, + 245, + 237, + 261, + 296, + 336, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 29, + 0, + 485, + 305, + 329, + 492, + 500, + 484, + 252 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 60, + 2, + 5, + 81, + 137, + 8, + 16, + 281, + 25 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 0, + 29, + 21, + 13, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 3, + 3, + 1, + 0 + ], + "matrix_rows": [ + 252, + 2, + 257, + 245, + 237, + 261, + 296, + 336, + 384 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 29, + 0, + 485, + 305, + 329, + 492, + 500, + 484, + 252 + ] + } + } + } + }, + { + "new": 318, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 20, + 38, + 7, + 65, + 136, + 2, + 3, + 8, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 1, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 3, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 44, + 2, + 39, + 16, + 69, + 102, + 104, + 144, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 99, + 65, + 44, + 76, + 144, + 37, + 11, + 16, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 20, + 38, + 7, + 65, + 136, + 2, + 3, + 8, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 1, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 1, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 44, + 2, + 39, + 16, + 69, + 102, + 104, + 144, + 256 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 99, + 65, + 44, + 76, + 144, + 37, + 11, + 16, + 0 + ] + } + } + } + }, + { + "new": 324, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 34, + 65, + 144, + 264, + 9, + 10, + 11, + 20, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 20, + 8, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 1, + 3, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 50, + 49, + 384, + 8, + 260, + 81, + 98, + 388, + 120 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 97, + 82, + 132, + 120, + 58, + 57, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 34, + 65, + 144, + 264, + 9, + 10, + 11, + 20, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 20, + 8, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 50, + 49, + 384, + 8, + 260, + 81, + 98, + 388, + 120 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 97, + 82, + 132, + 120, + 58, + 57, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 335, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 48, + 68, + 130, + 264, + 14, + 10, + 12, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 4, + 2, + 8, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 1, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 100, + 98, + 8, + 257, + 385, + 50, + 84, + 120 + ], + "offset": 6, + "phase": 1, + "quadratic_rows": [ + 129, + 82, + 52, + 120, + 14, + 108, + 106, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 48, + 68, + 130, + 264, + 14, + 10, + 12, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 4, + 2, + 8, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 0 + ], + "matrix_rows": [ + 384, + 100, + 98, + 8, + 257, + 385, + 50, + 84, + 120 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 129, + 82, + 52, + 120, + 14, + 108, + 106, + 129, + 0 + ] + } + } + } + }, + { + "new": 340, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 1, + 3, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 24, + 13, + 49, + 2, + 52, + 40, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 61, + 0, + 61, + 53, + 13, + 13, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 1, + 3, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 24, + 13, + 49, + 2, + 52, + 40, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 61, + 0, + 61, + 53, + 13, + 13, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 341, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 18, + 3, + 32, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 43, + 5, + 9, + 42, + 36, + 16, + 64, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 38, + 3, + 37, + 0, + 0, + 5, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 18, + 3, + 32, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 43, + 5, + 9, + 42, + 36, + 16, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 38, + 3, + 37, + 0, + 0, + 5, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 351, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 1, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 273, + 290, + 52, + 264, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 38, + 21, + 51, + 504, + 462, + 461, + 504, + 504, + 248 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 1, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 273, + 290, + 52, + 264, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 38, + 21, + 51, + 504, + 462, + 461, + 504, + 504, + 248 + ] + } + } + } + }, + { + "new": 352, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 3, + 65, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 3, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 24, + 11, + 448, + 41, + 42, + 4, + 48, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 35, + 35, + 0, + 24, + 56, + 19, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 3, + 65, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 1, + 2, + 3, + 3, + 2 + ], + "matrix_rows": [ + 24, + 11, + 448, + 41, + 42, + 4, + 48, + 320, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 35, + 35, + 0, + 24, + 56, + 19, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 353, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 1, + 1, + 2 + ], + "matrix_rows": [ + 40, + 14, + 448, + 1, + 50, + 52, + 24, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 62, + 62, + 54, + 14, + 14, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 40, + 14, + 448, + 1, + 50, + 52, + 24, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 62, + 62, + 54, + 14, + 14, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 354, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 7, + 1, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 6, + 485, + 283, + 25, + 266, + 276, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 230, + 21, + 243, + 0, + 6, + 229, + 229, + 229, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 7, + 1, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 6, + 485, + 283, + 25, + 266, + 276, + 288, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 230, + 21, + 243, + 0, + 6, + 229, + 229, + 229, + 0 + ] + } + } + } + }, + { + "new": 355, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 65, + 6, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 3, + 3, + 1 + ], + "matrix_rows": [ + 235, + 451, + 229, + 257, + 306, + 52, + 280, + 320, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 205, + 24, + 213, + 507, + 14, + 296, + 205, + 205, + 296 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 65, + 6, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 1, + 2, + 3, + 1, + 1, + 3 + ], + "matrix_rows": [ + 235, + 451, + 229, + 257, + 306, + 52, + 280, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 205, + 24, + 213, + 507, + 14, + 296, + 205, + 205, + 296 + ] + } + } + } + }, + { + "new": 356, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 3, + 1, + 64, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 0, + 1, + 1, + 2 + ], + "matrix_rows": [ + 6, + 27, + 448, + 25, + 10, + 20, + 32, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 6, + 0, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 3, + 1, + 64, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 6, + 27, + 448, + 25, + 10, + 20, + 32, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 6, + 0, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 357, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 64, + 1, + 2, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 3, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 53, + 54, + 448, + 17, + 34, + 52, + 8, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 37, + 22, + 51, + 0, + 54, + 53, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 64, + 1, + 2, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 1, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 53, + 54, + 448, + 17, + 34, + 52, + 8, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 37, + 22, + 51, + 0, + 54, + 53, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 358, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 7, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 1, + 3, + 2, + 3, + 3, + 1 + ], + "matrix_rows": [ + 453, + 280, + 267, + 297, + 42, + 260, + 304, + 320, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 486, + 291, + 197, + 280, + 56, + 19, + 197, + 197, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 7, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 3, + 1, + 2, + 1, + 1, + 3 + ], + "matrix_rows": [ + 453, + 280, + 267, + 297, + 42, + 260, + 304, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 486, + 291, + 197, + 280, + 56, + 19, + 197, + 197, + 267 + ] + } + } + } + }, + { + "new": 360, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 64, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 136, + 13, + 161, + 2, + 164, + 40, + 16, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 173, + 0, + 173, + 165, + 0, + 13, + 0, + 13, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 64, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 136, + 13, + 161, + 2, + 164, + 40, + 16, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 173, + 0, + 173, + 165, + 0, + 13, + 0, + 13, + 0 + ] + } + } + } + }, + { + "new": 361, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 13, + 208, + 33, + 2, + 36, + 40, + 144, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 80, + 13, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 13, + 208, + 33, + 2, + 36, + 40, + 144, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 80, + 13, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new": 371, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 133, + 385, + 2, + 388, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 261, + 0, + 261, + 120, + 120, + 120, + 56, + 384, + 133 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 133, + 385, + 2, + 388, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 261, + 0, + 261, + 120, + 120, + 120, + 56, + 384, + 133 + ] + } + } + } + }, + { + "new": 372, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 131, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 0, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 440, + 56, + 168, + 1, + 2, + 4, + 456, + 80, + 480 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 232, + 448, + 232, + 56, + 440, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 131, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 0, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 440, + 56, + 168, + 1, + 2, + 4, + 456, + 80, + 480 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 232, + 448, + 232, + 56, + 440, + 144 + ] + } + } + } + }, + { + "new": 373, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 272, + 168, + 21, + 321, + 2, + 324, + 136, + 80, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 341, + 0, + 341, + 40, + 325, + 40, + 21, + 0, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 272, + 168, + 21, + 321, + 2, + 324, + 136, + 80, + 160 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 341, + 0, + 341, + 40, + 325, + 40, + 21, + 0, + 21 + ] + } + } + } + }, + { + "new": 374, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 144, + 296, + 21, + 193, + 2, + 196, + 264, + 80, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 213, + 0, + 213, + 40, + 197, + 40, + 21, + 21, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 144, + 296, + 21, + 193, + 2, + 196, + 264, + 80, + 288 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 0, + 213, + 40, + 197, + 40, + 21, + 21, + 0 + ] + } + } + } + }, + { + "new": 375, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 168, + 65, + 2, + 68, + 392, + 80, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 0, + 85, + 296, + 85, + 296, + 21, + 384, + 168 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 1, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 168, + 65, + 2, + 68, + 392, + 80, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 0, + 85, + 296, + 85, + 296, + 21, + 384, + 168 + ] + } + } + } + }, + { + "new": 376, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 39, + 64, + 131, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 405, + 21, + 133, + 449, + 2, + 452, + 8, + 80, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 197, + 0, + 197, + 0, + 448, + 0, + 21, + 405, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 39, + 64, + 131, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 405, + 21, + 133, + 449, + 2, + 452, + 8, + 80, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 197, + 0, + 197, + 0, + 448, + 0, + 21, + 405, + 144 + ] + } + } + } + }, + { + "new": 377, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 133, + 272, + 56, + 129, + 2, + 132, + 328, + 80, + 352 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 5, + 0, + 5, + 376, + 360, + 376, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 133, + 272, + 56, + 129, + 2, + 132, + 328, + 80, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 376, + 360, + 376, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 378, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 261, + 144, + 56, + 257, + 2, + 260, + 200, + 80, + 224 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 5, + 0, + 5, + 248, + 232, + 248, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 261, + 144, + 56, + 257, + 2, + 260, + 200, + 80, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 248, + 232, + 248, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 380, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 34, + 67, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 470, + 475, + 289, + 258, + 36, + 296, + 272, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 251, + 269, + 502, + 251, + 269, + 13, + 269, + 269, + 470 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 34, + 67, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 3, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 470, + 475, + 289, + 258, + 36, + 296, + 272, + 320, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 251, + 269, + 502, + 251, + 269, + 13, + 269, + 269, + 470 + ] + } + } + } + }, + { + "new": 381, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 13, + 400, + 33, + 2, + 36, + 40, + 272, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 144, + 13, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 13, + 400, + 33, + 2, + 36, + 40, + 272, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 144, + 13, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 391, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 6, + 67, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 2, + 2, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 438, + 437, + 334, + 321, + 266, + 76, + 272, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 245, + 496, + 261, + 0, + 259, + 259, + 3, + 259, + 438 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 6, + 67, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 438, + 437, + 334, + 321, + 266, + 76, + 272, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 245, + 496, + 261, + 0, + 259, + 259, + 3, + 259, + 438 + ] + } + } + } + }, + { + "new": 392, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 11, + 400, + 97, + 98, + 4, + 72, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 107, + 107, + 0, + 99, + 144, + 11, + 11, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 11, + 400, + 97, + 98, + 4, + 72, + 272, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 107, + 107, + 0, + 99, + 144, + 11, + 11, + 144, + 0 + ] + } + } + } + }, + { + "new": 393, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 290, + 324, + 264, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 509, + 472, + 37, + 99, + 99, + 413, + 411, + 99, + 355 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 290, + 324, + 264, + 272, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 509, + 472, + 37, + 99, + 99, + 413, + 411, + 99, + 355 + ] + } + } + } + }, + { + "new": 394, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 3, + 68, + 129, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 14, + 400, + 1, + 74, + 76, + 272, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 40, + 144, + 104, + 38, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 3, + 68, + 129, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 14, + 400, + 1, + 74, + 76, + 272, + 96, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 40, + 144, + 104, + 38, + 144, + 0 + ] + } + } + } + }, + { + "new": 395, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 36, + 6, + 67, + 129, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 187, + 403, + 270, + 257, + 330, + 76, + 272, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 40, + 366, + 326, + 187, + 40, + 507, + 38, + 40, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 36, + 6, + 67, + 129, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 2, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 187, + 403, + 270, + 257, + 330, + 76, + 272, + 352, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 40, + 366, + 326, + 187, + 40, + 507, + 38, + 40, + 38 + ] + } + } + } + }, + { + "new": 396, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 64, + 132, + 3, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 0, + 1, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 99, + 400, + 97, + 34, + 68, + 8, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 69, + 70, + 0, + 144, + 0, + 6, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 64, + 132, + 3, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 99, + 400, + 97, + 34, + 68, + 8, + 272, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 69, + 70, + 0, + 144, + 0, + 6, + 144, + 0 + ] + } + } + } + }, + { + "new": 397, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 65, + 134, + 3, + 7, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 296, + 406, + 181, + 97, + 354, + 260, + 328, + 272, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 213, + 246, + 35, + 104, + 35, + 190, + 11, + 35, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 65, + 134, + 3, + 7, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 1, + 0, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 296, + 406, + 181, + 97, + 354, + 260, + 328, + 272, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 213, + 246, + 35, + 104, + 35, + 190, + 11, + 35, + 0 + ] + } + } + } + }, + { + "new": 398, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 2, + 68, + 128, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 3, + 1, + 0, + 3, + 1, + 2 + ], + "matrix_rows": [ + 77, + 78, + 400, + 65, + 10, + 76, + 272, + 32, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 13, + 70, + 75, + 77, + 144, + 0, + 78, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 2, + 68, + 128, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 3, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 77, + 78, + 400, + 65, + 10, + 76, + 272, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 13, + 70, + 75, + 77, + 144, + 0, + 78, + 144, + 0 + ] + } + } + } + }, + { + "new": 399, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 19, + 97, + 34, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 115, + 113, + 0, + 0, + 115, + 19, + 19, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 19, + 97, + 34, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 115, + 113, + 0, + 0, + 115, + 19, + 19, + 0, + 0 + ] + } + } + } + }, + { + "new": 400, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 19, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 3, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 476, + 463, + 289, + 290, + 260, + 264, + 48, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 239, + 239, + 275, + 275, + 508, + 19, + 275, + 275, + 476 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 19, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 1, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 476, + 463, + 289, + 290, + 260, + 264, + 48, + 320, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 239, + 239, + 275, + 275, + 508, + 19, + 275, + 275, + 476 + ] + } + } + } + }, + { + "new": 401, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 35, + 2, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 0, + 0, + 0 + ], + "matrix_rows": [ + 57, + 58, + 33, + 18, + 4, + 56, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 25, + 42, + 0, + 51, + 57, + 58, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 35, + 2, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 57, + 58, + 33, + 18, + 4, + 56, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 25, + 42, + 0, + 51, + 57, + 58, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 404, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 388, + 33, + 34, + 260, + 8, + 48, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 132, + 0, + 51, + 19, + 0, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 388, + 33, + 34, + 260, + 8, + 48, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 132, + 0, + 51, + 19, + 0, + 132, + 0 + ] + } + } + } + }, + { + "new": 411, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 69, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 388, + 90, + 1, + 82, + 260, + 24, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 10, + 132, + 98, + 0, + 104, + 40, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 69, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 388, + 90, + 1, + 82, + 260, + 24, + 96, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 0, + 10, + 132, + 98, + 0, + 104, + 40, + 132, + 0 + ] + } + } + } + }, + { + "new": 412, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 38, + 67, + 135, + 5, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 2, + 0, + 1, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 24, + 254, + 407, + 97, + 258, + 260, + 296, + 336, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 503, + 105, + 105, + 454, + 49, + 407, + 399, + 105, + 361 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 38, + 67, + 135, + 5, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 24, + 254, + 407, + 97, + 258, + 260, + 296, + 336, + 384 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 503, + 105, + 105, + 454, + 49, + 407, + 399, + 105, + 361 + ] + } + } + } + }, + { + "new": 413, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 37, + 68, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 1, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 182, + 273, + 189, + 321, + 82, + 260, + 344, + 288, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 236, + 230, + 267, + 493, + 0, + 267, + 11, + 267, + 428 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 37, + 68, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 182, + 273, + 189, + 321, + 82, + 260, + 344, + 288, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 236, + 230, + 267, + 493, + 0, + 267, + 11, + 267, + 428 + ] + } + } + } + }, + { + "new": 414, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 36, + 66, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 34, + 11, + 388, + 97, + 66, + 260, + 104, + 16, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 107, + 105, + 132, + 107, + 0, + 11, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 36, + 66, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 1, + 0, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 34, + 11, + 388, + 97, + 66, + 260, + 104, + 16, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 107, + 105, + 132, + 107, + 0, + 11, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 415, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 11, + 17, + 388, + 65, + 82, + 260, + 88, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 90, + 91, + 132, + 91, + 11, + 0, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 0, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 17, + 388, + 65, + 82, + 260, + 88, + 32, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 90, + 91, + 132, + 91, + 11, + 0, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 416, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 68, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 1, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 290, + 181, + 190, + 97, + 322, + 260, + 360, + 272, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 213, + 220, + 267, + 478, + 267, + 0, + 11, + 267, + 412 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 68, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 290, + 181, + 190, + 97, + 322, + 260, + 360, + 272, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 220, + 267, + 478, + 267, + 0, + 11, + 267, + 412 + ] + } + } + } + }, + { + "new": 417, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 37, + 67, + 6, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 0, + 2, + 1, + 2, + 2, + 3 + ], + "matrix_rows": [ + 253, + 40, + 423, + 257, + 82, + 260, + 280, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 90, + 503, + 90, + 453, + 423, + 50, + 399, + 90, + 346 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 37, + 67, + 6, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 1 + ], + "matrix_rows": [ + 253, + 40, + 423, + 257, + 82, + 260, + 280, + 352, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 90, + 503, + 90, + 453, + 423, + 50, + 399, + 90, + 346 + ] + } + } + } + }, + { + "new": 418, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 69, + 129, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 388, + 105, + 97, + 2, + 260, + 40, + 80, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 9, + 0, + 132, + 81, + 88, + 0, + 24, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 69, + 129, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 388, + 105, + 97, + 2, + 260, + 40, + 80, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 9, + 0, + 132, + 81, + 88, + 0, + 24, + 132, + 0 + ] + } + } + } + }, + { + "new": 424, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 19, + 196, + 33, + 34, + 132, + 8, + 48, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 19, + 196, + 33, + 34, + 132, + 8, + 48, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + } + } + }, + { + "new": 431, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 260, + 162, + 21, + 321, + 130, + 68, + 8, + 336, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 341, + 34, + 337, + 0, + 341, + 34, + 21, + 0, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 0, + 1, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 260, + 162, + 21, + 321, + 130, + 68, + 8, + 336, + 160 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 341, + 34, + 337, + 0, + 341, + 34, + 21, + 0, + 21 + ] + } + } + } + }, + { + "new": 432, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 132, + 290, + 21, + 193, + 258, + 68, + 8, + 208, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 213, + 34, + 209, + 0, + 213, + 34, + 21, + 21, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 0, + 1, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 132, + 290, + 21, + 193, + 258, + 68, + 8, + 208, + 288 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 34, + 209, + 0, + 213, + 34, + 21, + 21, + 0 + ] + } + } + } + }, + { + "new": 433, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 64, + 128, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 422, + 38, + 162, + 1, + 450, + 68, + 8, + 16, + 480 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 226, + 448, + 0, + 0, + 226, + 38, + 422, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 64, + 128, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 422, + 38, + 162, + 1, + 450, + 68, + 8, + 16, + 480 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 226, + 448, + 0, + 0, + 226, + 38, + 422, + 132 + ] + } + } + } + }, + { + "new": 434, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 38, + 145, + 385, + 66, + 68, + 8, + 400, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 273, + 102, + 102, + 0, + 273, + 102, + 38, + 384, + 145 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 38, + 145, + 385, + 66, + 68, + 8, + 400, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 273, + 102, + 102, + 0, + 273, + 102, + 38, + 384, + 145 + ] + } + } + } + }, + { + "new": 435, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 145, + 260, + 38, + 129, + 322, + 68, + 8, + 144, + 352 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 17, + 358, + 354, + 0, + 17, + 358, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 0, + 3, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 145, + 260, + 38, + 129, + 322, + 68, + 8, + 144, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 358, + 354, + 0, + 17, + 358, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 436, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 273, + 132, + 38, + 257, + 194, + 68, + 8, + 272, + 224 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 17, + 230, + 226, + 0, + 17, + 230, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 0, + 3, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 273, + 132, + 38, + 257, + 194, + 68, + 8, + 272, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 230, + 226, + 0, + 17, + 230, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 437, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 35, + 64, + 135, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 405, + 21, + 145, + 449, + 2, + 68, + 8, + 464, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 209, + 0, + 448, + 0, + 209, + 0, + 21, + 405, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 35, + 64, + 135, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 405, + 21, + 145, + 449, + 2, + 68, + 8, + 464, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 209, + 0, + 448, + 0, + 209, + 0, + 21, + 405, + 132 + ] + } + } + } + }, + { + "new": 438, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 64, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 162, + 65, + 386, + 68, + 8, + 80, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 290, + 85, + 0, + 85, + 290, + 21, + 384, + 162 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 64, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 0, + 1, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 162, + 65, + 386, + 68, + 8, + 80, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 290, + 85, + 0, + 85, + 290, + 21, + 384, + 162 + ] + } + } + } + }, + { + "new": 439, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 385, + 14, + 257, + 18, + 20, + 24, + 32, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 129, + 30, + 30, + 30, + 14, + 0, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 14, + 257, + 18, + 20, + 24, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 30, + 30, + 30, + 14, + 0, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 440, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 11, + 17, + 33, + 3, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 34, + 1, + 18, + 52, + 56, + 64, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 0, + 60, + 62, + 62, + 14, + 14, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 11, + 17, + 33, + 3, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 34, + 1, + 18, + 52, + 56, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 60, + 62, + 62, + 14, + 14, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 441, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 487, + 489, + 257, + 274, + 276, + 24, + 288, + 320, + 384 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 270, + 247, + 247, + 505, + 14, + 270, + 270, + 270, + 489 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 487, + 489, + 257, + 274, + 276, + 24, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 270, + 247, + 247, + 505, + 14, + 270, + 270, + 270, + 489 + ] + } + } + } + }, + { + "new": 444, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 68, + 14, + 1, + 82, + 20, + 88, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 94, + 90, + 94, + 14, + 0, + 14, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 68, + 14, + 1, + 82, + 20, + 88, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 94, + 90, + 94, + 14, + 0, + 14, + 0, + 0 + ] + } + } + } + }, + { + "new": 455, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 21, + 35, + 65, + 135, + 4, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 1, + 3, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 415, + 501, + 499, + 257, + 322, + 292, + 360, + 272, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 153, + 300, + 330, + 255, + 153, + 106, + 108, + 153, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 21, + 35, + 65, + 135, + 4, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 1, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 415, + 501, + 499, + 257, + 322, + 292, + 360, + 272, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 153, + 300, + 330, + 255, + 153, + 106, + 108, + 153, + 6 + ] + } + } + } + }, + { + "new": 456, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 134, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 2, + 3, + 3, + 1, + 2 + ], + "matrix_rows": [ + 385, + 114, + 116, + 257, + 34, + 68, + 8, + 112, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 129, + 82, + 52, + 0, + 102, + 116, + 114, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 134, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 385, + 114, + 116, + 257, + 34, + 68, + 8, + 112, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 129, + 82, + 52, + 0, + 102, + 116, + 114, + 129, + 0 + ] + } + } + } + }, + { + "new": 457, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 36, + 70, + 130, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 385, + 24, + 108, + 257, + 2, + 100, + 40, + 80, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 129, + 0, + 12, + 84, + 88, + 0, + 24, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 36, + 70, + 130, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 385, + 24, + 108, + 257, + 2, + 100, + 40, + 80, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 129, + 0, + 12, + 84, + 88, + 0, + 24, + 129, + 0 + ] + } + } + } + }, + { + "new": 458, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 39, + 65, + 133, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 415, + 391, + 501, + 257, + 354, + 260, + 328, + 304, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 237, + 376, + 237, + 223, + 330, + 391, + 415, + 237, + 114 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 39, + 65, + 133, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 415, + 391, + 501, + 257, + 354, + 260, + 328, + 304, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 237, + 376, + 237, + 223, + 330, + 391, + 415, + 237, + 114 + ] + } + } + } + }, + { + "new": 460, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 2, + 0 + ], + "matrix_rows": [ + 193, + 14, + 129, + 18, + 20, + 24, + 32, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 65, + 30, + 30, + 30, + 14, + 0, + 65, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 14, + 129, + 18, + 20, + 24, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 30, + 30, + 30, + 14, + 0, + 65, + 0, + 0 + ] + } + } + } + }, + { + "new": 461, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 132, + 14, + 1, + 146, + 20, + 152, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 158, + 154, + 158, + 14, + 0, + 0, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 132, + 14, + 1, + 146, + 20, + 152, + 32, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 158, + 154, + 158, + 14, + 0, + 0, + 14, + 0 + ] + } + } + } + }, + { + "new": 464, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 260, + 14, + 1, + 274, + 20, + 280, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 286, + 282, + 286, + 14, + 0, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 260, + 14, + 1, + 274, + 20, + 280, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 286, + 282, + 286, + 14, + 0, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 475, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 11, + 129, + 276, + 65, + 194, + 260, + 200, + 272, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 202, + 203, + 20, + 203, + 20, + 0, + 11, + 11, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 11, + 129, + 276, + 65, + 194, + 260, + 200, + 272, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 202, + 203, + 20, + 203, + 20, + 0, + 11, + 11, + 0 + ] + } + } + } + }, + { + "new": 476, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 11, + 257, + 148, + 65, + 322, + 132, + 328, + 144, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 330, + 331, + 20, + 331, + 20, + 0, + 11, + 0, + 11 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 3, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 11, + 257, + 148, + 65, + 322, + 132, + 328, + 144, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 330, + 331, + 20, + 331, + 20, + 0, + 11, + 0, + 11 + ] + } + } + } + }, + { + "new": 477, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 256, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 138, + 65, + 386, + 68, + 392, + 80, + 32 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 266, + 85, + 266, + 85, + 0, + 21, + 384, + 138 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 256, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 3, + 1, + 0, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 138, + 65, + 386, + 68, + 392, + 80, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 266, + 85, + 266, + 85, + 0, + 21, + 384, + 138 + ] + } + } + } + }, + { + "new": 478, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 64, + 135, + 256, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 21, + 405, + 148, + 65, + 2, + 452, + 8, + 464, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 448, + 0, + 212, + 0, + 212, + 0, + 21, + 405, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 64, + 135, + 256, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 21, + 405, + 148, + 65, + 2, + 452, + 8, + 464, + 32 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 448, + 0, + 212, + 0, + 212, + 0, + 21, + 405, + 129 + ] + } + } + } + }, + { + "new": 479, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 72, + 14, + 1, + 82, + 84, + 24, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 0, + 14, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 72, + 14, + 1, + 82, + 84, + 24, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 0, + 14, + 0, + 0 + ] + } + } + } + }, + { + "new": 481, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 1, + 3, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 27, + 25, + 18, + 12, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 1, + 3, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 27, + 25, + 18, + 12, + 32, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 484, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 14, + 416, + 1, + 18, + 20, + 24, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 160, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 14, + 416, + 1, + 18, + 20, + 24, + 288, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 160, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 491, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 64, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 0, + 2, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 83, + 5, + 416, + 17, + 82, + 68, + 8, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 70, + 3, + 69, + 0, + 0, + 160, + 5, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 64, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 83, + 5, + 416, + 17, + 82, + 68, + 8, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 70, + 3, + 69, + 0, + 0, + 160, + 5, + 160, + 0 + ] + } + } + } + }, + { + "new": 492, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 5, + 66, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 419, + 187, + 269, + 329, + 258, + 76, + 336, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 349, + 24, + 325, + 187, + 507, + 24, + 21, + 24, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 5, + 66, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 3, + 1, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 419, + 187, + 269, + 329, + 258, + 76, + 336, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 349, + 24, + 325, + 187, + 507, + 24, + 21, + 24, + 21 + ] + } + } + } + }, + { + "new": 493, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 66, + 3, + 133, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 421, + 280, + 182, + 337, + 82, + 260, + 328, + 288, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 245, + 230, + 19, + 88, + 189, + 19, + 11, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 66, + 3, + 133, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 1, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 421, + 280, + 182, + 337, + 82, + 260, + 328, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 245, + 230, + 19, + 88, + 189, + 19, + 11, + 19, + 0 + ] + } + } + } + }, + { + "new": 494, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 1, + 64, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 3, + 0, + 1, + 3, + 1, + 2 + ], + "matrix_rows": [ + 77, + 78, + 416, + 9, + 66, + 76, + 16, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 69, + 14, + 75, + 78, + 0, + 160, + 77, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 1, + 64, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 0, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 77, + 78, + 416, + 9, + 66, + 76, + 16, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 69, + 14, + 75, + 78, + 0, + 160, + 77, + 160, + 0 + ] + } + } + } + }, + { + "new": 495, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 1, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 11, + 416, + 81, + 82, + 4, + 72, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 91, + 91, + 0, + 83, + 11, + 160, + 11, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 1, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 0, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 11, + 416, + 81, + 82, + 4, + 72, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 91, + 91, + 0, + 83, + 11, + 160, + 11, + 160, + 0 + ] + } + } + } + }, + { + "new": 496, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 67, + 131, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 438, + 437, + 333, + 265, + 322, + 76, + 272, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 496, + 246, + 262, + 0, + 259, + 259, + 3, + 259, + 437 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 67, + 131, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 438, + 437, + 333, + 265, + 322, + 76, + 272, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 496, + 246, + 262, + 0, + 259, + 259, + 3, + 259, + 437 + ] + } + } + } + }, + { + "new": 497, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 3, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 430, + 5, + 253, + 273, + 82, + 324, + 264, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 488, + 510, + 22, + 83, + 430, + 83, + 427, + 83, + 339 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 3, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 430, + 5, + 253, + 273, + 82, + 324, + 264, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 488, + 510, + 22, + 83, + 430, + 83, + 427, + 83, + 339 + ] + } + } + } + }, + { + "new": 498, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 34, + 3, + 65, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 13, + 416, + 73, + 2, + 76, + 80, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 69, + 0, + 69, + 24, + 88, + 160, + 21, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 34, + 3, + 65, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 3, + 1, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 13, + 416, + 73, + 2, + 76, + 80, + 288, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 69, + 0, + 69, + 24, + 88, + 160, + 21, + 160, + 0 + ] + } + } + } + }, + { + "new": 500, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 264, + 14, + 1, + 274, + 276, + 24, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 0, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 264, + 14, + 1, + 274, + 276, + 24, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 0, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 501, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 14, + 352, + 1, + 18, + 20, + 24, + 288, + 320, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 14, + 352, + 1, + 18, + 20, + 24, + 288, + 320, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + } + } + }, + { + "new": 504, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 2, + 0 + ], + "matrix_rows": [ + 14, + 224, + 1, + 18, + 20, + 24, + 160, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 14, + 224, + 1, + 18, + 20, + 24, + 160, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + } + } + }, + { + "new": 511, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 134, + 288, + 56, + 1, + 130, + 132, + 328, + 336, + 96 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 376, + 376, + 344, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 134, + 288, + 56, + 1, + 130, + 132, + 328, + 336, + 96 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 376, + 376, + 344, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 512, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 262, + 160, + 56, + 1, + 258, + 260, + 200, + 208, + 96 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 248, + 248, + 216, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 262, + 160, + 56, + 1, + 258, + 260, + 200, + 208, + 96 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 248, + 248, + 216, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 513, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 64, + 128, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 422, + 38, + 134, + 1, + 450, + 452, + 8, + 16, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 448, + 38, + 422, + 160 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 64, + 128, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 422, + 38, + 134, + 1, + 450, + 452, + 8, + 16, + 96 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 448, + 38, + 422, + 160 + ] + } + } + } + }, + { + "new": 514, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 257, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 38, + 384, + 152, + 1, + 66, + 68, + 392, + 400, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 280, + 280, + 102, + 38, + 384, + 152 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 257, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 38, + 384, + 152, + 1, + 66, + 68, + 392, + 400, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 280, + 280, + 102, + 38, + 384, + 152 + ] + } + } + } + }, + { + "new": 515, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 288, + 152, + 38, + 1, + 322, + 324, + 136, + 144, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 358, + 358, + 24, + 24, + 326, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 288, + 152, + 38, + 1, + 322, + 324, + 136, + 144, + 96 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 358, + 358, + 24, + 24, + 326, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 516, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 160, + 280, + 38, + 1, + 194, + 196, + 264, + 272, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 230, + 230, + 24, + 24, + 198, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 160, + 280, + 38, + 1, + 194, + 196, + 264, + 272, + 96 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 230, + 230, + 24, + 24, + 198, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 517, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 135, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 440, + 56, + 152, + 1, + 2, + 4, + 456, + 464, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 216, + 216, + 448, + 56, + 440, + 160 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 135, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 440, + 56, + 152, + 1, + 2, + 4, + 456, + 464, + 96 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 216, + 216, + 448, + 56, + 440, + 160 + ] + } + } + } + }, + { + "new": 518, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 134, + 1, + 386, + 388, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 262, + 262, + 120, + 120, + 120, + 56, + 384, + 134 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 134, + 1, + 386, + 388, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 262, + 262, + 120, + 120, + 120, + 56, + 384, + 134 + ] + } + } + } + }, + { + "new": 519, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 392, + 33, + 34, + 4, + 264, + 48, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 0, + 136, + 51, + 19, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 392, + 33, + 34, + 4, + 264, + 48, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 136, + 51, + 19, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 520, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 33, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 3, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 19, + 289, + 34, + 260, + 264, + 304, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 307, + 509, + 206, + 206, + 307, + 19, + 206, + 206, + 19 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 33, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 1, + 1, + 2, + 1, + 1, + 0 + ], + "matrix_rows": [ + 462, + 19, + 289, + 34, + 260, + 264, + 304, + 320, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 307, + 509, + 206, + 206, + 307, + 19, + 206, + 206, + 19 + ] + } + } + } + }, + { + "new": 531, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 68, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 1, + 2, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 83, + 5, + 392, + 65, + 82, + 20, + 264, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 22, + 3, + 21, + 136, + 5, + 0, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 68, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 83, + 5, + 392, + 65, + 82, + 20, + 264, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 22, + 3, + 21, + 136, + 5, + 0, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 532, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 34, + 70, + 131, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 304, + 190, + 171, + 97, + 258, + 356, + 264, + 336, + 384 + ], + "offset": 5, + "phase": 3, + "quadratic_rows": [ + 203, + 277, + 478, + 277, + 206, + 0, + 21, + 277, + 398 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 34, + 70, + 131, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 0, + 2, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 304, + 190, + 171, + 97, + 258, + 356, + 264, + 336, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 277, + 478, + 277, + 206, + 0, + 21, + 277, + 398 + ] + } + } + } + }, + { + "new": 533, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 65, + 6, + 131, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 5, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 1, + 2, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 189, + 304, + 278, + 257, + 82, + 340, + 264, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 445, + 326, + 251, + 445, + 397, + 205, + 38, + 445, + 155 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 65, + 6, + 131, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 5, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 1, + 0, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 189, + 304, + 278, + 257, + 82, + 340, + 264, + 352, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 445, + 326, + 251, + 445, + 397, + 205, + 38, + 445, + 155 + ] + } + } + } + }, + { + "new": 534, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 68, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 0, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 99, + 392, + 97, + 66, + 36, + 264, + 16, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 37, + 38, + 136, + 0, + 6, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 68, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 3, + 0, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 99, + 392, + 97, + 66, + 36, + 264, + 16, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 37, + 38, + 136, + 0, + 6, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 535, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 322, + 292, + 264, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 509, + 440, + 69, + 99, + 99, + 411, + 413, + 99, + 355 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 322, + 292, + 264, + 272, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 509, + 440, + 69, + 99, + 99, + 411, + 413, + 99, + 355 + ] + } + } + } + }, + { + "new": 536, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 48, + 392, + 22, + 1, + 82, + 84, + 264, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 136, + 48, + 112, + 38, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 48, + 392, + 22, + 1, + 82, + 84, + 264, + 96, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 136, + 48, + 112, + 38, + 136, + 0 + ] + } + } + } + }, + { + "new": 537, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 48, + 392, + 21, + 97, + 2, + 100, + 264, + 80, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 117, + 0, + 117, + 136, + 101, + 21, + 21, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 48, + 392, + 21, + 97, + 2, + 100, + 264, + 80, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 117, + 0, + 117, + 136, + 101, + 21, + 21, + 136, + 0 + ] + } + } + } + }, + { + "new": 538, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 430, + 5, + 253, + 321, + 82, + 276, + 264, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 440, + 510, + 70, + 83, + 427, + 83, + 430, + 83, + 339 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 430, + 5, + 253, + 321, + 82, + 276, + 264, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 440, + 510, + 70, + 83, + 427, + 83, + 430, + 83, + 339 + ] + } + } + } + }, + { + "new": 551, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 131, + 56, + 264, + 129, + 130, + 4, + 72, + 336, + 352 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 368, + 376, + 376, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 131, + 56, + 264, + 129, + 130, + 4, + 72, + 336, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 368, + 376, + 376, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 552, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 259, + 56, + 136, + 257, + 258, + 4, + 72, + 208, + 224 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 240, + 248, + 248, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 259, + 56, + 136, + 257, + 258, + 4, + 72, + 208, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 240, + 248, + 248, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 553, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 67, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 395, + 11, + 131, + 449, + 450, + 4, + 72, + 16, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 195, + 195, + 0, + 448, + 0, + 0, + 11, + 395, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 67, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 395, + 11, + 131, + 449, + 450, + 4, + 72, + 16, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 195, + 195, + 0, + 448, + 0, + 0, + 11, + 395, + 136 + ] + } + } + } + }, + { + "new": 554, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 65, + 132, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 384, + 176, + 65, + 66, + 4, + 72, + 400, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 304, + 304, + 11, + 384, + 176 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 65, + 132, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 3, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 384, + 176, + 65, + 66, + 4, + 72, + 400, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 304, + 304, + 11, + 384, + 176 + ] + } + } + } + }, + { + "new": 555, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 136, + 11, + 304, + 193, + 194, + 4, + 72, + 272, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 203, + 203, + 0, + 195, + 48, + 48, + 11, + 11, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 136, + 11, + 304, + 193, + 194, + 4, + 72, + 272, + 288 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 203, + 0, + 195, + 48, + 48, + 11, + 11, + 0 + ] + } + } + } + }, + { + "new": 556, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 264, + 11, + 176, + 321, + 322, + 4, + 72, + 144, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 331, + 331, + 0, + 323, + 48, + 48, + 11, + 0, + 11 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 264, + 11, + 176, + 321, + 322, + 4, + 72, + 144, + 160 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 331, + 331, + 0, + 323, + 48, + 48, + 11, + 0, + 11 + ] + } + } + } + }, + { + "new": 557, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 131, + 385, + 386, + 4, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 120, + 120, + 120, + 56, + 384, + 131 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 131, + 385, + 386, + 4, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 120, + 120, + 120, + 56, + 384, + 131 + ] + } + } + } + }, + { + "new": 558, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 67, + 135, + 263, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 56, + 440, + 176, + 1, + 2, + 4, + 72, + 464, + 480 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 448, + 240, + 240, + 56, + 440, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 67, + 135, + 263, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 56, + 440, + 176, + 1, + 2, + 4, + 72, + 464, + 480 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 448, + 240, + 240, + 56, + 440, + 136 + ] + } + } + } + }, + { + "new": 571, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 0, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 384, + 164, + 65, + 66, + 388, + 72, + 16, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 292, + 75, + 0, + 292, + 11, + 384, + 164 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 384, + 164, + 65, + 66, + 388, + 72, + 16, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 292, + 75, + 0, + 292, + 11, + 384, + 164 + ] + } + } + } + }, + { + "new": 572, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 71, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 1, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 395, + 11, + 137, + 449, + 66, + 4, + 456, + 16, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 201, + 448, + 0, + 201, + 0, + 0, + 11, + 395, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 71, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 395, + 11, + 137, + 449, + 66, + 4, + 456, + 16, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 201, + 448, + 0, + 201, + 0, + 0, + 11, + 395, + 130 + ] + } + } + } + }, + { + "new": 573, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 137, + 38, + 258, + 129, + 66, + 324, + 136, + 16, + 352 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 9, + 356, + 358, + 9, + 0, + 358, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 137, + 38, + 258, + 129, + 66, + 324, + 136, + 16, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 356, + 358, + 9, + 0, + 358, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 574, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 265, + 38, + 130, + 257, + 66, + 196, + 264, + 16, + 224 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 9, + 228, + 230, + 9, + 0, + 230, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 265, + 38, + 130, + 257, + 66, + 196, + 264, + 16, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 228, + 230, + 9, + 0, + 230, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 591, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 35, + 65, + 6, + 133, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 431, + 391, + 499, + 257, + 258, + 340, + 280, + 352, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 219, + 219, + 376, + 191, + 431, + 284, + 391, + 219, + 116 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 35, + 65, + 6, + 133, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 431, + 391, + 499, + 257, + 258, + 340, + 280, + 352, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 219, + 219, + 376, + 191, + 431, + 284, + 391, + 219, + 116 + ] + } + } + } + }, + { + "new": 592, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 69, + 129, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 386, + 105, + 97, + 258, + 4, + 72, + 48, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 9, + 130, + 0, + 49, + 56, + 24, + 0, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 69, + 129, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 386, + 105, + 97, + 258, + 4, + 72, + 48, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 9, + 130, + 0, + 49, + 56, + 24, + 0, + 130, + 0 + ] + } + } + } + }, + { + "new": 593, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 35, + 70, + 130, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 1, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 292, + 190, + 171, + 97, + 258, + 324, + 264, + 368, + 384 + ], + "offset": 5, + "phase": 3, + "quadratic_rows": [ + 203, + 277, + 218, + 277, + 478, + 0, + 21, + 277, + 410 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 35, + 70, + 130, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 292, + 190, + 171, + 97, + 258, + 324, + 264, + 368, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 277, + 218, + 277, + 478, + 0, + 21, + 277, + 410 + ] + } + } + } + }, + { + "new": 594, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 69, + 4, + 128, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 1, + 2 + ], + "matrix_rows": [ + 89, + 386, + 92, + 65, + 258, + 20, + 88, + 32, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 25, + 130, + 76, + 85, + 89, + 0, + 92, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 69, + 4, + 128, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 1, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 89, + 386, + 92, + 65, + 258, + 20, + 88, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 25, + 130, + 76, + 85, + 89, + 0, + 92, + 130, + 0 + ] + } + } + } + }, + { + "new": 611, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 68, + 129, + 1, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 140, + 33, + 34, + 388, + 392, + 48, + 64 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 268, + 268, + 51, + 19, + 0, + 384, + 140 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 68, + 129, + 1, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 1, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 140, + 33, + 34, + 388, + 392, + 48, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 268, + 268, + 51, + 19, + 0, + 384, + 140 + ] + } + } + } + }, + { + "new": 612, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 32, + 64, + 135, + 3, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 19, + 403, + 146, + 33, + 418, + 4, + 8, + 432, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 416, + 178, + 0, + 0, + 178, + 19, + 0, + 403, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 32, + 64, + 135, + 3, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 403, + 146, + 33, + 418, + 4, + 8, + 432, + 64 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 416, + 178, + 0, + 0, + 178, + 19, + 0, + 403, + 129 + ] + } + } + } + }, + { + "new": 613, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 132, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 384, + 14, + 161, + 385, + 18, + 20, + 24, + 416, + 64 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 289, + 30, + 30, + 30, + 14, + 289, + 0, + 384, + 161 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 132, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 14, + 161, + 385, + 18, + 20, + 24, + 416, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 289, + 30, + 30, + 30, + 14, + 289, + 0, + 384, + 161 + ] + } + } + } + }, + { + "new": 614, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 3, + 128, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 14, + 398, + 140, + 1, + 18, + 404, + 408, + 32, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 400, + 156, + 156, + 14, + 0, + 0, + 398, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 3, + 128, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 14, + 398, + 140, + 1, + 18, + 404, + 408, + 32, + 64 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 400, + 156, + 156, + 14, + 0, + 0, + 398, + 130 + ] + } + } + } + }, + { + "new": 615, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 2, + 1, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 14, + 258, + 129, + 18, + 276, + 280, + 160, + 64 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 33, + 284, + 286, + 286, + 14, + 33, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 2, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 14, + 258, + 129, + 18, + 276, + 280, + 160, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 284, + 286, + 286, + 14, + 33, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 616, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 2, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 289, + 14, + 130, + 257, + 18, + 148, + 152, + 288, + 64 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 33, + 156, + 158, + 158, + 14, + 33, + 0, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 2, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 289, + 14, + 130, + 257, + 18, + 148, + 152, + 288, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 156, + 158, + 158, + 14, + 33, + 0, + 14, + 0 + ] + } + } + } + }, + { + "new": 618, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 19, + 129, + 268, + 33, + 162, + 260, + 264, + 176, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 178, + 179, + 12, + 12, + 179, + 19, + 0, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 19, + 129, + 268, + 33, + 162, + 260, + 264, + 176, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 178, + 179, + 12, + 12, + 179, + 19, + 0, + 19, + 0 + ] + } + } + } + }, + { + "new": 626, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 6, + 485, + 285, + 25, + 274, + 268, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 224, + 278, + 502, + 0, + 6, + 229, + 229, + 229, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 6, + 485, + 285, + 25, + 274, + 268, + 288, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 224, + 278, + 502, + 0, + 6, + 229, + 229, + 229, + 6 + ] + } + } + } + }, + { + "new": 627, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 72, + 14, + 416, + 1, + 82, + 84, + 24, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 160, + 14, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 72, + 14, + 416, + 1, + 82, + 84, + 24, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 160, + 14, + 160, + 0 + ] + } + } + } + }, + { + "new": 628, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 136, + 14, + 352, + 1, + 146, + 148, + 24, + 288, + 320 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 158, + 158, + 150, + 14, + 96, + 96, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 136, + 14, + 352, + 1, + 146, + 148, + 24, + 288, + 320 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 158, + 158, + 150, + 14, + 96, + 96, + 14, + 0 + ] + } + } + } + }, + { + "new": 629, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 385, + 68, + 14, + 257, + 82, + 20, + 88, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 129, + 94, + 90, + 94, + 14, + 0, + 14, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 1, + 2, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 68, + 14, + 257, + 82, + 20, + 88, + 32, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 94, + 90, + 94, + 14, + 0, + 14, + 129, + 0 + ] + } + } + } + }, + { + "new": 630, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 2, + 1, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 289, + 274, + 52, + 264, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 22, + 37, + 51, + 504, + 461, + 462, + 504, + 504, + 248 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 2, + 1, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 289, + 274, + 52, + 264, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 22, + 37, + 51, + 504, + 461, + 462, + 504, + 504, + 248 + ] + } + } + } + }, + { + "new": 631, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 80, + 392, + 19, + 97, + 98, + 4, + 264, + 48, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 115, + 115, + 0, + 136, + 99, + 19, + 19, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 2, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 80, + 392, + 19, + 97, + 98, + 4, + 264, + 48, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 115, + 115, + 0, + 136, + 99, + 19, + 19, + 136, + 0 + ] + } + } + } + }, + { + "new": 634, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 257, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 2, + 0, + 1, + 2, + 0 + ], + "matrix_rows": [ + 193, + 260, + 14, + 129, + 274, + 20, + 280, + 32, + 192 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 65, + 286, + 282, + 286, + 14, + 0, + 65, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 257, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 1, + 2, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 260, + 14, + 129, + 274, + 20, + 280, + 32, + 192 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 286, + 282, + 286, + 14, + 0, + 65, + 0, + 14 + ] + } + } + } + }, + { + "new": 674, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 1, + 2, + 0 + ], + "matrix_rows": [ + 264, + 14, + 224, + 1, + 274, + 276, + 24, + 160, + 192 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 96, + 96, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 264, + 14, + 224, + 1, + 274, + 276, + 24, + 160, + 192 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 96, + 96, + 0, + 14 + ] + } + } + } + }, + { + "new": 760, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 67, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 2, + 3, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 57, + 58, + 388, + 33, + 18, + 260, + 56, + 64, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 25, + 42, + 132, + 51, + 57, + 58, + 0, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 67, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 1, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 57, + 58, + 388, + 33, + 18, + 260, + 56, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 25, + 42, + 132, + 51, + 57, + 58, + 0, + 132, + 0 + ] + } + } + } + }, + { + "new": 773, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 64, + 135, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 403, + 19, + 145, + 417, + 34, + 4, + 8, + 432, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 177, + 416, + 0, + 0, + 177, + 19, + 0, + 403, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 64, + 135, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 403, + 19, + 145, + 417, + 34, + 4, + 8, + 432, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 177, + 416, + 0, + 0, + 177, + 19, + 0, + 403, + 130 + ] + } + } + } + }, + { + "new": 774, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 64, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 196, + 33, + 34, + 388, + 8, + 48, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 324, + 0, + 51, + 19, + 324, + 384, + 196 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 64, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 196, + 33, + 34, + 388, + 8, + 48, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 324, + 0, + 51, + 19, + 324, + 384, + 196 + ] + } + } + } + }, + { + "new": 788, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 35, + 65, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 1, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 237, + 324, + 227, + 257, + 82, + 276, + 344, + 288, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 270, + 179, + 185, + 445, + 14, + 270, + 0, + 270, + 425 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 35, + 65, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 237, + 324, + 227, + 257, + 82, + 276, + 344, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 270, + 179, + 185, + 445, + 14, + 270, + 0, + 270, + 425 + ] + } + } + } + }, + { + "new": 792, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 128, + 260, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 384, + 14, + 193, + 385, + 18, + 20, + 24, + 32, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 321, + 30, + 30, + 30, + 14, + 0, + 321, + 384, + 193 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 128, + 260, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 14, + 193, + 385, + 18, + 20, + 24, + 32, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 321, + 30, + 30, + 30, + 14, + 0, + 321, + 384, + 193 + ] + } + } + } + }, + { + "new": 793, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 71, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 398, + 14, + 138, + 1, + 402, + 20, + 408, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 154, + 400, + 154, + 14, + 0, + 0, + 398, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 71, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 398, + 14, + 138, + 1, + 402, + 20, + 408, + 32, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 154, + 400, + 154, + 14, + 0, + 0, + 398, + 132 + ] + } + } + } + }, + { + "new": 797, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 67, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 0, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 237, + 328, + 227, + 257, + 82, + 340, + 280, + 288, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 270, + 179, + 445, + 181, + 14, + 270, + 0, + 270, + 421 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 67, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 2, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 237, + 328, + 227, + 257, + 82, + 340, + 280, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 270, + 179, + 445, + 181, + 14, + 270, + 0, + 270, + 421 + ] + } + } + } + }, + { + "new": 798, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 1, + 3, + 68, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 6, + 27, + 416, + 25, + 18, + 12, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 160, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 1, + 3, + 68, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 6, + 27, + 416, + 25, + 18, + 12, + 288, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 160, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 809, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 67, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 398, + 14, + 134, + 1, + 402, + 404, + 24, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 150, + 150, + 400, + 14, + 0, + 0, + 398, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 67, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 398, + 14, + 134, + 1, + 402, + 404, + 24, + 32, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 150, + 150, + 400, + 14, + 0, + 0, + 398, + 136 + ] + } + } + } + }, + { + "new": 810, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 65, + 1, + 132, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 14, + 384, + 224, + 1, + 18, + 20, + 24, + 416, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 352, + 352, + 384, + 224 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 65, + 1, + 132, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 14, + 384, + 224, + 1, + 18, + 20, + 24, + 416, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 352, + 352, + 384, + 224 + ] + } + } + } + }, + { + "new": 822, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 70, + 129, + 7, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 336, + 398, + 205, + 97, + 354, + 260, + 264, + 304, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 173, + 238, + 67, + 67, + 112, + 19, + 222, + 67, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 70, + 129, + 7, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 0, + 1, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 336, + 398, + 205, + 97, + 354, + 260, + 264, + 304, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 173, + 238, + 67, + 67, + 112, + 19, + 222, + 67, + 0 + ] + } + } + } + }, + { + "new": 825, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 68, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 200, + 33, + 34, + 4, + 392, + 48, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 328, + 51, + 19, + 328, + 384, + 200 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 68, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 200, + 33, + 34, + 4, + 392, + 48, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 328, + 51, + 19, + 328, + 384, + 200 + ] + } + } + } + }, + { + "new": 826, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 64, + 131, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 403, + 19, + 131, + 417, + 418, + 4, + 8, + 48, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 163, + 163, + 0, + 0, + 416, + 19, + 0, + 403, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 64, + 131, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 403, + 19, + 131, + 417, + 418, + 4, + 8, + 48, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 163, + 163, + 0, + 0, + 416, + 19, + 0, + 403, + 144 + ] + } + } + } + }, + { + "new": 1, + "old": 114, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 2, + 4, + 8, + 16, + 19, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 34, + 4, + 8, + 48, + 64, + 128, + 256, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 32, + 32, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 2, + 4, + 8, + 16, + 19, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 34, + 4, + 8, + 48, + 64, + 128, + 256, + 32 + ], + "offset": 236, + "phase": 1, + "quadratic_rows": [ + 32, + 32, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 285, + "old": 114, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 821, + "old": 114, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 1, + 1, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 3, + 392, + 33, + 50, + 20, + 264, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 35, + 51, + 16, + 136, + 22, + 3, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 3, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 3, + 392, + 33, + 50, + 20, + 264, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 35, + 51, + 16, + 136, + 22, + 3, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 139, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 129, + 2, + 260, + 8, + 16, + 13, + 12, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 13, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 2, + 0, + 1, + 2, + 2 + ], + "matrix_rows": [ + 65, + 2, + 36, + 104, + 16, + 128, + 256, + 96, + 64 + ], + "offset": 393, + "phase": 1, + "quadratic_rows": [ + 32, + 0, + 96, + 96, + 0, + 13, + 76, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 129, + 2, + 260, + 8, + 16, + 13, + 12, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 13, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 1, + 2, + 2 + ], + "matrix_rows": [ + 65, + 2, + 36, + 104, + 16, + 128, + 256, + 96, + 64 + ], + "offset": 503, + "phase": 0, + "quadratic_rows": [ + 32, + 0, + 96, + 96, + 0, + 13, + 76, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 140, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 129, + 258, + 4, + 8, + 14, + 16, + 32, + 64, + 93 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 93, + 14, + 83, + 83, + 93, + 0, + 93, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 276, + 280, + 288, + 64, + 384, + 256, + 16 + ], + "offset": 141, + "phase": 1, + "quadratic_rows": [ + 256, + 16, + 272, + 272, + 14, + 256, + 0, + 256, + 173 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 129, + 258, + 4, + 8, + 14, + 16, + 32, + 64, + 93 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 93, + 14, + 83, + 83, + 93, + 0, + 93, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 2, + 276, + 280, + 288, + 64, + 384, + 256, + 16 + ], + "offset": 161, + "phase": 1, + "quadratic_rows": [ + 256, + 16, + 272, + 272, + 14, + 256, + 0, + 256, + 173 + ] + } + } + } + }, + { + "new": 1, + "old": 141, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 33, + 66, + 4, + 136, + 16, + 19, + 21, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 19, + 21, + 0, + 6, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 33, + 66, + 68, + 264, + 112, + 64, + 96, + 256, + 384 + ], + "offset": 145, + "phase": 2, + "quadratic_rows": [ + 96, + 32, + 64, + 0, + 96, + 19, + 21, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 33, + 66, + 4, + 136, + 16, + 19, + 21, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 19, + 21, + 0, + 6, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 33, + 66, + 68, + 264, + 112, + 64, + 96, + 256, + 384 + ], + "offset": 136, + "phase": 0, + "quadratic_rows": [ + 96, + 32, + 64, + 0, + 96, + 19, + 21, + 0, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 292, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 3, + 37, + 73, + 129, + 12, + 4, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 3, + 2, + 2, + 0, + 3 + ], + "matrix_rows": [ + 382, + 285, + 123, + 264, + 287, + 256, + 288, + 320, + 384 + ], + "offset": 200, + "phase": 3, + "quadratic_rows": [ + 120, + 24, + 120, + 295, + 87, + 13, + 21, + 0, + 264 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 3, + 37, + 73, + 129, + 12, + 4, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 3, + 2, + 2, + 0, + 3 + ], + "matrix_rows": [ + 382, + 285, + 123, + 264, + 287, + 256, + 288, + 320, + 384 + ], + "offset": 200, + "phase": 3, + "quadratic_rows": [ + 120, + 24, + 120, + 295, + 87, + 13, + 21, + 0, + 264 + ] + } + } + } + }, + { + "new": 621, + "old": 292, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 37, + 4, + 72, + 130, + 13, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 115, + 272, + 374, + 264, + 256, + 274, + 288, + 320, + 384 + ], + "offset": 254, + "phase": 3, + "quadratic_rows": [ + 370, + 21, + 370, + 32, + 87, + 13, + 21, + 0, + 261 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 37, + 4, + 72, + 130, + 13, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 115, + 272, + 374, + 264, + 256, + 274, + 288, + 320, + 384 + ], + "offset": 254, + "phase": 3, + "quadratic_rows": [ + 370, + 21, + 370, + 32, + 87, + 13, + 21, + 0, + 261 + ] + } + } + } + }, + { + "new": 621, + "old": 303, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 66, + 132, + 262, + 6, + 4, + 8, + 9 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 9, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 0, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 1, + 6, + 8, + 384, + 256, + 98, + 96, + 64, + 48 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 256, + 102, + 98, + 64, + 0, + 6, + 14, + 256, + 385 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 66, + 132, + 262, + 6, + 4, + 8, + 9 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 9, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 2, + 0, + 2, + 2, + 0, + 1 + ], + "matrix_rows": [ + 1, + 6, + 8, + 384, + 256, + 98, + 96, + 64, + 48 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 256, + 102, + 98, + 64, + 0, + 6, + 14, + 256, + 385 + ] + } + } + } + }, + { + "new": 280, + "old": 304, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 27, + 35, + 69, + 9, + 15, + 1, + 138, + 266, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 11, + 15, + 14, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 317, + 260, + 55, + 303, + 256, + 272, + 320, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 293, + 26, + 53, + 26, + 14, + 5, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 27, + 35, + 69, + 9, + 15, + 1, + 138, + 266, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 11, + 15, + 14, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 317, + 260, + 55, + 303, + 256, + 272, + 320, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 293, + 26, + 53, + 26, + 14, + 5, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 732, + "old": 360, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 67, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 272, + 338, + 1, + 322, + 4, + 8, + 80, + 32, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 67, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 272, + 338, + 1, + 322, + 4, + 8, + 80, + 32, + 128 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 738, + "old": 360, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 1, + 34, + 66, + 136, + 2, + 12, + 256, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 320, + 272, + 33, + 44, + 32, + 336, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 37, + 0, + 45, + 4, + 80, + 5, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 1, + 34, + 66, + 136, + 2, + 12, + 256, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 320, + 272, + 33, + 44, + 32, + 336, + 128 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 37, + 0, + 45, + 4, + 80, + 5, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new": 901, + "old": 371, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 32, + 64, + 132, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 2, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 257, + 96, + 18, + 256, + 98, + 4, + 56, + 64, + 384 + ], + "offset": 197, + "phase": 1, + "quadratic_rows": [ + 0, + 114, + 0, + 48, + 122, + 26, + 18, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 32, + 64, + 132, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 3, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 96, + 18, + 256, + 98, + 4, + 56, + 64, + 384 + ], + "offset": 192, + "phase": 2, + "quadratic_rows": [ + 0, + 114, + 0, + 48, + 122, + 26, + 18, + 0, + 0 + ] + } + } + } + }, + { + "new": 917, + "old": 371, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 98, + 1, + 114, + 256, + 56, + 64, + 384 + ], + "offset": 211, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 48, + 106, + 120, + 112, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 98, + 1, + 114, + 256, + 56, + 64, + 384 + ], + "offset": 213, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 0, + 48, + 106, + 120, + 112, + 0, + 0 + ] + } + } + } + }, + { + "new": 902, + "old": 372, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 23, + 6, + 32, + 65, + 130, + 3, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 1, + 3, + 1, + 0, + 2 + ], + "matrix_rows": [ + 118, + 275, + 354, + 273, + 358, + 56, + 320, + 256, + 384 + ], + "offset": 221, + "phase": 3, + "quadratic_rows": [ + 3, + 355, + 276, + 48, + 284, + 362, + 354, + 0, + 118 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 23, + 6, + 32, + 65, + 130, + 3, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 3, + 3, + 1, + 0, + 0 + ], + "matrix_rows": [ + 118, + 275, + 354, + 273, + 358, + 56, + 320, + 256, + 384 + ], + "offset": 222, + "phase": 2, + "quadratic_rows": [ + 3, + 355, + 276, + 48, + 284, + 362, + 354, + 0, + 118 + ] + } + } + } + }, + { + "new": 918, + "old": 372, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 69, + 129, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 1, + 3, + 0, + 1 + ], + "matrix_rows": [ + 277, + 113, + 355, + 115, + 276, + 56, + 320, + 256, + 384 + ], + "offset": 208, + "phase": 0, + "quadratic_rows": [ + 117, + 274, + 5, + 48, + 363, + 121, + 113, + 0, + 274 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 69, + 129, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 2, + 1, + 3, + 0, + 3 + ], + "matrix_rows": [ + 277, + 113, + 355, + 115, + 276, + 56, + 320, + 256, + 384 + ], + "offset": 213, + "phase": 3, + "quadratic_rows": [ + 117, + 274, + 5, + 48, + 363, + 121, + 113, + 0, + 274 + ] + } + } + } + }, + { + "new": 909, + "old": 373, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 5, + 160, + 170, + 81, + 162, + 68, + 128, + 64, + 256 + ], + "offset": 65, + "phase": 3, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 136, + 5, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 5, + 160, + 170, + 81, + 162, + 68, + 128, + 64, + 256 + ], + "offset": 69, + "phase": 1, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 136, + 5, + 160, + 0 + ] + } + } + } + }, + { + "new": 925, + "old": 373, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 8, + 5, + 170, + 65, + 10, + 84, + 128, + 64, + 256 + ], + "offset": 83, + "phase": 1, + "quadratic_rows": [ + 69, + 162, + 85, + 32, + 4, + 138, + 5, + 162, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 8, + 5, + 170, + 65, + 10, + 84, + 128, + 64, + 256 + ], + "offset": 87, + "phase": 1, + "quadratic_rows": [ + 69, + 162, + 85, + 32, + 4, + 138, + 5, + 162, + 0 + ] + } + } + } + }, + { + "new": 910, + "old": 374, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 5, + 288, + 298, + 81, + 290, + 68, + 256, + 64, + 128 + ], + "offset": 65, + "phase": 3, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 264, + 5, + 0, + 288 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 5, + 288, + 298, + 81, + 290, + 68, + 256, + 64, + 128 + ], + "offset": 69, + "phase": 1, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 264, + 5, + 0, + 288 + ] + } + } + } + }, + { + "new": 926, + "old": 374, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 8, + 5, + 298, + 65, + 10, + 84, + 256, + 64, + 128 + ], + "offset": 83, + "phase": 1, + "quadratic_rows": [ + 69, + 290, + 85, + 32, + 4, + 266, + 5, + 0, + 290 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 8, + 5, + 298, + 65, + 10, + 84, + 256, + 64, + 128 + ], + "offset": 87, + "phase": 1, + "quadratic_rows": [ + 69, + 290, + 85, + 32, + 4, + 266, + 5, + 0, + 290 + ] + } + } + } + }, + { + "new": 933, + "old": 375, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 35, + 68, + 1, + 128, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 82, + 4, + 264, + 21, + 6, + 64, + 256, + 32, + 384 + ], + "offset": 62, + "phase": 0, + "quadratic_rows": [ + 20, + 86, + 83, + 0, + 87, + 0, + 86, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 35, + 68, + 1, + 128, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 82, + 4, + 264, + 21, + 6, + 64, + 256, + 32, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 20, + 86, + 83, + 0, + 87, + 0, + 86, + 0, + 0 + ] + } + } + } + }, + { + "new": 949, + "old": 375, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 35, + 64, + 1, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 84, + 82, + 288, + 21, + 86, + 64, + 8, + 256, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 20, + 6, + 83, + 0, + 85, + 0, + 84, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 35, + 64, + 1, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 84, + 82, + 288, + 21, + 86, + 64, + 8, + 256, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 20, + 6, + 83, + 0, + 85, + 0, + 84, + 0, + 0 + ] + } + } + } + }, + { + "new": 934, + "old": 376, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 129, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 3, + 1, + 0, + 0, + 3 + ], + "matrix_rows": [ + 42, + 282, + 92, + 21, + 358, + 256, + 280, + 320, + 384 + ], + "offset": 240, + "phase": 1, + "quadratic_rows": [ + 20, + 84, + 43, + 124, + 283, + 364, + 42, + 0, + 304 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 129, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 42, + 282, + 92, + 21, + 358, + 256, + 280, + 320, + 384 + ], + "offset": 246, + "phase": 2, + "quadratic_rows": [ + 20, + 84, + 43, + 124, + 283, + 364, + 42, + 0, + 304 + ] + } + } + } + }, + { + "new": 950, + "old": 376, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 17, + 39, + 2, + 68, + 3, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 44, + 17, + 293, + 46, + 256, + 304, + 320, + 384 + ], + "offset": 235, + "phase": 3, + "quadratic_rows": [ + 309, + 38, + 35, + 0, + 305, + 55, + 0, + 0, + 17 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 17, + 39, + 2, + 68, + 3, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 44, + 17, + 293, + 46, + 256, + 304, + 320, + 384 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 309, + 38, + 35, + 0, + 305, + 55, + 0, + 0, + 17 + ] + } + } + } + }, + { + "new": 941, + "old": 377, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 135, + 132, + 40, + 128, + 134, + 88, + 64, + 96, + 256 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 6, + 3, + 129, + 120, + 8, + 104, + 40, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 135, + 132, + 40, + 128, + 134, + 88, + 64, + 96, + 256 + ], + "offset": 13, + "phase": 1, + "quadratic_rows": [ + 6, + 3, + 129, + 120, + 8, + 104, + 40, + 132, + 0 + ] + } + } + } + }, + { + "new": 957, + "old": 377, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 135, + 288, + 131, + 128, + 8, + 48, + 256, + 320 + ], + "offset": 482, + "phase": 2, + "quadratic_rows": [ + 132, + 6, + 3, + 0, + 32, + 48, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 135, + 288, + 131, + 128, + 8, + 48, + 256, + 320 + ], + "offset": 484, + "phase": 1, + "quadratic_rows": [ + 132, + 6, + 3, + 0, + 32, + 48, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 942, + "old": 378, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 263, + 260, + 40, + 256, + 262, + 88, + 64, + 96, + 128 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 6, + 3, + 257, + 120, + 8, + 104, + 40, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 263, + 260, + 40, + 256, + 262, + 88, + 64, + 96, + 128 + ], + "offset": 13, + "phase": 1, + "quadratic_rows": [ + 6, + 3, + 257, + 120, + 8, + 104, + 40, + 0, + 260 + ] + } + } + } + }, + { + "new": 958, + "old": 378, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 2, + 3, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 263, + 160, + 259, + 256, + 8, + 48, + 128, + 192 + ], + "offset": 482, + "phase": 2, + "quadratic_rows": [ + 260, + 6, + 3, + 0, + 32, + 48, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 2, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 263, + 160, + 259, + 256, + 8, + 48, + 128, + 192 + ], + "offset": 484, + "phase": 1, + "quadratic_rows": [ + 260, + 6, + 3, + 0, + 32, + 48, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 903, + "old": 391, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 131, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 19, + 179, + 288, + 273, + 274, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 131, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 19, + 179, + 288, + 273, + 274, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + } + } + }, + { + "new": 927, + "old": 391, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 132, + "phase": 3, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 131, + "phase": 1, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + } + } + }, + { + "new": 904, + "old": 392, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 3, + 384, + 404, + 73, + 66, + 388, + 64, + 256, + 32 + ], + "offset": 129, + "phase": 3, + "quadratic_rows": [ + 75, + 67, + 20, + 1, + 132, + 0, + 3, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 3, + 384, + 404, + 73, + 66, + 388, + 64, + 256, + 32 + ], + "offset": 133, + "phase": 1, + "quadratic_rows": [ + 75, + 67, + 20, + 1, + 132, + 0, + 3, + 272, + 384 + ] + } + } + } + }, + { + "new": 928, + "old": 392, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 132, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 106, + 66, + 400, + 11, + 32, + 20, + 96, + 256, + 384 + ], + "offset": 238, + "phase": 3, + "quadratic_rows": [ + 10, + 1, + 16, + 9, + 148, + 0, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 132, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 106, + 66, + 400, + 11, + 32, + 20, + 96, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 10, + 1, + 16, + 9, + 148, + 0, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 911, + "old": 393, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 39, + 66, + 4, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 398, + 150, + 64, + 322, + 324, + 256, + 96, + 384 + ], + "offset": 68, + "phase": 3, + "quadratic_rows": [ + 6, + 31, + 31, + 134, + 134, + 0, + 0, + 24, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 39, + 66, + 4, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 398, + 150, + 64, + 322, + 324, + 256, + 96, + 384 + ], + "offset": 67, + "phase": 1, + "quadratic_rows": [ + 6, + 31, + 31, + 134, + 134, + 0, + 0, + 24, + 0 + ] + } + } + } + }, + { + "new": 919, + "old": 393, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 69, + 3, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 3 + ], + "matrix_rows": [ + 158, + 278, + 8, + 153, + 18, + 20, + 256, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 152, + 408, + 408, + 263, + 263, + 0, + 0, + 135, + 286 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 69, + 3, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 3 + ], + "matrix_rows": [ + 158, + 278, + 8, + 153, + 18, + 20, + 256, + 32, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 152, + 408, + 408, + 263, + 263, + 0, + 0, + 135, + 286 + ] + } + } + } + }, + { + "new": 912, + "old": 394, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 38, + 70, + 129, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 1, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 400, + 36, + 68, + 17, + 38, + 64, + 72, + 256, + 384 + ], + "offset": 255, + "phase": 1, + "quadratic_rows": [ + 16, + 36, + 2, + 0, + 145, + 34, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 38, + 70, + 129, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 400, + 36, + 68, + 17, + 38, + 64, + 72, + 256, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 16, + 36, + 2, + 0, + 145, + 34, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 920, + "old": 394, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 384, + 6, + 401, + 385, + 66, + 100, + 8, + 256, + 64 + ], + "offset": 130, + "phase": 3, + "quadratic_rows": [ + 17, + 70, + 102, + 0, + 129, + 4, + 6, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 6, + 401, + 385, + 66, + 100, + 8, + 256, + 64 + ], + "offset": 134, + "phase": 1, + "quadratic_rows": [ + 17, + 70, + 102, + 0, + 129, + 4, + 6, + 272, + 384 + ] + } + } + } + }, + { + "new": 943, + "old": 395, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 34, + 66, + 4, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 423, + 98, + 182, + 256, + 326, + 64, + 72, + 352, + 384 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 166, + 55, + 19, + 0, + 166, + 51, + 0, + 17, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 34, + 66, + 4, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 0, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 423, + 98, + 182, + 256, + 326, + 64, + 72, + 352, + 384 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 166, + 55, + 19, + 0, + 166, + 51, + 0, + 17, + 0 + ] + } + } + } + }, + { + "new": 951, + "old": 395, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 39, + 71, + 135, + 259, + 4, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 1, + 2, + 1, + 1 + ], + "matrix_rows": [ + 212, + 340, + 308, + 165, + 38, + 320, + 328, + 368, + 256 + ], + "offset": 423, + "phase": 3, + "quadratic_rows": [ + 164, + 36, + 371, + 0, + 468, + 487, + 180, + 241, + 308 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 39, + 71, + 135, + 259, + 4, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 3, + 1, + 2, + 3, + 1 + ], + "matrix_rows": [ + 212, + 340, + 308, + 165, + 38, + 320, + 328, + 368, + 256 + ], + "offset": 420, + "phase": 2, + "quadratic_rows": [ + 164, + 36, + 371, + 0, + 468, + 487, + 180, + 241, + 308 + ] + } + } + } + }, + { + "new": 944, + "old": 396, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 1, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 65, + 36, + 400, + 32, + 6, + 96, + 24, + 256, + 384 + ], + "offset": 247, + "phase": 0, + "quadratic_rows": [ + 96, + 4, + 70, + 16, + 152, + 65, + 101, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 3, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 65, + 36, + 400, + 32, + 6, + 96, + 24, + 256, + 384 + ], + "offset": 242, + "phase": 1, + "quadratic_rows": [ + 96, + 4, + 70, + 16, + 152, + 65, + 101, + 144, + 0 + ] + } + } + } + }, + { + "new": 952, + "old": 396, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 65, + 384, + 408, + 69, + 6, + 64, + 392, + 256, + 32 + ], + "offset": 184, + "phase": 3, + "quadratic_rows": [ + 5, + 4, + 7, + 24, + 136, + 0, + 0, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 65, + 384, + 408, + 69, + 6, + 64, + 392, + 256, + 32 + ], + "offset": 189, + "phase": 0, + "quadratic_rows": [ + 5, + 4, + 7, + 24, + 136, + 0, + 0, + 272, + 384 + ] + } + } + } + }, + { + "new": 935, + "old": 397, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 39, + 65, + 1, + 128, + 256, + 3, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 1, + 3, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 10, + 388, + 4, + 149, + 134, + 256, + 24, + 32, + 64 + ], + "offset": 62, + "phase": 0, + "quadratic_rows": [ + 148, + 142, + 151, + 26, + 157, + 0, + 0, + 279, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 39, + 65, + 1, + 128, + 256, + 3, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 1, + 1, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 10, + 388, + 4, + 149, + 134, + 256, + 24, + 32, + 64 + ], + "offset": 62, + "phase": 1, + "quadratic_rows": [ + 148, + 142, + 151, + 26, + 157, + 0, + 0, + 279, + 384 + ] + } + } + } + }, + { + "new": 959, + "old": 397, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 34, + 70, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 194, + 463, + 155, + 323, + 64, + 320, + 328, + 96, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 22, + 151, + 139, + 20, + 139, + 0, + 0, + 150, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 34, + 70, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 194, + 463, + 155, + 323, + 64, + 320, + 328, + 96, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 22, + 151, + 139, + 20, + 139, + 0, + 0, + 150, + 0 + ] + } + } + } + }, + { + "new": 936, + "old": 398, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 130, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 1, + 2, + 0, + 3 + ], + "matrix_rows": [ + 68, + 432, + 384, + 5, + 6, + 64, + 72, + 256, + 416 + ], + "offset": 185, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 160, + 48, + 0, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 130, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 3, + 2, + 2, + 3 + ], + "matrix_rows": [ + 68, + 432, + 384, + 5, + 6, + 64, + 72, + 256, + 416 + ], + "offset": 186, + "phase": 3, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 160, + 48, + 0, + 272, + 384 + ] + } + } + } + }, + { + "new": 960, + "old": 398, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 3, + 68, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 3, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 12, + 16, + 3, + 72, + 64, + 48, + 128, + 256 + ], + "offset": 27, + "phase": 1, + "quadratic_rows": [ + 2, + 11, + 72, + 78, + 48, + 16, + 12, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 3, + 68, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 1, + 1, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 66, + 12, + 16, + 3, + 72, + 64, + 48, + 128, + 256 + ], + "offset": 25, + "phase": 3, + "quadratic_rows": [ + 2, + 11, + 72, + 78, + 48, + 16, + 12, + 0, + 0 + ] + } + } + } + }, + { + "new": 885, + "old": 411, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 0, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 388, + 66, + 96, + 5, + 64, + 256, + 40, + 80, + 384 + ], + "offset": 251, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 133, + 32, + 0, + 104, + 96, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 0, + 1, + 3, + 1, + 2 + ], + "matrix_rows": [ + 388, + 66, + 96, + 5, + 64, + 256, + 40, + 80, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 4, + 0, + 133, + 32, + 0, + 104, + 96, + 132, + 0 + ] + } + } + } + }, + { + "new": 917, + "old": 411, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 36, + 64, + 128, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 0, + 3, + 2, + 0, + 3 + ], + "matrix_rows": [ + 384, + 66, + 389, + 385, + 98, + 256, + 40, + 16, + 64 + ], + "offset": 368, + "phase": 3, + "quadratic_rows": [ + 5, + 34, + 129, + 32, + 0, + 42, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 36, + 64, + 128, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 2, + 0, + 1, + 2, + 2, + 3 + ], + "matrix_rows": [ + 384, + 66, + 389, + 385, + 98, + 256, + 40, + 16, + 64 + ], + "offset": 374, + "phase": 0, + "quadratic_rows": [ + 5, + 34, + 129, + 32, + 0, + 42, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 886, + "old": 412, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 71, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 89, + 410, + 156, + 64, + 256, + 328, + 336, + 96, + 384 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 24, + 152, + 152, + 31, + 31, + 0, + 0, + 6, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 71, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 89, + 410, + 156, + 64, + 256, + 328, + 336, + 96, + 384 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 24, + 152, + 152, + 31, + 31, + 0, + 0, + 6, + 0 + ] + } + } + } + }, + { + "new": 918, + "old": 412, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 64, + 133, + 256, + 5, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 3, + 1 + ], + "matrix_rows": [ + 210, + 66, + 272, + 147, + 320, + 20, + 24, + 64, + 32 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 146, + 321, + 16, + 16, + 269, + 0, + 450, + 193, + 338 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 64, + 133, + 256, + 5, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 1, + 1, + 3 + ], + "matrix_rows": [ + 210, + 66, + 272, + 147, + 320, + 20, + 24, + 64, + 32 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 146, + 321, + 16, + 16, + 269, + 0, + 450, + 193, + 338 + ] + } + } + } + }, + { + "new": 893, + "old": 413, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 67, + 128, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 3, + 0, + 2, + 1 + ], + "matrix_rows": [ + 169, + 9, + 288, + 261, + 166, + 256, + 424, + 16, + 64 + ], + "offset": 57, + "phase": 3, + "quadratic_rows": [ + 420, + 164, + 167, + 256, + 0, + 167, + 0, + 295, + 393 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 67, + 128, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 0, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 169, + 9, + 288, + 261, + 166, + 256, + 424, + 16, + 64 + ], + "offset": 57, + "phase": 0, + "quadratic_rows": [ + 420, + 164, + 167, + 256, + 0, + 167, + 0, + 295, + 393 + ] + } + } + } + }, + { + "new": 927, + "old": 413, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 129, + 4, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 200, + 463, + 171, + 321, + 330, + 320, + 64, + 80, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 36, + 44, + 139, + 174, + 0, + 139, + 0, + 172, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 129, + 4, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 200, + 463, + 171, + 321, + 330, + 320, + 64, + 80, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 36, + 44, + 139, + 174, + 0, + 139, + 0, + 172, + 0 + ] + } + } + } + }, + { + "new": 894, + "old": 414, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 65, + 130, + 256, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 9, + 404, + 384, + 67, + 64, + 256, + 72, + 400, + 32 + ], + "offset": 33, + "phase": 3, + "quadratic_rows": [ + 75, + 1, + 144, + 73, + 20, + 0, + 9, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 65, + 130, + 256, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 3, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 9, + 404, + 384, + 67, + 64, + 256, + 72, + 400, + 32 + ], + "offset": 35, + "phase": 1, + "quadratic_rows": [ + 75, + 1, + 144, + 73, + 20, + 0, + 9, + 260, + 384 + ] + } + } + } + }, + { + "new": 928, + "old": 414, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 65, + 4, + 1, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 1, + 2, + 1, + 1, + 0, + 0 + ], + "matrix_rows": [ + 106, + 34, + 4, + 11, + 96, + 20, + 32, + 128, + 256 + ], + "offset": 26, + "phase": 0, + "quadratic_rows": [ + 10, + 33, + 20, + 73, + 4, + 34, + 72, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 65, + 4, + 1, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 3, + 2, + 1, + 3, + 0, + 0 + ], + "matrix_rows": [ + 106, + 34, + 4, + 11, + 96, + 20, + 32, + 128, + 256 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 10, + 33, + 20, + 73, + 4, + 34, + 72, + 0, + 0 + ] + } + } + } + }, + { + "new": 937, + "old": 415, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 64, + 129, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 0, + 1, + 2, + 0, + 3 + ], + "matrix_rows": [ + 66, + 420, + 384, + 3, + 64, + 256, + 8, + 80, + 416 + ], + "offset": 233, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 160, + 0, + 0, + 36, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 64, + 129, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 0, + 3, + 2, + 2, + 3 + ], + "matrix_rows": [ + 66, + 420, + 384, + 3, + 64, + 256, + 8, + 80, + 416 + ], + "offset": 234, + "phase": 3, + "quadratic_rows": [ + 2, + 3, + 160, + 0, + 0, + 36, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 965, + "old": 415, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 1, + 66, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 0, + 2, + 1, + 0, + 0 + ], + "matrix_rows": [ + 74, + 66, + 4, + 11, + 64, + 36, + 80, + 128, + 256 + ], + "offset": 25, + "phase": 0, + "quadratic_rows": [ + 10, + 65, + 36, + 73, + 0, + 4, + 74, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 1, + 66, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 3, + 0, + 2, + 1, + 0, + 0 + ], + "matrix_rows": [ + 74, + 66, + 4, + 11, + 64, + 36, + 80, + 128, + 256 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 10, + 65, + 36, + 73, + 0, + 4, + 74, + 0, + 0 + ] + } + } + } + }, + { + "new": 938, + "old": 416, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 67, + 5, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 3, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 10, + 154, + 272, + 149, + 262, + 256, + 408, + 32, + 64 + ], + "offset": 58, + "phase": 3, + "quadratic_rows": [ + 148, + 404, + 151, + 256, + 151, + 0, + 0, + 279, + 394 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 67, + 5, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 1, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 10, + 154, + 272, + 149, + 262, + 256, + 408, + 32, + 64 + ], + "offset": 58, + "phase": 0, + "quadratic_rows": [ + 148, + 404, + 151, + 256, + 151, + 0, + 0, + 279, + 394 + ] + } + } + } + }, + { + "new": 966, + "old": 416, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 200, + 463, + 155, + 329, + 322, + 320, + 64, + 96, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 28, + 20, + 139, + 157, + 139, + 0, + 0, + 156, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 200, + 463, + 155, + 329, + 322, + 320, + 64, + 96, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 20, + 139, + 157, + 139, + 0, + 0, + 156, + 0 + ] + } + } + } + }, + { + "new": 947, + "old": 417, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 66, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 425, + 106, + 172, + 256, + 64, + 328, + 80, + 352, + 384 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 168, + 40, + 168, + 47, + 0, + 47, + 0, + 5, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 66, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 3, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 425, + 106, + 172, + 256, + 64, + 328, + 80, + 352, + 384 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 168, + 40, + 168, + 47, + 0, + 47, + 0, + 5, + 0 + ] + } + } + } + }, + { + "new": 969, + "old": 417, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 64, + 131, + 261, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 198, + 294, + 96, + 163, + 320, + 356, + 40, + 336, + 256 + ], + "offset": 419, + "phase": 2, + "quadratic_rows": [ + 162, + 1, + 128, + 32, + 0, + 393, + 384, + 229, + 96 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 64, + 131, + 261, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 198, + 294, + 96, + 163, + 320, + 356, + 40, + 336, + 256 + ], + "offset": 422, + "phase": 3, + "quadratic_rows": [ + 162, + 1, + 128, + 32, + 0, + 393, + 384, + 229, + 96 + ] + } + } + } + }, + { + "new": 948, + "old": 418, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 1, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 65, + 388, + 48, + 32, + 6, + 256, + 24, + 96, + 384 + ], + "offset": 247, + "phase": 0, + "quadratic_rows": [ + 96, + 4, + 134, + 16, + 88, + 65, + 113, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 2, + 1, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 65, + 388, + 48, + 32, + 6, + 256, + 24, + 96, + 384 + ], + "offset": 244, + "phase": 1, + "quadratic_rows": [ + 96, + 4, + 134, + 16, + 88, + 65, + 113, + 132, + 0 + ] + } + } + } + }, + { + "new": 970, + "old": 418, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 36, + 64, + 129, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 2, + 3, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 65, + 384, + 390, + 81, + 386, + 256, + 24, + 64, + 32 + ], + "offset": 232, + "phase": 3, + "quadratic_rows": [ + 17, + 6, + 130, + 16, + 25, + 0, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 36, + 64, + 129, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 1, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 65, + 384, + 390, + 81, + 386, + 256, + 24, + 64, + 32 + ], + "offset": 237, + "phase": 0, + "quadratic_rows": [ + 17, + 6, + 130, + 16, + 25, + 0, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 887, + "old": 431, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 1, + 3, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 17, + 170, + 160, + 69, + 128, + 64, + 168, + 80, + 256 + ], + "offset": 17, + "phase": 3, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 130, + 17, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 17, + 170, + 160, + 69, + 128, + 64, + 168, + 80, + 256 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 130, + 17, + 160, + 0 + ] + } + } + } + }, + { + "new": 925, + "old": 431, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 130, + 272, + 170, + 1, + 138, + 20, + 256, + 128, + 320 + ], + "offset": 364, + "phase": 2, + "quadratic_rows": [ + 0, + 160, + 16, + 40, + 20, + 10, + 0, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 1, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 130, + 272, + 170, + 1, + 138, + 20, + 256, + 128, + 320 + ], + "offset": 362, + "phase": 1, + "quadratic_rows": [ + 0, + 160, + 16, + 40, + 20, + 10, + 0, + 130, + 0 + ] + } + } + } + }, + { + "new": 888, + "old": 432, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 1, + 3, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 17, + 298, + 288, + 69, + 256, + 64, + 296, + 80, + 128 + ], + "offset": 17, + "phase": 3, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 258, + 17, + 0, + 288 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 17, + 298, + 288, + 69, + 256, + 64, + 296, + 80, + 128 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 258, + 17, + 0, + 288 + ] + } + } + } + }, + { + "new": 926, + "old": 432, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 258, + 144, + 298, + 1, + 266, + 20, + 128, + 256, + 192 + ], + "offset": 364, + "phase": 2, + "quadratic_rows": [ + 0, + 288, + 16, + 40, + 20, + 10, + 0, + 0, + 258 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 1, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 258, + 144, + 298, + 1, + 266, + 20, + 128, + 256, + 192 + ], + "offset": 362, + "phase": 1, + "quadratic_rows": [ + 0, + 288, + 16, + 40, + 20, + 10, + 0, + 0, + 258 + ] + } + } + } + }, + { + "new": 895, + "old": 433, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 16, + 35, + 71, + 4, + 134, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 124, + 25, + 269, + 261, + 38, + 320, + 376, + 256, + 384 + ], + "offset": 233, + "phase": 2, + "quadratic_rows": [ + 16, + 36, + 278, + 24, + 269, + 2, + 0, + 0, + 276 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 16, + 35, + 71, + 4, + 134, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 3, + 2, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 124, + 25, + 269, + 261, + 38, + 320, + 376, + 256, + 384 + ], + "offset": 236, + "phase": 1, + "quadratic_rows": [ + 16, + 36, + 278, + 24, + 269, + 2, + 0, + 0, + 276 + ] + } + } + } + }, + { + "new": 919, + "old": 433, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 20, + 36, + 1, + 7, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 56, + 9, + 15, + 57, + 306, + 276, + 256, + 320, + 384 + ], + "offset": 243, + "phase": 3, + "quadratic_rows": [ + 62, + 319, + 287, + 15, + 55, + 19, + 0, + 0, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 20, + 36, + 1, + 7, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 56, + 9, + 15, + 57, + 306, + 276, + 256, + 320, + 384 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 62, + 319, + 287, + 15, + 55, + 19, + 0, + 0, + 6 + ] + } + } + } + }, + { + "new": 896, + "old": 434, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 70, + 128, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 12, + 108, + 256, + 38, + 64, + 104, + 16, + 384 + ], + "offset": 55, + "phase": 2, + "quadratic_rows": [ + 0, + 36, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 70, + 128, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 12, + 108, + 256, + 38, + 64, + 104, + 16, + 384 + ], + "offset": 48, + "phase": 2, + "quadratic_rows": [ + 0, + 36, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 920, + "old": 434, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 3, + 68, + 130, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 46, + 40, + 272, + 1, + 74, + 108, + 256, + 64, + 384 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 0, + 102, + 70, + 40, + 0, + 10, + 6, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 3, + 68, + 130, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 46, + 40, + 272, + 1, + 74, + 108, + 256, + 64, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 102, + 70, + 40, + 0, + 10, + 6, + 0, + 0 + ] + } + } + } + }, + { + "new": 945, + "old": 435, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 153, + 34, + 144, + 128, + 70, + 64, + 152, + 96, + 256 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 129, + 98, + 34, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 153, + 34, + 144, + 128, + 70, + 64, + 152, + 96, + 256 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 129, + 98, + 34, + 144, + 0 + ] + } + } + } + }, + { + "new": 967, + "old": 435, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 288, + 153, + 137, + 2, + 36, + 128, + 256, + 320 + ], + "offset": 436, + "phase": 2, + "quadratic_rows": [ + 144, + 0, + 32, + 24, + 9, + 36, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 288, + 153, + 137, + 2, + 36, + 128, + 256, + 320 + ], + "offset": 434, + "phase": 1, + "quadratic_rows": [ + 144, + 0, + 32, + 24, + 9, + 36, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 946, + "old": 436, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 281, + 34, + 272, + 256, + 70, + 64, + 280, + 96, + 128 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 257, + 98, + 34, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 281, + 34, + 272, + 256, + 70, + 64, + 280, + 96, + 128 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 257, + 98, + 34, + 0, + 272 + ] + } + } + } + }, + { + "new": 968, + "old": 436, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 3, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 160, + 281, + 265, + 2, + 36, + 256, + 128, + 192 + ], + "offset": 436, + "phase": 2, + "quadratic_rows": [ + 272, + 0, + 32, + 24, + 9, + 36, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 160, + 281, + 265, + 2, + 36, + 256, + 128, + 192 + ], + "offset": 434, + "phase": 1, + "quadratic_rows": [ + 272, + 0, + 32, + 24, + 9, + 36, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 939, + "old": 437, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 35, + 71, + 133, + 4, + 6, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 42, + 124, + 270, + 21, + 262, + 320, + 376, + 256, + 384 + ], + "offset": 242, + "phase": 2, + "quadratic_rows": [ + 20, + 32, + 293, + 40, + 1, + 270, + 0, + 0, + 292 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 35, + 71, + 133, + 4, + 6, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 3, + 0, + 2, + 2, + 0, + 1 + ], + "matrix_rows": [ + 42, + 124, + 270, + 21, + 262, + 320, + 376, + 256, + 384 + ], + "offset": 244, + "phase": 1, + "quadratic_rows": [ + 20, + 32, + 293, + 40, + 1, + 270, + 0, + 0, + 292 + ] + } + } + } + }, + { + "new": 971, + "old": 437, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 21, + 36, + 2, + 67, + 7, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 0, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 56, + 15, + 305, + 58, + 292, + 256, + 320, + 384 + ], + "offset": 235, + "phase": 3, + "quadratic_rows": [ + 319, + 61, + 303, + 15, + 35, + 55, + 0, + 0, + 5 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 21, + 36, + 2, + 67, + 7, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 56, + 15, + 305, + 58, + 292, + 256, + 320, + 384 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 319, + 61, + 303, + 15, + 35, + 55, + 0, + 0, + 5 + ] + } + } + } + }, + { + "new": 940, + "old": 438, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 37, + 69, + 1, + 128, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 12, + 258, + 92, + 21, + 256, + 64, + 88, + 32, + 384 + ], + "offset": 47, + "phase": 2, + "quadratic_rows": [ + 20, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 37, + 69, + 1, + 128, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 12, + 258, + 92, + 21, + 256, + 64, + 88, + 32, + 384 + ], + "offset": 40, + "phase": 2, + "quadratic_rows": [ + 20, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 972, + "old": 438, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 3, + 66, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 29, + 24, + 288, + 73, + 2, + 92, + 64, + 256, + 384 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 85, + 0, + 69, + 24, + 9, + 0, + 5, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 3, + 66, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 29, + 24, + 288, + 73, + 2, + 92, + 64, + 256, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 85, + 0, + 69, + 24, + 9, + 0, + 5, + 0, + 0 + ] + } + } + } + }, + { + "new": 889, + "old": 491, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 2, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 2, + 0, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 20, + 66, + 416, + 5, + 16, + 80, + 40, + 256, + 384 + ], + "offset": 239, + "phase": 0, + "quadratic_rows": [ + 4, + 80, + 69, + 32, + 66, + 168, + 86, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 2, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 2, + 2, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 20, + 66, + 416, + 5, + 16, + 80, + 40, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 4, + 80, + 69, + 32, + 66, + 168, + 86, + 160, + 0 + ] + } + } + } + }, + { + "new": 949, + "old": 491, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 66, + 384, + 424, + 5, + 70, + 64, + 392, + 16, + 256 + ], + "offset": 312, + "phase": 3, + "quadratic_rows": [ + 4, + 6, + 7, + 40, + 0, + 136, + 0, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 66, + 384, + 424, + 5, + 70, + 64, + 392, + 16, + 256 + ], + "offset": 317, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 7, + 40, + 0, + 136, + 0, + 288, + 384 + ] + } + } + } + }, + { + "new": 890, + "old": 492, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 18, + 33, + 65, + 135, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 81, + 407, + 181, + 325, + 256, + 64, + 72, + 336, + 384 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 55, + 149, + 35, + 0, + 51, + 149, + 0, + 34, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 18, + 33, + 65, + 135, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 0, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 81, + 407, + 181, + 325, + 256, + 64, + 72, + 336, + 384 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 55, + 149, + 35, + 0, + 51, + 149, + 0, + 34, + 0 + ] + } + } + } + }, + { + "new": 950, + "old": 492, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 23, + 39, + 71, + 132, + 259, + 7, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 130, + 258, + 183, + 357, + 230, + 64, + 72, + 368, + 256 + ], + "offset": 463, + "phase": 2, + "quadratic_rows": [ + 467, + 467, + 368, + 0, + 471, + 356, + 183, + 83, + 311 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 23, + 39, + 71, + 132, + 259, + 7, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 130, + 258, + 183, + 357, + 230, + 64, + 72, + 368, + 256 + ], + "offset": 463, + "phase": 1, + "quadratic_rows": [ + 467, + 467, + 368, + 0, + 471, + 356, + 183, + 83, + 311 + ] + } + } + } + }, + { + "new": 899, + "old": 493, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 39, + 66, + 128, + 2, + 256, + 3, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 0, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 388, + 9, + 4, + 133, + 166, + 256, + 40, + 16, + 64 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 141, + 164, + 167, + 41, + 0, + 174, + 0, + 295, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 39, + 66, + 128, + 2, + 256, + 3, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 0, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 388, + 9, + 4, + 133, + 166, + 256, + 40, + 16, + 64 + ], + "offset": 61, + "phase": 1, + "quadratic_rows": [ + 141, + 164, + 167, + 41, + 0, + 174, + 0, + 295, + 384 + ] + } + } + } + }, + { + "new": 959, + "old": 493, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 34, + 71, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 73, + 399, + 171, + 323, + 64, + 256, + 328, + 80, + 384 + ], + "offset": 36, + "phase": 3, + "quadratic_rows": [ + 47, + 37, + 139, + 45, + 0, + 139, + 0, + 36, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 34, + 71, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 73, + 399, + 171, + 323, + 64, + 256, + 328, + 80, + 384 + ], + "offset": 35, + "phase": 1, + "quadratic_rows": [ + 47, + 37, + 139, + 45, + 0, + 139, + 0, + 36, + 0 + ] + } + } + } + }, + { + "new": 900, + "old": 494, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 132, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 1, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 68, + 384, + 432, + 5, + 6, + 64, + 72, + 400, + 256 + ], + "offset": 313, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 48, + 144, + 0, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 132, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 3, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 68, + 384, + 432, + 5, + 6, + 64, + 72, + 400, + 256 + ], + "offset": 316, + "phase": 3, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 48, + 144, + 0, + 288, + 384 + ] + } + } + } + }, + { + "new": 960, + "old": 494, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 2, + 64, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 2, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 10, + 68, + 416, + 3, + 72, + 8, + 48, + 256, + 384 + ], + "offset": 223, + "phase": 0, + "quadratic_rows": [ + 2, + 67, + 72, + 68, + 32, + 176, + 78, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 2, + 64, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 2, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 10, + 68, + 416, + 3, + 72, + 8, + 48, + 256, + 384 + ], + "offset": 217, + "phase": 1, + "quadratic_rows": [ + 2, + 67, + 72, + 68, + 32, + 176, + 78, + 160, + 0 + ] + } + } + } + }, + { + "new": 905, + "old": 495, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 3, + 384, + 420, + 65, + 74, + 388, + 64, + 16, + 256 + ], + "offset": 257, + "phase": 3, + "quadratic_rows": [ + 67, + 75, + 36, + 2, + 0, + 132, + 3, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 3, + 384, + 420, + 65, + 74, + 388, + 64, + 16, + 256 + ], + "offset": 261, + "phase": 1, + "quadratic_rows": [ + 67, + 75, + 36, + 2, + 0, + 132, + 3, + 288, + 384 + ] + } + } + } + }, + { + "new": 965, + "old": 495, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 90, + 66, + 416, + 11, + 16, + 36, + 80, + 256, + 384 + ], + "offset": 238, + "phase": 3, + "quadratic_rows": [ + 10, + 1, + 32, + 9, + 0, + 164, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 2, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 90, + 66, + 416, + 11, + 16, + 36, + 80, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 10, + 1, + 32, + 9, + 0, + 164, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 906, + "old": 496, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 134, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 291, + 179, + 16, + 33, + 34, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 134, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 291, + 179, + 16, + 33, + 34, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + } + } + }, + { + "new": 966, + "old": 496, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 132, + "phase": 3, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 131, + "phase": 1, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + } + } + }, + { + "new": 915, + "old": 497, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 39, + 66, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 397, + 165, + 321, + 64, + 324, + 256, + 80, + 384 + ], + "offset": 68, + "phase": 3, + "quadratic_rows": [ + 47, + 5, + 47, + 133, + 0, + 133, + 0, + 40, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 39, + 66, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 397, + 165, + 321, + 64, + 324, + 256, + 80, + 384 + ], + "offset": 67, + "phase": 1, + "quadratic_rows": [ + 47, + 5, + 47, + 133, + 0, + 133, + 0, + 40, + 0 + ] + } + } + } + }, + { + "new": 971, + "old": 497, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 70, + 128, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 293, + 173, + 8, + 33, + 170, + 36, + 256, + 16, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 424, + 168, + 424, + 263, + 0, + 263, + 0, + 135, + 301 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 70, + 128, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 293, + 173, + 8, + 33, + 170, + 36, + 256, + 16, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 424, + 168, + 424, + 263, + 0, + 263, + 0, + 135, + 301 + ] + } + } + } + }, + { + "new": 916, + "old": 498, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 37, + 69, + 1, + 130, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 20, + 416, + 68, + 21, + 34, + 64, + 72, + 256, + 384 + ], + "offset": 255, + "phase": 1, + "quadratic_rows": [ + 20, + 32, + 1, + 0, + 17, + 162, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 37, + 69, + 1, + 130, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 20, + 416, + 68, + 21, + 34, + 64, + 72, + 256, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 20, + 32, + 1, + 0, + 17, + 162, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 972, + "old": 498, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 64, + 130, + 260, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 384, + 5, + 418, + 65, + 386, + 84, + 8, + 64, + 256 + ], + "offset": 258, + "phase": 3, + "quadratic_rows": [ + 69, + 34, + 85, + 0, + 4, + 130, + 5, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 64, + 130, + 260, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 5, + 418, + 65, + 386, + 84, + 8, + 64, + 256 + ], + "offset": 262, + "phase": 1, + "quadratic_rows": [ + 69, + 34, + 85, + 0, + 4, + 130, + 5, + 288, + 384 + ] + } + } + } + }, + { + "new": 891, + "old": 511, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 132, + 135, + 24, + 133, + 128, + 104, + 80, + 64, + 256 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 3, + 5, + 130, + 120, + 88, + 8, + 24, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 132, + 135, + 24, + 133, + 128, + 104, + 80, + 64, + 256 + ], + "offset": 22, + "phase": 1, + "quadratic_rows": [ + 3, + 5, + 130, + 120, + 88, + 8, + 24, + 132, + 0 + ] + } + } + } + }, + { + "new": 957, + "old": 511, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 2, + 135, + 24, + 3, + 128, + 72, + 112, + 64, + 256 + ], + "offset": 29, + "phase": 1, + "quadratic_rows": [ + 133, + 4, + 131, + 88, + 120, + 16, + 24, + 133, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 2, + 135, + 24, + 3, + 128, + 72, + 112, + 64, + 256 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 133, + 4, + 131, + 88, + 120, + 16, + 24, + 133, + 0 + ] + } + } + } + }, + { + "new": 892, + "old": 512, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 260, + 263, + 24, + 261, + 256, + 104, + 80, + 64, + 128 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 3, + 5, + 258, + 120, + 88, + 8, + 24, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 260, + 263, + 24, + 261, + 256, + 104, + 80, + 64, + 128 + ], + "offset": 22, + "phase": 1, + "quadratic_rows": [ + 3, + 5, + 258, + 120, + 88, + 8, + 24, + 0, + 260 + ] + } + } + } + }, + { + "new": 958, + "old": 512, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 2, + 263, + 24, + 3, + 256, + 72, + 112, + 64, + 128 + ], + "offset": 29, + "phase": 1, + "quadratic_rows": [ + 261, + 4, + 259, + 88, + 120, + 16, + 24, + 0, + 261 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 2, + 263, + 24, + 3, + 256, + 72, + 112, + 64, + 128 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 261, + 4, + 259, + 88, + 120, + 16, + 24, + 0, + 261 + ] + } + } + } + }, + { + "new": 897, + "old": 513, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 71, + 1, + 130, + 5, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 297, + 25, + 108, + 341, + 38, + 256, + 296, + 320, + 384 + ], + "offset": 232, + "phase": 1, + "quadratic_rows": [ + 100, + 36, + 27, + 124, + 348, + 299, + 25, + 0, + 304 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 71, + 1, + 130, + 5, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 297, + 25, + 108, + 341, + 38, + 256, + 296, + 320, + 384 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 100, + 36, + 27, + 124, + 348, + 299, + 25, + 0, + 304 + ] + } + } + } + }, + { + "new": 951, + "old": 513, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 39, + 1, + 71, + 131, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 3, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 305, + 340, + 25, + 109, + 38, + 256, + 304, + 320, + 384 + ], + "offset": 226, + "phase": 1, + "quadratic_rows": [ + 324, + 36, + 27, + 124, + 348, + 298, + 25, + 0, + 305 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 39, + 1, + 71, + 131, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 3, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 305, + 340, + 25, + 109, + 38, + 256, + 304, + 320, + 384 + ], + "offset": 225, + "phase": 2, + "quadratic_rows": [ + 324, + 36, + 27, + 124, + 348, + 298, + 25, + 0, + 305 + ] + } + } + } + }, + { + "new": 898, + "old": 514, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 68, + 128, + 2, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 4, + 97, + 264, + 5, + 38, + 64, + 256, + 16, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 101, + 36, + 99, + 0, + 0, + 103, + 101, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 68, + 128, + 2, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 0, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 4, + 97, + 264, + 5, + 38, + 64, + 256, + 16, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 101, + 36, + 99, + 0, + 0, + 103, + 101, + 0, + 0 + ] + } + } + } + }, + { + "new": 952, + "old": 514, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 64, + 132, + 1, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 100, + 97, + 272, + 101, + 38, + 64, + 8, + 256, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 5, + 36, + 99, + 0, + 0, + 102, + 100, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 64, + 132, + 1, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 100, + 97, + 272, + 101, + 38, + 64, + 8, + 256, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 5, + 36, + 99, + 0, + 0, + 102, + 100, + 0, + 0 + ] + } + } + } + }, + { + "new": 913, + "old": 515, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 144, + 6, + 153, + 145, + 98, + 68, + 128, + 64, + 256 + ], + "offset": 66, + "phase": 3, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 136, + 2, + 6, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 144, + 6, + 153, + 145, + 98, + 68, + 128, + 64, + 256 + ], + "offset": 70, + "phase": 1, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 136, + 2, + 6, + 144, + 0 + ] + } + } + } + }, + { + "new": 967, + "old": 515, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 8, + 6, + 153, + 9, + 66, + 100, + 128, + 64, + 256 + ], + "offset": 75, + "phase": 1, + "quadratic_rows": [ + 145, + 70, + 102, + 16, + 137, + 4, + 6, + 145, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 8, + 6, + 153, + 9, + 66, + 100, + 128, + 64, + 256 + ], + "offset": 79, + "phase": 1, + "quadratic_rows": [ + 145, + 70, + 102, + 16, + 137, + 4, + 6, + 145, + 0 + ] + } + } + } + }, + { + "new": 914, + "old": 516, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 272, + 6, + 281, + 273, + 98, + 68, + 256, + 64, + 128 + ], + "offset": 66, + "phase": 3, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 264, + 2, + 6, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 272, + 6, + 281, + 273, + 98, + 68, + 256, + 64, + 128 + ], + "offset": 70, + "phase": 1, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 264, + 2, + 6, + 0, + 272 + ] + } + } + } + }, + { + "new": 968, + "old": 516, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 8, + 6, + 281, + 9, + 66, + 100, + 256, + 64, + 128 + ], + "offset": 75, + "phase": 1, + "quadratic_rows": [ + 273, + 70, + 102, + 16, + 265, + 4, + 6, + 0, + 273 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 8, + 6, + 281, + 9, + 66, + 100, + 256, + 64, + 128 + ], + "offset": 79, + "phase": 1, + "quadratic_rows": [ + 273, + 70, + 102, + 16, + 265, + 4, + 6, + 0, + 273 + ] + } + } + } + }, + { + "new": 907, + "old": 517, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 5, + 32, + 65, + 130, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 3, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 291, + 117, + 337, + 341, + 290, + 56, + 256, + 320, + 384 + ], + "offset": 222, + "phase": 3, + "quadratic_rows": [ + 339, + 3, + 292, + 48, + 345, + 300, + 337, + 0, + 117 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 5, + 32, + 65, + 130, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 3, + 3, + 1, + 0, + 0 + ], + "matrix_rows": [ + 291, + 117, + 337, + 341, + 290, + 56, + 256, + 320, + 384 + ], + "offset": 221, + "phase": 2, + "quadratic_rows": [ + 339, + 3, + 292, + 48, + 345, + 300, + 337, + 0, + 117 + ] + } + } + } + }, + { + "new": 969, + "old": 517, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 65, + 133, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 1, + 0, + 3, + 0, + 1 + ], + "matrix_rows": [ + 293, + 113, + 339, + 115, + 292, + 56, + 256, + 320, + 384 + ], + "offset": 208, + "phase": 0, + "quadratic_rows": [ + 117, + 290, + 5, + 48, + 121, + 347, + 113, + 0, + 290 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 65, + 133, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 1, + 2, + 3, + 0, + 3 + ], + "matrix_rows": [ + 293, + 113, + 339, + 115, + 292, + 56, + 256, + 320, + 384 + ], + "offset": 213, + "phase": 3, + "quadratic_rows": [ + 117, + 290, + 5, + 48, + 121, + 347, + 113, + 0, + 290 + ] + } + } + } + }, + { + "new": 908, + "old": 518, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 64, + 133, + 4, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 16, + 258, + 97, + 17, + 256, + 4, + 56, + 64, + 384 + ], + "offset": 203, + "phase": 0, + "quadratic_rows": [ + 113, + 0, + 0, + 48, + 105, + 121, + 113, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 64, + 133, + 4, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 2, + 0, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 16, + 258, + 97, + 17, + 256, + 4, + 56, + 64, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 113, + 0, + 0, + 48, + 105, + 121, + 113, + 0, + 0 + ] + } + } + } + }, + { + "new": 970, + "old": 518, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 97, + 113, + 2, + 256, + 56, + 64, + 384 + ], + "offset": 203, + "phase": 0, + "quadratic_rows": [ + 17, + 0, + 0, + 48, + 105, + 120, + 112, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 97, + 113, + 2, + 256, + 56, + 64, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 17, + 0, + 0, + 48, + 105, + 120, + 112, + 0, + 0 + ] + } + } + } + }, + { + "new": 305, + "old": 626, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 230, + 1, + 322, + 324, + 8, + 16, + 288, + 256, + 384 + ], + "offset": 141, + "phase": 1, + "quadratic_rows": [ + 0, + 422, + 422, + 0, + 0, + 486, + 416, + 486, + 230 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 230, + 1, + 322, + 324, + 8, + 16, + 288, + 256, + 384 + ], + "offset": 141, + "phase": 0, + "quadratic_rows": [ + 0, + 422, + 422, + 0, + 0, + 486, + 416, + 486, + 230 + ] + } + } + } + }, + { + "new": 303, + "old": 629, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 304, + "old": 634, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 129, + 193, + 66, + 4, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 65, + 64, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 129, + 193, + 66, + 4, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 65, + 64, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + } + } + }, + { + "new": 305, + "old": 798, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 70, + 1, + 66, + 68, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 70, + 1, + 66, + 68, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 885, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 2, + 260, + 64, + 80, + 96 + ], + "offset": 72, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 0, + 0, + 8, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 2, + 260, + 64, + 80, + 96 + ], + "offset": 73, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 0, + 0, + 8, + 256, + 384 + ] + } + } + } + }, + { + "new": 1, + "old": 886, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 257, + 2, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 4, + 320, + 64, + 352 + ], + "offset": 192, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 320, + 0, + 24, + 256, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 257, + 2, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 4, + 320, + 64, + 352 + ], + "offset": 195, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 320, + 0, + 24, + 256, + 144 + ] + } + } + } + }, + { + "new": 1, + "old": 887, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 136, + 272, + 320, + 2, + 324, + 128, + 64, + 160 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 320, + 0, + 17, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 136, + 272, + 320, + 2, + 324, + 128, + 64, + 160 + ], + "offset": 231, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 320, + 0, + 17, + 0, + 272 + ] + } + } + } + }, + { + "new": 1, + "old": 888, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 264, + 144, + 192, + 2, + 196, + 256, + 64, + 288 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 192, + 0, + 17, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 264, + 144, + 192, + 2, + 196, + 256, + 64, + 288 + ], + "offset": 231, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 192, + 0, + 17, + 144, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 901, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 68, + 4, + 133, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 82, + 260, + 8, + 1, + 80, + 256, + 16, + 96, + 384 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 16, + 8, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 68, + 4, + 133, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 82, + 260, + 8, + 1, + 80, + 256, + 16, + 96, + 384 + ], + "offset": 98, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 16, + 8, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 902, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 68, + 133, + 6, + 7, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 1, + 1, + 0, + 1 + ], + "matrix_rows": [ + 353, + 98, + 8, + 96, + 256, + 260, + 288, + 336, + 384 + ], + "offset": 30, + "phase": 1, + "quadratic_rows": [ + 256, + 352, + 0, + 288, + 0, + 106, + 98, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 68, + 133, + 6, + 7, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 3 + ], + "matrix_rows": [ + 353, + 98, + 8, + 96, + 256, + 260, + 288, + 336, + 384 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 256, + 352, + 0, + 288, + 0, + 106, + 98, + 0, + 267 + ] + } + } + } + }, + { + "new": 1, + "old": 909, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 130, + 260, + 320, + 128, + 64, + 8, + 336, + 160 + ], + "offset": 176, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 320, + 0, + 0, + 0, + 5, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 130, + 260, + 320, + 128, + 64, + 8, + 336, + 160 + ], + "offset": 183, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 320, + 0, + 0, + 0, + 5, + 0, + 260 + ] + } + } + } + }, + { + "new": 1, + "old": 910, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 258, + 132, + 192, + 256, + 64, + 8, + 208, + 288 + ], + "offset": 176, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 192, + 0, + 0, + 0, + 5, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 258, + 132, + 192, + 256, + 64, + 8, + 208, + 288 + ], + "offset": 183, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 192, + 0, + 0, + 0, + 5, + 132, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 918, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 68, + 135, + 5, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 353, + 100, + 8, + 256, + 258, + 352, + 288, + 336, + 384 + ], + "offset": 45, + "phase": 1, + "quadratic_rows": [ + 96, + 0, + 256, + 288, + 0, + 361, + 353, + 0, + 108 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 68, + 135, + 5, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 0 + ], + "matrix_rows": [ + 353, + 100, + 8, + 256, + 258, + 352, + 288, + 336, + 384 + ], + "offset": 47, + "phase": 1, + "quadratic_rows": [ + 96, + 0, + 256, + 288, + 0, + 361, + 353, + 0, + 108 + ] + } + } + } + }, + { + "new": 279, + "old": 921, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 39, + 68, + 6, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 1, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 341, + 6, + 92, + 256, + 320, + 276, + 336, + 288, + 384 + ], + "offset": 237, + "phase": 3, + "quadratic_rows": [ + 84, + 324, + 31, + 260, + 341, + 0, + 339, + 0, + 90 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 39, + 68, + 6, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 341, + 6, + 92, + 256, + 320, + 276, + 336, + 288, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 84, + 324, + 31, + 260, + 341, + 0, + 339, + 0, + 90 + ] + } + } + } + }, + { + "new": 279, + "old": 922, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 38, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 38, + 4, + 256, + 64, + 100, + 8, + 80, + 384 + ], + "offset": 184, + "phase": 1, + "quadratic_rows": [ + 0, + 100, + 66, + 0, + 0, + 98, + 38, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 38, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 38, + 4, + 256, + 64, + 100, + 8, + 80, + 384 + ], + "offset": 189, + "phase": 2, + "quadratic_rows": [ + 0, + 100, + 66, + 0, + 0, + 98, + 38, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 923, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 66, + 2, + 132, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 257, + 84, + 124, + 256, + 2, + 92, + 16, + 64, + 384 + ], + "offset": 14, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 112, + 56, + 124, + 28, + 84, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 66, + 2, + 132, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 257, + 84, + 124, + 256, + 2, + 92, + 16, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 112, + 56, + 124, + 28, + 84, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 924, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 68, + 134, + 7, + 5, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 0, + 1, + 3, + 0, + 3 + ], + "matrix_rows": [ + 109, + 354, + 8, + 256, + 96, + 268, + 320, + 304, + 384 + ], + "offset": 137, + "phase": 0, + "quadratic_rows": [ + 364, + 256, + 357, + 33, + 0, + 109, + 101, + 0, + 263 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 68, + 134, + 7, + 5, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 2, + 0, + 1, + 3, + 0, + 1 + ], + "matrix_rows": [ + 109, + 354, + 8, + 256, + 96, + 268, + 320, + 304, + 384 + ], + "offset": 139, + "phase": 0, + "quadratic_rows": [ + 364, + 256, + 357, + 33, + 0, + 109, + 101, + 0, + 263 + ] + } + } + } + }, + { + "new": 1, + "old": 925, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 66, + 132, + 256, + 1, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 130, + 260, + 64, + 128, + 320, + 136, + 336, + 32 + ], + "offset": 152, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 64, + 0, + 0, + 0, + 5, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 66, + 132, + 256, + 1, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 130, + 260, + 64, + 128, + 320, + 136, + 336, + 32 + ], + "offset": 159, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 64, + 0, + 0, + 0, + 5, + 0, + 257 + ] + } + } + } + }, + { + "new": 280, + "old": 929, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 3, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 130, + 260, + 39, + 128, + 256, + 136, + 272, + 64 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 167, + 39, + 39, + 0, + 0, + 7, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 3, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 0, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 130, + 260, + 39, + 128, + 256, + 136, + 272, + 64 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 167, + 39, + 39, + 0, + 0, + 7, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 930, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 258, + 132, + 39, + 256, + 128, + 264, + 144, + 64 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 295, + 39, + 39, + 0, + 0, + 7, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 258, + 132, + 39, + 256, + 128, + 264, + 144, + 64 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 295, + 39, + 39, + 0, + 0, + 7, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 279, + "old": 931, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 128, + 257, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 5, + 258, + 384, + 64, + 256, + 68, + 264, + 16, + 96 + ], + "offset": 312, + "phase": 1, + "quadratic_rows": [ + 68, + 0, + 69, + 0, + 0, + 0, + 5, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 128, + 257, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 5, + 258, + 384, + 64, + 256, + 68, + 264, + 16, + 96 + ], + "offset": 314, + "phase": 1, + "quadratic_rows": [ + 68, + 0, + 69, + 0, + 0, + 0, + 5, + 256, + 384 + ] + } + } + } + }, + { + "new": 279, + "old": 932, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 128, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 260, + 384, + 64, + 2, + 356, + 8, + 16, + 320 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 320, + 0, + 100, + 0, + 0, + 4, + 5, + 256, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 128, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 260, + 384, + 64, + 2, + 356, + 8, + 16, + 320 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 100, + 0, + 0, + 4, + 5, + 256, + 129 + ] + } + } + } + }, + { + "new": 279, + "old": 953, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 7, + 132, + 6, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 0, + 1, + 0, + 1 + ], + "matrix_rows": [ + 341, + 6, + 88, + 80, + 320, + 276, + 256, + 288, + 384 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 260, + 324, + 67, + 336, + 88, + 0, + 94, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 7, + 132, + 6, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 0, + 1, + 0, + 3 + ], + "matrix_rows": [ + 341, + 6, + 88, + 80, + 320, + 276, + 256, + 288, + 384 + ], + "offset": 225, + "phase": 2, + "quadratic_rows": [ + 260, + 324, + 67, + 336, + 88, + 0, + 94, + 0, + 267 + ] + } + } + } + }, + { + "new": 279, + "old": 954, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 130, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 2, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 54, + 48, + 264, + 1, + 96, + 116, + 256, + 64, + 384 + ], + "offset": 82, + "phase": 0, + "quadratic_rows": [ + 0, + 84, + 70, + 0, + 34, + 48, + 6, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 130, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 2, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 54, + 48, + 264, + 1, + 96, + 116, + 256, + 64, + 384 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 0, + 84, + 70, + 0, + 34, + 48, + 6, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 955, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 2, + 131, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 21, + 16, + 264, + 64, + 2, + 84, + 256, + 96, + 384 + ], + "offset": 74, + "phase": 0, + "quadratic_rows": [ + 84, + 0, + 69, + 0, + 65, + 0, + 21, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 2, + 131, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 21, + 16, + 264, + 64, + 2, + 84, + 256, + 96, + 384 + ], + "offset": 76, + "phase": 3, + "quadratic_rows": [ + 84, + 0, + 69, + 0, + 65, + 0, + 21, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 956, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 132, + 7, + 5, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 3, + 1, + 0, + 1 + ], + "matrix_rows": [ + 5, + 358, + 104, + 320, + 96, + 292, + 256, + 272, + 384 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 324, + 260, + 67, + 352, + 0, + 104, + 109, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 132, + 7, + 5, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 2, + 0, + 3, + 1, + 0, + 3 + ], + "matrix_rows": [ + 5, + 358, + 104, + 320, + 96, + 292, + 256, + 272, + 384 + ], + "offset": 226, + "phase": 2, + "quadratic_rows": [ + 324, + 260, + 67, + 352, + 0, + 104, + 109, + 0, + 267 + ] + } + } + } + }, + { + "new": 280, + "old": 961, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 281, + 136, + 317, + 2, + 288, + 128, + 32, + 192 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 164, + 0, + 25, + 36, + 20, + 9, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 281, + 136, + 317, + 2, + 288, + 128, + 32, + 192 + ], + "offset": 388, + "phase": 3, + "quadratic_rows": [ + 164, + 0, + 25, + 36, + 20, + 9, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 962, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 2, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 153, + 264, + 189, + 2, + 160, + 256, + 32, + 320 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 292, + 0, + 25, + 36, + 20, + 9, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 1, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 153, + 264, + 189, + 2, + 160, + 256, + 32, + 320 + ], + "offset": 388, + "phase": 3, + "quadratic_rows": [ + 292, + 0, + 25, + 36, + 20, + 9, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 281, + "old": 963, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 258, + 12, + 64, + 80, + 96 + ], + "offset": 488, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 8, + 76, + 0, + 0, + 8, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 258, + 12, + 64, + 80, + 96 + ], + "offset": 489, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 8, + 76, + 0, + 0, + 8, + 256, + 384 + ] + } + } + } + }, + { + "new": 281, + "old": 964, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 2, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 12, + 64, + 320, + 352 + ], + "offset": 352, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 8, + 332, + 64, + 0, + 24, + 256, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 2, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 12, + 64, + 320, + 352 + ], + "offset": 355, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 8, + 332, + 64, + 0, + 24, + 256, + 136 + ] + } + } + } + }, + { + "new": 1, + "old": 973, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 66, + 129, + 1, + 256, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 1, + 260, + 384, + 32, + 34, + 256, + 264, + 48, + 64 + ], + "offset": 40, + "phase": 3, + "quadratic_rows": [ + 32, + 0, + 0, + 0, + 0, + 1, + 0, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 66, + 129, + 1, + 256, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 1, + 260, + 384, + 32, + 34, + 256, + 264, + 48, + 64 + ], + "offset": 42, + "phase": 3, + "quadratic_rows": [ + 32, + 0, + 0, + 0, + 0, + 1, + 0, + 256, + 384 + ] + } + } + } + }, + { + "new": 1, + "old": 977, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 68, + 130, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 258, + 132, + 32, + 288, + 128, + 136, + 304, + 64 + ], + "offset": 168, + "phase": 0, + "quadratic_rows": [ + 288, + 32, + 0, + 0, + 0, + 3, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 68, + 130, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 258, + 132, + 32, + 288, + 128, + 136, + 304, + 64 + ], + "offset": 175, + "phase": 0, + "quadratic_rows": [ + 288, + 32, + 0, + 0, + 0, + 3, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 1, + "old": 988, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 3, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 65, + 66, + 96, + 32, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 72, + "phase": 0, + "quadratic_rows": [ + 32, + 96, + 0, + 0, + 0, + 3, + 66, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 3, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 65, + 66, + 96, + 32, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 75, + "phase": 0, + "quadratic_rows": [ + 32, + 96, + 0, + 0, + 0, + 3, + 66, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 996, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 128, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 257, + 258, + 288, + 32, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 72, + "phase": 0, + "quadratic_rows": [ + 32, + 288, + 0, + 0, + 0, + 3, + 0, + 0, + 258 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 128, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 258, + 288, + 32, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 75, + "phase": 0, + "quadratic_rows": [ + 32, + 288, + 0, + 0, + 0, + 3, + 0, + 0, + 258 + ] + } + } + } + } + ], + "paid": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "status": "PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS" + }, + "retimed_source_head": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9", + "retimed_source_sha256": { + "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7", + "research/kappa-function-composition/complex/prune_native.py": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "research/kappa-rebuild/complex/native_extensions.py": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3", + "research/kappa-rebuild/complex/power_two_balance.py": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424", + "research/kappa-rebuild/complex/rebuild_native.py": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "scalar_contact_frames_retimed": 395, + "schema": "source-bound-retimed-arbitrary-native-supplier/1", + "status": "PASS_ALL_632_INPUTS_BOTH_DIRECTIONS_AND_ALL_RETIMED_HELPER_PHASES", + "whole_helper_boundary_recipes": 408 + }, + "local_supplier_source_sha256": "8542575d046c9488574dbf1ca258bbdc6ff7dc66db778cba3b0027b7b4673653", + "main_contact_checks": 8512, + "native_and_boundary_scalar_allowance": 3385896, + "native_mask": 28633115307, + "native_stage_indices": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "native_stages": 19, + "omitted_direct_inverse_translation_rejected": 112, + "omitted_endpoint_translation_rejected": 1904, + "owned_bank_scope": "Each direct copy persists across its own recursive request and is released after the ADD. Each native invocation retains its original owned center. All nested suspended banks are separately charged.", + "p": 17, + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 69273, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "productive_fields": 11560, + "productive_main_fields": 3808, + "rank_margin": 800, + "raw_owned_bank_episodes": 1811, + "scalar_allowance": 3500584, + "schema": "complete-source-bound-hybrid-p17-native-inventory/1", + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/kappa-rebuild/transfer-audit/p3_native_audit.py": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + }, + "status": "PASS_RETIMED_SUPPLIER_AND_ALL_HYBRID_CONTROLLER_PHASES", + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + }, + "whole_idle_profile": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "wrong_direct_orientation_rejected": true + }, + "new_max_target_encoding": "153^17160", + "new_min_target_encoding": "19^17160", + "normalized_moment_upper_rational": "262144250000429/262144449839104", + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_rank_one_moment": 259998, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "productive_fields": 11560, + "rank_one_surplus_encoding": "260798^17160-259998^17160", + "schema": "hybrid-p17-paid-completion-certificate/1", + "scope": "Exact moment bounds for the documented chronological native product, paid target completion and disjoint splitting. Native all-column, precision, storage, analytic and fixed-tape premises remain separate; no full multiplication theorem is formally verified.", + "source_sha256": { + "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + "status": "PASS_EXACT_HYBRID_P17_TARGET_COMPLETION_STRICTIFICATION", + "strict_moment_verified": true, + "strictification_gap": { + "lower": "0.00000076232273894280302102501592107", + "upper": "0.00000076232273894280302102501592108" + }, + "strictification_gap_rational": "199838675/262144449839104", + "target_floor_base": 19, + "target_floor_encoding": "19^17160", + "target_rank_one_moment": 260798, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + }, + "tested_saving": "1500527/500000000", + "theta_upper": "54/55" + } +} diff --git a/research/kappa-hybrid-controller/SOURCES.json b/research/kappa-hybrid-controller/SOURCES.json new file mode 100644 index 0000000000..9ddacdc0b2 --- /dev/null +++ b/research/kappa-hybrid-controller/SOURCES.json @@ -0,0 +1,332 @@ +{ + "schema_version": 1, + "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "notes/copied-centers-lemma.tex", + "usage": "input", + "git_blob": "8933aaf508aa9d4c75ba1290913e02f6868d351d", + "sha256": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe" + }, + { + "path": "notes/three-stage-cover-bit.tex", + "usage": "input", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "path": "notes/three-stage-cover-rows.tex", + "usage": "input", + "git_blob": "590da4b892a08b9d5182fb3d8a983c6239dd27db", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "usage": "input", + "git_blob": "91594e0223e8fac49162b5aef834ffaa8e94a254", + "sha256": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca" + }, + { + "path": "research/fresh-helper-boundary/CHANGES.json", + "usage": "input", + "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/CHANGES.json" + }, + { + "path": "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "usage": "input", + "git_blob": "e6fdb31624e4eb8c7c770bb4422cd07ea99ab152", + "sha256": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/NATIVE-RESULT.json.gz" + }, + { + "path": "research/fresh-helper-boundary/native.py", + "usage": "input", + "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "pin": "head:ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9:research/fresh-helper-boundary/native.py" + }, + { + "path": "research/fresh-helper-thinned/PROOF.md", + "git_blob": "bf68dc2b987cb7de6431ff5e3514b60af48720a5", + "sha256": "9883b3329fef7624d3471e27bb55258cd9dc18bb6d37779a3939de99add87347", + "pin": "head:5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39:research/fresh-helper-thinned/PROOF.md", + "usage": "input" + }, + { + "path": "research/fresh-helper-thinned/README.md", + "git_blob": "344616d6654a96085dd45cf2c3189ef283deeac1", + "sha256": "70c1c872c2327c3f71918e218d5f1ecb7a00037771a5dd1b8ae415b84cc90dc2", + "pin": "head:5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39:research/fresh-helper-thinned/README.md", + "usage": "input" + }, + { + "path": "research/fresh-helper-thinned/RESULT.json", + "git_blob": "e223acd07a6b1f4f1c9f2778b8ea64d4b7a2be55", + "sha256": "8e7db2fed5f4be6a7f944bc59e7942ccbcc3e6c36130b5671331540c183ada21", + "pin": "head:5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39:research/fresh-helper-thinned/RESULT.json", + "usage": "input" + }, + { + "path": "research/fresh-helper-thinned/verify.py", + "git_blob": "9ba85a59aa5dcc5cdaec85ee18607cb050530c55", + "sha256": "c841265ccee9b6f79045ad818ce9d27cfd7ee1f60047525a75d491f0dd8b997a", + "pin": "head:5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39:research/fresh-helper-thinned/verify.py", + "usage": "input" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "usage": "input", + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "research/kappa-function-composition/complex/prune_native.py", + "usage": "input", + "git_blob": "8c3e11b2408fa96eefa3ebe7952d1b11b90b772b", + "sha256": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "input", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "usage": "input", + "git_blob": "6a139eedbc1015c13df6f2a4333e1a89b5edd18d", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf" + }, + { + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "usage": "input", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/249-records.bin", + "usage": "input", + "git_blob": "bdf9ab4ca0fd74cde6837f95f5f4e88133704e0e", + "sha256": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "usage": "input", + "git_blob": "a9a932b9268da28af9ba4bccdab205c5bcd50ad3", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "usage": "input", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "usage": "input", + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "research/kappa-rebuild/complex/native_extensions.py", + "usage": "input", + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "research/kappa-rebuild/complex/power_two_balance.py", + "usage": "input", + "git_blob": "a55ae0ce78a1861965f899a82604b276260f636c", + "sha256": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424" + }, + { + "path": "research/kappa-rebuild/complex/rebuild_native.py", + "usage": "input", + "git_blob": "78a7b1b0e6e43a1347fb361f45c6e0eaff8dd27b", + "sha256": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5" + }, + { + "path": "research/pr4359-p7-padding/EXPORTED-SOURCES.json", + "usage": "input", + "git_blob": "439a06e9bcbf44fc7b1e95ae2e005e0c21d0c15b", + "sha256": "0305d4730e2dfede834a241099aa6ceeee29444f305dfeb25ae9a1bb8b2df0b6" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/template_bound.py", + "usage": "input", + "git_blob": "ddc852c4fa2bb0739af01cdac6dd65e0c049f756", + "sha256": "25d409726cd867f7584fbd52e1b846335debdab42d24377e00c5653aaf12c0fb" + }, + { + "path": "research/pr4359-p7-padding/dependencies/tensor-strictification/native_inventory.py", + "usage": "input", + "git_blob": "417fefe5fb13e695bb5c551ac98be422b93b0258", + "sha256": "e1ba009d546981e75f0e6468723b9af4c065f5eb6e08390084fbbf9a579cedf1" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "usage": "input", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/identity_mixed_certificate.py", + "usage": "input", + "git_blob": "f4b51b358eff3cc43ea200503d16e7b75f67c7bc", + "sha256": "e1795294fa4d3100352bfda787ecb1efc2468ff11cbcbaca2476eb642b8d2a0a" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/mixed_forest_search.py", + "usage": "input", + "git_blob": "9b5213bf3f164664a36f81592740801f79b3c97d", + "sha256": "2dcec76840b437c67125af5b6d3529577f8c38851c792d0ffd9fa928c473e23b" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "usage": "input", + "git_blob": "fbe6da7241357d89cf5c55b2e7ce2d0d046be32a", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/complex_controller_factor.py", + "usage": "input", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/fresh-certificates/THREE-base-HELPER-BOUNDARIES.json.gz", + "usage": "input", + "git_blob": "1dae5193bad6e7467eb13434fd1a2e971f2a4cba", + "sha256": "f90517e395bde58c72cacd5d3481c4ea31d459fe4535384ac16547ac40460555" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "usage": "input", + "git_blob": "c6edcbdc43bf36bb11201235027d0ec170d07fc8", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "usage": "input", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "usage": "input", + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full_identity_rebuild.py", + "usage": "input", + "git_blob": "7cff9bff0f61e9b387ade5128dfeab9265efe6d9", + "sha256": "9af2ffbb0038c92e2a7d281081b0daaeadce75b11b566e5427845dc1af91e33d" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/controller/P3-NATIVE-COVER.json.gz", + "usage": "input", + "git_blob": "51a09b3952a491f06780bf6ce5f69b385f026b21", + "sha256": "facfc6d6ecde151afb7e6a167776f3fdaac1c816e785a21a39f7f0bfd9140f3f" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/controller/p3_native_cover.py", + "usage": "input", + "git_blob": "8756693610a8dc8352629d8270cb4c6aed087cb8", + "sha256": "fae71fcbbd20b9ee73b049cf6f43ea1d048217fb15feb6055a007e47da3363fe" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "usage": "input", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/OUTER-TRANSFER-AUDIT.md", + "usage": "input", + "git_blob": "e8b7ef8956ece5bd493cbf52113916e5dc288535", + "sha256": "67569961d068633c6ff3ac9dfde47a0c17f0da6d20432799dcc920cff92b5779" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/p3_cover_audit.py", + "usage": "input", + "git_blob": "d9b44b662a3cfdbc634222590acd9098eb92b9df", + "sha256": "a0fe9a26f77556e83b31b0c91fea909d6f3d8209d0f9f7ad4e5bc1375d33615e" + }, + { + "path": "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "usage": "input", + "git_blob": "0f3a4067a4b4e20d0e6ca0f84f41851c5168f76d", + "sha256": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + }, + { + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendored_path": "research/kappa-hybrid-controller/dependencies/clifford_exact.py" + } + ] +} diff --git a/research/kappa-hybrid-controller/TASK.json b/research/kappa-hybrid-controller/TASK.json new file mode 100644 index 0000000000..45272fe19f --- /dev/null +++ b/research/kappa-hybrid-controller/TASK.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Independently audit the retimed p17 native/direct complex profile in updated PR4441, provide the complete source-bound physical, phase and conditional-transfer certificate plus ordinary BIT admission 0.00312, and refine its conditional kappa from 0.00300105 to 0.003001053.", + "scope_change_reason": "The user explicitly requested inventive means to push kappa significantly and a PR, with periodic refreshes of stronger proposals. The20:13 UTC refresh found concurrent PR4440 query thinning and PR4441 helper retiming. We adopted the audited retiming. The20:27 UTC refresh found updated PR4441 already combined the same profile at0.00300105, above our initial0.00300104. We audited that update, built the publication directly on its exact head, and refined our independent certificate to0.003001053. The combined profile is credited as concurrent work.", + "bottleneck_link": "Paid direct stages remove transverse factors from idle jobs while retaining the exact Laurent shear identity. Combining the exact full controller invoice with an improved arbitrary-input helper supplier raises the complete moment and admits the stronger conditional endpoint.", + "budget_minutes": 120, + "stop_rule": "Reject an unbound controller identity, missing direct-query phase, unpaid scratch or completion work, noncontractive strictification, insufficient ordinary BIT saving or failed outer predicate. Do not change the selected frontier; keep search claims within their stated finite scope.", + "outcome": "completed", + "evidence": "README.md and NATIVE.md explain the construction and concurrent-source audit; native_inventory.py, local_supplier.py and controller/ reconstruct the retimed local word, exact factor and complete profile; PROOF.md, strictification.py, endpoint.py, bit/ and verify.py give the source-bound conditional certificate.", + "author": "Cinna Davis (1337isnot1337) with substantial OpenAI assistance", + "ai_assistance": "Substantial OpenAI assistance. Parallel research and review covered helper boundaries, exact controller factorization, dynamic discovery, native phases, ordinary BIT admission, strictification and integration.", + "open_questions": [ + { + "question": "Can an intermediate local supplier improve on the native/direct choice?", + "why_it_matters": "A partial supplier could retain productive helpers while reducing transverse and idle costs.", + "first_step": "Derive an arbitrary-input local operator with a complete paid and productive invoice, then add it as a certified controller choice.", + "blocked_by": "A relaxed tariff or scalar-count improvement alone is not a physical supplier." + }, + { + "question": "Can controllers outside the minimal-cut path family improve the complete moment?", + "why_it_matters": "The search through p120 covers only one explicitly described family.", + "first_step": "Generate another exact Laurent factorization and price every physical idle and boundary route.", + "blocked_by": "No exact factorization, phase certificate or global optimality result is available for the larger family." + }, + { + "question": "Can higher-moment tails reduce the sufficient tensor power of the hybrid unit?", + "why_it_matters": "Updated PR4441 already reduces the tensor power to1024 for this invoice. Our independent first-moment proof retains a larger sufficient power and ambient281.", + "first_step": "Rebind the higher-moment tail and logarithmic compiler argument to this exact native geometry, including all paid completion requests and the retained281-dimensional ambient.", + "blocked_by": "The smaller finite constants cannot simply be copied across a different ambient and compiler certificate; no smaller power is needed for the endpoint claim." + }, + { + "question": "Do the inherited all-column, cover, precision and recovery premises hold for the entire expanded program?", + "why_it_matters": "The finite native and arithmetic certificates do not formally verify the asymptotic multiplication theorem.", + "first_step": "Replay the source-bound finite gates, then audit each inherited premise against the chronological product and new fixed-cost envelopes.", + "blocked_by": "A complete independent theorem review remains separate from these finite checks." + } + ] +} diff --git a/research/kappa-hybrid-controller/VALIDATION.md b/research/kappa-hybrid-controller/VALIDATION.md new file mode 100644 index 0000000000..2b8bed3b73 --- /dev/null +++ b/research/kappa-hybrid-controller/VALIDATION.md @@ -0,0 +1,39 @@ +# Validation of the final conditional certificate + +The final default-path replay passed on CPython 3.12.14 with optimization enabled: + +```sh +python3 -I -O -B research/kappa-hybrid-controller/verify.py +``` + +The separate non-regenerating comparison ran from 2026-10-21T20:45:02.127245UTC to 20:47:08.800859UTC and took 126.674 seconds. It reproduced the entire saved receipt and exited 0 without standard-error output. REPLAY.json records the command, exact interpreter version, elapsed time and output. + +The final result is kappa 3001053/1000000000=0.003001053, tested saving 1500527/500000000=0.003001054, ordinary BIT 39/12500=0.00312, tensor power 17160, and sufficient uniform height 15026650096742881962201. This follows a fresh full regeneration with --write-result, which also passed. + +## Executed coverage + +- Intact retimed local supplier: both original literal interpreters, both orientations, all 632 arbitrary local columns, all 320 changed complete-phase recipes, and the unchanged main/scalar/warp/owned-center interfaces. +- Exact full controller: 1156 Laurent entries, 8512 native contacts, 3808 main endpoints, every whole idle and all 112 direct rank-one kernels, including inverse translations and owned copies. +- Complete rank invoice, chronological product, every paid completion/split tail, explicit compiler integers and expanded nonrecursive/ownership/precision envelopes. +- Native p6 BIT construction: 7039 arbitrary input columns, 117 owned-copy episodes, complete ordinary conversion, and all 54 outer strict predicates plus four functional guards. +- A second rational interval implementation checks the construction's moment and both complete tails independently. + +Executed rejection controls cover the direct orientation, 112 omitted direct inverse translations, 1904 omitted endpoint translations, a wrong reverse sign, a wrong intermediate center frame, 224 omitted idle phases, an unpadded rank-one tail, one insufficient decay block, an undamped completion tail, closed epsilon/uniform gaps, insufficient BIT admission and the unfunded tested endpoint. The sufficient compiler checks reject H0-1 and H1-1; the BIT side rejects its unsupported larger raw saving. + +The final source inventory has 53 pinned rows and 51 live input paths. Every live local byte stream was checked against its SHA256 and its Git blob identity obtained from the exact published sources. The pinned task card matches the original catalogue object. These are source/metadata checks, separate from mathematical replay. + +## Independent audit of the stronger concurrent frontier + +This additional registered command passed after conversion to repository-relative paths: + +```sh +python3 -I -O -B research/kappa-hybrid-controller/frontier/audit.py +``` + +It reproduces the complete audit receipt with a newly written outward integer interval engine. It verifies updated PR4441's raw moment, higher-moment tails, compiler arithmetic, exact BIT conversion, all 54+4 outer checks, and fixed-profile ceiling through 16 derivative cells and 128 further interval cells. The audit reuses the already replayed unchanged native source; it does not perform an additional full native replay. See frontier/REPORT.md for the precise active-ambient and conditional scope. + +## Validation boundary + +The direct default command and independent frontier command were executed locally. The repository's Git-dependent registered-package metadata runner was not executed in the partial local staging tree; hosted registered replay is tracked separately. VERIFY.json registers both commands with timeouts 600 and 120 seconds, using only the Python standard library. + +No huge tensor or uniform word was materialized. No full historical suite or formal proof assistant was run. All-column lifting, permitted physical movement and whole-job matching, precision, analytic estimates, owned erasure, fixed-tape and exact-recovery hypotheses remain the stated inherited premises. A finite replay pass is not independent human acceptance of the full multiplication theorem. diff --git a/research/kappa-hybrid-controller/VERIFY.json b/research/kappa-hybrid-controller/VERIFY.json new file mode 100644 index 0000000000..30e933c43f --- /dev/null +++ b/research/kappa-hybrid-controller/VERIFY.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "notes/copied-centers-lemma.tex", + "notes/three-stage-cover-bit.tex", + "notes/three-stage-cover-rows.tex", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "research/fresh-helper-boundary/CHANGES.json", + "research/fresh-helper-boundary/NATIVE-RESULT.json.gz", + "research/fresh-helper-boundary/native.py", + "research/fresh-helper-thinned/PROOF.md", + "research/fresh-helper-thinned/README.md", + "research/fresh-helper-thinned/RESULT.json", + "research/fresh-helper-thinned/verify.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "research/kappa-function-composition/complex/prune_native.py", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "research/kappa-rebuild/bit/bit_native_binding.py", + "research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/249-records.bin", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/kappa-rebuild/complex/native_extensions.py", + "research/kappa-rebuild/complex/power_two_balance.py", + "research/kappa-rebuild/complex/rebuild_native.py", + "research/pr4359-p7-padding/EXPORTED-SOURCES.json", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/dependencies/compiler-refill/template_bound.py", + "research/pr4359-p7-padding/dependencies/tensor-strictification/native_inventory.py", + "research/pr4359-p7-padding/source/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/pr4359-p7-padding/source/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/identity_mixed_certificate.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/mixed_forest_search.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/complex_controller_factor.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/fresh-certificates/THREE-base-HELPER-BOUNDARIES.json.gz", + "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/pr4359-p7-padding/source/research/kappa-rebuild/complex/full_identity_rebuild.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/controller/P3-NATIVE-COVER.json.gz", + "research/pr4359-p7-padding/source/research/kappa-rebuild/controller/p3_native_cover.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/OUTER-TRANSFER-AUDIT.md", + "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/p3_cover_audit.py", + "research/pr4359-p7-padding/source/research/kappa-rebuild/transfer-audit/p3_native_audit.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate47 live sources; regenerate the intact retimed supplier in both arbitrary-input native interpreters with all320 absolute-phase recipes; reconstruct every p17 Laurent coefficient, main endpoint, whole idle and direct inverse shear; compare the complete invoice and saved receipts; certify paid completion, explicit uniform compilation, native p6 BIT admission,54 strict inequalities and4 functional guards, with rejection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/frontier/audit.py" + ], + "timeout_seconds": 120, + "checks": "Independently replay the exact updated PR4441 arithmetic, fixed-profile ceiling, both paid tails, finite compiler and full outer ledger using outward integer intervals; authenticate four immutable frontier inputs and compare the complete audit receipt." + } + ] +} diff --git a/research/kappa-hybrid-controller/bit/BIT-P6-TENSOR-RESULT.json b/research/kappa-hybrid-controller/bit/BIT-P6-TENSOR-RESULT.json new file mode 100644 index 0000000000..40f2f66216 --- /dev/null +++ b/research/kappa-hybrid-controller/bit/BIT-P6-TENSOR-RESULT.json @@ -0,0 +1,1915 @@ +{ + "admitted_BIT_saving": "39/12500", + "alpha_upper": "99999/100000", + "arithmetic_dependency_sha256": "7ac72da26df21a0bef1ed15cb500468cf94b328e86efd1ed60a7a0016db415c0", + "compiled_uniform_saving": "627/200000", + "complete_normalized_paid_moment_upper": "1653/1696", + "cover": { + "complete_moment_upper": "800001/800002", + "gap": "1/200000", + "prime_coefficient_times_N5": "51200000" + }, + "covered_saving": "313/100000", + "cutoff_encoding": "7^6000", + "gamma_upper": "999/1000", + "materialized_tensor_or_uniform_word": false, + "native_source": { + "COPY_or_ERASE_records": 234, + "all_arbitrary_columns": 7039, + "ambient_rank": 92, + "common_weight_contract": "All original port charts and every product/compiler matcher are fixed rational right routes in one final cover. No intermediate covered child is lowered.", + "exact_factorization": { + "boundary_unit_ADDs_per_port": 48, + "coefficient_projectors": { + "14337": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1024, + 2048 + ], + "15": [ + 5, + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "15873": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 256, + 512, + 0, + 0 + ], + "16383": [ + 64, + 0, + 64, + 0, + 64, + 0, + 64, + 170, + 0, + 0, + 0, + 0 + ], + "255": [ + 80, + 0, + 80, + 0, + 80, + 42, + 0, + 42, + 0, + 0, + 0, + 0 + ], + "63": [ + 20, + 0, + 20, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "diagonal_monomials": [ + 15, + 15, + 63, + 63, + 255, + 255, + 14337, + 14337, + 15873, + 15873, + 16383, + 16383 + ], + "full_coefficient_endpoint_sha256": "bf485e1f07f44b15757bccec1a7c23e2887a8dbef22943b5ff2426fa21fbb0a6", + "left_program": [ + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 7, + 10 + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 2, + 6 + ], + [ + "ADD", + 0, + 6 + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 10, + 5 + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 0, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 10, + 3 + ], + [ + "ADD", + 4, + 3 + ], + [ + "ADD", + 0, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 10, + 1 + ], + [ + "ADD", + 4, + 1 + ], + [ + "ADD", + 2, + 1 + ] + ], + "left_rows": [ + 5, + 2, + 10, + 20, + 42, + 80, + 1024, + 2048, + 256, + 512, + 170, + 64 + ], + "right_program": [ + [ + "ADD", + 5, + 11 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 7, + 11 + ], + [ + "SWAP", + 6, + 10 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 7, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 0, + 3 + ], + [ + "ADD", + 5, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 1 + ] + ], + "right_rows": [ + 2089, + 2, + 2088, + 6, + 2080, + 20, + 2048, + 1040, + 256, + 512, + 64, + 128 + ] + }, + "expanded_chart_identity": "Gamma=I-EE^t+E rho E^t; Gamma^2=I92, active identity on im(E), identity on its orthogonal complement", + "helper_owners": [ + { + "first": 1332, + "last_exclusive": 1771, + "stage": 0 + }, + { + "first": 1771, + "last_exclusive": 2210, + "stage": 1 + }, + { + "first": 2210, + "last_exclusive": 2649, + "stage": 2 + }, + { + "first": 2649, + "last_exclusive": 3088, + "stage": 3 + }, + { + "first": 3088, + "last_exclusive": 3527, + "stage": 4 + }, + { + "first": 3527, + "last_exclusive": 3966, + "stage": 5 + }, + { + "first": 3966, + "last_exclusive": 4405, + "stage": 6 + }, + { + "first": 4405, + "last_exclusive": 4844, + "stage": 7 + }, + { + "first": 4844, + "last_exclusive": 5283, + "stage": 8 + }, + { + "first": 5283, + "last_exclusive": 5722, + "stage": 9 + }, + { + "first": 5722, + "last_exclusive": 6161, + "stage": 10 + }, + { + "first": 6161, + "last_exclusive": 6600, + "stage": 11 + }, + { + "first": 6600, + "last_exclusive": 7039, + "stage": 12 + } + ], + "independent_dirty_helpers": 5707, + "keep": 25279, + "local_all_f_lift": "Every head projector and chart is tensor-multiplied by I_f; the reversed tail block uses C_(Nf). Polynomial identities remain exact, and routes change only cover coordinates.", + "local_audit": "PASS_FULL_LOCAL_COLUMNS_AND_EXACT_PROJECTORS", + "main_endpoints": [ + { + "central_q": true, + "rank": 22, + "role": 0, + "stages": [ + 0, + 1, + 2 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 1, + "stages": [ + 0, + 1, + 2 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 2, + "stages": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 3, + "stages": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "central_q": true, + "rank": 50, + "role": 4, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "central_q": true, + "rank": 50, + "role": 5, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 6, + "stages": [ + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 7, + "stages": [ + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 8, + "stages": [ + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 9, + "stages": [ + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 92, + "role": 10, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 92, + "role": 11, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12 + ] + } + ], + "nonidentity_port_routes_including_inverses": 5328, + "original_p3_audit": "PASS_FIXED_RATIONAL_PORTS_AND_PHYSICAL_ENDPOINTS", + "owned_COPY_episodes": 117, + "paid": { + "1": 17199, + "14": 444, + "2": 17446, + "28": 444, + "3": 1027, + "4": 572, + "42": 222, + "5": 1326, + "6": 143, + "7": 1357 + }, + "pairs": 6, + "scalar_ADD_allowance": 326621, + "source_generator_sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "source_port_audit_sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "source_sha256": { + "DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "MIXED-PRODUCTIVE-BIT.json": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf", + "bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "sources/pr589-regenerated/WORD.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "sources/pr589-regenerated/records/249-records.bin": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a", + "sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "stage_chart_embeddings": [ + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ], + "spectator_axes": [ + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 1 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 15, + 16, + 17, + 18, + 19, + 20, + 21 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 2 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 22, + 23, + 24, + 25, + 26, + 27, + 28 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 3 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 29, + 30, + 31, + 32, + 33, + 34, + 35 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 4 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 36, + 37, + 38, + 39, + 40, + 41, + 42 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 5 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 43, + 44, + 45, + 46, + 47, + 48, + 49 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 6 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 50, + 51, + 52, + 53, + 54, + 55, + 56 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 7 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 8 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 9 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 71, + 72, + 73, + 74, + 75, + 76, + 77 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 10 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 78, + 79, + 80, + 81, + 82, + 83, + 84 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 11 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84 + ], + "stage": 12 + } + ], + "stages": 13, + "status": "PASS_P6_EXACT_NATIVE_PORTS_ARBITRARY_COLUMNS_AND_WHOLE_IDLES", + "targets": { + "22": 444, + "36": 444, + "50": 222, + "8": 5707, + "92": 222 + }, + "whole_idle_windows": [ + { + "index": 0, + "kind": "initial", + "pair": 1, + "rank": 14, + "retained": true, + "stages": [ + 0, + 1 + ] + }, + { + "index": 1, + "kind": "middle", + "pair": 1, + "rank": 7, + "retained": true, + "stages": [ + 2 + ] + }, + { + "index": 2, + "kind": "initial", + "pair": 2, + "rank": 28, + "retained": true, + "stages": [ + 0, + 1, + 2, + 3 + ] + }, + { + "index": 3, + "kind": "middle", + "pair": 2, + "rank": 7, + "retained": true, + "stages": [ + 4 + ] + }, + { + "index": 4, + "kind": "initial", + "pair": 3, + "rank": 42, + "retained": true, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + }, + { + "index": 5, + "kind": "middle", + "pair": 3, + "rank": 7, + "retained": true, + "stages": [ + 6 + ] + }, + { + "index": 7, + "kind": "middle", + "pair": 4, + "rank": 7, + "retained": true, + "stages": [ + 8 + ] + }, + { + "index": 9, + "kind": "middle", + "pair": 5, + "rank": 7, + "retained": true, + "stages": [ + 10 + ] + }, + { + "index": 13, + "kind": "terminal", + "pair": 3, + "rank": 28, + "retained": true, + "stages": [ + 9, + 10, + 11, + 12 + ] + }, + { + "index": 14, + "kind": "terminal", + "pair": 4, + "rank": 14, + "retained": true, + "stages": [ + 11, + 12 + ] + } + ] + }, + "ordinary": { + "admission_gap": "334599/3125000000000", + "atom_power": "2/625", + "linear_adapter_gap": "249665401/3125000000000", + "old_saving": "384599/10000000000", + "stock_absorption_gap": "3105249665401/3125000000000" + }, + "ordinary_saving": "9750334599/3125000000000", + "paid": { + "1": 17199, + "14": 444, + "2": 17446, + "28": 444, + "3": 1027, + "4": 572, + "42": 222, + "5": 1326, + "6": 143, + "7": 1357 + }, + "paid_rank_mass": 102419, + "positive_rank_surplus": 513, + "status": "PASS_EXACT_P6_BIT_TENSOR_AND_ORDINARY_ARITHMETIC", + "strictification_margin": "43/1696", + "target_rank_mass": 102932, + "targets": { + "22": 444, + "36": 444, + "50": 222, + "8": 5707, + "92": 222 + }, + "tensor_power": 6000, + "tested_saving": "157/50000", + "uniform_compiler": { + "H0": 850090000, + "H1": 1066862950001, + "N_encoding": "2^1066862950001", + "delta": "1/400000", + "exit_log2_upper": "20625", + "h": "1/16", + "negative_log2_eta_upper": "5311/40", + "theta_upper": "15/16" + }, + "verifier_sha256": "9993c4b695740d41f56bfac0f4d016e7c62c6fef692fc09b0c01b6d67da7da7c" +} diff --git a/research/kappa-hybrid-controller/bit/BIT-P6-TENSOR.md b/research/kappa-hybrid-controller/bit/BIT-P6-TENSOR.md new file mode 100644 index 0000000000..54a61e2162 --- /dev/null +++ b/research/kappa-hybrid-controller/bit/BIT-P6-TENSOR.md @@ -0,0 +1,240 @@ +# Ordinary BIT saving 0.00312 from the native p6 controller + +This conditional supplier retains DreamingOfClouds's PR589 local word, +eumemic's PR555/543 lineage, zxv's PR4359 controller and delayed-cover +interface, and Jacob Alan Sussman's finite mixed compiler. The finite native +product uses the chronological substitution argument from PR4412/4414. +The source is commit `da637c87c89482bc4c86be36bd0071b3d400dbed`; every local +word, coefficient generator, port binder and input record is authenticated +by exact SHA-256 in the verifier. + +The new supplier uses six main pairs, thirteen native local invocations, +and keep mask 25279. Whole idle operators remain intact until a native +product restores strict rank separation. The result is the ordinary BIT +admission **0.00312**, which supports the stronger hybrid complex compiler. + +## Complete native controller and arbitrary owners + +Run the original `physical_controller(6,25279)` and regenerate every +coefficient projector and both constant boundary programs over the original +BIT coefficient ring. The twelve exact diagonal monomials, in the source's +bit encoding, are + +``` +15,15,63,63,255,255,14337,14337,15873,15873,16383,16383. +``` + +Their productive main ranks are 22, 36, 50 and 92. There are 111 ports per +main role, giving 1332 independent main inputs. Each native invocation +retains all 439 arbitrary helper inputs, for 5707 distinct helpers. Thus +the complete unit has 7039 independent productive input fields. + +The verifier runs the original local forward and reverse audit on all 661 +arbitrary columns. It also runs the original decoded global scalar replay +for all 7039 arbitrary columns, with all 117 source-owned COPY episodes and +234 COPY/ERASE records. No center field contributes productive rank credit. +One owned center bank suffices within a raw invocation; simultaneous or +suspended product invocations use distinct banks. + +The exact scalar allowance is + +``` +13*24305 + 6*(6-1)*111 + 48*111 + 3*6*111 = 326621 +``` + +unit ADDs. This includes the complete raw words, inter-pair bridges, both +new constant boundary programs, and every final swap charged as three ADDs. +The finite template must additionally price every coordinate route and +owned-bank movement from its actual expanded stream. + +## Rational port charts in the larger carrier + +Keep the same original eight-dimensional central block. Add twelve disjoint +seven-dimensional coordinate blocks. The ambient rank is + +\[ +M=8+12\cdot7=92. +\] + +For each of the 111 source roots \(q\), the original binder verifies the +rational rank-one projector \(P_q=qq^t/4\), its orthonormal complement +columns, and the exact 15-dimensional involution \(\rho_q\). It checks +\(\rho_q^2=I\), every entrance and exit frame of the literal local word, +and the exact physical partial-swap identities. These are source byte +authenticated checks, not inferred endpoint ranks. + +For fresh stage \(s=1,\ldots,12\), let \(E_s\) inject the old eight axes +and that stage's seven fresh axes into the 92-dimensional carrier. Extend +the original chart by + +\[ +\Gamma_{s,q}=I-E_sE_s^t+E_s\rho_qE_s^t. +\] + +The verifier lists and checks every coordinate injection and its spectator +axes. Since \(E_s^tE_s=I_{15}\), the original exact chart identity implies +\(\Gamma_{s,q}^2=I_{92}\). The original active projector identity holds +on the image of \(E_s\), and the map is identity on its orthogonal +complement. This proves the larger chart without assuming that the source +six-stage list already covers twelve stages. + +The stage-zero complement \(K_q=I_8-P_q\), the twelve fresh block +projectors, and \(P_q\) are pairwise orthogonal in their stated supports. +Consequently each factored main endpoint has the exact rank + +\[ +1+7\,\#\{\text{selected stage projectors}\}. +\] + +All charts, coefficient identities and projector identities tensor with +\(I_f\) for arbitrary column multiplicity. They are fixed rational right +routes in one eventual cover. The source's common ancestor-dependent +weight contract remains in force. + +## The whole idle inventory + +The ten retained idle events have ranks + +``` +14,7,28,7,42,7,7,7,28,14. +``` + +Each event acts on both sides of its pair at all 111 ports. These are sums +of the exact orthogonal stage projectors; their total stage count is 23. +For orthogonal projectors \(P,Q\), the native identity +\(D_PD_Q=D_{P+Q}\) combines adjacent stages with their original whole-job +matcher. No arithmetic event lies inside an idle interval. The complete +invoice is therefore + +``` +targets = {8:5707,22:444,36:444,50:222,92:222}, +paid = {1:17199,2:17446,3:1027,4:572,5:1326,6:143, + 7:1357,14:444,28:444,42:222}. +``` + +The target rank mass is 102932 and the paid rank mass is 102419. The positive +surplus is 513. All copied-center descendants remain in the paid invoice. +The raw profiles overlap in rank, so this raw mixed inequality is not yet +a strictly decreasing recursive rule. + +## Native product before covering + +Let complete native words \(U,V\) have target ranks \(k_i,h_j\) and +chronological paid ranks \(r_\ell,s_a\). Make distinct \(U\) copies, +one for each \(V\) target role, at the corresponding column multiplicity +\(h_j\). Embed all projectors and fixed rational routes in one common +product ambient. Their independent productive owners are the pairs +\((i,j)\). + +Run those copies in lockstep. At paid position \(\ell\), suspend each +copy and apply one complete \(V\) invocation, at multiplicity \(r_\ell\), +to the distinct current owners. Its target \(j\) returns the required +rank \(r_\ell h_j\) job. Restore its full role matchers and finish its +own separate owned-bank episodes before resuming \(U\). + +The original local correctness holds on arbitrary inputs, including +correlated values occupying distinct owners. This finite acyclic program +has target ranks \(k_i h_j\) and paid ranks \(r_\ell s_a\). It preserves +all source-owned COPY and ERASE operations and every chronological paid +position. Target and paid moments consequently multiply. + +No intermediate cover or weighted ordinary child is formed. All port, +product and uniform-compiler matchers remain fixed rational right routes +until one final cover is chosen. Child-specific weights are introduced +only at its final rank-one leaves, with fresh disjoint row stock. This +ordering is essential to the inherited common-weight condition. + +## Exact finite strictification + +Set \(C=0.00314\), \(\tau=1-C\), and write \(T_\tau,P_\tau\) for +the complete raw moments. Directed rational logarithm and exponential +intervals prove + +\[ +\alpha=\frac{P_\tau}{T_\tau}<1-\frac1{100000},\qquad +\gamma=\frac{102419}{7^C T_\tau}<\frac{999}{1000}. +\] + +Take \(v=6000\) native factors and cutoff \(J=7^v\). A product target +has rank between \(8^v\) and \(92^v\). Split every paid rank above \(J\) +into consecutive orthogonal blocks \(J,\ldots,J,r\), omitting a zero +remainder, inside the original complete-job matcher. For \(R=qJ+r\), + +\[ +qJ^\tau+r^\tau\leq2RJ^{-C}. +\] + +The complete normalized paid moment, including every split tail, is less +than + +\[ +\alpha^v+2\gamma^v +<\frac{1}{1+6000/100000}+\frac2{2^6} +=\frac{1653}{1696}<1. +\] + +The verifier checks \((999/1000)^{1000}<1/2\) with exact arithmetic. +Every final paid rank is at most \(7^v<8^v\), while splitting preserves +the surplus \(102932^v-102419^v>0\). These are the two hypotheses required +by the strict finite mixed compiler. + +## Explicit uniformization and delayed cover + +Use uniform saving 0.003135. Put + +\[ +t=1-0.00314,\quad z=1-0.003135,\quad +z_0=(t+z)/2,\quad \delta=z_0-t=1/400000,\quad h=1/16. +\] + +The inequalities \(7^{16}<8^{15}\), \(7<2^3\), and \(92<2^7\) give +the compiler exit bound with logarithmic coefficient +\((3+7h)v=20625\). Its complement coefficient has negative logarithm +less than \(1+7v(1-z_0)=5311/40\). The sufficient integers are + +\[ +H_0=850090000,\qquad H_1=1066862950001,\qquad N=2^{H_1}. +\] + +The verifier derives these integers from the source inequalities and +checks \(H_0\ge7v\) and +\(H_1(z-z_0)>H_0(1-z_0)\). The original rank-50 numerical coefficient +is not reused for the larger finite template. + +Now choose the final odd-prime cover, excluding all fixed denominator, +determinant and rank-witness primes. With covered saving 0.00313 and +gap \(d=1/200000\), take \(q>51200000N^5\). The complete good-class +and bad-class fallback moment is less than + +\[ +\frac{1+d/4}{1+d/2}<1. +\] + +Retain the source \(4N^2-2N\) generic-normalizer and \(32N^2\) fallback +allowances. Recompute all finite movement, field, owned-bank, matrix-height +and precision constants from the expanded word. The original small-word +stock bound is not reused. The finite template is fixed before the eventual +input size varies, so its borrowed stock remains +\(O_{\text{fixed template}}(w\log e)\). + +## Ordinary conversion + +Use atom power 0.0032 and the source ordinary saving \(384599/10^{10}\). +The ordinary saving before relaxation is exactly + +\[ +(1-0.0032)\,0.00313+0.0032\,\frac{384599}{10^{10}} +=\frac{9750334599}{3125000000000} +=0.00312010707168>0.00312. +\] + +It is below the atom power, and the stock-absorption inequality also has +strict slack. The original fixed two-call ordinary wrapper changes only +the fixed multiplicity, as in PR4359. This proves the conditional ordinary +BIT supplier saving 0.00312 under the inherited native, mixed-compiler, +cover, precision, fixed-tape and recovery premises. + +`bit_p6_tensor_extension.py --source-root SOURCE --out RESULT.json` runs the +complete source replay and exact parameter calculation. Arithmetic-only +execution is explicitly labelled as such. The huge product and uniform +words are finite algorithmic constructions; they have not been materialized. diff --git a/research/kappa-hybrid-controller/bit/BIT-TENSOR-RESULT.json b/research/kappa-hybrid-controller/bit/BIT-TENSOR-RESULT.json new file mode 100644 index 0000000000..163f02fc51 --- /dev/null +++ b/research/kappa-hybrid-controller/bit/BIT-TENSOR-RESULT.json @@ -0,0 +1,117 @@ +{ + "admitted_BIT_saving": "29/10000", + "alpha_upper": "124999/125000", + "compiled_uniform_saving": "583/200000", + "complete_normalized_paid_moment_upper": "64129/66048", + "cover": { + "complete_moment_upper": "800001/800002", + "gap": "1/200000", + "prime_coefficient_times_N5": "51200000" + }, + "covered_saving": "291/100000", + "cutoff_encoding": "7^4000", + "gamma_upper": "399/400", + "materialized_tensor_or_uniform_word": false, + "native_source": { + "complete_idle_windows": [ + { + "index": 0, + "kind": "initial", + "pair": 1, + "rank": 14, + "retained": true, + "stages": [ + 0, + 1 + ] + }, + { + "index": 1, + "kind": "middle", + "pair": 1, + "rank": 7, + "retained": true, + "stages": [ + 2 + ] + }, + { + "index": 3, + "kind": "middle", + "pair": 2, + "rank": 7, + "retained": true, + "stages": [ + 4 + ] + }, + { + "index": 5, + "kind": "terminal", + "pair": 1, + "rank": 14, + "retained": true, + "stages": [ + 5, + 6 + ] + } + ], + "forward_reverse_local_audit": "PASS_FULL_LOCAL_COLUMNS_AND_EXACT_PROJECTORS", + "global_productive_fields": 3739, + "local_arbitrary_columns": 661, + "native_audit": "PASS_FIXED_RATIONAL_PORTS_AND_PHYSICAL_ENDPOINTS", + "raw_owned_COPY_episodes": 63, + "raw_scalar_ADD_allowance": 174908, + "source_sha256": { + "DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "MIXED-PRODUCTIVE-BIT.json": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf", + "bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "sources/pr589-regenerated/WORD.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "sources/pr589-regenerated/records/249-records.bin": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a", + "sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "status": "PASS_SOURCE_NATIVE_AND_WHOLE_IDLE_REPLAY" + }, + "ordinary": { + "admission_gap": "13853797/10000000000000", + "atom_power": "3/1000", + "linear_adapter_gap": "986146203/10000000000000", + "old_saving": "384599/10000000000", + "stock_absorption_gap": "9940986146203/10000000000000" + }, + "ordinary_saving": "29013853797/10000000000000", + "paid": { + "1": 9261, + "14": 444, + "2": 9394, + "3": 553, + "4": 308, + "5": 714, + "6": 77, + "7": 577 + }, + "paid_rank_mass": 45227, + "positive_rank_surplus": 225, + "status": "PASS_EXACT_BIT_TENSOR_ARITHMETIC", + "strictification_margin": "1919/66048", + "target_rank_mass": 45452, + "targets": { + "22": 444, + "50": 222, + "8": 3073 + }, + "tensor_power": 4000, + "tested_saving": "73/25000", + "uniform_compiler": { + "H0": 454744000, + "H1": 530686248001, + "N_encoding": "2^530686248001", + "delta": "1/400000", + "exit_log2_upper": "13500", + "h": "1/16", + "negative_log2_eta_upper": "3551/50", + "theta_upper": "15/16" + } +} diff --git a/research/kappa-hybrid-controller/bit/BIT-TENSOR.md b/research/kappa-hybrid-controller/bit/BIT-TENSOR.md new file mode 100644 index 0000000000..58340d88f1 --- /dev/null +++ b/research/kappa-hybrid-controller/bit/BIT-TENSOR.md @@ -0,0 +1,166 @@ +# Ordinary BIT saving 0.0029 from complete idle jobs + +This is a conditional supplier extension of zxv's PR4359 BIT construction. +It retains DreamingOfClouds's PR589 local word, eumemic's PR555/543 lineage, +Jacob Alan Sussman's finite mixed compiler, and the original delayed-cover +interface. The native product follows the chronological substitution argument +in PR4412 and PR4414. The new observation is that the old BIT bill splits +complete rank-fourteen idle jobs solely to enforce local rank separation. +Keeping those jobs whole gives a better moment; a native product restores +strict separation afterward. + +## The complete native p3 word + +Use the same seven-call controller, three main pairs and keep mask 43. Keep +all 666 independent main inputs and all 3073 fresh helper inputs. All 63 +source-owned COPY episodes remain paid, with one reusable owned bank within +each raw invocation. Distinct suspended raw invocations get distinct banks. +The literal scalar allowance is the source's 174908 ADDs, with swaps counted +as three ADDs. The exact source replay checks all 661 local arbitrary input +columns in both orientations, rational port charts, all helper ownership and +the complete physical endpoints. + +The four retained idle events have ranks 14, 7, 7 and 14. Each acts on both +main sides at every one of the 111 ports. At a rank-fourteen event, the two +rank-seven stage projectors P and Q satisfy PQ=QP=0. The source projector +identity D_P D_Q=D_(P+Q) holds by direct multiplication. Replace the adjacent +two rank-seven calls by this single whole rank-fourteen call. Preserve the +event's input owner and its whole-job routes. There is no scalar operation +between the original two calls, so this replacement preserves the actual +chronological operator. + +The new complete inventory is + +``` +targets = {8:3073,22:444,50:222}, +paid = {1:9261,2:9394,3:553,4:308,5:714,6:77,7:577,14:444}. +``` + +Expanding each rank-fourteen call back into two rank-seven calls gives the +source's exact invoice, including all copied-center descendants. The target +rank mass is 45452 and the paid rank mass is 45227, leaving surplus 225. +The raw rule has overlapping target and paid ranks, so it is not admitted +directly into the original strict compiler. + +## Native BIT product before covering + +For native words U and V, let U have independent target roles i of ranks k_i +and chronological paid ranks r_l; let V have target roles j of ranks h_j +and paid ranks s_a. For each V target j, instantiate a distinct U copy at +column multiplicity h_j. Embed its projectors and every fixed rational +right-route symbol into one common product ambient space. Its productive +input fields are labelled (i,j). Each input is an arbitrary complete array. + +Run the U copies in lockstep through their common scalar/COPY/paid-call +sequence. At paid position l, pause each copy. The current paid owners are +distinct across the copies, though their values may be correlated or belong +to owned center banks. Run one V invocation at column multiplicity r_l on +these owners, using the source's whole-job rational equal-rank matchers. +V's target j returns the required job of rank r_l h_j. Undo its complete +role routes and resume U only after V has finished and erased its own +separate owned banks. + +This is a finite acyclic native projector program. It computes independent +endpoints of ranks k_i h_j and pays ranks r_l s_a. Source correctness on +arbitrary inputs permits correlated values inside distinct physical slots. +No field is duplicated to create output credit, and no two paid positions +of one U copy are combined. Every center and source-owned COPY is retained. +Thus the target and paid moments multiply under native composition. + +The cover is still formal at this point. No intermediate job has been +lowered to an ordinary weighted child. All original port routes, tensor +matchers and uniform-compiler routes will belong to one final GL_N cover. +This preserves PR4359's common-weight contract: child-specific weights are +created only when final rank-one leaves are lowered after uniformization. + +## A finite strict rule + +Write C=0.00292 and tau=1-C. Let T_tau and P_tau be the moments of the +complete raw profiles above. The directed rational interval calculation in +`bit_tensor_extension.py` proves + +``` +alpha = P_tau/T_tau < 1 - 1/125000, +gamma = 45227/(7^C T_tau) < 399/400. +``` + +Take v=4000 native copies. The product target minimum is 8^v and its maximum +is 50^v. Set J=7^v. Split each paid rank R>J into consecutive disjoint-axis +jobs J,...,J,r, omitting a zero remainder. Preserve the original complete-job +matcher around the whole replacement. The elementary inequality + +``` +q J^tau+r^tau <= 2 R J^(-C), R=qJ+r, +``` + +gives the complete normalized paid bound + +``` +alpha^v + 2 gamma^v +< 1/(1+4000/125000) + 2/2^10 < 1. +``` + +Here (399/400)^400<1/2 is checked with exact integer arithmetic. The first +term uses (1-u)^v<=1/(1+vu). Both the mixed moment and the separate tail +condition are required. All final paid ranks are at most 7^v<8^v, giving +the strict separation needed by the source compiler. Splitting preserves +the positive rank-one surplus 45452^v-45227^v. + +## Explicit uniformization + +Set the uniform saving to 0.002915. Let t=1-0.00292, z=1-0.002915, +z0=(t+z)/2, delta=z0-t=1/400000, and h=1/16. The exact inequalities +7^16<8^15, 7<2^3 and 50<2^6 give the source exit estimate + +``` +m E(x)/x < 2^((3+6h)v) x^(-h), x>=m=50^v. +``` + +The complement coefficient eta=z0 m^(z0-1) satisfies +-log2(eta)<1+6v(1-z0). Consequently the explicit integers + +``` +H0 = ceil((((3+6h)v)delta+1+6v(1-z0))/(h delta)), +H1 = floor(H0(1-z0)/(z-z0))+1, +N = 2^H1 +``` + +give the source strict uniform moment. The certificate records H0 and H1 +and checks H0>=6v, so the initial threshold covers every finite base rank. +This reuses the source induction with new exit and complement constants; +it does not reuse its old rank-50 coefficient bound for the expanded word. + +## Delayed cover and ordinary conversion + +After compiling this finite native word, apply a single GL_N cover. Preserve +all rational port charts and every product/compiler matcher. Choose an odd +prime q avoiding all fixed denominators, determinants and rank witnesses, +with q>51200000 N^5. This is the original q>256 N^5/d rule with +d=0.002915-0.00291=1/200000. Its complete good-plus-fallback moment is less +than (1+d/4)/(1+d/2)<1. Only its final rank-one leaves become ordinary +weighted children, with each new child using fresh disjoint row stock. + +Use the source's atom power 0.003 and its old ordinary saving +384599/10^10. The new ordinary saving before relaxation is exactly + +``` +(1-0.003)*0.00291 + 0.003*(384599/10^10) += 29013853797/10^13 += 0.0029013853797. +``` + +It is greater than 0.0029 and less than the atom power 0.003. The root linear +adapter and O(w log e) borrowed-stock terms remain lower order. The source +row reserve is still O_(fixed template)(w log e), because the product and +uniform words are fixed before the eventual input size varies. + +All constants must be computed from this new expanded word: ambient N, +productive fields, actual paid leaves, owned banks, scalar/COPY/erase records, +every rational route and inverse, and every matrix height. Retain the source +4N^2-2N generic-normalizer allowance and 32N^2 bad-class fallback allowance. +No original small-word numerical stock or movement constant is reused. + +This proves the conditional ordinary BIT admission 0.0029 under the source +native, finite-compiler, cover and fixed-tape premises. It does not alone +claim an improved multiplication kappa. The huge finite tensor and uniform +words are algorithmically specified and have not been materialized. diff --git a/research/kappa-hybrid-controller/bit/bit_p6_tensor_extension.py b/research/kappa-hybrid-controller/bit/bit_p6_tensor_extension.py new file mode 100644 index 0000000000..6dd73935af --- /dev/null +++ b/research/kappa-hybrid-controller/bit/bit_p6_tensor_extension.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""Source-bound p6 native BIT controller with ordinary saving 0.00312. + +Retains the complete PR589/PR4359 local word and its owned copied centers. +Every p6 polynomial coefficient, helper owner and whole idle is regenerated. +The p3 utility is an authenticated dependency for rational arithmetic and +the original local port audit. Apache-2.0; source authors credited in proof. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse, json, sys + +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import bit_tensor_extension as BASE +if sha256(Path(BASE.__file__).read_bytes()).hexdigest()!='7ac72da26df21a0bef1ed15cb500468cf94b328e86efd1ed60a7a0016db415c0': + raise ValueError('Authenticated p3 arithmetic and original source-replay dependency') + +PAIRS=6 +KEEP=25279 +STAGES=13 +AMBIENT=92 +T={8:5707,22:444,36:444,50:222,92:222} +P={1:17199,2:17446,3:1027,4:572,5:1326,6:143,7:1357,14:444,28:444,42:222} +TESTED=Q('0.00314') +UNIFORM=Q('0.003135') +COVERED=Q('0.00313') +ADMITTED=Q('0.00312') +POWER=6000 +need=BASE.need + +def source_replay(root): + baseline=BASE.source_replay(root) + import mixed_productive_bit as B + import bit_native_binding as N + folder=root/'research/kappa-rebuild/bit' + word,streams,local=B.audit_local(folder/'sources/pr589-regenerated/WORD.json.gz') + ports=N.run() + need(ports['status']=='PASS_FIXED_RATIONAL_PORTS_AND_PHYSICAL_ENDPOINTS', + 'Original exact 15-coordinate rational port charts') + coefficient,events,idle=B.physical_controller(PAIRS,KEEP) + factor=B.simultaneous_monomial_factor(coefficient) + need(factor is not None,'Every p6 coefficient factors over the exact source ring') + expected=[15,15,63,63,255,255,14337,14337,15873,15873,16383,16383] + need(factor['diagonal_monomials']==expected,'All twelve complete p6 physical monomials') + decoded=B.explicit_unbanked_scalar_replay(PAIRS,streams) + need(decoded['all_arbitrary_columns']==7039 and decoded['independent_dirty_helpers']==5707, + 'Every main and native helper input remains arbitrary and distinct') + need(decoded['COPY_episodes']==117 and decoded['private_COPY_closed'], + 'All copied-center episodes remain charged and restored') + scalar=(decoded['unit_ADDs_before_new_boundary_adapters']+ + B.V*factor['boundary_unit_ADDs_per_port']+3*PAIRS*B.V) + need(scalar==326621,'Complete scalar word including both boundaries and final swaps') + need(AMBIENT==8+7*(STAGES-1),'Exact expanded rational carrier') + embeddings=[] + occupied=set(range(8)) + for stage in range(1,STAGES): + fresh=list(range(8+7*(stage-1),8+7*stage)) + axes=list(range(8))+fresh + need(len(axes)==len(set(axes))==15 and max(axes)>(s+1)&1] + need(mon&1==1,'Every p6 main role keeps exactly one central rank') + rank=1+7*len(selected) + targets[rank]+=B.V + endpoints.append(dict(role=role,central_q=True,stages=selected,rank=rank)) + paid=Counter({rank:STAGES*count for rank,count in B.LOCAL.items()}) + windows=[] + for row in idle: + if row['retained']: + need(row['rank']==7*len(row['stages']), 'Whole idle is the sum of its orthogonal stage projectors') + paid[row['rank']]+=2*B.V + windows.append(row) + need(dict(targets)==T and dict(paid)==P,'Complete p6 target and paid histograms') + need(len(windows)==10 and sum(len(w['stages']) for w in windows)==23, + 'All complete idle windows are present once') + need(sum(T.values())==7039,'No scratch endpoint receives target credit') + helper_owners=[dict(stage=s,first=2*PAIRS*B.V+s*B.R, + last_exclusive=2*PAIRS*B.V+(s+1)*B.R) for s in range(STAGES)] + need(helper_owners[0]['first']==1332 and helper_owners[-1]['last_exclusive']==7039, + 'Fresh helper owners partition all helper input columns') + return dict(status='PASS_P6_EXACT_NATIVE_PORTS_ARBITRARY_COLUMNS_AND_WHOLE_IDLES', + pairs=PAIRS,keep=KEEP,stages=STAGES,ambient_rank=AMBIENT, + local_audit=local['status'],original_p3_audit=baseline['native_audit'], + all_arbitrary_columns=7039,independent_dirty_helpers=5707, + owned_COPY_episodes=117,COPY_or_ERASE_records=234, + scalar_ADD_allowance=scalar,helper_owners=helper_owners, + exact_factorization=factor,main_endpoints=endpoints, + whole_idle_windows=windows,stage_chart_embeddings=embeddings, + nonidentity_port_routes_including_inverses=(STAGES-1)*111*2*2, + targets=dict(sorted(targets.items())),paid=dict(sorted(paid.items())), + source_sha256=BASE.SOURCE_HASHES, + source_generator_sha256=sha256(Path(B.__file__).read_bytes()).hexdigest(), + source_port_audit_sha256=sha256(Path(N.__file__).read_bytes()).hexdigest(), + local_all_f_lift=ports['all_f_lift'], + expanded_chart_identity='Gamma=I-EE^t+E rho E^t; Gamma^2=I92, active identity on im(E), identity on its orthogonal complement', + common_weight_contract='All original port charts and every product/compiler matcher are fixed rational right routes in one final cover. No intermediate covered child is lowered.') + +def arithmetic(): + tlo,thi=BASE.moment(T,TESTED);plo,phi=BASE.moment(P,TESTED) + T1=sum(rank*count for rank,count in T.items()) + P1=sum(rank*count for rank,count in P.items()) + need((T1,P1)==(102932,102419),'Exact complete rank masses') + alpha=phi/tlo + gamma=Q(P1)/(BASE.powers(7,TESTED)[0]*tlo) + need(alpha<1-Q(1,100000),'Certified strict tested mixed moment') + need(gamma=7*POWER and H1*(z-z0)>H0*(1-z0),'Uniform compiler strict moment') + gap=UNIFORM-COVERED + cover_bound=(1+gap/4)/(1+gap/2) + need(gap==Q(1,200000) and cover_bound<1,'Complete delayed good and fallback cover') + atom=Q('0.0032');old=Q(384599,10**10) + ordinary=(1-atom)*COVERED+atom*old + need(ordinary==Q(9750334599,3125000000000),'Exact ordinary conversion') + need(atom>ordinary>ADMITTED and atom<1-ordinary,'Ordinary adapter and borrowed stock exponents') + need(BASE.moment(T,Q('.00315'))[1]=1,'Logarithm domain') + while n>2:n/=2;power+=1 + x=(n-1)/(n+1); count=80 + lo=2*sum((x**(2*k+1)/(2*k+1)for k in range(count)),Q(0)) + hi=lo+2*x**(2*count+1)/((2*count+1)*(1-x*x)) + if power: + a,b=log_bounds(2);lo+=power*a;hi+=power*b + return lo,hi + +def exp_bounds(x): + need(0<=x>1).bit_count()]+=111 + paid=Counter({r:7*n for r,n in B.LOCAL.items()}) + windows=[] + for row in idle: + if row['retained']: + paid[row['rank']]+=222 + windows.append(row) + need(dict(targets)==T and dict(paid)==P,'Whole idle invoice from literal controller') + split=Counter(paid);split[7]+=2*split.pop(14) + need(dict(split)==native['paid'],'Disjoint rank-seven splitting reproduces source invoice') + need(sum(n*r for r,n in P.items())==sum(n*r for r,n in native['paid'].items()), + 'Whole idle replacement preserves every rank-one charge') + need(len(windows)==4 and [w['rank']for w in windows]==[14,7,7,14], + 'All four literal complete idle operators') + return {'status':'PASS_SOURCE_NATIVE_AND_WHOLE_IDLE_REPLAY', + 'local_arbitrary_columns':661,'global_productive_fields':3739, + 'complete_idle_windows':windows,'raw_owned_COPY_episodes':63, + 'raw_scalar_ADD_allowance':174908, + 'source_sha256':SOURCE_HASHES, + 'forward_reverse_local_audit':audit['status'], + 'native_audit':native['status']} + +def arithmetic(): + tlo,thi=moment(T,TESTED);plo,phi=moment(P,TESTED) + T1=sum(n*r for r,n in T.items());P1=sum(n*r for r,n in P.items()) + need(T1==45452 and P1==45227,'Complete rank-one masses') + alpha=phi/tlo + gamma=Q(P1)/(powers(7,TESTED)[0]*tlo) + need(alpha<1-Q(1,125000),'Strict tested mixed moment with certified margin') + need(gamma=6*POWER and H1*(z-z0)>H0*(1-z0),'Explicit sufficient uniform rank') + covergap=UNIFORM-COVERED + need(covergap>0,'Delayed-cover slack') + prime=256/covergap + complete_cover=(1+covergap/4)/(1+covergap/2) + need(complete_cover<1,'All bad-class fallback fits before lowering final leaves') + atom=Q(3,1000);old=Q(384599,10**10) + ordinary=(1-atom)*COVERED+atom*old + need(atom>ordinary>ADMITTED>0 and atom<1-ordinary,'Ordinary adapter and stock costs') + need(max(P)>min(T),'Raw rule does need strictification') + need(moment(T,Q('.003'))[1] 259998^n; target padding adds equal paid and target rank, and splitting preserves rank", + "t": "498499473/500000000", + "target_max_encoding": "153^17160", + "target_min_encoding": "19^17160", + "tensor_power": 17160, + "theta_upper": "54/55", + "z": "6978992623/7000000000", + "z0": "2791597049/2800000000" + }, + "gain_over_PR4359": "701053/1000000000", + "gain_over_PR4405": "695963/1000000000", + "gain_over_PR4414": "321183/1000000000", + "gain_over_PR4416": "314583/1000000000", + "gain_over_allfresh_p3": "523503/1000000000", + "kappa": "3001053/1000000000", + "ledger_source_sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "minimum_outer_margin": "10489496313/24500000000000000000", + "negative_controls": { + "closed_epsilon": { + "actual_logarithmic_gamma_guard": "0", + "epsilon_below_one": "0", + "gaussian_above_main": "-31511061/24500000000000000000", + "global_gamma_power_slack": "-1/70000000000", + "new_semantic_guard_with_C1_one": "0", + "source_axis_superpolynomial": "0" + }, + "closed_uniform_gap": { + "new_complex_uniform_saving_above_b": "0" + }, + "insufficient_BIT": { + "actual_bit_above_effective": "-39259/56000000" + }, + "unfunded_outer_point": { + "boundary_algebraic_matrix_above_kappa": "-10510503687/24500000000000000000", + "fused_gaussian_above_kappa": "-10531511061/24500000000000000000", + "global_coordinate_router_above_kappa": "-3/7000000000", + "group_bit_router_above_kappa": "-112504177/392000000000000000", + "main_transform_above_kappa": "-14010503687/24500000000000000000" + } + }, + "ordinary_BIT_certificate": { + "admitted_BIT_saving": "39/12500", + "alpha_upper": "99999/100000", + "arithmetic_dependency_sha256": "7ac72da26df21a0bef1ed15cb500468cf94b328e86efd1ed60a7a0016db415c0", + "compiled_uniform_saving": "627/200000", + "complete_normalized_paid_moment_upper": "1653/1696", + "cover": { + "complete_moment_upper": "800001/800002", + "gap": "1/200000", + "prime_coefficient_times_N5": "51200000" + }, + "covered_saving": "313/100000", + "cutoff_encoding": "7^6000", + "gamma_upper": "999/1000", + "materialized_tensor_or_uniform_word": false, + "native_source": { + "COPY_or_ERASE_records": 234, + "all_arbitrary_columns": 7039, + "ambient_rank": 92, + "common_weight_contract": "All original port charts and every product/compiler matcher are fixed rational right routes in one final cover. No intermediate covered child is lowered.", + "exact_factorization": { + "boundary_unit_ADDs_per_port": 48, + "coefficient_projectors": { + "14337": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1024, + 2048 + ], + "15": [ + 5, + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "15873": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 256, + 512, + 0, + 0 + ], + "16383": [ + 64, + 0, + 64, + 0, + 64, + 0, + 64, + 170, + 0, + 0, + 0, + 0 + ], + "255": [ + 80, + 0, + 80, + 0, + 80, + 42, + 0, + 42, + 0, + 0, + 0, + 0 + ], + "63": [ + 20, + 0, + 20, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "diagonal_monomials": [ + 15, + 15, + 63, + 63, + 255, + 255, + 14337, + 14337, + 15873, + 15873, + 16383, + 16383 + ], + "full_coefficient_endpoint_sha256": "bf485e1f07f44b15757bccec1a7c23e2887a8dbef22943b5ff2426fa21fbb0a6", + "left_program": [ + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 7, + 10 + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 2, + 6 + ], + [ + "ADD", + 0, + 6 + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 10, + 5 + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 0, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 10, + 3 + ], + [ + "ADD", + 4, + 3 + ], + [ + "ADD", + 0, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 10, + 1 + ], + [ + "ADD", + 4, + 1 + ], + [ + "ADD", + 2, + 1 + ] + ], + "left_rows": [ + 5, + 2, + 10, + 20, + 42, + 80, + 1024, + 2048, + 256, + 512, + 170, + 64 + ], + "right_program": [ + [ + "ADD", + 5, + 11 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 7, + 11 + ], + [ + "SWAP", + 6, + 10 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 7, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 0, + 3 + ], + [ + "ADD", + 5, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 1 + ] + ], + "right_rows": [ + 2089, + 2, + 2088, + 6, + 2080, + 20, + 2048, + 1040, + 256, + 512, + 64, + 128 + ] + }, + "expanded_chart_identity": "Gamma=I-EE^t+E rho E^t; Gamma^2=I92, active identity on im(E), identity on its orthogonal complement", + "helper_owners": [ + { + "first": 1332, + "last_exclusive": 1771, + "stage": 0 + }, + { + "first": 1771, + "last_exclusive": 2210, + "stage": 1 + }, + { + "first": 2210, + "last_exclusive": 2649, + "stage": 2 + }, + { + "first": 2649, + "last_exclusive": 3088, + "stage": 3 + }, + { + "first": 3088, + "last_exclusive": 3527, + "stage": 4 + }, + { + "first": 3527, + "last_exclusive": 3966, + "stage": 5 + }, + { + "first": 3966, + "last_exclusive": 4405, + "stage": 6 + }, + { + "first": 4405, + "last_exclusive": 4844, + "stage": 7 + }, + { + "first": 4844, + "last_exclusive": 5283, + "stage": 8 + }, + { + "first": 5283, + "last_exclusive": 5722, + "stage": 9 + }, + { + "first": 5722, + "last_exclusive": 6161, + "stage": 10 + }, + { + "first": 6161, + "last_exclusive": 6600, + "stage": 11 + }, + { + "first": 6600, + "last_exclusive": 7039, + "stage": 12 + } + ], + "independent_dirty_helpers": 5707, + "keep": 25279, + "local_all_f_lift": "Every head projector and chart is tensor-multiplied by I_f; the reversed tail block uses C_(Nf). Polynomial identities remain exact, and routes change only cover coordinates.", + "local_audit": "PASS_FULL_LOCAL_COLUMNS_AND_EXACT_PROJECTORS", + "main_endpoints": [ + { + "central_q": true, + "rank": 22, + "role": 0, + "stages": [ + 0, + 1, + 2 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 1, + "stages": [ + 0, + 1, + 2 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 2, + "stages": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 3, + "stages": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + { + "central_q": true, + "rank": 50, + "role": 4, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "central_q": true, + "rank": 50, + "role": 5, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 6, + "stages": [ + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 22, + "role": 7, + "stages": [ + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 8, + "stages": [ + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 36, + "role": 9, + "stages": [ + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 92, + "role": 10, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12 + ] + }, + { + "central_q": true, + "rank": 92, + "role": 11, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12 + ] + } + ], + "nonidentity_port_routes_including_inverses": 5328, + "original_p3_audit": "PASS_FIXED_RATIONAL_PORTS_AND_PHYSICAL_ENDPOINTS", + "owned_COPY_episodes": 117, + "paid": { + "1": 17199, + "14": 444, + "2": 17446, + "28": 444, + "3": 1027, + "4": 572, + "42": 222, + "5": 1326, + "6": 143, + "7": 1357 + }, + "pairs": 6, + "scalar_ADD_allowance": 326621, + "source_generator_sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "source_port_audit_sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "source_sha256": { + "DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "MIXED-PRODUCTIVE-BIT.json": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf", + "bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "sources/pr589-regenerated/WORD.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "sources/pr589-regenerated/records/249-records.bin": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a", + "sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "stage_chart_embeddings": [ + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ], + "spectator_axes": [ + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 1 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 15, + 16, + 17, + 18, + 19, + 20, + 21 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 2 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 22, + 23, + 24, + 25, + 26, + 27, + 28 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 3 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 29, + 30, + 31, + 32, + 33, + 34, + 35 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 4 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 36, + 37, + 38, + 39, + 40, + 41, + 42 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 5 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 43, + 44, + 45, + 46, + 47, + 48, + 49 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 6 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 50, + 51, + 52, + 53, + 54, + 55, + 56 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 7 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 8 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 9 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 71, + 72, + 73, + 74, + 75, + 76, + 77 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 10 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 78, + 79, + 80, + 81, + 82, + 83, + 84 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "stage": 11 + }, + { + "chart_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 85, + 86, + 87, + 88, + 89, + 90, + 91 + ], + "spectator_axes": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84 + ], + "stage": 12 + } + ], + "stages": 13, + "status": "PASS_P6_EXACT_NATIVE_PORTS_ARBITRARY_COLUMNS_AND_WHOLE_IDLES", + "targets": { + "22": 444, + "36": 444, + "50": 222, + "8": 5707, + "92": 222 + }, + "whole_idle_windows": [ + { + "index": 0, + "kind": "initial", + "pair": 1, + "rank": 14, + "retained": true, + "stages": [ + 0, + 1 + ] + }, + { + "index": 1, + "kind": "middle", + "pair": 1, + "rank": 7, + "retained": true, + "stages": [ + 2 + ] + }, + { + "index": 2, + "kind": "initial", + "pair": 2, + "rank": 28, + "retained": true, + "stages": [ + 0, + 1, + 2, + 3 + ] + }, + { + "index": 3, + "kind": "middle", + "pair": 2, + "rank": 7, + "retained": true, + "stages": [ + 4 + ] + }, + { + "index": 4, + "kind": "initial", + "pair": 3, + "rank": 42, + "retained": true, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + }, + { + "index": 5, + "kind": "middle", + "pair": 3, + "rank": 7, + "retained": true, + "stages": [ + 6 + ] + }, + { + "index": 7, + "kind": "middle", + "pair": 4, + "rank": 7, + "retained": true, + "stages": [ + 8 + ] + }, + { + "index": 9, + "kind": "middle", + "pair": 5, + "rank": 7, + "retained": true, + "stages": [ + 10 + ] + }, + { + "index": 13, + "kind": "terminal", + "pair": 3, + "rank": 28, + "retained": true, + "stages": [ + 9, + 10, + 11, + 12 + ] + }, + { + "index": 14, + "kind": "terminal", + "pair": 4, + "rank": 14, + "retained": true, + "stages": [ + 11, + 12 + ] + } + ] + }, + "ordinary": { + "admission_gap": "334599/3125000000000", + "atom_power": "2/625", + "linear_adapter_gap": "249665401/3125000000000", + "old_saving": "384599/10000000000", + "stock_absorption_gap": "3105249665401/3125000000000" + }, + "ordinary_saving": "9750334599/3125000000000", + "paid": { + "1": 17199, + "14": 444, + "2": 17446, + "28": 444, + "3": 1027, + "4": 572, + "42": 222, + "5": 1326, + "6": 143, + "7": 1357 + }, + "paid_rank_mass": 102419, + "positive_rank_surplus": 513, + "status": "PASS_EXACT_P6_BIT_TENSOR_AND_ORDINARY_ARITHMETIC", + "strictification_margin": "43/1696", + "target_rank_mass": 102932, + "targets": { + "22": 444, + "36": 444, + "50": 222, + "8": 5707, + "92": 222 + }, + "tensor_power": 6000, + "tested_saving": "157/50000", + "uniform_compiler": { + "H0": 850090000, + "H1": 1066862950001, + "N_encoding": "2^1066862950001", + "delta": "1/400000", + "exit_log2_upper": "20625", + "h": "1/16", + "negative_log2_eta_upper": "5311/40", + "theta_upper": "15/16" + }, + "verifier_sha256": "9993c4b695740d41f56bfac0f4d016e7c62c6fef692fc09b0c01b6d67da7da7c" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "622999999733/625000000000", + "fixed_halo_explicit_metadata_branch": "134750000001/1750000000", + "new_BIT_row_stock_sublinear_in_active_group": "6978999997009/7000000000000", + "new_semantic_group_guard": "3/7000000000" + }, + "margins": { + "boundary_algebraic_matrix": "73525812489496313/24500000000000000000", + "fused_gaussian": "73525812468488939/24500000000000000000", + "global_coordinate_router": "168059/56000000", + "group_bit_router": "1176413055495823/392000000000000000", + "group_scans": "3499999999/3500000000", + "main_transform": "73525808989496313/24500000000000000000", + "microbox_face_corrections": "134750000001/1750000000", + "polynomial_products": "6999999999/7000000000", + "sparse_union_movement": "10026650812489496313/24500000000000000000" + }, + "parameters": { + "a": "168059/56000000", + "b": "1312961/437500000", + "beta": "6999999997/7000000000", + "bit_saving": "39/12500", + "cap_xi": "22276650808989496313/24500000000000000000", + "complex_uniform_saving": "21007377/7000000000", + "d": "1/7000000000", + "epsilon": "6999999999/7000000000", + "kappa": "3001053/1000000000", + "lambda_": "1993997893/2000000000", + "lambda_prime": "3489496313/3500000000", + "layout": "1/7000000000", + "q": "10503687/3500000000", + "r0": "1/70000000000", + "stop": "1/7000000000", + "tested_saving": "1500527/500000000" + }, + "strict_checks": { + "actual_bit_above_effective": "6661/56000000", + "actual_logarithmic_gamma_guard": "1/7000000000", + "actual_logarithmic_group_guard": "2223349196260503687/12250000000000000000", + "alpha_logarithm_absorption": "1/70000000000", + "boundary_algebraic_matrix_above_kappa": "13989496313/24500000000000000000", + "cap_above_band": "10026650808989496313/24500000000000000000", + "cap_below_cell": "2223349187510503687/24500000000000000000", + "cap_below_phase_cell_power": "26723349191010503687/24500000000000000000", + "complex_above_effective": "1/7000000000", + "complex_below_one_over_32": "6179457/218750000", + "complex_endpoint": "1/3500000000", + "epsilon_below_one": "1/7000000000", + "epsilon_positive": "6999999999/7000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "13968488939/24500000000000000000", + "gaussian_above_main": "1739496313/12250000000000000000", + "global_coordinate_router_above_kappa": "1/1750000000", + "global_gamma_power_slack": "9/70000000000", + "group_below_dimension": "1/3500000000", + "group_bit_router_above_kappa": "279495823/392000000000000000", + "group_gauge_power_slack": "2223349196085503687/12250000000000000000", + "group_key_fits_record": "1/3500000000", + "group_positive": "6999999997/7000000000", + "group_scans_above_kappa": "6978992627/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "635041290400418148631/500000000000000000000000", + "lambda_above_internal": "1/14000000000", + "lambda_above_sigma": "3/14000000000", + "lambda_above_tau": "1/14000000000", + "lambda_prime_above_lambda": "1/14000000000", + "lambda_prime_above_leaf": "873687039/3062500000000000000", + "leaf_saving_above_effective": "436187039/3062500000000000000", + "main_transform_above_kappa": "10489496313/24500000000000000000", + "membership_arithmetic_fits_record": "1/7000000000", + "microbox_face_corrections_above_kappa": "538978992633/7000000000", + "microbox_halo_volume": "553000000003/7000000000", + "new_complex_uniform_saving_above_b": "1/7000000000", + "new_semantic_guard_with_C1_one": "1/7000000000", + "polynomial_products_above_kappa": "1744748157/1750000000", + "positive_layout_slack": "1/7000000000", + "q_below_effective": "1/7000000000", + "q_below_internal": "1/7000000000", + "q_below_leaf": "873687039/3062500000000000000", + "q_positive": "10503687/3500000000", + "short_record_fallback": "436187039/437500000", + "source_axis_superpolynomial": "1/7000000000", + "sparse_union_movement_above_kappa": "9953125013989496313/24500000000000000000", + "stop_below_one": "6999999999/7000000000", + "stop_positive": "1/7000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/7000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/7000000000", + "union_tag_work_per_visit_fits_record": "3/7000000000" + } + }, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "schema": "hybrid-p17-padding-outer-endpoint/1", + "scope": "Source-bound PR4441 retimed arbitrary-input local word, p17 native/direct geometry, a finite tensor recipe with target padding, exact moment and outer inequalities, and a specified finite uniform rank. Native tensor closure and the PR4359 inherited precision, storage, analytic, fixed-tape and recovery hypotheses are written premises, not a full formal theorem certificate.", + "status": "PASS_CONDITIONAL_HYBRID_P17_OUTER_POINT", + "strictification_source_sha256": "8028ebd0f83e59bbba1c5f0dd760adb3050c4dce660d675f48eb227ff4649904", + "tested_saving": "1500527/500000000" +} diff --git a/research/kappa-hybrid-controller/certificates/HYBRID-GEOMETRY.json.gz b/research/kappa-hybrid-controller/certificates/HYBRID-GEOMETRY.json.gz new file mode 100644 index 0000000000..8579335be0 Binary files /dev/null and b/research/kappa-hybrid-controller/certificates/HYBRID-GEOMETRY.json.gz differ diff --git a/research/kappa-hybrid-controller/certificates/NATIVE.json b/research/kappa-hybrid-controller/certificates/NATIVE.json new file mode 100644 index 0000000000..4f49ec443c --- /dev/null +++ b/research/kappa-hybrid-controller/certificates/NATIVE.json @@ -0,0 +1,51970 @@ +{ + "all_column_direct_recipe": "At f columns the address map is P tensor I_f (or I_f tensor P in column order), with its induced per-column array permutation. Use one Gaussian child of rank f, inverse route and repeated q translation for C_q inverse. The request has the complete ancestor weight.", + "artifact_hash_encoding": "Uncompressed UTF-8 JSON, sort_keys=True, separators=(comma,colon)", + "artifact_sha256": "a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034", + "case_sha256": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "dimension": 281, + "direct_nonrecursive_movement_records_allowance": 14336, + "direct_owned_copy_episodes": 1792, + "direct_owned_release_episodes": 1792, + "direct_paid_queries": 1792, + "direct_productive_scratch_endpoints": 0, + "direct_query_rank_for_f_columns": "f, with the same ancestor weight; never f rank-one column queries", + "direct_scalar_allowance": 114688, + "direct_scratch_ownership": "Copy source to an owned zero array; query that copy; add to destination; release. No arbitrary helper or productive scratch credit.", + "direct_stage_indices": [ + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32 + ], + "direct_stages": 16, + "factor_factory": { + "artifacts": { + "P17-DIRECT-CASE.json": "00247ee53b39cf01e176d93b8035bbdb18e7669f969b4ab576130205ae02d0df", + "P17-FULL-LAURENT-CASE.json": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33" + }, + "direct_rank1_children": 1792, + "incorrect_backward_sign_rejected": true, + "native_invocations": 19, + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + "status": "PASS_EXACT_P17_LAURENT_SPECIALIZATION" + }, + "factor_factory_source_sha256": "f527528ff19b107427d593bf35481e127154831563179eed3f43f365177d4585", + "fresh_helper_fields": 7752, + "geometry_payload_sha256": "a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034", + "geometry_source_sha256": "fe4e7d689df8af865dc0ae16bcbac9cb50e988efd24f3ff99ac52b498cd6c60a", + "keep": 280378328416255, + "laurent": { + "input_columns": 34, + "literal_events": 341, + "matrix_entries": 1156 + }, + "limits": "Complete finite native/direct controller admission. The common-column tensor rule, expanded fixed route/scalar/owned-stock bounds and inherited precision, analytic, fixed-tape and exact-recovery premises are written separately in PROOF.md.", + "local_profiles": "Independently audited PR4441 retimed local supplier; the enclosing native_inventory reruns its complete literal and phase gate.", + "local_supplier": { + "all_408_helpers_arbitrary": true, + "all_scalar_actions_and_order_unchanged": true, + "all_warp_contacts_unchanged": true, + "authenticated_original_files": 23, + "boundary_movement_allowance": "Every new whole-helper left/right monomial and transport recipe contributes its full finite route and phase cost.", + "distinct_physical_edge_and_boundary_recipes": 320, + "external_main_boundaries_unchanged": true, + "fresh_arbitrary_input_fields": 632, + "inherited_native_gate": { + "ambient_rank": 57, + "controls": { + "raw_rule_not_strictly_separated": true, + "whole_idle_missing_phase_rejected_count": 224, + "wrong_intermediate_center_rejected": true + }, + "fresh_helper_fields": 2856, + "main_fields": 672, + "native_scalar_allowance": 1147304, + "paid": { + "1": 17409, + "16": 448, + "2": 4991, + "3": 1568, + "4": 714, + "5": 140, + "8": 504 + }, + "paid_calls": 25774, + "productive_fields": 3528, + "rank_surplus": 224, + "restored_native_centers": 56, + "schema": "native-all-fresh-full-idle-inventory/1", + "scope": "Exact finite all-fresh controller inventory. Native all-column closure is inherited; the raw rule requires the separate tensor strictification before the old strict compiler applies.", + "source_head": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/kappa-rebuild/complex/fresh-certificates/THREE-base-HELPER-BOUNDARIES.json.gz": "f90517e395bde58c72cacd5d3481c4ea31d459fe4535384ac16547ac40460555", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "research/kappa-rebuild/complex/full_identity_rebuild.py": "9af2ffbb0038c92e2a7d281081b0daaeadce75b11b566e5427845dc1af91e33d", + "research/kappa-rebuild/controller/P3-NATIVE-COVER.json.gz": "facfc6d6ecde151afb7e6a167776f3fdaac1c816e785a21a39f7f0bfd9140f3f", + "research/kappa-rebuild/controller/p3_native_cover.py": "fae71fcbbd20b9ee73b049cf6f43ea1d048217fb15feb6055a007e47da3363fe", + "research/kappa-rebuild/transfer-audit/p3_cover_audit.py": "a0fe9a26f77556e83b31b0c91fea909d6f3d8209d0f9f7ad4e5bc1375d33615e" + }, + "status": "PASS_ACTUAL_ARBITRARY_HELPERS_AND_COMPLETE_PHASE_CORRECT_IDLE_JOBS", + "targets": { + "25": 448, + "5": 196, + "57": 224, + "6": 126, + "7": 392, + "8": 651, + "9": 1491 + }, + "whole_idle_profile": { + "16": 448, + "8": 448 + } + }, + "local_helper_profile": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "local_paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "local_replays": { + "backward": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + }, + "forward": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + }, + "retimed_artifact_sha256": { + "CHANGES.json": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "NATIVE-RESULT.json.gz": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29" + }, + "retimed_native_receipt": { + "changed_entrances": 117, + "changed_exits": 42, + "changed_scalar_frames": 395, + "helpers": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "native": { + "backward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 6396, + "role": [ + "L", + 225 + ] + }, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158168, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + }, + "forward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 19099, + "role": [ + "L", + 224 + ] + }, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158120, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + } + }, + "new_physical_edges_and_boundaries": [ + { + "new": 1, + "old": 0, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 139, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 8, + 17, + 33, + 64, + 3, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 65, + 33, + 2, + 100, + 104, + 16, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 108, + 0, + 109, + 109, + 0, + 13, + 13, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 8, + 17, + 33, + 64, + 3, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 65, + 33, + 2, + 100, + 104, + 16, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 108, + 0, + 109, + 109, + 0, + 13, + 13, + 0, + 0 + ] + } + } + } + }, + { + "new": 140, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 19, + 35, + 2, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 173, + 14, + 257, + 18, + 276, + 280, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 429, + 30, + 435, + 435, + 14, + 429, + 0, + 429, + 173 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 19, + 35, + 2, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 173, + 14, + 257, + 18, + 276, + 280, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 429, + 30, + 435, + 435, + 14, + 429, + 0, + 429, + 173 + ] + } + } + } + }, + { + "new": 141, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 35, + 65, + 136, + 258, + 3, + 1, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 6, + 19, + 384, + 264, + 97, + 34, + 68, + 392, + 112 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 115, + 53, + 70, + 136, + 115, + 19, + 21, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 35, + 65, + 136, + 258, + 3, + 1, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 6, + 19, + 384, + 264, + 97, + 34, + 68, + 392, + 112 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 115, + 53, + 70, + 136, + 115, + 19, + 21, + 136, + 0 + ] + } + } + } + }, + { + "new": 254, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 264, + 4, + 10, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 4, + 34, + 16, + 64, + 128, + 256, + 42 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 264, + 4, + 10, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 4, + 34, + 16, + 64, + 128, + 256, + 42 + ], + "offset": 245, + "phase": 2, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 255, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 133, + 260, + 1, + 7, + 8, + 3, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 3, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 15, + 16, + 64, + 128, + 256, + 45, + 42 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 34, + 39, + 38, + 40, + 0, + 15, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 133, + 260, + 1, + 7, + 8, + 3, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 15, + 16, + 64, + 128, + 256, + 45, + 42 + ], + "offset": 125, + "phase": 2, + "quadratic_rows": [ + 34, + 39, + 38, + 40, + 0, + 15, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 259, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 127, + "phase": 3, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 260, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 294, + 6, + 8, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 98, + 8, + 16, + 70, + 128, + 256, + 102 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 66, + 36, + 0, + 0, + 36, + 2, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 294, + 6, + 8, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 98, + 8, + 16, + 70, + 128, + 256, + 102 + ], + "offset": 219, + "phase": 2, + "quadratic_rows": [ + 0, + 66, + 36, + 0, + 0, + 36, + 2, + 0, + 0 + ] + } + } + } + }, + { + "new": 264, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 267, + 3, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 73, + 4, + 67, + 16, + 32, + 128, + 256, + 75 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 10, + 0, + 10, + 0, + 0, + 1, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 267, + 3, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 73, + 4, + 67, + 16, + 32, + 128, + 256, + 75 + ], + "offset": 245, + "phase": 2, + "quadratic_rows": [ + 65, + 10, + 0, + 10, + 0, + 0, + 1, + 0, + 0 + ] + } + } + } + }, + { + "new": 269, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 274, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 258, + 3, + 1, + 4, + 8, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 5, + 8, + 16, + 32, + 64, + 128, + 256, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 258, + 3, + 1, + 4, + 8, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 5, + 8, + 16, + 32, + 64, + 128, + 256, + 7 + ], + "offset": 252, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 272, + 8, + 20, + 4, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 48, + 8, + 36, + 64, + 128, + 256, + 52 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 272, + 8, + 20, + 4, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 48, + 8, + 36, + 64, + 128, + 256, + 52 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 318, + 3, + 5, + 9, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 126, + 125, + 123, + 119, + 111, + 95, + 128, + 256, + 127 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 318, + 3, + 5, + 9, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 126, + 125, + 123, + 119, + 111, + 95, + 128, + 256, + 127 + ], + "offset": 192, + "phase": 2, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 264, + 12, + 16, + 32, + 4, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 72, + 68, + 16, + 32, + 128, + 256, + 76 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 264, + 12, + 16, + 32, + 4, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 72, + 68, + 16, + 32, + 128, + 256, + 76 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 282, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 132, + 262, + 2, + 7, + 3, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 2, + 15, + 32, + 64, + 128, + 256, + 25, + 30 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 23, + 17, + 21, + 24, + 15, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 132, + 262, + 2, + 7, + 3, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 2, + 15, + 32, + 64, + 128, + 256, + 25, + 30 + ], + "offset": 126, + "phase": 2, + "quadratic_rows": [ + 23, + 17, + 21, + 24, + 15, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 283, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 139, + 3, + 264, + 4, + 9, + 1, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 2, + 3, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 8, + 23, + 64, + 128, + 256, + 51, + 52 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 21, + 38, + 39, + 0, + 49, + 22, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 139, + 3, + 264, + 4, + 9, + 1, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 8, + 23, + 64, + 128, + 256, + 51, + 52 + ], + "offset": 125, + "phase": 2, + "quadratic_rows": [ + 21, + 38, + 39, + 0, + 49, + 22, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 284, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 285, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 290, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 132, + 266, + 12, + 2, + 16, + 6, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 68, + 32, + 128, + 256, + 82, + 76 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 0, + 26, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 132, + 266, + 12, + 2, + 16, + 6, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 68, + 32, + 128, + 256, + 82, + 76 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 0, + 26, + 0, + 0 + ] + } + } + } + }, + { + "new": 291, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 144, + 270, + 6, + 10, + 2, + 17, + 1, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 2, + 12, + 12, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 0, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 96, + 2, + 26, + 22, + 65, + 128, + 256, + 97, + 30 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 12, + 12, + 2, + 33, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 144, + 270, + 6, + 10, + 2, + 17, + 1, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 2, + 12, + 12, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 0, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 96, + 2, + 26, + 22, + 65, + 128, + 256, + 97, + 30 + ], + "offset": 98, + "phase": 3, + "quadratic_rows": [ + 33, + 18, + 12, + 12, + 2, + 33, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 293, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 67, + 131, + 2, + 1, + 264, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 3, + 0 + ], + "matrix_rows": [ + 13, + 14, + 384, + 320, + 33, + 18, + 52, + 56, + 448 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 45, + 30, + 51, + 51, + 14, + 13, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 67, + 131, + 2, + 1, + 264, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 3, + 0 + ], + "matrix_rows": [ + 13, + 14, + 384, + 320, + 33, + 18, + 52, + 56, + 448 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 45, + 30, + 51, + 51, + 14, + 13, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 294, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 45, + 67, + 10, + 4, + 135, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 10, + 12, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 1, + 1, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 509, + 507, + 258, + 321, + 266, + 276, + 288, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 326, + 15, + 275, + 250, + 252, + 248, + 249, + 248, + 5 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 45, + 67, + 10, + 4, + 135, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 10, + 12, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 1, + 1, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 509, + 507, + 258, + 321, + 266, + 276, + 288, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 326, + 15, + 275, + 250, + 252, + 248, + 249, + 248, + 5 + ] + } + } + } + }, + { + "new": 296, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 60, + 6, + 82, + 8, + 138, + 16, + 282, + 26 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 28, + 30, + 22, + 14, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 1, + 252, + 258, + 246, + 222, + 262, + 280, + 352, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 46, + 470, + 306, + 476, + 330, + 500, + 468, + 252 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 60, + 6, + 82, + 8, + 138, + 16, + 282, + 26 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 28, + 30, + 22, + 14, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 3, + 2, + 3, + 1, + 0 + ], + "matrix_rows": [ + 1, + 252, + 258, + 246, + 222, + 262, + 280, + 352, + 384 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 0, + 46, + 470, + 306, + 476, + 330, + 500, + 468, + 252 + ] + } + } + } + }, + { + "new": 298, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 37, + 68, + 7, + 130, + 1, + 272, + 3, + 24, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 24, + 24, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 3, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 1, + 28, + 23, + 384, + 288, + 85, + 70, + 88, + 416 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 66, + 83, + 28, + 76, + 22, + 160, + 11, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 37, + 68, + 7, + 130, + 1, + 272, + 3, + 24, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 24, + 24, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 1, + 28, + 23, + 384, + 288, + 85, + 70, + 88, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 66, + 83, + 28, + 76, + 22, + 160, + 11, + 160, + 0 + ] + } + } + } + }, + { + "new": 299, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 1, + 3, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 301, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 35, + 69, + 128, + 270, + 3, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 390, + 19, + 21, + 145, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 35, + 69, + 128, + 270, + 3, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 2, + 2, + 0, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 390, + 19, + 21, + 145, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ] + } + } + } + }, + { + "new": 303, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 1, + 2, + 3, + 3, + 1, + 2 + ], + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ] + } + } + } + }, + { + "new": 304, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 45, + 70, + 141, + 6, + 256, + 3, + 10, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 4, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 389, + 14, + 138, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 462, + 351, + 411, + 351, + 14, + 0, + 11, + 389, + 143 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 45, + 70, + 141, + 6, + 256, + 3, + 10, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 4, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 1, + 2, + 0, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 389, + 14, + 138, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 462, + 351, + 411, + 351, + 14, + 0, + 11, + 389, + 143 + ] + } + } + } + }, + { + "new": 305, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ] + } + } + } + }, + { + "new": 307, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 46, + 78, + 131, + 3, + 261, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 424, + 14, + 38, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 46, + 78, + 131, + 3, + 261, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 424, + 14, + 38, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ] + } + } + } + }, + { + "new": 308, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ] + } + } + } + }, + { + "new": 309, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 46, + 64, + 131, + 261, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 408, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 379, + 379, + 0, + 467, + 427, + 19, + 11, + 408, + 155 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 46, + 64, + 131, + 261, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 408, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 379, + 379, + 0, + 467, + 427, + 19, + 11, + 408, + 155 + ] + } + } + } + }, + { + "new": 314, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 60, + 2, + 5, + 81, + 137, + 8, + 16, + 281, + 25 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 0, + 29, + 21, + 13, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 2, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 252, + 2, + 257, + 245, + 237, + 261, + 296, + 336, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 29, + 0, + 485, + 305, + 329, + 492, + 500, + 484, + 252 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 60, + 2, + 5, + 81, + 137, + 8, + 16, + 281, + 25 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 0, + 29, + 21, + 13, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 3, + 3, + 1, + 0 + ], + "matrix_rows": [ + 252, + 2, + 257, + 245, + 237, + 261, + 296, + 336, + 384 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 29, + 0, + 485, + 305, + 329, + 492, + 500, + 484, + 252 + ] + } + } + } + }, + { + "new": 318, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 20, + 38, + 7, + 65, + 136, + 2, + 3, + 8, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 1, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 3, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 44, + 2, + 39, + 16, + 69, + 102, + 104, + 144, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 99, + 65, + 44, + 76, + 144, + 37, + 11, + 16, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 20, + 38, + 7, + 65, + 136, + 2, + 3, + 8, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 1, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 1, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 44, + 2, + 39, + 16, + 69, + 102, + 104, + 144, + 256 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 99, + 65, + 44, + 76, + 144, + 37, + 11, + 16, + 0 + ] + } + } + } + }, + { + "new": 324, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 34, + 65, + 144, + 264, + 9, + 10, + 11, + 20, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 20, + 8, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 1, + 3, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 50, + 49, + 384, + 8, + 260, + 81, + 98, + 388, + 120 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 97, + 82, + 132, + 120, + 58, + 57, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 34, + 65, + 144, + 264, + 9, + 10, + 11, + 20, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 20, + 8, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 50, + 49, + 384, + 8, + 260, + 81, + 98, + 388, + 120 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 97, + 82, + 132, + 120, + 58, + 57, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 335, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 48, + 68, + 130, + 264, + 14, + 10, + 12, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 4, + 2, + 8, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 1, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 100, + 98, + 8, + 257, + 385, + 50, + 84, + 120 + ], + "offset": 6, + "phase": 1, + "quadratic_rows": [ + 129, + 82, + 52, + 120, + 14, + 108, + 106, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 48, + 68, + 130, + 264, + 14, + 10, + 12, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 4, + 2, + 8, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 0 + ], + "matrix_rows": [ + 384, + 100, + 98, + 8, + 257, + 385, + 50, + 84, + 120 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 129, + 82, + 52, + 120, + 14, + 108, + 106, + 129, + 0 + ] + } + } + } + }, + { + "new": 340, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 1, + 3, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 24, + 13, + 49, + 2, + 52, + 40, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 61, + 0, + 61, + 53, + 13, + 13, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 1, + 3, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 24, + 13, + 49, + 2, + 52, + 40, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 61, + 0, + 61, + 53, + 13, + 13, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 341, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 18, + 3, + 32, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 43, + 5, + 9, + 42, + 36, + 16, + 64, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 38, + 3, + 37, + 0, + 0, + 5, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 18, + 3, + 32, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 43, + 5, + 9, + 42, + 36, + 16, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 38, + 3, + 37, + 0, + 0, + 5, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 351, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 1, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 273, + 290, + 52, + 264, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 38, + 21, + 51, + 504, + 462, + 461, + 504, + 504, + 248 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 1, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 273, + 290, + 52, + 264, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 38, + 21, + 51, + 504, + 462, + 461, + 504, + 504, + 248 + ] + } + } + } + }, + { + "new": 352, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 3, + 65, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 3, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 24, + 11, + 448, + 41, + 42, + 4, + 48, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 35, + 35, + 0, + 24, + 56, + 19, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 3, + 65, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 1, + 2, + 3, + 3, + 2 + ], + "matrix_rows": [ + 24, + 11, + 448, + 41, + 42, + 4, + 48, + 320, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 35, + 35, + 0, + 24, + 56, + 19, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 353, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 1, + 1, + 2 + ], + "matrix_rows": [ + 40, + 14, + 448, + 1, + 50, + 52, + 24, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 62, + 62, + 54, + 14, + 14, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 40, + 14, + 448, + 1, + 50, + 52, + 24, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 62, + 62, + 54, + 14, + 14, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 354, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 7, + 1, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 6, + 485, + 283, + 25, + 266, + 276, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 230, + 21, + 243, + 0, + 6, + 229, + 229, + 229, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 7, + 1, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 6, + 485, + 283, + 25, + 266, + 276, + 288, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 230, + 21, + 243, + 0, + 6, + 229, + 229, + 229, + 0 + ] + } + } + } + }, + { + "new": 355, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 65, + 6, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 3, + 3, + 1 + ], + "matrix_rows": [ + 235, + 451, + 229, + 257, + 306, + 52, + 280, + 320, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 205, + 24, + 213, + 507, + 14, + 296, + 205, + 205, + 296 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 65, + 6, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 1, + 2, + 3, + 1, + 1, + 3 + ], + "matrix_rows": [ + 235, + 451, + 229, + 257, + 306, + 52, + 280, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 205, + 24, + 213, + 507, + 14, + 296, + 205, + 205, + 296 + ] + } + } + } + }, + { + "new": 356, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 3, + 1, + 64, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 0, + 1, + 1, + 2 + ], + "matrix_rows": [ + 6, + 27, + 448, + 25, + 10, + 20, + 32, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 6, + 0, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 3, + 1, + 64, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 6, + 27, + 448, + 25, + 10, + 20, + 32, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 6, + 0, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 357, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 64, + 1, + 2, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 3, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 53, + 54, + 448, + 17, + 34, + 52, + 8, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 37, + 22, + 51, + 0, + 54, + 53, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 64, + 1, + 2, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 1, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 53, + 54, + 448, + 17, + 34, + 52, + 8, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 37, + 22, + 51, + 0, + 54, + 53, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 358, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 7, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 1, + 3, + 2, + 3, + 3, + 1 + ], + "matrix_rows": [ + 453, + 280, + 267, + 297, + 42, + 260, + 304, + 320, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 486, + 291, + 197, + 280, + 56, + 19, + 197, + 197, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 7, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 3, + 1, + 2, + 1, + 1, + 3 + ], + "matrix_rows": [ + 453, + 280, + 267, + 297, + 42, + 260, + 304, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 486, + 291, + 197, + 280, + 56, + 19, + 197, + 197, + 267 + ] + } + } + } + }, + { + "new": 360, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 64, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 136, + 13, + 161, + 2, + 164, + 40, + 16, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 173, + 0, + 173, + 165, + 0, + 13, + 0, + 13, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 64, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 136, + 13, + 161, + 2, + 164, + 40, + 16, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 173, + 0, + 173, + 165, + 0, + 13, + 0, + 13, + 0 + ] + } + } + } + }, + { + "new": 361, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 13, + 208, + 33, + 2, + 36, + 40, + 144, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 80, + 13, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 13, + 208, + 33, + 2, + 36, + 40, + 144, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 80, + 13, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new": 371, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 133, + 385, + 2, + 388, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 261, + 0, + 261, + 120, + 120, + 120, + 56, + 384, + 133 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 133, + 385, + 2, + 388, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 261, + 0, + 261, + 120, + 120, + 120, + 56, + 384, + 133 + ] + } + } + } + }, + { + "new": 372, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 131, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 0, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 440, + 56, + 168, + 1, + 2, + 4, + 456, + 80, + 480 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 232, + 448, + 232, + 56, + 440, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 131, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 0, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 440, + 56, + 168, + 1, + 2, + 4, + 456, + 80, + 480 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 232, + 448, + 232, + 56, + 440, + 144 + ] + } + } + } + }, + { + "new": 373, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 272, + 168, + 21, + 321, + 2, + 324, + 136, + 80, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 341, + 0, + 341, + 40, + 325, + 40, + 21, + 0, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 272, + 168, + 21, + 321, + 2, + 324, + 136, + 80, + 160 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 341, + 0, + 341, + 40, + 325, + 40, + 21, + 0, + 21 + ] + } + } + } + }, + { + "new": 374, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 144, + 296, + 21, + 193, + 2, + 196, + 264, + 80, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 213, + 0, + 213, + 40, + 197, + 40, + 21, + 21, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 144, + 296, + 21, + 193, + 2, + 196, + 264, + 80, + 288 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 0, + 213, + 40, + 197, + 40, + 21, + 21, + 0 + ] + } + } + } + }, + { + "new": 375, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 168, + 65, + 2, + 68, + 392, + 80, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 0, + 85, + 296, + 85, + 296, + 21, + 384, + 168 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 1, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 168, + 65, + 2, + 68, + 392, + 80, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 0, + 85, + 296, + 85, + 296, + 21, + 384, + 168 + ] + } + } + } + }, + { + "new": 376, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 39, + 64, + 131, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 405, + 21, + 133, + 449, + 2, + 452, + 8, + 80, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 197, + 0, + 197, + 0, + 448, + 0, + 21, + 405, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 39, + 64, + 131, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 405, + 21, + 133, + 449, + 2, + 452, + 8, + 80, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 197, + 0, + 197, + 0, + 448, + 0, + 21, + 405, + 144 + ] + } + } + } + }, + { + "new": 377, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 133, + 272, + 56, + 129, + 2, + 132, + 328, + 80, + 352 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 5, + 0, + 5, + 376, + 360, + 376, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 133, + 272, + 56, + 129, + 2, + 132, + 328, + 80, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 376, + 360, + 376, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 378, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 261, + 144, + 56, + 257, + 2, + 260, + 200, + 80, + 224 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 5, + 0, + 5, + 248, + 232, + 248, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 261, + 144, + 56, + 257, + 2, + 260, + 200, + 80, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 248, + 232, + 248, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 380, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 34, + 67, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 470, + 475, + 289, + 258, + 36, + 296, + 272, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 251, + 269, + 502, + 251, + 269, + 13, + 269, + 269, + 470 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 34, + 67, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 3, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 470, + 475, + 289, + 258, + 36, + 296, + 272, + 320, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 251, + 269, + 502, + 251, + 269, + 13, + 269, + 269, + 470 + ] + } + } + } + }, + { + "new": 381, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 13, + 400, + 33, + 2, + 36, + 40, + 272, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 144, + 13, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 13, + 400, + 33, + 2, + 36, + 40, + 272, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 144, + 13, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 391, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 6, + 67, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 2, + 2, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 438, + 437, + 334, + 321, + 266, + 76, + 272, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 245, + 496, + 261, + 0, + 259, + 259, + 3, + 259, + 438 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 6, + 67, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 438, + 437, + 334, + 321, + 266, + 76, + 272, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 245, + 496, + 261, + 0, + 259, + 259, + 3, + 259, + 438 + ] + } + } + } + }, + { + "new": 392, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 11, + 400, + 97, + 98, + 4, + 72, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 107, + 107, + 0, + 99, + 144, + 11, + 11, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 11, + 400, + 97, + 98, + 4, + 72, + 272, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 107, + 107, + 0, + 99, + 144, + 11, + 11, + 144, + 0 + ] + } + } + } + }, + { + "new": 393, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 290, + 324, + 264, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 509, + 472, + 37, + 99, + 99, + 413, + 411, + 99, + 355 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 290, + 324, + 264, + 272, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 509, + 472, + 37, + 99, + 99, + 413, + 411, + 99, + 355 + ] + } + } + } + }, + { + "new": 394, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 3, + 68, + 129, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 14, + 400, + 1, + 74, + 76, + 272, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 40, + 144, + 104, + 38, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 3, + 68, + 129, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 14, + 400, + 1, + 74, + 76, + 272, + 96, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 40, + 144, + 104, + 38, + 144, + 0 + ] + } + } + } + }, + { + "new": 395, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 36, + 6, + 67, + 129, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 187, + 403, + 270, + 257, + 330, + 76, + 272, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 40, + 366, + 326, + 187, + 40, + 507, + 38, + 40, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 36, + 6, + 67, + 129, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 2, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 187, + 403, + 270, + 257, + 330, + 76, + 272, + 352, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 40, + 366, + 326, + 187, + 40, + 507, + 38, + 40, + 38 + ] + } + } + } + }, + { + "new": 396, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 64, + 132, + 3, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 0, + 1, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 99, + 400, + 97, + 34, + 68, + 8, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 69, + 70, + 0, + 144, + 0, + 6, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 64, + 132, + 3, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 99, + 400, + 97, + 34, + 68, + 8, + 272, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 69, + 70, + 0, + 144, + 0, + 6, + 144, + 0 + ] + } + } + } + }, + { + "new": 397, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 65, + 134, + 3, + 7, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 296, + 406, + 181, + 97, + 354, + 260, + 328, + 272, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 213, + 246, + 35, + 104, + 35, + 190, + 11, + 35, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 65, + 134, + 3, + 7, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 1, + 0, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 296, + 406, + 181, + 97, + 354, + 260, + 328, + 272, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 213, + 246, + 35, + 104, + 35, + 190, + 11, + 35, + 0 + ] + } + } + } + }, + { + "new": 398, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 2, + 68, + 128, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 3, + 1, + 0, + 3, + 1, + 2 + ], + "matrix_rows": [ + 77, + 78, + 400, + 65, + 10, + 76, + 272, + 32, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 13, + 70, + 75, + 77, + 144, + 0, + 78, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 2, + 68, + 128, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 3, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 77, + 78, + 400, + 65, + 10, + 76, + 272, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 13, + 70, + 75, + 77, + 144, + 0, + 78, + 144, + 0 + ] + } + } + } + }, + { + "new": 399, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 19, + 97, + 34, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 115, + 113, + 0, + 0, + 115, + 19, + 19, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 19, + 97, + 34, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 115, + 113, + 0, + 0, + 115, + 19, + 19, + 0, + 0 + ] + } + } + } + }, + { + "new": 400, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 19, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 3, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 476, + 463, + 289, + 290, + 260, + 264, + 48, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 239, + 239, + 275, + 275, + 508, + 19, + 275, + 275, + 476 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 19, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 1, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 476, + 463, + 289, + 290, + 260, + 264, + 48, + 320, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 239, + 239, + 275, + 275, + 508, + 19, + 275, + 275, + 476 + ] + } + } + } + }, + { + "new": 401, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 35, + 2, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 0, + 0, + 0 + ], + "matrix_rows": [ + 57, + 58, + 33, + 18, + 4, + 56, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 25, + 42, + 0, + 51, + 57, + 58, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 35, + 2, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 57, + 58, + 33, + 18, + 4, + 56, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 25, + 42, + 0, + 51, + 57, + 58, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 404, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 388, + 33, + 34, + 260, + 8, + 48, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 132, + 0, + 51, + 19, + 0, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 388, + 33, + 34, + 260, + 8, + 48, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 132, + 0, + 51, + 19, + 0, + 132, + 0 + ] + } + } + } + }, + { + "new": 411, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 69, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 388, + 90, + 1, + 82, + 260, + 24, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 10, + 132, + 98, + 0, + 104, + 40, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 69, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 388, + 90, + 1, + 82, + 260, + 24, + 96, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 0, + 10, + 132, + 98, + 0, + 104, + 40, + 132, + 0 + ] + } + } + } + }, + { + "new": 412, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 38, + 67, + 135, + 5, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 2, + 0, + 1, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 24, + 254, + 407, + 97, + 258, + 260, + 296, + 336, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 503, + 105, + 105, + 454, + 49, + 407, + 399, + 105, + 361 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 38, + 67, + 135, + 5, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 24, + 254, + 407, + 97, + 258, + 260, + 296, + 336, + 384 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 503, + 105, + 105, + 454, + 49, + 407, + 399, + 105, + 361 + ] + } + } + } + }, + { + "new": 413, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 37, + 68, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 1, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 182, + 273, + 189, + 321, + 82, + 260, + 344, + 288, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 236, + 230, + 267, + 493, + 0, + 267, + 11, + 267, + 428 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 37, + 68, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 182, + 273, + 189, + 321, + 82, + 260, + 344, + 288, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 236, + 230, + 267, + 493, + 0, + 267, + 11, + 267, + 428 + ] + } + } + } + }, + { + "new": 414, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 36, + 66, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 34, + 11, + 388, + 97, + 66, + 260, + 104, + 16, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 107, + 105, + 132, + 107, + 0, + 11, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 36, + 66, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 1, + 0, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 34, + 11, + 388, + 97, + 66, + 260, + 104, + 16, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 107, + 105, + 132, + 107, + 0, + 11, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 415, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 11, + 17, + 388, + 65, + 82, + 260, + 88, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 90, + 91, + 132, + 91, + 11, + 0, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 0, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 17, + 388, + 65, + 82, + 260, + 88, + 32, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 90, + 91, + 132, + 91, + 11, + 0, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 416, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 68, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 1, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 290, + 181, + 190, + 97, + 322, + 260, + 360, + 272, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 213, + 220, + 267, + 478, + 267, + 0, + 11, + 267, + 412 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 68, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 290, + 181, + 190, + 97, + 322, + 260, + 360, + 272, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 220, + 267, + 478, + 267, + 0, + 11, + 267, + 412 + ] + } + } + } + }, + { + "new": 417, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 37, + 67, + 6, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 0, + 2, + 1, + 2, + 2, + 3 + ], + "matrix_rows": [ + 253, + 40, + 423, + 257, + 82, + 260, + 280, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 90, + 503, + 90, + 453, + 423, + 50, + 399, + 90, + 346 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 37, + 67, + 6, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 1 + ], + "matrix_rows": [ + 253, + 40, + 423, + 257, + 82, + 260, + 280, + 352, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 90, + 503, + 90, + 453, + 423, + 50, + 399, + 90, + 346 + ] + } + } + } + }, + { + "new": 418, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 69, + 129, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 388, + 105, + 97, + 2, + 260, + 40, + 80, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 9, + 0, + 132, + 81, + 88, + 0, + 24, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 69, + 129, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 388, + 105, + 97, + 2, + 260, + 40, + 80, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 9, + 0, + 132, + 81, + 88, + 0, + 24, + 132, + 0 + ] + } + } + } + }, + { + "new": 424, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 19, + 196, + 33, + 34, + 132, + 8, + 48, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 19, + 196, + 33, + 34, + 132, + 8, + 48, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + } + } + }, + { + "new": 431, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 260, + 162, + 21, + 321, + 130, + 68, + 8, + 336, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 341, + 34, + 337, + 0, + 341, + 34, + 21, + 0, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 0, + 1, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 260, + 162, + 21, + 321, + 130, + 68, + 8, + 336, + 160 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 341, + 34, + 337, + 0, + 341, + 34, + 21, + 0, + 21 + ] + } + } + } + }, + { + "new": 432, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 132, + 290, + 21, + 193, + 258, + 68, + 8, + 208, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 213, + 34, + 209, + 0, + 213, + 34, + 21, + 21, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 0, + 1, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 132, + 290, + 21, + 193, + 258, + 68, + 8, + 208, + 288 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 34, + 209, + 0, + 213, + 34, + 21, + 21, + 0 + ] + } + } + } + }, + { + "new": 433, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 64, + 128, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 422, + 38, + 162, + 1, + 450, + 68, + 8, + 16, + 480 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 226, + 448, + 0, + 0, + 226, + 38, + 422, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 64, + 128, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 422, + 38, + 162, + 1, + 450, + 68, + 8, + 16, + 480 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 226, + 448, + 0, + 0, + 226, + 38, + 422, + 132 + ] + } + } + } + }, + { + "new": 434, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 38, + 145, + 385, + 66, + 68, + 8, + 400, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 273, + 102, + 102, + 0, + 273, + 102, + 38, + 384, + 145 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 38, + 145, + 385, + 66, + 68, + 8, + 400, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 273, + 102, + 102, + 0, + 273, + 102, + 38, + 384, + 145 + ] + } + } + } + }, + { + "new": 435, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 145, + 260, + 38, + 129, + 322, + 68, + 8, + 144, + 352 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 17, + 358, + 354, + 0, + 17, + 358, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 0, + 3, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 145, + 260, + 38, + 129, + 322, + 68, + 8, + 144, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 358, + 354, + 0, + 17, + 358, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 436, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 273, + 132, + 38, + 257, + 194, + 68, + 8, + 272, + 224 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 17, + 230, + 226, + 0, + 17, + 230, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 0, + 3, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 273, + 132, + 38, + 257, + 194, + 68, + 8, + 272, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 230, + 226, + 0, + 17, + 230, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 437, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 35, + 64, + 135, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 405, + 21, + 145, + 449, + 2, + 68, + 8, + 464, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 209, + 0, + 448, + 0, + 209, + 0, + 21, + 405, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 35, + 64, + 135, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 405, + 21, + 145, + 449, + 2, + 68, + 8, + 464, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 209, + 0, + 448, + 0, + 209, + 0, + 21, + 405, + 132 + ] + } + } + } + }, + { + "new": 438, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 64, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 162, + 65, + 386, + 68, + 8, + 80, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 290, + 85, + 0, + 85, + 290, + 21, + 384, + 162 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 64, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 0, + 1, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 162, + 65, + 386, + 68, + 8, + 80, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 290, + 85, + 0, + 85, + 290, + 21, + 384, + 162 + ] + } + } + } + }, + { + "new": 439, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 385, + 14, + 257, + 18, + 20, + 24, + 32, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 129, + 30, + 30, + 30, + 14, + 0, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 14, + 257, + 18, + 20, + 24, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 30, + 30, + 30, + 14, + 0, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 440, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 11, + 17, + 33, + 3, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 34, + 1, + 18, + 52, + 56, + 64, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 0, + 60, + 62, + 62, + 14, + 14, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 11, + 17, + 33, + 3, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 34, + 1, + 18, + 52, + 56, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 60, + 62, + 62, + 14, + 14, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 441, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 487, + 489, + 257, + 274, + 276, + 24, + 288, + 320, + 384 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 270, + 247, + 247, + 505, + 14, + 270, + 270, + 270, + 489 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 487, + 489, + 257, + 274, + 276, + 24, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 270, + 247, + 247, + 505, + 14, + 270, + 270, + 270, + 489 + ] + } + } + } + }, + { + "new": 444, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 68, + 14, + 1, + 82, + 20, + 88, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 94, + 90, + 94, + 14, + 0, + 14, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 68, + 14, + 1, + 82, + 20, + 88, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 94, + 90, + 94, + 14, + 0, + 14, + 0, + 0 + ] + } + } + } + }, + { + "new": 455, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 21, + 35, + 65, + 135, + 4, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 1, + 3, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 415, + 501, + 499, + 257, + 322, + 292, + 360, + 272, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 153, + 300, + 330, + 255, + 153, + 106, + 108, + 153, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 21, + 35, + 65, + 135, + 4, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 1, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 415, + 501, + 499, + 257, + 322, + 292, + 360, + 272, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 153, + 300, + 330, + 255, + 153, + 106, + 108, + 153, + 6 + ] + } + } + } + }, + { + "new": 456, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 134, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 2, + 3, + 3, + 1, + 2 + ], + "matrix_rows": [ + 385, + 114, + 116, + 257, + 34, + 68, + 8, + 112, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 129, + 82, + 52, + 0, + 102, + 116, + 114, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 134, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 385, + 114, + 116, + 257, + 34, + 68, + 8, + 112, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 129, + 82, + 52, + 0, + 102, + 116, + 114, + 129, + 0 + ] + } + } + } + }, + { + "new": 457, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 36, + 70, + 130, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 385, + 24, + 108, + 257, + 2, + 100, + 40, + 80, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 129, + 0, + 12, + 84, + 88, + 0, + 24, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 36, + 70, + 130, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 385, + 24, + 108, + 257, + 2, + 100, + 40, + 80, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 129, + 0, + 12, + 84, + 88, + 0, + 24, + 129, + 0 + ] + } + } + } + }, + { + "new": 458, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 39, + 65, + 133, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 415, + 391, + 501, + 257, + 354, + 260, + 328, + 304, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 237, + 376, + 237, + 223, + 330, + 391, + 415, + 237, + 114 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 39, + 65, + 133, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 415, + 391, + 501, + 257, + 354, + 260, + 328, + 304, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 237, + 376, + 237, + 223, + 330, + 391, + 415, + 237, + 114 + ] + } + } + } + }, + { + "new": 460, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 2, + 0 + ], + "matrix_rows": [ + 193, + 14, + 129, + 18, + 20, + 24, + 32, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 65, + 30, + 30, + 30, + 14, + 0, + 65, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 14, + 129, + 18, + 20, + 24, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 30, + 30, + 30, + 14, + 0, + 65, + 0, + 0 + ] + } + } + } + }, + { + "new": 461, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 132, + 14, + 1, + 146, + 20, + 152, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 158, + 154, + 158, + 14, + 0, + 0, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 132, + 14, + 1, + 146, + 20, + 152, + 32, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 158, + 154, + 158, + 14, + 0, + 0, + 14, + 0 + ] + } + } + } + }, + { + "new": 464, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 260, + 14, + 1, + 274, + 20, + 280, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 286, + 282, + 286, + 14, + 0, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 260, + 14, + 1, + 274, + 20, + 280, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 286, + 282, + 286, + 14, + 0, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 475, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 11, + 129, + 276, + 65, + 194, + 260, + 200, + 272, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 202, + 203, + 20, + 203, + 20, + 0, + 11, + 11, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 11, + 129, + 276, + 65, + 194, + 260, + 200, + 272, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 202, + 203, + 20, + 203, + 20, + 0, + 11, + 11, + 0 + ] + } + } + } + }, + { + "new": 476, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 11, + 257, + 148, + 65, + 322, + 132, + 328, + 144, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 330, + 331, + 20, + 331, + 20, + 0, + 11, + 0, + 11 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 3, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 11, + 257, + 148, + 65, + 322, + 132, + 328, + 144, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 330, + 331, + 20, + 331, + 20, + 0, + 11, + 0, + 11 + ] + } + } + } + }, + { + "new": 477, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 256, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 138, + 65, + 386, + 68, + 392, + 80, + 32 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 266, + 85, + 266, + 85, + 0, + 21, + 384, + 138 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 256, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 3, + 1, + 0, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 138, + 65, + 386, + 68, + 392, + 80, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 266, + 85, + 266, + 85, + 0, + 21, + 384, + 138 + ] + } + } + } + }, + { + "new": 478, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 64, + 135, + 256, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 21, + 405, + 148, + 65, + 2, + 452, + 8, + 464, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 448, + 0, + 212, + 0, + 212, + 0, + 21, + 405, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 64, + 135, + 256, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 21, + 405, + 148, + 65, + 2, + 452, + 8, + 464, + 32 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 448, + 0, + 212, + 0, + 212, + 0, + 21, + 405, + 129 + ] + } + } + } + }, + { + "new": 479, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 72, + 14, + 1, + 82, + 84, + 24, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 0, + 14, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 72, + 14, + 1, + 82, + 84, + 24, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 0, + 14, + 0, + 0 + ] + } + } + } + }, + { + "new": 481, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 1, + 3, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 27, + 25, + 18, + 12, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 1, + 3, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 27, + 25, + 18, + 12, + 32, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 484, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 14, + 416, + 1, + 18, + 20, + 24, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 160, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 14, + 416, + 1, + 18, + 20, + 24, + 288, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 160, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 491, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 64, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 0, + 2, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 83, + 5, + 416, + 17, + 82, + 68, + 8, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 70, + 3, + 69, + 0, + 0, + 160, + 5, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 64, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 83, + 5, + 416, + 17, + 82, + 68, + 8, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 70, + 3, + 69, + 0, + 0, + 160, + 5, + 160, + 0 + ] + } + } + } + }, + { + "new": 492, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 5, + 66, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 419, + 187, + 269, + 329, + 258, + 76, + 336, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 349, + 24, + 325, + 187, + 507, + 24, + 21, + 24, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 5, + 66, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 3, + 1, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 419, + 187, + 269, + 329, + 258, + 76, + 336, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 349, + 24, + 325, + 187, + 507, + 24, + 21, + 24, + 21 + ] + } + } + } + }, + { + "new": 493, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 66, + 3, + 133, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 421, + 280, + 182, + 337, + 82, + 260, + 328, + 288, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 245, + 230, + 19, + 88, + 189, + 19, + 11, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 66, + 3, + 133, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 1, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 421, + 280, + 182, + 337, + 82, + 260, + 328, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 245, + 230, + 19, + 88, + 189, + 19, + 11, + 19, + 0 + ] + } + } + } + }, + { + "new": 494, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 1, + 64, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 3, + 0, + 1, + 3, + 1, + 2 + ], + "matrix_rows": [ + 77, + 78, + 416, + 9, + 66, + 76, + 16, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 69, + 14, + 75, + 78, + 0, + 160, + 77, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 1, + 64, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 0, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 77, + 78, + 416, + 9, + 66, + 76, + 16, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 69, + 14, + 75, + 78, + 0, + 160, + 77, + 160, + 0 + ] + } + } + } + }, + { + "new": 495, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 1, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 11, + 416, + 81, + 82, + 4, + 72, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 91, + 91, + 0, + 83, + 11, + 160, + 11, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 1, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 0, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 11, + 416, + 81, + 82, + 4, + 72, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 91, + 91, + 0, + 83, + 11, + 160, + 11, + 160, + 0 + ] + } + } + } + }, + { + "new": 496, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 67, + 131, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 438, + 437, + 333, + 265, + 322, + 76, + 272, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 496, + 246, + 262, + 0, + 259, + 259, + 3, + 259, + 437 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 67, + 131, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 438, + 437, + 333, + 265, + 322, + 76, + 272, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 496, + 246, + 262, + 0, + 259, + 259, + 3, + 259, + 437 + ] + } + } + } + }, + { + "new": 497, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 3, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 430, + 5, + 253, + 273, + 82, + 324, + 264, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 488, + 510, + 22, + 83, + 430, + 83, + 427, + 83, + 339 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 3, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 430, + 5, + 253, + 273, + 82, + 324, + 264, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 488, + 510, + 22, + 83, + 430, + 83, + 427, + 83, + 339 + ] + } + } + } + }, + { + "new": 498, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 34, + 3, + 65, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 13, + 416, + 73, + 2, + 76, + 80, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 69, + 0, + 69, + 24, + 88, + 160, + 21, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 34, + 3, + 65, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 3, + 1, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 13, + 416, + 73, + 2, + 76, + 80, + 288, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 69, + 0, + 69, + 24, + 88, + 160, + 21, + 160, + 0 + ] + } + } + } + }, + { + "new": 500, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 264, + 14, + 1, + 274, + 276, + 24, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 0, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 264, + 14, + 1, + 274, + 276, + 24, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 0, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 501, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 14, + 352, + 1, + 18, + 20, + 24, + 288, + 320, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 14, + 352, + 1, + 18, + 20, + 24, + 288, + 320, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + } + } + }, + { + "new": 504, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 2, + 0 + ], + "matrix_rows": [ + 14, + 224, + 1, + 18, + 20, + 24, + 160, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 14, + 224, + 1, + 18, + 20, + 24, + 160, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + } + } + }, + { + "new": 511, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 134, + 288, + 56, + 1, + 130, + 132, + 328, + 336, + 96 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 376, + 376, + 344, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 134, + 288, + 56, + 1, + 130, + 132, + 328, + 336, + 96 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 376, + 376, + 344, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 512, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 262, + 160, + 56, + 1, + 258, + 260, + 200, + 208, + 96 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 248, + 248, + 216, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 262, + 160, + 56, + 1, + 258, + 260, + 200, + 208, + 96 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 248, + 248, + 216, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 513, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 64, + 128, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 422, + 38, + 134, + 1, + 450, + 452, + 8, + 16, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 448, + 38, + 422, + 160 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 64, + 128, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 422, + 38, + 134, + 1, + 450, + 452, + 8, + 16, + 96 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 448, + 38, + 422, + 160 + ] + } + } + } + }, + { + "new": 514, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 257, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 38, + 384, + 152, + 1, + 66, + 68, + 392, + 400, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 280, + 280, + 102, + 38, + 384, + 152 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 257, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 38, + 384, + 152, + 1, + 66, + 68, + 392, + 400, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 280, + 280, + 102, + 38, + 384, + 152 + ] + } + } + } + }, + { + "new": 515, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 288, + 152, + 38, + 1, + 322, + 324, + 136, + 144, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 358, + 358, + 24, + 24, + 326, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 288, + 152, + 38, + 1, + 322, + 324, + 136, + 144, + 96 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 358, + 358, + 24, + 24, + 326, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 516, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 160, + 280, + 38, + 1, + 194, + 196, + 264, + 272, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 230, + 230, + 24, + 24, + 198, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 160, + 280, + 38, + 1, + 194, + 196, + 264, + 272, + 96 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 230, + 230, + 24, + 24, + 198, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 517, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 135, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 440, + 56, + 152, + 1, + 2, + 4, + 456, + 464, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 216, + 216, + 448, + 56, + 440, + 160 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 135, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 440, + 56, + 152, + 1, + 2, + 4, + 456, + 464, + 96 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 216, + 216, + 448, + 56, + 440, + 160 + ] + } + } + } + }, + { + "new": 518, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 134, + 1, + 386, + 388, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 262, + 262, + 120, + 120, + 120, + 56, + 384, + 134 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 134, + 1, + 386, + 388, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 262, + 262, + 120, + 120, + 120, + 56, + 384, + 134 + ] + } + } + } + }, + { + "new": 519, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 392, + 33, + 34, + 4, + 264, + 48, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 0, + 136, + 51, + 19, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 392, + 33, + 34, + 4, + 264, + 48, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 136, + 51, + 19, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 520, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 33, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 3, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 19, + 289, + 34, + 260, + 264, + 304, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 307, + 509, + 206, + 206, + 307, + 19, + 206, + 206, + 19 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 33, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 1, + 1, + 2, + 1, + 1, + 0 + ], + "matrix_rows": [ + 462, + 19, + 289, + 34, + 260, + 264, + 304, + 320, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 307, + 509, + 206, + 206, + 307, + 19, + 206, + 206, + 19 + ] + } + } + } + }, + { + "new": 531, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 68, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 1, + 2, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 83, + 5, + 392, + 65, + 82, + 20, + 264, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 22, + 3, + 21, + 136, + 5, + 0, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 68, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 83, + 5, + 392, + 65, + 82, + 20, + 264, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 22, + 3, + 21, + 136, + 5, + 0, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 532, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 34, + 70, + 131, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 304, + 190, + 171, + 97, + 258, + 356, + 264, + 336, + 384 + ], + "offset": 5, + "phase": 3, + "quadratic_rows": [ + 203, + 277, + 478, + 277, + 206, + 0, + 21, + 277, + 398 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 34, + 70, + 131, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 0, + 2, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 304, + 190, + 171, + 97, + 258, + 356, + 264, + 336, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 277, + 478, + 277, + 206, + 0, + 21, + 277, + 398 + ] + } + } + } + }, + { + "new": 533, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 65, + 6, + 131, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 5, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 1, + 2, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 189, + 304, + 278, + 257, + 82, + 340, + 264, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 445, + 326, + 251, + 445, + 397, + 205, + 38, + 445, + 155 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 65, + 6, + 131, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 5, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 1, + 0, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 189, + 304, + 278, + 257, + 82, + 340, + 264, + 352, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 445, + 326, + 251, + 445, + 397, + 205, + 38, + 445, + 155 + ] + } + } + } + }, + { + "new": 534, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 68, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 0, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 99, + 392, + 97, + 66, + 36, + 264, + 16, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 37, + 38, + 136, + 0, + 6, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 68, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 3, + 0, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 99, + 392, + 97, + 66, + 36, + 264, + 16, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 37, + 38, + 136, + 0, + 6, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 535, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 322, + 292, + 264, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 509, + 440, + 69, + 99, + 99, + 411, + 413, + 99, + 355 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 322, + 292, + 264, + 272, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 509, + 440, + 69, + 99, + 99, + 411, + 413, + 99, + 355 + ] + } + } + } + }, + { + "new": 536, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 48, + 392, + 22, + 1, + 82, + 84, + 264, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 136, + 48, + 112, + 38, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 48, + 392, + 22, + 1, + 82, + 84, + 264, + 96, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 136, + 48, + 112, + 38, + 136, + 0 + ] + } + } + } + }, + { + "new": 537, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 48, + 392, + 21, + 97, + 2, + 100, + 264, + 80, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 117, + 0, + 117, + 136, + 101, + 21, + 21, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 48, + 392, + 21, + 97, + 2, + 100, + 264, + 80, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 117, + 0, + 117, + 136, + 101, + 21, + 21, + 136, + 0 + ] + } + } + } + }, + { + "new": 538, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 430, + 5, + 253, + 321, + 82, + 276, + 264, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 440, + 510, + 70, + 83, + 427, + 83, + 430, + 83, + 339 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 430, + 5, + 253, + 321, + 82, + 276, + 264, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 440, + 510, + 70, + 83, + 427, + 83, + 430, + 83, + 339 + ] + } + } + } + }, + { + "new": 551, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 131, + 56, + 264, + 129, + 130, + 4, + 72, + 336, + 352 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 368, + 376, + 376, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 131, + 56, + 264, + 129, + 130, + 4, + 72, + 336, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 368, + 376, + 376, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 552, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 259, + 56, + 136, + 257, + 258, + 4, + 72, + 208, + 224 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 240, + 248, + 248, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 259, + 56, + 136, + 257, + 258, + 4, + 72, + 208, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 240, + 248, + 248, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 553, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 67, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 395, + 11, + 131, + 449, + 450, + 4, + 72, + 16, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 195, + 195, + 0, + 448, + 0, + 0, + 11, + 395, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 67, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 395, + 11, + 131, + 449, + 450, + 4, + 72, + 16, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 195, + 195, + 0, + 448, + 0, + 0, + 11, + 395, + 136 + ] + } + } + } + }, + { + "new": 554, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 65, + 132, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 384, + 176, + 65, + 66, + 4, + 72, + 400, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 304, + 304, + 11, + 384, + 176 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 65, + 132, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 3, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 384, + 176, + 65, + 66, + 4, + 72, + 400, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 304, + 304, + 11, + 384, + 176 + ] + } + } + } + }, + { + "new": 555, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 136, + 11, + 304, + 193, + 194, + 4, + 72, + 272, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 203, + 203, + 0, + 195, + 48, + 48, + 11, + 11, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 136, + 11, + 304, + 193, + 194, + 4, + 72, + 272, + 288 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 203, + 0, + 195, + 48, + 48, + 11, + 11, + 0 + ] + } + } + } + }, + { + "new": 556, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 264, + 11, + 176, + 321, + 322, + 4, + 72, + 144, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 331, + 331, + 0, + 323, + 48, + 48, + 11, + 0, + 11 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 264, + 11, + 176, + 321, + 322, + 4, + 72, + 144, + 160 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 331, + 331, + 0, + 323, + 48, + 48, + 11, + 0, + 11 + ] + } + } + } + }, + { + "new": 557, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 131, + 385, + 386, + 4, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 120, + 120, + 120, + 56, + 384, + 131 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 131, + 385, + 386, + 4, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 120, + 120, + 120, + 56, + 384, + 131 + ] + } + } + } + }, + { + "new": 558, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 67, + 135, + 263, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 56, + 440, + 176, + 1, + 2, + 4, + 72, + 464, + 480 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 448, + 240, + 240, + 56, + 440, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 67, + 135, + 263, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 56, + 440, + 176, + 1, + 2, + 4, + 72, + 464, + 480 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 448, + 240, + 240, + 56, + 440, + 136 + ] + } + } + } + }, + { + "new": 571, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 0, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 384, + 164, + 65, + 66, + 388, + 72, + 16, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 292, + 75, + 0, + 292, + 11, + 384, + 164 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 384, + 164, + 65, + 66, + 388, + 72, + 16, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 292, + 75, + 0, + 292, + 11, + 384, + 164 + ] + } + } + } + }, + { + "new": 572, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 71, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 1, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 395, + 11, + 137, + 449, + 66, + 4, + 456, + 16, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 201, + 448, + 0, + 201, + 0, + 0, + 11, + 395, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 71, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 395, + 11, + 137, + 449, + 66, + 4, + 456, + 16, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 201, + 448, + 0, + 201, + 0, + 0, + 11, + 395, + 130 + ] + } + } + } + }, + { + "new": 573, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 137, + 38, + 258, + 129, + 66, + 324, + 136, + 16, + 352 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 9, + 356, + 358, + 9, + 0, + 358, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 137, + 38, + 258, + 129, + 66, + 324, + 136, + 16, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 356, + 358, + 9, + 0, + 358, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 574, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 265, + 38, + 130, + 257, + 66, + 196, + 264, + 16, + 224 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 9, + 228, + 230, + 9, + 0, + 230, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 265, + 38, + 130, + 257, + 66, + 196, + 264, + 16, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 228, + 230, + 9, + 0, + 230, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 591, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 35, + 65, + 6, + 133, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 431, + 391, + 499, + 257, + 258, + 340, + 280, + 352, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 219, + 219, + 376, + 191, + 431, + 284, + 391, + 219, + 116 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 35, + 65, + 6, + 133, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 431, + 391, + 499, + 257, + 258, + 340, + 280, + 352, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 219, + 219, + 376, + 191, + 431, + 284, + 391, + 219, + 116 + ] + } + } + } + }, + { + "new": 592, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 69, + 129, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 386, + 105, + 97, + 258, + 4, + 72, + 48, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 9, + 130, + 0, + 49, + 56, + 24, + 0, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 69, + 129, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 386, + 105, + 97, + 258, + 4, + 72, + 48, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 9, + 130, + 0, + 49, + 56, + 24, + 0, + 130, + 0 + ] + } + } + } + }, + { + "new": 593, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 35, + 70, + 130, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 1, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 292, + 190, + 171, + 97, + 258, + 324, + 264, + 368, + 384 + ], + "offset": 5, + "phase": 3, + "quadratic_rows": [ + 203, + 277, + 218, + 277, + 478, + 0, + 21, + 277, + 410 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 35, + 70, + 130, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 292, + 190, + 171, + 97, + 258, + 324, + 264, + 368, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 277, + 218, + 277, + 478, + 0, + 21, + 277, + 410 + ] + } + } + } + }, + { + "new": 594, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 69, + 4, + 128, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 1, + 2 + ], + "matrix_rows": [ + 89, + 386, + 92, + 65, + 258, + 20, + 88, + 32, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 25, + 130, + 76, + 85, + 89, + 0, + 92, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 69, + 4, + 128, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 1, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 89, + 386, + 92, + 65, + 258, + 20, + 88, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 25, + 130, + 76, + 85, + 89, + 0, + 92, + 130, + 0 + ] + } + } + } + }, + { + "new": 611, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 68, + 129, + 1, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 140, + 33, + 34, + 388, + 392, + 48, + 64 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 268, + 268, + 51, + 19, + 0, + 384, + 140 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 68, + 129, + 1, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 1, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 140, + 33, + 34, + 388, + 392, + 48, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 268, + 268, + 51, + 19, + 0, + 384, + 140 + ] + } + } + } + }, + { + "new": 612, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 32, + 64, + 135, + 3, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 19, + 403, + 146, + 33, + 418, + 4, + 8, + 432, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 416, + 178, + 0, + 0, + 178, + 19, + 0, + 403, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 32, + 64, + 135, + 3, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 403, + 146, + 33, + 418, + 4, + 8, + 432, + 64 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 416, + 178, + 0, + 0, + 178, + 19, + 0, + 403, + 129 + ] + } + } + } + }, + { + "new": 613, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 132, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 384, + 14, + 161, + 385, + 18, + 20, + 24, + 416, + 64 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 289, + 30, + 30, + 30, + 14, + 289, + 0, + 384, + 161 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 132, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 14, + 161, + 385, + 18, + 20, + 24, + 416, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 289, + 30, + 30, + 30, + 14, + 289, + 0, + 384, + 161 + ] + } + } + } + }, + { + "new": 614, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 3, + 128, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 14, + 398, + 140, + 1, + 18, + 404, + 408, + 32, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 400, + 156, + 156, + 14, + 0, + 0, + 398, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 3, + 128, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 14, + 398, + 140, + 1, + 18, + 404, + 408, + 32, + 64 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 400, + 156, + 156, + 14, + 0, + 0, + 398, + 130 + ] + } + } + } + }, + { + "new": 615, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 2, + 1, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 14, + 258, + 129, + 18, + 276, + 280, + 160, + 64 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 33, + 284, + 286, + 286, + 14, + 33, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 2, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 14, + 258, + 129, + 18, + 276, + 280, + 160, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 284, + 286, + 286, + 14, + 33, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 616, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 2, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 289, + 14, + 130, + 257, + 18, + 148, + 152, + 288, + 64 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 33, + 156, + 158, + 158, + 14, + 33, + 0, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 2, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 289, + 14, + 130, + 257, + 18, + 148, + 152, + 288, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 156, + 158, + 158, + 14, + 33, + 0, + 14, + 0 + ] + } + } + } + }, + { + "new": 618, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 19, + 129, + 268, + 33, + 162, + 260, + 264, + 176, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 178, + 179, + 12, + 12, + 179, + 19, + 0, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 19, + 129, + 268, + 33, + 162, + 260, + 264, + 176, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 178, + 179, + 12, + 12, + 179, + 19, + 0, + 19, + 0 + ] + } + } + } + }, + { + "new": 626, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 6, + 485, + 285, + 25, + 274, + 268, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 224, + 278, + 502, + 0, + 6, + 229, + 229, + 229, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 6, + 485, + 285, + 25, + 274, + 268, + 288, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 224, + 278, + 502, + 0, + 6, + 229, + 229, + 229, + 6 + ] + } + } + } + }, + { + "new": 627, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 72, + 14, + 416, + 1, + 82, + 84, + 24, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 160, + 14, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 72, + 14, + 416, + 1, + 82, + 84, + 24, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 160, + 14, + 160, + 0 + ] + } + } + } + }, + { + "new": 628, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 136, + 14, + 352, + 1, + 146, + 148, + 24, + 288, + 320 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 158, + 158, + 150, + 14, + 96, + 96, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 136, + 14, + 352, + 1, + 146, + 148, + 24, + 288, + 320 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 158, + 158, + 150, + 14, + 96, + 96, + 14, + 0 + ] + } + } + } + }, + { + "new": 629, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 385, + 68, + 14, + 257, + 82, + 20, + 88, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 129, + 94, + 90, + 94, + 14, + 0, + 14, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 1, + 2, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 68, + 14, + 257, + 82, + 20, + 88, + 32, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 94, + 90, + 94, + 14, + 0, + 14, + 129, + 0 + ] + } + } + } + }, + { + "new": 630, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 2, + 1, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 289, + 274, + 52, + 264, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 22, + 37, + 51, + 504, + 461, + 462, + 504, + 504, + 248 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 2, + 1, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 289, + 274, + 52, + 264, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 22, + 37, + 51, + 504, + 461, + 462, + 504, + 504, + 248 + ] + } + } + } + }, + { + "new": 631, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 80, + 392, + 19, + 97, + 98, + 4, + 264, + 48, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 115, + 115, + 0, + 136, + 99, + 19, + 19, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 2, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 80, + 392, + 19, + 97, + 98, + 4, + 264, + 48, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 115, + 115, + 0, + 136, + 99, + 19, + 19, + 136, + 0 + ] + } + } + } + }, + { + "new": 634, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 257, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 2, + 0, + 1, + 2, + 0 + ], + "matrix_rows": [ + 193, + 260, + 14, + 129, + 274, + 20, + 280, + 32, + 192 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 65, + 286, + 282, + 286, + 14, + 0, + 65, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 257, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 1, + 2, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 260, + 14, + 129, + 274, + 20, + 280, + 32, + 192 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 286, + 282, + 286, + 14, + 0, + 65, + 0, + 14 + ] + } + } + } + }, + { + "new": 674, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 1, + 2, + 0 + ], + "matrix_rows": [ + 264, + 14, + 224, + 1, + 274, + 276, + 24, + 160, + 192 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 96, + 96, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 264, + 14, + 224, + 1, + 274, + 276, + 24, + 160, + 192 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 96, + 96, + 0, + 14 + ] + } + } + } + }, + { + "new": 760, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 67, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 2, + 3, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 57, + 58, + 388, + 33, + 18, + 260, + 56, + 64, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 25, + 42, + 132, + 51, + 57, + 58, + 0, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 67, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 1, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 57, + 58, + 388, + 33, + 18, + 260, + 56, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 25, + 42, + 132, + 51, + 57, + 58, + 0, + 132, + 0 + ] + } + } + } + }, + { + "new": 773, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 64, + 135, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 403, + 19, + 145, + 417, + 34, + 4, + 8, + 432, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 177, + 416, + 0, + 0, + 177, + 19, + 0, + 403, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 64, + 135, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 403, + 19, + 145, + 417, + 34, + 4, + 8, + 432, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 177, + 416, + 0, + 0, + 177, + 19, + 0, + 403, + 130 + ] + } + } + } + }, + { + "new": 774, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 64, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 196, + 33, + 34, + 388, + 8, + 48, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 324, + 0, + 51, + 19, + 324, + 384, + 196 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 64, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 196, + 33, + 34, + 388, + 8, + 48, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 324, + 0, + 51, + 19, + 324, + 384, + 196 + ] + } + } + } + }, + { + "new": 788, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 35, + 65, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 1, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 237, + 324, + 227, + 257, + 82, + 276, + 344, + 288, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 270, + 179, + 185, + 445, + 14, + 270, + 0, + 270, + 425 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 35, + 65, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 237, + 324, + 227, + 257, + 82, + 276, + 344, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 270, + 179, + 185, + 445, + 14, + 270, + 0, + 270, + 425 + ] + } + } + } + }, + { + "new": 792, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 128, + 260, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 384, + 14, + 193, + 385, + 18, + 20, + 24, + 32, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 321, + 30, + 30, + 30, + 14, + 0, + 321, + 384, + 193 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 128, + 260, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 14, + 193, + 385, + 18, + 20, + 24, + 32, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 321, + 30, + 30, + 30, + 14, + 0, + 321, + 384, + 193 + ] + } + } + } + }, + { + "new": 793, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 71, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 398, + 14, + 138, + 1, + 402, + 20, + 408, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 154, + 400, + 154, + 14, + 0, + 0, + 398, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 71, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 398, + 14, + 138, + 1, + 402, + 20, + 408, + 32, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 154, + 400, + 154, + 14, + 0, + 0, + 398, + 132 + ] + } + } + } + }, + { + "new": 797, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 67, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 0, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 237, + 328, + 227, + 257, + 82, + 340, + 280, + 288, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 270, + 179, + 445, + 181, + 14, + 270, + 0, + 270, + 421 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 67, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 2, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 237, + 328, + 227, + 257, + 82, + 340, + 280, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 270, + 179, + 445, + 181, + 14, + 270, + 0, + 270, + 421 + ] + } + } + } + }, + { + "new": 798, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 1, + 3, + 68, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 6, + 27, + 416, + 25, + 18, + 12, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 160, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 1, + 3, + 68, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 6, + 27, + 416, + 25, + 18, + 12, + 288, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 160, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 809, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 67, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 398, + 14, + 134, + 1, + 402, + 404, + 24, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 150, + 150, + 400, + 14, + 0, + 0, + 398, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 67, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 398, + 14, + 134, + 1, + 402, + 404, + 24, + 32, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 150, + 150, + 400, + 14, + 0, + 0, + 398, + 136 + ] + } + } + } + }, + { + "new": 810, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 65, + 1, + 132, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 14, + 384, + 224, + 1, + 18, + 20, + 24, + 416, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 352, + 352, + 384, + 224 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 65, + 1, + 132, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 14, + 384, + 224, + 1, + 18, + 20, + 24, + 416, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 352, + 352, + 384, + 224 + ] + } + } + } + }, + { + "new": 822, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 70, + 129, + 7, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 336, + 398, + 205, + 97, + 354, + 260, + 264, + 304, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 173, + 238, + 67, + 67, + 112, + 19, + 222, + 67, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 70, + 129, + 7, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 0, + 1, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 336, + 398, + 205, + 97, + 354, + 260, + 264, + 304, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 173, + 238, + 67, + 67, + 112, + 19, + 222, + 67, + 0 + ] + } + } + } + }, + { + "new": 825, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 68, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 200, + 33, + 34, + 4, + 392, + 48, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 328, + 51, + 19, + 328, + 384, + 200 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 68, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 200, + 33, + 34, + 4, + 392, + 48, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 328, + 51, + 19, + 328, + 384, + 200 + ] + } + } + } + }, + { + "new": 826, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 64, + 131, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 403, + 19, + 131, + 417, + 418, + 4, + 8, + 48, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 163, + 163, + 0, + 0, + 416, + 19, + 0, + 403, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 64, + 131, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 403, + 19, + 131, + 417, + 418, + 4, + 8, + 48, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 163, + 163, + 0, + 0, + 416, + 19, + 0, + 403, + 144 + ] + } + } + } + }, + { + "new": 1, + "old": 114, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 2, + 4, + 8, + 16, + 19, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 34, + 4, + 8, + 48, + 64, + 128, + 256, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 32, + 32, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 2, + 4, + 8, + 16, + 19, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 34, + 4, + 8, + 48, + 64, + 128, + 256, + 32 + ], + "offset": 236, + "phase": 1, + "quadratic_rows": [ + 32, + 32, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 285, + "old": 114, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 821, + "old": 114, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 1, + 1, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 3, + 392, + 33, + 50, + 20, + 264, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 35, + 51, + 16, + 136, + 22, + 3, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 3, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 3, + 392, + 33, + 50, + 20, + 264, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 35, + 51, + 16, + 136, + 22, + 3, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 139, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 129, + 2, + 260, + 8, + 16, + 13, + 12, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 13, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 2, + 0, + 1, + 2, + 2 + ], + "matrix_rows": [ + 65, + 2, + 36, + 104, + 16, + 128, + 256, + 96, + 64 + ], + "offset": 393, + "phase": 1, + "quadratic_rows": [ + 32, + 0, + 96, + 96, + 0, + 13, + 76, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 129, + 2, + 260, + 8, + 16, + 13, + 12, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 13, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 1, + 2, + 2 + ], + "matrix_rows": [ + 65, + 2, + 36, + 104, + 16, + 128, + 256, + 96, + 64 + ], + "offset": 503, + "phase": 0, + "quadratic_rows": [ + 32, + 0, + 96, + 96, + 0, + 13, + 76, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 140, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 129, + 258, + 4, + 8, + 14, + 16, + 32, + 64, + 93 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 93, + 14, + 83, + 83, + 93, + 0, + 93, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 276, + 280, + 288, + 64, + 384, + 256, + 16 + ], + "offset": 141, + "phase": 1, + "quadratic_rows": [ + 256, + 16, + 272, + 272, + 14, + 256, + 0, + 256, + 173 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 129, + 258, + 4, + 8, + 14, + 16, + 32, + 64, + 93 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 93, + 14, + 83, + 83, + 93, + 0, + 93, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 2, + 276, + 280, + 288, + 64, + 384, + 256, + 16 + ], + "offset": 161, + "phase": 1, + "quadratic_rows": [ + 256, + 16, + 272, + 272, + 14, + 256, + 0, + 256, + 173 + ] + } + } + } + }, + { + "new": 1, + "old": 141, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 33, + 66, + 4, + 136, + 16, + 19, + 21, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 19, + 21, + 0, + 6, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 33, + 66, + 68, + 264, + 112, + 64, + 96, + 256, + 384 + ], + "offset": 145, + "phase": 2, + "quadratic_rows": [ + 96, + 32, + 64, + 0, + 96, + 19, + 21, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 33, + 66, + 4, + 136, + 16, + 19, + 21, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 19, + 21, + 0, + 6, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 33, + 66, + 68, + 264, + 112, + 64, + 96, + 256, + 384 + ], + "offset": 136, + "phase": 0, + "quadratic_rows": [ + 96, + 32, + 64, + 0, + 96, + 19, + 21, + 0, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 292, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 3, + 37, + 73, + 129, + 12, + 4, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 3, + 2, + 2, + 0, + 3 + ], + "matrix_rows": [ + 382, + 285, + 123, + 264, + 287, + 256, + 288, + 320, + 384 + ], + "offset": 200, + "phase": 3, + "quadratic_rows": [ + 120, + 24, + 120, + 295, + 87, + 13, + 21, + 0, + 264 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 3, + 37, + 73, + 129, + 12, + 4, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 3, + 2, + 2, + 0, + 3 + ], + "matrix_rows": [ + 382, + 285, + 123, + 264, + 287, + 256, + 288, + 320, + 384 + ], + "offset": 200, + "phase": 3, + "quadratic_rows": [ + 120, + 24, + 120, + 295, + 87, + 13, + 21, + 0, + 264 + ] + } + } + } + }, + { + "new": 621, + "old": 292, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 37, + 4, + 72, + 130, + 13, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 115, + 272, + 374, + 264, + 256, + 274, + 288, + 320, + 384 + ], + "offset": 254, + "phase": 3, + "quadratic_rows": [ + 370, + 21, + 370, + 32, + 87, + 13, + 21, + 0, + 261 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 37, + 4, + 72, + 130, + 13, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 115, + 272, + 374, + 264, + 256, + 274, + 288, + 320, + 384 + ], + "offset": 254, + "phase": 3, + "quadratic_rows": [ + 370, + 21, + 370, + 32, + 87, + 13, + 21, + 0, + 261 + ] + } + } + } + }, + { + "new": 621, + "old": 303, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 66, + 132, + 262, + 6, + 4, + 8, + 9 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 9, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 0, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 1, + 6, + 8, + 384, + 256, + 98, + 96, + 64, + 48 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 256, + 102, + 98, + 64, + 0, + 6, + 14, + 256, + 385 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 66, + 132, + 262, + 6, + 4, + 8, + 9 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 9, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 2, + 0, + 2, + 2, + 0, + 1 + ], + "matrix_rows": [ + 1, + 6, + 8, + 384, + 256, + 98, + 96, + 64, + 48 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 256, + 102, + 98, + 64, + 0, + 6, + 14, + 256, + 385 + ] + } + } + } + }, + { + "new": 280, + "old": 304, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 27, + 35, + 69, + 9, + 15, + 1, + 138, + 266, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 11, + 15, + 14, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 317, + 260, + 55, + 303, + 256, + 272, + 320, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 293, + 26, + 53, + 26, + 14, + 5, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 27, + 35, + 69, + 9, + 15, + 1, + 138, + 266, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 11, + 15, + 14, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 317, + 260, + 55, + 303, + 256, + 272, + 320, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 293, + 26, + 53, + 26, + 14, + 5, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 732, + "old": 360, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 67, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 272, + 338, + 1, + 322, + 4, + 8, + 80, + 32, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 67, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 272, + 338, + 1, + 322, + 4, + 8, + 80, + 32, + 128 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 738, + "old": 360, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 1, + 34, + 66, + 136, + 2, + 12, + 256, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 320, + 272, + 33, + 44, + 32, + 336, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 37, + 0, + 45, + 4, + 80, + 5, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 1, + 34, + 66, + 136, + 2, + 12, + 256, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 320, + 272, + 33, + 44, + 32, + 336, + 128 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 37, + 0, + 45, + 4, + 80, + 5, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new": 901, + "old": 371, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 32, + 64, + 132, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 2, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 257, + 96, + 18, + 256, + 98, + 4, + 56, + 64, + 384 + ], + "offset": 197, + "phase": 1, + "quadratic_rows": [ + 0, + 114, + 0, + 48, + 122, + 26, + 18, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 32, + 64, + 132, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 3, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 96, + 18, + 256, + 98, + 4, + 56, + 64, + 384 + ], + "offset": 192, + "phase": 2, + "quadratic_rows": [ + 0, + 114, + 0, + 48, + 122, + 26, + 18, + 0, + 0 + ] + } + } + } + }, + { + "new": 917, + "old": 371, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 98, + 1, + 114, + 256, + 56, + 64, + 384 + ], + "offset": 211, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 48, + 106, + 120, + 112, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 98, + 1, + 114, + 256, + 56, + 64, + 384 + ], + "offset": 213, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 0, + 48, + 106, + 120, + 112, + 0, + 0 + ] + } + } + } + }, + { + "new": 902, + "old": 372, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 23, + 6, + 32, + 65, + 130, + 3, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 1, + 3, + 1, + 0, + 2 + ], + "matrix_rows": [ + 118, + 275, + 354, + 273, + 358, + 56, + 320, + 256, + 384 + ], + "offset": 221, + "phase": 3, + "quadratic_rows": [ + 3, + 355, + 276, + 48, + 284, + 362, + 354, + 0, + 118 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 23, + 6, + 32, + 65, + 130, + 3, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 3, + 3, + 1, + 0, + 0 + ], + "matrix_rows": [ + 118, + 275, + 354, + 273, + 358, + 56, + 320, + 256, + 384 + ], + "offset": 222, + "phase": 2, + "quadratic_rows": [ + 3, + 355, + 276, + 48, + 284, + 362, + 354, + 0, + 118 + ] + } + } + } + }, + { + "new": 918, + "old": 372, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 69, + 129, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 1, + 3, + 0, + 1 + ], + "matrix_rows": [ + 277, + 113, + 355, + 115, + 276, + 56, + 320, + 256, + 384 + ], + "offset": 208, + "phase": 0, + "quadratic_rows": [ + 117, + 274, + 5, + 48, + 363, + 121, + 113, + 0, + 274 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 69, + 129, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 2, + 1, + 3, + 0, + 3 + ], + "matrix_rows": [ + 277, + 113, + 355, + 115, + 276, + 56, + 320, + 256, + 384 + ], + "offset": 213, + "phase": 3, + "quadratic_rows": [ + 117, + 274, + 5, + 48, + 363, + 121, + 113, + 0, + 274 + ] + } + } + } + }, + { + "new": 909, + "old": 373, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 5, + 160, + 170, + 81, + 162, + 68, + 128, + 64, + 256 + ], + "offset": 65, + "phase": 3, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 136, + 5, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 5, + 160, + 170, + 81, + 162, + 68, + 128, + 64, + 256 + ], + "offset": 69, + "phase": 1, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 136, + 5, + 160, + 0 + ] + } + } + } + }, + { + "new": 925, + "old": 373, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 8, + 5, + 170, + 65, + 10, + 84, + 128, + 64, + 256 + ], + "offset": 83, + "phase": 1, + "quadratic_rows": [ + 69, + 162, + 85, + 32, + 4, + 138, + 5, + 162, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 8, + 5, + 170, + 65, + 10, + 84, + 128, + 64, + 256 + ], + "offset": 87, + "phase": 1, + "quadratic_rows": [ + 69, + 162, + 85, + 32, + 4, + 138, + 5, + 162, + 0 + ] + } + } + } + }, + { + "new": 910, + "old": 374, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 5, + 288, + 298, + 81, + 290, + 68, + 256, + 64, + 128 + ], + "offset": 65, + "phase": 3, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 264, + 5, + 0, + 288 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 5, + 288, + 298, + 81, + 290, + 68, + 256, + 64, + 128 + ], + "offset": 69, + "phase": 1, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 264, + 5, + 0, + 288 + ] + } + } + } + }, + { + "new": 926, + "old": 374, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 8, + 5, + 298, + 65, + 10, + 84, + 256, + 64, + 128 + ], + "offset": 83, + "phase": 1, + "quadratic_rows": [ + 69, + 290, + 85, + 32, + 4, + 266, + 5, + 0, + 290 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 8, + 5, + 298, + 65, + 10, + 84, + 256, + 64, + 128 + ], + "offset": 87, + "phase": 1, + "quadratic_rows": [ + 69, + 290, + 85, + 32, + 4, + 266, + 5, + 0, + 290 + ] + } + } + } + }, + { + "new": 933, + "old": 375, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 35, + 68, + 1, + 128, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 82, + 4, + 264, + 21, + 6, + 64, + 256, + 32, + 384 + ], + "offset": 62, + "phase": 0, + "quadratic_rows": [ + 20, + 86, + 83, + 0, + 87, + 0, + 86, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 35, + 68, + 1, + 128, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 82, + 4, + 264, + 21, + 6, + 64, + 256, + 32, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 20, + 86, + 83, + 0, + 87, + 0, + 86, + 0, + 0 + ] + } + } + } + }, + { + "new": 949, + "old": 375, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 35, + 64, + 1, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 84, + 82, + 288, + 21, + 86, + 64, + 8, + 256, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 20, + 6, + 83, + 0, + 85, + 0, + 84, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 35, + 64, + 1, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 84, + 82, + 288, + 21, + 86, + 64, + 8, + 256, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 20, + 6, + 83, + 0, + 85, + 0, + 84, + 0, + 0 + ] + } + } + } + }, + { + "new": 934, + "old": 376, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 129, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 3, + 1, + 0, + 0, + 3 + ], + "matrix_rows": [ + 42, + 282, + 92, + 21, + 358, + 256, + 280, + 320, + 384 + ], + "offset": 240, + "phase": 1, + "quadratic_rows": [ + 20, + 84, + 43, + 124, + 283, + 364, + 42, + 0, + 304 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 129, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 42, + 282, + 92, + 21, + 358, + 256, + 280, + 320, + 384 + ], + "offset": 246, + "phase": 2, + "quadratic_rows": [ + 20, + 84, + 43, + 124, + 283, + 364, + 42, + 0, + 304 + ] + } + } + } + }, + { + "new": 950, + "old": 376, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 17, + 39, + 2, + 68, + 3, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 44, + 17, + 293, + 46, + 256, + 304, + 320, + 384 + ], + "offset": 235, + "phase": 3, + "quadratic_rows": [ + 309, + 38, + 35, + 0, + 305, + 55, + 0, + 0, + 17 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 17, + 39, + 2, + 68, + 3, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 44, + 17, + 293, + 46, + 256, + 304, + 320, + 384 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 309, + 38, + 35, + 0, + 305, + 55, + 0, + 0, + 17 + ] + } + } + } + }, + { + "new": 941, + "old": 377, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 135, + 132, + 40, + 128, + 134, + 88, + 64, + 96, + 256 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 6, + 3, + 129, + 120, + 8, + 104, + 40, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 135, + 132, + 40, + 128, + 134, + 88, + 64, + 96, + 256 + ], + "offset": 13, + "phase": 1, + "quadratic_rows": [ + 6, + 3, + 129, + 120, + 8, + 104, + 40, + 132, + 0 + ] + } + } + } + }, + { + "new": 957, + "old": 377, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 135, + 288, + 131, + 128, + 8, + 48, + 256, + 320 + ], + "offset": 482, + "phase": 2, + "quadratic_rows": [ + 132, + 6, + 3, + 0, + 32, + 48, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 135, + 288, + 131, + 128, + 8, + 48, + 256, + 320 + ], + "offset": 484, + "phase": 1, + "quadratic_rows": [ + 132, + 6, + 3, + 0, + 32, + 48, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 942, + "old": 378, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 263, + 260, + 40, + 256, + 262, + 88, + 64, + 96, + 128 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 6, + 3, + 257, + 120, + 8, + 104, + 40, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 263, + 260, + 40, + 256, + 262, + 88, + 64, + 96, + 128 + ], + "offset": 13, + "phase": 1, + "quadratic_rows": [ + 6, + 3, + 257, + 120, + 8, + 104, + 40, + 0, + 260 + ] + } + } + } + }, + { + "new": 958, + "old": 378, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 2, + 3, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 263, + 160, + 259, + 256, + 8, + 48, + 128, + 192 + ], + "offset": 482, + "phase": 2, + "quadratic_rows": [ + 260, + 6, + 3, + 0, + 32, + 48, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 2, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 263, + 160, + 259, + 256, + 8, + 48, + 128, + 192 + ], + "offset": 484, + "phase": 1, + "quadratic_rows": [ + 260, + 6, + 3, + 0, + 32, + 48, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 903, + "old": 391, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 131, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 19, + 179, + 288, + 273, + 274, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 131, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 19, + 179, + 288, + 273, + 274, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + } + } + }, + { + "new": 927, + "old": 391, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 132, + "phase": 3, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 131, + "phase": 1, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + } + } + }, + { + "new": 904, + "old": 392, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 3, + 384, + 404, + 73, + 66, + 388, + 64, + 256, + 32 + ], + "offset": 129, + "phase": 3, + "quadratic_rows": [ + 75, + 67, + 20, + 1, + 132, + 0, + 3, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 3, + 384, + 404, + 73, + 66, + 388, + 64, + 256, + 32 + ], + "offset": 133, + "phase": 1, + "quadratic_rows": [ + 75, + 67, + 20, + 1, + 132, + 0, + 3, + 272, + 384 + ] + } + } + } + }, + { + "new": 928, + "old": 392, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 132, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 106, + 66, + 400, + 11, + 32, + 20, + 96, + 256, + 384 + ], + "offset": 238, + "phase": 3, + "quadratic_rows": [ + 10, + 1, + 16, + 9, + 148, + 0, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 132, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 106, + 66, + 400, + 11, + 32, + 20, + 96, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 10, + 1, + 16, + 9, + 148, + 0, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 911, + "old": 393, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 39, + 66, + 4, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 398, + 150, + 64, + 322, + 324, + 256, + 96, + 384 + ], + "offset": 68, + "phase": 3, + "quadratic_rows": [ + 6, + 31, + 31, + 134, + 134, + 0, + 0, + 24, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 39, + 66, + 4, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 398, + 150, + 64, + 322, + 324, + 256, + 96, + 384 + ], + "offset": 67, + "phase": 1, + "quadratic_rows": [ + 6, + 31, + 31, + 134, + 134, + 0, + 0, + 24, + 0 + ] + } + } + } + }, + { + "new": 919, + "old": 393, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 69, + 3, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 3 + ], + "matrix_rows": [ + 158, + 278, + 8, + 153, + 18, + 20, + 256, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 152, + 408, + 408, + 263, + 263, + 0, + 0, + 135, + 286 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 69, + 3, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 3 + ], + "matrix_rows": [ + 158, + 278, + 8, + 153, + 18, + 20, + 256, + 32, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 152, + 408, + 408, + 263, + 263, + 0, + 0, + 135, + 286 + ] + } + } + } + }, + { + "new": 912, + "old": 394, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 38, + 70, + 129, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 1, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 400, + 36, + 68, + 17, + 38, + 64, + 72, + 256, + 384 + ], + "offset": 255, + "phase": 1, + "quadratic_rows": [ + 16, + 36, + 2, + 0, + 145, + 34, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 38, + 70, + 129, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 400, + 36, + 68, + 17, + 38, + 64, + 72, + 256, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 16, + 36, + 2, + 0, + 145, + 34, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 920, + "old": 394, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 384, + 6, + 401, + 385, + 66, + 100, + 8, + 256, + 64 + ], + "offset": 130, + "phase": 3, + "quadratic_rows": [ + 17, + 70, + 102, + 0, + 129, + 4, + 6, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 6, + 401, + 385, + 66, + 100, + 8, + 256, + 64 + ], + "offset": 134, + "phase": 1, + "quadratic_rows": [ + 17, + 70, + 102, + 0, + 129, + 4, + 6, + 272, + 384 + ] + } + } + } + }, + { + "new": 943, + "old": 395, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 34, + 66, + 4, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 423, + 98, + 182, + 256, + 326, + 64, + 72, + 352, + 384 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 166, + 55, + 19, + 0, + 166, + 51, + 0, + 17, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 34, + 66, + 4, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 0, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 423, + 98, + 182, + 256, + 326, + 64, + 72, + 352, + 384 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 166, + 55, + 19, + 0, + 166, + 51, + 0, + 17, + 0 + ] + } + } + } + }, + { + "new": 951, + "old": 395, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 39, + 71, + 135, + 259, + 4, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 1, + 2, + 1, + 1 + ], + "matrix_rows": [ + 212, + 340, + 308, + 165, + 38, + 320, + 328, + 368, + 256 + ], + "offset": 423, + "phase": 3, + "quadratic_rows": [ + 164, + 36, + 371, + 0, + 468, + 487, + 180, + 241, + 308 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 39, + 71, + 135, + 259, + 4, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 3, + 1, + 2, + 3, + 1 + ], + "matrix_rows": [ + 212, + 340, + 308, + 165, + 38, + 320, + 328, + 368, + 256 + ], + "offset": 420, + "phase": 2, + "quadratic_rows": [ + 164, + 36, + 371, + 0, + 468, + 487, + 180, + 241, + 308 + ] + } + } + } + }, + { + "new": 944, + "old": 396, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 1, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 65, + 36, + 400, + 32, + 6, + 96, + 24, + 256, + 384 + ], + "offset": 247, + "phase": 0, + "quadratic_rows": [ + 96, + 4, + 70, + 16, + 152, + 65, + 101, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 3, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 65, + 36, + 400, + 32, + 6, + 96, + 24, + 256, + 384 + ], + "offset": 242, + "phase": 1, + "quadratic_rows": [ + 96, + 4, + 70, + 16, + 152, + 65, + 101, + 144, + 0 + ] + } + } + } + }, + { + "new": 952, + "old": 396, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 65, + 384, + 408, + 69, + 6, + 64, + 392, + 256, + 32 + ], + "offset": 184, + "phase": 3, + "quadratic_rows": [ + 5, + 4, + 7, + 24, + 136, + 0, + 0, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 65, + 384, + 408, + 69, + 6, + 64, + 392, + 256, + 32 + ], + "offset": 189, + "phase": 0, + "quadratic_rows": [ + 5, + 4, + 7, + 24, + 136, + 0, + 0, + 272, + 384 + ] + } + } + } + }, + { + "new": 935, + "old": 397, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 39, + 65, + 1, + 128, + 256, + 3, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 1, + 3, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 10, + 388, + 4, + 149, + 134, + 256, + 24, + 32, + 64 + ], + "offset": 62, + "phase": 0, + "quadratic_rows": [ + 148, + 142, + 151, + 26, + 157, + 0, + 0, + 279, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 39, + 65, + 1, + 128, + 256, + 3, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 1, + 1, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 10, + 388, + 4, + 149, + 134, + 256, + 24, + 32, + 64 + ], + "offset": 62, + "phase": 1, + "quadratic_rows": [ + 148, + 142, + 151, + 26, + 157, + 0, + 0, + 279, + 384 + ] + } + } + } + }, + { + "new": 959, + "old": 397, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 34, + 70, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 194, + 463, + 155, + 323, + 64, + 320, + 328, + 96, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 22, + 151, + 139, + 20, + 139, + 0, + 0, + 150, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 34, + 70, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 194, + 463, + 155, + 323, + 64, + 320, + 328, + 96, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 22, + 151, + 139, + 20, + 139, + 0, + 0, + 150, + 0 + ] + } + } + } + }, + { + "new": 936, + "old": 398, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 130, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 1, + 2, + 0, + 3 + ], + "matrix_rows": [ + 68, + 432, + 384, + 5, + 6, + 64, + 72, + 256, + 416 + ], + "offset": 185, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 160, + 48, + 0, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 130, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 3, + 2, + 2, + 3 + ], + "matrix_rows": [ + 68, + 432, + 384, + 5, + 6, + 64, + 72, + 256, + 416 + ], + "offset": 186, + "phase": 3, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 160, + 48, + 0, + 272, + 384 + ] + } + } + } + }, + { + "new": 960, + "old": 398, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 3, + 68, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 3, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 12, + 16, + 3, + 72, + 64, + 48, + 128, + 256 + ], + "offset": 27, + "phase": 1, + "quadratic_rows": [ + 2, + 11, + 72, + 78, + 48, + 16, + 12, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 3, + 68, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 1, + 1, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 66, + 12, + 16, + 3, + 72, + 64, + 48, + 128, + 256 + ], + "offset": 25, + "phase": 3, + "quadratic_rows": [ + 2, + 11, + 72, + 78, + 48, + 16, + 12, + 0, + 0 + ] + } + } + } + }, + { + "new": 885, + "old": 411, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 0, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 388, + 66, + 96, + 5, + 64, + 256, + 40, + 80, + 384 + ], + "offset": 251, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 133, + 32, + 0, + 104, + 96, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 0, + 1, + 3, + 1, + 2 + ], + "matrix_rows": [ + 388, + 66, + 96, + 5, + 64, + 256, + 40, + 80, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 4, + 0, + 133, + 32, + 0, + 104, + 96, + 132, + 0 + ] + } + } + } + }, + { + "new": 917, + "old": 411, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 36, + 64, + 128, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 0, + 3, + 2, + 0, + 3 + ], + "matrix_rows": [ + 384, + 66, + 389, + 385, + 98, + 256, + 40, + 16, + 64 + ], + "offset": 368, + "phase": 3, + "quadratic_rows": [ + 5, + 34, + 129, + 32, + 0, + 42, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 36, + 64, + 128, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 2, + 0, + 1, + 2, + 2, + 3 + ], + "matrix_rows": [ + 384, + 66, + 389, + 385, + 98, + 256, + 40, + 16, + 64 + ], + "offset": 374, + "phase": 0, + "quadratic_rows": [ + 5, + 34, + 129, + 32, + 0, + 42, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 886, + "old": 412, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 71, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 89, + 410, + 156, + 64, + 256, + 328, + 336, + 96, + 384 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 24, + 152, + 152, + 31, + 31, + 0, + 0, + 6, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 71, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 89, + 410, + 156, + 64, + 256, + 328, + 336, + 96, + 384 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 24, + 152, + 152, + 31, + 31, + 0, + 0, + 6, + 0 + ] + } + } + } + }, + { + "new": 918, + "old": 412, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 64, + 133, + 256, + 5, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 3, + 1 + ], + "matrix_rows": [ + 210, + 66, + 272, + 147, + 320, + 20, + 24, + 64, + 32 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 146, + 321, + 16, + 16, + 269, + 0, + 450, + 193, + 338 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 64, + 133, + 256, + 5, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 1, + 1, + 3 + ], + "matrix_rows": [ + 210, + 66, + 272, + 147, + 320, + 20, + 24, + 64, + 32 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 146, + 321, + 16, + 16, + 269, + 0, + 450, + 193, + 338 + ] + } + } + } + }, + { + "new": 893, + "old": 413, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 67, + 128, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 3, + 0, + 2, + 1 + ], + "matrix_rows": [ + 169, + 9, + 288, + 261, + 166, + 256, + 424, + 16, + 64 + ], + "offset": 57, + "phase": 3, + "quadratic_rows": [ + 420, + 164, + 167, + 256, + 0, + 167, + 0, + 295, + 393 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 67, + 128, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 0, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 169, + 9, + 288, + 261, + 166, + 256, + 424, + 16, + 64 + ], + "offset": 57, + "phase": 0, + "quadratic_rows": [ + 420, + 164, + 167, + 256, + 0, + 167, + 0, + 295, + 393 + ] + } + } + } + }, + { + "new": 927, + "old": 413, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 129, + 4, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 200, + 463, + 171, + 321, + 330, + 320, + 64, + 80, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 36, + 44, + 139, + 174, + 0, + 139, + 0, + 172, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 129, + 4, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 200, + 463, + 171, + 321, + 330, + 320, + 64, + 80, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 36, + 44, + 139, + 174, + 0, + 139, + 0, + 172, + 0 + ] + } + } + } + }, + { + "new": 894, + "old": 414, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 65, + 130, + 256, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 9, + 404, + 384, + 67, + 64, + 256, + 72, + 400, + 32 + ], + "offset": 33, + "phase": 3, + "quadratic_rows": [ + 75, + 1, + 144, + 73, + 20, + 0, + 9, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 65, + 130, + 256, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 3, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 9, + 404, + 384, + 67, + 64, + 256, + 72, + 400, + 32 + ], + "offset": 35, + "phase": 1, + "quadratic_rows": [ + 75, + 1, + 144, + 73, + 20, + 0, + 9, + 260, + 384 + ] + } + } + } + }, + { + "new": 928, + "old": 414, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 65, + 4, + 1, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 1, + 2, + 1, + 1, + 0, + 0 + ], + "matrix_rows": [ + 106, + 34, + 4, + 11, + 96, + 20, + 32, + 128, + 256 + ], + "offset": 26, + "phase": 0, + "quadratic_rows": [ + 10, + 33, + 20, + 73, + 4, + 34, + 72, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 65, + 4, + 1, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 3, + 2, + 1, + 3, + 0, + 0 + ], + "matrix_rows": [ + 106, + 34, + 4, + 11, + 96, + 20, + 32, + 128, + 256 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 10, + 33, + 20, + 73, + 4, + 34, + 72, + 0, + 0 + ] + } + } + } + }, + { + "new": 937, + "old": 415, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 64, + 129, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 0, + 1, + 2, + 0, + 3 + ], + "matrix_rows": [ + 66, + 420, + 384, + 3, + 64, + 256, + 8, + 80, + 416 + ], + "offset": 233, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 160, + 0, + 0, + 36, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 64, + 129, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 0, + 3, + 2, + 2, + 3 + ], + "matrix_rows": [ + 66, + 420, + 384, + 3, + 64, + 256, + 8, + 80, + 416 + ], + "offset": 234, + "phase": 3, + "quadratic_rows": [ + 2, + 3, + 160, + 0, + 0, + 36, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 965, + "old": 415, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 1, + 66, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 0, + 2, + 1, + 0, + 0 + ], + "matrix_rows": [ + 74, + 66, + 4, + 11, + 64, + 36, + 80, + 128, + 256 + ], + "offset": 25, + "phase": 0, + "quadratic_rows": [ + 10, + 65, + 36, + 73, + 0, + 4, + 74, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 1, + 66, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 3, + 0, + 2, + 1, + 0, + 0 + ], + "matrix_rows": [ + 74, + 66, + 4, + 11, + 64, + 36, + 80, + 128, + 256 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 10, + 65, + 36, + 73, + 0, + 4, + 74, + 0, + 0 + ] + } + } + } + }, + { + "new": 938, + "old": 416, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 67, + 5, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 3, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 10, + 154, + 272, + 149, + 262, + 256, + 408, + 32, + 64 + ], + "offset": 58, + "phase": 3, + "quadratic_rows": [ + 148, + 404, + 151, + 256, + 151, + 0, + 0, + 279, + 394 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 67, + 5, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 1, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 10, + 154, + 272, + 149, + 262, + 256, + 408, + 32, + 64 + ], + "offset": 58, + "phase": 0, + "quadratic_rows": [ + 148, + 404, + 151, + 256, + 151, + 0, + 0, + 279, + 394 + ] + } + } + } + }, + { + "new": 966, + "old": 416, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 200, + 463, + 155, + 329, + 322, + 320, + 64, + 96, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 28, + 20, + 139, + 157, + 139, + 0, + 0, + 156, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 200, + 463, + 155, + 329, + 322, + 320, + 64, + 96, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 20, + 139, + 157, + 139, + 0, + 0, + 156, + 0 + ] + } + } + } + }, + { + "new": 947, + "old": 417, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 66, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 425, + 106, + 172, + 256, + 64, + 328, + 80, + 352, + 384 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 168, + 40, + 168, + 47, + 0, + 47, + 0, + 5, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 66, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 3, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 425, + 106, + 172, + 256, + 64, + 328, + 80, + 352, + 384 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 168, + 40, + 168, + 47, + 0, + 47, + 0, + 5, + 0 + ] + } + } + } + }, + { + "new": 969, + "old": 417, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 64, + 131, + 261, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 198, + 294, + 96, + 163, + 320, + 356, + 40, + 336, + 256 + ], + "offset": 419, + "phase": 2, + "quadratic_rows": [ + 162, + 1, + 128, + 32, + 0, + 393, + 384, + 229, + 96 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 64, + 131, + 261, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 198, + 294, + 96, + 163, + 320, + 356, + 40, + 336, + 256 + ], + "offset": 422, + "phase": 3, + "quadratic_rows": [ + 162, + 1, + 128, + 32, + 0, + 393, + 384, + 229, + 96 + ] + } + } + } + }, + { + "new": 948, + "old": 418, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 1, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 65, + 388, + 48, + 32, + 6, + 256, + 24, + 96, + 384 + ], + "offset": 247, + "phase": 0, + "quadratic_rows": [ + 96, + 4, + 134, + 16, + 88, + 65, + 113, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 2, + 1, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 65, + 388, + 48, + 32, + 6, + 256, + 24, + 96, + 384 + ], + "offset": 244, + "phase": 1, + "quadratic_rows": [ + 96, + 4, + 134, + 16, + 88, + 65, + 113, + 132, + 0 + ] + } + } + } + }, + { + "new": 970, + "old": 418, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 36, + 64, + 129, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 2, + 3, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 65, + 384, + 390, + 81, + 386, + 256, + 24, + 64, + 32 + ], + "offset": 232, + "phase": 3, + "quadratic_rows": [ + 17, + 6, + 130, + 16, + 25, + 0, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 36, + 64, + 129, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 1, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 65, + 384, + 390, + 81, + 386, + 256, + 24, + 64, + 32 + ], + "offset": 237, + "phase": 0, + "quadratic_rows": [ + 17, + 6, + 130, + 16, + 25, + 0, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 887, + "old": 431, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 1, + 3, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 17, + 170, + 160, + 69, + 128, + 64, + 168, + 80, + 256 + ], + "offset": 17, + "phase": 3, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 130, + 17, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 17, + 170, + 160, + 69, + 128, + 64, + 168, + 80, + 256 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 130, + 17, + 160, + 0 + ] + } + } + } + }, + { + "new": 925, + "old": 431, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 130, + 272, + 170, + 1, + 138, + 20, + 256, + 128, + 320 + ], + "offset": 364, + "phase": 2, + "quadratic_rows": [ + 0, + 160, + 16, + 40, + 20, + 10, + 0, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 1, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 130, + 272, + 170, + 1, + 138, + 20, + 256, + 128, + 320 + ], + "offset": 362, + "phase": 1, + "quadratic_rows": [ + 0, + 160, + 16, + 40, + 20, + 10, + 0, + 130, + 0 + ] + } + } + } + }, + { + "new": 888, + "old": 432, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 1, + 3, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 17, + 298, + 288, + 69, + 256, + 64, + 296, + 80, + 128 + ], + "offset": 17, + "phase": 3, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 258, + 17, + 0, + 288 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 17, + 298, + 288, + 69, + 256, + 64, + 296, + 80, + 128 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 258, + 17, + 0, + 288 + ] + } + } + } + }, + { + "new": 926, + "old": 432, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 258, + 144, + 298, + 1, + 266, + 20, + 128, + 256, + 192 + ], + "offset": 364, + "phase": 2, + "quadratic_rows": [ + 0, + 288, + 16, + 40, + 20, + 10, + 0, + 0, + 258 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 1, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 258, + 144, + 298, + 1, + 266, + 20, + 128, + 256, + 192 + ], + "offset": 362, + "phase": 1, + "quadratic_rows": [ + 0, + 288, + 16, + 40, + 20, + 10, + 0, + 0, + 258 + ] + } + } + } + }, + { + "new": 895, + "old": 433, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 16, + 35, + 71, + 4, + 134, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 124, + 25, + 269, + 261, + 38, + 320, + 376, + 256, + 384 + ], + "offset": 233, + "phase": 2, + "quadratic_rows": [ + 16, + 36, + 278, + 24, + 269, + 2, + 0, + 0, + 276 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 16, + 35, + 71, + 4, + 134, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 3, + 2, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 124, + 25, + 269, + 261, + 38, + 320, + 376, + 256, + 384 + ], + "offset": 236, + "phase": 1, + "quadratic_rows": [ + 16, + 36, + 278, + 24, + 269, + 2, + 0, + 0, + 276 + ] + } + } + } + }, + { + "new": 919, + "old": 433, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 20, + 36, + 1, + 7, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 56, + 9, + 15, + 57, + 306, + 276, + 256, + 320, + 384 + ], + "offset": 243, + "phase": 3, + "quadratic_rows": [ + 62, + 319, + 287, + 15, + 55, + 19, + 0, + 0, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 20, + 36, + 1, + 7, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 56, + 9, + 15, + 57, + 306, + 276, + 256, + 320, + 384 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 62, + 319, + 287, + 15, + 55, + 19, + 0, + 0, + 6 + ] + } + } + } + }, + { + "new": 896, + "old": 434, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 70, + 128, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 12, + 108, + 256, + 38, + 64, + 104, + 16, + 384 + ], + "offset": 55, + "phase": 2, + "quadratic_rows": [ + 0, + 36, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 70, + 128, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 12, + 108, + 256, + 38, + 64, + 104, + 16, + 384 + ], + "offset": 48, + "phase": 2, + "quadratic_rows": [ + 0, + 36, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 920, + "old": 434, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 3, + 68, + 130, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 46, + 40, + 272, + 1, + 74, + 108, + 256, + 64, + 384 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 0, + 102, + 70, + 40, + 0, + 10, + 6, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 3, + 68, + 130, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 46, + 40, + 272, + 1, + 74, + 108, + 256, + 64, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 102, + 70, + 40, + 0, + 10, + 6, + 0, + 0 + ] + } + } + } + }, + { + "new": 945, + "old": 435, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 153, + 34, + 144, + 128, + 70, + 64, + 152, + 96, + 256 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 129, + 98, + 34, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 153, + 34, + 144, + 128, + 70, + 64, + 152, + 96, + 256 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 129, + 98, + 34, + 144, + 0 + ] + } + } + } + }, + { + "new": 967, + "old": 435, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 288, + 153, + 137, + 2, + 36, + 128, + 256, + 320 + ], + "offset": 436, + "phase": 2, + "quadratic_rows": [ + 144, + 0, + 32, + 24, + 9, + 36, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 288, + 153, + 137, + 2, + 36, + 128, + 256, + 320 + ], + "offset": 434, + "phase": 1, + "quadratic_rows": [ + 144, + 0, + 32, + 24, + 9, + 36, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 946, + "old": 436, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 281, + 34, + 272, + 256, + 70, + 64, + 280, + 96, + 128 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 257, + 98, + 34, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 281, + 34, + 272, + 256, + 70, + 64, + 280, + 96, + 128 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 257, + 98, + 34, + 0, + 272 + ] + } + } + } + }, + { + "new": 968, + "old": 436, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 3, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 160, + 281, + 265, + 2, + 36, + 256, + 128, + 192 + ], + "offset": 436, + "phase": 2, + "quadratic_rows": [ + 272, + 0, + 32, + 24, + 9, + 36, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 160, + 281, + 265, + 2, + 36, + 256, + 128, + 192 + ], + "offset": 434, + "phase": 1, + "quadratic_rows": [ + 272, + 0, + 32, + 24, + 9, + 36, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 939, + "old": 437, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 35, + 71, + 133, + 4, + 6, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 42, + 124, + 270, + 21, + 262, + 320, + 376, + 256, + 384 + ], + "offset": 242, + "phase": 2, + "quadratic_rows": [ + 20, + 32, + 293, + 40, + 1, + 270, + 0, + 0, + 292 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 35, + 71, + 133, + 4, + 6, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 3, + 0, + 2, + 2, + 0, + 1 + ], + "matrix_rows": [ + 42, + 124, + 270, + 21, + 262, + 320, + 376, + 256, + 384 + ], + "offset": 244, + "phase": 1, + "quadratic_rows": [ + 20, + 32, + 293, + 40, + 1, + 270, + 0, + 0, + 292 + ] + } + } + } + }, + { + "new": 971, + "old": 437, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 21, + 36, + 2, + 67, + 7, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 0, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 56, + 15, + 305, + 58, + 292, + 256, + 320, + 384 + ], + "offset": 235, + "phase": 3, + "quadratic_rows": [ + 319, + 61, + 303, + 15, + 35, + 55, + 0, + 0, + 5 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 21, + 36, + 2, + 67, + 7, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 56, + 15, + 305, + 58, + 292, + 256, + 320, + 384 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 319, + 61, + 303, + 15, + 35, + 55, + 0, + 0, + 5 + ] + } + } + } + }, + { + "new": 940, + "old": 438, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 37, + 69, + 1, + 128, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 12, + 258, + 92, + 21, + 256, + 64, + 88, + 32, + 384 + ], + "offset": 47, + "phase": 2, + "quadratic_rows": [ + 20, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 37, + 69, + 1, + 128, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 12, + 258, + 92, + 21, + 256, + 64, + 88, + 32, + 384 + ], + "offset": 40, + "phase": 2, + "quadratic_rows": [ + 20, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 972, + "old": 438, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 3, + 66, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 29, + 24, + 288, + 73, + 2, + 92, + 64, + 256, + 384 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 85, + 0, + 69, + 24, + 9, + 0, + 5, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 3, + 66, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 29, + 24, + 288, + 73, + 2, + 92, + 64, + 256, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 85, + 0, + 69, + 24, + 9, + 0, + 5, + 0, + 0 + ] + } + } + } + }, + { + "new": 889, + "old": 491, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 2, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 2, + 0, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 20, + 66, + 416, + 5, + 16, + 80, + 40, + 256, + 384 + ], + "offset": 239, + "phase": 0, + "quadratic_rows": [ + 4, + 80, + 69, + 32, + 66, + 168, + 86, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 2, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 2, + 2, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 20, + 66, + 416, + 5, + 16, + 80, + 40, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 4, + 80, + 69, + 32, + 66, + 168, + 86, + 160, + 0 + ] + } + } + } + }, + { + "new": 949, + "old": 491, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 66, + 384, + 424, + 5, + 70, + 64, + 392, + 16, + 256 + ], + "offset": 312, + "phase": 3, + "quadratic_rows": [ + 4, + 6, + 7, + 40, + 0, + 136, + 0, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 66, + 384, + 424, + 5, + 70, + 64, + 392, + 16, + 256 + ], + "offset": 317, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 7, + 40, + 0, + 136, + 0, + 288, + 384 + ] + } + } + } + }, + { + "new": 890, + "old": 492, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 18, + 33, + 65, + 135, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 81, + 407, + 181, + 325, + 256, + 64, + 72, + 336, + 384 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 55, + 149, + 35, + 0, + 51, + 149, + 0, + 34, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 18, + 33, + 65, + 135, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 0, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 81, + 407, + 181, + 325, + 256, + 64, + 72, + 336, + 384 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 55, + 149, + 35, + 0, + 51, + 149, + 0, + 34, + 0 + ] + } + } + } + }, + { + "new": 950, + "old": 492, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 23, + 39, + 71, + 132, + 259, + 7, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 130, + 258, + 183, + 357, + 230, + 64, + 72, + 368, + 256 + ], + "offset": 463, + "phase": 2, + "quadratic_rows": [ + 467, + 467, + 368, + 0, + 471, + 356, + 183, + 83, + 311 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 23, + 39, + 71, + 132, + 259, + 7, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 130, + 258, + 183, + 357, + 230, + 64, + 72, + 368, + 256 + ], + "offset": 463, + "phase": 1, + "quadratic_rows": [ + 467, + 467, + 368, + 0, + 471, + 356, + 183, + 83, + 311 + ] + } + } + } + }, + { + "new": 899, + "old": 493, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 39, + 66, + 128, + 2, + 256, + 3, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 0, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 388, + 9, + 4, + 133, + 166, + 256, + 40, + 16, + 64 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 141, + 164, + 167, + 41, + 0, + 174, + 0, + 295, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 39, + 66, + 128, + 2, + 256, + 3, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 0, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 388, + 9, + 4, + 133, + 166, + 256, + 40, + 16, + 64 + ], + "offset": 61, + "phase": 1, + "quadratic_rows": [ + 141, + 164, + 167, + 41, + 0, + 174, + 0, + 295, + 384 + ] + } + } + } + }, + { + "new": 959, + "old": 493, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 34, + 71, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 73, + 399, + 171, + 323, + 64, + 256, + 328, + 80, + 384 + ], + "offset": 36, + "phase": 3, + "quadratic_rows": [ + 47, + 37, + 139, + 45, + 0, + 139, + 0, + 36, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 34, + 71, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 73, + 399, + 171, + 323, + 64, + 256, + 328, + 80, + 384 + ], + "offset": 35, + "phase": 1, + "quadratic_rows": [ + 47, + 37, + 139, + 45, + 0, + 139, + 0, + 36, + 0 + ] + } + } + } + }, + { + "new": 900, + "old": 494, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 132, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 1, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 68, + 384, + 432, + 5, + 6, + 64, + 72, + 400, + 256 + ], + "offset": 313, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 48, + 144, + 0, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 132, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 3, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 68, + 384, + 432, + 5, + 6, + 64, + 72, + 400, + 256 + ], + "offset": 316, + "phase": 3, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 48, + 144, + 0, + 288, + 384 + ] + } + } + } + }, + { + "new": 960, + "old": 494, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 2, + 64, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 2, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 10, + 68, + 416, + 3, + 72, + 8, + 48, + 256, + 384 + ], + "offset": 223, + "phase": 0, + "quadratic_rows": [ + 2, + 67, + 72, + 68, + 32, + 176, + 78, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 2, + 64, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 2, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 10, + 68, + 416, + 3, + 72, + 8, + 48, + 256, + 384 + ], + "offset": 217, + "phase": 1, + "quadratic_rows": [ + 2, + 67, + 72, + 68, + 32, + 176, + 78, + 160, + 0 + ] + } + } + } + }, + { + "new": 905, + "old": 495, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 3, + 384, + 420, + 65, + 74, + 388, + 64, + 16, + 256 + ], + "offset": 257, + "phase": 3, + "quadratic_rows": [ + 67, + 75, + 36, + 2, + 0, + 132, + 3, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 3, + 384, + 420, + 65, + 74, + 388, + 64, + 16, + 256 + ], + "offset": 261, + "phase": 1, + "quadratic_rows": [ + 67, + 75, + 36, + 2, + 0, + 132, + 3, + 288, + 384 + ] + } + } + } + }, + { + "new": 965, + "old": 495, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 90, + 66, + 416, + 11, + 16, + 36, + 80, + 256, + 384 + ], + "offset": 238, + "phase": 3, + "quadratic_rows": [ + 10, + 1, + 32, + 9, + 0, + 164, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 2, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 90, + 66, + 416, + 11, + 16, + 36, + 80, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 10, + 1, + 32, + 9, + 0, + 164, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 906, + "old": 496, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 134, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 291, + 179, + 16, + 33, + 34, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 134, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 291, + 179, + 16, + 33, + 34, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + } + } + }, + { + "new": 966, + "old": 496, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 132, + "phase": 3, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 131, + "phase": 1, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + } + } + }, + { + "new": 915, + "old": 497, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 39, + 66, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 397, + 165, + 321, + 64, + 324, + 256, + 80, + 384 + ], + "offset": 68, + "phase": 3, + "quadratic_rows": [ + 47, + 5, + 47, + 133, + 0, + 133, + 0, + 40, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 39, + 66, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 397, + 165, + 321, + 64, + 324, + 256, + 80, + 384 + ], + "offset": 67, + "phase": 1, + "quadratic_rows": [ + 47, + 5, + 47, + 133, + 0, + 133, + 0, + 40, + 0 + ] + } + } + } + }, + { + "new": 971, + "old": 497, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 70, + 128, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 293, + 173, + 8, + 33, + 170, + 36, + 256, + 16, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 424, + 168, + 424, + 263, + 0, + 263, + 0, + 135, + 301 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 70, + 128, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 293, + 173, + 8, + 33, + 170, + 36, + 256, + 16, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 424, + 168, + 424, + 263, + 0, + 263, + 0, + 135, + 301 + ] + } + } + } + }, + { + "new": 916, + "old": 498, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 37, + 69, + 1, + 130, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 20, + 416, + 68, + 21, + 34, + 64, + 72, + 256, + 384 + ], + "offset": 255, + "phase": 1, + "quadratic_rows": [ + 20, + 32, + 1, + 0, + 17, + 162, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 37, + 69, + 1, + 130, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 20, + 416, + 68, + 21, + 34, + 64, + 72, + 256, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 20, + 32, + 1, + 0, + 17, + 162, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 972, + "old": 498, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 64, + 130, + 260, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 384, + 5, + 418, + 65, + 386, + 84, + 8, + 64, + 256 + ], + "offset": 258, + "phase": 3, + "quadratic_rows": [ + 69, + 34, + 85, + 0, + 4, + 130, + 5, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 64, + 130, + 260, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 5, + 418, + 65, + 386, + 84, + 8, + 64, + 256 + ], + "offset": 262, + "phase": 1, + "quadratic_rows": [ + 69, + 34, + 85, + 0, + 4, + 130, + 5, + 288, + 384 + ] + } + } + } + }, + { + "new": 891, + "old": 511, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 132, + 135, + 24, + 133, + 128, + 104, + 80, + 64, + 256 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 3, + 5, + 130, + 120, + 88, + 8, + 24, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 132, + 135, + 24, + 133, + 128, + 104, + 80, + 64, + 256 + ], + "offset": 22, + "phase": 1, + "quadratic_rows": [ + 3, + 5, + 130, + 120, + 88, + 8, + 24, + 132, + 0 + ] + } + } + } + }, + { + "new": 957, + "old": 511, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 2, + 135, + 24, + 3, + 128, + 72, + 112, + 64, + 256 + ], + "offset": 29, + "phase": 1, + "quadratic_rows": [ + 133, + 4, + 131, + 88, + 120, + 16, + 24, + 133, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 2, + 135, + 24, + 3, + 128, + 72, + 112, + 64, + 256 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 133, + 4, + 131, + 88, + 120, + 16, + 24, + 133, + 0 + ] + } + } + } + }, + { + "new": 892, + "old": 512, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 260, + 263, + 24, + 261, + 256, + 104, + 80, + 64, + 128 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 3, + 5, + 258, + 120, + 88, + 8, + 24, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 260, + 263, + 24, + 261, + 256, + 104, + 80, + 64, + 128 + ], + "offset": 22, + "phase": 1, + "quadratic_rows": [ + 3, + 5, + 258, + 120, + 88, + 8, + 24, + 0, + 260 + ] + } + } + } + }, + { + "new": 958, + "old": 512, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 2, + 263, + 24, + 3, + 256, + 72, + 112, + 64, + 128 + ], + "offset": 29, + "phase": 1, + "quadratic_rows": [ + 261, + 4, + 259, + 88, + 120, + 16, + 24, + 0, + 261 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 2, + 263, + 24, + 3, + 256, + 72, + 112, + 64, + 128 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 261, + 4, + 259, + 88, + 120, + 16, + 24, + 0, + 261 + ] + } + } + } + }, + { + "new": 897, + "old": 513, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 71, + 1, + 130, + 5, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 297, + 25, + 108, + 341, + 38, + 256, + 296, + 320, + 384 + ], + "offset": 232, + "phase": 1, + "quadratic_rows": [ + 100, + 36, + 27, + 124, + 348, + 299, + 25, + 0, + 304 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 71, + 1, + 130, + 5, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 297, + 25, + 108, + 341, + 38, + 256, + 296, + 320, + 384 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 100, + 36, + 27, + 124, + 348, + 299, + 25, + 0, + 304 + ] + } + } + } + }, + { + "new": 951, + "old": 513, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 39, + 1, + 71, + 131, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 3, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 305, + 340, + 25, + 109, + 38, + 256, + 304, + 320, + 384 + ], + "offset": 226, + "phase": 1, + "quadratic_rows": [ + 324, + 36, + 27, + 124, + 348, + 298, + 25, + 0, + 305 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 39, + 1, + 71, + 131, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 3, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 305, + 340, + 25, + 109, + 38, + 256, + 304, + 320, + 384 + ], + "offset": 225, + "phase": 2, + "quadratic_rows": [ + 324, + 36, + 27, + 124, + 348, + 298, + 25, + 0, + 305 + ] + } + } + } + }, + { + "new": 898, + "old": 514, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 68, + 128, + 2, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 4, + 97, + 264, + 5, + 38, + 64, + 256, + 16, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 101, + 36, + 99, + 0, + 0, + 103, + 101, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 68, + 128, + 2, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 0, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 4, + 97, + 264, + 5, + 38, + 64, + 256, + 16, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 101, + 36, + 99, + 0, + 0, + 103, + 101, + 0, + 0 + ] + } + } + } + }, + { + "new": 952, + "old": 514, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 64, + 132, + 1, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 100, + 97, + 272, + 101, + 38, + 64, + 8, + 256, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 5, + 36, + 99, + 0, + 0, + 102, + 100, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 64, + 132, + 1, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 100, + 97, + 272, + 101, + 38, + 64, + 8, + 256, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 5, + 36, + 99, + 0, + 0, + 102, + 100, + 0, + 0 + ] + } + } + } + }, + { + "new": 913, + "old": 515, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 144, + 6, + 153, + 145, + 98, + 68, + 128, + 64, + 256 + ], + "offset": 66, + "phase": 3, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 136, + 2, + 6, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 144, + 6, + 153, + 145, + 98, + 68, + 128, + 64, + 256 + ], + "offset": 70, + "phase": 1, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 136, + 2, + 6, + 144, + 0 + ] + } + } + } + }, + { + "new": 967, + "old": 515, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 8, + 6, + 153, + 9, + 66, + 100, + 128, + 64, + 256 + ], + "offset": 75, + "phase": 1, + "quadratic_rows": [ + 145, + 70, + 102, + 16, + 137, + 4, + 6, + 145, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 8, + 6, + 153, + 9, + 66, + 100, + 128, + 64, + 256 + ], + "offset": 79, + "phase": 1, + "quadratic_rows": [ + 145, + 70, + 102, + 16, + 137, + 4, + 6, + 145, + 0 + ] + } + } + } + }, + { + "new": 914, + "old": 516, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 272, + 6, + 281, + 273, + 98, + 68, + 256, + 64, + 128 + ], + "offset": 66, + "phase": 3, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 264, + 2, + 6, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 272, + 6, + 281, + 273, + 98, + 68, + 256, + 64, + 128 + ], + "offset": 70, + "phase": 1, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 264, + 2, + 6, + 0, + 272 + ] + } + } + } + }, + { + "new": 968, + "old": 516, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 8, + 6, + 281, + 9, + 66, + 100, + 256, + 64, + 128 + ], + "offset": 75, + "phase": 1, + "quadratic_rows": [ + 273, + 70, + 102, + 16, + 265, + 4, + 6, + 0, + 273 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 8, + 6, + 281, + 9, + 66, + 100, + 256, + 64, + 128 + ], + "offset": 79, + "phase": 1, + "quadratic_rows": [ + 273, + 70, + 102, + 16, + 265, + 4, + 6, + 0, + 273 + ] + } + } + } + }, + { + "new": 907, + "old": 517, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 5, + 32, + 65, + 130, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 3, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 291, + 117, + 337, + 341, + 290, + 56, + 256, + 320, + 384 + ], + "offset": 222, + "phase": 3, + "quadratic_rows": [ + 339, + 3, + 292, + 48, + 345, + 300, + 337, + 0, + 117 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 5, + 32, + 65, + 130, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 3, + 3, + 1, + 0, + 0 + ], + "matrix_rows": [ + 291, + 117, + 337, + 341, + 290, + 56, + 256, + 320, + 384 + ], + "offset": 221, + "phase": 2, + "quadratic_rows": [ + 339, + 3, + 292, + 48, + 345, + 300, + 337, + 0, + 117 + ] + } + } + } + }, + { + "new": 969, + "old": 517, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 65, + 133, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 1, + 0, + 3, + 0, + 1 + ], + "matrix_rows": [ + 293, + 113, + 339, + 115, + 292, + 56, + 256, + 320, + 384 + ], + "offset": 208, + "phase": 0, + "quadratic_rows": [ + 117, + 290, + 5, + 48, + 121, + 347, + 113, + 0, + 290 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 65, + 133, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 1, + 2, + 3, + 0, + 3 + ], + "matrix_rows": [ + 293, + 113, + 339, + 115, + 292, + 56, + 256, + 320, + 384 + ], + "offset": 213, + "phase": 3, + "quadratic_rows": [ + 117, + 290, + 5, + 48, + 121, + 347, + 113, + 0, + 290 + ] + } + } + } + }, + { + "new": 908, + "old": 518, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 64, + 133, + 4, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 16, + 258, + 97, + 17, + 256, + 4, + 56, + 64, + 384 + ], + "offset": 203, + "phase": 0, + "quadratic_rows": [ + 113, + 0, + 0, + 48, + 105, + 121, + 113, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 64, + 133, + 4, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 2, + 0, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 16, + 258, + 97, + 17, + 256, + 4, + 56, + 64, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 113, + 0, + 0, + 48, + 105, + 121, + 113, + 0, + 0 + ] + } + } + } + }, + { + "new": 970, + "old": 518, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 97, + 113, + 2, + 256, + 56, + 64, + 384 + ], + "offset": 203, + "phase": 0, + "quadratic_rows": [ + 17, + 0, + 0, + 48, + 105, + 120, + 112, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 97, + 113, + 2, + 256, + 56, + 64, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 17, + 0, + 0, + 48, + 105, + 120, + 112, + 0, + 0 + ] + } + } + } + }, + { + "new": 305, + "old": 626, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 230, + 1, + 322, + 324, + 8, + 16, + 288, + 256, + 384 + ], + "offset": 141, + "phase": 1, + "quadratic_rows": [ + 0, + 422, + 422, + 0, + 0, + 486, + 416, + 486, + 230 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 230, + 1, + 322, + 324, + 8, + 16, + 288, + 256, + 384 + ], + "offset": 141, + "phase": 0, + "quadratic_rows": [ + 0, + 422, + 422, + 0, + 0, + 486, + 416, + 486, + 230 + ] + } + } + } + }, + { + "new": 303, + "old": 629, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 304, + "old": 634, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 129, + 193, + 66, + 4, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 65, + 64, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 129, + 193, + 66, + 4, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 65, + 64, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + } + } + }, + { + "new": 305, + "old": 798, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 70, + 1, + 66, + 68, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 70, + 1, + 66, + 68, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 885, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 2, + 260, + 64, + 80, + 96 + ], + "offset": 72, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 0, + 0, + 8, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 2, + 260, + 64, + 80, + 96 + ], + "offset": 73, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 0, + 0, + 8, + 256, + 384 + ] + } + } + } + }, + { + "new": 1, + "old": 886, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 257, + 2, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 4, + 320, + 64, + 352 + ], + "offset": 192, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 320, + 0, + 24, + 256, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 257, + 2, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 4, + 320, + 64, + 352 + ], + "offset": 195, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 320, + 0, + 24, + 256, + 144 + ] + } + } + } + }, + { + "new": 1, + "old": 887, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 136, + 272, + 320, + 2, + 324, + 128, + 64, + 160 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 320, + 0, + 17, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 136, + 272, + 320, + 2, + 324, + 128, + 64, + 160 + ], + "offset": 231, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 320, + 0, + 17, + 0, + 272 + ] + } + } + } + }, + { + "new": 1, + "old": 888, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 264, + 144, + 192, + 2, + 196, + 256, + 64, + 288 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 192, + 0, + 17, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 264, + 144, + 192, + 2, + 196, + 256, + 64, + 288 + ], + "offset": 231, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 192, + 0, + 17, + 144, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 901, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 68, + 4, + 133, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 82, + 260, + 8, + 1, + 80, + 256, + 16, + 96, + 384 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 16, + 8, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 68, + 4, + 133, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 82, + 260, + 8, + 1, + 80, + 256, + 16, + 96, + 384 + ], + "offset": 98, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 16, + 8, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 902, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 68, + 133, + 6, + 7, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 1, + 1, + 0, + 1 + ], + "matrix_rows": [ + 353, + 98, + 8, + 96, + 256, + 260, + 288, + 336, + 384 + ], + "offset": 30, + "phase": 1, + "quadratic_rows": [ + 256, + 352, + 0, + 288, + 0, + 106, + 98, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 68, + 133, + 6, + 7, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 3 + ], + "matrix_rows": [ + 353, + 98, + 8, + 96, + 256, + 260, + 288, + 336, + 384 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 256, + 352, + 0, + 288, + 0, + 106, + 98, + 0, + 267 + ] + } + } + } + }, + { + "new": 1, + "old": 909, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 130, + 260, + 320, + 128, + 64, + 8, + 336, + 160 + ], + "offset": 176, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 320, + 0, + 0, + 0, + 5, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 130, + 260, + 320, + 128, + 64, + 8, + 336, + 160 + ], + "offset": 183, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 320, + 0, + 0, + 0, + 5, + 0, + 260 + ] + } + } + } + }, + { + "new": 1, + "old": 910, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 258, + 132, + 192, + 256, + 64, + 8, + 208, + 288 + ], + "offset": 176, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 192, + 0, + 0, + 0, + 5, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 258, + 132, + 192, + 256, + 64, + 8, + 208, + 288 + ], + "offset": 183, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 192, + 0, + 0, + 0, + 5, + 132, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 918, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 68, + 135, + 5, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 353, + 100, + 8, + 256, + 258, + 352, + 288, + 336, + 384 + ], + "offset": 45, + "phase": 1, + "quadratic_rows": [ + 96, + 0, + 256, + 288, + 0, + 361, + 353, + 0, + 108 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 68, + 135, + 5, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 0 + ], + "matrix_rows": [ + 353, + 100, + 8, + 256, + 258, + 352, + 288, + 336, + 384 + ], + "offset": 47, + "phase": 1, + "quadratic_rows": [ + 96, + 0, + 256, + 288, + 0, + 361, + 353, + 0, + 108 + ] + } + } + } + }, + { + "new": 279, + "old": 921, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 39, + 68, + 6, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 1, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 341, + 6, + 92, + 256, + 320, + 276, + 336, + 288, + 384 + ], + "offset": 237, + "phase": 3, + "quadratic_rows": [ + 84, + 324, + 31, + 260, + 341, + 0, + 339, + 0, + 90 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 39, + 68, + 6, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 341, + 6, + 92, + 256, + 320, + 276, + 336, + 288, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 84, + 324, + 31, + 260, + 341, + 0, + 339, + 0, + 90 + ] + } + } + } + }, + { + "new": 279, + "old": 922, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 38, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 38, + 4, + 256, + 64, + 100, + 8, + 80, + 384 + ], + "offset": 184, + "phase": 1, + "quadratic_rows": [ + 0, + 100, + 66, + 0, + 0, + 98, + 38, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 38, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 38, + 4, + 256, + 64, + 100, + 8, + 80, + 384 + ], + "offset": 189, + "phase": 2, + "quadratic_rows": [ + 0, + 100, + 66, + 0, + 0, + 98, + 38, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 923, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 66, + 2, + 132, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 257, + 84, + 124, + 256, + 2, + 92, + 16, + 64, + 384 + ], + "offset": 14, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 112, + 56, + 124, + 28, + 84, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 66, + 2, + 132, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 257, + 84, + 124, + 256, + 2, + 92, + 16, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 112, + 56, + 124, + 28, + 84, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 924, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 68, + 134, + 7, + 5, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 0, + 1, + 3, + 0, + 3 + ], + "matrix_rows": [ + 109, + 354, + 8, + 256, + 96, + 268, + 320, + 304, + 384 + ], + "offset": 137, + "phase": 0, + "quadratic_rows": [ + 364, + 256, + 357, + 33, + 0, + 109, + 101, + 0, + 263 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 68, + 134, + 7, + 5, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 2, + 0, + 1, + 3, + 0, + 1 + ], + "matrix_rows": [ + 109, + 354, + 8, + 256, + 96, + 268, + 320, + 304, + 384 + ], + "offset": 139, + "phase": 0, + "quadratic_rows": [ + 364, + 256, + 357, + 33, + 0, + 109, + 101, + 0, + 263 + ] + } + } + } + }, + { + "new": 1, + "old": 925, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 66, + 132, + 256, + 1, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 130, + 260, + 64, + 128, + 320, + 136, + 336, + 32 + ], + "offset": 152, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 64, + 0, + 0, + 0, + 5, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 66, + 132, + 256, + 1, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 130, + 260, + 64, + 128, + 320, + 136, + 336, + 32 + ], + "offset": 159, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 64, + 0, + 0, + 0, + 5, + 0, + 257 + ] + } + } + } + }, + { + "new": 280, + "old": 929, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 3, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 130, + 260, + 39, + 128, + 256, + 136, + 272, + 64 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 167, + 39, + 39, + 0, + 0, + 7, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 3, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 0, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 130, + 260, + 39, + 128, + 256, + 136, + 272, + 64 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 167, + 39, + 39, + 0, + 0, + 7, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 930, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 258, + 132, + 39, + 256, + 128, + 264, + 144, + 64 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 295, + 39, + 39, + 0, + 0, + 7, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 258, + 132, + 39, + 256, + 128, + 264, + 144, + 64 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 295, + 39, + 39, + 0, + 0, + 7, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 279, + "old": 931, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 128, + 257, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 5, + 258, + 384, + 64, + 256, + 68, + 264, + 16, + 96 + ], + "offset": 312, + "phase": 1, + "quadratic_rows": [ + 68, + 0, + 69, + 0, + 0, + 0, + 5, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 128, + 257, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 5, + 258, + 384, + 64, + 256, + 68, + 264, + 16, + 96 + ], + "offset": 314, + "phase": 1, + "quadratic_rows": [ + 68, + 0, + 69, + 0, + 0, + 0, + 5, + 256, + 384 + ] + } + } + } + }, + { + "new": 279, + "old": 932, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 128, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 260, + 384, + 64, + 2, + 356, + 8, + 16, + 320 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 320, + 0, + 100, + 0, + 0, + 4, + 5, + 256, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 128, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 260, + 384, + 64, + 2, + 356, + 8, + 16, + 320 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 100, + 0, + 0, + 4, + 5, + 256, + 129 + ] + } + } + } + }, + { + "new": 279, + "old": 953, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 7, + 132, + 6, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 0, + 1, + 0, + 1 + ], + "matrix_rows": [ + 341, + 6, + 88, + 80, + 320, + 276, + 256, + 288, + 384 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 260, + 324, + 67, + 336, + 88, + 0, + 94, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 7, + 132, + 6, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 0, + 1, + 0, + 3 + ], + "matrix_rows": [ + 341, + 6, + 88, + 80, + 320, + 276, + 256, + 288, + 384 + ], + "offset": 225, + "phase": 2, + "quadratic_rows": [ + 260, + 324, + 67, + 336, + 88, + 0, + 94, + 0, + 267 + ] + } + } + } + }, + { + "new": 279, + "old": 954, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 130, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 2, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 54, + 48, + 264, + 1, + 96, + 116, + 256, + 64, + 384 + ], + "offset": 82, + "phase": 0, + "quadratic_rows": [ + 0, + 84, + 70, + 0, + 34, + 48, + 6, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 130, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 2, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 54, + 48, + 264, + 1, + 96, + 116, + 256, + 64, + 384 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 0, + 84, + 70, + 0, + 34, + 48, + 6, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 955, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 2, + 131, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 21, + 16, + 264, + 64, + 2, + 84, + 256, + 96, + 384 + ], + "offset": 74, + "phase": 0, + "quadratic_rows": [ + 84, + 0, + 69, + 0, + 65, + 0, + 21, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 2, + 131, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 21, + 16, + 264, + 64, + 2, + 84, + 256, + 96, + 384 + ], + "offset": 76, + "phase": 3, + "quadratic_rows": [ + 84, + 0, + 69, + 0, + 65, + 0, + 21, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 956, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 132, + 7, + 5, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 3, + 1, + 0, + 1 + ], + "matrix_rows": [ + 5, + 358, + 104, + 320, + 96, + 292, + 256, + 272, + 384 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 324, + 260, + 67, + 352, + 0, + 104, + 109, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 132, + 7, + 5, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 2, + 0, + 3, + 1, + 0, + 3 + ], + "matrix_rows": [ + 5, + 358, + 104, + 320, + 96, + 292, + 256, + 272, + 384 + ], + "offset": 226, + "phase": 2, + "quadratic_rows": [ + 324, + 260, + 67, + 352, + 0, + 104, + 109, + 0, + 267 + ] + } + } + } + }, + { + "new": 280, + "old": 961, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 281, + 136, + 317, + 2, + 288, + 128, + 32, + 192 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 164, + 0, + 25, + 36, + 20, + 9, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 281, + 136, + 317, + 2, + 288, + 128, + 32, + 192 + ], + "offset": 388, + "phase": 3, + "quadratic_rows": [ + 164, + 0, + 25, + 36, + 20, + 9, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 962, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 2, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 153, + 264, + 189, + 2, + 160, + 256, + 32, + 320 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 292, + 0, + 25, + 36, + 20, + 9, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 1, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 153, + 264, + 189, + 2, + 160, + 256, + 32, + 320 + ], + "offset": 388, + "phase": 3, + "quadratic_rows": [ + 292, + 0, + 25, + 36, + 20, + 9, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 281, + "old": 963, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 258, + 12, + 64, + 80, + 96 + ], + "offset": 488, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 8, + 76, + 0, + 0, + 8, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 258, + 12, + 64, + 80, + 96 + ], + "offset": 489, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 8, + 76, + 0, + 0, + 8, + 256, + 384 + ] + } + } + } + }, + { + "new": 281, + "old": 964, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 2, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 12, + 64, + 320, + 352 + ], + "offset": 352, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 8, + 332, + 64, + 0, + 24, + 256, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 2, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 12, + 64, + 320, + 352 + ], + "offset": 355, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 8, + 332, + 64, + 0, + 24, + 256, + 136 + ] + } + } + } + }, + { + "new": 1, + "old": 973, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 66, + 129, + 1, + 256, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 1, + 260, + 384, + 32, + 34, + 256, + 264, + 48, + 64 + ], + "offset": 40, + "phase": 3, + "quadratic_rows": [ + 32, + 0, + 0, + 0, + 0, + 1, + 0, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 66, + 129, + 1, + 256, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 1, + 260, + 384, + 32, + 34, + 256, + 264, + 48, + 64 + ], + "offset": 42, + "phase": 3, + "quadratic_rows": [ + 32, + 0, + 0, + 0, + 0, + 1, + 0, + 256, + 384 + ] + } + } + } + }, + { + "new": 1, + "old": 977, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 68, + 130, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 258, + 132, + 32, + 288, + 128, + 136, + 304, + 64 + ], + "offset": 168, + "phase": 0, + "quadratic_rows": [ + 288, + 32, + 0, + 0, + 0, + 3, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 68, + 130, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 258, + 132, + 32, + 288, + 128, + 136, + 304, + 64 + ], + "offset": 175, + "phase": 0, + "quadratic_rows": [ + 288, + 32, + 0, + 0, + 0, + 3, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 1, + "old": 988, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 3, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 65, + 66, + 96, + 32, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 72, + "phase": 0, + "quadratic_rows": [ + 32, + 96, + 0, + 0, + 0, + 3, + 66, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 3, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 65, + 66, + 96, + 32, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 75, + "phase": 0, + "quadratic_rows": [ + 32, + 96, + 0, + 0, + 0, + 3, + 66, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 996, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 128, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 257, + 258, + 288, + 32, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 72, + "phase": 0, + "quadratic_rows": [ + 32, + 288, + 0, + 0, + 0, + 3, + 0, + 0, + 258 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 128, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 258, + 288, + 32, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 75, + "phase": 0, + "quadratic_rows": [ + 32, + 288, + 0, + 0, + 0, + 3, + 0, + 0, + 258 + ] + } + } + } + } + ], + "paid": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "status": "PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS" + }, + "retimed_source_head": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9", + "retimed_source_sha256": { + "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7", + "research/kappa-function-composition/complex/prune_native.py": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "research/kappa-rebuild/complex/native_extensions.py": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3", + "research/kappa-rebuild/complex/power_two_balance.py": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424", + "research/kappa-rebuild/complex/rebuild_native.py": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "scalar_contact_frames_retimed": 395, + "schema": "source-bound-retimed-arbitrary-native-supplier/1", + "status": "PASS_ALL_632_INPUTS_BOTH_DIRECTIONS_AND_ALL_RETIMED_HELPER_PHASES", + "whole_helper_boundary_recipes": 408 + }, + "local_supplier_source_sha256": "8542575d046c9488574dbf1ca258bbdc6ff7dc66db778cba3b0027b7b4673653", + "main_contact_checks": 8512, + "native_and_boundary_scalar_allowance": 3385896, + "native_mask": 28633115307, + "native_stage_indices": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "native_stages": 19, + "omitted_direct_inverse_translation_rejected": 112, + "omitted_endpoint_translation_rejected": 1904, + "owned_bank_scope": "Each direct copy persists across its own recursive request and is released after the ADD. Each native invocation retains its original owned center. All nested suspended banks are separately charged.", + "p": 17, + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 69273, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "productive_fields": 11560, + "productive_main_fields": 3808, + "rank_margin": 800, + "raw_owned_bank_episodes": 1811, + "scalar_allowance": 3500584, + "schema": "complete-source-bound-hybrid-p17-native-inventory/1", + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/kappa-rebuild/transfer-audit/p3_native_audit.py": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + }, + "status": "PASS_RETIMED_SUPPLIER_AND_ALL_HYBRID_CONTROLLER_PHASES", + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + }, + "whole_idle_profile": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "wrong_direct_orientation_rejected": true +} diff --git a/research/kappa-hybrid-controller/certificates/STRICTIFICATION.json b/research/kappa-hybrid-controller/certificates/STRICTIFICATION.json new file mode 100644 index 0000000000..64f9b26cdb --- /dev/null +++ b/research/kappa-hybrid-controller/certificates/STRICTIFICATION.json @@ -0,0 +1,52056 @@ +{ + "alpha_interval": { + "lower": "0.99999999981197332875426410809243316", + "upper": "0.99999999981197332875426410809243317" + }, + "alpha_upper": "9999999999/10000000000", + "ambient_rank_encoding": "281^17160", + "completion_decay_block_length": 5, + "controls": { + "one_decay_block_rejected": true, + "undamped_completion_rejected": true, + "unpadded_rank_one_tail_rejected": true + }, + "cutoff_base": 18, + "cutoff_encoding": "18^17160", + "decay_block_count": 22, + "decay_block_length": 780, + "delta_interval": { + "lower": "0.84399113766577138522456189514008497", + "upper": "0.84399113766577138522456189514008498" + }, + "delta_upper": "6/7", + "exponent": 17160, + "gamma_interval": { + "lower": "0.99907124299228386730839393376721823", + "upper": "0.99907124299228386730839393376721824" + }, + "gamma_upper": "9991/10000", + "materialized_tensor_or_completed_word": false, + "native_inventory": { + "all_column_direct_recipe": "At f columns the address map is P tensor I_f (or I_f tensor P in column order), with its induced per-column array permutation. Use one Gaussian child of rank f, inverse route and repeated q translation for C_q inverse. The request has the complete ancestor weight.", + "artifact_hash_encoding": "Uncompressed UTF-8 JSON, sort_keys=True, separators=(comma,colon)", + "artifact_sha256": "a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034", + "case_sha256": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "dimension": 281, + "direct_nonrecursive_movement_records_allowance": 14336, + "direct_owned_copy_episodes": 1792, + "direct_owned_release_episodes": 1792, + "direct_paid_queries": 1792, + "direct_productive_scratch_endpoints": 0, + "direct_query_rank_for_f_columns": "f, with the same ancestor weight; never f rank-one column queries", + "direct_scalar_allowance": 114688, + "direct_scratch_ownership": "Copy source to an owned zero array; query that copy; add to destination; release. No arbitrary helper or productive scratch credit.", + "direct_stage_indices": [ + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32 + ], + "direct_stages": 16, + "factor_factory": { + "artifacts": { + "P17-DIRECT-CASE.json": "00247ee53b39cf01e176d93b8035bbdb18e7669f969b4ab576130205ae02d0df", + "P17-FULL-LAURENT-CASE.json": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33" + }, + "direct_rank1_children": 1792, + "incorrect_backward_sign_rejected": true, + "native_invocations": 19, + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + "status": "PASS_EXACT_P17_LAURENT_SPECIALIZATION" + }, + "factor_factory_source_sha256": "f527528ff19b107427d593bf35481e127154831563179eed3f43f365177d4585", + "fresh_helper_fields": 7752, + "geometry_payload_sha256": "a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034", + "geometry_source_sha256": "fe4e7d689df8af865dc0ae16bcbac9cb50e988efd24f3ff99ac52b498cd6c60a", + "keep": 280378328416255, + "laurent": { + "input_columns": 34, + "literal_events": 341, + "matrix_entries": 1156 + }, + "limits": "Complete finite native/direct controller admission. The common-column tensor rule, expanded fixed route/scalar/owned-stock bounds and inherited precision, analytic, fixed-tape and exact-recovery premises are written separately in PROOF.md.", + "local_profiles": "Independently audited PR4441 retimed local supplier; the enclosing native_inventory reruns its complete literal and phase gate.", + "local_supplier": { + "all_408_helpers_arbitrary": true, + "all_scalar_actions_and_order_unchanged": true, + "all_warp_contacts_unchanged": true, + "authenticated_original_files": 23, + "boundary_movement_allowance": "Every new whole-helper left/right monomial and transport recipe contributes its full finite route and phase cost.", + "distinct_physical_edge_and_boundary_recipes": 320, + "external_main_boundaries_unchanged": true, + "fresh_arbitrary_input_fields": 632, + "inherited_native_gate": { + "ambient_rank": 57, + "controls": { + "raw_rule_not_strictly_separated": true, + "whole_idle_missing_phase_rejected_count": 224, + "wrong_intermediate_center_rejected": true + }, + "fresh_helper_fields": 2856, + "main_fields": 672, + "native_scalar_allowance": 1147304, + "paid": { + "1": 17409, + "16": 448, + "2": 4991, + "3": 1568, + "4": 714, + "5": 140, + "8": 504 + }, + "paid_calls": 25774, + "productive_fields": 3528, + "rank_surplus": 224, + "restored_native_centers": 56, + "schema": "native-all-fresh-full-idle-inventory/1", + "scope": "Exact finite all-fresh controller inventory. Native all-column closure is inherited; the raw rule requires the separate tensor strictification before the old strict compiler applies.", + "source_head": "da637c87c89482bc4c86be36bd0071b3d400dbed", + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/kappa-rebuild/complex/fresh-certificates/THREE-base-HELPER-BOUNDARIES.json.gz": "f90517e395bde58c72cacd5d3481c4ea31d459fe4535384ac16547ac40460555", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "research/kappa-rebuild/complex/full_identity_rebuild.py": "9af2ffbb0038c92e2a7d281081b0daaeadce75b11b566e5427845dc1af91e33d", + "research/kappa-rebuild/controller/P3-NATIVE-COVER.json.gz": "facfc6d6ecde151afb7e6a167776f3fdaac1c816e785a21a39f7f0bfd9140f3f", + "research/kappa-rebuild/controller/p3_native_cover.py": "fae71fcbbd20b9ee73b049cf6f43ea1d048217fb15feb6055a007e47da3363fe", + "research/kappa-rebuild/transfer-audit/p3_cover_audit.py": "a0fe9a26f77556e83b31b0c91fea909d6f3d8209d0f9f7ad4e5bc1375d33615e" + }, + "status": "PASS_ACTUAL_ARBITRARY_HELPERS_AND_COMPLETE_PHASE_CORRECT_IDLE_JOBS", + "targets": { + "25": 448, + "5": 196, + "57": 224, + "6": 126, + "7": 392, + "8": 651, + "9": 1491 + }, + "whole_idle_profile": { + "16": 448, + "8": 448 + } + }, + "local_helper_profile": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "local_paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "local_replays": { + "backward": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + }, + "forward": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + }, + "retimed_artifact_sha256": { + "CHANGES.json": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "NATIVE-RESULT.json.gz": "37d0848458b289eb50271c47adef6e74014ae30be6363d09394b2337b566b839", + "native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29" + }, + "retimed_native_receipt": { + "changed_entrances": 117, + "changed_exits": 42, + "changed_scalar_frames": 395, + "helpers": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "native": { + "backward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 6396, + "role": [ + "L", + 225 + ] + }, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158168, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + }, + "forward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 19099, + "role": [ + "L", + 224 + ] + }, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290, + "real_scalar_allowance": 158120, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5290 + } + } + }, + "new_physical_edges_and_boundaries": [ + { + "new": 1, + "old": 0, + "rank": 9, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 139, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 8, + 17, + 33, + 64, + 3, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 65, + 33, + 2, + 100, + 104, + 16, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 108, + 0, + 109, + 109, + 0, + 13, + 13, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 8, + 17, + 33, + 64, + 3, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 65, + 33, + 2, + 100, + 104, + 16, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 108, + 0, + 109, + 109, + 0, + 13, + 13, + 0, + 0 + ] + } + } + } + }, + { + "new": 140, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 19, + 35, + 2, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 173, + 14, + 257, + 18, + 276, + 280, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 429, + 30, + 435, + 435, + 14, + 429, + 0, + 429, + 173 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 19, + 35, + 2, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 173, + 14, + 257, + 18, + 276, + 280, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 429, + 30, + 435, + 435, + 14, + 429, + 0, + 429, + 173 + ] + } + } + } + }, + { + "new": 141, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 35, + 65, + 136, + 258, + 3, + 1, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 6, + 19, + 384, + 264, + 97, + 34, + 68, + 392, + 112 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 115, + 53, + 70, + 136, + 115, + 19, + 21, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 35, + 65, + 136, + 258, + 3, + 1, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 6, + 19, + 384, + 264, + 97, + 34, + 68, + 392, + 112 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 115, + 53, + 70, + 136, + 115, + 19, + 21, + 136, + 0 + ] + } + } + } + }, + { + "new": 254, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 264, + 4, + 10, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 4, + 34, + 16, + 64, + 128, + 256, + 42 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 264, + 4, + 10, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 4, + 34, + 16, + 64, + 128, + 256, + 42 + ], + "offset": 245, + "phase": 2, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 255, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 133, + 260, + 1, + 7, + 8, + 3, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 3, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 15, + 16, + 64, + 128, + 256, + 45, + 42 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 34, + 39, + 38, + 40, + 0, + 15, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 133, + 260, + 1, + 7, + 8, + 3, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 3, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 15, + 16, + 64, + 128, + 256, + 45, + 42 + ], + "offset": 125, + "phase": 2, + "quadratic_rows": [ + 34, + 39, + 38, + 40, + 0, + 15, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 259, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 127, + "phase": 3, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 260, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 294, + 6, + 8, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 98, + 8, + 16, + 70, + 128, + 256, + 102 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 66, + 36, + 0, + 0, + 36, + 2, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 294, + 6, + 8, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 98, + 8, + 16, + 70, + 128, + 256, + 102 + ], + "offset": 219, + "phase": 2, + "quadratic_rows": [ + 0, + 66, + 36, + 0, + 0, + 36, + 2, + 0, + 0 + ] + } + } + } + }, + { + "new": 264, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 267, + 3, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 73, + 4, + 67, + 16, + 32, + 128, + 256, + 75 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 10, + 0, + 10, + 0, + 0, + 1, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 267, + 3, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 73, + 4, + 67, + 16, + 32, + 128, + 256, + 75 + ], + "offset": 245, + "phase": 2, + "quadratic_rows": [ + 65, + 10, + 0, + 10, + 0, + 0, + 1, + 0, + 0 + ] + } + } + } + }, + { + "new": 269, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 274, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 258, + 3, + 1, + 4, + 8, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 5, + 8, + 16, + 32, + 64, + 128, + 256, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 258, + 3, + 1, + 4, + 8, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 5, + 8, + 16, + 32, + 64, + 128, + 256, + 7 + ], + "offset": 252, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 272, + 8, + 20, + 4, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 48, + 8, + 36, + 64, + 128, + 256, + 52 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 272, + 8, + 20, + 4, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 48, + 8, + 36, + 64, + 128, + 256, + 52 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 318, + 3, + 5, + 9, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 126, + 125, + 123, + 119, + 111, + 95, + 128, + 256, + 127 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 318, + 3, + 5, + 9, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 126, + 125, + 123, + 119, + 111, + 95, + 128, + 256, + 127 + ], + "offset": 192, + "phase": 2, + "quadratic_rows": [ + 63, + 63, + 63, + 63, + 63, + 63, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 264, + 12, + 16, + 32, + 4, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 72, + 68, + 16, + 32, + 128, + 256, + 76 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 264, + 12, + 16, + 32, + 4, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 2, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 72, + 68, + 16, + 32, + 128, + 256, + 76 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 282, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 132, + 262, + 2, + 7, + 3, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 2, + 15, + 32, + 64, + 128, + 256, + 25, + 30 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 23, + 17, + 21, + 24, + 15, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 132, + 262, + 2, + 7, + 3, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 2, + 15, + 32, + 64, + 128, + 256, + 25, + 30 + ], + "offset": 126, + "phase": 2, + "quadratic_rows": [ + 23, + 17, + 21, + 24, + 15, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 283, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 139, + 3, + 264, + 4, + 9, + 1, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 2, + 3, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 8, + 23, + 64, + 128, + 256, + 51, + 52 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 21, + 38, + 39, + 0, + 49, + 22, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 139, + 3, + 264, + 4, + 9, + 1, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 8, + 23, + 64, + 128, + 256, + 51, + 52 + ], + "offset": 125, + "phase": 2, + "quadratic_rows": [ + 21, + 38, + 39, + 0, + 49, + 22, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 284, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 285, + "old": 0, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 290, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 132, + 266, + 12, + 2, + 16, + 6, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 68, + 32, + 128, + 256, + 82, + 76 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 0, + 26, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 132, + 266, + 12, + 2, + 16, + 6, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 2, + 0, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 68, + 32, + 128, + 256, + 82, + 76 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 0, + 26, + 0, + 0 + ] + } + } + } + }, + { + "new": 291, + "old": 0, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 144, + 270, + 6, + 10, + 2, + 17, + 1, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 2, + 12, + 12, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 0, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 96, + 2, + 26, + 22, + 65, + 128, + 256, + 97, + 30 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 12, + 12, + 2, + 33, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 144, + 270, + 6, + 10, + 2, + 17, + 1, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 2, + 12, + 12, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 0, + 3, + 0, + 2, + 2 + ], + "matrix_rows": [ + 96, + 2, + 26, + 22, + 65, + 128, + 256, + 97, + 30 + ], + "offset": 98, + "phase": 3, + "quadratic_rows": [ + 33, + 18, + 12, + 12, + 2, + 33, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 293, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 67, + 131, + 2, + 1, + 264, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 3, + 0 + ], + "matrix_rows": [ + 13, + 14, + 384, + 320, + 33, + 18, + 52, + 56, + 448 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 45, + 30, + 51, + 51, + 14, + 13, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 67, + 131, + 2, + 1, + 264, + 12, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 3, + 0 + ], + "matrix_rows": [ + 13, + 14, + 384, + 320, + 33, + 18, + 52, + 56, + 448 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 45, + 30, + 51, + 51, + 14, + 13, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 294, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 45, + 67, + 10, + 4, + 135, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 10, + 12, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 1, + 1, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 509, + 507, + 258, + 321, + 266, + 276, + 288, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 326, + 15, + 275, + 250, + 252, + 248, + 249, + 248, + 5 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 45, + 67, + 10, + 4, + 135, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 10, + 12, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 1, + 1, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 510, + 509, + 507, + 258, + 321, + 266, + 276, + 288, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 326, + 15, + 275, + 250, + 252, + 248, + 249, + 248, + 5 + ] + } + } + } + }, + { + "new": 296, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 60, + 6, + 82, + 8, + 138, + 16, + 282, + 26 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 28, + 30, + 22, + 14, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 1, + 252, + 258, + 246, + 222, + 262, + 280, + 352, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 46, + 470, + 306, + 476, + 330, + 500, + 468, + 252 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 60, + 6, + 82, + 8, + 138, + 16, + 282, + 26 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 28, + 30, + 22, + 14, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 3, + 2, + 3, + 1, + 0 + ], + "matrix_rows": [ + 1, + 252, + 258, + 246, + 222, + 262, + 280, + 352, + 384 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 0, + 46, + 470, + 306, + 476, + 330, + 500, + 468, + 252 + ] + } + } + } + }, + { + "new": 298, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 37, + 68, + 7, + 130, + 1, + 272, + 3, + 24, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 24, + 24, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 3, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 1, + 28, + 23, + 384, + 288, + 85, + 70, + 88, + 416 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 66, + 83, + 28, + 76, + 22, + 160, + 11, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 37, + 68, + 7, + 130, + 1, + 272, + 3, + 24, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 24, + 24, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 1, + 28, + 23, + 384, + 288, + 85, + 70, + 88, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 66, + 83, + 28, + 76, + 22, + 160, + 11, + 160, + 0 + ] + } + } + } + }, + { + "new": 299, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 1, + 3, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 301, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 35, + 69, + 128, + 270, + 3, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 390, + 19, + 21, + 145, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 35, + 69, + 128, + 270, + 3, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 2, + 2, + 0, + 1, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 390, + 19, + 21, + 145, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ] + } + } + } + }, + { + "new": 303, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 1, + 2, + 3, + 3, + 1, + 2 + ], + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ] + } + } + } + }, + { + "new": 304, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 45, + 70, + 141, + 6, + 256, + 3, + 10, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 4, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 389, + 14, + 138, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 462, + 351, + 411, + 351, + 14, + 0, + 11, + 389, + 143 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 45, + 70, + 141, + 6, + 256, + 3, + 10, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 10, + 4, + 2, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 1, + 2, + 0, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 389, + 14, + 138, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 462, + 351, + 411, + 351, + 14, + 0, + 11, + 389, + 143 + ] + } + } + } + }, + { + "new": 305, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ] + } + } + } + }, + { + "new": 307, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 46, + 78, + 131, + 3, + 261, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 424, + 14, + 38, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 16, + 46, + 78, + 131, + 3, + 261, + 5, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 424, + 14, + 38, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ] + } + } + } + }, + { + "new": 308, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 15, + "phase": 0, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ] + } + } + } + }, + { + "new": 309, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 46, + 64, + 131, + 261, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 2, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 408, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 379, + 379, + 0, + 467, + 427, + 19, + 11, + 408, + 155 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 30, + 46, + 64, + 131, + 261, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 408, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 8, + "phase": 1, + "quadratic_rows": [ + 379, + 379, + 0, + 467, + 427, + 19, + 11, + 408, + 155 + ] + } + } + } + }, + { + "new": 314, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 60, + 2, + 5, + 81, + 137, + 8, + 16, + 281, + 25 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 0, + 29, + 21, + 13, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 2, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 252, + 2, + 257, + 245, + 237, + 261, + 296, + 336, + 384 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 29, + 0, + 485, + 305, + 329, + 492, + 500, + 484, + 252 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 60, + 2, + 5, + 81, + 137, + 8, + 16, + 281, + 25 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 0, + 29, + 21, + 13, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 3, + 3, + 1, + 0 + ], + "matrix_rows": [ + 252, + 2, + 257, + 245, + 237, + 261, + 296, + 336, + 384 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 29, + 0, + 485, + 305, + 329, + 492, + 500, + 484, + 252 + ] + } + } + } + }, + { + "new": 318, + "old": 0, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 20, + 38, + 7, + 65, + 136, + 2, + 3, + 8, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 1, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 3, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 44, + 2, + 39, + 16, + 69, + 102, + 104, + 144, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 99, + 65, + 44, + 76, + 144, + 37, + 11, + 16, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 20, + 38, + 7, + 65, + 136, + 2, + 3, + 8, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 1, + 8, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 1, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 44, + 2, + 39, + 16, + 69, + 102, + 104, + 144, + 256 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 99, + 65, + 44, + 76, + 144, + 37, + 11, + 16, + 0 + ] + } + } + } + }, + { + "new": 324, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 34, + 65, + 144, + 264, + 9, + 10, + 11, + 20, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 20, + 8, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 1, + 3, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 50, + 49, + 384, + 8, + 260, + 81, + 98, + 388, + 120 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 97, + 82, + 132, + 120, + 58, + 57, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 34, + 65, + 144, + 264, + 9, + 10, + 11, + 20, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 20, + 8, + 20, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 50, + 49, + 384, + 8, + 260, + 81, + 98, + 388, + 120 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 97, + 82, + 132, + 120, + 58, + 57, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 335, + "old": 0, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 48, + 68, + 130, + 264, + 14, + 10, + 12, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 4, + 2, + 8, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 1, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 100, + 98, + 8, + 257, + 385, + 50, + 84, + 120 + ], + "offset": 6, + "phase": 1, + "quadratic_rows": [ + 129, + 82, + 52, + 120, + 14, + 108, + 106, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 48, + 68, + 130, + 264, + 14, + 10, + 12, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 17, + 4, + 2, + 8, + 17, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 0 + ], + "matrix_rows": [ + 384, + 100, + 98, + 8, + 257, + 385, + 50, + 84, + 120 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 129, + 82, + 52, + 120, + 14, + 108, + 106, + 129, + 0 + ] + } + } + } + }, + { + "new": 340, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 1, + 3, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 24, + 13, + 49, + 2, + 52, + 40, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 61, + 0, + 61, + 53, + 13, + 13, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 1, + 3, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 24, + 13, + 49, + 2, + 52, + 40, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 61, + 0, + 61, + 53, + 13, + 13, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 341, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 18, + 3, + 32, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 43, + 5, + 9, + 42, + 36, + 16, + 64, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 38, + 3, + 37, + 0, + 0, + 5, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 18, + 3, + 32, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 43, + 5, + 9, + 42, + 36, + 16, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 38, + 3, + 37, + 0, + 0, + 5, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 351, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 1, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 273, + 290, + 52, + 264, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 38, + 21, + 51, + 504, + 462, + 461, + 504, + 504, + 248 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 1, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 273, + 290, + 52, + 264, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 38, + 21, + 51, + 504, + 462, + 461, + 504, + 504, + 248 + ] + } + } + } + }, + { + "new": 352, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 3, + 65, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 3, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 24, + 11, + 448, + 41, + 42, + 4, + 48, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 35, + 35, + 0, + 24, + 56, + 19, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 3, + 65, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 1, + 2, + 3, + 3, + 2 + ], + "matrix_rows": [ + 24, + 11, + 448, + 41, + 42, + 4, + 48, + 320, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 35, + 35, + 0, + 24, + 56, + 19, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 353, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 1, + 1, + 2 + ], + "matrix_rows": [ + 40, + 14, + 448, + 1, + 50, + 52, + 24, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 62, + 62, + 54, + 14, + 14, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 1, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 40, + 14, + 448, + 1, + 50, + 52, + 24, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 62, + 62, + 54, + 14, + 14, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 354, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 7, + 1, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 6, + 485, + 283, + 25, + 266, + 276, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 230, + 21, + 243, + 0, + 6, + 229, + 229, + 229, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 7, + 1, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 6, + 485, + 283, + 25, + 266, + 276, + 288, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 230, + 21, + 243, + 0, + 6, + 229, + 229, + 229, + 0 + ] + } + } + } + }, + { + "new": 355, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 65, + 6, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 3, + 3, + 1 + ], + "matrix_rows": [ + 235, + 451, + 229, + 257, + 306, + 52, + 280, + 320, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 205, + 24, + 213, + 507, + 14, + 296, + 205, + 205, + 296 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 65, + 6, + 2, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 1, + 2, + 3, + 1, + 1, + 3 + ], + "matrix_rows": [ + 235, + 451, + 229, + 257, + 306, + 52, + 280, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 205, + 24, + 213, + 507, + 14, + 296, + 205, + 205, + 296 + ] + } + } + } + }, + { + "new": 356, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 3, + 1, + 64, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 0, + 1, + 1, + 2 + ], + "matrix_rows": [ + 6, + 27, + 448, + 25, + 10, + 20, + 32, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 6, + 0, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 3, + 1, + 64, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 6, + 27, + 448, + 25, + 10, + 20, + 32, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 6, + 0, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 357, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 64, + 1, + 2, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 3, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 53, + 54, + 448, + 17, + 34, + 52, + 8, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 37, + 22, + 51, + 0, + 54, + 53, + 192, + 192, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 64, + 1, + 2, + 132, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 1, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 53, + 54, + 448, + 17, + 34, + 52, + 8, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 37, + 22, + 51, + 0, + 54, + 53, + 192, + 192, + 0 + ] + } + } + } + }, + { + "new": 358, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 7, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 1, + 3, + 2, + 3, + 3, + 1 + ], + "matrix_rows": [ + 453, + 280, + 267, + 297, + 42, + 260, + 304, + 320, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 486, + 291, + 197, + 280, + 56, + 19, + 197, + 197, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 7, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 3, + 1, + 2, + 1, + 1, + 3 + ], + "matrix_rows": [ + 453, + 280, + 267, + 297, + 42, + 260, + 304, + 320, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 486, + 291, + 197, + 280, + 56, + 19, + 197, + 197, + 267 + ] + } + } + } + }, + { + "new": 360, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 64, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 136, + 13, + 161, + 2, + 164, + 40, + 16, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 173, + 0, + 173, + 165, + 0, + 13, + 0, + 13, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 35, + 64, + 3, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 136, + 13, + 161, + 2, + 164, + 40, + 16, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 173, + 0, + 173, + 165, + 0, + 13, + 0, + 13, + 0 + ] + } + } + } + }, + { + "new": 361, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 13, + 208, + 33, + 2, + 36, + 40, + 144, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 80, + 13, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 13, + 208, + 33, + 2, + 36, + 40, + 144, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 80, + 13, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new": 371, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 133, + 385, + 2, + 388, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 261, + 0, + 261, + 120, + 120, + 120, + 56, + 384, + 133 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 133, + 385, + 2, + 388, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 261, + 0, + 261, + 120, + 120, + 120, + 56, + 384, + 133 + ] + } + } + } + }, + { + "new": 372, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 131, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 0, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 440, + 56, + 168, + 1, + 2, + 4, + 456, + 80, + 480 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 232, + 448, + 232, + 56, + 440, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 131, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 0, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 440, + 56, + 168, + 1, + 2, + 4, + 456, + 80, + 480 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 232, + 448, + 232, + 56, + 440, + 144 + ] + } + } + } + }, + { + "new": 373, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 272, + 168, + 21, + 321, + 2, + 324, + 136, + 80, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 341, + 0, + 341, + 40, + 325, + 40, + 21, + 0, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 272, + 168, + 21, + 321, + 2, + 324, + 136, + 80, + 160 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 341, + 0, + 341, + 40, + 325, + 40, + 21, + 0, + 21 + ] + } + } + } + }, + { + "new": 374, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 144, + 296, + 21, + 193, + 2, + 196, + 264, + 80, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 213, + 0, + 213, + 40, + 197, + 40, + 21, + 21, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 144, + 296, + 21, + 193, + 2, + 196, + 264, + 80, + 288 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 0, + 213, + 40, + 197, + 40, + 21, + 21, + 0 + ] + } + } + } + }, + { + "new": 375, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 168, + 65, + 2, + 68, + 392, + 80, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 0, + 85, + 296, + 85, + 296, + 21, + 384, + 168 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 1, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 168, + 65, + 2, + 68, + 392, + 80, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 0, + 85, + 296, + 85, + 296, + 21, + 384, + 168 + ] + } + } + } + }, + { + "new": 376, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 39, + 64, + 131, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 405, + 21, + 133, + 449, + 2, + 452, + 8, + 80, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 197, + 0, + 197, + 0, + 448, + 0, + 21, + 405, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 39, + 64, + 131, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 405, + 21, + 133, + 449, + 2, + 452, + 8, + 80, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 197, + 0, + 197, + 0, + 448, + 0, + 21, + 405, + 144 + ] + } + } + } + }, + { + "new": 377, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 133, + 272, + 56, + 129, + 2, + 132, + 328, + 80, + 352 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 5, + 0, + 5, + 376, + 360, + 376, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 133, + 272, + 56, + 129, + 2, + 132, + 328, + 80, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 376, + 360, + 376, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 378, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 261, + 144, + 56, + 257, + 2, + 260, + 200, + 80, + 224 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 5, + 0, + 5, + 248, + 232, + 248, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 134, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 261, + 144, + 56, + 257, + 2, + 260, + 200, + 80, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 5, + 0, + 5, + 248, + 232, + 248, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 380, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 34, + 67, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 470, + 475, + 289, + 258, + 36, + 296, + 272, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 251, + 269, + 502, + 251, + 269, + 13, + 269, + 269, + 470 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 34, + 67, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 3, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 470, + 475, + 289, + 258, + 36, + 296, + 272, + 320, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 251, + 269, + 502, + 251, + 269, + 13, + 269, + 269, + 470 + ] + } + } + } + }, + { + "new": 381, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 13, + 400, + 33, + 2, + 36, + 40, + 272, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 144, + 13, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 8, + 17, + 33, + 66, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 13, + 400, + 33, + 2, + 36, + 40, + 272, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 45, + 0, + 45, + 45, + 144, + 13, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 391, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 6, + 67, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 2, + 2, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 438, + 437, + 334, + 321, + 266, + 76, + 272, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 245, + 496, + 261, + 0, + 259, + 259, + 3, + 259, + 438 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 6, + 67, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 438, + 437, + 334, + 321, + 266, + 76, + 272, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 245, + 496, + 261, + 0, + 259, + 259, + 3, + 259, + 438 + ] + } + } + } + }, + { + "new": 392, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 11, + 400, + 97, + 98, + 4, + 72, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 107, + 107, + 0, + 99, + 144, + 11, + 11, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 11, + 400, + 97, + 98, + 4, + 72, + 272, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 107, + 107, + 0, + 99, + 144, + 11, + 11, + 144, + 0 + ] + } + } + } + }, + { + "new": 393, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 290, + 324, + 264, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 509, + 472, + 37, + 99, + 99, + 413, + 411, + 99, + 355 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 3, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 290, + 324, + 264, + 272, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 509, + 472, + 37, + 99, + 99, + 413, + 411, + 99, + 355 + ] + } + } + } + }, + { + "new": 394, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 3, + 68, + 129, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 14, + 400, + 1, + 74, + 76, + 272, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 40, + 144, + 104, + 38, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 3, + 68, + 129, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 14, + 400, + 1, + 74, + 76, + 272, + 96, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 40, + 144, + 104, + 38, + 144, + 0 + ] + } + } + } + }, + { + "new": 395, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 36, + 6, + 67, + 129, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 187, + 403, + 270, + 257, + 330, + 76, + 272, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 40, + 366, + 326, + 187, + 40, + 507, + 38, + 40, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 36, + 6, + 67, + 129, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 2, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 187, + 403, + 270, + 257, + 330, + 76, + 272, + 352, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 40, + 366, + 326, + 187, + 40, + 507, + 38, + 40, + 38 + ] + } + } + } + }, + { + "new": 396, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 64, + 132, + 3, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 0, + 1, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 99, + 400, + 97, + 34, + 68, + 8, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 69, + 70, + 0, + 144, + 0, + 6, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 64, + 132, + 3, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 99, + 400, + 97, + 34, + 68, + 8, + 272, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 69, + 70, + 0, + 144, + 0, + 6, + 144, + 0 + ] + } + } + } + }, + { + "new": 397, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 65, + 134, + 3, + 7, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 2, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 296, + 406, + 181, + 97, + 354, + 260, + 328, + 272, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 213, + 246, + 35, + 104, + 35, + 190, + 11, + 35, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 65, + 134, + 3, + 7, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 1, + 0, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 296, + 406, + 181, + 97, + 354, + 260, + 328, + 272, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 213, + 246, + 35, + 104, + 35, + 190, + 11, + 35, + 0 + ] + } + } + } + }, + { + "new": 398, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 2, + 68, + 128, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 3, + 1, + 0, + 3, + 1, + 2 + ], + "matrix_rows": [ + 77, + 78, + 400, + 65, + 10, + 76, + 272, + 32, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 13, + 70, + 75, + 77, + 144, + 0, + 78, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 2, + 68, + 128, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 3, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 77, + 78, + 400, + 65, + 10, + 76, + 272, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 13, + 70, + 75, + 77, + 144, + 0, + 78, + 144, + 0 + ] + } + } + } + }, + { + "new": 399, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 19, + 97, + 34, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 115, + 113, + 0, + 0, + 115, + 19, + 19, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 19, + 97, + 34, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 115, + 113, + 0, + 0, + 115, + 19, + 19, + 0, + 0 + ] + } + } + } + }, + { + "new": 400, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 19, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 3, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 476, + 463, + 289, + 290, + 260, + 264, + 48, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 239, + 239, + 275, + 275, + 508, + 19, + 275, + 275, + 476 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 19, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 1, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 476, + 463, + 289, + 290, + 260, + 264, + 48, + 320, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 239, + 239, + 275, + 275, + 508, + 19, + 275, + 275, + 476 + ] + } + } + } + }, + { + "new": 401, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 35, + 2, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 0, + 0, + 0 + ], + "matrix_rows": [ + 57, + 58, + 33, + 18, + 4, + 56, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 25, + 42, + 0, + 51, + 57, + 58, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 35, + 2, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 57, + 58, + 33, + 18, + 4, + 56, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 25, + 42, + 0, + 51, + 57, + 58, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 404, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 388, + 33, + 34, + 260, + 8, + 48, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 132, + 0, + 51, + 19, + 0, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 388, + 33, + 34, + 260, + 8, + 48, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 132, + 0, + 51, + 19, + 0, + 132, + 0 + ] + } + } + } + }, + { + "new": 411, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 69, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 40, + 388, + 90, + 1, + 82, + 260, + 24, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 10, + 132, + 98, + 0, + 104, + 40, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 69, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 40, + 388, + 90, + 1, + 82, + 260, + 24, + 96, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 0, + 10, + 132, + 98, + 0, + 104, + 40, + 132, + 0 + ] + } + } + } + }, + { + "new": 412, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 38, + 67, + 135, + 5, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 2, + 0, + 1, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 24, + 254, + 407, + 97, + 258, + 260, + 296, + 336, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 503, + 105, + 105, + 454, + 49, + 407, + 399, + 105, + 361 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 38, + 67, + 135, + 5, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 24, + 254, + 407, + 97, + 258, + 260, + 296, + 336, + 384 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 503, + 105, + 105, + 454, + 49, + 407, + 399, + 105, + 361 + ] + } + } + } + }, + { + "new": 413, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 37, + 68, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 1, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 182, + 273, + 189, + 321, + 82, + 260, + 344, + 288, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 236, + 230, + 267, + 493, + 0, + 267, + 11, + 267, + 428 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 37, + 68, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 182, + 273, + 189, + 321, + 82, + 260, + 344, + 288, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 236, + 230, + 267, + 493, + 0, + 267, + 11, + 267, + 428 + ] + } + } + } + }, + { + "new": 414, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 36, + 66, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 34, + 11, + 388, + 97, + 66, + 260, + 104, + 16, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 107, + 105, + 132, + 107, + 0, + 11, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 36, + 66, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 1, + 0, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 34, + 11, + 388, + 97, + 66, + 260, + 104, + 16, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 107, + 105, + 132, + 107, + 0, + 11, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 415, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 11, + 17, + 388, + 65, + 82, + 260, + 88, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 90, + 91, + 132, + 91, + 11, + 0, + 11, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 0, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 17, + 388, + 65, + 82, + 260, + 88, + 32, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 90, + 91, + 132, + 91, + 11, + 0, + 11, + 132, + 0 + ] + } + } + } + }, + { + "new": 416, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 68, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 1, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 290, + 181, + 190, + 97, + 322, + 260, + 360, + 272, + 384 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 213, + 220, + 267, + 478, + 267, + 0, + 11, + 267, + 412 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 38, + 68, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 290, + 181, + 190, + 97, + 322, + 260, + 360, + 272, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 220, + 267, + 478, + 267, + 0, + 11, + 267, + 412 + ] + } + } + } + }, + { + "new": 417, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 37, + 67, + 6, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 2, + 0, + 2, + 1, + 2, + 2, + 3 + ], + "matrix_rows": [ + 253, + 40, + 423, + 257, + 82, + 260, + 280, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 90, + 503, + 90, + 453, + 423, + 50, + 399, + 90, + 346 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 37, + 67, + 6, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 1 + ], + "matrix_rows": [ + 253, + 40, + 423, + 257, + 82, + 260, + 280, + 352, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 90, + 503, + 90, + 453, + 423, + 50, + 399, + 90, + 346 + ] + } + } + } + }, + { + "new": 418, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 69, + 129, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 388, + 105, + 97, + 2, + 260, + 40, + 80, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 9, + 0, + 132, + 81, + 88, + 0, + 24, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 69, + 129, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 388, + 105, + 97, + 2, + 260, + 40, + 80, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 9, + 0, + 132, + 81, + 88, + 0, + 24, + 132, + 0 + ] + } + } + } + }, + { + "new": 424, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 2, + 0 + ], + "matrix_rows": [ + 19, + 196, + 33, + 34, + 132, + 8, + 48, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 18, + 32, + 65, + 1, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 19, + 196, + 33, + 34, + 132, + 8, + 48, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 68, + 0, + 51, + 19, + 68, + 0, + 0 + ] + } + } + } + }, + { + "new": 431, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 260, + 162, + 21, + 321, + 130, + 68, + 8, + 336, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 341, + 34, + 337, + 0, + 341, + 34, + 21, + 0, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 0, + 1, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 260, + 162, + 21, + 321, + 130, + 68, + 8, + 336, + 160 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 341, + 34, + 337, + 0, + 341, + 34, + 21, + 0, + 21 + ] + } + } + } + }, + { + "new": 432, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 132, + 290, + 21, + 193, + 258, + 68, + 8, + 208, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 213, + 34, + 209, + 0, + 213, + 34, + 21, + 21, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 37, + 64, + 132, + 258, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 0, + 1, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 132, + 290, + 21, + 193, + 258, + 68, + 8, + 208, + 288 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 213, + 34, + 209, + 0, + 213, + 34, + 21, + 21, + 0 + ] + } + } + } + }, + { + "new": 433, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 64, + 128, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 422, + 38, + 162, + 1, + 450, + 68, + 8, + 16, + 480 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 226, + 448, + 0, + 0, + 226, + 38, + 422, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 64, + 128, + 263, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 422, + 38, + 162, + 1, + 450, + 68, + 8, + 16, + 480 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 226, + 448, + 0, + 0, + 226, + 38, + 422, + 132 + ] + } + } + } + }, + { + "new": 434, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 38, + 145, + 385, + 66, + 68, + 8, + 400, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 273, + 102, + 102, + 0, + 273, + 102, + 38, + 384, + 145 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 38, + 145, + 385, + 66, + 68, + 8, + 400, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 273, + 102, + 102, + 0, + 273, + 102, + 38, + 384, + 145 + ] + } + } + } + }, + { + "new": 435, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 145, + 260, + 38, + 129, + 322, + 68, + 8, + 144, + 352 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 17, + 358, + 354, + 0, + 17, + 358, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 0, + 3, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 145, + 260, + 38, + 129, + 322, + 68, + 8, + 144, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 358, + 354, + 0, + 17, + 358, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 436, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 273, + 132, + 38, + 257, + 194, + 68, + 8, + 272, + 224 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 17, + 230, + 226, + 0, + 17, + 230, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 64, + 129, + 260, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 0, + 3, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 273, + 132, + 38, + 257, + 194, + 68, + 8, + 272, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 230, + 226, + 0, + 17, + 230, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 437, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 35, + 64, + 135, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 405, + 21, + 145, + 449, + 2, + 68, + 8, + 464, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 209, + 0, + 448, + 0, + 209, + 0, + 21, + 405, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 16, + 35, + 64, + 135, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 405, + 21, + 145, + 449, + 2, + 68, + 8, + 464, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 209, + 0, + 448, + 0, + 209, + 0, + 21, + 405, + 132 + ] + } + } + } + }, + { + "new": 438, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 64, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 162, + 65, + 386, + 68, + 8, + 80, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 290, + 85, + 0, + 85, + 290, + 21, + 384, + 162 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 64, + 129, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 0, + 1, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 162, + 65, + 386, + 68, + 8, + 80, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 290, + 85, + 0, + 85, + 290, + 21, + 384, + 162 + ] + } + } + } + }, + { + "new": 439, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 385, + 14, + 257, + 18, + 20, + 24, + 32, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 129, + 30, + 30, + 30, + 14, + 0, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 14, + 257, + 18, + 20, + 24, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 30, + 30, + 30, + 14, + 0, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 440, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 11, + 17, + 33, + 3, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 34, + 1, + 18, + 52, + 56, + 64, + 128, + 256 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 0, + 60, + 62, + 62, + 14, + 14, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 11, + 17, + 33, + 3, + 2, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 34, + 1, + 18, + 52, + 56, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 60, + 62, + 62, + 14, + 14, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 441, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 487, + 489, + 257, + 274, + 276, + 24, + 288, + 320, + 384 + ], + "offset": 2, + "phase": 3, + "quadratic_rows": [ + 270, + 247, + 247, + 505, + 14, + 270, + 270, + 270, + 489 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 487, + 489, + 257, + 274, + 276, + 24, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 270, + 247, + 247, + 505, + 14, + 270, + 270, + 270, + 489 + ] + } + } + } + }, + { + "new": 444, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 68, + 14, + 1, + 82, + 20, + 88, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 94, + 90, + 94, + 14, + 0, + 14, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 68, + 14, + 1, + 82, + 20, + 88, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 94, + 90, + 94, + 14, + 0, + 14, + 0, + 0 + ] + } + } + } + }, + { + "new": 455, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 21, + 35, + 65, + 135, + 4, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 1, + 3, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 415, + 501, + 499, + 257, + 322, + 292, + 360, + 272, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 153, + 300, + 330, + 255, + 153, + 106, + 108, + 153, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 21, + 35, + 65, + 135, + 4, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 1, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 415, + 501, + 499, + 257, + 322, + 292, + 360, + 272, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 153, + 300, + 330, + 255, + 153, + 106, + 108, + 153, + 6 + ] + } + } + } + }, + { + "new": 456, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 134, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 2, + 3, + 3, + 1, + 2 + ], + "matrix_rows": [ + 385, + 114, + 116, + 257, + 34, + 68, + 8, + 112, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 129, + 82, + 52, + 0, + 102, + 116, + 114, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 134, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 385, + 114, + 116, + 257, + 34, + 68, + 8, + 112, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 129, + 82, + 52, + 0, + 102, + 116, + 114, + 129, + 0 + ] + } + } + } + }, + { + "new": 457, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 36, + 70, + 130, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 385, + 24, + 108, + 257, + 2, + 100, + 40, + 80, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 129, + 0, + 12, + 84, + 88, + 0, + 24, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 36, + 70, + 130, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 385, + 24, + 108, + 257, + 2, + 100, + 40, + 80, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 129, + 0, + 12, + 84, + 88, + 0, + 24, + 129, + 0 + ] + } + } + } + }, + { + "new": 458, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 39, + 65, + 133, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 415, + 391, + 501, + 257, + 354, + 260, + 328, + 304, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 237, + 376, + 237, + 223, + 330, + 391, + 415, + 237, + 114 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 39, + 65, + 133, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 415, + 391, + 501, + 257, + 354, + 260, + 328, + 304, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 237, + 376, + 237, + 223, + 330, + 391, + 415, + 237, + 114 + ] + } + } + } + }, + { + "new": 460, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 2, + 0 + ], + "matrix_rows": [ + 193, + 14, + 129, + 18, + 20, + 24, + 32, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 65, + 30, + 30, + 30, + 14, + 0, + 65, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 18, + 34, + 2, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 14, + 129, + 18, + 20, + 24, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 30, + 30, + 30, + 14, + 0, + 65, + 0, + 0 + ] + } + } + } + }, + { + "new": 461, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 132, + 14, + 1, + 146, + 20, + 152, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 158, + 154, + 158, + 14, + 0, + 0, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 132, + 14, + 1, + 146, + 20, + 152, + 32, + 64, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 158, + 154, + 158, + 14, + 0, + 0, + 14, + 0 + ] + } + } + } + }, + { + "new": 464, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 260, + 14, + 1, + 274, + 20, + 280, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 286, + 282, + 286, + 14, + 0, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 19, + 34, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 260, + 14, + 1, + 274, + 20, + 280, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 286, + 282, + 286, + 14, + 0, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 475, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 11, + 129, + 276, + 65, + 194, + 260, + 200, + 272, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 202, + 203, + 20, + 203, + 20, + 0, + 11, + 11, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 11, + 129, + 276, + 65, + 194, + 260, + 200, + 272, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 202, + 203, + 20, + 203, + 20, + 0, + 11, + 11, + 0 + ] + } + } + } + }, + { + "new": 476, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 11, + 257, + 148, + 65, + 322, + 132, + 328, + 144, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 330, + 331, + 20, + 331, + 20, + 0, + 11, + 0, + 11 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 65, + 132, + 256, + 3, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 1, + 3, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 11, + 257, + 148, + 65, + 322, + 132, + 328, + 144, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 330, + 331, + 20, + 331, + 20, + 0, + 11, + 0, + 11 + ] + } + } + } + }, + { + "new": 477, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 256, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 21, + 384, + 138, + 65, + 386, + 68, + 392, + 80, + 32 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 85, + 266, + 85, + 266, + 85, + 0, + 21, + 384, + 138 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 256, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 1, + 3, + 1, + 0, + 2, + 3, + 0 + ], + "matrix_rows": [ + 21, + 384, + 138, + 65, + 386, + 68, + 392, + 80, + 32 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 85, + 266, + 85, + 266, + 85, + 0, + 21, + 384, + 138 + ] + } + } + } + }, + { + "new": 478, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 64, + 135, + 256, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 21, + 405, + 148, + 65, + 2, + 452, + 8, + 464, + 32 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 448, + 0, + 212, + 0, + 212, + 0, + 21, + 405, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 64, + 135, + 256, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 21, + 405, + 148, + 65, + 2, + 452, + 8, + 464, + 32 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 448, + 0, + 212, + 0, + 212, + 0, + 21, + 405, + 129 + ] + } + } + } + }, + { + "new": 479, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 72, + 14, + 1, + 82, + 84, + 24, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 0, + 14, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 72, + 14, + 1, + 82, + 84, + 24, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 0, + 14, + 0, + 0 + ] + } + } + } + }, + { + "new": 481, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 1, + 3, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 27, + 25, + 18, + 12, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 1, + 3, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 27, + 25, + 18, + 12, + 32, + 64, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 484, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 14, + 416, + 1, + 18, + 20, + 24, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 160, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 14, + 416, + 1, + 18, + 20, + 24, + 288, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 160, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 491, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 64, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 0, + 2, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 83, + 5, + 416, + 17, + 82, + 68, + 8, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 70, + 3, + 69, + 0, + 0, + 160, + 5, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 64, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 2, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 83, + 5, + 416, + 17, + 82, + 68, + 8, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 70, + 3, + 69, + 0, + 0, + 160, + 5, + 160, + 0 + ] + } + } + } + }, + { + "new": 492, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 5, + 66, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 419, + 187, + 269, + 329, + 258, + 76, + 336, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 349, + 24, + 325, + 187, + 507, + 24, + 21, + 24, + 21 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 36, + 5, + 66, + 131, + 1, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 3, + 3, + 1, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 419, + 187, + 269, + 329, + 258, + 76, + 336, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 349, + 24, + 325, + 187, + 507, + 24, + 21, + 24, + 21 + ] + } + } + } + }, + { + "new": 493, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 66, + 3, + 133, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 421, + 280, + 182, + 337, + 82, + 260, + 328, + 288, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 245, + 230, + 19, + 88, + 189, + 19, + 11, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 66, + 3, + 133, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 1, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 421, + 280, + 182, + 337, + 82, + 260, + 328, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 245, + 230, + 19, + 88, + 189, + 19, + 11, + 19, + 0 + ] + } + } + } + }, + { + "new": 494, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 1, + 64, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 3, + 0, + 1, + 3, + 1, + 2 + ], + "matrix_rows": [ + 77, + 78, + 416, + 9, + 66, + 76, + 16, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 69, + 14, + 75, + 78, + 0, + 160, + 77, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 1, + 64, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 0, + 3, + 1, + 3, + 2 + ], + "matrix_rows": [ + 77, + 78, + 416, + 9, + 66, + 76, + 16, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 69, + 14, + 75, + 78, + 0, + 160, + 77, + 160, + 0 + ] + } + } + } + }, + { + "new": 495, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 1, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 11, + 416, + 81, + 82, + 4, + 72, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 91, + 91, + 0, + 83, + 11, + 160, + 11, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 1, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 0, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 11, + 416, + 81, + 82, + 4, + 72, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 91, + 91, + 0, + 83, + 11, + 160, + 11, + 160, + 0 + ] + } + } + } + }, + { + "new": 496, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 67, + 131, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 2, + 2, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 438, + 437, + 333, + 265, + 322, + 76, + 272, + 288, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 496, + 246, + 262, + 0, + 259, + 259, + 3, + 259, + 437 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 67, + 131, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 438, + 437, + 333, + 265, + 322, + 76, + 272, + 288, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 496, + 246, + 262, + 0, + 259, + 259, + 3, + 259, + 437 + ] + } + } + } + }, + { + "new": 497, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 3, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 430, + 5, + 253, + 273, + 82, + 324, + 264, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 488, + 510, + 22, + 83, + 430, + 83, + 427, + 83, + 339 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 3, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 430, + 5, + 253, + 273, + 82, + 324, + 264, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 488, + 510, + 22, + 83, + 430, + 83, + 427, + 83, + 339 + ] + } + } + } + }, + { + "new": 498, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 34, + 3, + 65, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 3, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 13, + 416, + 73, + 2, + 76, + 80, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 69, + 0, + 69, + 24, + 88, + 160, + 21, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 34, + 3, + 65, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 3, + 1, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 13, + 416, + 73, + 2, + 76, + 80, + 288, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 69, + 0, + 69, + 24, + 88, + 160, + 21, + 160, + 0 + ] + } + } + } + }, + { + "new": 500, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 264, + 14, + 1, + 274, + 276, + 24, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 0, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 35, + 3, + 64, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 264, + 14, + 1, + 274, + 276, + 24, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 0, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 501, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 14, + 352, + 1, + 18, + 20, + 24, + 288, + 320, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 256, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 14, + 352, + 1, + 18, + 20, + 24, + 288, + 320, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + } + } + }, + { + "new": 504, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 2, + 0 + ], + "matrix_rows": [ + 14, + 224, + 1, + 18, + 20, + 24, + 160, + 192, + 256 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 33, + 1, + 66, + 130, + 2, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 14, + 224, + 1, + 18, + 20, + 24, + 160, + 192, + 256 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 96, + 96, + 0, + 0 + ] + } + } + } + }, + { + "new": 511, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 134, + 288, + 56, + 1, + 130, + 132, + 328, + 336, + 96 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 376, + 376, + 344, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 134, + 288, + 56, + 1, + 130, + 132, + 328, + 336, + 96 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 376, + 376, + 344, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 512, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 262, + 160, + 56, + 1, + 258, + 260, + 200, + 208, + 96 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 248, + 248, + 216, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 262, + 6, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 262, + 160, + 56, + 1, + 258, + 260, + 200, + 208, + 96 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 248, + 248, + 216, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 513, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 64, + 128, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 422, + 38, + 134, + 1, + 450, + 452, + 8, + 16, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 448, + 38, + 422, + 160 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 64, + 128, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 422, + 38, + 134, + 1, + 450, + 452, + 8, + 16, + 96 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 448, + 38, + 422, + 160 + ] + } + } + } + }, + { + "new": 514, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 257, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 38, + 384, + 152, + 1, + 66, + 68, + 392, + 400, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 280, + 280, + 102, + 38, + 384, + 152 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 132, + 257, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 38, + 384, + 152, + 1, + 66, + 68, + 392, + 400, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 280, + 280, + 102, + 38, + 384, + 152 + ] + } + } + } + }, + { + "new": 515, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 288, + 152, + 38, + 1, + 322, + 324, + 136, + 144, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 358, + 358, + 24, + 24, + 326, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 288, + 152, + 38, + 1, + 322, + 324, + 136, + 144, + 96 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 358, + 358, + 24, + 24, + 326, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 516, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 160, + 280, + 38, + 1, + 194, + 196, + 264, + 272, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 230, + 230, + 24, + 24, + 198, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 261, + 5, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 3, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 160, + 280, + 38, + 1, + 194, + 196, + 264, + 272, + 96 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 230, + 230, + 24, + 24, + 198, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 517, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 135, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 1, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 440, + 56, + 152, + 1, + 2, + 4, + 456, + 464, + 96 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 216, + 216, + 448, + 56, + 440, + 160 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 71, + 135, + 259, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 3, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 440, + 56, + 152, + 1, + 2, + 4, + 456, + 464, + 96 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 216, + 216, + 448, + 56, + 440, + 160 + ] + } + } + } + }, + { + "new": 518, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 134, + 1, + 386, + 388, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 262, + 262, + 120, + 120, + 120, + 56, + 384, + 134 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 134, + 1, + 386, + 388, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 262, + 262, + 120, + 120, + 120, + 56, + 384, + 134 + ] + } + } + } + }, + { + "new": 519, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 392, + 33, + 34, + 4, + 264, + 48, + 64, + 384 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 51, + 51, + 0, + 136, + 51, + 19, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 392, + 33, + 34, + 4, + 264, + 48, + 64, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 136, + 51, + 19, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 520, + "old": 0, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 33, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 3, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 19, + 289, + 34, + 260, + 264, + 304, + 320, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 307, + 509, + 206, + 206, + 307, + 19, + 206, + 206, + 19 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 33, + 66, + 3, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 1, + 1, + 2, + 1, + 1, + 0 + ], + "matrix_rows": [ + 462, + 19, + 289, + 34, + 260, + 264, + 304, + 320, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 307, + 509, + 206, + 206, + 307, + 19, + 206, + 206, + 19 + ] + } + } + } + }, + { + "new": 531, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 68, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 3, + 1, + 2, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 83, + 5, + 392, + 65, + 82, + 20, + 264, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 22, + 3, + 21, + 136, + 5, + 0, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 34, + 68, + 2, + 128, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 83, + 5, + 392, + 65, + 82, + 20, + 264, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 22, + 3, + 21, + 136, + 5, + 0, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 532, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 34, + 70, + 131, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 304, + 190, + 171, + 97, + 258, + 356, + 264, + 336, + 384 + ], + "offset": 5, + "phase": 3, + "quadratic_rows": [ + 203, + 277, + 478, + 277, + 206, + 0, + 21, + 277, + 398 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 34, + 70, + 131, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 1, + 0, + 2, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 304, + 190, + 171, + 97, + 258, + 356, + 264, + 336, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 277, + 478, + 277, + 206, + 0, + 21, + 277, + 398 + ] + } + } + } + }, + { + "new": 533, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 65, + 6, + 131, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 5, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 1, + 2, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 189, + 304, + 278, + 257, + 82, + 340, + 264, + 352, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 445, + 326, + 251, + 445, + 397, + 205, + 38, + 445, + 155 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 37, + 65, + 6, + 131, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 5, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 1, + 0, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 189, + 304, + 278, + 257, + 82, + 340, + 264, + 352, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 445, + 326, + 251, + 445, + 397, + 205, + 38, + 445, + 155 + ] + } + } + } + }, + { + "new": 534, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 68, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 1, + 0, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 6, + 99, + 392, + 97, + 66, + 36, + 264, + 16, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 37, + 38, + 136, + 0, + 6, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 68, + 128, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 3, + 0, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 6, + 99, + 392, + 97, + 66, + 36, + 264, + 16, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 37, + 38, + 136, + 0, + 6, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 535, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 322, + 292, + 264, + 272, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 509, + 440, + 69, + 99, + 99, + 411, + 413, + 99, + 355 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 21, + 39, + 70, + 134, + 1, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 6, + 413, + 254, + 97, + 322, + 292, + 264, + 272, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 509, + 440, + 69, + 99, + 99, + 411, + 413, + 99, + 355 + ] + } + } + } + }, + { + "new": 536, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 48, + 392, + 22, + 1, + 82, + 84, + 264, + 96, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 136, + 48, + 112, + 38, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 36, + 66, + 5, + 129, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 48, + 392, + 22, + 1, + 82, + 84, + 264, + 96, + 384 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 70, + 70, + 136, + 48, + 112, + 38, + 136, + 0 + ] + } + } + } + }, + { + "new": 537, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 48, + 392, + 21, + 97, + 2, + 100, + 264, + 80, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 117, + 0, + 117, + 136, + 101, + 21, + 21, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 36, + 66, + 133, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 2, + 0, + 2, + 3, + 2 + ], + "matrix_rows": [ + 48, + 392, + 21, + 97, + 2, + 100, + 264, + 80, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 117, + 0, + 117, + 136, + 101, + 21, + 21, + 136, + 0 + ] + } + } + } + }, + { + "new": 538, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "matrix_rows": [ + 430, + 5, + 253, + 321, + 82, + 276, + 264, + 288, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 440, + 510, + 70, + 83, + 427, + 83, + 430, + 83, + 339 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 69, + 2, + 133, + 3, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 430, + 5, + 253, + 321, + 82, + 276, + 264, + 288, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 440, + 510, + 70, + 83, + 427, + 83, + 430, + 83, + 339 + ] + } + } + } + }, + { + "new": 551, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 131, + 56, + 264, + 129, + 130, + 4, + 72, + 336, + 352 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 368, + 376, + 376, + 56, + 0, + 56 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 131, + 56, + 264, + 129, + 130, + 4, + 72, + 336, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 368, + 376, + 376, + 56, + 0, + 56 + ] + } + } + } + }, + { + "new": 552, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 259, + 56, + 136, + 257, + 258, + 4, + 72, + 208, + 224 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 240, + 248, + 248, + 56, + 56, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 70, + 130, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 259, + 56, + 136, + 257, + 258, + 4, + 72, + 208, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 240, + 248, + 248, + 56, + 56, + 0 + ] + } + } + } + }, + { + "new": 553, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 67, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 395, + 11, + 131, + 449, + 450, + 4, + 72, + 16, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 195, + 195, + 0, + 448, + 0, + 0, + 11, + 395, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 67, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 395, + 11, + 131, + 449, + 450, + 4, + 72, + 16, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 195, + 195, + 0, + 448, + 0, + 0, + 11, + 395, + 136 + ] + } + } + } + }, + { + "new": 554, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 65, + 132, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 384, + 176, + 65, + 66, + 4, + 72, + 400, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 304, + 304, + 11, + 384, + 176 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 65, + 132, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 3, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 384, + 176, + 65, + 66, + 4, + 72, + 400, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 304, + 304, + 11, + 384, + 176 + ] + } + } + } + }, + { + "new": 555, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 136, + 11, + 304, + 193, + 194, + 4, + 72, + 272, + 288 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 203, + 203, + 0, + 195, + 48, + 48, + 11, + 11, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 136, + 11, + 304, + 193, + 194, + 4, + 72, + 272, + 288 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 203, + 0, + 195, + 48, + 48, + 11, + 11, + 0 + ] + } + } + } + }, + { + "new": 556, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 264, + 11, + 176, + 321, + 322, + 4, + 72, + 144, + 160 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 331, + 331, + 0, + 323, + 48, + 48, + 11, + 0, + 11 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 32, + 67, + 132, + 260, + 3, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 3, + 3, + 2, + 2, + 0 + ], + "matrix_rows": [ + 264, + 11, + 176, + 321, + 322, + 4, + 72, + 144, + 160 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 331, + 331, + 0, + 323, + 48, + 48, + 11, + 0, + 11 + ] + } + } + } + }, + { + "new": 557, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 384, + 56, + 131, + 385, + 386, + 4, + 72, + 80, + 96 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 120, + 120, + 120, + 56, + 384, + 131 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 130, + 258, + 2, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 1, + 1, + 1, + 2, + 3, + 0 + ], + "matrix_rows": [ + 384, + 56, + 131, + 385, + 386, + 4, + 72, + 80, + 96 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 120, + 120, + 120, + 56, + 384, + 131 + ] + } + } + } + }, + { + "new": 558, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 67, + 135, + 263, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 1, + 0 + ], + "matrix_rows": [ + 56, + 440, + 176, + 1, + 2, + 4, + 72, + 464, + 480 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 448, + 240, + 240, + 56, + 440, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 67, + 135, + 263, + 3, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 56, + 440, + 176, + 1, + 2, + 4, + 72, + 464, + 480 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 0, + 448, + 240, + 240, + 56, + 440, + 136 + ] + } + } + } + }, + { + "new": 571, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 0, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 11, + 384, + 164, + 65, + 66, + 388, + 72, + 16, + 416 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 292, + 75, + 0, + 292, + 11, + 384, + 164 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 11, + 384, + 164, + 65, + 66, + 388, + 72, + 16, + 416 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 292, + 75, + 0, + 292, + 11, + 384, + 164 + ] + } + } + } + }, + { + "new": 572, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 71, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 1, + 0, + 0, + 2, + 1, + 0 + ], + "matrix_rows": [ + 395, + 11, + 137, + 449, + 66, + 4, + 456, + 16, + 32 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 201, + 448, + 0, + 201, + 0, + 0, + 11, + 395, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 71, + 128, + 256, + 3, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 0, + 0, + 2, + 1, + 2 + ], + "matrix_rows": [ + 395, + 11, + 137, + 449, + 66, + 4, + 456, + 16, + 32 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 201, + 448, + 0, + 201, + 0, + 0, + 11, + 395, + 130 + ] + } + } + } + }, + { + "new": 573, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 137, + 38, + 258, + 129, + 66, + 324, + 136, + 16, + 352 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 9, + 356, + 358, + 9, + 0, + 358, + 38, + 0, + 38 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 1, + 2, + 2, + 0 + ], + "matrix_rows": [ + 137, + 38, + 258, + 129, + 66, + 324, + 136, + 16, + 352 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 356, + 358, + 9, + 0, + 358, + 38, + 0, + 38 + ] + } + } + } + }, + { + "new": 574, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 265, + 38, + 130, + 257, + 66, + 196, + 264, + 16, + 224 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 9, + 228, + 230, + 9, + 0, + 230, + 38, + 38, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 65, + 128, + 258, + 6, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 3, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 265, + 38, + 130, + 257, + 66, + 196, + 264, + 16, + 224 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 228, + 230, + 9, + 0, + 230, + 38, + 38, + 0 + ] + } + } + } + }, + { + "new": 591, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 35, + 65, + 6, + 133, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 2, + 2, + 2, + 3, + 0 + ], + "matrix_rows": [ + 431, + 391, + 499, + 257, + 258, + 340, + 280, + 352, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 219, + 219, + 376, + 191, + 431, + 284, + 391, + 219, + 116 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 35, + 65, + 6, + 133, + 2, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 431, + 391, + 499, + 257, + 258, + 340, + 280, + 352, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 219, + 219, + 376, + 191, + 431, + 284, + 391, + 219, + 116 + ] + } + } + } + }, + { + "new": 592, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 69, + 129, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 3, + 2, + 2, + 1, + 2 + ], + "matrix_rows": [ + 24, + 386, + 105, + 97, + 258, + 4, + 72, + 48, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 9, + 130, + 0, + 49, + 56, + 24, + 0, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 69, + 129, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 3, + 2, + 2, + 3, + 2 + ], + "matrix_rows": [ + 24, + 386, + 105, + 97, + 258, + 4, + 72, + 48, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 9, + 130, + 0, + 49, + 56, + 24, + 0, + 130, + 0 + ] + } + } + } + }, + { + "new": 593, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 35, + 70, + 130, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 1, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 292, + 190, + 171, + 97, + 258, + 324, + 264, + 368, + 384 + ], + "offset": 5, + "phase": 3, + "quadratic_rows": [ + 203, + 277, + 218, + 277, + 478, + 0, + 21, + 277, + 410 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 22, + 35, + 70, + 130, + 1, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 292, + 190, + 171, + 97, + 258, + 324, + 264, + 368, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 203, + 277, + 218, + 277, + 478, + 0, + 21, + 277, + 410 + ] + } + } + } + }, + { + "new": 594, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 69, + 4, + 128, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 1, + 2 + ], + "matrix_rows": [ + 89, + 386, + 92, + 65, + 258, + 20, + 88, + 32, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 25, + 130, + 76, + 85, + 89, + 0, + 92, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 69, + 4, + 128, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 1, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 89, + 386, + 92, + 65, + 258, + 20, + 88, + 32, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 25, + 130, + 76, + 85, + 89, + 0, + 92, + 130, + 0 + ] + } + } + } + }, + { + "new": 611, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 68, + 129, + 1, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 140, + 33, + 34, + 388, + 392, + 48, + 64 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 268, + 268, + 51, + 19, + 0, + 384, + 140 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 68, + 129, + 1, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 3, + 1, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 140, + 33, + 34, + 388, + 392, + 48, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 268, + 268, + 51, + 19, + 0, + 384, + 140 + ] + } + } + } + }, + { + "new": 612, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 32, + 64, + 135, + 3, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 19, + 403, + 146, + 33, + 418, + 4, + 8, + 432, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 416, + 178, + 0, + 0, + 178, + 19, + 0, + 403, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 23, + 32, + 64, + 135, + 3, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 19, + 403, + 146, + 33, + 418, + 4, + 8, + 432, + 64 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 416, + 178, + 0, + 0, + 178, + 19, + 0, + 403, + 129 + ] + } + } + } + }, + { + "new": 613, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 132, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 384, + 14, + 161, + 385, + 18, + 20, + 24, + 416, + 64 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 289, + 30, + 30, + 30, + 14, + 289, + 0, + 384, + 161 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 132, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 14, + 161, + 385, + 18, + 20, + 24, + 416, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 289, + 30, + 30, + 30, + 14, + 289, + 0, + 384, + 161 + ] + } + } + } + }, + { + "new": 614, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 3, + 128, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 14, + 398, + 140, + 1, + 18, + 404, + 408, + 32, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 0, + 400, + 156, + 156, + 14, + 0, + 0, + 398, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 3, + 128, + 256, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 14, + 398, + 140, + 1, + 18, + 404, + 408, + 32, + 64 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 0, + 400, + 156, + 156, + 14, + 0, + 0, + 398, + 130 + ] + } + } + } + }, + { + "new": 615, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 2, + 1, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 14, + 258, + 129, + 18, + 276, + 280, + 160, + 64 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 33, + 284, + 286, + 286, + 14, + 33, + 0, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 2, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 14, + 258, + 129, + 18, + 276, + 280, + 160, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 284, + 286, + 286, + 14, + 33, + 0, + 0, + 14 + ] + } + } + } + }, + { + "new": 616, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 1, + 2, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 289, + 14, + 130, + 257, + 18, + 148, + 152, + 288, + 64 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 33, + 156, + 158, + 158, + 14, + 33, + 0, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 22, + 34, + 66, + 6, + 129, + 256, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 2, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 289, + 14, + 130, + 257, + 18, + 148, + 152, + 288, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 156, + 158, + 158, + 14, + 33, + 0, + 14, + 0 + ] + } + } + } + }, + { + "new": 618, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 19, + 129, + 268, + 33, + 162, + 260, + 264, + 176, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 178, + 179, + 12, + 12, + 179, + 19, + 0, + 19, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 17, + 36, + 68, + 129, + 3, + 256, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 19, + 129, + 268, + 33, + 162, + 260, + 264, + 176, + 64 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 178, + 179, + 12, + 12, + 179, + 19, + 0, + 19, + 0 + ] + } + } + } + }, + { + "new": 626, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 1, + 1, + 1, + 0 + ], + "matrix_rows": [ + 6, + 485, + 285, + 25, + 274, + 268, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 224, + 278, + 502, + 0, + 6, + 229, + 229, + 229, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 39, + 5, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 6, + 485, + 285, + 25, + 274, + 268, + 288, + 320, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 224, + 278, + 502, + 0, + 6, + 229, + 229, + 229, + 6 + ] + } + } + } + }, + { + "new": 627, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 72, + 14, + 416, + 1, + 82, + 84, + 24, + 288, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 160, + 14, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 72, + 14, + 416, + 1, + 82, + 84, + 24, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 94, + 94, + 86, + 14, + 160, + 14, + 160, + 0 + ] + } + } + } + }, + { + "new": 628, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 136, + 14, + 352, + 1, + 146, + 148, + 24, + 288, + 320 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 158, + 158, + 150, + 14, + 96, + 96, + 14, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 136, + 14, + 352, + 1, + 146, + 148, + 24, + 288, + 320 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 158, + 158, + 150, + 14, + 96, + 96, + 14, + 0 + ] + } + } + } + }, + { + "new": 629, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 385, + 68, + 14, + 257, + 82, + 20, + 88, + 32, + 384 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 129, + 94, + 90, + 94, + 14, + 0, + 14, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 1, + 2, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 68, + 14, + 257, + 82, + 20, + 88, + 32, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 94, + 90, + 94, + 14, + 0, + 14, + 129, + 0 + ] + } + } + } + }, + { + "new": 630, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 2, + 1, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 289, + 274, + 52, + 264, + 320, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 22, + 37, + 51, + 504, + 461, + 462, + 504, + 504, + 248 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 21, + 35, + 71, + 2, + 1, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 462, + 461, + 251, + 289, + 274, + 52, + 264, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 22, + 37, + 51, + 504, + 461, + 462, + 504, + 504, + 248 + ] + } + } + } + }, + { + "new": 631, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 80, + 392, + 19, + 97, + 98, + 4, + 264, + 48, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 115, + 115, + 0, + 136, + 99, + 19, + 19, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 20, + 32, + 66, + 133, + 5, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 2, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 80, + 392, + 19, + 97, + 98, + 4, + 264, + 48, + 384 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 115, + 115, + 0, + 136, + 99, + 19, + 19, + 136, + 0 + ] + } + } + } + }, + { + "new": 634, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 257, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 2, + 0, + 1, + 2, + 0 + ], + "matrix_rows": [ + 193, + 260, + 14, + 129, + 274, + 20, + 280, + 32, + 192 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 65, + 286, + 282, + 286, + 14, + 0, + 65, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 38, + 68, + 6, + 128, + 257, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 2, + 1, + 2, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 260, + 14, + 129, + 274, + 20, + 280, + 32, + 192 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 286, + 282, + 286, + 14, + 0, + 65, + 0, + 14 + ] + } + } + } + }, + { + "new": 674, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 1, + 1, + 2, + 0 + ], + "matrix_rows": [ + 264, + 14, + 224, + 1, + 274, + 276, + 24, + 160, + 192 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 96, + 96, + 0, + 14 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 34, + 67, + 3, + 132, + 260, + 4, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 264, + 14, + 224, + 1, + 274, + 276, + 24, + 160, + 192 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 286, + 286, + 278, + 14, + 96, + 96, + 0, + 14 + ] + } + } + } + }, + { + "new": 760, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 67, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 2, + 3, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 57, + 58, + 388, + 33, + 18, + 260, + 56, + 64, + 384 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 25, + 42, + 132, + 51, + 57, + 58, + 0, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 67, + 2, + 1, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 1, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 57, + 58, + 388, + 33, + 18, + 260, + 56, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 25, + 42, + 132, + 51, + 57, + 58, + 0, + 132, + 0 + ] + } + } + } + }, + { + "new": 773, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 64, + 135, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 1, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 403, + 19, + 145, + 417, + 34, + 4, + 8, + 432, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 177, + 416, + 0, + 0, + 177, + 19, + 0, + 403, + 130 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 19, + 32, + 64, + 135, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 403, + 19, + 145, + 417, + 34, + 4, + 8, + 432, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 177, + 416, + 0, + 0, + 177, + 19, + 0, + 403, + 130 + ] + } + } + } + }, + { + "new": 774, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 64, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 196, + 33, + 34, + 388, + 8, + 48, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 324, + 0, + 51, + 19, + 324, + 384, + 196 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 64, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 196, + 33, + 34, + 388, + 8, + 48, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 324, + 0, + 51, + 19, + 324, + 384, + 196 + ] + } + } + } + }, + { + "new": 788, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 35, + 65, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 1, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 237, + 324, + 227, + 257, + 82, + 276, + 344, + 288, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 270, + 179, + 185, + 445, + 14, + 270, + 0, + 270, + 425 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 35, + 65, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 237, + 324, + 227, + 257, + 82, + 276, + 344, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 270, + 179, + 185, + 445, + 14, + 270, + 0, + 270, + 425 + ] + } + } + } + }, + { + "new": 792, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 128, + 260, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 3, + 2 + ], + "matrix_rows": [ + 384, + 14, + 193, + 385, + 18, + 20, + 24, + 32, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 321, + 30, + 30, + 30, + 14, + 0, + 321, + 384, + 193 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 66, + 2, + 128, + 260, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 14, + 193, + 385, + 18, + 20, + 24, + 32, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 321, + 30, + 30, + 30, + 14, + 0, + 321, + 384, + 193 + ] + } + } + } + }, + { + "new": 793, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 71, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 1, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 398, + 14, + 138, + 1, + 402, + 20, + 408, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 154, + 400, + 154, + 14, + 0, + 0, + 398, + 132 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 35, + 71, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 398, + 14, + 138, + 1, + 402, + 20, + 408, + 32, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 154, + 400, + 154, + 14, + 0, + 0, + 398, + 132 + ] + } + } + } + }, + { + "new": 797, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 67, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 0, + 2, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 237, + 328, + 227, + 257, + 82, + 340, + 280, + 288, + 384 + ], + "offset": 6, + "phase": 3, + "quadratic_rows": [ + 270, + 179, + 445, + 181, + 14, + 270, + 0, + 270, + 421 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 33, + 67, + 6, + 133, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 2, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 237, + 328, + 227, + 257, + 82, + 340, + 280, + 288, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 270, + 179, + 445, + 181, + 14, + 270, + 0, + 270, + 421 + ] + } + } + } + }, + { + "new": 798, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 1, + 3, + 68, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 3, + 2, + 2, + 1, + 0, + 1, + 2 + ], + "matrix_rows": [ + 6, + 27, + 416, + 25, + 18, + 12, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 160, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 19, + 33, + 1, + 3, + 68, + 128, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 6, + 27, + 416, + 25, + 18, + 12, + 288, + 64, + 384 + ], + "offset": 7, + "phase": 3, + "quadratic_rows": [ + 3, + 13, + 14, + 6, + 0, + 160, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 809, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 67, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 1, + 0 + ], + "matrix_rows": [ + 398, + 14, + 134, + 1, + 402, + 404, + 24, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 0, + 150, + 150, + 400, + 14, + 0, + 0, + 398, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 23, + 39, + 67, + 3, + 128, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 398, + 14, + 134, + 1, + 402, + 404, + 24, + 32, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 0, + 150, + 150, + 400, + 14, + 0, + 0, + 398, + 136 + ] + } + } + } + }, + { + "new": 810, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 65, + 1, + 132, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "matrix_rows": [ + 14, + 384, + 224, + 1, + 18, + 20, + 24, + 416, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 352, + 352, + 384, + 224 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 65, + 1, + 132, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 3, + 3, + 3, + 0 + ], + "matrix_rows": [ + 14, + 384, + 224, + 1, + 18, + 20, + 24, + 416, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 352, + 352, + 384, + 224 + ] + } + } + } + }, + { + "new": 822, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 70, + 129, + 7, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 2, + 0 + ], + "matrix_rows": [ + 336, + 398, + 205, + 97, + 354, + 260, + 264, + 304, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 173, + 238, + 67, + 67, + 112, + 19, + 222, + 67, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 38, + 70, + 129, + 7, + 3, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 0, + 1, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 336, + 398, + 205, + 97, + 354, + 260, + 264, + 304, + 384 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 173, + 238, + 67, + 67, + 112, + 19, + 222, + 67, + 0 + ] + } + } + } + }, + { + "new": 825, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 68, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 1, + 1, + 2, + 1, + 3, + 2 + ], + "matrix_rows": [ + 19, + 384, + 200, + 33, + 34, + 4, + 392, + 48, + 448 + ], + "offset": 0, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 328, + 51, + 19, + 328, + 384, + 200 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 68, + 129, + 1, + 260, + 6, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 3, + 1, + 2, + 3, + 3, + 0 + ], + "matrix_rows": [ + 19, + 384, + 200, + 33, + 34, + 4, + 392, + 48, + 448 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 51, + 51, + 0, + 328, + 51, + 19, + 328, + 384, + 200 + ] + } + } + } + }, + { + "new": 826, + "old": 0, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 64, + 131, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 403, + 19, + 131, + 417, + 418, + 4, + 8, + 48, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 163, + 163, + 0, + 0, + 416, + 19, + 0, + 403, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 32, + 64, + 131, + 3, + 256, + 5, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 403, + 19, + 131, + 417, + 418, + 4, + 8, + 48, + 64 + ], + "offset": 5, + "phase": 2, + "quadratic_rows": [ + 163, + 163, + 0, + 0, + 416, + 19, + 0, + 403, + 144 + ] + } + } + } + }, + { + "new": 1, + "old": 114, + "rank": 8, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 2, + 4, + 8, + 16, + 19, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 34, + 4, + 8, + 48, + 64, + 128, + 256, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 32, + 32, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 2, + 4, + 8, + 16, + 19, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 34, + 4, + 8, + 48, + 64, + 128, + 256, + 32 + ], + "offset": 236, + "phase": 1, + "quadratic_rows": [ + 32, + 32, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 285, + "old": 114, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 821, + "old": 114, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 1, + 1, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 3, + 392, + 33, + 50, + 20, + 264, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 3, + "quadratic_rows": [ + 35, + 51, + 16, + 136, + 22, + 3, + 0, + 136, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 34, + 65, + 1, + 128, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 3, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 3, + 392, + 33, + 50, + 20, + 264, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 35, + 51, + 16, + 136, + 22, + 3, + 0, + 136, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 139, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 129, + 2, + 260, + 8, + 16, + 13, + 12, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 13, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 2, + 0, + 1, + 2, + 2 + ], + "matrix_rows": [ + 65, + 2, + 36, + 104, + 16, + 128, + 256, + 96, + 64 + ], + "offset": 393, + "phase": 1, + "quadratic_rows": [ + 32, + 0, + 96, + 96, + 0, + 13, + 76, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 129, + 2, + 260, + 8, + 16, + 13, + 12, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 13, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 1, + 2, + 2 + ], + "matrix_rows": [ + 65, + 2, + 36, + 104, + 16, + 128, + 256, + 96, + 64 + ], + "offset": 503, + "phase": 0, + "quadratic_rows": [ + 32, + 0, + 96, + 96, + 0, + 13, + 76, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 140, + "rank": 7, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 129, + 258, + 4, + 8, + 14, + 16, + 32, + 64, + 93 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 93, + 14, + 83, + 83, + 93, + 0, + 93, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 2, + 276, + 280, + 288, + 64, + 384, + 256, + 16 + ], + "offset": 141, + "phase": 1, + "quadratic_rows": [ + 256, + 16, + 272, + 272, + 14, + 256, + 0, + 256, + 173 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 3, + 0, + 0 + ], + "matrix_rows": [ + 129, + 258, + 4, + 8, + 14, + 16, + 32, + 64, + 93 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 93, + 14, + 83, + 83, + 93, + 0, + 93, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 2, + 276, + 280, + 288, + 64, + 384, + 256, + 16 + ], + "offset": 161, + "phase": 1, + "quadratic_rows": [ + 256, + 16, + 272, + 272, + 14, + 256, + 0, + 256, + 173 + ] + } + } + } + }, + { + "new": 1, + "old": 141, + "rank": 5, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 33, + 66, + 4, + 136, + 16, + 19, + 21, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 19, + 21, + 0, + 6, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 33, + 66, + 68, + 264, + 112, + 64, + 96, + 256, + 384 + ], + "offset": 145, + "phase": 2, + "quadratic_rows": [ + 96, + 32, + 64, + 0, + 96, + 19, + 21, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 33, + 66, + 4, + 136, + 16, + 19, + 21, + 264, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 19, + 21, + 0, + 6, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 33, + 66, + 68, + 264, + 112, + 64, + 96, + 256, + 384 + ], + "offset": 136, + "phase": 0, + "quadratic_rows": [ + 96, + 32, + 64, + 0, + 96, + 19, + 21, + 0, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 292, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 3, + 37, + 73, + 129, + 12, + 4, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 3, + 2, + 2, + 0, + 3 + ], + "matrix_rows": [ + 382, + 285, + 123, + 264, + 287, + 256, + 288, + 320, + 384 + ], + "offset": 200, + "phase": 3, + "quadratic_rows": [ + 120, + 24, + 120, + 295, + 87, + 13, + 21, + 0, + 264 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 22, + 3, + 37, + 73, + 129, + 12, + 4, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 3, + 2, + 2, + 0, + 3 + ], + "matrix_rows": [ + 382, + 285, + 123, + 264, + 287, + 256, + 288, + 320, + 384 + ], + "offset": 200, + "phase": 3, + "quadratic_rows": [ + 120, + 24, + 120, + 295, + 87, + 13, + 21, + 0, + 264 + ] + } + } + } + }, + { + "new": 621, + "old": 292, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 37, + 4, + 72, + 130, + 13, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 115, + 272, + 374, + 264, + 256, + 274, + 288, + 320, + 384 + ], + "offset": 254, + "phase": 3, + "quadratic_rows": [ + 370, + 21, + 370, + 32, + 87, + 13, + 21, + 0, + 261 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 37, + 4, + 72, + 130, + 13, + 7, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 15, + 7, + 15, + 13, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 115, + 272, + 374, + 264, + 256, + 274, + 288, + 320, + 384 + ], + "offset": 254, + "phase": 3, + "quadratic_rows": [ + 370, + 21, + 370, + 32, + 87, + 13, + 21, + 0, + 261 + ] + } + } + } + }, + { + "new": 621, + "old": 303, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 66, + 132, + 262, + 6, + 4, + 8, + 9 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 9, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 0, + 2, + 2, + 2, + 1 + ], + "matrix_rows": [ + 1, + 6, + 8, + 384, + 256, + 98, + 96, + 64, + 48 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 256, + 102, + 98, + 64, + 0, + 6, + 14, + 256, + 385 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 17, + 34, + 66, + 132, + 262, + 6, + 4, + 8, + 9 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 9, + 2, + 4, + 9, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 2, + 0, + 2, + 2, + 0, + 1 + ], + "matrix_rows": [ + 1, + 6, + 8, + 384, + 256, + 98, + 96, + 64, + 48 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 256, + 102, + 98, + 64, + 0, + 6, + 14, + 256, + 385 + ] + } + } + } + }, + { + "new": 280, + "old": 304, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 27, + 35, + 69, + 9, + 15, + 1, + 138, + 266, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 11, + 15, + 14, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 317, + 260, + 55, + 303, + 256, + 272, + 320, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 293, + 26, + 53, + 26, + 14, + 5, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 27, + 35, + 69, + 9, + 15, + 1, + 138, + 266, + 10 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 11, + 15, + 14, + 15, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 317, + 260, + 55, + 303, + 256, + 272, + 320, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 293, + 26, + 53, + 26, + 14, + 5, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 732, + "old": 360, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 67, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 272, + 338, + 1, + 322, + 4, + 8, + 80, + 32, + 128 + ], + "offset": 0, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 32, + 67, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 272, + 338, + 1, + 322, + 4, + 8, + 80, + 32, + 128 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 738, + "old": 360, + "rank": 4, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 1, + 34, + 66, + 136, + 2, + 12, + 256, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 320, + 272, + 33, + 44, + 32, + 336, + 128 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 37, + 0, + 45, + 4, + 80, + 5, + 80, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 18, + 1, + 34, + 66, + 136, + 2, + 12, + 256, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 4, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 320, + 272, + 33, + 44, + 32, + 336, + 128 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 37, + 0, + 45, + 4, + 80, + 5, + 80, + 0, + 0 + ] + } + } + } + }, + { + "new": 901, + "old": 371, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 32, + 64, + 132, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 2, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 257, + 96, + 18, + 256, + 98, + 4, + 56, + 64, + 384 + ], + "offset": 197, + "phase": 1, + "quadratic_rows": [ + 0, + 114, + 0, + 48, + 122, + 26, + 18, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 32, + 64, + 132, + 6, + 2, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 3, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 96, + 18, + 256, + 98, + 4, + 56, + 64, + 384 + ], + "offset": 192, + "phase": 2, + "quadratic_rows": [ + 0, + 114, + 0, + 48, + 122, + 26, + 18, + 0, + 0 + ] + } + } + } + }, + { + "new": 917, + "old": 371, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 98, + 1, + 114, + 256, + 56, + 64, + 384 + ], + "offset": 211, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 48, + 106, + 120, + 112, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 20, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 98, + 1, + 114, + 256, + 56, + 64, + 384 + ], + "offset": 213, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 0, + 48, + 106, + 120, + 112, + 0, + 0 + ] + } + } + } + }, + { + "new": 902, + "old": 372, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 23, + 6, + 32, + 65, + 130, + 3, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 1, + 3, + 1, + 0, + 2 + ], + "matrix_rows": [ + 118, + 275, + 354, + 273, + 358, + 56, + 320, + 256, + 384 + ], + "offset": 221, + "phase": 3, + "quadratic_rows": [ + 3, + 355, + 276, + 48, + 284, + 362, + 354, + 0, + 118 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 23, + 6, + 32, + 65, + 130, + 3, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 3, + 3, + 1, + 0, + 0 + ], + "matrix_rows": [ + 118, + 275, + 354, + 273, + 358, + 56, + 320, + 256, + 384 + ], + "offset": 222, + "phase": 2, + "quadratic_rows": [ + 3, + 355, + 276, + 48, + 284, + 362, + 354, + 0, + 118 + ] + } + } + } + }, + { + "new": 918, + "old": 372, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 69, + 129, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 1, + 3, + 0, + 1 + ], + "matrix_rows": [ + 277, + 113, + 355, + 115, + 276, + 56, + 320, + 256, + 384 + ], + "offset": 208, + "phase": 0, + "quadratic_rows": [ + 117, + 274, + 5, + 48, + 363, + 121, + 113, + 0, + 274 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 69, + 129, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 2, + 1, + 3, + 0, + 3 + ], + "matrix_rows": [ + 277, + 113, + 355, + 115, + 276, + 56, + 320, + 256, + 384 + ], + "offset": 213, + "phase": 3, + "quadratic_rows": [ + 117, + 274, + 5, + 48, + 363, + 121, + 113, + 0, + 274 + ] + } + } + } + }, + { + "new": 909, + "old": 373, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 5, + 160, + 170, + 81, + 162, + 68, + 128, + 64, + 256 + ], + "offset": 65, + "phase": 3, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 136, + 5, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 5, + 160, + 170, + 81, + 162, + 68, + 128, + 64, + 256 + ], + "offset": 69, + "phase": 1, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 136, + 5, + 160, + 0 + ] + } + } + } + }, + { + "new": 925, + "old": 373, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 8, + 5, + 170, + 65, + 10, + 84, + 128, + 64, + 256 + ], + "offset": 83, + "phase": 1, + "quadratic_rows": [ + 69, + 162, + 85, + 32, + 4, + 138, + 5, + 162, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 8, + 5, + 170, + 65, + 10, + 84, + 128, + 64, + 256 + ], + "offset": 87, + "phase": 1, + "quadratic_rows": [ + 69, + 162, + 85, + 32, + 4, + 138, + 5, + 162, + 0 + ] + } + } + } + }, + { + "new": 910, + "old": 374, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 5, + 288, + 298, + 81, + 290, + 68, + 256, + 64, + 128 + ], + "offset": 65, + "phase": 3, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 264, + 5, + 0, + 288 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 33, + 68, + 129, + 2, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 5, + 288, + 298, + 81, + 290, + 68, + 256, + 64, + 128 + ], + "offset": 69, + "phase": 1, + "quadratic_rows": [ + 85, + 10, + 69, + 34, + 1, + 264, + 5, + 0, + 288 + ] + } + } + } + }, + { + "new": 926, + "old": 374, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 8, + 5, + 298, + 65, + 10, + 84, + 256, + 64, + 128 + ], + "offset": 83, + "phase": 1, + "quadratic_rows": [ + 69, + 290, + 85, + 32, + 4, + 266, + 5, + 0, + 290 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 65, + 130, + 4, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 8, + 5, + 298, + 65, + 10, + 84, + 256, + 64, + 128 + ], + "offset": 87, + "phase": 1, + "quadratic_rows": [ + 69, + 290, + 85, + 32, + 4, + 266, + 5, + 0, + 290 + ] + } + } + } + }, + { + "new": 933, + "old": 375, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 35, + 68, + 1, + 128, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 82, + 4, + 264, + 21, + 6, + 64, + 256, + 32, + 384 + ], + "offset": 62, + "phase": 0, + "quadratic_rows": [ + 20, + 86, + 83, + 0, + 87, + 0, + 86, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 35, + 68, + 1, + 128, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 82, + 4, + 264, + 21, + 6, + 64, + 256, + 32, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 20, + 86, + 83, + 0, + 87, + 0, + 86, + 0, + 0 + ] + } + } + } + }, + { + "new": 949, + "old": 375, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 35, + 64, + 1, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 84, + 82, + 288, + 21, + 86, + 64, + 8, + 256, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 20, + 6, + 83, + 0, + 85, + 0, + 84, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 35, + 64, + 1, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 84, + 82, + 288, + 21, + 86, + 64, + 8, + 256, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 20, + 6, + 83, + 0, + 85, + 0, + 84, + 0, + 0 + ] + } + } + } + }, + { + "new": 934, + "old": 376, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 129, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 3, + 1, + 0, + 0, + 3 + ], + "matrix_rows": [ + 42, + 282, + 92, + 21, + 358, + 256, + 280, + 320, + 384 + ], + "offset": 240, + "phase": 1, + "quadratic_rows": [ + 20, + 84, + 43, + 124, + 283, + 364, + 42, + 0, + 304 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 39, + 71, + 129, + 2, + 6, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 5, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 42, + 282, + 92, + 21, + 358, + 256, + 280, + 320, + 384 + ], + "offset": 246, + "phase": 2, + "quadratic_rows": [ + 20, + 84, + 43, + 124, + 283, + 364, + 42, + 0, + 304 + ] + } + } + } + }, + { + "new": 950, + "old": 376, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 17, + 39, + 2, + 68, + 3, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 44, + 17, + 293, + 46, + 256, + 304, + 320, + 384 + ], + "offset": 235, + "phase": 3, + "quadratic_rows": [ + 309, + 38, + 35, + 0, + 305, + 55, + 0, + 0, + 17 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 17, + 39, + 2, + 68, + 3, + 135, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 44, + 17, + 293, + 46, + 256, + 304, + 320, + 384 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 309, + 38, + 35, + 0, + 305, + 55, + 0, + 0, + 17 + ] + } + } + } + }, + { + "new": 941, + "old": 377, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 135, + 132, + 40, + 128, + 134, + 88, + 64, + 96, + 256 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 6, + 3, + 129, + 120, + 8, + 104, + 40, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 135, + 132, + 40, + 128, + 134, + 88, + 64, + 96, + 256 + ], + "offset": 13, + "phase": 1, + "quadratic_rows": [ + 6, + 3, + 129, + 120, + 8, + 104, + 40, + 132, + 0 + ] + } + } + } + }, + { + "new": 957, + "old": 377, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 2, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 135, + 288, + 131, + 128, + 8, + 48, + 256, + 320 + ], + "offset": 482, + "phase": 2, + "quadratic_rows": [ + 132, + 6, + 3, + 0, + 32, + 48, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 135, + 288, + 131, + 128, + 8, + 48, + 256, + 320 + ], + "offset": 484, + "phase": 1, + "quadratic_rows": [ + 132, + 6, + 3, + 0, + 32, + 48, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 942, + "old": 378, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 263, + 260, + 40, + 256, + 262, + 88, + 64, + 96, + 128 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 6, + 3, + 257, + 120, + 8, + 104, + 40, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 263, + 260, + 40, + 256, + 262, + 88, + 64, + 96, + 128 + ], + "offset": 13, + "phase": 1, + "quadratic_rows": [ + 6, + 3, + 257, + 120, + 8, + 104, + 40, + 0, + 260 + ] + } + } + } + }, + { + "new": 958, + "old": 378, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 2, + 2, + 3, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 263, + 160, + 259, + 256, + 8, + 48, + 128, + 192 + ], + "offset": 482, + "phase": 2, + "quadratic_rows": [ + 260, + 6, + 3, + 0, + 32, + 48, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 1, + 18, + 32, + 64, + 132, + 260, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 2, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 263, + 160, + 259, + 256, + 8, + 48, + 128, + 192 + ], + "offset": 484, + "phase": 1, + "quadratic_rows": [ + 260, + 6, + 3, + 0, + 32, + 48, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 903, + "old": 391, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 131, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 19, + 179, + 288, + 273, + 274, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 131, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 19, + 179, + 288, + 273, + 274, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + } + } + }, + { + "new": 927, + "old": 391, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 132, + "phase": 3, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 131, + "phase": 1, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + } + } + }, + { + "new": 904, + "old": 392, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 3, + 384, + 404, + 73, + 66, + 388, + 64, + 256, + 32 + ], + "offset": 129, + "phase": 3, + "quadratic_rows": [ + 75, + 67, + 20, + 1, + 132, + 0, + 3, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 3, + 384, + 404, + 73, + 66, + 388, + 64, + 256, + 32 + ], + "offset": 133, + "phase": 1, + "quadratic_rows": [ + 75, + 67, + 20, + 1, + 132, + 0, + 3, + 272, + 384 + ] + } + } + } + }, + { + "new": 928, + "old": 392, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 132, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 106, + 66, + 400, + 11, + 32, + 20, + 96, + 256, + 384 + ], + "offset": 238, + "phase": 3, + "quadratic_rows": [ + 10, + 1, + 16, + 9, + 148, + 0, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 132, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 106, + 66, + 400, + 11, + 32, + 20, + 96, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 10, + 1, + 16, + 9, + 148, + 0, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 911, + "old": 393, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 39, + 66, + 4, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 398, + 150, + 64, + 322, + 324, + 256, + 96, + 384 + ], + "offset": 68, + "phase": 3, + "quadratic_rows": [ + 6, + 31, + 31, + 134, + 134, + 0, + 0, + 24, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 39, + 66, + 4, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 398, + 150, + 64, + 322, + 324, + 256, + 96, + 384 + ], + "offset": 67, + "phase": 1, + "quadratic_rows": [ + 6, + 31, + 31, + 134, + 134, + 0, + 0, + 24, + 0 + ] + } + } + } + }, + { + "new": 919, + "old": 393, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 69, + 3, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 3 + ], + "matrix_rows": [ + 158, + 278, + 8, + 153, + 18, + 20, + 256, + 32, + 64 + ], + "offset": 1, + "phase": 2, + "quadratic_rows": [ + 152, + 408, + 408, + 263, + 263, + 0, + 0, + 135, + 286 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 69, + 3, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 3 + ], + "matrix_rows": [ + 158, + 278, + 8, + 153, + 18, + 20, + 256, + 32, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 152, + 408, + 408, + 263, + 263, + 0, + 0, + 135, + 286 + ] + } + } + } + }, + { + "new": 912, + "old": 394, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 38, + 70, + 129, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 1, + 3, + 2, + 3, + 2 + ], + "matrix_rows": [ + 400, + 36, + 68, + 17, + 38, + 64, + 72, + 256, + 384 + ], + "offset": 255, + "phase": 1, + "quadratic_rows": [ + 16, + 36, + 2, + 0, + 145, + 34, + 0, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 38, + 70, + 129, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 1, + 2, + 1, + 2 + ], + "matrix_rows": [ + 400, + 36, + 68, + 17, + 38, + 64, + 72, + 256, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 16, + 36, + 2, + 0, + 145, + 34, + 0, + 144, + 0 + ] + } + } + } + }, + { + "new": 920, + "old": 394, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 384, + 6, + 401, + 385, + 66, + 100, + 8, + 256, + 64 + ], + "offset": 130, + "phase": 3, + "quadratic_rows": [ + 17, + 70, + 102, + 0, + 129, + 4, + 6, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 64, + 132, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 6, + 401, + 385, + 66, + 100, + 8, + 256, + 64 + ], + "offset": 134, + "phase": 1, + "quadratic_rows": [ + 17, + 70, + 102, + 0, + 129, + 4, + 6, + 272, + 384 + ] + } + } + } + }, + { + "new": 943, + "old": 395, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 34, + 66, + 4, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 423, + 98, + 182, + 256, + 326, + 64, + 72, + 352, + 384 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 166, + 55, + 19, + 0, + 166, + 51, + 0, + 17, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 23, + 34, + 66, + 4, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 0, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 423, + 98, + 182, + 256, + 326, + 64, + 72, + 352, + 384 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 166, + 55, + 19, + 0, + 166, + 51, + 0, + 17, + 0 + ] + } + } + } + }, + { + "new": 951, + "old": 395, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 39, + 71, + 135, + 259, + 4, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 1, + 2, + 1, + 1 + ], + "matrix_rows": [ + 212, + 340, + 308, + 165, + 38, + 320, + 328, + 368, + 256 + ], + "offset": 423, + "phase": 3, + "quadratic_rows": [ + 164, + 36, + 371, + 0, + 468, + 487, + 180, + 241, + 308 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 39, + 71, + 135, + 259, + 4, + 1, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 3, + 1, + 2, + 3, + 1 + ], + "matrix_rows": [ + 212, + 340, + 308, + 165, + 38, + 320, + 328, + 368, + 256 + ], + "offset": 420, + "phase": 2, + "quadratic_rows": [ + 164, + 36, + 371, + 0, + 468, + 487, + 180, + 241, + 308 + ] + } + } + } + }, + { + "new": 944, + "old": 396, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 1, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 65, + 36, + 400, + 32, + 6, + 96, + 24, + 256, + 384 + ], + "offset": 247, + "phase": 0, + "quadratic_rows": [ + 96, + 4, + 70, + 16, + 152, + 65, + 101, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 3, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 65, + 36, + 400, + 32, + 6, + 96, + 24, + 256, + 384 + ], + "offset": 242, + "phase": 1, + "quadratic_rows": [ + 96, + 4, + 70, + 16, + 152, + 65, + 101, + 144, + 0 + ] + } + } + } + }, + { + "new": 952, + "old": 396, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 65, + 384, + 408, + 69, + 6, + 64, + 392, + 256, + 32 + ], + "offset": 184, + "phase": 3, + "quadratic_rows": [ + 5, + 4, + 7, + 24, + 136, + 0, + 0, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 132, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 65, + 384, + 408, + 69, + 6, + 64, + 392, + 256, + 32 + ], + "offset": 189, + "phase": 0, + "quadratic_rows": [ + 5, + 4, + 7, + 24, + 136, + 0, + 0, + 272, + 384 + ] + } + } + } + }, + { + "new": 935, + "old": 397, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 39, + 65, + 1, + 128, + 256, + 3, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 1, + 3, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 10, + 388, + 4, + 149, + 134, + 256, + 24, + 32, + 64 + ], + "offset": 62, + "phase": 0, + "quadratic_rows": [ + 148, + 142, + 151, + 26, + 157, + 0, + 0, + 279, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 39, + 65, + 1, + 128, + 256, + 3, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 1, + 1, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 10, + 388, + 4, + 149, + 134, + 256, + 24, + 32, + 64 + ], + "offset": 62, + "phase": 1, + "quadratic_rows": [ + 148, + 142, + 151, + 26, + 157, + 0, + 0, + 279, + 384 + ] + } + } + } + }, + { + "new": 959, + "old": 397, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 34, + 70, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 194, + 463, + 155, + 323, + 64, + 320, + 328, + 96, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 22, + 151, + 139, + 20, + 139, + 0, + 0, + 150, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 17, + 34, + 70, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 194, + 463, + 155, + 323, + 64, + 320, + 328, + 96, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 22, + 151, + 139, + 20, + 139, + 0, + 0, + 150, + 0 + ] + } + } + } + }, + { + "new": 936, + "old": 398, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 130, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 1, + 2, + 0, + 3 + ], + "matrix_rows": [ + 68, + 432, + 384, + 5, + 6, + 64, + 72, + 256, + 416 + ], + "offset": 185, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 160, + 48, + 0, + 272, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 130, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 3, + 2, + 2, + 3 + ], + "matrix_rows": [ + 68, + 432, + 384, + 5, + 6, + 64, + 72, + 256, + 416 + ], + "offset": 186, + "phase": 3, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 160, + 48, + 0, + 272, + 384 + ] + } + } + } + }, + { + "new": 960, + "old": 398, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 3, + 68, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 3, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 12, + 16, + 3, + 72, + 64, + 48, + 128, + 256 + ], + "offset": 27, + "phase": 1, + "quadratic_rows": [ + 2, + 11, + 72, + 78, + 48, + 16, + 12, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 3, + 68, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 1, + 1, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 66, + 12, + 16, + 3, + 72, + 64, + 48, + 128, + 256 + ], + "offset": 25, + "phase": 3, + "quadratic_rows": [ + 2, + 11, + 72, + 78, + 48, + 16, + 12, + 0, + 0 + ] + } + } + } + }, + { + "new": 885, + "old": 411, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 0, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 388, + 66, + 96, + 5, + 64, + 256, + 40, + 80, + 384 + ], + "offset": 251, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 133, + 32, + 0, + 104, + 96, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 0, + 1, + 3, + 1, + 2 + ], + "matrix_rows": [ + 388, + 66, + 96, + 5, + 64, + 256, + 40, + 80, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 4, + 0, + 133, + 32, + 0, + 104, + 96, + 132, + 0 + ] + } + } + } + }, + { + "new": 917, + "old": 411, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 36, + 64, + 128, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 0, + 3, + 2, + 0, + 3 + ], + "matrix_rows": [ + 384, + 66, + 389, + 385, + 98, + 256, + 40, + 16, + 64 + ], + "offset": 368, + "phase": 3, + "quadratic_rows": [ + 5, + 34, + 129, + 32, + 0, + 42, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 36, + 64, + 128, + 258, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 2, + 0, + 1, + 2, + 2, + 3 + ], + "matrix_rows": [ + 384, + 66, + 389, + 385, + 98, + 256, + 40, + 16, + 64 + ], + "offset": 374, + "phase": 0, + "quadratic_rows": [ + 5, + 34, + 129, + 32, + 0, + 42, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 886, + "old": 412, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 71, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 89, + 410, + 156, + 64, + 256, + 328, + 336, + 96, + 384 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 24, + 152, + 152, + 31, + 31, + 0, + 0, + 6, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 71, + 129, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 89, + 410, + 156, + 64, + 256, + 328, + 336, + 96, + 384 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 24, + 152, + 152, + 31, + 31, + 0, + 0, + 6, + 0 + ] + } + } + } + }, + { + "new": 918, + "old": 412, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 64, + 133, + 256, + 5, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 3, + 1 + ], + "matrix_rows": [ + 210, + 66, + 272, + 147, + 320, + 20, + 24, + 64, + 32 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 146, + 321, + 16, + 16, + 269, + 0, + 450, + 193, + 338 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 64, + 133, + 256, + 5, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 1, + 1, + 3 + ], + "matrix_rows": [ + 210, + 66, + 272, + 147, + 320, + 20, + 24, + 64, + 32 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 146, + 321, + 16, + 16, + 269, + 0, + 450, + 193, + 338 + ] + } + } + } + }, + { + "new": 893, + "old": 413, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 67, + 128, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 3, + 0, + 2, + 1 + ], + "matrix_rows": [ + 169, + 9, + 288, + 261, + 166, + 256, + 424, + 16, + 64 + ], + "offset": 57, + "phase": 3, + "quadratic_rows": [ + 420, + 164, + 167, + 256, + 0, + 167, + 0, + 295, + 393 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 67, + 128, + 6, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 0, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 169, + 9, + 288, + 261, + 166, + 256, + 424, + 16, + 64 + ], + "offset": 57, + "phase": 0, + "quadratic_rows": [ + 420, + 164, + 167, + 256, + 0, + 167, + 0, + 295, + 393 + ] + } + } + } + }, + { + "new": 927, + "old": 413, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 129, + 4, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 200, + 463, + 171, + 321, + 330, + 320, + 64, + 80, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 36, + 44, + 139, + 174, + 0, + 139, + 0, + 172, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 129, + 4, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 200, + 463, + 171, + 321, + 330, + 320, + 64, + 80, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 36, + 44, + 139, + 174, + 0, + 139, + 0, + 172, + 0 + ] + } + } + } + }, + { + "new": 894, + "old": 414, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 65, + 130, + 256, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 1, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 9, + 404, + 384, + 67, + 64, + 256, + 72, + 400, + 32 + ], + "offset": 33, + "phase": 3, + "quadratic_rows": [ + 75, + 1, + 144, + 73, + 20, + 0, + 9, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 65, + 130, + 256, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 3, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 9, + 404, + 384, + 67, + 64, + 256, + 72, + 400, + 32 + ], + "offset": 35, + "phase": 1, + "quadratic_rows": [ + 75, + 1, + 144, + 73, + 20, + 0, + 9, + 260, + 384 + ] + } + } + } + }, + { + "new": 928, + "old": 414, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 65, + 4, + 1, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 1, + 2, + 1, + 1, + 0, + 0 + ], + "matrix_rows": [ + 106, + 34, + 4, + 11, + 96, + 20, + 32, + 128, + 256 + ], + "offset": 26, + "phase": 0, + "quadratic_rows": [ + 10, + 33, + 20, + 73, + 4, + 34, + 72, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 65, + 4, + 1, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 3, + 2, + 1, + 3, + 0, + 0 + ], + "matrix_rows": [ + 106, + 34, + 4, + 11, + 96, + 20, + 32, + 128, + 256 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 10, + 33, + 20, + 73, + 4, + 34, + 72, + 0, + 0 + ] + } + } + } + }, + { + "new": 937, + "old": 415, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 64, + 129, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 0, + 2, + 0, + 1, + 2, + 0, + 3 + ], + "matrix_rows": [ + 66, + 420, + 384, + 3, + 64, + 256, + 8, + 80, + 416 + ], + "offset": 233, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 160, + 0, + 0, + 36, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 64, + 129, + 258, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 0, + 3, + 2, + 2, + 3 + ], + "matrix_rows": [ + 66, + 420, + 384, + 3, + 64, + 256, + 8, + 80, + 416 + ], + "offset": 234, + "phase": 3, + "quadratic_rows": [ + 2, + 3, + 160, + 0, + 0, + 36, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 965, + "old": 415, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 1, + 66, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 3, + 0, + 2, + 1, + 0, + 0 + ], + "matrix_rows": [ + 74, + 66, + 4, + 11, + 64, + 36, + 80, + 128, + 256 + ], + "offset": 25, + "phase": 0, + "quadratic_rows": [ + 10, + 65, + 36, + 73, + 0, + 4, + 74, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 36, + 1, + 66, + 4, + 2, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 3, + 0, + 2, + 1, + 0, + 0 + ], + "matrix_rows": [ + 74, + 66, + 4, + 11, + 64, + 36, + 80, + 128, + 256 + ], + "offset": 27, + "phase": 0, + "quadratic_rows": [ + 10, + 65, + 36, + 73, + 0, + 4, + 74, + 0, + 0 + ] + } + } + } + }, + { + "new": 938, + "old": 416, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 67, + 5, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 3, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 10, + 154, + 272, + 149, + 262, + 256, + 408, + 32, + 64 + ], + "offset": 58, + "phase": 3, + "quadratic_rows": [ + 148, + 404, + 151, + 256, + 151, + 0, + 0, + 279, + 394 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 67, + 5, + 128, + 256, + 1, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 0, + 1, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 10, + 154, + 272, + 149, + 262, + 256, + 408, + 32, + 64 + ], + "offset": 58, + "phase": 0, + "quadratic_rows": [ + 148, + 404, + 151, + 256, + 151, + 0, + 0, + 279, + 394 + ] + } + } + } + }, + { + "new": 966, + "old": 416, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 200, + 463, + 155, + 329, + 322, + 320, + 64, + 96, + 384 + ], + "offset": 7, + "phase": 0, + "quadratic_rows": [ + 28, + 20, + 139, + 157, + 139, + 0, + 0, + 156, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 22, + 34, + 65, + 4, + 129, + 1, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 1, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 200, + 463, + 155, + 329, + 322, + 320, + 64, + 96, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 28, + 20, + 139, + 157, + 139, + 0, + 0, + 156, + 0 + ] + } + } + } + }, + { + "new": 947, + "old": 417, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 66, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 1, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 425, + 106, + 172, + 256, + 64, + 328, + 80, + 352, + 384 + ], + "offset": 12, + "phase": 3, + "quadratic_rows": [ + 168, + 40, + 168, + 47, + 0, + 47, + 0, + 5, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 4, + 39, + 66, + 135, + 2, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 3, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 425, + 106, + 172, + 256, + 64, + 328, + 80, + 352, + 384 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 168, + 40, + 168, + 47, + 0, + 47, + 0, + 5, + 0 + ] + } + } + } + }, + { + "new": 969, + "old": 417, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 64, + 131, + 261, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 198, + 294, + 96, + 163, + 320, + 356, + 40, + 336, + 256 + ], + "offset": 419, + "phase": 2, + "quadratic_rows": [ + 162, + 1, + 128, + 32, + 0, + 393, + 384, + 229, + 96 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 35, + 64, + 131, + 261, + 6, + 1, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 198, + 294, + 96, + 163, + 320, + 356, + 40, + 336, + 256 + ], + "offset": 422, + "phase": 3, + "quadratic_rows": [ + 162, + 1, + 128, + 32, + 0, + 393, + 384, + 229, + 96 + ] + } + } + } + }, + { + "new": 948, + "old": 418, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 1, + 2, + 1, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 65, + 388, + 48, + 32, + 6, + 256, + 24, + 96, + 384 + ], + "offset": 247, + "phase": 0, + "quadratic_rows": [ + 96, + 4, + 134, + 16, + 88, + 65, + 113, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 132, + 1, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 2, + 1, + 2, + 1, + 1, + 2 + ], + "matrix_rows": [ + 65, + 388, + 48, + 32, + 6, + 256, + 24, + 96, + 384 + ], + "offset": 244, + "phase": 1, + "quadratic_rows": [ + 96, + 4, + 134, + 16, + 88, + 65, + 113, + 132, + 0 + ] + } + } + } + }, + { + "new": 970, + "old": 418, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 36, + 64, + 129, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 0, + 2, + 3, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 65, + 384, + 390, + 81, + 386, + 256, + 24, + 64, + 32 + ], + "offset": 232, + "phase": 3, + "quadratic_rows": [ + 17, + 6, + 130, + 16, + 25, + 0, + 0, + 260, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 20, + 36, + 64, + 129, + 256, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 0, + 2, + 1, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 65, + 384, + 390, + 81, + 386, + 256, + 24, + 64, + 32 + ], + "offset": 237, + "phase": 0, + "quadratic_rows": [ + 17, + 6, + 130, + 16, + 25, + 0, + 0, + 260, + 384 + ] + } + } + } + }, + { + "new": 887, + "old": 431, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 1, + 3, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 17, + 170, + 160, + 69, + 128, + 64, + 168, + 80, + 256 + ], + "offset": 17, + "phase": 3, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 130, + 17, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 6, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 17, + 170, + 160, + 69, + 128, + 64, + 168, + 80, + 256 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 130, + 17, + 160, + 0 + ] + } + } + } + }, + { + "new": 925, + "old": 431, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 130, + 272, + 170, + 1, + 138, + 20, + 256, + 128, + 320 + ], + "offset": 364, + "phase": 2, + "quadratic_rows": [ + 0, + 160, + 16, + 40, + 20, + 10, + 0, + 130, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 1, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 130, + 272, + 170, + 1, + 138, + 20, + 256, + 128, + 320 + ], + "offset": 362, + "phase": 1, + "quadratic_rows": [ + 0, + 160, + 16, + 40, + 20, + 10, + 0, + 130, + 0 + ] + } + } + } + }, + { + "new": 888, + "old": 432, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 1, + 3, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 17, + 298, + 288, + 69, + 256, + 64, + 296, + 80, + 128 + ], + "offset": 17, + "phase": 3, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 258, + 17, + 0, + 288 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 129, + 4, + 1, + 256, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 17, + 298, + 288, + 69, + 256, + 64, + 296, + 80, + 128 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 85, + 40, + 1, + 10, + 81, + 258, + 17, + 0, + 288 + ] + } + } + } + }, + { + "new": 926, + "old": 432, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 3, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 258, + 144, + 298, + 1, + 266, + 20, + 128, + 256, + 192 + ], + "offset": 364, + "phase": 2, + "quadratic_rows": [ + 0, + 288, + 16, + 40, + 20, + 10, + 0, + 0, + 258 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 32, + 1, + 66, + 132, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 1, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 258, + 144, + 298, + 1, + 266, + 20, + 128, + 256, + 192 + ], + "offset": 362, + "phase": 1, + "quadratic_rows": [ + 0, + 288, + 16, + 40, + 20, + 10, + 0, + 0, + 258 + ] + } + } + } + }, + { + "new": 895, + "old": 433, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 16, + 35, + 71, + 4, + 134, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 124, + 25, + 269, + 261, + 38, + 320, + 376, + 256, + 384 + ], + "offset": 233, + "phase": 2, + "quadratic_rows": [ + 16, + 36, + 278, + 24, + 269, + 2, + 0, + 0, + 276 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 16, + 35, + 71, + 4, + 134, + 5, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 3, + 2, + 0, + 2, + 0, + 1 + ], + "matrix_rows": [ + 124, + 25, + 269, + 261, + 38, + 320, + 376, + 256, + 384 + ], + "offset": 236, + "phase": 1, + "quadratic_rows": [ + 16, + 36, + 278, + 24, + 269, + 2, + 0, + 0, + 276 + ] + } + } + } + }, + { + "new": 919, + "old": 433, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 20, + 36, + 1, + 7, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 56, + 9, + 15, + 57, + 306, + 276, + 256, + 320, + 384 + ], + "offset": 243, + "phase": 3, + "quadratic_rows": [ + 62, + 319, + 287, + 15, + 55, + 19, + 0, + 0, + 6 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 20, + 36, + 1, + 7, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 7, + 3, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 1, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 56, + 9, + 15, + 57, + 306, + 276, + 256, + 320, + 384 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 62, + 319, + 287, + 15, + 55, + 19, + 0, + 0, + 6 + ] + } + } + } + }, + { + "new": 896, + "old": 434, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 70, + 128, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 12, + 108, + 256, + 38, + 64, + 104, + 16, + 384 + ], + "offset": 55, + "phase": 2, + "quadratic_rows": [ + 0, + 36, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 70, + 128, + 2, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 2, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 12, + 108, + 256, + 38, + 64, + 104, + 16, + 384 + ], + "offset": 48, + "phase": 2, + "quadratic_rows": [ + 0, + 36, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 920, + "old": 434, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 3, + 68, + 130, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 3, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 46, + 40, + 272, + 1, + 74, + 108, + 256, + 64, + 384 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 0, + 102, + 70, + 40, + 0, + 10, + 6, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 3, + 68, + 130, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 1, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 46, + 40, + 272, + 1, + 74, + 108, + 256, + 64, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 102, + 70, + 40, + 0, + 10, + 6, + 0, + 0 + ] + } + } + } + }, + { + "new": 945, + "old": 435, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 153, + 34, + 144, + 128, + 70, + 64, + 152, + 96, + 256 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 129, + 98, + 34, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 153, + 34, + 144, + 128, + 70, + 64, + 152, + 96, + 256 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 129, + 98, + 34, + 144, + 0 + ] + } + } + } + }, + { + "new": 967, + "old": 435, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 288, + 153, + 137, + 2, + 36, + 128, + 256, + 320 + ], + "offset": 436, + "phase": 2, + "quadratic_rows": [ + 144, + 0, + 32, + 24, + 9, + 36, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 4, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 288, + 153, + 137, + 2, + 36, + 128, + 256, + 320 + ], + "offset": 434, + "phase": 1, + "quadratic_rows": [ + 144, + 0, + 32, + 24, + 9, + 36, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 946, + "old": 436, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 281, + 34, + 272, + 256, + 70, + 64, + 280, + 96, + 128 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 257, + 98, + 34, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 281, + 34, + 272, + 256, + 70, + 64, + 280, + 96, + 128 + ], + "offset": 11, + "phase": 1, + "quadratic_rows": [ + 24, + 102, + 2, + 9, + 257, + 98, + 34, + 0, + 272 + ] + } + } + } + }, + { + "new": 968, + "old": 436, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 3, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 160, + 281, + 265, + 2, + 36, + 256, + 128, + 192 + ], + "offset": 436, + "phase": 2, + "quadratic_rows": [ + 272, + 0, + 32, + 24, + 9, + 36, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 32, + 1, + 68, + 130, + 258, + 2, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 160, + 281, + 265, + 2, + 36, + 256, + 128, + 192 + ], + "offset": 434, + "phase": 1, + "quadratic_rows": [ + 272, + 0, + 32, + 24, + 9, + 36, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 939, + "old": 437, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 35, + 71, + 133, + 4, + 6, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 42, + 124, + 270, + 21, + 262, + 320, + 376, + 256, + 384 + ], + "offset": 242, + "phase": 2, + "quadratic_rows": [ + 20, + 32, + 293, + 40, + 1, + 270, + 0, + 0, + 292 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 21, + 35, + 71, + 133, + 4, + 6, + 261, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 3, + 0, + 2, + 2, + 0, + 1 + ], + "matrix_rows": [ + 42, + 124, + 270, + 21, + 262, + 320, + 376, + 256, + 384 + ], + "offset": 244, + "phase": 1, + "quadratic_rows": [ + 20, + 32, + 293, + 40, + 1, + 270, + 0, + 0, + 292 + ] + } + } + } + }, + { + "new": 971, + "old": 437, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 21, + 36, + 2, + 67, + 7, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 0, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 56, + 15, + 305, + 58, + 292, + 256, + 320, + 384 + ], + "offset": 235, + "phase": 3, + "quadratic_rows": [ + 319, + 61, + 303, + 15, + 35, + 55, + 0, + 0, + 5 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 21, + 36, + 2, + 67, + 7, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 2, + 1, + 0, + 0, + 2 + ], + "matrix_rows": [ + 10, + 56, + 15, + 305, + 58, + 292, + 256, + 320, + 384 + ], + "offset": 235, + "phase": 2, + "quadratic_rows": [ + 319, + 61, + 303, + 15, + 35, + 55, + 0, + 0, + 5 + ] + } + } + } + }, + { + "new": 940, + "old": 438, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 37, + 69, + 1, + 128, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 12, + 258, + 92, + 21, + 256, + 64, + 88, + 32, + 384 + ], + "offset": 47, + "phase": 2, + "quadratic_rows": [ + 20, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 37, + 69, + 1, + 128, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 2, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 12, + 258, + 92, + 21, + 256, + 64, + 88, + 32, + 384 + ], + "offset": 40, + "phase": 2, + "quadratic_rows": [ + 20, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 972, + "old": 438, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 3, + 66, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 1, + 3, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 29, + 24, + 288, + 73, + 2, + 92, + 64, + 256, + 384 + ], + "offset": 4, + "phase": 2, + "quadratic_rows": [ + 85, + 0, + 69, + 24, + 9, + 0, + 5, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 3, + 66, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 29, + 24, + 288, + 73, + 2, + 92, + 64, + 256, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 85, + 0, + 69, + 24, + 9, + 0, + 5, + 0, + 0 + ] + } + } + } + }, + { + "new": 889, + "old": 491, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 2, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 2, + 0, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 20, + 66, + 416, + 5, + 16, + 80, + 40, + 256, + 384 + ], + "offset": 239, + "phase": 0, + "quadratic_rows": [ + 4, + 80, + 69, + 32, + 66, + 168, + 86, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 18, + 33, + 64, + 2, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 2, + 2, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 20, + 66, + 416, + 5, + 16, + 80, + 40, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 4, + 80, + 69, + 32, + 66, + 168, + 86, + 160, + 0 + ] + } + } + } + }, + { + "new": 949, + "old": 491, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 66, + 384, + 424, + 5, + 70, + 64, + 392, + 16, + 256 + ], + "offset": 312, + "phase": 3, + "quadratic_rows": [ + 4, + 6, + 7, + 40, + 0, + 136, + 0, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 66, + 384, + 424, + 5, + 70, + 64, + 392, + 16, + 256 + ], + "offset": 317, + "phase": 0, + "quadratic_rows": [ + 4, + 6, + 7, + 40, + 0, + 136, + 0, + 288, + 384 + ] + } + } + } + }, + { + "new": 890, + "old": 492, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 18, + 33, + 65, + 135, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 81, + 407, + 181, + 325, + 256, + 64, + 72, + 336, + 384 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 55, + 149, + 35, + 0, + 51, + 149, + 0, + 34, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 18, + 33, + 65, + 135, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 0, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 81, + 407, + 181, + 325, + 256, + 64, + 72, + 336, + 384 + ], + "offset": 19, + "phase": 1, + "quadratic_rows": [ + 55, + 149, + 35, + 0, + 51, + 149, + 0, + 34, + 0 + ] + } + } + } + }, + { + "new": 950, + "old": 492, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 23, + 39, + 71, + 132, + 259, + 7, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 130, + 258, + 183, + 357, + 230, + 64, + 72, + 368, + 256 + ], + "offset": 463, + "phase": 2, + "quadratic_rows": [ + 467, + 467, + 368, + 0, + 471, + 356, + 183, + 83, + 311 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 23, + 39, + 71, + 132, + 259, + 7, + 2, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 130, + 258, + 183, + 357, + 230, + 64, + 72, + 368, + 256 + ], + "offset": 463, + "phase": 1, + "quadratic_rows": [ + 467, + 467, + 368, + 0, + 471, + 356, + 183, + 83, + 311 + ] + } + } + } + }, + { + "new": 899, + "old": 493, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 39, + 66, + 128, + 2, + 256, + 3, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 1, + 1, + 0, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 388, + 9, + 4, + 133, + 166, + 256, + 40, + 16, + 64 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 141, + 164, + 167, + 41, + 0, + 174, + 0, + 295, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 39, + 66, + 128, + 2, + 256, + 3, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 1, + 0, + 1, + 0, + 2, + 3 + ], + "matrix_rows": [ + 388, + 9, + 4, + 133, + 166, + 256, + 40, + 16, + 64 + ], + "offset": 61, + "phase": 1, + "quadratic_rows": [ + 141, + 164, + 167, + 41, + 0, + 174, + 0, + 295, + 384 + ] + } + } + } + }, + { + "new": 959, + "old": 493, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 34, + 71, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 73, + 399, + 171, + 323, + 64, + 256, + 328, + 80, + 384 + ], + "offset": 36, + "phase": 3, + "quadratic_rows": [ + 47, + 37, + 139, + 45, + 0, + 139, + 0, + 36, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 34, + 71, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 0, + 3, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 73, + 399, + 171, + 323, + 64, + 256, + 328, + 80, + 384 + ], + "offset": 35, + "phase": 1, + "quadratic_rows": [ + 47, + 37, + 139, + 45, + 0, + 139, + 0, + 36, + 0 + ] + } + } + } + }, + { + "new": 900, + "old": 494, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 132, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 1, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 68, + 384, + 432, + 5, + 6, + 64, + 72, + 400, + 256 + ], + "offset": 313, + "phase": 0, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 48, + 144, + 0, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 33, + 65, + 132, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 3, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 68, + 384, + 432, + 5, + 6, + 64, + 72, + 400, + 256 + ], + "offset": 316, + "phase": 3, + "quadratic_rows": [ + 4, + 4, + 3, + 0, + 48, + 144, + 0, + 288, + 384 + ] + } + } + } + }, + { + "new": 960, + "old": 494, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 2, + 64, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 0, + 2, + 1, + 3, + 3, + 2 + ], + "matrix_rows": [ + 10, + 68, + 416, + 3, + 72, + 8, + 48, + 256, + 384 + ], + "offset": 223, + "phase": 0, + "quadratic_rows": [ + 2, + 67, + 72, + 68, + 32, + 176, + 78, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 2, + 64, + 132, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 1, + 0, + 2, + 2, + 3, + 1, + 1, + 2 + ], + "matrix_rows": [ + 10, + 68, + 416, + 3, + 72, + 8, + 48, + 256, + 384 + ], + "offset": 217, + "phase": 1, + "quadratic_rows": [ + 2, + 67, + 72, + 68, + 32, + 176, + 78, + 160, + 0 + ] + } + } + } + }, + { + "new": 905, + "old": 495, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 2, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 3, + 384, + 420, + 65, + 74, + 388, + 64, + 16, + 256 + ], + "offset": 257, + "phase": 3, + "quadratic_rows": [ + 67, + 75, + 36, + 2, + 0, + 132, + 3, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 36, + 65, + 128, + 260, + 1, + 2, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 3, + 384, + 420, + 65, + 74, + 388, + 64, + 16, + 256 + ], + "offset": 261, + "phase": 1, + "quadratic_rows": [ + 67, + 75, + 36, + 2, + 0, + 132, + 3, + 288, + 384 + ] + } + } + } + }, + { + "new": 965, + "old": 495, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 2, + 1, + 0, + 3, + 2 + ], + "matrix_rows": [ + 90, + 66, + 416, + 11, + 16, + 36, + 80, + 256, + 384 + ], + "offset": 238, + "phase": 3, + "quadratic_rows": [ + 10, + 1, + 32, + 9, + 0, + 164, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 19, + 32, + 65, + 3, + 132, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 2, + 3, + 0, + 1, + 2 + ], + "matrix_rows": [ + 90, + 66, + 416, + 11, + 16, + 36, + 80, + 256, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 10, + 1, + 32, + 9, + 0, + 164, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 906, + "old": 496, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 134, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 291, + 179, + 16, + 33, + 34, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 19, + 32, + 64, + 134, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 291, + 179, + 16, + 33, + 34, + 180, + 8, + 256, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 432, + 432, + 176, + 0, + 263, + 263, + 0, + 135, + 307 + ] + } + } + } + }, + { + "new": 966, + "old": 496, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 132, + "phase": 3, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 23, + 33, + 65, + 130, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 403, + 163, + 321, + 322, + 64, + 72, + 256, + 384 + ], + "offset": 131, + "phase": 1, + "quadratic_rows": [ + 55, + 55, + 3, + 0, + 131, + 131, + 0, + 48, + 0 + ] + } + } + } + }, + { + "new": 915, + "old": 497, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 39, + 66, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 397, + 165, + 321, + 64, + 324, + 256, + 80, + 384 + ], + "offset": 68, + "phase": 3, + "quadratic_rows": [ + 47, + 5, + 47, + 133, + 0, + 133, + 0, + 40, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 39, + 66, + 129, + 4, + 1, + 262, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 71, + 397, + 165, + 321, + 64, + 324, + 256, + 80, + 384 + ], + "offset": 67, + "phase": 1, + "quadratic_rows": [ + 47, + 5, + 47, + 133, + 0, + 133, + 0, + 40, + 0 + ] + } + } + } + }, + { + "new": 971, + "old": 497, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 70, + 128, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 293, + 173, + 8, + 33, + 170, + 36, + 256, + 16, + 64 + ], + "offset": 2, + "phase": 2, + "quadratic_rows": [ + 424, + 168, + 424, + 263, + 0, + 263, + 0, + 135, + 301 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 70, + 128, + 3, + 256, + 2, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 1, + 3 + ], + "matrix_rows": [ + 293, + 173, + 8, + 33, + 170, + 36, + 256, + 16, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 424, + 168, + 424, + 263, + 0, + 263, + 0, + 135, + 301 + ] + } + } + } + }, + { + "new": 916, + "old": 498, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 37, + 69, + 1, + 130, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 1, + 2, + 3, + 2 + ], + "matrix_rows": [ + 20, + 416, + 68, + 21, + 34, + 64, + 72, + 256, + 384 + ], + "offset": 255, + "phase": 1, + "quadratic_rows": [ + 20, + 32, + 1, + 0, + 17, + 162, + 0, + 160, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 37, + 69, + 1, + 130, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 1, + 3, + 2, + 1, + 2 + ], + "matrix_rows": [ + 20, + 416, + 68, + 21, + 34, + 64, + 72, + 256, + 384 + ], + "offset": 248, + "phase": 3, + "quadratic_rows": [ + 20, + 32, + 1, + 0, + 17, + 162, + 0, + 160, + 0 + ] + } + } + } + }, + { + "new": 972, + "old": 498, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 64, + 130, + 260, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 3, + 0, + 2, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 384, + 5, + 418, + 65, + 386, + 84, + 8, + 64, + 256 + ], + "offset": 258, + "phase": 3, + "quadratic_rows": [ + 69, + 34, + 85, + 0, + 4, + 130, + 5, + 288, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 20, + 34, + 64, + 130, + 260, + 2, + 1, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 5, + 418, + 65, + 386, + 84, + 8, + 64, + 256 + ], + "offset": 262, + "phase": 1, + "quadratic_rows": [ + 69, + 34, + 85, + 0, + 4, + 130, + 5, + 288, + 384 + ] + } + } + } + }, + { + "new": 891, + "old": 511, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 132, + 135, + 24, + 133, + 128, + 104, + 80, + 64, + 256 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 3, + 5, + 130, + 120, + 88, + 8, + 24, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 132, + 135, + 24, + 133, + 128, + 104, + 80, + 64, + 256 + ], + "offset": 22, + "phase": 1, + "quadratic_rows": [ + 3, + 5, + 130, + 120, + 88, + 8, + 24, + 132, + 0 + ] + } + } + } + }, + { + "new": 957, + "old": 511, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 2, + 135, + 24, + 3, + 128, + 72, + 112, + 64, + 256 + ], + "offset": 29, + "phase": 1, + "quadratic_rows": [ + 133, + 4, + 131, + 88, + 120, + 16, + 24, + 133, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 3, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 2, + 135, + 24, + 3, + 128, + 72, + 112, + 64, + 256 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 133, + 4, + 131, + 88, + 120, + 16, + 24, + 133, + 0 + ] + } + } + } + }, + { + "new": 892, + "old": 512, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 260, + 263, + 24, + 261, + 256, + 104, + 80, + 64, + 128 + ], + "offset": 20, + "phase": 3, + "quadratic_rows": [ + 3, + 5, + 258, + 120, + 88, + 8, + 24, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 18, + 1, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 260, + 263, + 24, + 261, + 256, + 104, + 80, + 64, + 128 + ], + "offset": 22, + "phase": 1, + "quadratic_rows": [ + 3, + 5, + 258, + 120, + 88, + 8, + 24, + 0, + 260 + ] + } + } + } + }, + { + "new": 958, + "old": 512, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 3, + 3, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 2, + 263, + 24, + 3, + 256, + 72, + 112, + 64, + 128 + ], + "offset": 29, + "phase": 1, + "quadratic_rows": [ + 261, + 4, + 259, + 88, + 120, + 16, + 24, + 0, + 261 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 17, + 2, + 36, + 68, + 132, + 4, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 2, + 3, + 3, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 2, + 263, + 24, + 3, + 256, + 72, + 112, + 64, + 128 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 261, + 4, + 259, + 88, + 120, + 16, + 24, + 0, + 261 + ] + } + } + } + }, + { + "new": 897, + "old": 513, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 71, + 1, + 130, + 5, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 1, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 297, + 25, + 108, + 341, + 38, + 256, + 296, + 320, + 384 + ], + "offset": 232, + "phase": 1, + "quadratic_rows": [ + 100, + 36, + 27, + 124, + 348, + 299, + 25, + 0, + 304 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 39, + 71, + 1, + 130, + 5, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 297, + 25, + 108, + 341, + 38, + 256, + 296, + 320, + 384 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 100, + 36, + 27, + 124, + 348, + 299, + 25, + 0, + 304 + ] + } + } + } + }, + { + "new": 951, + "old": 513, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 39, + 1, + 71, + 131, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 3, + 3, + 3, + 0, + 0, + 3 + ], + "matrix_rows": [ + 305, + 340, + 25, + 109, + 38, + 256, + 304, + 320, + 384 + ], + "offset": 226, + "phase": 1, + "quadratic_rows": [ + 324, + 36, + 27, + 124, + 348, + 298, + 25, + 0, + 305 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 16, + 39, + 1, + 71, + 131, + 4, + 263, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 1, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 3, + 1, + 0, + 0, + 1 + ], + "matrix_rows": [ + 305, + 340, + 25, + 109, + 38, + 256, + 304, + 320, + 384 + ], + "offset": 225, + "phase": 2, + "quadratic_rows": [ + 324, + 36, + 27, + 124, + 348, + 298, + 25, + 0, + 305 + ] + } + } + } + }, + { + "new": 898, + "old": 514, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 68, + 128, + 2, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 4, + 97, + 264, + 5, + 38, + 64, + 256, + 16, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 101, + 36, + 99, + 0, + 0, + 103, + 101, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 68, + 128, + 2, + 1, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 0, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 4, + 97, + 264, + 5, + 38, + 64, + 256, + 16, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 101, + 36, + 99, + 0, + 0, + 103, + 101, + 0, + 0 + ] + } + } + } + }, + { + "new": 952, + "old": 514, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 64, + 132, + 1, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 100, + 97, + 272, + 101, + 38, + 64, + 8, + 256, + 384 + ], + "offset": 61, + "phase": 0, + "quadratic_rows": [ + 5, + 36, + 99, + 0, + 0, + 102, + 100, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 10, + 16, + 35, + 64, + 132, + 1, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 100, + 97, + 272, + 101, + 38, + 64, + 8, + 256, + 384 + ], + "offset": 59, + "phase": 1, + "quadratic_rows": [ + 5, + 36, + 99, + 0, + 0, + 102, + 100, + 0, + 0 + ] + } + } + } + }, + { + "new": 913, + "old": 515, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 144, + 6, + 153, + 145, + 98, + 68, + 128, + 64, + 256 + ], + "offset": 66, + "phase": 3, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 136, + 2, + 6, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 144, + 6, + 153, + 145, + 98, + 68, + 128, + 64, + 256 + ], + "offset": 70, + "phase": 1, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 136, + 2, + 6, + 144, + 0 + ] + } + } + } + }, + { + "new": 967, + "old": 515, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 1, + 0 + ], + "matrix_rows": [ + 8, + 6, + 153, + 9, + 66, + 100, + 128, + 64, + 256 + ], + "offset": 75, + "phase": 1, + "quadratic_rows": [ + 145, + 70, + 102, + 16, + 137, + 4, + 6, + 145, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 5, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 2, + 2, + 0, + 3, + 0 + ], + "matrix_rows": [ + 8, + 6, + 153, + 9, + 66, + 100, + 128, + 64, + 256 + ], + "offset": 79, + "phase": 1, + "quadratic_rows": [ + 145, + 70, + 102, + 16, + 137, + 4, + 6, + 145, + 0 + ] + } + } + } + }, + { + "new": 914, + "old": 516, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 272, + 6, + 281, + 273, + 98, + 68, + 256, + 64, + 128 + ], + "offset": 66, + "phase": 3, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 264, + 2, + 6, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 68, + 1, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 272, + 6, + 281, + 273, + 98, + 68, + 256, + 64, + 128 + ], + "offset": 70, + "phase": 1, + "quadratic_rows": [ + 9, + 102, + 70, + 17, + 264, + 2, + 6, + 0, + 272 + ] + } + } + } + }, + { + "new": 968, + "old": 516, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 1 + ], + "matrix_rows": [ + 8, + 6, + 281, + 9, + 66, + 100, + 256, + 64, + 128 + ], + "offset": 75, + "phase": 1, + "quadratic_rows": [ + 273, + 70, + 102, + 16, + 265, + 4, + 6, + 0, + 273 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 34, + 65, + 4, + 130, + 2, + 256, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 8, + 6, + 281, + 9, + 66, + 100, + 256, + 64, + 128 + ], + "offset": 79, + "phase": 1, + "quadratic_rows": [ + 273, + 70, + 102, + 16, + 265, + 4, + 6, + 0, + 273 + ] + } + } + } + }, + { + "new": 907, + "old": 517, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 5, + 32, + 65, + 130, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 3, + 3, + 0, + 3, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 291, + 117, + 337, + 341, + 290, + 56, + 256, + 320, + 384 + ], + "offset": 222, + "phase": 3, + "quadratic_rows": [ + 339, + 3, + 292, + 48, + 345, + 300, + 337, + 0, + 117 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 17, + 5, + 32, + 65, + 130, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 1, + 0, + 3, + 3, + 1, + 0, + 0 + ], + "matrix_rows": [ + 291, + 117, + 337, + 341, + 290, + 56, + 256, + 320, + 384 + ], + "offset": 221, + "phase": 2, + "quadratic_rows": [ + 339, + 3, + 292, + 48, + 345, + 300, + 337, + 0, + 117 + ] + } + } + } + }, + { + "new": 969, + "old": 517, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 65, + 133, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 1, + 0, + 3, + 0, + 1 + ], + "matrix_rows": [ + 293, + 113, + 339, + 115, + 292, + 56, + 256, + 320, + 384 + ], + "offset": 208, + "phase": 0, + "quadratic_rows": [ + 117, + 290, + 5, + 48, + 121, + 347, + 113, + 0, + 290 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 15, + 3, + 17, + 32, + 65, + 133, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 1, + 2, + 3, + 0, + 3 + ], + "matrix_rows": [ + 293, + 113, + 339, + 115, + 292, + 56, + 256, + 320, + 384 + ], + "offset": 213, + "phase": 3, + "quadratic_rows": [ + 117, + 290, + 5, + 48, + 121, + 347, + 113, + 0, + 290 + ] + } + } + } + }, + { + "new": 908, + "old": 518, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 64, + 133, + 4, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 16, + 258, + 97, + 17, + 256, + 4, + 56, + 64, + 384 + ], + "offset": 203, + "phase": 0, + "quadratic_rows": [ + 113, + 0, + 0, + 48, + 105, + 121, + 113, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 18, + 32, + 64, + 133, + 4, + 1, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 2, + 0, + 3, + 3, + 0, + 2 + ], + "matrix_rows": [ + 16, + 258, + 97, + 17, + 256, + 4, + 56, + 64, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 113, + 0, + 0, + 48, + 105, + 121, + 113, + 0, + 0 + ] + } + } + } + }, + { + "new": 970, + "old": 518, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 97, + 113, + 2, + 256, + 56, + 64, + 384 + ], + "offset": 203, + "phase": 0, + "quadratic_rows": [ + 17, + 0, + 0, + 48, + 105, + 120, + 112, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 12, + 16, + 34, + 64, + 133, + 1, + 4, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 112, + 260, + 97, + 113, + 2, + 256, + 56, + 64, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 17, + 0, + 0, + 48, + 105, + 120, + 112, + 0, + 0 + ] + } + } + } + }, + { + "new": 305, + "old": 626, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 3, + 2, + 3, + 0 + ], + "matrix_rows": [ + 230, + 1, + 322, + 324, + 8, + 16, + 288, + 256, + 384 + ], + "offset": 141, + "phase": 1, + "quadratic_rows": [ + 0, + 422, + 422, + 0, + 0, + 486, + 416, + 486, + 230 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 3, + 0, + 3, + 0 + ], + "matrix_rows": [ + 230, + 1, + 322, + 324, + 8, + 16, + 288, + 256, + 384 + ], + "offset": 141, + "phase": 0, + "quadratic_rows": [ + 0, + 422, + 422, + 0, + 0, + 486, + 416, + 486, + 230 + ] + } + } + } + }, + { + "new": 303, + "old": 629, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 1, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 304, + "old": 634, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 129, + 193, + 66, + 4, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 65, + 64, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + "matrix_rows": [ + 129, + 193, + 66, + 4, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 65, + 64, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + } + } + }, + { + "new": 305, + "old": 798, + "rank": 1, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 70, + 1, + 66, + 68, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 70, + 1, + 66, + 68, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 885, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 2, + 260, + 64, + 80, + 96 + ], + "offset": 72, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 0, + 0, + 8, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 2, + 260, + 64, + 80, + 96 + ], + "offset": 73, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 0, + 0, + 8, + 256, + 384 + ] + } + } + } + }, + { + "new": 1, + "old": 886, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 257, + 2, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 4, + 320, + 64, + 352 + ], + "offset": 192, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 320, + 0, + 24, + 256, + 144 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 257, + 2, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 4, + 320, + 64, + 352 + ], + "offset": 195, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 64, + 320, + 0, + 24, + 256, + 144 + ] + } + } + } + }, + { + "new": 1, + "old": 887, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 136, + 272, + 320, + 2, + 324, + 128, + 64, + 160 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 320, + 0, + 17, + 0, + 272 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 136, + 272, + 320, + 2, + 324, + 128, + 64, + 160 + ], + "offset": 231, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 320, + 0, + 17, + 0, + 272 + ] + } + } + } + }, + { + "new": 1, + "old": 888, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 264, + 144, + 192, + 2, + 196, + 256, + 64, + 288 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 192, + 0, + 17, + 144, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 66, + 132, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 264, + 144, + 192, + 2, + 196, + 256, + 64, + 288 + ], + "offset": 231, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 0, + 0, + 192, + 0, + 17, + 144, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 901, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 68, + 4, + 133, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 82, + 260, + 8, + 1, + 80, + 256, + 16, + 96, + 384 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 16, + 8, + 0, + 0, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 34, + 68, + 4, + 133, + 5, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 82, + 260, + 8, + 1, + 80, + 256, + 16, + 96, + 384 + ], + "offset": 98, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 16, + 8, + 0, + 0, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 902, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 68, + 133, + 6, + 7, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 1, + 1, + 0, + 1 + ], + "matrix_rows": [ + 353, + 98, + 8, + 96, + 256, + 260, + 288, + 336, + 384 + ], + "offset": 30, + "phase": 1, + "quadratic_rows": [ + 256, + 352, + 0, + 288, + 0, + 106, + 98, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 34, + 68, + 133, + 6, + 7, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 3 + ], + "matrix_rows": [ + 353, + 98, + 8, + 96, + 256, + 260, + 288, + 336, + 384 + ], + "offset": 31, + "phase": 1, + "quadratic_rows": [ + 256, + 352, + 0, + 288, + 0, + 106, + 98, + 0, + 267 + ] + } + } + } + }, + { + "new": 1, + "old": 909, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 130, + 260, + 320, + 128, + 64, + 8, + 336, + 160 + ], + "offset": 176, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 320, + 0, + 0, + 0, + 5, + 0, + 260 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 130, + 260, + 320, + 128, + 64, + 8, + 336, + 160 + ], + "offset": 183, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 320, + 0, + 0, + 0, + 5, + 0, + 260 + ] + } + } + } + }, + { + "new": 1, + "old": 910, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 258, + 132, + 192, + 256, + 64, + 8, + 208, + 288 + ], + "offset": 176, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 192, + 0, + 0, + 0, + 5, + 132, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 64, + 129, + 258, + 4, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 258, + 132, + 192, + 256, + 64, + 8, + 208, + 288 + ], + "offset": 183, + "phase": 0, + "quadratic_rows": [ + 64, + 0, + 192, + 0, + 0, + 0, + 5, + 132, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 918, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 68, + 135, + 5, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 2 + ], + "matrix_rows": [ + 353, + 100, + 8, + 256, + 258, + 352, + 288, + 336, + 384 + ], + "offset": 45, + "phase": 1, + "quadratic_rows": [ + 96, + 0, + 256, + 288, + 0, + 361, + 353, + 0, + 108 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 68, + 135, + 5, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 0 + ], + "matrix_rows": [ + 353, + 100, + 8, + 256, + 258, + 352, + 288, + 336, + 384 + ], + "offset": 47, + "phase": 1, + "quadratic_rows": [ + 96, + 0, + 256, + 288, + 0, + 361, + 353, + 0, + 108 + ] + } + } + } + }, + { + "new": 279, + "old": 921, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 39, + 68, + 6, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 1, + 2, + 1, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 341, + 6, + 92, + 256, + 320, + 276, + 336, + 288, + 384 + ], + "offset": 237, + "phase": 3, + "quadratic_rows": [ + 84, + 324, + 31, + 260, + 341, + 0, + 339, + 0, + 90 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 39, + 68, + 6, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 5, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 2, + 1, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 341, + 6, + 92, + 256, + 320, + 276, + 336, + 288, + 384 + ], + "offset": 233, + "phase": 1, + "quadratic_rows": [ + 84, + 324, + 31, + 260, + 341, + 0, + 339, + 0, + 90 + ] + } + } + } + }, + { + "new": 279, + "old": 922, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 38, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 38, + 4, + 256, + 64, + 100, + 8, + 80, + 384 + ], + "offset": 184, + "phase": 1, + "quadratic_rows": [ + 0, + 100, + 66, + 0, + 0, + 98, + 38, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 38, + 64, + 130, + 4, + 6, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 38, + 4, + 256, + 64, + 100, + 8, + 80, + 384 + ], + "offset": 189, + "phase": 2, + "quadratic_rows": [ + 0, + 100, + 66, + 0, + 0, + 98, + 38, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 923, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 66, + 2, + 132, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 1, + 0, + 1, + 0, + 2 + ], + "matrix_rows": [ + 257, + 84, + 124, + 256, + 2, + 92, + 16, + 64, + 384 + ], + "offset": 14, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 112, + 56, + 124, + 28, + 84, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 38, + 66, + 2, + 132, + 4, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 257, + 84, + 124, + 256, + 2, + 92, + 16, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 112, + 56, + 124, + 28, + 84, + 0, + 0 + ] + } + } + } + }, + { + "new": 281, + "old": 924, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 68, + 134, + 7, + 5, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 3, + 2, + 0, + 1, + 3, + 0, + 3 + ], + "matrix_rows": [ + 109, + 354, + 8, + 256, + 96, + 268, + 320, + 304, + 384 + ], + "offset": 137, + "phase": 0, + "quadratic_rows": [ + 364, + 256, + 357, + 33, + 0, + 109, + 101, + 0, + 263 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 68, + 134, + 7, + 5, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 3, + 2, + 0, + 1, + 3, + 0, + 1 + ], + "matrix_rows": [ + 109, + 354, + 8, + 256, + 96, + 268, + 320, + 304, + 384 + ], + "offset": 139, + "phase": 0, + "quadratic_rows": [ + 364, + 256, + 357, + 33, + 0, + 109, + 101, + 0, + 263 + ] + } + } + } + }, + { + "new": 1, + "old": 925, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 66, + 132, + 256, + 1, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 130, + 260, + 64, + 128, + 320, + 136, + 336, + 32 + ], + "offset": 152, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 64, + 0, + 0, + 0, + 5, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 66, + 132, + 256, + 1, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 130, + 260, + 64, + 128, + 320, + 136, + 336, + 32 + ], + "offset": 159, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 64, + 0, + 0, + 0, + 5, + 0, + 257 + ] + } + } + } + }, + { + "new": 280, + "old": 929, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 3, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 130, + 260, + 39, + 128, + 256, + 136, + 272, + 64 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 167, + 39, + 39, + 0, + 0, + 7, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 3, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 0, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 130, + 260, + 39, + 128, + 256, + 136, + 272, + 64 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 167, + 39, + 39, + 0, + 0, + 7, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 930, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 3, + 3, + 1, + 0, + 0, + 2, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 258, + 132, + 39, + 256, + 128, + 264, + 144, + 64 + ], + "offset": 97, + "phase": 0, + "quadratic_rows": [ + 295, + 39, + 39, + 0, + 0, + 7, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 19, + 37, + 67, + 133, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 258, + 132, + 39, + 256, + 128, + 264, + 144, + 64 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 295, + 39, + 39, + 0, + 0, + 7, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 279, + "old": 931, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 128, + 257, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 5, + 258, + 384, + 64, + 256, + 68, + 264, + 16, + 96 + ], + "offset": 312, + "phase": 1, + "quadratic_rows": [ + 68, + 0, + 69, + 0, + 0, + 0, + 5, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 33, + 66, + 128, + 257, + 1, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 5, + 258, + 384, + 64, + 256, + 68, + 264, + 16, + 96 + ], + "offset": 314, + "phase": 1, + "quadratic_rows": [ + 68, + 0, + 69, + 0, + 0, + 0, + 5, + 256, + 384 + ] + } + } + } + }, + { + "new": 279, + "old": 932, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 128, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 257, + 260, + 384, + 64, + 2, + 356, + 8, + 16, + 320 + ], + "offset": 10, + "phase": 3, + "quadratic_rows": [ + 320, + 0, + 100, + 0, + 0, + 4, + 5, + 256, + 129 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 34, + 64, + 128, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 0, + 2, + 2, + 0, + 2 + ], + "matrix_rows": [ + 257, + 260, + 384, + 64, + 2, + 356, + 8, + 16, + 320 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 320, + 0, + 100, + 0, + 0, + 4, + 5, + 256, + 129 + ] + } + } + } + }, + { + "new": 279, + "old": 953, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 7, + 132, + 6, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 3, + 0, + 1, + 0, + 1 + ], + "matrix_rows": [ + 341, + 6, + 88, + 80, + 320, + 276, + 256, + 288, + 384 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 260, + 324, + 67, + 336, + 88, + 0, + 94, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 7, + 132, + 6, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 0, + 1, + 0, + 3 + ], + "matrix_rows": [ + 341, + 6, + 88, + 80, + 320, + 276, + 256, + 288, + 384 + ], + "offset": 225, + "phase": 2, + "quadratic_rows": [ + 260, + 324, + 67, + 336, + 88, + 0, + 94, + 0, + 267 + ] + } + } + } + }, + { + "new": 279, + "old": 954, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 130, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 2, + 1, + 2, + 0, + 2 + ], + "matrix_rows": [ + 54, + 48, + 264, + 1, + 96, + 116, + 256, + 64, + 384 + ], + "offset": 82, + "phase": 0, + "quadratic_rows": [ + 0, + 84, + 70, + 0, + 34, + 48, + 6, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 17, + 33, + 68, + 130, + 3, + 2, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 2, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 54, + 48, + 264, + 1, + 96, + 116, + 256, + 64, + 384 + ], + "offset": 85, + "phase": 0, + "quadratic_rows": [ + 0, + 84, + 70, + 0, + 34, + 48, + 6, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 955, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 2, + 131, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 2, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 21, + 16, + 264, + 64, + 2, + 84, + 256, + 96, + 384 + ], + "offset": 74, + "phase": 0, + "quadratic_rows": [ + 84, + 0, + 69, + 0, + 65, + 0, + 21, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 16, + 33, + 68, + 2, + 131, + 3, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 21, + 16, + 264, + 64, + 2, + 84, + 256, + 96, + 384 + ], + "offset": 76, + "phase": 3, + "quadratic_rows": [ + 84, + 0, + 69, + 0, + 65, + 0, + 21, + 0, + 0 + ] + } + } + } + }, + { + "new": 279, + "old": 956, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 132, + 7, + 5, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 3, + 1, + 0, + 1 + ], + "matrix_rows": [ + 5, + 358, + 104, + 320, + 96, + 292, + 256, + 272, + 384 + ], + "offset": 224, + "phase": 0, + "quadratic_rows": [ + 324, + 260, + 67, + 352, + 0, + 104, + 109, + 0, + 267 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 35, + 68, + 132, + 7, + 5, + 260, + 4 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 2, + 0, + 3, + 1, + 0, + 3 + ], + "matrix_rows": [ + 5, + 358, + 104, + 320, + 96, + 292, + 256, + 272, + 384 + ], + "offset": 226, + "phase": 2, + "quadratic_rows": [ + 324, + 260, + 67, + 352, + 0, + 104, + 109, + 0, + 267 + ] + } + } + } + }, + { + "new": 280, + "old": 961, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 2, + 0, + 1, + 2 + ], + "matrix_rows": [ + 129, + 281, + 136, + 317, + 2, + 288, + 128, + 32, + 192 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 164, + 0, + 25, + 36, + 20, + 9, + 0, + 129, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 5, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 1, + 2, + 0, + 3, + 2 + ], + "matrix_rows": [ + 129, + 281, + 136, + 317, + 2, + 288, + 128, + 32, + 192 + ], + "offset": 388, + "phase": 3, + "quadratic_rows": [ + 164, + 0, + 25, + 36, + 20, + 9, + 0, + 129, + 0 + ] + } + } + } + }, + { + "new": 280, + "old": 962, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 2, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 153, + 264, + 189, + 2, + 160, + 256, + 32, + 320 + ], + "offset": 387, + "phase": 1, + "quadratic_rows": [ + 292, + 0, + 25, + 36, + 20, + 9, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 16, + 35, + 69, + 129, + 1, + 261, + 2, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 1, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 153, + 264, + 189, + 2, + 160, + 256, + 32, + 320 + ], + "offset": 388, + "phase": 3, + "quadratic_rows": [ + 292, + 0, + 25, + 36, + 20, + 9, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 281, + "old": 963, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 2, + 2, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 258, + 12, + 64, + 80, + 96 + ], + "offset": 488, + "phase": 2, + "quadratic_rows": [ + 0, + 0, + 8, + 76, + 0, + 0, + 8, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 32, + 66, + 130, + 258, + 2, + 4, + 5 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 4, + 2, + 5, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 0, + 0, + 2, + 0, + 3 + ], + "matrix_rows": [ + 257, + 8, + 384, + 256, + 258, + 12, + 64, + 80, + 96 + ], + "offset": 489, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 8, + 76, + 0, + 0, + 8, + 256, + 384 + ] + } + } + } + }, + { + "new": 281, + "old": 964, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 3, + 2, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 12, + 64, + 320, + 352 + ], + "offset": 352, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 8, + 332, + 64, + 0, + 24, + 256, + 136 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 8, + 16, + 32, + 65, + 130, + 258, + 1, + 4, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 6, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 1, + 2, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 264, + 272, + 384, + 1, + 2, + 12, + 64, + 320, + 352 + ], + "offset": 355, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 8, + 332, + 64, + 0, + 24, + 256, + 136 + ] + } + } + } + }, + { + "new": 1, + "old": 973, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 66, + 129, + 1, + 256, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 3 + ], + "matrix_rows": [ + 1, + 260, + 384, + 32, + 34, + 256, + 264, + 48, + 64 + ], + "offset": 40, + "phase": 3, + "quadratic_rows": [ + 32, + 0, + 0, + 0, + 0, + 1, + 0, + 256, + 384 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 3, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 17, + 34, + 66, + 129, + 1, + 256, + 4, + 6 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 3 + ], + "matrix_rows": [ + 1, + 260, + 384, + 32, + 34, + 256, + 264, + 48, + 64 + ], + "offset": 42, + "phase": 3, + "quadratic_rows": [ + 32, + 0, + 0, + 0, + 0, + 1, + 0, + 256, + 384 + ] + } + } + } + }, + { + "new": 1, + "old": 977, + "rank": 3, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 68, + 130, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 257, + 258, + 132, + 32, + 288, + 128, + 136, + 304, + 64 + ], + "offset": 168, + "phase": 0, + "quadratic_rows": [ + 288, + 32, + 0, + 0, + 0, + 3, + 0, + 0, + 257 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 9, + 18, + 36, + 68, + 130, + 1, + 256, + 4, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "matrix_rows": [ + 257, + 258, + 132, + 32, + 288, + 128, + 136, + 304, + 64 + ], + "offset": 175, + "phase": 0, + "quadratic_rows": [ + 288, + 32, + 0, + 0, + 0, + 3, + 0, + 0, + 257 + ] + } + } + } + }, + { + "new": 1, + "old": 988, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 3, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 0 + ], + "matrix_rows": [ + 65, + 66, + 96, + 32, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 72, + "phase": 0, + "quadratic_rows": [ + 32, + 96, + 0, + 0, + 0, + 3, + 66, + 0, + 0 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 3, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 65, + 66, + 96, + 32, + 4, + 8, + 112, + 128, + 256 + ], + "offset": 75, + "phase": 0, + "quadratic_rows": [ + 32, + 96, + 0, + 0, + 0, + 3, + 66, + 0, + 0 + ] + } + } + } + }, + { + "new": 1, + "old": 996, + "rank": 2, + "recipes": { + "backward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 128, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3 + ], + "matrix_rows": [ + 257, + 258, + 288, + 32, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 72, + "phase": 0, + "quadratic_rows": [ + 32, + 288, + 0, + 0, + 0, + 3, + 0, + 0, + 258 + ] + } + }, + "forward": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 10, + 16, + 32, + 65, + 2, + 128, + 256, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 257, + 258, + 288, + 32, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 75, + "phase": 0, + "quadratic_rows": [ + 32, + 288, + 0, + 0, + 0, + 3, + 0, + 0, + 258 + ] + } + } + } + } + ], + "paid": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "status": "PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS" + }, + "retimed_source_head": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9", + "retimed_source_sha256": { + "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7", + "research/kappa-function-composition/complex/prune_native.py": "f2b37c183a10922eabc8e0436b426a08866430e96bd0adc7e178951c7fbb5257", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "research/kappa-rebuild/complex/native_extensions.py": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3", + "research/kappa-rebuild/complex/power_two_balance.py": "76929bb3887911ccf100c4593574b8a1c82ee64e96f939a8aca196869438b424", + "research/kappa-rebuild/complex/rebuild_native.py": "f94c527cc02215de49350d477618188c4c0da48bc8fb05b4e37b24c482cad7d5", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "scalar_contact_frames_retimed": 395, + "schema": "source-bound-retimed-arbitrary-native-supplier/1", + "status": "PASS_ALL_632_INPUTS_BOTH_DIRECTIONS_AND_ALL_RETIMED_HELPER_PHASES", + "whole_helper_boundary_recipes": 408 + }, + "local_supplier_source_sha256": "8542575d046c9488574dbf1ca258bbdc6ff7dc66db778cba3b0027b7b4673653", + "main_contact_checks": 8512, + "native_and_boundary_scalar_allowance": 3385896, + "native_mask": 28633115307, + "native_stage_indices": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "native_stages": 19, + "omitted_direct_inverse_translation_rejected": 112, + "omitted_endpoint_translation_rejected": 1904, + "owned_bank_scope": "Each direct copy persists across its own recursive request and is released after the ADD. Each native invocation retains its original owned center. All nested suspended banks are separately charged.", + "p": 17, + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 69273, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "productive_fields": 11560, + "productive_main_fields": 3808, + "rank_margin": 800, + "raw_owned_bank_episodes": 1811, + "scalar_allowance": 3500584, + "schema": "complete-source-bound-hybrid-p17-native-inventory/1", + "source_sha256": { + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/kappa-rebuild/transfer-audit/p3_native_audit.py": "5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902" + }, + "status": "PASS_RETIMED_SUPPLIER_AND_ALL_HYBRID_CONTROLLER_PHASES", + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + }, + "whole_idle_profile": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "wrong_direct_orientation_rejected": true + }, + "new_max_target_encoding": "153^17160", + "new_min_target_encoding": "19^17160", + "normalized_moment_upper_rational": "262144250000429/262144449839104", + "paid": { + "1": 44599, + "16": 448, + "2": 9785, + "24": 448, + "3": 8455, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_rank_one_moment": 259998, + "parameters_sha256": "c12bc02374d8aa5947d15098288394beff52fc417ee5e5c72bd6b0c83f4b1d80", + "productive_fields": 11560, + "rank_one_surplus_encoding": "260798^17160-259998^17160", + "schema": "hybrid-p17-paid-completion-certificate/1", + "scope": "Exact moment bounds for the documented chronological native product, paid target completion and disjoint splitting. Native all-column, precision, storage, analytic and fixed-tape premises remain separate; no full multiplication theorem is formally verified.", + "source_sha256": { + "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + "status": "PASS_EXACT_HYBRID_P17_TARGET_COMPLETION_STRICTIFICATION", + "strict_moment_verified": true, + "strictification_gap": { + "lower": "0.00000076232273894280302102501592107", + "upper": "0.00000076232273894280302102501592108" + }, + "strictification_gap_rational": "199838675/262144449839104", + "target_floor_base": 19, + "target_floor_encoding": "19^17160", + "target_rank_one_moment": 260798, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 494, + "41": 448, + "49": 448, + "5": 38, + "57": 448, + "65": 448, + "7": 551, + "73": 448, + "8": 798, + "9": 5871 + }, + "tested_saving": "1500527/500000000", + "theta_upper": "54/55" +} diff --git a/research/kappa-hybrid-controller/controller/P17-DIRECT-CASE.json b/research/kappa-hybrid-controller/controller/P17-DIRECT-CASE.json new file mode 100644 index 0000000000..cae8ca2fd0 --- /dev/null +++ b/research/kappa-hybrid-controller/controller/P17-DIRECT-CASE.json @@ -0,0 +1,48473 @@ +{ + "schema": "exact-p17-direct-stage-Laurent-specialization/1", + "source_sha256": { + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + "source_full_case_sha256": "b6a480b2c8c21520a73d74871f360acee7a4b0c6979314d1c2e67fa3641fee33", + "pairs": 17, + "cut": 8, + "keep_idle_mask": 280378328416255, + "native_stage_mask": 28633115307, + "native_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "direct_stages": [ + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32 + ], + "coefficient_variables": [ + "Q", + "D0", + "D1", + "D2", + "D3", + "D4", + "D5", + "D6", + "D7", + "D8", + "D9", + "D10", + "D11", + "D12", + "D13", + "D14", + "D15", + "D16", + "D17", + "D18", + "D19", + "D20", + "D21", + "D22", + "D23", + "D24", + "D25", + "D26", + "D27", + "D28", + "D29", + "D30", + "D31", + "D32", + "D33", + "D34" + ], + "specialized_coefficient_matrices": [ + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + } + ], + "left": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 29, + 31 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "SWAP", + 27, + 30 + ], + [ + "SWAP", + 25, + 27 + ], + [ + "SWAP", + 24, + 31 + ], + [ + "SWAP", + 23, + 27 + ], + [ + "SWAP", + 22, + 27 + ], + [ + "SWAP", + 21, + 23 + ], + [ + "SWAP", + 20, + 30 + ], + [ + "SWAP", + 19, + 24 + ], + [ + "SWAP", + 18, + 28 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 14, + 16, + "1" + ], + [ + "ADD", + 12, + 16, + "-1" + ], + [ + "ADD", + 10, + 16, + "1" + ], + [ + "ADD", + 8, + 16, + "-1" + ], + [ + "ADD", + 6, + 16, + "1" + ], + [ + "ADD", + 4, + 16, + "-1" + ], + [ + "ADD", + 2, + 16, + "1" + ], + [ + "ADD", + 0, + 16, + "-1" + ], + [ + "ADD", + 33, + 15, + "-1" + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 33, + 13, + "1" + ], + [ + "ADD", + 32, + 13, + "1" + ], + [ + "SWAP", + 13, + 31 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 33, + 11, + "-1" + ], + [ + "ADD", + 32, + 11, + "-1" + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 30 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 33, + 9, + "1" + ], + [ + "ADD", + 32, + 9, + "1" + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "SWAP", + 9, + 29 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 33, + 7, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 28 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 33, + 5, + "1" + ], + [ + "ADD", + 32, + 5, + "1" + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "SWAP", + 5, + 27 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 33, + 3, + "-1" + ], + [ + "ADD", + 32, + 3, + "-1" + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 26 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 33, + 1, + "1" + ], + [ + "ADD", + 32, + 1, + "1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right_program": [ + [ + "ADD", + 33, + 32, + "-1" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 32, + 31, + "1" + ], + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "SWAP", + 29, + 30 + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 31, + 27, + "1" + ], + [ + "ADD", + 26, + 27, + "-1" + ], + [ + "ADD", + 25, + 27, + "-1" + ], + [ + "SWAP", + 27, + 30 + ], + [ + "ADD", + 30, + 26, + "1" + ], + [ + "ADD", + 25, + 26, + "-1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 30, + 25, + "1" + ], + [ + "SWAP", + 25, + 26 + ], + [ + "SWAP", + 24, + 29 + ], + [ + "SWAP", + 23, + 25 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 27 + ], + [ + "SWAP", + 19, + 29 + ], + [ + "SWAP", + 18, + 31 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 15, + 16, + "-1" + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 32 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 24 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 32 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 20 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 24 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "SWAP", + 8, + 32 + ], + [ + "SWAP", + 7, + 18 + ], + [ + "SWAP", + 6, + 20 + ], + [ + "SWAP", + 5, + 22 + ], + [ + "SWAP", + 4, + 24 + ], + [ + "SWAP", + 3, + 26 + ], + [ + "SWAP", + 2, + 28 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 0, + 32 + ] + ], + "exact_diagonal_monomials": [ + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ] + ], + "every_specialized_Laurent_coefficient_checked": true, + "incorrect_backward_sign_rejected": true, + "main_productive_profile": { + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "native_helper_profile": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + }, + "native_paid_profile": { + "1": 2253, + "2": 515, + "3": 445, + "4": 102, + "5": 40, + "8": 8 + }, + "native_invocations": 19, + "direct_Q_shears": 16, + "direct_rank1_children": 1792, + "complete_paid_profile": { + "1": 44599, + "2": 9785, + "3": 8455, + "4": 1938, + "5": 760, + "8": 152, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "complete_productive_profile": { + "4": 494, + "5": 38, + "7": 551, + "8": 798, + "9": 5871, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "retained_idle_windows": [ + { + "index": 0, + "kind": "initial", + "pair": 1, + "stages": [ + 0, + 1 + ], + "rank": 16, + "retained": true, + "active_stages": [ + 0, + 1 + ], + "specialized_rank": 16 + }, + { + "index": 1, + "kind": "middle", + "pair": 1, + "stages": [ + 2 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 2, + "kind": "initial", + "pair": 2, + "stages": [ + 0, + 1, + 2, + 3 + ], + "rank": 32, + "retained": true, + "active_stages": [ + 0, + 1, + 3 + ], + "specialized_rank": 24 + }, + { + "index": 3, + "kind": "middle", + "pair": 2, + "stages": [ + 4 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 4, + "kind": "initial", + "pair": 3, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "rank": 48, + "retained": true, + "active_stages": [ + 0, + 1, + 3, + 5 + ], + "specialized_rank": 32 + }, + { + "index": 5, + "kind": "middle", + "pair": 3, + "stages": [ + 6 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 6, + "kind": "initial", + "pair": 4, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "rank": 64, + "retained": true, + "active_stages": [ + 0, + 1, + 3, + 5, + 7 + ], + "specialized_rank": 40 + }, + { + "index": 7, + "kind": "middle", + "pair": 4, + "stages": [ + 8 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 8, + "kind": "initial", + "pair": 5, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "rank": 80, + "retained": true, + "active_stages": [ + 0, + 1, + 3, + 5, + 7, + 9 + ], + "specialized_rank": 48 + }, + { + "index": 9, + "kind": "middle", + "pair": 5, + "stages": [ + 10 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 10, + "kind": "initial", + "pair": 6, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + "rank": 96, + "retained": true, + "active_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ], + "specialized_rank": 56 + }, + { + "index": 11, + "kind": "middle", + "pair": 6, + "stages": [ + 12 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 12, + "kind": "initial", + "pair": 7, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13 + ], + "rank": 112, + "retained": true, + "active_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ], + "specialized_rank": 64 + }, + { + "index": 13, + "kind": "middle", + "pair": 7, + "stages": [ + 14 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 14, + "kind": "initial", + "pair": 8, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "rank": 128, + "retained": true, + "active_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15 + ], + "specialized_rank": 72 + }, + { + "index": 15, + "kind": "middle", + "pair": 8, + "stages": [ + 16 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 17, + "kind": "middle", + "pair": 9, + "stages": [ + 18 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 19, + "kind": "middle", + "pair": 10, + "stages": [ + 20 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 21, + "kind": "middle", + "pair": 11, + "stages": [ + 22 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 23, + "kind": "middle", + "pair": 12, + "stages": [ + 24 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 25, + "kind": "middle", + "pair": 13, + "stages": [ + 26 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 27, + "kind": "middle", + "pair": 14, + "stages": [ + 28 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 29, + "kind": "middle", + "pair": 15, + "stages": [ + 30 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 31, + "kind": "middle", + "pair": 16, + "stages": [ + 32 + ], + "rank": 8, + "retained": true, + "active_stages": [], + "specialized_rank": 0 + }, + { + "index": 40, + "kind": "terminal", + "pair": 8, + "stages": [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 128, + "retained": true, + "active_stages": [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "specialized_rank": 72 + }, + { + "index": 41, + "kind": "terminal", + "pair": 9, + "stages": [ + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 112, + "retained": true, + "active_stages": [ + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "specialized_rank": 64 + }, + { + "index": 42, + "kind": "terminal", + "pair": 10, + "stages": [ + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 96, + "retained": true, + "active_stages": [ + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "specialized_rank": 56 + }, + { + "index": 43, + "kind": "terminal", + "pair": 11, + "stages": [ + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 80, + "retained": true, + "active_stages": [ + 25, + 27, + 29, + 31, + 33, + 34 + ], + "specialized_rank": 48 + }, + { + "index": 44, + "kind": "terminal", + "pair": 12, + "stages": [ + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 64, + "retained": true, + "active_stages": [ + 27, + 29, + 31, + 33, + 34 + ], + "specialized_rank": 40 + }, + { + "index": 45, + "kind": "terminal", + "pair": 13, + "stages": [ + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 48, + "retained": true, + "active_stages": [ + 29, + 31, + 33, + 34 + ], + "specialized_rank": 32 + }, + { + "index": 46, + "kind": "terminal", + "pair": 14, + "stages": [ + 31, + 32, + 33, + 34 + ], + "rank": 32, + "retained": true, + "active_stages": [ + 31, + 33, + 34 + ], + "specialized_rank": 24 + }, + { + "index": 47, + "kind": "terminal", + "pair": 15, + "stages": [ + 33, + 34 + ], + "rank": 16, + "retained": true, + "active_stages": [ + 33, + 34 + ], + "specialized_rank": 16 + } + ], + "ambient_dimension_with_all_original_stage_coordinates": 281, + "full_Laurent_identity": true, + "physical_direct_shear_and_native_source_bindings_are_separate": true, + "no_interval_or_rounded_transfer_claim": true +} diff --git a/research/kappa-hybrid-controller/controller/P17-FULL-LAURENT-CASE.json b/research/kappa-hybrid-controller/controller/P17-FULL-LAURENT-CASE.json new file mode 100644 index 0000000000..3b133c0fa9 --- /dev/null +++ b/research/kappa-hybrid-controller/controller/P17-FULL-LAURENT-CASE.json @@ -0,0 +1,49977 @@ +{ + "pairs": 17, + "stages": 35, + "keep_idle_mask": 280378328416255, + "coefficient_variables": [ + "Q", + "D0", + "D1", + "D2", + "D3", + "D4", + "D5", + "D6", + "D7", + "D8", + "D9", + "D10", + "D11", + "D12", + "D13", + "D14", + "D15", + "D16", + "D17", + "D18", + "D19", + "D20", + "D21", + "D22", + "D23", + "D24", + "D25", + "D26", + "D27", + "D28", + "D29", + "D30", + "D31", + "D32", + "D33", + "D34" + ], + "coefficient_matrices": [ + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] + } + ], + "left": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 29, + 31 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "SWAP", + 27, + 30 + ], + [ + "SWAP", + 25, + 27 + ], + [ + "SWAP", + 24, + 31 + ], + [ + "SWAP", + 23, + 27 + ], + [ + "SWAP", + 22, + 27 + ], + [ + "SWAP", + 21, + 23 + ], + [ + "SWAP", + 20, + 30 + ], + [ + "SWAP", + 19, + 24 + ], + [ + "SWAP", + 18, + 28 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 14, + 16, + "1" + ], + [ + "ADD", + 12, + 16, + "-1" + ], + [ + "ADD", + 10, + 16, + "1" + ], + [ + "ADD", + 8, + 16, + "-1" + ], + [ + "ADD", + 6, + 16, + "1" + ], + [ + "ADD", + 4, + 16, + "-1" + ], + [ + "ADD", + 2, + 16, + "1" + ], + [ + "ADD", + 0, + 16, + "-1" + ], + [ + "ADD", + 33, + 15, + "-1" + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 33, + 13, + "1" + ], + [ + "ADD", + 32, + 13, + "1" + ], + [ + "SWAP", + 13, + 31 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 33, + 11, + "-1" + ], + [ + "ADD", + 32, + 11, + "-1" + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 30 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 33, + 9, + "1" + ], + [ + "ADD", + 32, + 9, + "1" + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "SWAP", + 9, + 29 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 33, + 7, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 28 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 33, + 5, + "1" + ], + [ + "ADD", + 32, + 5, + "1" + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "SWAP", + 5, + 27 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 33, + 3, + "-1" + ], + [ + "ADD", + 32, + 3, + "-1" + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 26 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 33, + 1, + "1" + ], + [ + "ADD", + 32, + 1, + "1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right_program": [ + [ + "ADD", + 33, + 32, + "-1" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 32, + 31, + "1" + ], + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "SWAP", + 29, + 30 + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 31, + 27, + "1" + ], + [ + "ADD", + 26, + 27, + "-1" + ], + [ + "ADD", + 25, + 27, + "-1" + ], + [ + "SWAP", + 27, + 30 + ], + [ + "ADD", + 30, + 26, + "1" + ], + [ + "ADD", + 25, + 26, + "-1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 30, + 25, + "1" + ], + [ + "SWAP", + 25, + 26 + ], + [ + "SWAP", + 24, + 29 + ], + [ + "SWAP", + 23, + 25 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 27 + ], + [ + "SWAP", + 19, + 29 + ], + [ + "SWAP", + 18, + 31 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 15, + 16, + "-1" + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 32 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 24 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 32 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 20 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 24 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "SWAP", + 8, + 32 + ], + [ + "SWAP", + 7, + 18 + ], + [ + "SWAP", + 6, + 20 + ], + [ + "SWAP", + 5, + 22 + ], + [ + "SWAP", + 4, + 24 + ], + [ + "SWAP", + 3, + 26 + ], + [ + "SWAP", + 2, + 28 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 0, + 32 + ] + ], + "exact_diagonal_monomials": [ + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + ], + "all_boundary_entries_integral": true, + "maximum_boundary_absolute_coefficient": "1", + "endpoint_after_stated_free_Pauli_normalization": { + "25": 448, + "41": 448, + "57": 448, + "73": 448, + "89": 448, + "105": 448, + "121": 448, + "137": 448, + "281": 224 + }, + "retained_idle_windows": [ + { + "index": 0, + "kind": "initial", + "pair": 1, + "stages": [ + 0, + 1 + ], + "rank": 16, + "retained": true + }, + { + "index": 1, + "kind": "middle", + "pair": 1, + "stages": [ + 2 + ], + "rank": 8, + "retained": true + }, + { + "index": 2, + "kind": "initial", + "pair": 2, + "stages": [ + 0, + 1, + 2, + 3 + ], + "rank": 32, + "retained": true + }, + { + "index": 3, + "kind": "middle", + "pair": 2, + "stages": [ + 4 + ], + "rank": 8, + "retained": true + }, + { + "index": 4, + "kind": "initial", + "pair": 3, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "rank": 48, + "retained": true + }, + { + "index": 5, + "kind": "middle", + "pair": 3, + "stages": [ + 6 + ], + "rank": 8, + "retained": true + }, + { + "index": 6, + "kind": "initial", + "pair": 4, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "rank": 64, + "retained": true + }, + { + "index": 7, + "kind": "middle", + "pair": 4, + "stages": [ + 8 + ], + "rank": 8, + "retained": true + }, + { + "index": 8, + "kind": "initial", + "pair": 5, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "rank": 80, + "retained": true + }, + { + "index": 9, + "kind": "middle", + "pair": 5, + "stages": [ + 10 + ], + "rank": 8, + "retained": true + }, + { + "index": 10, + "kind": "initial", + "pair": 6, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + "rank": 96, + "retained": true + }, + { + "index": 11, + "kind": "middle", + "pair": 6, + "stages": [ + 12 + ], + "rank": 8, + "retained": true + }, + { + "index": 12, + "kind": "initial", + "pair": 7, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13 + ], + "rank": 112, + "retained": true + }, + { + "index": 13, + "kind": "middle", + "pair": 7, + "stages": [ + 14 + ], + "rank": 8, + "retained": true + }, + { + "index": 14, + "kind": "initial", + "pair": 8, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "rank": 128, + "retained": true + }, + { + "index": 15, + "kind": "middle", + "pair": 8, + "stages": [ + 16 + ], + "rank": 8, + "retained": true + }, + { + "index": 17, + "kind": "middle", + "pair": 9, + "stages": [ + 18 + ], + "rank": 8, + "retained": true + }, + { + "index": 19, + "kind": "middle", + "pair": 10, + "stages": [ + 20 + ], + "rank": 8, + "retained": true + }, + { + "index": 21, + "kind": "middle", + "pair": 11, + "stages": [ + 22 + ], + "rank": 8, + "retained": true + }, + { + "index": 23, + "kind": "middle", + "pair": 12, + "stages": [ + 24 + ], + "rank": 8, + "retained": true + }, + { + "index": 25, + "kind": "middle", + "pair": 13, + "stages": [ + 26 + ], + "rank": 8, + "retained": true + }, + { + "index": 27, + "kind": "middle", + "pair": 14, + "stages": [ + 28 + ], + "rank": 8, + "retained": true + }, + { + "index": 29, + "kind": "middle", + "pair": 15, + "stages": [ + 30 + ], + "rank": 8, + "retained": true + }, + { + "index": 31, + "kind": "middle", + "pair": 16, + "stages": [ + 32 + ], + "rank": 8, + "retained": true + }, + { + "index": 40, + "kind": "terminal", + "pair": 8, + "stages": [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 128, + "retained": true + }, + { + "index": 41, + "kind": "terminal", + "pair": 9, + "stages": [ + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 112, + "retained": true + }, + { + "index": 42, + "kind": "terminal", + "pair": 10, + "stages": [ + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 96, + "retained": true + }, + { + "index": 43, + "kind": "terminal", + "pair": 11, + "stages": [ + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 80, + "retained": true + }, + { + "index": 44, + "kind": "terminal", + "pair": 12, + "stages": [ + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 64, + "retained": true + }, + { + "index": 45, + "kind": "terminal", + "pair": 13, + "stages": [ + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 48, + "retained": true + }, + { + "index": 46, + "kind": "terminal", + "pair": 14, + "stages": [ + 31, + 32, + 33, + 34 + ], + "rank": 32, + "retained": true + }, + { + "index": 47, + "kind": "terminal", + "pair": 15, + "stages": [ + 33, + 34 + ], + "rank": 16, + "retained": true + } + ], + "omitted_idle_windows": [ + { + "index": 16, + "kind": "initial", + "pair": 9, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "rank": 144, + "retained": false + }, + { + "index": 18, + "kind": "initial", + "pair": 10, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19 + ], + "rank": 160, + "retained": false + }, + { + "index": 20, + "kind": "initial", + "pair": 11, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21 + ], + "rank": 176, + "retained": false + }, + { + "index": 22, + "kind": "initial", + "pair": 12, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "rank": 192, + "retained": false + }, + { + "index": 24, + "kind": "initial", + "pair": 13, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25 + ], + "rank": 208, + "retained": false + }, + { + "index": 26, + "kind": "initial", + "pair": 14, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ], + "rank": 224, + "retained": false + }, + { + "index": 28, + "kind": "initial", + "pair": 15, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ], + "rank": 240, + "retained": false + }, + { + "index": 30, + "kind": "initial", + "pair": 16, + "stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ], + "rank": 256, + "retained": false + }, + { + "index": 32, + "kind": "terminal", + "pair": 0, + "stages": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 256, + "retained": false + }, + { + "index": 33, + "kind": "terminal", + "pair": 1, + "stages": [ + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 240, + "retained": false + }, + { + "index": 34, + "kind": "terminal", + "pair": 2, + "stages": [ + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 224, + "retained": false + }, + { + "index": 35, + "kind": "terminal", + "pair": 3, + "stages": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 208, + "retained": false + }, + { + "index": 36, + "kind": "terminal", + "pair": 4, + "stages": [ + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 192, + "retained": false + }, + { + "index": 37, + "kind": "terminal", + "pair": 5, + "stages": [ + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 176, + "retained": false + }, + { + "index": 38, + "kind": "terminal", + "pair": 6, + "stages": [ + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 160, + "retained": false + }, + { + "index": 39, + "kind": "terminal", + "pair": 7, + "stages": [ + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ], + "rank": 144, + "retained": false + } + ], + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2, + 1 + ], + [ + "ADD", + 3, + 1, + -1 + ], + [ + "LOCAL", + 2, + 0, + false + ], + [ + "IDLE", + 1, + [ + 2 + ] + ], + [ + "ADD", + 0, + 2, + -1 + ], + [ + "ADD", + 3, + 1, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 2, + 3 + ] + ], + [ + "ADD", + 2, + 4, + 1 + ], + [ + "ADD", + 5, + 3, + -1 + ], + [ + "LOCAL", + 4, + 1, + false + ], + [ + "IDLE", + 2, + [ + 4 + ] + ], + [ + "ADD", + 2, + 4, + -1 + ], + [ + "ADD", + 5, + 3, + 1 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + ], + [ + "ADD", + 4, + 6, + 1 + ], + [ + "ADD", + 7, + 5, + -1 + ], + [ + "LOCAL", + 6, + 2, + false + ], + [ + "IDLE", + 3, + [ + 6 + ] + ], + [ + "ADD", + 4, + 6, + -1 + ], + [ + "ADD", + 7, + 5, + 1 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ] + ], + [ + "ADD", + 6, + 8, + 1 + ], + [ + "ADD", + 9, + 7, + -1 + ], + [ + "LOCAL", + 8, + 3, + false + ], + [ + "IDLE", + 4, + [ + 8 + ] + ], + [ + "ADD", + 6, + 8, + -1 + ], + [ + "ADD", + 9, + 7, + 1 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ], + [ + "ADD", + 8, + 10, + 1 + ], + [ + "ADD", + 11, + 9, + -1 + ], + [ + "LOCAL", + 10, + 4, + false + ], + [ + "IDLE", + 5, + [ + 10 + ] + ], + [ + "ADD", + 8, + 10, + -1 + ], + [ + "ADD", + 11, + 9, + 1 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ] + ], + [ + "ADD", + 10, + 12, + 1 + ], + [ + "ADD", + 13, + 11, + -1 + ], + [ + "LOCAL", + 12, + 5, + false + ], + [ + "IDLE", + 6, + [ + 12 + ] + ], + [ + "ADD", + 10, + 12, + -1 + ], + [ + "ADD", + 13, + 11, + 1 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13 + ] + ], + [ + "ADD", + 12, + 14, + 1 + ], + [ + "ADD", + 15, + 13, + -1 + ], + [ + "LOCAL", + 14, + 6, + false + ], + [ + "IDLE", + 7, + [ + 14 + ] + ], + [ + "ADD", + 12, + 14, + -1 + ], + [ + "ADD", + 15, + 13, + 1 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "IDLE", + 8, + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ] + ], + [ + "ADD", + 14, + 16, + 1 + ], + [ + "ADD", + 17, + 15, + -1 + ], + [ + "LOCAL", + 16, + 7, + false + ], + [ + "IDLE", + 8, + [ + 16 + ] + ], + [ + "ADD", + 14, + 16, + -1 + ], + [ + "ADD", + 17, + 15, + 1 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18, + 1 + ], + [ + "ADD", + 19, + 17, + -1 + ], + [ + "LOCAL", + 18, + 8, + false + ], + [ + "IDLE", + 9, + [ + 18 + ] + ], + [ + "ADD", + 16, + 18, + -1 + ], + [ + "ADD", + 19, + 17, + 1 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20, + 1 + ], + [ + "ADD", + 21, + 19, + -1 + ], + [ + "LOCAL", + 20, + 9, + false + ], + [ + "IDLE", + 10, + [ + 20 + ] + ], + [ + "ADD", + 18, + 20, + -1 + ], + [ + "ADD", + 21, + 19, + 1 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22, + 1 + ], + [ + "ADD", + 23, + 21, + -1 + ], + [ + "LOCAL", + 22, + 10, + false + ], + [ + "IDLE", + 11, + [ + 22 + ] + ], + [ + "ADD", + 20, + 22, + -1 + ], + [ + "ADD", + 23, + 21, + 1 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24, + 1 + ], + [ + "ADD", + 25, + 23, + -1 + ], + [ + "LOCAL", + 24, + 11, + false + ], + [ + "IDLE", + 12, + [ + 24 + ] + ], + [ + "ADD", + 22, + 24, + -1 + ], + [ + "ADD", + 25, + 23, + 1 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26, + 1 + ], + [ + "ADD", + 27, + 25, + -1 + ], + [ + "LOCAL", + 26, + 12, + false + ], + [ + "IDLE", + 13, + [ + 26 + ] + ], + [ + "ADD", + 24, + 26, + -1 + ], + [ + "ADD", + 27, + 25, + 1 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28, + 1 + ], + [ + "ADD", + 29, + 27, + -1 + ], + [ + "LOCAL", + 28, + 13, + false + ], + [ + "IDLE", + 14, + [ + 28 + ] + ], + [ + "ADD", + 26, + 28, + -1 + ], + [ + "ADD", + 29, + 27, + 1 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30, + 1 + ], + [ + "ADD", + 31, + 29, + -1 + ], + [ + "LOCAL", + 30, + 14, + false + ], + [ + "IDLE", + 15, + [ + 30 + ] + ], + [ + "ADD", + 28, + 30, + -1 + ], + [ + "ADD", + 31, + 29, + 1 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "ADD", + 30, + 32, + 1 + ], + [ + "ADD", + 33, + 31, + -1 + ], + [ + "LOCAL", + 32, + 15, + false + ], + [ + "IDLE", + 16, + [ + 32 + ] + ], + [ + "ADD", + 30, + 32, + -1 + ], + [ + "ADD", + 33, + 31, + 1 + ], + [ + "LOCAL", + 33, + 16, + true + ], + [ + "LOCAL", + 34, + 16, + false + ], + [ + "IDLE", + 8, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 30, + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 32, + 33, + 34 + ] + ], + [ + "IDLE", + 15, + [ + 33, + 34 + ] + ], + [ + "ADD", + 32, + 30, + 1 + ], + [ + "ADD", + 31, + 33, + -1 + ], + [ + "ADD", + 30, + 28, + 1 + ], + [ + "ADD", + 29, + 31, + -1 + ], + [ + "ADD", + 28, + 26, + 1 + ], + [ + "ADD", + 27, + 29, + -1 + ], + [ + "ADD", + 26, + 24, + 1 + ], + [ + "ADD", + 25, + 27, + -1 + ], + [ + "ADD", + 24, + 22, + 1 + ], + [ + "ADD", + 23, + 25, + -1 + ], + [ + "ADD", + 22, + 20, + 1 + ], + [ + "ADD", + 21, + 23, + -1 + ], + [ + "ADD", + 20, + 18, + 1 + ], + [ + "ADD", + 19, + 21, + -1 + ], + [ + "ADD", + 18, + 16, + 1 + ], + [ + "ADD", + 17, + 19, + -1 + ], + [ + "ADD", + 16, + 14, + 1 + ], + [ + "ADD", + 15, + 17, + -1 + ], + [ + "ADD", + 14, + 12, + 1 + ], + [ + "ADD", + 13, + 15, + -1 + ], + [ + "ADD", + 12, + 10, + 1 + ], + [ + "ADD", + 11, + 13, + -1 + ], + [ + "ADD", + 10, + 8, + 1 + ], + [ + "ADD", + 9, + 11, + -1 + ], + [ + "ADD", + 8, + 6, + 1 + ], + [ + "ADD", + 7, + 9, + -1 + ], + [ + "ADD", + 6, + 4, + 1 + ], + [ + "ADD", + 5, + 7, + -1 + ], + [ + "ADD", + 4, + 2, + 1 + ], + [ + "ADD", + 3, + 5, + -1 + ], + [ + "ADD", + 2, + 0, + 1 + ], + [ + "ADD", + 1, + 3, + -1 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ], + [ + "SIGNED_SWAP", + 32, + 33 + ] + ], + "full_Laurent_identity": true, + "native_operator_contract_independently_replayed": false +} diff --git a/research/kappa-hybrid-controller/controller/make_direct_case.py b/research/kappa-hybrid-controller/controller/make_direct_case.py new file mode 100644 index 0000000000..a3fc42d5c6 --- /dev/null +++ b/research/kappa-hybrid-controller/controller/make_direct_case.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python3 +"""Regenerate and compare the exact p17 rational Laurent specialization. + +The original complex controller, rational algebra, and binary discovery source +are authenticated at --source-root. Sparse multiplication omits zero summands +but uses exact rational arithmetic. Every acceptance guard survives python -O. +Native source/geometry and interval transfer are independently audited elsewhere. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import sys + +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +PINS={ + 'research/kappa-rebuild/bit/complex_controller_factor.py':'1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497', + 'research/kappa-rebuild/bit/mixed_productive_bit.py':'b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e', + 'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py':'8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85', +} +PAIRS=17 +CUT=8 +KEEP=280378328416255 +NATIVE=28633115307 +HELPERS={4:26,5:2,7:29,8:42,9:309} +LOCAL_PAID={1:2253,2:515,3:445,4:102,5:40,8:8} + + +def need(ok,message): + if not ok: + raise ValueError(message) + + +def load(path,name): + spec=importlib.util.spec_from_file_location(name,path) + module=importlib.util.module_from_spec(spec) + sys.modules[name]=module + spec.loader.exec_module(module) + return module + + +def authenticated(source_root): + root=Path(source_root).resolve() + for relative,expected in PINS.items(): + need(sha256((root/relative).read_bytes()).hexdigest()==expected,'Pinned original source: '+relative) + paths=list(PINS) + load(root/paths[2],'joint_pair_dag') + algebra=load(root/paths[1],'mixed_productive_bit') + controller=load(root/paths[0],'p17_original_complex_controller') + return controller,algebra + + +def sparse_multiply(a,b): + need(bool(a) and bool(b) and len(a[0])==len(b),'Matrix dimensions') + result=[[Q(0) for _ in b[0]] for row in a] + sparse_b=[[(j,x) for j,x in enumerate(row) if x] for row in b] + for i,row in enumerate(a): + for k,x in enumerate(row): + if x: + for j,y in sparse_b[k]: + result[i][j]+=x*y + return result + + +def specialize(term): + return (term[0],)+tuple(x if NATIVE>>s&1 else 0 for s,x in enumerate(term[1:])) + + +def collapse(coefficients): + result={} + for term,matrix in coefficients.items(): + key=specialize(term) + if key not in result: + result[key]=[row[:] for row in matrix] + else: + result[key]=[[x+y for x,y in zip(a,b)] for a,b in zip(result[key],matrix)] + return {key:matrix for key,matrix in result.items() if any(any(row) for row in matrix)} + + +def encode(value): + return (json.dumps(value,indent=2)+'\n').encode() + + +def generate(source_root): + C,B=authenticated(source_root) + B.matrix_multiply=sparse_multiply + need(NATIVE==sum(1<>1)&NATIVE).bit_count()]+=112 + need(main==binary_main,'Exact complex and binary job widths agree') + native_count=NATIVE.bit_count() + direct_count=35-native_count + need(native_count==19 and direct_count==16,'Native/direct stage inventory') + paid=Counter({k:native_count*v for k,v in LOCAL_PAID.items()}) + paid[1]+=112*direct_count + productive=Counter({k:native_count*v for k,v in HELPERS.items()})+main + windows=[] + for idle in idles: + if not idle['retained']: + continue + active=[s for s in idle['stages'] if NATIVE>>s&1] + rank=8*len(active) + if rank: + paid[rank]+=224 + windows.append(dict(**idle,active_stages=active,specialized_rank=rank)) + need(main==Counter({**{k:448 for k in range(17,74,8)},153:224}),'Exact main productive profile') + need(sum(main.values())==34*112,'Every main input field contributes one productive output') + need(sum(k*v for k,v in productive.items())-sum(k*v for k,v in paid.items())==800,'Exact raw rank-mass margin') + result=dict(schema='exact-p17-direct-stage-Laurent-specialization/1', + source_sha256=PINS,source_full_case_sha256=full_sha, + pairs=PAIRS,cut=CUT,keep_idle_mask=KEEP,native_stage_mask=NATIVE, + native_stages=[s for s in range(35) if NATIVE>>s&1], + direct_stages=[s for s in range(35) if not(NATIVE>>s&1)], + coefficient_variables=original['coefficient_variables'], + specialized_coefficient_matrices=[dict(exponents=list(key),matrix=C.serialize_matrix(matrix)) + for key,matrix in sorted(specialized.items())], + left=original['left'],right=original['right'], + left_program=original['left_program'],right_program=original['right_program'], + exact_diagonal_monomials=[list(term) for term in diagonal], + every_specialized_Laurent_coefficient_checked=True, + incorrect_backward_sign_rejected=True, + main_productive_profile=dict(sorted(main.items())), + native_helper_profile=HELPERS,native_paid_profile=LOCAL_PAID, + native_invocations=native_count,direct_Q_shears=direct_count, + direct_rank1_children=112*direct_count, + complete_paid_profile=dict(sorted(paid.items())), + complete_productive_profile=dict(sorted(productive.items())), + retained_idle_windows=windows, + ambient_dimension_with_all_original_stage_coordinates=9+16*PAIRS, + full_Laurent_identity=True, + physical_direct_shear_and_native_source_bindings_are_separate=True, + no_interval_or_rounded_transfer_claim=True) + return {'P17-FULL-LAURENT-CASE.json':original,'P17-DIRECT-CASE.json':result} + + +def run(source_root,out=HERE,write=False): + generated=generate(source_root) + hashes={} + out=Path(out) + if write: + out.mkdir(parents=True,exist_ok=True) + for name,value in generated.items(): + data=encode(value) + path=out/name + if write: + path.write_bytes(data) + else: + need(path.read_bytes()==data,'Exact regenerated receipt bytes: '+name) + hashes[name]=sha256(data).hexdigest() + return dict(status='PASS_EXACT_P17_LAURENT_SPECIALIZATION',source_sha256=PINS, + artifacts=hashes,native_invocations=19,direct_rank1_children=1792, + incorrect_backward_sign_rejected=True) + + +if __name__=='__main__': + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root',type=Path,default=HERE.parents[2]) + parser.add_argument('--out',type=Path,default=HERE) + parser.add_argument('--write',action='store_true',help='Write regenerated receipts instead of comparing them') + args=parser.parse_args() + print(json.dumps(run(args.source_root,args.out,args.write),sort_keys=True)) diff --git a/research/kappa-hybrid-controller/dependencies/clifford_exact.py b/research/kappa-hybrid-controller/dependencies/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/kappa-hybrid-controller/dependencies/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<= 1 and Q(1, 2) < t < z0 < z < 1, 'Strict compiler exponents') + need(cutoff**PARAMETERS.THETA_DENOMINATOR < floor**(PARAMETERS.THETA_DENOMINATOR-1), + 'Strict source-bound logarithmic cutoff/floor separation') + need(cutoff < 2**cutoff_log and ambient < 2**ambient_log, 'Exact power bounds for exit and complement') + # With r_max=cutoff^n, k_min=floor^n, m=ambient^n, m*E(x)/x + # is below 2^B*x^-h. All inactive carrier axes remain included. + B = (cutoff_log+ambient_log*h)*n + debt = 1+ambient_log*n*(1-z0) + ratio = (delta*B+debt)/(h*delta) + H0 = -((-ratio.numerator)//ratio.denominator) + need(H0 >= ambient_log*n, 'Initial threshold covers every base rank below m') + need(H0*h*delta >= delta*B+debt, 'Exact sufficient exit/complement inequality') + final_ratio = H0*(1-z0)/(z-z0) + H1 = final_ratio.numerator//final_ratio.denominator+1 + need(H1 > H0 and H1*(z-z0) > H0*(1-z0), 'Strict final uniform moment') + need((H0-1)*h*delta < delta*B+debt, 'One lower H0 fails the stated sufficient bound') + need((H1-1)*(z-z0) <= H0*(1-z0), 'One lower H1 fails the final strict bound') + return {'tensor_power': n, 'target_min_encoding': str(floor)+'^'+str(n), + 'target_max_encoding': str(max(PARAMETERS.TARGETS))+'^'+str(n), + 'ambient_rank_encoding': str(ambient)+'^'+str(n), + 'paid_max_bound_encoding': str(cutoff)+'^'+str(n), + 'theta_upper': 1-h, 'h': h, 't': t, 'z0': z0, 'z': z, + 'delta': delta, 'exit_coefficient_log2_upper': B, + 'negative_log2_eta_upper': debt, 'H0': H0, 'H1': H1, + 'N_encoding': '2^'+str(H1), + 'final_strict_power_gap': H1*(z-z0)-H0*(1-z0), + 'rank_one_induction': str(PARAMETERS.TARGET_MASS)+'^n > '+str(PARAMETERS.PAID_MASS)+'^n; target padding adds equal paid and target rank, and splitting preserves rank', + 'materialized_tensor_rule_or_uniform_word': False} + + +def bit_certificate(source_root=DEFAULT_BIT_SOURCE): + script = HERE/'bit/bit_p6_tensor_extension.py' + need(sha256(script.read_bytes()).hexdigest() == BIT_SCRIPT_SHA256, 'Exact BIT tensor/native validator') + B = module('hybrid_bit_p6_tensor', script) + result = encode(B.run(Path(source_root).resolve())) + need(result == json.loads((HERE/'bit/BIT-P6-TENSOR-RESULT.json').read_text()), + 'Exact ordinary BIT certificate reproduction including native replay') + need(Q(result['admitted_BIT_saving']) == PARAMETERS.BIT_SAVING, 'Admitted ordinary BIT saving') + return result + + +def run(source_root=DEFAULT_SOURCE, strict_result=None, bit_source_root=DEFAULT_BIT_SOURCE, bit_result=None, retimed_source_root=None): + if strict_result is None: + strict_result = module('tensor_strictification', HERE/'strictification.py').run(source_root,retimed_source_root=retimed_source_root) + need(strict_result['strict_moment_verified'], 'Strict mixed moment was certified') + need(strict_result['cutoff_base'] == PARAMETERS.CUTOFF and strict_result['target_floor_base'] == PARAMETERS.TARGET_FLOOR + and Q(strict_result['tested_saving']) == TESTED, + 'Compiler inputs bind to the certified cutoff and saving') + ledger_path = Path(source_root).resolve().parent/'dependencies/compiler-refill/endpoint.py' + need(sha256(ledger_path.read_bytes()).hexdigest() == LEDGER_SHA256, 'Exact inherited outer ledger') + if bit_result is None: + bit_result = bit_certificate(bit_source_root) + need(bit_result['native_source']['status'] == 'PASS_P6_EXACT_NATIVE_PORTS_ARBITRARY_COLUMNS_AND_WHOLE_IDLES', 'BIT native gate') + need(Q(bit_result['admitted_BIT_saving']) == PARAMETERS.BIT_SAVING, 'BIT ordinary saving matches parameter table') + previous = module('pr4405_outer_ledger', ledger_path) + d = (TESTED-KAPPA)/7 + p = {'kappa': KAPPA, 'tested_saving': TESTED, + 'complex_uniform_saving': KAPPA+6*d, 'b': KAPPA+5*d, + 'a': KAPPA+4*d, 'q': KAPPA+3*d, 'bit_saving': Q(bit_result['admitted_BIT_saving']), + 'epsilon': 1-d, 'beta': 1-3*d, 'r0': d/10, + 'stop': d, 'layout': d, 'd': d} + outer = previous.ledger(p) + need(len(outer['functional_checks']) == 3, 'Preserve the three inherited functional checks') + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = p['beta']*(1-Q(bit_result['ordinary']['atom_power'])) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, + 'Complete preserved outer predicate set') + need(all(v > 0 for v in outer['strict_checks'].values()), 'All 54 strict outer predicates') + need(all(v > 0 for v in outer['functional_checks'].values()), 'All four functional predicates, including the actual new BIT atom') + need(min(outer['margins'].values()) == outer['margins']['main_transform'], + 'Main transform remains limiting') + controls = {} + for label, updates in [('closed_epsilon', {'epsilon': Q(1)}), + ('closed_uniform_gap', {'complex_uniform_saving': p['b']}), + ('unfunded_outer_point', {'kappa': TESTED}), + ('insufficient_BIT', {'bit_saving': Q('0.0023')})]: + tested = previous.ledger(dict(p, **updates)) + failed = {k: v for k, v in tested['strict_checks'].items() if v <= 0} + need(failed, 'Reject '+label) + controls[label] = failed + rank = compiler_rank(strict_result['exponent'], TESTED, p['complex_uniform_saving']) + return encode({'schema': 'hybrid-p17-padding-outer-endpoint/1', + 'status': 'PASS_CONDITIONAL_HYBRID_P17_OUTER_POINT', 'kappa': KAPPA, + 'gain_over_PR4359': KAPPA-Q('0.0023'), + 'gain_over_PR4405': KAPPA-Q('0.00230509'), + 'gain_over_allfresh_p3': KAPPA-Q('0.00247755'), + 'gain_over_PR4414': KAPPA-Q('0.00267987'), + 'gain_over_PR4416': KAPPA-Q('0.00268647'), + 'tested_saving': TESTED, 'outer': outer, 'compiler': rank, + 'ordinary_BIT_certificate': bit_result, + 'BIT_validator_sha256': BIT_SCRIPT_SHA256, + 'parameters_sha256': sha256((HERE/'parameters.py').read_bytes()).hexdigest(), + 'minimum_outer_margin': min(outer['margins'].values())-KAPPA, + 'negative_controls': controls, + 'ledger_source_sha256': sha256(ledger_path.read_bytes()).hexdigest(), + 'strictification_source_sha256': sha256((HERE/'strictification.py').read_bytes()).hexdigest(), + 'scope': 'Source-bound PR4441 retimed arbitrary-input local word, p17 native/direct geometry, a finite tensor recipe with target padding, exact moment and outer inequalities, and a specified finite uniform rank. Native tensor closure and the PR4359 inherited precision, storage, analytic, fixed-tape and recovery hypotheses are written premises, not a full formal theorem certificate.'}) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, default=DEFAULT_SOURCE) + parser.add_argument('--bit-source-root', type=Path, default=DEFAULT_BIT_SOURCE) + parser.add_argument('--out', type=Path) + parser.add_argument('--retimed-source-root', type=Path) + args = parser.parse_args() + result = run(args.source_root, bit_source_root=args.bit_source_root,retimed_source_root=args.retimed_source_root) + if args.out: + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(json.dumps({key: result[key] for key in + ('status', 'kappa', 'gain_over_PR4359', 'minimum_outer_margin', 'compiler')}, sort_keys=True)) diff --git a/research/kappa-hybrid-controller/frontier/AUDIT.json b/research/kappa-hybrid-controller/frontier/AUDIT.json new file mode 100644 index 0000000000..e4c738c345 --- /dev/null +++ b/research/kappa-hybrid-controller/frontier/AUDIT.json @@ -0,0 +1,63 @@ +{ + "status": "PASS_INDEPENDENT_COMBINED_PR4441_ARITHMETIC", + "source_head": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39", + "source_sha256": { + "RESULT.json": "8e7db2fed5f4be6a7f944bc59e7942ccbcc3e6c36130b5671331540c183ada21", + "README.md": "70c1c872c2327c3f71918e218d5f1ecb7a00037771a5dd1b8ae415b84cc90dc2", + "PROOF.md": "9883b3329fef7624d3471e27bb55258cd9dc18bb6d37779a3939de99add87347", + "verify.py": "c841265ccee9b6f79045ad818ce9d27cfd7ee1f60047525a75d491f0dd8b997a" + }, + "engine": "Independent outward integer fixed-point intervals in units10^-60; atanh logarithm80terms with exact remainder; exponential160terms with exact geometric remainder. No source interval code imported.", + "profile_matches_independent_controller": true, + "alpha": { + "lower": "0.999999997758999184602267590366798323272665791573751100485190", + "upper": "0.999999997758999184602267590366798323272665791573751100486058" + }, + "gamma": { + "lower": "0.969126930833863729265427869330123421762375736735156993596550", + "upper": "0.969126930833863729265427869330123421762375736735156993597698" + }, + "delta": { + "lower": "0.932537400874663431699700098660626553481393010004834599958801", + "upper": "0.932537400874663431699700098660626553481393010004834599959429" + }, + "normalized_paid_bound": "2097152001953127/2097154147483648", + "eta": { + "lower": "0.000000192738808606315094338627648047411184654336388834454968", + "upper": "0.000000192738808606315094338627648047411184654336388834454970" + }, + "compiler_H": 165315500000000, + "root_bracket_signs": { + "lower": { + "lower": "0.000000046318992475575202648286681833862420812197817786099330", + "upper": "0.000000046318992475575202648286681833862420812197818009812690" + }, + "upper": { + "lower": "-0.000000059611230077814150466286112209518891941217299354238904", + "upper": "-0.000000059611230077814150466286112209518891941217299130658559" + } + }, + "fixed_profile_ceiling": { + "strictly_decreasing_through": "1/20", + "negative_derivative_upper": { + "lower": "-209315.536979071590541345657103770455881664249731376687670554105980", + "upper": "-209315.536979071590541345657103770455881664249731376687670554105980" + }, + "remaining_interval_upper": { + "lower": "-7187.718561211958612523888656616521882686629795500265844795146442", + "upper": "-7187.718561211958612523888656616521882686629795500265844795146442" + }, + "derivative_cells": 16, + "remaining_cells": 128 + }, + "ordinary_BIT": "8590884599/2500000000000", + "outer_counts": { + "strict": 54, + "functional": 4 + }, + "refined_alpha_at_C_003001054": { + "lower": "0.999999999811973328754264108092433162796391206723906209133439", + "upper": "0.999999999811973328754264108092433162796391206723906209134307" + }, + "scope": "Independent arithmetic and written substitution audit, retaining the already audited native source and all-column/physical/analytic/precision/stock/tape/recovery premises. The153 active ambient is not independently reconstructed here; parent keeps conservative281. Full source verifiers are not rerun in this audit." +} diff --git a/research/kappa-hybrid-controller/frontier/FRONTIER.json b/research/kappa-hybrid-controller/frontier/FRONTIER.json new file mode 100644 index 0000000000..47bdc93eba --- /dev/null +++ b/research/kappa-hybrid-controller/frontier/FRONTIER.json @@ -0,0 +1,368 @@ +{ + "time": "2026-10-21 20:42:34 UTC", + "main": "2a13eb1827784206202db90e5dc8327cf8a250db", + "updated": [ + { + "number": 4441, + "title": "Conditional κ = 0.00300105 (+4.105e-5 over #4440): combine query thinning and helper retiming", + "head": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39", + "updated": "2026-10-21T20:41:48Z" + }, + { + "number": 4440, + "title": "Conditional κ = 0.00296 via query-thinned productive controllers (+10.18%)", + "head": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", + "updated": "2026-10-21T20:14:35Z" + }, + { + "number": 4442, + "title": "Apply the smaller halo exponents across a cell, under the downward reading (no new κ)", + "head": "d079c2b058ebd3d7a9ff424113b095bf61175427", + "updated": "2026-10-21T20:11:41Z" + }, + { + "number": 4439, + "title": "Apply the smaller halo exponents inside one cell, with normalizer 6 (no new κ)", + "head": "26af8afbadd7f8feb737d98b47ac9f4b45d35c7a", + "updated": "2026-10-21T20:02:46Z" + }, + { + "number": 4434, + "title": "Decide #4281's depth-five connector at m = 5 exactly (minima 25, 30, 35, 35) and at m = 6 for length 5m (c = 1 new, c = 3; others >= 36) by exact meet-in-the-middle (no new κ)", + "head": "930469ad8c0b82b04cd4c1775913e27de47b1113", + "updated": "2026-10-21T20:00:49Z" + }, + { + "number": 4421, + "title": "Extend #4365's rank dual to every plane triple: three-plane COPY floor 12 over every field on all 27,720 triples (no new κ)", + "head": "333452eb9d78f7077b77971877f20f4b4a276948", + "updated": "2026-10-21T19:57:46Z" + }, + { + "number": 4438, + "title": "Bound the within-cell column gap by a relative weight error of 1/(16p^2) (no new κ)", + "head": "6157a47bfe169cd9c5f666f85ab8caa929e1174f", + "updated": "2026-10-21T19:56:30Z" + }, + { + "number": 4436, + "title": "Bound compiler width by exp(O(N log N)) and route overlapping ranks", + "head": "56003680aee2871773de408e5f01cc5dd46b144c", + "updated": "2026-10-21T19:54:23Z" + }, + { + "number": 4437, + "title": "Extend the ideal column majorant across every legal g=2 step (no new κ)", + "head": "7ca94e9762ee33edbfb2e527e7313bc579e463ee", + "updated": "2026-10-21T19:49:34Z" + }, + { + "number": 4079, + "title": "Research: seven-source weight-at-most-four connector boundary (L<=18 excluded, 216-call floor) (no new kappa)", + "head": "39a1fd620d1c702b72ab080ec11b090ea9ce98b7", + "updated": "2026-10-21T19:46:06Z" + }, + { + "number": 4435, + "title": "Derive the broad forward inverse asymptotics: ||K^-1||_2 ~ e^(a/4)/(2 alpha sqrt(pi)) theta^(-1/2) from a turning-point harmonic oscillator; confirmed to 0.3% (no new κ)", + "head": "d08a3fdd9b840ae79c11d830a53d66586e6a4b8a", + "updated": "2026-10-21T19:28:32Z" + }, + { + "number": 4348, + "title": "Answer #4322's open question 1: at n = 5 the first all-sound length is 26; the firing set drops from 30 to 28 masks at L = 24 (no new κ)", + "head": "91c87533a6a8b3be98663b52073c739093217921", + "updated": "2026-10-21T19:27:54Z" + }, + { + "number": 4345, + "title": "Independently census five full-guard header laws (#4259, #4261, #4273, #4274, #4275) through GL_5(F2), GL_4(F3), GL_3(F4), GL_3(F5): every count matches (no new κ)", + "head": "e99128a6785b562dd7a73ee550bf32ff06ac5b4a", + "updated": "2026-10-21T19:27:54Z" + }, + { + "number": 4344, + "title": "Independently check #4279's depth-four count vectors for m = 2..5: P(m) and the dominance law hold in the box n <= 3m (no new κ)", + "head": "2dce07ef435e776889e23f1f1f58afaa989611fc", + "updated": "2026-10-21T19:27:54Z" + }, + { + "number": 4341, + "title": "Independently reproduce #4281's depth-five connector minima: m = 4 gives 28, 24, 28 by a separate exhaustive BFS; all 173 witnesses verified (no new κ)", + "head": "806922e07f0a83ab37d0897e1750033e72fa0507", + "updated": "2026-10-21T19:27:54Z" + }, + { + "number": 4400, + "title": "This section's polynomial-inverse error is strictly below 2^{-513} (no new κ)", + "head": "53b7721f6da11004ed979294a29f5f0f0a9cc646", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4396, + "title": "This section's polynomial-inverse error is strictly below 2^{-437} (no new κ)", + "head": "d8e334f0158d64113781d4c16dddad42a6150054", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4394, + "title": "This section's polynomial-inverse error is strictly below 2^{-399} (no new κ)", + "head": "00bcf250f21ecbda5a24ce7c262c18284a227a2c", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4392, + "title": "This section's polynomial-inverse error is strictly below 2^{-361} (no new κ)", + "head": "ae4d3eed1e233261a6bcd9e07e12c96df9b93457", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4389, + "title": "This section's polynomial-inverse error is strictly below 2^{-304} (no new κ)", + "head": "877e5fafff4b5d17217e6f80dc3e49d8bbc0078d", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4388, + "title": "This section's polynomial-inverse error is strictly below 2^{-285} (no new κ)", + "head": "fca350341e94cbc9877bfe22db18e3cfd13d7d0a", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4385, + "title": "This section's polynomial-inverse error is strictly below 2^{-228} (no new κ)", + "head": "c1e30a15ae4a887fdbea55b41325afa654859182", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4384, + "title": "This section's polynomial-inverse error is strictly below 2^{-209} (no new κ)", + "head": "eb63013e17c24c8b3692aca633e81d475a341222", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4383, + "title": "This section's polynomial-inverse error is strictly below 2^{-190} (no new κ)", + "head": "e6dba8c5f9fe2c200450272bd31515403fa82254", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4382, + "title": "This section's polynomial-inverse error is strictly below 2^{-171} (no new κ)", + "head": "df6c0bfc99677916a7906d19793a82565c1c4c32", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4381, + "title": "This section's polynomial-inverse error is strictly below 2^{-152} (no new κ)", + "head": "e5a5b49449b447c62d731a4300f4422558cc2cf2", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4380, + "title": "This section's polynomial-inverse error is strictly below 2^{-133} (no new κ)", + "head": "c23102709d43d9c7880219e394026baa870e3996", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4379, + "title": "This section's polynomial-inverse error is strictly below 2^{-114} (no new κ)", + "head": "18f1dc603e832ed2c33b850d8b7d7f35ee7160da", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4378, + "title": "Record the square i-block obstruction for mixed negative Q8 targets.", + "head": "da82b198bd06dfc248bdcdf4ab477da50688fb07", + "updated": "2026-10-21T19:27:53Z" + }, + { + "number": 4377, + "title": "Prove the uniform CRT evaluator bound with constant 1.", + "head": "0c998e1f6548738b010f403a64df9c8dc2b4d429", + "updated": "2026-10-21T19:27:53Z" + } + ], + "created": [ + { + "number": 4442, + "title": "Apply the smaller halo exponents across a cell, under the downward reading (no new κ)", + "head": "d079c2b058ebd3d7a9ff424113b095bf61175427", + "updated": "2026-10-21T20:11:41Z" + }, + { + "number": 4441, + "title": "Conditional κ = 0.00300105 (+4.105e-5 over #4440): combine query thinning and helper retiming", + "head": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39", + "updated": "2026-10-21T20:41:48Z" + }, + { + "number": 4440, + "title": "Conditional κ = 0.00296 via query-thinned productive controllers (+10.18%)", + "head": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", + "updated": "2026-10-21T20:14:35Z" + }, + { + "number": 4439, + "title": "Apply the smaller halo exponents inside one cell, with normalizer 6 (no new κ)", + "head": "26af8afbadd7f8feb737d98b47ac9f4b45d35c7a", + "updated": "2026-10-21T20:02:46Z" + }, + { + "number": 4438, + "title": "Bound the within-cell column gap by a relative weight error of 1/(16p^2) (no new κ)", + "head": "6157a47bfe169cd9c5f666f85ab8caa929e1174f", + "updated": "2026-10-21T19:56:30Z" + }, + { + "number": 4437, + "title": "Extend the ideal column majorant across every legal g=2 step (no new κ)", + "head": "7ca94e9762ee33edbfb2e527e7313bc579e463ee", + "updated": "2026-10-21T19:49:34Z" + }, + { + "number": 4436, + "title": "Bound compiler width by exp(O(N log N)) and route overlapping ranks", + "head": "56003680aee2871773de408e5f01cc5dd46b144c", + "updated": "2026-10-21T19:54:23Z" + }, + { + "number": 4435, + "title": "Derive the broad forward inverse asymptotics: ||K^-1||_2 ~ e^(a/4)/(2 alpha sqrt(pi)) theta^(-1/2) from a turning-point harmonic oscillator; confirmed to 0.3% (no new κ)", + "head": "d08a3fdd9b840ae79c11d830a53d66586e6a4b8a", + "updated": "2026-10-21T19:28:32Z" + }, + { + "number": 4434, + "title": "Decide #4281's depth-five connector at m = 5 exactly (minima 25, 30, 35, 35) and at m = 6 for length 5m (c = 1 new, c = 3; others >= 36) by exact meet-in-the-middle (no new κ)", + "head": "930469ad8c0b82b04cd4c1775913e27de47b1113", + "updated": "2026-10-21T20:00:49Z" + }, + { + "number": 4433, + "title": "Reduce p7 tensor power and uniform-rank exponent (41.6× and 46.38M×)", + "head": "b84060c9cba91b1e76f84617a877d259621eb015", + "updated": "2026-10-21T19:27:51Z" + }, + { + "number": 4432, + "title": "Audit #4100 BIT.md's local-ring algebra, row stock, depth, recurrence and wrapper: all hold (no new κ)", + "head": "44c094454b174bba943a0dfbb324cfec8bd7c976", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4431, + "title": "Prove a completion-independent native H obstruction from one ordinary edge", + "head": "abdf6548948cbc8e44209bad2d1cd640d780a04b", + "updated": "2026-10-21T19:27:51Z" + }, + { + "number": 4430, + "title": "Independently review #4417's nonlinear centre-sharing floor: Theorems 1-2 hold; all six screen ceilings reproduced by separate code; rank-72 regroup is extremal (no new κ)", + "head": "da76aa4d3aec87a2fc51439f3f16a789d2a2b517", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4429, + "title": "Independently check the #4412 and #4414 tensor endpoints: alpha/gamma bounds and ranks hold; least tensor powers 10,714 and 60,701 (no new κ)", + "head": "40f675338b7102ec38d858355a1db6cc051778e7", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4428, + "title": "Independently check #4416's paid-completion tensor bound at kappa 0.00268647: proof steps and arithmetic hold; gamma margin 8e-6; least v 5745 (no new κ)", + "head": "ba0efeaac4e62d1757d7a9be6fd8aaf8f9bd35dc", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4427, + "title": "Answer #4322's open question 2: no functional fires at (7,18) or (7,20), since 133,421,988 and 3,857,028,444 canonical walks include no universal word (no new κ)", + "head": "eaa39d7439821a408f4c4ef03a71fd4c0399028e", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4426, + "title": "Rebuild #4416's p7 invoice from its literal controller word: exact Laurent replay gives T and P exactly (no new κ)", + "head": "6f918e2658c727007611d98ffb8d3c7336e2290c", + "updated": "2026-10-21T19:27:51Z" + }, + { + "number": 4425, + "title": "Independently review #4411's logarithmic majorant: proof holds, arithmetic certified, least ranks slightly below stated, exact L(N) <= F(N) to N = 6000 (no new κ)", + "head": "76613f8d29b664e386f29f30153f74087f462953", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4424, + "title": "Audit #4100 COMPLEX.md's common cover and native warps: |O(73,2)|, X_delta correction, stock arithmetic and Z4-monomial warps hold (no new κ)", + "head": "5d7169599ecb6167cc3e1d17dd374968c225c307", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4423, + "title": "Check jwr404's p = 19 section chain in one package: #4354, #4355, #4361, #4362, #4364 and all 28 two-power PRs hold; the sharp threshold is 2^-519 (no new κ)", + "head": "53f601cfd51f3487348f15e5d443ed3a8543a5c3", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4422, + "title": "Independently check #4412's and #4414's strictification inequalities: all hold; each tested saving sits within 1e-8 of its invoice's limit (no new κ)", + "head": "6977b9f52c8632d066b0d649f2a6280c5a96185e", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4421, + "title": "Extend #4365's rank dual to every plane triple: three-plane COPY floor 12 over every field on all 27,720 triples (no new κ)", + "head": "333452eb9d78f7077b77971877f20f4b4a276948", + "updated": "2026-10-21T19:57:46Z" + }, + { + "number": 4420, + "title": "Independently check #4416's moment and paid-tail inequalities at κ = 0.00268647: all hold; the tested saving sits 9.05e-9 below this invoice's limit (no new κ)", + "head": "64b4f5457613ada7f0e3f2f4d26f9978d19cdfa7", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4419, + "title": "Report omitted local notes in overlap searches", + "head": "f837d4c443113e7d87d8451ba85878b0feed82f4", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4418, + "title": "Decide #4281's eleven open depth-five connector residues: exact minima 30, 35, 35 (m=5), 30, 36, 36, 36 (m=6), 35, 42 (m=7), 40, 40 (m=8) (no new κ)", + "head": "f87bec70596b2e34d641fd70a0fde281c94d5eaf", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4417, + "title": "Close nonlinear and adaptive centre sharing at the fresh-information floor (no new κ)", + "head": "2b1011151f9a8bb9777f2659bdb0e88cb81c5e41", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4416, + "title": "Conditional κ = 0.00268647 via paid target padding after native composition", + "head": "e9058860b5c850760fdf970e796a96aefcdb1d98", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4415, + "title": "Answer #4371's open question 1: one coefficient's error path through #4100's transforms carries one factor of T (m = 1), so C = 5 suffices for b >= 13 (no new κ)", + "head": "ebfa9588f5a1ca4c595b3ff837f24917d5dd7caf", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4414, + "title": "Conditional κ = 0.00267987 with a complete p6 native controller", + "head": "90da4b0ab894350ca12cac9110cc6da2225d18af", + "updated": "2026-10-21T19:27:52Z" + }, + { + "number": 4413, + "title": "Rebalance #4359's own ledger at unchanged kappa 0.0023: explicit ranks shrink to 2^268300549 (complex) and 2^14664 (BIT) with all 54 predicates strict (no new κ)", + "head": "c2cf40086db273d7e0fcdd647fa63e2cc187550e", + "updated": "2026-10-21T19:27:52Z" + } + ] +} diff --git a/research/kappa-hybrid-controller/frontier/REPORT.md b/research/kappa-hybrid-controller/frontier/REPORT.md new file mode 100644 index 0000000000..3657df1880 --- /dev/null +++ b/research/kappa-hybrid-controller/frontier/REPORT.md @@ -0,0 +1,29 @@ +# Independent audit of the updated PR4441 frontier + +At **2026-10-21 20:42:34 UTC**, the 30 most recently updated PRs, the 30 most recently created PRs and canonical main were refreshed. The strongest newly observed claim remained PR4441 at **kappa 0.00300105**, head `5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39`. No claim above the proposed `0.003001053` was found in those bounded lists. Canonical main remained `2a13eb1827784206202db90e5dc8327cf8a250db`. This is bounded retrieval coverage, not an exhaustive claim about all historical PRs. + +## Checked + +The independently constructed retimed p17 case and the published combined profile agree exactly. They contain 11560 productive fields, 69273 paid requests, and productive/paid rank masses 260798/259998. + +A newly written interval engine uses only integer arithmetic, outward rounding in units of 10^-60, an atanh series with an exact logarithm remainder, and an exponential series with an exact geometric remainder. It imports no source interval implementation. Optimized execution succeeds with `python3 -I -O -B research/kappa-hybrid-controller/frontier/audit.py`. + +At tested saving 0.003001052, the new engine independently encloses every published alpha, gamma and delta interval. It proves alpha < 1-10^-9, gamma < 97/100 and delta < 19/20; the earlier gamma limit 31/32 fails. Both decay-block inequalities and the complete paid-tail bound `2097152001953127/2097154147483648 < 1` hold exactly. + +The two signs bracketing the fixed-profile root at 0.0030010541830 and 0.0030010541834 hold independently. Sixteen derivative interval cells prove strict decrease through C=1/20. Another 128 interval cells keep the moment negative from C=1/20 through 1. This establishes the stated ceiling for this one profile throughout 0=0 and b[0]>0,'Positive division') + return a[0]*S//b[1],ceildiv(a[1]*S,b[0]) +def atanh_log(z): + need(0<=z<=Q(1,3),'Log range reduction') + zz=rat(z);z2=mul(zz,zz);term=zz;out=(0,0);N=80 + for j in range(N): + out=add(out,scale(term,Q(2,2*j+1))) + term=mul(term,z2) + tail=2*z**(2*N+1)/((2*N+1)*(1-z*z)) + return out[0],out[1]+rat(tail)[1] +@lru_cache(None) +def logn(n): + if n==1:return 0,0 + k=n.bit_length()-1 + return add(scale(atanh_log(Q(1,3)),k),atanh_log(Q(n-2**k,n+2**k))) +def exp_interval(x): + if x[1]<=0: + y=exp_interval((-x[1],-x[0])) if x!=(0,0) else (S,S) + return S*S//y[1],ceildiv(S*S,y[0]) + need(x[0]>=0 and x[1]<20*S,'Exponential input domain') + term=(S,S);out=term;N=160 + for j in range(1,N+1): + term=scale(mul(term,x),Q(1,j));out=add(out,term) + nxt=ceildiv(term[1]*x[1],S*(N+1)) + tail=ceildiv(nxt*S*(N+2),(N+2)*S-x[1]) + return out[0],out[1]+tail +@lru_cache(None) +def power(n,e):return exp_interval(scale(logn(n),e)) +def moment(profile,e): + out=(0,0) + for n,count in profile.items():out=add(out,scale(power(n,e),count)) + return out +def show(x): + def one(n): + sign='-' if n<0 else '';n=abs(n) + return sign+str(n//S)+'.'+str(n%S).zfill(60) + return {'lower':one(x[0]),'upper':one(x[1])} +def overlap(x,entry): + return max(Q(x[0],S),Q(entry['lower']))<=min(Q(x[1],S),Q(entry['upper'])) +def encode(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +source_meta=json.loads((HERE.parent/'SOURCES.json').read_text()) +for name in SOURCE_FILES: + path='research/fresh-helper-thinned/'+name + row=next(r for r in source_meta['files'] if r['path']==path) + need(hashlib.sha256((SOURCE/name).read_bytes()).hexdigest()==row['sha256'],'Exact updated-frontier source: '+name) +r=json.loads((SOURCE/'RESULT.json').read_text()) +T={int(k):v for k,v in r['targets'].items()};P={int(k):v for k,v in r['paid'].items()} +own_path=HERE.parent/'controller/P17-DIRECT-CASE.json' +need(hashlib.sha256(own_path.read_bytes()).hexdigest()=='00247ee53b39cf01e176d93b8035bbdb18e7669f969b4ab576130205ae02d0df','Independently constructed controller source pin') +own=json.loads(own_path.read_text()) +need(T=={int(k):v for k,v in own['complete_productive_profile'].items()} and P=={int(k):v for k,v in own['complete_paid_profile'].items()},'Published invoice equals independently constructed full controller') +need(sum(T.values())==11560 and sum(P.values())==69273,'All fields and requests') +need(sum(k*v for k,v in T.items())==260798 and sum(k*v for k,v in P.items())==259998,'Both exact masses') +C=Q('.003001052');kappa=Q('.00300105');v=1024;t=1-C +tm=moment(T,t);pm=moment(P,t) +alpha=div(pm,tm) +gamma=div(moment(P,t+Q(1,5)),mul(power(20,Q(1,5)),tm)) +delta=div(rat(11560*21),mul(power(20,C),tm)) +need(alpha[1]<(S-S//10**9),'Alpha bound') +need(gamma[1]rat(Q(31,32))[1],'Old gamma bound fails') +for name,x in [('alpha',alpha),('gamma',gamma),('delta',delta)]: + need(overlap(x,r['strictification'][name]),'Published interval overlap: '+name) +need(Q(97,100)**128rat(theta**1000)[1],'Complement log-majorant capacity') +need(power(153,v*C)[1]<2**1000*S,'Initial compiler range') +need(overlap(eta,r['compiler']['eta']),'Published eta interval') +gap=(C-kappa)/7;H=r['compiler']['H'];j=r['compiler']['integer_test_exponent'] +need(gap==Q(1,3500000000) and H==3500000000*j and H==165315500000000,'Compiler grid') +need((H+1)**1000<2**j,'Final uniform rank inequality') +need((H-3500000000+1)**1000>=2**(j-1),'Preceding compiler grid point rejected') +root_signs={} +for name,c in [('lower',Q('.0030010541830')),('upper',Q('.0030010541834'))]: + ta,pa=moment(T,1-c),moment(P,1-c) + margin=(ta[0]-pa[1],ta[1]-pa[0]);root_signs[name]=show(margin) + need(margin[0]>0 if name=='lower' else margin[1]<0,'Independent root bracket sign') +signed={rank:T.get(rank,0)-P.get(rank,0) for rank in T.keys()|P.keys()} +derivative=[] +for j in range(16): + left,right=Q(j,320),Q(j+1,320);total=(0,0) + for rank,count in signed.items(): + total=add(total,scale(mul(power(rank,1-(right if count>0 else left)),logn(rank)),count)) + derivative.append(total[0]) +remaining=[] +for j in range(128): + left,right=Q(1,20)+Q(19*j,2560),Q(1,20)+Q(19*(j+1),2560);total=(0,0) + for rank,count in signed.items(): + total=add(total,scale(power(rank,1-(left if count>0 else right)),count)) + remaining.append(total[1]) +need(min(derivative)>0 and max(remaining)<0,'Fixed-profile ceiling throughout every real0ordinary>Q(bit['admitted'])>C,'Exact ordinary BIT arithmetic') +ledger_path=ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py' +need(hashlib.sha256(ledger_path.read_bytes()).hexdigest()=='d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15','Pinned outer ledger source') +spec=importlib.util.spec_from_file_location('pinned_outer',ledger_path);L=importlib.util.module_from_spec(spec);spec.loader.exec_module(L) +params={'kappa':kappa,'tested_saving':C,'complex_uniform_saving':kappa+6*gap,'b':kappa+5*gap,'a':kappa+4*gap,'q':kappa+3*gap,'bit_saving':Q(bit['admitted']),'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} +outer=L.ledger(params);outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) +need(encode(outer)==r['outer'],'Exact outer ledger receipt reproduction') +need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4 and all(q>0 for k in ('strict_checks','functional_checks') for q in outer[k].values()),'All 54+4 inequalities') +refined_alpha=div(moment(P,1-Q('.003001054')),moment(T,1-Q('.003001054'))) +need(refined_alpha[1]= 224 for e in program), + 'Old helper wrapper markers are replaced by the new complete boundary recipes') + native_edges.append({(e[3],e[4]) for e in program if e[0] == 'climb'}) + literal = replay['native'][direction] + need(literal['independent_persistent_columns'] == 632 and + literal['arbitrary_owned_C0_cleared'] and literal['scalar_frames_checked'], + 'All persistent inputs, scalar contact frames and the owned center are checked') + checks[direction] = literal['second_literal'] + need(checks[direction]['independent_borrowed_input_fields'] == 632 and + checks[direction]['expected_restored_helpers'] == 408 and + checks[direction]['free_warp_operator_endpoint_matches'], + 'Second literal interpreter checks every arbitrary source and helper endpoint') + need(native_edges[0] == native_edges[1],'Both orientations have the same retimed transport edges') + physical = {(row['old'],row['new']):row for row in replay['new_physical_edges_and_boundaries']} + for role in range(224,632): + edge = (canonical['start'][role],canonical['final'][role]) + need(edge in physical,'Every complete helper boundary has a physical phase recipe') + row = physical[edge] + width = len(canonical['frames'][edge[1]])-len(canonical['frames'][edge[0]]) + need(width > 0 and row['rank'] == width and + all(row['recipes'][direction]['rank'] == width for direction in ('forward','backward')), + 'Every arbitrary helper is positively productive with both complete phases') + helpers = {int(k):v for k,v in replay['helpers'].items()} + paid = {int(k):v for k,v in replay['paid'].items()} + need(helpers == parameters.LOCAL_HELPERS and paid == parameters.LOCAL_PAID, + 'Exact current retimed helper and paid profiles') + need(sum(helpers.values()) == 408,'All helpers retain distinct arbitrary owners') + need((replay['changed_entrances'],replay['changed_exits'],replay['changed_scalar_frames']) == (117,42,395), + 'Exact inherited retiming scope') + for direction,expected in (('forward',158120),('backward',158168)): + need(checks[direction]['conservative_real_scalar_primitive_allowance'] == expected and + replay['native'][direction]['real_scalar_allowance'] == expected, + 'Both independent scalar invoices equal the unchanged source invoice') + return {'schema':'source-bound-retimed-arbitrary-native-supplier/1', + 'status':'PASS_ALL_632_INPUTS_BOTH_DIRECTIONS_AND_ALL_RETIMED_HELPER_PHASES', + 'local_helper_profile':helpers,'local_paid_profile':paid,'local_replays':checks, + 'retimed_native_receipt':replay,'retimed_source_head':RETIMED_HEAD, + 'retimed_artifact_sha256':RETIMED_FILES,'retimed_source_sha256':RETIMED_SOURCES, + 'external_main_boundaries_unchanged':True,'all_scalar_actions_and_order_unchanged':True, + 'all_warp_contacts_unchanged':True,'scalar_contact_frames_retimed':395, + 'all_408_helpers_arbitrary':True,'whole_helper_boundary_recipes':408, + 'distinct_physical_edge_and_boundary_recipes':len(physical), + 'fresh_arbitrary_input_fields':632,'authenticated_original_files':authenticated, + 'inherited_native_gate':inherited_gate, + 'boundary_movement_allowance':'Every new whole-helper left/right monomial and transport recipe contributes its full finite route and phase cost.'} diff --git a/research/kappa-hybrid-controller/native_geometry.py b/research/kappa-hybrid-controller/native_geometry.py new file mode 100644 index 0000000000..2d8c9297d0 --- /dev/null +++ b/research/kappa-hybrid-controller/native_geometry.py @@ -0,0 +1,421 @@ +#!/usr/bin/env python3 +"""Independent exact audit of native/direct controller specialization. + +The local supplier is separately validated by the complete source-bound gate. +This checks the literal specialized Laurent word, every surviving native +contact, every whole idle and endpoint phase, and both direct Q kernels. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +DEFAULT_SOURCE = HERE.parent/'pr4359-p7-padding/source' +LOCAL_HELPERS = {4: 26, 5: 2, 7: 29, 8: 42, 9: 309} +LOCAL_PAID = {1: 2253, 2: 515, 3: 445, 4: 102, 5: 40, 8: 8} +PINS = { + 'research/kappa-rebuild/transfer-audit/p3_native_audit.py': '5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902', + 'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json': 'c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa', +} +CLIFFORD_SHA256 = '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' + + +def need(ok, why): + if not ok: + raise AssertionError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +# Phase algebra adapted without mathematical changes from PR4416 native_inventory.py. +def norm(terms): + out = Counter() + for axis, value in terms: + out[axis] += value + return tuple(sorted((axis, value % 4) for axis, value in out.items() if axis and value % 4)) + + +def act(columns, value): + result = 0 + while value: + low = value & -value + result ^= columns[low.bit_length()-1] + value ^= low + return result + + +@lru_cache(None) +def polynomial(terms, dimension): + linear = [0]*dimension + quadratic = [0]*dimension + for axis, value in terms: + support = [i for i in range(dimension) if axis >> i & 1] + for i in support: + linear[i] = (linear[i]+value) % 4 + if value % 2: + for j in support: + if i < j: + quadratic[i] ^= 1 << j + return tuple(linear), tuple(quadratic) + + +def contact(old, new, route, dimension): + moved = norm((act(route, axis), value) for axis, value in old) + left, right = polynomial(moved, dimension), polynomial(new, dimension) + need(left[1] == right[1], 'Actual native contact has identical quadratic part') + delta = tuple((a-b) % 4 for a, b in zip(right[0], left[0])) + need(all(value in (0, 2) for value in delta), 'Even linear phase is a physical translation') + shift = sum((value//2) << i for i, value in enumerate(delta)) + need(polynomial(norm(list(moved)+[(shift, 2)]), dimension) == right, 'Full native forward phase') + inverse_shift = act(route, shift) + inverse = norm([(act(route, axis), value) for axis, value in new]+[(inverse_shift, 2)]) + need(polynomial(inverse, dimension) == polynomial(old, dimension), 'Full inverse contact phase') + return {'translation': shift, 'inverse_translation': inverse_shift} + + +def scalar_invoice(case, native_scalar): + word = case['right_program']+case['left_program'] + counts = Counter(row[0] for row in word) + need(all(Q(row[-1]) in (1, -1) for row in word if row[0] in ('ADD', 'SCALE')), + 'Literal boundary word has only unit coefficients') + adds = counts['ADD']+3*counts['SWAP'] + negs = counts['SCALE']+counts['SWAP'] + bridges = sum(row[0] == 'ADD' for row in case['physical_events']) + swaps = sum(row[0] == 'SIGNED_SWAP' for row in case['physical_events']) + return native_scalar+112*(8*(adds+bridges+3*swaps)+2*negs) + + +def specialize(case, native_mask): + """Apply the ring homomorphism D_s -> 1 to the actual finite word.""" + result = json.loads(json.dumps(case)) + for event in result['physical_events']: + if event[0] == 'LOCAL' and not (native_mask >> event[1]) & 1: + event[0] = 'DIRECT' + elif event[0] == 'IDLE': + event[2] = [s for s in event[2] if (native_mask >> s) & 1] + for monomial in result['exact_diagonal_monomials']: + for stage in range(2*case['pairs']+1): + if not (native_mask >> stage) & 1: + monomial[stage+1] = 0 + for window in result['retained_idle_windows']: + window['original_stages'] = window['stages'][:] + window['stages'] = [s for s in window['stages'] if (native_mask >> s) & 1] + window['rank'] = 8*len(window['stages']) + result['native_mask'] = native_mask + return result + + +def replay(case): + """Replay all input columns over the exact integer Laurent ring.""" + rows = 2*case['pairs'] + variables = len(case['coefficient_variables']) + zero = (0,)*variables + matrix = [[{zero:Q(1)} if i == j else {} for j in range(rows)] for i in range(rows)] + + def add(a, b, coefficient=1): + out = a.copy() + for term, value in b.items(): + out[term] = out.get(term, Q(0))+coefficient*value + if not out[term]: + del out[term] + return out + + def shift(row, delta): + return {tuple(x+y for x,y in zip(term,delta)):value for term,value in row.items()} + + events = case['right_program']+case['physical_events']+case['left_program'] + for event in events: + kind = event[0] + if kind == 'ADD': + _, destination, source, coefficient = event + matrix[destination] = [add(a,b,Q(coefficient)) for a,b in zip(matrix[destination],matrix[source])] + elif kind == 'SCALE': + _, role, coefficient = event + matrix[role] = [{term:Q(coefficient)*value for term,value in row.items()} for row in matrix[role]] + elif kind == 'SWAP': + _, a, b = event + matrix[a],matrix[b] = matrix[b],matrix[a] + elif kind == 'SIGNED_SWAP': + _, a, b = event + matrix[a],matrix[b] = matrix[b],[{term:-value for term,value in row.items()} for row in matrix[a]] + elif kind == 'IDLE': + _, pair, stages = event + delta = (0,)+tuple(int(s in stages) for s in range(variables-1)) + for role in (2*pair,2*pair+1): + matrix[role] = [shift(row,delta) for row in matrix[role]] + elif kind in ('LOCAL','DIRECT'): + _, stage, pair, backward = event + x,y = 2*pair,2*pair+1 + destination,source,coefficient = (x,y,-1) if backward else (y,x,1) + delta = (1 if backward else -1,)+(0,)*(variables-1) + matrix[destination] = [add(a,shift(b,delta),coefficient) + for a,b in zip(matrix[destination],matrix[source])] + if kind == 'LOCAL': + delta = tuple(int(i == stage+1) for i in range(variables)) + for role in (x,y): + matrix[role] = [shift(row,delta) for row in matrix[role]] + else: + raise AssertionError('Unrecognized literal event '+kind) + expected = [[{tuple(case['exact_diagonal_monomials'][i]):Q(1)} if i == j else {} + for j in range(rows)] for i in range(rows)] + need(matrix == expected,'Every exact coefficient of the specialized physical controller') + return {'input_columns':rows,'matrix_entries':rows*rows,'literal_events':len(events)} + + +def direct_recipes(phases, ce): + """Complete-phase rank-one kernels, with literal owned-copy semantics.""" + records = [] + negative_missing_inverse_shift = 0 + for port, recipe in enumerate(phases['recipes']): + q = recipe['q'] + basis = recipe['idle_children'][0]['orthogonal_axes'][:8] + columns = (q,*basis) + need(all((a&b).bit_count()%2 == int(i == j) + for i,a in enumerate(columns) for j,b in enumerate(columns)), + 'The actual port supplies a full orthonormal coordinate basis') + P = ce.perm(9,ce.transpose(columns,9)) + child = ce.fourier(9,[0]) + forward = P.adjoint().then(child).then(P) + inverse = forward.then(ce.xgate(9,q)) + directions = {} + for direction,op,sign in (('forward_Q',forward,1),('inverse_Q',inverse,-1)): + exact = ce.cgate(9,q,sign) + need(op.tab == exact.tab and op.zero_state() == exact.zero_state(), + 'All Pauli generators and the absolute phase of the actual Q kernel') + # The tableau fixes translation covariance, so equality on |0> + # proves every literal column; this loop independently checks the + # two nonzero coefficients of all 512 columns using the route. + a,b = (1,sign),(1,-sign) + for x in range(512): + y = ce.mv(ce.inv(ce.transpose(columns,9),9),x) + destinations = [ce.mv(ce.transpose(columns,9),y), + ce.mv(ce.transpose(columns,9),y^1)] + coefficients = [(1,1),(1,-1)] + if sign == -1: + destinations = [z^q for z in destinations] + observed = dict(zip(destinations,coefficients)) + need(observed == {x:a,x^q:b},'Literal two-point kernel on every coordinate column') + lowered,compiled = ce.lower_child(exact) + need(lowered['rank'] == 1 and compiled.tab == exact.tab and + compiled.zero_state() == exact.zero_state(),'Independent complete-phase rank-one lowering') + directions[direction] = {'kernel_numerator_at_x':a,'kernel_numerator_at_x_xor_q':b, + 'kernel_denominator':2,'rank':1,'phase_Z4':0, + 'translation_after':q if sign == -1 else 0, + 'independent_lowering':lowered} + need(forward.tab != inverse.tab or forward.zero_state() != inverse.zero_state(), + 'Omitting the inverse translation changes the operator') + negative_missing_inverse_shift += 1 + records.append({'port':port,'q':q,'route_columns':columns,'directions':directions, + 'owned_scratch_fields':1,'productive_scratch_endpoints':0, + 'paid_queries_per_direct_stage':1, + 'literal_forward':[['ZERO','tmp'],['ADD','tmp','X',1], + ['GAUSSIAN_Q_INVERSE','tmp'],['ADD','Y','tmp',1],['RELEASE','tmp']], + 'literal_backward':[['ZERO','tmp'],['ADD','tmp','Y',1], + ['GAUSSIAN_Q','tmp'],['ADD','X','tmp',-1],['RELEASE','tmp']]}) + return records,negative_missing_inverse_shift + + +def geometry(case, phases, native_mask): + p = case['pairs'] + dimension = 9+16*p + axes = tuple(1<>stage)&1 for stage,yes in enumerate(selected)), + 'No productive rank on any specialized-away D axis') + for port,recipe in enumerate(phases['recipes']): + q = recipe['q'] + physical = norm([(q,qp)]+[entry for stage,yes in enumerate(selected) if yes + for entry in stage_frame(stage,q)]) + positive = list(axes[:9]) if selected[0] else [q] + positive += [axis for stage in range(1,len(selected)) if selected[stage] + for axis in axes[9+8*(stage-1):9+8*stage]] + shift = q if qp == -1 else 0 + need(len(positive) == 1+8*sum(selected),'Specialized productive endpoint rank') + need(polynomial(norm(list(physical)+[(shift,2)]),dimension) == + polynomial(norm((axis,1) for axis in positive),dimension),'Complete specialized endpoint phase') + if shift: + need(polynomial(physical,dimension) != polynomial(norm((axis,1) for axis in positive),dimension), + 'Omitting the endpoint translation changes the operator') + endpoint_negative += 1 + endpoints.append({'role':role,'port':port,'rank':len(positive),'axes':positive,'translation':shift}) + target_main[len(positive)] += 1 + literal = Counter((row[1],tuple(row[2])) for row in case['physical_events'] if row[0] == 'IDLE') + recorded = Counter((row['pair'],tuple(row['stages'])) for row in case['retained_idle_windows']) + need(literal == recorded,'Bijection of specialized literal IDLE records and whole idle invoices') + idle,records = Counter(),[] + for window in case['retained_idle_windows']: + selected = window['stages'] + for port,recipe in enumerate(phases['recipes']): + q = recipe['q'] + positive = recipe['idle_children'][0]['orthogonal_axes'][:8] if 0 in selected else [] + positive += [axis for stage in selected if stage > 0 + for axis in axes[9+8*(stage-1):9+8*stage]] + shift = recipe['idle_children'][0]['translation_after'] if 0 in selected else 0 + desired = norm(entry for stage in selected for entry in stage_frame(stage,q)) + actual = norm([(axis,1) for axis in positive]+[(shift,2)]) + need(len(positive) == window['rank'],'Exact specialized whole idle rank') + need(all((a&b).bit_count()%2 == int(i == j) + for i,a in enumerate(positive) for j,b in enumerate(positive)), + 'Exact specialized whole idle independent orthogonal axes') + need(polynomial(actual,dimension) == polynomial(desired,dimension),'Complete specialized whole idle phase') + if positive: + idle[len(positive)] += 2 + records.append({'window':window['index'],'pair':window['pair'],'stages':selected,'port':port, + 'axes':positive,'translation':shift,'paid_queries':2 if positive else 0}) + targets = target_main+Counter({r:c*len(stages) for r,c in LOCAL_HELPERS.items()}) + paid = Counter({r:c*len(stages) for r,c in LOCAL_PAID.items()})+idle + direct = [event for event in case['physical_events'] if event[0] == 'DIRECT'] + paid[1] += len(phases['recipes'])*len(direct) + scalar_native = sum(158168 if row[3] else 158120 for row in stages) + scalar_boundary = scalar_invoice(case,scalar_native) + scalar_direct = 64*len(phases['recipes'])*len(direct) + receipt = {'dimension':dimension,'native_stages':len(stages),'direct_stages':len(direct), + 'native_stage_indices':[row[1] for row in stages], + 'direct_stage_indices':[row[1] for row in direct], + 'main_contact_checks':4*len(contacts),'productive_main_fields':sum(target_main.values()), + 'fresh_helper_fields':408*len(stages),'productive_fields':sum(targets.values()), + 'targets':dict(sorted(targets.items())),'paid':dict(sorted(paid.items())), + 'whole_idle_profile':dict(sorted(idle.items())), + 'direct_paid_queries':len(phases['recipes'])*len(direct), + 'direct_scalar_allowance':scalar_direct,'native_and_boundary_scalar_allowance':scalar_boundary, + 'scalar_allowance':scalar_boundary+scalar_direct, + 'paid_calls':sum(paid.values()),'rank_margin':sum(r*c for r,c in targets.items())-sum(r*c for r,c in paid.items()), + 'omitted_endpoint_translation_rejected':endpoint_negative} + return receipt,{'contacts':contacts,'endpoints':endpoints,'whole_idles':records} + + +def run(case_path, native_mask, source_root=DEFAULT_SOURCE, output_dir=None): + root = Path(source_root).resolve() + source_pins = {} + for relative,expected in PINS.items(): + data = (root/relative).read_bytes() + need(sha256(data).hexdigest() == expected,'Exact source pin: '+relative) + source_pins[relative] = expected + ce_path = HERE/'dependencies/clifford_exact.py' + need(sha256(ce_path.read_bytes()).hexdigest() == CLIFFORD_SHA256,'Pinned exact Clifford compiler') + ce = load(ce_path,'hybrid_exact_clifford_audit') + independent = load(root/list(PINS)[0],'hybrid_original_laurent') + phases = read(root/list(PINS)[1]) + need(len(phases['recipes']) == 112,'All112 actual ports') + original_case = read(case_path) + need(0 < native_mask < 1<<(2*original_case['pairs']+1) and native_mask&1, + 'Selected mixed controller retains D0') + independent.replay(original_case) + case = specialize(original_case,native_mask) + laurent = replay(case) + negative = json.loads(json.dumps(case)) + direct_event = next(event for event in negative['physical_events'] if event[0] == 'DIRECT') + direct_event[3] = not direct_event[3] + negative_ok = False + try: + replay(negative) + except AssertionError: + negative_ok = True + need(negative_ok,'A wrong direct shear orientation fails the full exact Laurent word') + direct,missing_shift = direct_recipes(phases,ce) + receipt,artifact = geometry(case,phases,native_mask) + artifact.update({'formal':case,'direct_recipes':direct}) + payload = canonical(artifact) + receipt.update({'schema':'independent-exact-native-direct-controller-audit/1', + 'status':'PASS_SPECIALIZED_LAURENT_NATIVE_CONTACTS_DIRECT_KERNELS_ENDPOINTS_IDLES', + 'p':case['pairs'],'keep':case['keep_idle_mask'],'native_mask':native_mask, + 'laurent':laurent,'wrong_direct_orientation_rejected':negative_ok, + 'omitted_direct_inverse_translation_rejected':missing_shift, + 'direct_query_rank_for_f_columns':'f, with the same ancestor weight; never f rank-one column queries', + 'direct_scratch_ownership':'Copy source to an owned zero array; query that copy; add to destination; release. No arbitrary helper or productive scratch credit.', + 'artifact_sha256':sha256(payload).hexdigest(), + 'artifact_hash_encoding':'Uncompressed UTF-8 JSON, sort_keys=True, separators=(comma,colon)', + 'case_sha256':sha256(case_path.read_bytes()).hexdigest(), + 'clifford_source_sha256':CLIFFORD_SHA256, + 'source_sha256':source_pins, + 'local_profiles':'Independently audited PR4441 retimed local supplier; the enclosing native_inventory reruns its complete literal and phase gate.', + 'limits':'Finite exact native/direct phase and scalar accounting; tensor strictification, full finite route and owned stock invoices, precision, analytic and fixed-tape/recovery premises remain separate.'}) + if output_dir is not None: + output_dir.mkdir(parents=True,exist_ok=True) + (output_dir/'HYBRID-GEOMETRY.json.gz').write_bytes(gzip.compress(payload,compresslevel=9,mtime=0)) + (output_dir/'HYBRID-GEOMETRY.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + return receipt,artifact + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--case',type=Path,default=HERE/'controller/P17-FULL-LAURENT-CASE.json') + parser.add_argument('--native-mask',type=int,default=28633115307) + parser.add_argument('--source-root',type=Path,default=DEFAULT_SOURCE) + parser.add_argument('--output-dir',type=Path) + args = parser.parse_args() + result,_ = run(args.case,args.native_mask,args.source_root,args.output_dir) + print(json.dumps({k:result[k] for k in ('status','p','keep','native_mask','native_stages','direct_stages','targets','paid','rank_margin','scalar_allowance')},sort_keys=True)) diff --git a/research/kappa-hybrid-controller/native_inventory.py b/research/kappa-hybrid-controller/native_inventory.py new file mode 100644 index 0000000000..7dad0de005 --- /dev/null +++ b/research/kappa-hybrid-controller/native_inventory.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python3 +"""Rebuild the complete source-bound p17 native/direct physical invoice.""" +from collections import Counter +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +DEFAULT_SOURCE = HERE.parent/'pr4359-p7-padding/source' +GEOMETRY_PAYLOAD_SHA256 = 'a58789b3cc4449fd7f9520119b2aaf6f5d9f7351cc34ed96f32e41e4169eb034' + + +def need(ok, why): + if not ok: + raise AssertionError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name,path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def digest(path): + return sha256(path.read_bytes()).hexdigest() + + +def run(source_root=DEFAULT_SOURCE, output_dir=None, retimed_source_root=None): + root = Path(source_root).resolve() + parameters = load(HERE/'parameters.py','hybrid_inventory_parameters') + supplier_module = load(HERE/'local_supplier.py','hybrid_inventory_supplier') + local = supplier_module.run(root,retimed_source_root) + factory = load(HERE/'controller/make_direct_case.py','hybrid_inventory_factory') + factor = factory.run(root) + need(factor['status'] == 'PASS_EXACT_P17_LAURENT_SPECIALIZATION', 'Fresh exact controller factorization') + geometry_module = load(HERE/'native_geometry.py','hybrid_inventory_geometry') + geometry,artifact = geometry_module.run(HERE/'controller/P17-FULL-LAURENT-CASE.json', + parameters.NATIVE_MASK,root) + need((geometry['p'],geometry['keep'],geometry['native_mask'],geometry['dimension']) == + (parameters.PAIRS,parameters.KEEP,parameters.NATIVE_MASK,parameters.AMBIENT), + 'Exact source-bound controller and full original carrier') + need(tuple(geometry['direct_stage_indices']) == parameters.DIRECT_STAGES and + geometry['native_stages'] == parameters.INVOCATIONS, 'Exact native/direct chronology') + need(geometry_module.LOCAL_HELPERS == local['local_helper_profile'] == parameters.LOCAL_HELPERS and + geometry_module.LOCAL_PAID == local['local_paid_profile'] == parameters.LOCAL_PAID, + 'Geometry uses the fresh arbitrary-input local supplier profiles') + need(geometry['targets'] == parameters.TARGETS and geometry['paid'] == parameters.PAID, + 'Exact complete native/direct/idle/helper tariff') + need(sum(k*v for k,v in geometry['targets'].items()) == parameters.TARGET_MASS and + sum(k*v for k,v in geometry['paid'].items()) == parameters.PAID_MASS and + geometry['productive_fields'] == parameters.PRODUCTIVE_FIELDS, + 'Exact productive census and both rank-one masses') + direct_case = json.loads((HERE/'controller/P17-DIRECT-CASE.json').read_text()) + need(artifact['formal']['exact_diagonal_monomials'] == direct_case['exact_diagonal_monomials'], + 'Independent literal replay and rational factor factory agree on every endpoint') + need(Counter({int(k):v for k,v in direct_case['complete_paid_profile'].items()}) == Counter(parameters.PAID) and + Counter({int(k):v for k,v in direct_case['complete_productive_profile'].items()}) == Counter(parameters.TARGETS), + 'Independent factor invoice agrees with physical geometry') + payload = geometry_module.canonical(artifact) + frozen_path = HERE/'certificates/HYBRID-GEOMETRY.json.gz' + frozen_payload = gzip.decompress(frozen_path.read_bytes()) + need(sha256(payload).hexdigest() == GEOMETRY_PAYLOAD_SHA256 and payload == frozen_payload, + 'Every generated contact/route/endpoint/direct kernel equals the audited canonical payload') + native_orientation = Counter('backward' if row[3] else 'forward' + for row in artifact['formal']['physical_events'] if row[0] == 'LOCAL') + need(native_orientation == Counter(forward=2,backward=17), 'Exact local scalar orientation counts') + native_scalar = sum(local['local_replays'][direction]['conservative_real_scalar_primitive_allowance']*count + for direction,count in native_orientation.items()) + need(geometry_module.scalar_invoice(artifact['formal'],native_scalar) == + geometry['native_and_boundary_scalar_allowance'], 'Complete fresh native and boundary scalar invoice') + need(geometry['direct_paid_queries'] == 1792 and geometry['direct_scalar_allowance'] == 64*1792, + 'Every owned-copy direct query and its pointwise operations are charged') + result = dict(geometry) + result.update(schema='complete-source-bound-hybrid-p17-native-inventory/1', + status='PASS_RETIMED_SUPPLIER_AND_ALL_HYBRID_CONTROLLER_PHASES', + local_supplier=local,factor_factory=factor, + direct_owned_copy_episodes=1792,direct_owned_release_episodes=1792, + direct_productive_scratch_endpoints=0, + direct_nonrecursive_movement_records_allowance=8*1792, + raw_owned_bank_episodes=parameters.INVOCATIONS+1792, + owned_bank_scope='Each direct copy persists across its own recursive request and is released after the ADD. Each native invocation retains its original owned center. All nested suspended banks are separately charged.', + all_column_direct_recipe='At f columns the address map is P tensor I_f (or I_f tensor P in column order), with its induced per-column array permutation. Use one Gaussian child of rank f, inverse route and repeated q translation for C_q inverse. The request has the complete ancestor weight.', + geometry_payload_sha256=GEOMETRY_PAYLOAD_SHA256, + geometry_source_sha256=digest(HERE/'native_geometry.py'), + local_supplier_source_sha256=digest(HERE/'local_supplier.py'), + factor_factory_source_sha256=digest(HERE/'controller/make_direct_case.py'), + parameters_sha256=digest(HERE/'parameters.py'), + limits='Complete finite native/direct controller admission. The common-column tensor rule, expanded fixed route/scalar/owned-stock bounds and inherited precision, analytic, fixed-tape and exact-recovery premises are written separately in PROOF.md.') + if output_dir is not None: + output_dir = Path(output_dir) + output_dir.mkdir(parents=True,exist_ok=True) + (output_dir/'NATIVE.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + return result + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root',type=Path,default=DEFAULT_SOURCE) + parser.add_argument('--output-dir',type=Path) + parser.add_argument('--retimed-source-root',type=Path) + args = parser.parse_args() + result = run(args.source_root,args.output_dir,args.retimed_source_root) + print(json.dumps({key:result[key] for key in ('status','p','targets','paid','rank_margin','scalar_allowance')},sort_keys=True)) diff --git a/research/kappa-hybrid-controller/parameters.py b/research/kappa-hybrid-controller/parameters.py new file mode 100644 index 0000000000..43bc35bd7a --- /dev/null +++ b/research/kappa-hybrid-controller/parameters.py @@ -0,0 +1,31 @@ +"""Exact parameters for the source-bound p17 native/direct controller.""" +from fractions import Fraction as Q + +PAIRS = 17 +CUT = 8 +KEEP = 280378328416255 +NATIVE_MASK = 28633115307 +AMBIENT = 281 +INVOCATIONS = 19 +DIRECT_STAGES = tuple(range(2, 33, 2)) +TESTED_SAVING = Q('0.003001054') +KAPPA = Q('0.003001053') +BIT_SAVING = Q('0.00312') +EXPONENT = 17160 +CUTOFF = 18 +TARGET_FLOOR = 19 +ALPHA_UPPER = 1-Q(1, 10000000000) +GAMMA_UPPER = Q(9991, 10000) +DELTA_UPPER = Q(6, 7) +BLOCK = 780 +COMPLETION_BLOCK = 5 +THETA_DENOMINATOR = 55 +CUTOFF_LOG2_UPPER = 5 +AMBIENT_LOG2_UPPER = 9 +TARGETS = {4: 494, 5: 38, 7: 551, 8: 798, 9: 5871, 17: 448, 25: 448, 33: 448, 41: 448, 49: 448, 57: 448, 65: 448, 73: 448, 153: 224} +PAID = {1: 44599, 2: 9785, 3: 8455, 4: 1938, 5: 760, 8: 152, 16: 448, 24: 448, 32: 448, 40: 448, 48: 448, 56: 448, 64: 448, 72: 448} +PRODUCTIVE_FIELDS = 11560 +TARGET_MASS = 260798 +PAID_MASS = 259998 +LOCAL_HELPERS = {4: 26, 5: 2, 7: 29, 8: 42, 9: 309} +LOCAL_PAID = {1: 2253, 2: 515, 3: 445, 4: 102, 5: 40, 8: 8} diff --git a/research/kappa-hybrid-controller/search/SEARCH.md b/research/kappa-hybrid-controller/search/SEARCH.md new file mode 100644 index 0000000000..8e688a7053 --- /dev/null +++ b/research/kappa-hybrid-controller/search/SEARCH.md @@ -0,0 +1,99 @@ +# Direct-stage search in the minimal-cut path family + +The selected candidate has 17 data pairs, cut 8, idle mask +`280378328416255`, and native-stage mask `28633115307`. Stages +`2,4,...,32` are direct rank-one Q shears. The remaining 19 stages use the +audited retimed native supplier from PR #4441 at commit +`ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9`. Its helper profile is +`{4:26,5:2,7:29,8:42,9:309}` and its complete local paid profile is +`{1:2253,2:515,3:445,4:102,5:40,8:8}`. This supplier already includes +the fifteen previously shortened helper lifetimes. + +Its raw moment root is approximately `0.003001054183175`. This number is a +discovery estimate. The independent integration package supplies the exact +interval inequality, physical bindings, and inherited transfer obligations. + +## Dynamic program + +For a controller with p pairs, there are `2p+1` local stages. Fix a cut c +between 0 and p−1. The minimal-cut idle mask retains all middle singleton +windows, the c initial windows, and the p−1−c terminal windows. Before +specialization, the main output monomials are two copies of each of: + +* prefixes `[0,...,2j]`, for `1<=j<=c`; +* suffixes `[2p−2j,...,2p]`, for `1<=j<=p−1−c`; +* the full stage interval `[0,...,2p]`. + +Each copy corresponds to 112 physical fields. For a binary choice of native +stages, an output interval containing n selected stages has productive +width `1+8n`. A retained idle interval containing n selected stages costs +224 children of width `8n`, and disappears when n is zero. Each native +stage contributes the same local paid and helper histograms. Each direct +stage contributes 112 rank-one children and no native helper outputs. + +At a test exponent tau, write `f(r)=r^tau`, with `f(0)=0`. A left branch +of length c is processed from the outer endpoint toward the central stage. +Before its j-th even stage, let t be the number of native stages already +selected. Selecting that even stage with bit e contributes + +`224 [ f(1+8(t+e)) − f(8t) − e f(8) ]`. + +The first two terms are the paired productive prefix and idle prefix. The +last term prices the middle singleton. The following odd bit changes only +the native count used by subsequent terms. Thus the sufficient branch state +is its current native count; the program stores the best score and one +realizing mask for each count. The right branch is the reflected recurrence. + +The two outermost positions of a nonempty branch have identical membership +in every relevant output and idle interval. Their individual bit order has +no effect on the invoice: only their total count 0, 1, or 2 matters. The +implementation therefore keeps `01` as a representative of the one-selected +case and omits the equivalent `10`. This is an equivalence of these profiles, +not an assertion that the two physical native placements are identical. + +For branch counts nL and nR and central-stage bit m, let n=nL+nR+m. Their +remaining shared score is + +`n [112 + helper_moment − local_paid_moment] − 112(2p+1) + 224 f(1+8n)`. + +The first terms charge native versus direct local stages; the last term +is the full-interval productive output. Enumerating the two branch counts, +the central bit, and all cuts therefore covers every direct/native stage +mask in this minimal-cut path family, up to the stated outer-bit equivalence. + +## Search scope and numerical limitations + +The floating-point dynamic program was run for every p from 1 through 120, +every cut, and every native-count state at test kappa `0.00300106`. Its best +candidate is the p17 profile above. The same controller had previously been +selected using the fifteen-tail-pruned supplier. The new run replaces the +complete local helper and paid histograms before scoring every candidate. + +This is not a proof of global optimality. It does not cover arbitrary idle +masks outside the minimal-cut family, other controller topologies, new +native suppliers, or every p beyond 120. Floating comparison of dynamic +programming scores is a discovery procedure. The positive p17 result is +certified separately using exact rational Laurent identities and exact +integer histograms, followed by the integration package's interval tests. + +## Reproduction + +Run from this directory: + +```sh +python direct_stage_dp.py --max-p 120 --kappa 0.00300106 --summary --out SUMMARY-120.json +python ../controller/make_direct_case.py --source-root /path/to/integer-mult-bounds +``` + +The controller builder authenticates the attributed controller and rational +algebra source files. It reconstructs and factors the full complex controller +over the rational Laurent ring, substitutes the direct-stage variables by +one, and checks every specialized coefficient with the same exact scalar +boundary factors. A wrong backward sign fails this check. It independently +reconstructs the binary monomial factor only to cross-check the integer +width histogram; the complex acceptance check retains both Q and Q inverse. + +The exact specialized receipt is `../controller/P17-DIRECT-CASE.json`. The +unspecialized receipt is `../controller/P17-FULL-LAURENT-CASE.json`. Sparse matrix +multiplication in the builder omits zero summands but retains exact rational +arithmetic throughout. diff --git a/research/kappa-hybrid-controller/search/SUMMARY-120.json b/research/kappa-hybrid-controller/search/SUMMARY-120.json new file mode 100644 index 0000000000..e55c4df76d --- /dev/null +++ b/research/kappa-hybrid-controller/search/SUMMARY-120.json @@ -0,0 +1,1267 @@ +{ + "test_kappa": 0.00300106, + "all_cuts": true, + "profiles": [ + { + "p": 1, + "cut": 0, + "keep": 0, + "native_mask": 7, + "native_stages": 3, + "kappa": 0.001050352546488753, + "rank_mass_gap": 32, + "score_at_test_kappa": -59.154398789763036 + }, + { + "p": 2, + "cut": 0, + "keep": 6, + "native_mask": 31, + "native_stages": 5, + "kappa": 0.002167399874259992, + "rank_mass_gap": 128, + "score_at_test_kappa": -48.971853246059254 + }, + { + "p": 3, + "cut": 1, + "keep": 43, + "native_mask": 107, + "native_stages": 5, + "kappa": 0.002269237756339599, + "rank_mass_gap": 128, + "score_at_test_kappa": -41.06821219937956 + }, + { + "p": 4, + "cut": 1, + "keep": 427, + "native_mask": 427, + "native_stages": 6, + "kappa": 0.002513260964983246, + "rank_mass_gap": 176, + "score_at_test_kappa": -33.97865336606992 + }, + { + "p": 5, + "cut": 2, + "keep": 3247, + "native_mask": 1707, + "native_stages": 7, + "kappa": 0.0026685554311550418, + "rank_mass_gap": 224, + "score_at_test_kappa": -27.758222231947002 + }, + { + "p": 6, + "cut": 2, + "keep": 29359, + "native_mask": 6827, + "native_stages": 8, + "kappa": 0.002770856992494331, + "rank_mass_gap": 272, + "score_at_test_kappa": -22.47122786433647 + }, + { + "p": 7, + "cut": 3, + "keep": 232127, + "native_mask": 27307, + "native_stages": 9, + "kappa": 0.0028417423520697227, + "rank_mass_gap": 320, + "score_at_test_kappa": -17.83758976466379 + }, + { + "p": 8, + "cut": 3, + "keep": 1977023, + "native_mask": 109227, + "native_stages": 10, + "kappa": 0.0028909757400013454, + "rank_mass_gap": 368, + "score_at_test_kappa": -13.931114701339538 + }, + { + "p": 9, + "cut": 4, + "keep": 15772415, + "native_mask": 436907, + "native_stages": 11, + "kappa": 0.0029264142630525914, + "rank_mass_gap": 416, + "score_at_test_kappa": -10.548115086774487 + }, + { + "p": 10, + "cut": 4, + "keep": 130198271, + "native_mask": 1747627, + "native_stages": 12, + "kappa": 0.0029513960517153857, + "rank_mass_gap": 464, + "score_at_test_kappa": -7.7607213325827615 + }, + { + "p": 11, + "cut": 5, + "keep": 1040886783, + "native_mask": 6990507, + "native_stages": 13, + "kappa": 0.002969489782654193, + "rank_mass_gap": 512, + "score_at_test_kappa": -5.410003097658773 + }, + { + "p": 12, + "cut": 5, + "keep": 8458513407, + "native_mask": 27962027, + "native_stages": 14, + "kappa": 0.0029819652528867376, + "rank_mass_gap": 560, + "score_at_test_kappa": -3.563648286348325 + }, + { + "p": 13, + "cut": 6, + "keep": 67656921087, + "native_mask": 111848107, + "native_stages": 15, + "kappa": 0.0029907052459692807, + "rank_mass_gap": 608, + "score_at_test_kappa": -2.091854442471231 + }, + { + "p": 14, + "cut": 6, + "keep": 545505587199, + "native_mask": 447392427, + "native_stages": 16, + "kappa": 0.0029961994668024523, + "rank_mass_gap": 656, + "score_at_test_kappa": -1.057417918334977 + }, + { + "p": 15, + "cut": 7, + "keep": 4363865735167, + "native_mask": 1789569707, + "native_stages": 17, + "kappa": 0.0029995552775870142, + "rank_mass_gap": 704, + "score_at_test_kappa": -0.35089061083999695 + }, + { + "p": 16, + "cut": 7, + "keep": 35047648968703, + "native_mask": 7158278827, + "native_stages": 18, + "kappa": 0.0030009377992287157, + "rank_mass_gap": 752, + "score_at_test_kappa": -0.030423252457694616 + }, + { + "p": 17, + "cut": 8, + "keep": 280378328416255, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0030010541831747175, + "rank_mass_gap": 800, + "score_at_test_kappa": -0.00154044392547803 + }, + { + "p": 18, + "cut": 8, + "keep": 2247413220442111, + "native_mask": 114532461227, + "native_stages": 20, + "kappa": 0.002999926883220745, + "rank_mass_gap": 848, + "score_at_test_kappa": -0.31818344225757755 + }, + { + "p": 19, + "cut": 9, + "keep": 17979259950465023, + "native_mask": 458129844907, + "native_stages": 21, + "kappa": 0.002998037361693449, + "rank_mass_gap": 896, + "score_at_test_kappa": -0.8973258529003942 + }, + { + "p": 20, + "cut": 9, + "keep": 143974633839525887, + "native_mask": 1832519379627, + "native_stages": 22, + "kappa": 0.0029953445031419444, + "rank_mass_gap": 944, + "score_at_test_kappa": -1.7891570000792854 + }, + { + "p": 21, + "cut": 8, + "keep": 1152640762637910015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 22, + "cut": 8, + "keep": 9222249068978962431, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 23, + "cut": 8, + "keep": 73782484423334887423, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 24, + "cut": 8, + "keep": 590277842872692310015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 25, + "cut": 8, + "keep": 4722294612925591781375, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 26, + "cut": 8, + "keep": 37778644383180947914751, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 27, + "cut": 8, + "keep": 302230304984552438431743, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.0029931394958099124, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 28, + "cut": 8, + "keep": 2417847039552838928367615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 29, + "cut": 8, + "keep": 19342794715128389111054335, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 30, + "cut": 8, + "keep": 154742431315849823625347071, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 31, + "cut": 8, + "keep": 1237939744906089431950884863, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 32, + "cut": 8, + "keep": 9903519136765878827399970815, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 33, + "cut": 8, + "keep": 79228157804195684106371792895, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 34, + "cut": 8, + "keep": 633825281273840086799662907391, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 35, + "cut": 8, + "keep": 5070602325551819150192057974783, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 36, + "cut": 8, + "keep": 40564818905858947024715483119615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 37, + "cut": 8, + "keep": 324518552452649151490439942701055, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 38, + "cut": 8, + "keep": 2596148424444303513094383853043711, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 39, + "cut": 8, + "keep": 20769187414846869309438528070549503, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 40, + "cut": 8, + "keep": 166153499395944719294242053549654015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 41, + "cut": 8, + "keep": 1329227995476236813628871744338722815, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 42, + "cut": 8, + "keep": 10633823965044610746130715218476204031, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 43, + "cut": 8, + "keep": 85070591725295750917444686802875777023, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 44, + "cut": 8, + "keep": 680564733822121467133153354643271254015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 45, + "cut": 8, + "keep": 5444517870655993576239610278027230642175, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 46, + "cut": 8, + "keep": 43556142965564035966614415987742088036351, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 47, + "cut": 8, + "keep": 348449143725776637159705462956033676345343, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 48, + "cut": 8, + "keep": 2787593149811270494984804243864657299439615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 49, + "cut": 8, + "keep": 22300745198510393550707076111782809950683135, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 50, + "cut": 8, + "keep": 178405961588164066768971177537724685826588671, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 51, + "cut": 8, + "keep": 1427247692705636207605027694875646311497662463, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 52, + "cut": 8, + "keep": 11417981541646384354653254657300565791521570815, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 53, + "cut": 8, + "keep": 91343852333176253612478169651586107530334109695, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 54, + "cut": 8, + "keep": 730750818665430744000833886785415185035319508991, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 55, + "cut": 8, + "keep": 5846006549323528812410705212574226779453143056383, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 56, + "cut": 8, + "keep": 46768052394588561940901778173757435432307492847615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 57, + "cut": 8, + "keep": 374144419156709821293678771282713968245189336825855, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 58, + "cut": 8, + "keep": 2993155353253683873415288353832329685108432271245311, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 59, + "cut": 8, + "keep": 23945242826029492199585739564941109237455128476975103, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 60, + "cut": 8, + "keep": 191561942608236022445739647456658760925991709044310015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 61, + "cut": 8, + "keep": 1532495540865888518962132103401789635513336397268975615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 62, + "cut": 8, + "keep": 12259964326927109509281916522208395276528302077810245631, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 63, + "cut": 8, + "keep": 98079714615416881504594770957643474981912860221116186623, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 64, + "cut": 8, + "keep": 784637716923335073758115922781053050934048656163466838015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 65, + "cut": 8, + "keep": 6277101735386680676950358402728045411787372346885884542975, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 66, + "cut": 8, + "keep": 50216813883093445763144591303742847311558911165399676157951, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 67, + "cut": 8, + "keep": 401734511064747567495323626757616714561511018884447808978943, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 68, + "cut": 8, + "keep": 3213876088517980545523256599371629460768247069320584071151615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 69, + "cut": 8, + "keep": 25711008708143844386428723136215818663250612227544678966951935, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 70, + "cut": 8, + "keep": 205688069665150755180400466454697681214423440512277457327030271, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 71, + "cut": 8, + "keep": 1645504557321206041799086457097465977349061694865899760982360063, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 72, + "cut": 8, + "keep": 13164036458569648335816222558619265929327190241997918497323810815, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 73, + "cut": 8, + "keep": 105312291668557186692223904076312279876756308668266229616450666495, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 74, + "cut": 8, + "keep": 842498333348457493560567727039930848782605616275261363483046510591, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 75, + "cut": 8, + "keep": 6739986666787659948575647794037177229335065517918617014070137257983, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 76, + "cut": 8, + "keep": 53919893334301279588969606263168339590977406494215040537384159215615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 77, + "cut": 8, + "keep": 431359146674410236713214545748830403753006781357184741998365518790655, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 78, + "cut": 8, + "keep": 3450873173395281893711547148564577978124804368471335606784093131046911, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 79, + "cut": 8, + "keep": 27606985387162255149715700318812362817401435418226115537461420971720703, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 80, + "cut": 8, + "keep": 220855883097298041197818895071681858508823485227630647032446071467606015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 81, + "cut": 8, + "keep": 1766847064778384329582924330658186691949035889348332067190587386516668415, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 82, + "cut": 8, + "keep": 14134776518227074636664887325604420831106079144895804101248774351237087231, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 83, + "cut": 8, + "keep": 113078212145816597093325069326191075830903801279603023064886495846312116223, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 84, + "cut": 8, + "keep": 904625697166532776746624437494951443375451082718570545538677170916159062015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 85, + "cut": 8, + "keep": 7237005577332262213973091031501302893916491351675549808387758183911921483775, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 86, + "cut": 8, + "keep": 57896044618658097711785110378177188538983461573112340243415428737625968279551, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 87, + "cut": 8, + "keep": 463168356949264781694282411530084569862473815623730489052576882966330132332543, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 88, + "cut": 8, + "keep": 3705346855594118253554265406259344805102215017145170980841628875991930603503615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 89, + "cut": 8, + "keep": 29642774844752946028434147706149431425627418105782676120417086256980603007860735, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 90, + "cut": 8, + "keep": 237142198758023568227473279473494143344258136720746642058072911052025456782671871, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387747049 + }, + { + "p": 91, + "cut": 8, + "keep": 1897137590064188545819786627085147914511020261263914068843528172400926185140977663, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 92, + "cut": 8, + "keep": 15177100720513508366558294581869962387115982760103076280264004915146299604646690815, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 93, + "cut": 8, + "keep": 121416805764108066932466362915714815381039144760791665160175157464925957331249463295, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 94, + "cut": 8, + "keep": 971334446112864535459730928368738988184758288806201540953653732294429900626299912191, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 95, + "cut": 8, + "keep": 7770675568902916283677847527121993766023846833329085206318239748655528172915616579583, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 96, + "cut": 8, + "keep": 62165404551223330269422780617664277570373896758150573165301957550444581254945802223615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 97, + "cut": 8, + "keep": 497323236409786642155382246544067530331723662431276151381439818648358073526049896595455, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 98, + "cut": 8, + "keep": 3978585891278293137243057978763553481728719252914495475287615182166070282154333088448511, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 99, + "cut": 8, + "keep": 31828687130226345097944463855752480810129473837173108859245307989245385033018400370786303, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 100, + "cut": 8, + "keep": 254629497041810760783555710948596058306234669952813451101740010041630371367282145619542015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 101, + "cut": 8, + "keep": 2037035976334486086268445687999073313750672876644221929725030264843712135350796935569801215, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 102, + "cut": 8, + "keep": 16296287810675888690147565505633805899208565081240632721444682856792373740456534567012728831, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 103, + "cut": 8, + "keep": 130370302485407109521180524051635324750481248922272490906135225806509696554252912865919565823, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 104, + "cut": 8, + "keep": 1042962419883256876169444192439342108231100904467569643787392858260760398956425848246627926015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 105, + "cut": 8, + "keep": 8343699359066055009355553539619774906757810888098116016452387073320814497741016967250109464575, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 106, + "cut": 8, + "keep": 66749594872528440074844428317378351417698501714215163596232073415505441206286576463109220401151, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 107, + "cut": 8, + "keep": 533996758980227520598755426540707419996132072151442250628308494639799230547726374605307142406143, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 108, + "cut": 8, + "keep": 4271974071841820164790043412332381794587232810962421772460275586381416647971546048444190656495615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 109, + "cut": 8, + "keep": 34175792574734561318320347298685944095170567422702909249417435208103424398131308593960459321409535, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 110, + "cut": 8, + "keep": 273406340597876490546562778389595111715255359121637414274280403733035760042486229577311410849513471, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 111, + "cut": 8, + "keep": 2187250724783011924372502227117191129537606151933155875310006918137119539769632879921002231909515263, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 112, + "cut": 8, + "keep": 17498005798264095394980017816939249979563102331305473246943110098188290155876035212578061635730210815, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 113, + "cut": 8, + "keep": 139984046386112763159840142535520883609553831113804690953397099797871656597884170393464668207658500095, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 114, + "cut": 8, + "keep": 1119872371088902105278721140284194603968626698763881147538585674432434594186576917919078046148535713791, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 115, + "cut": 8, + "keep": 8958978968711216842229769122273666972117797789524823659954320899657322119106629562438067171137357021183, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 116, + "cut": 8, + "keep": 71671831749689734737838152978189776338417519113853687198217109214049958415309093375846308576895141871615, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 117, + "cut": 8, + "keep": 573374653997517877902705223825519972953240700101449889260067041779565193172296974512137553446346278240255, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 118, + "cut": 8, + "keep": 4586997231980143023221641790604166832609527789574080680777857006505183648777672706118568766895510799450111, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 119, + "cut": 8, + "keep": 36695977855841144185773134324833362856810631071642571713012138741116117603818569289034423492463048690171903, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + }, + { + "p": 120, + "cut": 8, + "keep": 293567822846729153486185074598667015638222683593340278771254240685227534484937304872618881368900238700118015, + "native_mask": 28633115307, + "native_stages": 19, + "kappa": 0.002993139495809806, + "rank_mass_gap": 800, + "score_at_test_kappa": -2.103111387739773 + } + ], + "best": { + "p": 17, + "cut": 8, + "keep": 280378328416255, + "native_mask": 28633115307, + "native_stages": 19, + "direct_stages": [ + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32 + ], + "target": { + "4": 494, + "5": 38, + "7": 551, + "8": 798, + "9": 5871, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "paid": { + "1": 44599, + "2": 9785, + "3": 8455, + "4": 1938, + "5": 760, + "8": 152, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "kappa": 0.0030010541831747175, + "rank_mass_gap": 800, + "score_at_test_kappa": -0.00154044392547803 + }, + "seconds": 31.608927075000338 +} diff --git a/research/kappa-hybrid-controller/search/direct_stage_dp.py b/research/kappa-hybrid-controller/search/direct_stage_dp.py new file mode 100644 index 0000000000..0717a3a577 --- /dev/null +++ b/research/kappa-hybrid-controller/search/direct_stage_dp.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python3 +"""Dynamic optimization of direct/native stages in minimal-cut path controllers. + +This discovery program uses floating moment scores. Its selected histograms +must separately receive exact interval, native, and phase certificates. +""" +from collections import Counter +from pathlib import Path +import argparse +import json +import math +import time + +H={4:26,5:2,7:29,8:42,9:309} +L={1:2253,2:515,3:445,4:102,5:40,8:8} +HERE=Path(__file__).resolve().parent + + +def branch(length,powers): + if length==0: + return {0:(0.,0),1:(0.,1)} + state={i:(0.,(1<new[n][0]: + new[n]=(val,mm) + state=new + return state + + +def keep_mask(p,cut): + return (sum(1<<(2*j+1) for j in range(p-1))+ + sum(1<<(2*j) for j in range(cut))+ + sum(1<<(2*(p-1)+j) for j in range(cut,p-1))) + + +def profile(p,cut,mask): + n=mask.bit_count();stages=2*p+1 + paid=Counter({k:v*n for k,v in L.items()}) + productive=Counter({k:v*n for k,v in H.items()}) + paid[1]+=112*(stages-n) + productive[1+8*n]+=224 + for length,reverse in ((cut,False),(p-1-cut,True)): + for j in range(1,length+1): + support=list(range(2*j+1)) + if reverse: + support=[2*p-s for s in support] + r=sum((mask>>s)&1 for s in support) + productive[1+8*r]+=224 + r0=sum((mask>>s)&1 for s in support[:-1]) + if r0: + paid[8*r0]+=224 + for j in range(1,p): + if (mask>>(2*j))&1: + paid[8]+=224 + paid={k:v for k,v in sorted(paid.items()) if v} + productive={k:v for k,v in sorted(productive.items()) if v} + def margin(kappa): + tau=1-kappa + return sum(v*k**tau for k,v in productive.items())-sum(v*k**tau for k,v in paid.items()) + if margin(0)<=0: + root=0 + else: + lo,hi=0.,.03 + for _ in range(48): + mid=(lo+hi)/2 + if margin(mid)>0: + lo=mid + else: + hi=mid + root=lo + return dict(p=p,cut=cut,keep=keep_mask(p,cut),native_mask=mask,native_stages=n, + direct_stages=[s for s in range(stages) if not(mask>>s&1)], + target=productive,paid=paid,kappa=root,rank_mass_gap=margin(0)) + + +def optimize(max_p,kappa,all_cuts=True): + powers=[0.]+[r**(1-kappa) for r in range(1,8*(2*max_p+1)+2)] + delta=112+sum(v*powers[k] for k,v in H.items())-sum(v*powers[k] for k,v in L.items()) + branches=[branch(b,powers) for b in range(max_p)] + answers=[] + for p in range(1,max_p+1): + best=(-float('inf'),None,None) + cuts=range(p) if all_cuts else ((p-1)//2,) + for cut in cuts: + right=p-1-cut + for nl,(sl,ml) in branches[cut].items(): + for nr,(sr,mr) in branches[right].items(): + for middle in (0,1): + n=nl+nr+middle + score=sl+sr+n*delta-112*(2*p+1)+224*powers[1+8*n] + if score>best[0]: + right_mask=sum(1<<(2*p-s) for s in range(2*right+1) if mr>>s&1) + native=ml|right_mask|(middle<<(2*cut+1)) + best=(score,cut,native) + row=profile(p,best[1],best[2]);row['score_at_test_kappa']=best[0] + answers.append(row) + return answers + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--max-p',type=int,default=40) + parser.add_argument('--kappa',type=float,default=.0028) + parser.add_argument('--balanced-only',action='store_true') + parser.add_argument('--summary',action='store_true',help='Keep compact per-p profiles and the complete winner') + parser.add_argument('--out',type=Path,default=HERE/'DIRECT-STAGE-DP.json') + args=parser.parse_args();started=time.monotonic() + rows=optimize(args.max_p,args.kappa,not args.balanced_only) + best=max(rows,key=lambda x:x['kappa']) + summary_keys=('p','cut','keep','native_mask','native_stages','kappa','rank_mass_gap','score_at_test_kappa') + saved_rows=[{k:row[k] for k in summary_keys} for row in rows] if args.summary else rows + result=dict(test_kappa=args.kappa,all_cuts=not args.balanced_only,profiles=saved_rows,best=best, + seconds=time.monotonic()-started) + args.out.write_text(json.dumps(result,indent=2)+'\n') + for row in rows: + print(json.dumps({k:row[k] for k in ('p','cut','kappa','native_stages','direct_stages','score_at_test_kappa')}),flush=True) + print('BEST',json.dumps(best),flush=True) + + +if __name__=='__main__': + main() diff --git a/research/kappa-hybrid-controller/strictification.py b/research/kappa-hybrid-controller/strictification.py new file mode 100644 index 0000000000..7adb266b11 --- /dev/null +++ b/research/kappa-hybrid-controller/strictification.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python3 +"""Exact tensor-and-target-completion certificate for the p17 native/direct word. + +Apache-2.0. Substantial OpenAI/Codex assistance. Native controller and interval +engine: zxv's PR4359. Integer compiler: Jacob Alan Sussman's Theorem 1G. +""" +from fractions import Fraction as Q +from hashlib import sha256 +import argparse +import importlib.util +import json +from pathlib import Path +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +DEFAULT_SOURCE = HERE.parent/'pr4359-p7-padding/source' +_parameter_spec = importlib.util.spec_from_file_location('hybrid_parameters_strict', HERE/'parameters.py') +PARAMETERS = importlib.util.module_from_spec(_parameter_spec) +_parameter_spec.loader.exec_module(PARAMETERS) +for _name in ('EXPONENT', 'CUTOFF', 'TARGET_FLOOR', 'TESTED_SAVING', + 'ALPHA_UPPER', 'GAMMA_UPPER', 'DELTA_UPPER', 'BLOCK', 'TARGETS', 'PAID', + 'COMPLETION_BLOCK', 'THETA_DENOMINATOR', 'CUTOFF_LOG2_UPPER', 'AMBIENT_LOG2_UPPER'): + globals()[_name] = getattr(PARAMETERS, _name) + + +def need(ok, message): + if not ok: + raise AssertionError(message) + + +def module(name, path): + spec = importlib.util.spec_from_file_location(name,path) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +def run(source_root, native_result=None, retimed_source_root=None): + if native_result is None: + native_result = module('hybrid_native',HERE/'native_inventory.py').run(source_root,retimed_source_root=retimed_source_root) + targets = {int(k):v for k,v in native_result['targets'].items()} + paid = {int(k):v for k,v in native_result['paid'].items()} + need(targets == TARGETS and paid == PAID,'Exact reconstructed p17 native/direct invoice') + need(native_result['p'] == PARAMETERS.PAIRS and native_result['keep'] == PARAMETERS.KEEP + and native_result['native_mask'] == PARAMETERS.NATIVE_MASK, + 'Actual reconstructed controller selection') + need(native_result['dimension'] == PARAMETERS.AMBIENT,'Actual native ambient rank') + productive_count = sum(targets.values()) + paid_rank = sum(k*v for k,v in paid.items()) + target_rank = sum(k*v for k,v in targets.items()) + need(productive_count == PARAMETERS.PRODUCTIVE_FIELDS,'Every independent productive field') + need((target_rank,paid_rank) == (PARAMETERS.TARGET_MASS,PARAMETERS.PAID_MASS),'Exact rank-one moments') + need(target_rank-paid_rank == native_result['rank_margin'] > 0, + 'Positive raw rank-one surplus, preserved by completion and splitting') + engine_path = source_root/'research/kappa-rebuild/architecture/mixed_target_probe.py' + E = module('hybrid_source_intervals',engine_path) + target_lo,target_hi = E.moment(targets,TESTED_SAVING) + paid_lo,paid_hi = E.moment(paid,TESTED_SAVING) + alpha_lo,alpha_hi = paid_lo/target_hi,paid_hi/target_lo + log_lo,log_hi = E.log_interval(CUTOFF) + power_lo = E.exp_interval(TESTED_SAVING*log_lo)[0] + power_hi = E.exp_interval(TESTED_SAVING*log_hi)[1] + gamma_lo = paid_rank/(power_hi*target_hi) + gamma_hi = paid_rank/(power_lo*target_lo) + delta_lo = productive_count*TARGET_FLOOR/(power_hi*target_hi) + delta_hi = productive_count*TARGET_FLOOR/(power_lo*target_lo) + need(0 < alpha_hi < ALPHA_UPPER < 1,'Certified alpha has the stated exact positive gap') + need(0 < gamma_hi < GAMMA_UPPER < 1,'Certified original-paid tail below its stated rational bound') + need(0 < delta_hi < DELTA_UPPER < 1,'Certified completion tail below its stated rational bound') + need(GAMMA_UPPER**BLOCK < Q(1,2),'Exact finite rational block decay') + need(EXPONENT % BLOCK == 0,'Complete decay blocks') + blocks = EXPONENT//BLOCK + need(DELTA_UPPER**COMPLETION_BLOCK < Q(1,2),'Exact finite completion-tail decay') + need(EXPONENT//COMPLETION_BLOCK >= blocks,'Completion tail is below the conservative block bound') + bound = 1/(1+EXPONENT*(1-ALPHA_UPPER))+Q(4,2**blocks) + need(bound < 1,'Complete normalized paid moment, including all target completion') + need(1 < CUTOFF < TARGET_FLOOR < max(targets) and 0 < TESTED_SAVING < 1, + 'Completion fits the actual ambient space and restores strict rank separation') + need(CUTOFF**THETA_DENOMINATOR < TARGET_FLOOR**(THETA_DENOMINATOR-1), + 'Strict logarithmic compiler rank separation') + need(CUTOFF < 2**CUTOFF_LOG2_UPPER and PARAMETERS.AMBIENT < 2**AMBIENT_LOG2_UPPER,'Exact compiler power bounds') + need(1/(1+BLOCK*(1-ALPHA_UPPER))+Q(4,2) > 1, + 'One decay block is insufficient under these bounds') + need(1/(1+EXPONENT*(1-ALPHA_UPPER))+2 > 1, + 'An undamped completion tail is rejected') + # Without completion, every permitted cutoff is below the raw minimum target. + # Its rank-one tail is worse than this already failing boundary value. + _,lnmin_hi = E.log_interval(min(targets)) + old_tail_lo = paid_rank/(E.exp_interval(TESTED_SAVING*lnmin_hi)[1]*target_hi) + need(old_tail_lo > 1,'Unpadded rank-one tail condition fails even at the raw target minimum') + return { + 'schema':'hybrid-p17-paid-completion-certificate/1', + 'status':'PASS_EXACT_HYBRID_P17_TARGET_COMPLETION_STRICTIFICATION', + 'exponent':EXPONENT,'cutoff_base':CUTOFF,'target_floor_base':TARGET_FLOOR, + 'cutoff_encoding':str(CUTOFF)+'^'+str(EXPONENT),'target_floor_encoding':str(TARGET_FLOOR)+'^'+str(EXPONENT), + 'tested_saving':str(TESTED_SAVING),'targets':targets,'paid':paid, + 'productive_fields':productive_count, + 'target_rank_one_moment':target_rank,'paid_rank_one_moment':paid_rank, + 'rank_one_surplus_encoding':str(target_rank)+'^'+str(EXPONENT)+'-'+str(paid_rank)+'^'+str(EXPONENT), + 'alpha_upper':str(ALPHA_UPPER),'alpha_interval':E.show((alpha_lo,alpha_hi)), + 'gamma_upper':str(GAMMA_UPPER),'gamma_interval':E.show((gamma_lo,gamma_hi)), + 'delta_upper':str(DELTA_UPPER),'delta_interval':E.show((delta_lo,delta_hi)), + 'decay_block_length':BLOCK,'decay_block_count':blocks, + 'completion_decay_block_length':COMPLETION_BLOCK, + 'normalized_moment_upper_rational':str(bound), + 'strictification_gap_rational':str(1-bound), + 'strictification_gap':E.show((1-bound,1-bound)), + 'strict_moment_verified':True,'new_min_target_encoding':str(TARGET_FLOOR)+'^'+str(EXPONENT), + 'new_max_target_encoding':str(max(targets))+'^'+str(EXPONENT), + 'ambient_rank_encoding':str(PARAMETERS.AMBIENT)+'^'+str(EXPONENT), + 'theta_upper':str(Q(THETA_DENOMINATOR-1,THETA_DENOMINATOR)), + 'native_inventory':native_result,'parameters_sha256':sha256((HERE/'parameters.py').read_bytes()).hexdigest(), + 'source_sha256':{'research/kappa-rebuild/architecture/mixed_target_probe.py': + sha256(engine_path.read_bytes()).hexdigest()}, + 'controls':{'unpadded_rank_one_tail_rejected':True, + 'one_decay_block_rejected':True,'undamped_completion_rejected':True}, + 'materialized_tensor_or_completed_word':False, + 'scope':'Exact moment bounds for the documented chronological native product, paid target completion and disjoint splitting. Native all-column, precision, storage, analytic and fixed-tape premises remain separate; no full multiplication theorem is formally verified.'} + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root',type=Path,default=DEFAULT_SOURCE) + parser.add_argument('--native-result',type=Path, + help='Use an already audited native receipt instead of rerunning its producer.') + parser.add_argument('--out',type=Path) + parser.add_argument('--retimed-source-root',type=Path) + args = parser.parse_args() + native = json.loads(args.native_result.read_text()) if args.native_result else None + result = run(args.source_root,native,args.retimed_source_root) + if args.out: + args.out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({key:result[key] for key in + ('status','exponent','cutoff_encoding','target_floor_encoding', + 'tested_saving','strictification_gap')},sort_keys=True)) diff --git a/research/kappa-hybrid-controller/verify.py b/research/kappa-hybrid-controller/verify.py new file mode 100644 index 0000000000..bb3d1b52e7 --- /dev/null +++ b/research/kappa-hybrid-controller/verify.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +"""Regenerate the complete conditional native/direct p17 and p6 BIT certificates.""" +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +DEFAULT_SOURCE = HERE.parent/'pr4359-p7-padding/source' +DEFAULT_BIT_SOURCE = HERE.parents[1] + + +def need(ok, message): + if not ok: + raise AssertionError(message) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def run(source_root=DEFAULT_SOURCE, bit_source_root=DEFAULT_BIT_SOURCE, retimed_source_root=None): + source_root = Path(source_root).resolve() + strictifier = load(HERE/'strictification.py', 'hybrid_p17_strict_verify') + endpoint_module = load(HERE/'endpoint.py', 'hybrid_p17_endpoint_verify') + strict = strictifier.run(source_root,retimed_source_root=retimed_source_root) + endpoint = endpoint_module.run(source_root, strict, bit_source_root) + independent_path = source_root.parent/'dependencies/compiler-refill/template_bound.py' + need(sha256(independent_path.read_bytes()).hexdigest() == + '25d409726cd867f7584fbd52e1b846335debdab42d24377e00c5653aaf12c0fb', + 'Exact independently implemented interval engine') + independent = load(independent_path, 'hybrid_p17_independent_interval') + targets, paid = strict['targets'], strict['paid'] + saving = Q(strict['tested_saving']) + tlo, thi = independent.moment_margin(targets, {}, saving) + plo, phi = independent.moment_margin(paid, {}, saving) + need(phi/tlo < Q(strict['alpha_upper']), 'Independent strict raw mixed moment') + loglo, loghi = independent.log_interval(strict['cutoff_base']) + power_lo = independent.exp_interval(saving*loglo)[0] + paid_mass = sum(k*v for k,v in paid.items()) + need(paid_mass/(power_lo*tlo) < Q(strict['gamma_upper']), + 'Independent full original paid-tail charge') + need(sum(targets.values())*strict['target_floor_base']/(power_lo*tlo) < Q(strict['delta_upper']), + 'Independent paid completion and split-tail charge') + n, block = strict['exponent'], strict['decay_block_length'] + need(n % block == 0 and Q(strict['gamma_upper'])**block < Q(1,2), + 'Exact original paid-tail decay blocks') + need(Q(strict['delta_upper'])**block < Q(1,2), 'Exact completion-tail decay blocks') + upper = 1/(1+n*(1-Q(strict['alpha_upper'])))+Q(4,2**(n//block)) + need(upper == Q(strict['normalized_moment_upper_rational']) < 1, + 'Independent complete padded and split moment') + bit = endpoint['ordinary_BIT_certificate'] + need(bit['native_source']['status'] == 'PASS_P6_EXACT_NATIVE_PORTS_ARBITRARY_COLUMNS_AND_WHOLE_IDLES', + 'Native BIT arbitrary-input certificate included') + need(Q(bit['admitted_BIT_saving']) == Q(endpoint['outer']['parameters']['bit_saving']), + 'Outer BIT premise is exactly the newly certified ordinary saving') + source_files = {str(path.relative_to(HERE)):sha256(path.read_bytes()).hexdigest() + for path in (HERE/'parameters.py', HERE/'native_inventory.py', HERE/'native_geometry.py', + HERE/'local_supplier.py', HERE/'controller/make_direct_case.py', + HERE/'strictification.py', HERE/'endpoint.py', HERE/'verify.py', + HERE/'bit/bit_tensor_extension.py', HERE/'bit/bit_p6_tensor_extension.py')} + return dict(schema='hybrid-p17-complete-conditional-certificate/1', + status='PASS_SOURCE_BOUND_HYBRID_P17_AND_ORDINARY_BIT_P6', + strictification=strict, endpoint=endpoint, + independent_interval_crosscheck=True, + implementation_sha256=source_files, + scope='Fresh finite retimed native replay, all helper phases, full native/direct p17 geometry, two independent interval engines, explicit uniform ranks, native BIT and all outer inequalities. All-column tensor, route-cost, precision, stock, analytic, fixed-tape and recovery assumptions remain the inherited written premises.') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, default=DEFAULT_SOURCE) + parser.add_argument('--bit-source-root', type=Path, default=DEFAULT_BIT_SOURCE) + parser.add_argument('--write-result', action='store_true') + parser.add_argument('--retimed-source-root', type=Path) + args = parser.parse_args() + result = json.loads(json.dumps(run(args.source_root, args.bit_source_root,args.retimed_source_root))) + path = HERE/'RESULT.json' + if args.write_result: + path.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + certificates = HERE/'certificates' + certificates.mkdir(exist_ok=True) + for name, value in (('NATIVE',result['strictification']['native_inventory']), + ('STRICTIFICATION',result['strictification']), + ('ENDPOINT',result['endpoint'])): + (certificates/(name+'.json')).write_text(json.dumps(value, indent=2, sort_keys=True)+'\n') + else: + need(result == json.loads(path.read_text()), 'Exact complete saved receipt reproduction') + print(json.dumps(dict(status=result['status'], kappa=result['endpoint']['kappa'], + tested_saving=result['strictification']['tested_saving'], + ordinary_BIT=result['endpoint']['ordinary_BIT_certificate']['admitted_BIT_saving'], + tensor_power=result['strictification']['exponent'], + uniform_rank_exponent=result['endpoint']['compiler']['H1']), sort_keys=True)) diff --git a/research/query-thinned-controllers/BIT-CONTROLLER.json b/research/query-thinned-controllers/BIT-CONTROLLER.json new file mode 100644 index 0000000000..89c400d597 --- /dev/null +++ b/research/query-thinned-controllers/BIT-CONTROLLER.json @@ -0,0 +1,2175 @@ +{ + "ambient_rank": 127, + "boundaries": { + "boundary_unit_ADDs_per_port": 160, + "coefficient_projectors": { + "12884901889": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1073741824, + 2147483648 + ], + "1367": [ + 1280, + 0, + 1280, + 0, + 1280, + 0, + 1280, + 0, + 1280, + 682, + 0, + 682, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "13958643713": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 268435456, + 536870912, + 0, + 0 + ], + "14227079169": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 67108864, + 134217728, + 0, + 0, + 0, + 0 + ], + "14294188033": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16777216, + 33554432, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14310965249": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4194304, + 8388608, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14315159553": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1048576, + 2097152, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14316208129": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 262144, + 524288, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14316470273": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 65536, + 131072, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "14316557655": [ + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 0, + 16384, + 43690, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "21847": [ + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 0, + 20480, + 10922, + 0, + 10922, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "23": [ + 20, + 0, + 20, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "343": [ + 320, + 0, + 320, + 0, + 320, + 0, + 320, + 170, + 0, + 170, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "5463": [ + 5120, + 0, + 5120, + 0, + 5120, + 0, + 5120, + 0, + 5120, + 0, + 5120, + 2730, + 0, + 2730, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "7": [ + 5, + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "87": [ + 80, + 0, + 80, + 0, + 80, + 42, + 0, + 42, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "diagonal_monomials": [ + 7, + 7, + 23, + 23, + 87, + 87, + 343, + 343, + 1367, + 1367, + 5463, + 5463, + 21847, + 21847, + 12884901889, + 12884901889, + 13958643713, + 13958643713, + 14227079169, + 14227079169, + 14294188033, + 14294188033, + 14310965249, + 14310965249, + 14315159553, + 14315159553, + 14316208129, + 14316208129, + 14316470273, + 14316470273, + 14316557655, + 14316557655 + ], + "full_coefficient_endpoint_sha256": "0164c424ad261c955e105330fcec5942d9a863d1b6030f70e786f5cdafb2acef", + "left_program": [ + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 24 + ], + [ + "SWAP", + 19, + 27 + ], + [ + "SWAP", + 18, + 26 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 28 + ], + [ + "SWAP", + 15, + 30 + ], + [ + "ADD", + 12, + 14 + ], + [ + "ADD", + 10, + 14 + ], + [ + "ADD", + 8, + 14 + ], + [ + "ADD", + 6, + 14 + ], + [ + "ADD", + 4, + 14 + ], + [ + "ADD", + 2, + 14 + ], + [ + "ADD", + 0, + 14 + ], + [ + "SWAP", + 14, + 31 + ], + [ + "ADD", + 30, + 13 + ], + [ + "ADD", + 10, + 12 + ], + [ + "ADD", + 8, + 12 + ], + [ + "ADD", + 6, + 12 + ], + [ + "ADD", + 4, + 12 + ], + [ + "ADD", + 2, + 12 + ], + [ + "ADD", + 0, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 30, + 11 + ], + [ + "ADD", + 12, + 11 + ], + [ + "ADD", + 8, + 10 + ], + [ + "ADD", + 6, + 10 + ], + [ + "ADD", + 4, + 10 + ], + [ + "ADD", + 2, + 10 + ], + [ + "ADD", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 30, + 9 + ], + [ + "ADD", + 12, + 9 + ], + [ + "ADD", + 10, + 9 + ], + [ + "ADD", + 6, + 8 + ], + [ + "ADD", + 4, + 8 + ], + [ + "ADD", + 2, + 8 + ], + [ + "ADD", + 0, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 30, + 7 + ], + [ + "ADD", + 12, + 7 + ], + [ + "ADD", + 10, + 7 + ], + [ + "ADD", + 8, + 7 + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 2, + 6 + ], + [ + "ADD", + 0, + 6 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 30, + 5 + ], + [ + "ADD", + 12, + 5 + ], + [ + "ADD", + 10, + 5 + ], + [ + "ADD", + 8, + 5 + ], + [ + "ADD", + 6, + 5 + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 0, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 30, + 3 + ], + [ + "ADD", + 12, + 3 + ], + [ + "ADD", + 10, + 3 + ], + [ + "ADD", + 8, + 3 + ], + [ + "ADD", + 6, + 3 + ], + [ + "ADD", + 4, + 3 + ], + [ + "ADD", + 0, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 30, + 1 + ], + [ + "ADD", + 12, + 1 + ], + [ + "ADD", + 10, + 1 + ], + [ + "ADD", + 8, + 1 + ], + [ + "ADD", + 6, + 1 + ], + [ + "ADD", + 4, + 1 + ], + [ + "ADD", + 2, + 1 + ] + ], + "left_rows": [ + 5, + 2, + 10, + 20, + 42, + 80, + 170, + 320, + 682, + 1280, + 2730, + 5120, + 10922, + 20480, + 1073741824, + 2147483648, + 268435456, + 536870912, + 67108864, + 134217728, + 16777216, + 33554432, + 4194304, + 8388608, + 1048576, + 2097152, + 262144, + 524288, + 65536, + 131072, + 43690, + 16384 + ], + "right_program": [ + [ + "ADD", + 13, + 31 + ], + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 24 + ], + [ + "SWAP", + 19, + 27 + ], + [ + "SWAP", + 18, + 26 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 28 + ], + [ + "SWAP", + 15, + 31 + ], + [ + "SWAP", + 14, + 30 + ], + [ + "ADD", + 11, + 13 + ], + [ + "ADD", + 15, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 9, + 11 + ], + [ + "ADD", + 13, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 7, + 9 + ], + [ + "ADD", + 11, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 5, + 7 + ], + [ + "ADD", + 9, + 6 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 7, + 4 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 0, + 3 + ], + [ + "ADD", + 5, + 2 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 1 + ] + ], + "right_rows": [ + 2147494569, + 2, + 2147494568, + 6, + 2147494560, + 20, + 2147494528, + 80, + 2147494400, + 320, + 2147493888, + 1280, + 2147491840, + 5120, + 2147483648, + 1073745920, + 268435456, + 536870912, + 67108864, + 134217728, + 16777216, + 33554432, + 4194304, + 8388608, + 1048576, + 2097152, + 262144, + 524288, + 65536, + 131072, + 16384, + 32768 + ] + }, + "diagonal": [ + 7, + 7, + 23, + 23, + 87, + 87, + 343, + 343, + 1367, + 1367, + 5463, + 5463, + 21847, + 21847, + 12884901889, + 12884901889, + 13958643713, + 13958643713, + 14227079169, + 14227079169, + 14294188033, + 14294188033, + 14310965249, + 14310965249, + 14315159553, + 14315159553, + 14316208129, + 14316208129, + 14316470273, + 14316470273, + 14316557655, + 14316557655 + ], + "invoice": { + "main": { + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "127": 222 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 25479, + "2": 24156, + "3": 1422, + "4": 792, + "5": 1836, + "6": 198, + "7": 342, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + }, + "paid_calls": 57555, + "productive_fields": 11454, + "rank_surplus": 753, + "raw_scalar_record_bound": 1000000000, + "targets": { + "8": 7902, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "127": 222 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1665, + "whole_idle": { + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + } + }, + "keep_mask": 35047648968703, + "kind": "bit", + "pairs": 16, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2 + ], + [ + "ADD", + 3, + 1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2 + ], + [ + "ADD", + 3, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 5, + 3 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4 + ], + [ + "ADD", + 5, + 3 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 7, + 5 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6 + ], + [ + "ADD", + 7, + 5 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8 + ], + [ + "ADD", + 9, + 7 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8 + ], + [ + "ADD", + 9, + 7 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10 + ], + [ + "ADD", + 11, + 9 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10 + ], + [ + "ADD", + 11, + 9 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12 + ], + [ + "ADD", + 13, + 11 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12 + ], + [ + "ADD", + 13, + 11 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14 + ], + [ + "ADD", + 15, + 13 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14 + ], + [ + "ADD", + 15, + 13 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "ADD", + 14, + 16 + ], + [ + "ADD", + 17, + 15 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16 + ], + [ + "ADD", + 17, + 15 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18 + ], + [ + "ADD", + 19, + 17 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18 + ], + [ + "ADD", + 19, + 17 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20 + ], + [ + "ADD", + 21, + 19 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20 + ], + [ + "ADD", + 21, + 19 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22 + ], + [ + "ADD", + 23, + 21 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22 + ], + [ + "ADD", + 23, + 21 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24 + ], + [ + "ADD", + 25, + 23 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24 + ], + [ + "ADD", + 25, + 23 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26 + ], + [ + "ADD", + 27, + 25 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26 + ], + [ + "ADD", + 27, + 25 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28 + ], + [ + "ADD", + 29, + 27 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28 + ], + [ + "ADD", + 29, + 27 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30 + ], + [ + "ADD", + 31, + 29 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30 + ], + [ + "ADD", + 31, + 29 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "LOCAL", + 32, + 15, + false + ], + [ + "IDLE", + 7, + [ + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 32 + ] + ], + [ + "ADD", + 30, + 28 + ], + [ + "ADD", + 29, + 31 + ], + [ + "ADD", + 28, + 26 + ], + [ + "ADD", + 27, + 29 + ], + [ + "ADD", + 26, + 24 + ], + [ + "ADD", + 25, + 27 + ], + [ + "ADD", + 24, + 22 + ], + [ + "ADD", + 23, + 25 + ], + [ + "ADD", + 22, + 20 + ], + [ + "ADD", + 21, + 23 + ], + [ + "ADD", + 20, + 18 + ], + [ + "ADD", + 19, + 21 + ], + [ + "ADD", + 18, + 16 + ], + [ + "ADD", + 17, + 19 + ], + [ + "ADD", + 16, + 14 + ], + [ + "ADD", + 15, + 17 + ], + [ + "ADD", + 14, + 12 + ], + [ + "ADD", + 13, + 15 + ], + [ + "ADD", + 12, + 10 + ], + [ + "ADD", + 11, + 13 + ], + [ + "ADD", + 10, + 8 + ], + [ + "ADD", + 9, + 11 + ], + [ + "ADD", + 8, + 6 + ], + [ + "ADD", + 7, + 9 + ], + [ + "ADD", + 6, + 4 + ], + [ + "ADD", + 5, + 7 + ], + [ + "ADD", + 4, + 2 + ], + [ + "ADD", + 3, + 5 + ], + [ + "ADD", + 2, + 0 + ], + [ + "ADD", + 1, + 3 + ], + [ + "SWAP", + 0, + 1 + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 4, + 5 + ], + [ + "SWAP", + 6, + 7 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "SWAP", + 30, + 31 + ] + ], + "prefix_pairs": 7 +} diff --git a/research/query-thinned-controllers/COMPLEX-CONTROLLER.json b/research/query-thinned-controllers/COMPLEX-CONTROLLER.json new file mode 100644 index 0000000000..39318f6ad9 --- /dev/null +++ b/research/query-thinned-controllers/COMPLEX-CONTROLLER.json @@ -0,0 +1,5801 @@ +{ + "ambient_rank": 153, + "boundaries": { + "left": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 29, + 31 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "SWAP", + 27, + 30 + ], + [ + "SWAP", + 25, + 27 + ], + [ + "SWAP", + 24, + 31 + ], + [ + "SWAP", + 23, + 27 + ], + [ + "SWAP", + 22, + 27 + ], + [ + "SWAP", + 21, + 23 + ], + [ + "SWAP", + 20, + 30 + ], + [ + "SWAP", + 19, + 24 + ], + [ + "SWAP", + 18, + 28 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 14, + 16, + "1" + ], + [ + "ADD", + 12, + 16, + "-1" + ], + [ + "ADD", + 10, + 16, + "1" + ], + [ + "ADD", + 8, + 16, + "-1" + ], + [ + "ADD", + 6, + 16, + "1" + ], + [ + "ADD", + 4, + 16, + "-1" + ], + [ + "ADD", + 2, + 16, + "1" + ], + [ + "ADD", + 0, + 16, + "-1" + ], + [ + "ADD", + 33, + 15, + "-1" + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 33, + 13, + "1" + ], + [ + "ADD", + 32, + 13, + "1" + ], + [ + "SWAP", + 13, + 31 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 33, + 11, + "-1" + ], + [ + "ADD", + 32, + 11, + "-1" + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 30 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 33, + 9, + "1" + ], + [ + "ADD", + 32, + 9, + "1" + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "SWAP", + 9, + 29 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 33, + 7, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 28 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 33, + 5, + "1" + ], + [ + "ADD", + 32, + 5, + "1" + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "SWAP", + 5, + 27 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 33, + 3, + "-1" + ], + [ + "ADD", + 32, + 3, + "-1" + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 26 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 33, + 1, + "1" + ], + [ + "ADD", + 32, + 1, + "1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right_program": [ + [ + "ADD", + 33, + 32, + "-1" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 32, + 31, + "1" + ], + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "SWAP", + 29, + 30 + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 31, + 27, + "1" + ], + [ + "ADD", + 26, + 27, + "-1" + ], + [ + "ADD", + 25, + 27, + "-1" + ], + [ + "SWAP", + 27, + 30 + ], + [ + "ADD", + 30, + 26, + "1" + ], + [ + "ADD", + 25, + 26, + "-1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 30, + 25, + "1" + ], + [ + "SWAP", + 25, + 26 + ], + [ + "SWAP", + 24, + 29 + ], + [ + "SWAP", + 23, + 25 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "SWAP", + 21, + 25 + ], + [ + "SWAP", + 20, + 27 + ], + [ + "SWAP", + 19, + 29 + ], + [ + "SWAP", + 18, + 31 + ], + [ + "SWAP", + 17, + 33 + ], + [ + "ADD", + 15, + 16, + "-1" + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 32 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 32 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 24 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 32 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 20 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 24 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "SWAP", + 8, + 32 + ], + [ + "SWAP", + 7, + 18 + ], + [ + "SWAP", + 6, + 20 + ], + [ + "SWAP", + 5, + 22 + ], + [ + "SWAP", + 4, + 24 + ], + [ + "SWAP", + 3, + 26 + ], + [ + "SWAP", + 2, + 28 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 0, + 32 + ] + ] + }, + "diagonal": [ + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ] + ], + "invoice": { + "main": { + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 49045, + "2": 13547, + "3": 4256, + "4": 1938, + "5": 380, + "8": 152, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "paid_calls": 72902, + "productive_fields": 11560, + "rank_surplus": 800, + "raw_scalar_record_bound": 1000000000, + "targets": { + "5": 532, + "6": 342, + "7": 1064, + "8": 1767, + "9": 4047, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "thick_calls": 19, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "thin_queries": 1792, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + } + }, + "keep_mask": 280378328416255, + "kind": "complex", + "pairs": 17, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "LOCAL", + 1, + 0, + true + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2, + 1 + ], + [ + "ADD", + 3, + 1, + -1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2, + -1 + ], + [ + "ADD", + 3, + 1, + 1 + ], + [ + "LOCAL", + 3, + 1, + true + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4, + 1 + ], + [ + "ADD", + 5, + 3, + -1 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4, + -1 + ], + [ + "ADD", + 5, + 3, + 1 + ], + [ + "LOCAL", + 5, + 2, + true + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6, + 1 + ], + [ + "ADD", + 7, + 5, + -1 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6, + -1 + ], + [ + "ADD", + 7, + 5, + 1 + ], + [ + "LOCAL", + 7, + 3, + true + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8, + 1 + ], + [ + "ADD", + 9, + 7, + -1 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8, + -1 + ], + [ + "ADD", + 9, + 7, + 1 + ], + [ + "LOCAL", + 9, + 4, + true + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10, + 1 + ], + [ + "ADD", + 11, + 9, + -1 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10, + -1 + ], + [ + "ADD", + 11, + 9, + 1 + ], + [ + "LOCAL", + 11, + 5, + true + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12, + 1 + ], + [ + "ADD", + 13, + 11, + -1 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12, + -1 + ], + [ + "ADD", + 13, + 11, + 1 + ], + [ + "LOCAL", + 13, + 6, + true + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14, + 1 + ], + [ + "ADD", + 15, + 13, + -1 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14, + -1 + ], + [ + "ADD", + 15, + 13, + 1 + ], + [ + "LOCAL", + 15, + 7, + true + ], + [ + "IDLE", + 8, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15 + ] + ], + [ + "ADD", + 14, + 16, + 1 + ], + [ + "ADD", + 17, + 15, + -1 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16, + -1 + ], + [ + "ADD", + 17, + 15, + 1 + ], + [ + "LOCAL", + 17, + 8, + true + ], + [ + "ADD", + 16, + 18, + 1 + ], + [ + "ADD", + 19, + 17, + -1 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18, + -1 + ], + [ + "ADD", + 19, + 17, + 1 + ], + [ + "LOCAL", + 19, + 9, + true + ], + [ + "ADD", + 18, + 20, + 1 + ], + [ + "ADD", + 21, + 19, + -1 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20, + -1 + ], + [ + "ADD", + 21, + 19, + 1 + ], + [ + "LOCAL", + 21, + 10, + true + ], + [ + "ADD", + 20, + 22, + 1 + ], + [ + "ADD", + 23, + 21, + -1 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22, + -1 + ], + [ + "ADD", + 23, + 21, + 1 + ], + [ + "LOCAL", + 23, + 11, + true + ], + [ + "ADD", + 22, + 24, + 1 + ], + [ + "ADD", + 25, + 23, + -1 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24, + -1 + ], + [ + "ADD", + 25, + 23, + 1 + ], + [ + "LOCAL", + 25, + 12, + true + ], + [ + "ADD", + 24, + 26, + 1 + ], + [ + "ADD", + 27, + 25, + -1 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26, + -1 + ], + [ + "ADD", + 27, + 25, + 1 + ], + [ + "LOCAL", + 27, + 13, + true + ], + [ + "ADD", + 26, + 28, + 1 + ], + [ + "ADD", + 29, + 27, + -1 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28, + -1 + ], + [ + "ADD", + 29, + 27, + 1 + ], + [ + "LOCAL", + 29, + 14, + true + ], + [ + "ADD", + 28, + 30, + 1 + ], + [ + "ADD", + 31, + 29, + -1 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30, + -1 + ], + [ + "ADD", + 31, + 29, + 1 + ], + [ + "LOCAL", + 31, + 15, + true + ], + [ + "ADD", + 30, + 32, + 1 + ], + [ + "ADD", + 33, + 31, + -1 + ], + [ + "QUERY_SHEAR", + 32, + 15, + false + ], + [ + "ADD", + 30, + 32, + -1 + ], + [ + "ADD", + 33, + 31, + 1 + ], + [ + "LOCAL", + 33, + 16, + true + ], + [ + "LOCAL", + 34, + 16, + false + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 33, + 34 + ] + ], + [ + "IDLE", + 15, + [ + 33, + 34 + ] + ], + [ + "ADD", + 32, + 30, + 1 + ], + [ + "ADD", + 31, + 33, + -1 + ], + [ + "ADD", + 30, + 28, + 1 + ], + [ + "ADD", + 29, + 31, + -1 + ], + [ + "ADD", + 28, + 26, + 1 + ], + [ + "ADD", + 27, + 29, + -1 + ], + [ + "ADD", + 26, + 24, + 1 + ], + [ + "ADD", + 25, + 27, + -1 + ], + [ + "ADD", + 24, + 22, + 1 + ], + [ + "ADD", + 23, + 25, + -1 + ], + [ + "ADD", + 22, + 20, + 1 + ], + [ + "ADD", + 21, + 23, + -1 + ], + [ + "ADD", + 20, + 18, + 1 + ], + [ + "ADD", + 19, + 21, + -1 + ], + [ + "ADD", + 18, + 16, + 1 + ], + [ + "ADD", + 17, + 19, + -1 + ], + [ + "ADD", + 16, + 14, + 1 + ], + [ + "ADD", + 15, + 17, + -1 + ], + [ + "ADD", + 14, + 12, + 1 + ], + [ + "ADD", + 13, + 15, + -1 + ], + [ + "ADD", + 12, + 10, + 1 + ], + [ + "ADD", + 11, + 13, + -1 + ], + [ + "ADD", + 10, + 8, + 1 + ], + [ + "ADD", + 9, + 11, + -1 + ], + [ + "ADD", + 8, + 6, + 1 + ], + [ + "ADD", + 7, + 9, + -1 + ], + [ + "ADD", + 6, + 4, + 1 + ], + [ + "ADD", + 5, + 7, + -1 + ], + [ + "ADD", + 4, + 2, + 1 + ], + [ + "ADD", + 3, + 5, + -1 + ], + [ + "ADD", + 2, + 0, + 1 + ], + [ + "ADD", + 1, + 3, + -1 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ], + [ + "SIGNED_SWAP", + 32, + 33 + ] + ], + "prefix_pairs": 8 +} diff --git a/research/query-thinned-controllers/PROOF.md b/research/query-thinned-controllers/PROOF.md new file mode 100644 index 0000000000..9068f42989 --- /dev/null +++ b/research/query-thinned-controllers/PROOF.md @@ -0,0 +1,278 @@ +# Query-thinned productive controllers + +## Conditional result + +Under the retained native, whole-job matching, owned-erasure, tape, analytic, +precision and exact-recovery contracts of #4359/#4416, the construction below +gives + + T(n) = O(n (log n)^(1 - kappa)), kappa = 37/12500 = 0.00296. + +This is a new author-checked conditional construction. It is not an +unconditional theorem, a formal-kernel proof, a practical implementation or a +change to the selected record. It improves #4416/#4433's conditional 0.00268647 +by about 10.1818%, and the selected 0.0023 checkpoint by about 28.6957%. +Those percentages compare exponent savings, not running times. + +The new mechanism replaces selected full native invocations by copied +rank-one query shears. Losing their productive helpers is charged. Removing +their stage multipliers also removes the corresponding parts of every idle +transform and main target. These coupled changes improve the complete moment; +merely deleting a local bill would not. + +## 1. Exact local interfaces + +Retain the source local word's all-column interpretation. For complex data, +on each of 112 ports write Q for its central rank-one Gaussian and D_s for +the commuting fresh eight-axis multiplier at stage s. Stage zero instead +uses the source nine-axis multiplier times Q^-1. The forward and backward +physical local maps are + + D_s S_y(Q^-1), D_s S_x(-Q). + +The complete THREE-base supplier has independent helper targets + + {5:28, 6:18, 7:56, 8:93, 9:213} + +and unsplit paid profile + + {1:2487, 2:713, 3:224, 4:102, 5:20, 8:8}. + +Its 408 helpers are arbitrary original fields. The one sequentially reused +owned center receives no productive credit. These source words and their +all-column/phase evidence are retained unchanged; this contribution does not +repeat their full historical physical replay. + +For BIT, retain the PR589 local word on 111 ports and 439 arbitrary helpers. +Each helper target has rank 8, D_s has rank 7, Q is the port's rank-one +projector involution, and the paid profile is + + {1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}. + +Its nine copied-center episodes remain in that profile. Its rational charts +and common-weight delayed-cover interpretation remain explicit premises. + +### The new query-only call + +To implement S_y(Q^-1) on arbitrary X,Y, clear one owned stream Z, copy X +into Z, perform Q^-1 on Z, add Z to Y, and erase Z. Return X unchanged and +Z zero. Backward uses Q and subtracts from X. Each port costs exactly one +paid rank-one job, plus the copy/add/erase and fixed matching/routing work. +There is no independent input or output credit for Z. + +For complex data Q^-1 is one positive Gaussian followed by its physical +Pauli translation: the Z4 phases -q and q+2q agree. It is not replaced by Q +using an order-two assumption. For BIT Q^-1=Q. The same construction at +column multiplicity f makes a rank-f request; this cost is never treated as +a scalar operation. Erasure is the inherited owned-stream erasure operation, +not a claim about reversible or dirty-borrowed erasure. + +## 2. The two actual finite controller words + +Start with the credited paired path controller, keeping all middle idle +windows and splitting the initial/terminal windows at a. Let p be the pair +count, with 2p+1 local stages. Keep the full native call at stages + + S = {0, 2p} union {1,3,...,2p-1}. + +Replace each other local call by its query-only shear. In every idle word, +remove those same stage multipliers. Every scalar bridge and signed exchange +remains in its original chronological place. Thus there are p+2 full native +calls and p-1 query shears. Thin stages have no fresh axes or helpers. + +`controller.py` constructs the words and constant scalar boundaries. The +verifier replays the emitted LOCAL, QUERY_SHEAR, IDLE, ADD and exchange events +directly, compares with the original polynomial specialized by D_s=1 on thin +stages, and checks every coefficient of L A R against the advertised diagonal. +The complex check is over rational Laurent polynomials, with all Q signs +retained. BIT has a separate exact binary group-ring factorization. + +Only two finite words are needed: + +| Family | p | a | Full native calls | Query shears | Active ambient rank | +|---|---:|---:|---:|---:|---:| +| Complex | 17 | 8 | 19 | 16 | 153 | +| BIT | 16 | 7 | 18 | 15 | 127 | + +Unused fresh blocks can be removed by an injective relabeling. All noninitial +complex native contacts occur on the same old-nine plus fresh-eight space; +other blocks are fixed spectators. Exact forward/inverse phase checks on +all 112 ports establish this contact independently of the number of stages. +The initial native call is unchanged. The binary rational 15-dimensional +charts are likewise checked on all 111 ports. Tensoring these identities with +I_f preserves them for each positive column multiplicity under the inherited +all-column implementation contract. + +For block rank d and port count v, the main targets are two v-field copies +of rank 1+d(p+2), and two v-field copies of rank 1+d(j+1) for j=1..a and +j=1..p-1-a. The corresponding whole idle ranks are d(j+1), each with 2v +calls. The old one-stage middle idles have become identities. In addition, +there are (p+2) fresh helper inventories, (p+2) native paid inventories, and +v(p-1) paid rank-one queries. Literal and formula-derived ledgers agree. + +All helper identities are allocated freshly per full invocation. The main +fields, helpers and suspended centers have distinct physical slots. Scalar +boundary changes are invertible, so independent arbitrary main inputs remain +independent. Thin copies introduce no new sources. Center/query ownership is +retained until the relevant call returns, and every matcher is undone. + +The exact invoices are in RESULT.json. Their basic resource counts are: + +| Family | Productive fields | Paid jobs | Productive rank mass | Paid rank mass | Surplus | +|---|---:|---:|---:|---:|---:| +| Complex | 11,560 | 72,902 | 258,271 | 257,471 | 800 | +| BIT | 11,454 | 57,555 | 217,506 | 216,753 | 753 | + +Both paid and target ranks overlap. They are not directly admitted to the +strict compiler. Raw numerical roots near 0.002960345565 and 0.003464248972 +were discovery aids; the argument uses the exact strict tests below. + +## 3. Charged tensor completion and splitting + +Apply #4416's chronological product construction and #4433's higher-moment +tail theorem to each new native unit. This is composition of actual programs: +copies are paused at the same paid position, a complete child unit runs on +distinct current owners, and it returns before any parent resumes. Correlated +values in distinct slots are allowed. No product of sums of operator matrices +is substituted for this schedule. + +Write T_t,P_t for the raw moments, B for the productive field count, +t=1-C, and choose cutoff c, target floor b, u>=C and integer power v. +After the product finishes, complete every rank K2^26*N^5, also avoiding the finite denominators and +rank witnesses, exceeds 256/(C0-C1)*N^5 and pays the complete fallback. + +Change the atom power to delta=0.004. With retained old ordinary saving +a_old=0.0000384599, the ordinary saving is exactly + + (1-delta)*C1+delta*a_old = 0.0034363538396 > 0.0034. + +Admit 0.0034. The linear adapter has saving delta>0.0034363538396; stock +is sublinear because delta<1-0.0034363538396. The old delta=0.003 fails +this adapter comparison and is explicitly rejected. All compiled dimensions, +role counts, routes, centers and leaf counts replace the old p3 constants in +the delayed-cover stock formulas. For fixed compiled N,B,P, the borrowed +digits remain O(w log e)=o(e), with w=ceil(e^0.004). + +Put kappa=0.00296, C=0.00296030, d=(C-kappa)/7, and + + complex_uniform = kappa+6d, b=kappa+5d, + a=kappa+4d, q=kappa+3d, + epsilon=1-d, beta=1-3d, r0=d/10, stop=layout=d. + +Use the admitted BIT saving 0.0034 in the unchanged nine-row outer ledger. +All 54 named strict predicates and the three retained functional predicates +pass. An additional functional predicate binds the new BIT atom explicitly, +beta*(1-0.004)>0. The smallest outer saving exceeds kappa by +629378373/4900000000000000. Old BIT admission, zero layout, closed epsilon, +closed complex slack and an unfunded endpoint each fail their intended checks. + +## 5. Finite constants, precision and scope + +No new operation is declared free. Raw scalar programs, signed swaps, copy/ +erase records, affine port charts and inverse routes are finite emitted lists. +The conservative raw scalar record bound is 10^9, above the checked local, +query and boundary bills. Every query adds its own paid job and its own +fixed routing records. Initial/end charts and target normalizers are retained. + +For a raw unit with productive count B, paid count P and scalar bound L0, +a v-fold chronological product has at most +L0*v*(B+P)^v nonrecursive records before final completion. Its old paid rank +mass is P1^v, and added completion rank is at most B^v*b^v. Bound all new +completion/splitting records by their integer rank masses, then multiply by +10*m^(2v)+10 to cover whole-job normalizers and inverse routes. This is a +constructive finite overestimate, not a claim that those movements vanish. +Allocate a distinct center to each simultaneously suspended instance; a +bound by the total expanded record count suffices. The integer compiler adds +only finitely many effective classes and clears their batch denominators. + +Apply the retained semantic-precision and stock prescriptions to these new +finite lists, coefficient heights, prefix row norms, owned centers and +matchers. They are fixed constants before the asymptotic input size varies. +All raw complex boundary coefficients are unit signed scalars; native dyadic +coefficients and BIT rational cover entries retain their pinned bounds. A +brute-force product of per-record row-mass bounds supplies an effective +prefix bound if a sharper bound is unnecessary. Increase the fixed precision +constant and fixed stock coefficient accordingly. The outer slack conditions +are strict, so absorbing these fixed constants does not change their powers. +This inherits the same all-column, physical tape, native movement/repair, +precision, analytic and recovery contracts as the reviewed source; it does +not independently prove that historical implementation stack. + +## 6. Sources, attribution, validation and next questions + +Canonical baseline: 3a23e9d9d2e67833515d1c60a17e966bcdcab43c, priority +revision 7. Refreshed main and PR checks are recorded in TASK.json. Live +overlap covered all open PR bodies and Discussion pages; sparse local README +coverage and closed-PR-body coverage are incomplete. No novelty theorem is +claimed. #4194's coded/clean local hybrid addresses a different interface; +this construction uses complete native calls and copied rank-one shears. + +Credit: zxv for the retained controller/native construction and higher-moment +tail proof (#4359/#4433); Jacob Alan Sussman for mixed-target integer flow +(#4268); Cinna Davis for the p7 paid-completion/native construction (#4416); +DreamingOfClouds, eumemic and their retained PR589/PR555 BIT lineage; +David Ganz, Jeremy Kothe, Rohan Arun, Marius-Paul Dumitrean, Erwan Secousses +and the native/outer contributors named in the unchanged source notices and +the selected contributor map. New query-thinning construction, proofs and +checks were prepared for Cinna Davis with substantial OpenAI Codex assistance. +Apache-2.0. No subagents were used. + +Reproduce with the registered command in README.md. Finite source, physical +operator, phase, interval, invoice and outer checks support this written +conditional proof; they do not constitute formal verification. Full old native +word replays, Lean and Docker were not rerun for this contribution. + +Open next questions, with first steps and blockers, are in TASK.json. The +next useful audit is the whole-job/owned-query lowering at arbitrary column +multiplicity. The next improvement question is a changed local query/native +alphabet or controller topology. A larger path census alone gives no global +optimality or assurance of a stronger complete construction. diff --git a/research/query-thinned-controllers/README.md b/research/query-thinned-controllers/README.md new file mode 100644 index 0000000000..6d1099e9a5 --- /dev/null +++ b/research/query-thinned-controllers/README.md @@ -0,0 +1,39 @@ +# Conditional κ = 0.00296 through query-thinned productive controllers + +The new construction replaces selected full native calls by paid rank-one +query shears, charging the lost productive helpers and removing the same +stage multipliers from the idle and main transforms. It gives an author-checked +conditional multiplication saving **κ = 37/12500 = 0.00296**, approximately +**10.18% above #4416/#4433's 0.00268647**. + +The complex controller uses 17 pairs, 19 full native calls and 16 query shears. +The accompanying BIT controller uses 16 pairs, 18 full calls and 15 query +shears, supporting a stronger ordinary BIT saving of 0.0034 after all cover +and atom-conversion charges. The complete outer ledger passes at κ=0.00296. + +[PROOF.md](PROOF.md) gives the native query implementation, chronological +product and paid completion, effective compiler ranks, changed BIT stock +parameters, full cost/precision obligations, attribution and conditional scope. +[RESULT.json](RESULT.json) records the exact arithmetic and rejection controls. +The two controller JSON files contain their actual emitted event lists and +constant scalar boundary programs. `controller.py` regenerates them; normal +verification directly replays them without repeating factor discovery. + +```sh +python3.12 -B scripts/research_package.py --package research/query-thinned-controllers +python3.12 -O -B research/query-thinned-controllers/verify.py +``` + +See VALIDATION.md for the exact executed environments and commands. + +This retains the reviewed source's all-column native, owned-erasure, +whole-job matching, fixed-tape, precision, analytic, prime and recovery +premises. It claims no unconditional theorem, formal verification, practical +speedup, global controller optimum or selected-frontier change. + +## Open next questions + +Open next questions are recorded in [TASK.json](TASK.json), with relevance, +first steps and blockers. Prepared for Cinna Davis with substantial OpenAI +Codex assistance; no subagents. Apache-2.0. Source attribution is in PROOF.md +and the unchanged pinned predecessor notices. diff --git a/research/query-thinned-controllers/RESULT.json b/research/query-thinned-controllers/RESULT.json new file mode 100644 index 0000000000..e0695152c9 --- /dev/null +++ b/research/query-thinned-controllers/RESULT.json @@ -0,0 +1,356 @@ +{ + "bit_invoice": { + "main": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 25479, + "14": 444, + "2": 24156, + "21": 444, + "28": 444, + "3": 1422, + "35": 444, + "4": 792, + "42": 444, + "49": 444, + "5": 1836, + "56": 444, + "6": 198, + "63": 222, + "7": 342 + }, + "paid_calls": 57555, + "productive_fields": 11454, + "rank_surplus": 753, + "raw_scalar_record_bound": 1000000000, + "targets": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "8": 7902 + }, + "thick_calls": 18, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ], + "thin_queries": 1665, + "whole_idle": { + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + } + }, + "bit_strictification": { + "alpha": { + "lower": "0.999995735238059506641600561767", + "upper": "0.999995735238059506641600561768" + }, + "compiler_H0": 3755884544, + "cutoff_base": 17, + "delta": { + "lower": "0.949707924144871179442776557218", + "upper": "0.949707924144871179442776557219" + }, + "gamma": { + "lower": "0.957429821066420278606254392110", + "upper": "0.957429821066420278606254392111" + }, + "normalized_surplus_lower": "68719461047/16845935476736", + "tail_exponent": "1/5", + "target_floor_base": 18, + "tensor_power": 1024, + "tested_saving": "173/50000", + "uniform_H1": 25986965159937, + "uniform_N": "2^25986965159937", + "uniform_saving": "3459/1000000", + "winning_word_materialized": false + }, + "complex_invoice": { + "main": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448 + }, + "owned_streams_reused_sequentially": 1, + "paid": { + "1": 49045, + "16": 448, + "2": 13547, + "24": 448, + "3": 4256, + "32": 448, + "4": 1938, + "40": 448, + "48": 448, + "5": 380, + "56": 448, + "64": 448, + "72": 448, + "8": 152 + }, + "paid_calls": 72902, + "productive_fields": 11560, + "rank_surplus": 800, + "raw_scalar_record_bound": 1000000000, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "5": 532, + "57": 448, + "6": 342, + "65": 448, + "7": 1064, + "73": 448, + "8": 1767, + "9": 4047 + }, + "thick_calls": 19, + "thick_stages": [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 34 + ], + "thin_queries": 1792, + "whole_idle": { + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + } + }, + "complex_strictification": { + "alpha": { + "lower": "0.999999952117240859760145478345", + "upper": "0.999999952117240859760145478346" + }, + "compiler_H0": 75415467350, + "cutoff_base": 20, + "delta": { + "lower": "0.941649713484853845388929204840", + "upper": "0.941649713484853845388929204841" + }, + "gamma": { + "lower": "0.967466409565147920980822933859", + "upper": "0.967466409565147920980822933860" + }, + "normalized_surplus_lower": "8589700209/251666829934592", + "tail_exponent": "1/5", + "target_floor_base": 21, + "tensor_power": 1024, + "tested_saving": "29603/10000000", + "uniform_H1": 10418370291022217, + "uniform_N": "2^10418370291022217", + "uniform_saving": "103609/35000000", + "winning_word_materialized": false + }, + "kappa": "37/12500", + "minimum_outer_margin_minus_kappa": "629378373/4900000000000000", + "native": { + "binary_charts": 111, + "complex_contacts_and_inverses": 896, + "owned_stream_restored_zero": true, + "thin_paid_rank_per_port": 1, + "thin_productive_credit": 0 + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform_gap": [ + "new_complex_uniform_saving_above_b" + ], + "missing_layout": [ + "positive_layout_slack" + ], + "old_BIT_cap": [ + "actual_bit_above_effective" + ], + "unfunded_kappa": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "old_atom_rejected": true, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "17429997759/17500000000", + "fixed_halo_explicit_metadata_branch": "1347500003/17500000", + "new_BIT_row_stock_sublinear_in_active_group": "69789991027/70000000000", + "new_semantic_group_guard": "9/70000000" + }, + "margins": { + "boundary_algebraic_matrix": "14504839378373/4900000000000000", + "fused_gaussian": "14504838135119/4900000000000000", + "global_coordinate_router": "51803/17500000", + "group_bit_router": "3626262033773/1225000000000000", + "group_scans": "34999997/35000000", + "main_transform": "14504629378373/4900000000000000", + "microbox_face_corrections": "1347500003/17500000", + "polynomial_products": "69999997/70000000", + "sparse_union_movement": "2005129839378373/4900000000000000" + }, + "parameters": { + "a": "51803/17500000", + "b": "41443/14000000", + "beta": "69999991/70000000", + "bit_saving": "17/5000", + "cap_xi": "4455129629378373/4900000000000000", + "complex_uniform_saving": "103609/35000000", + "d": "3/70000000", + "epsilon": "69999997/70000000", + "kappa": "37/12500", + "lambda_": "19940797/20000000", + "lambda_prime": "69792791/70000000", + "layout": "3/70000000", + "q": "207209/70000000", + "r0": "3/700000000", + "stop": "3/70000000", + "tested_saving": "29603/10000000" + }, + "strict_checks": { + "actual_bit_above_effective": "7697/17500000", + "actual_logarithmic_gamma_guard": "3/70000000", + "actual_logarithmic_group_guard": "444870685621627/2450000000000000", + "alpha_logarithm_absorption": "3/700000000", + "boundary_algebraic_matrix_above_kappa": "839378373/4900000000000000", + "cap_above_band": "2005129629378373/4900000000000000", + "cap_below_cell": "444870160621627/4900000000000000", + "cap_below_phase_cell_power": "5344870370621627/4900000000000000", + "complex_above_effective": "3/70000000", + "complex_below_one_over_32": "396057/14000000", + "complex_endpoint": "3/35000000", + "epsilon_below_one": "3/70000000", + "epsilon_positive": "69999997/70000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "838135119/4900000000000000", + "gaussian_above_main": "104378373/2450000000000000", + "global_coordinate_router_above_kappa": "3/17500000", + "global_gamma_power_slack": "27/700000000", + "group_below_dimension": "3/35000000", + "group_bit_router_above_kappa": "262033773/1225000000000000", + "group_gauge_power_slack": "444870675121627/2450000000000000", + "group_key_fits_record": "3/35000000", + "group_positive": "69999991/70000000", + "group_scans_above_kappa": "34896397/35000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "614514790400418148631/500000000000000000000000", + "lambda_above_internal": "3/140000000", + "lambda_above_sigma": "9/140000000", + "lambda_above_tau": "3/140000000", + "lambda_prime_above_lambda": "3/140000000", + "lambda_prime_above_leaf": "83875671/980000000000000", + "leaf_saving_above_effective": "41875671/980000000000000", + "main_transform_above_kappa": "629378373/4900000000000000", + "membership_arithmetic_fits_record": "3/70000000", + "microbox_face_corrections_above_kappa": "1347448203/17500000", + "microbox_halo_volume": "5530000009/70000000", + "new_complex_uniform_saving_above_b": "3/70000000", + "new_semantic_guard_with_C1_one": "3/70000000", + "polynomial_products_above_kappa": "69792797/70000000", + "positive_layout_slack": "3/70000000", + "q_below_effective": "3/70000000", + "q_below_internal": "3/70000000", + "q_below_leaf": "83875671/980000000000000", + "q_positive": "207209/70000000", + "short_record_fallback": "13958557/14000000", + "source_axis_superpolynomial": "3/70000000", + "sparse_union_movement_above_kappa": "1990625839378373/4900000000000000", + "stop_below_one": "69999997/70000000", + "stop_positive": "3/70000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "9/70000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "9/70000000", + "union_tag_work_per_visit_fits_record": "9/70000000" + } + }, + "relative_gain_over_p7": "27353/268647", + "schema": "query-thinned-productive-controllers/1", + "scope": "Conditional native construction; all-column, erasure, whole-job matching, fixed-tape, precision, analytic, prime and exact-recovery premises retained. No unconditional theorem or selected promotion.", + "source_inputs_authenticated": 17, + "status": "PASS_CONDITIONAL_QUERY_THINNED_KAPPA_00296" +} diff --git a/research/query-thinned-controllers/SOURCES.json b/research/query-thinned-controllers/SOURCES.json new file mode 100644 index 0000000000..0f061c87ff --- /dev/null +++ b/research/query-thinned-controllers/SOURCES.json @@ -0,0 +1,120 @@ +{ + "schema_version": 1, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "usage": "input", + "git_blob": "fbe6da7241357d89cf5c55b2e7ce2d0d046be32a", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef" + }, + { + "path": "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "usage": "input", + "git_blob": "e8c5e4f077fea0bef355e6c3013c7f252d3606cf", + "sha256": "9ece46fdfda6182e757e9a3b1f513fb3d029d730f3bafdcd6ed59180a14175b0" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "input", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "usage": "input", + "git_blob": "6a139eedbc1015c13df6f2a4333e1a89b5edd18d", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf" + }, + { + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "usage": "input", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "usage": "input", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "usage": "input", + "git_blob": "f97a23d7d21bd7f79c9d0cb14d8c6b44fddd3f23", + "sha256": "c4aa88c4943ef041e9542c519b7600ecf26ed6caff92558fdb07ac88ace64c17" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "usage": "input", + "git_blob": "c6edcbdc43bf36bb11201235027d0ec170d07fc8", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6" + }, + { + "path": "research/pr4359-p7-padding/TENSOR.md", + "usage": "input", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/pr4359-p7-padding/native_inventory.py", + "usage": "input", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + } + ] +} diff --git a/research/query-thinned-controllers/TASK.json b/research/query-thinned-controllers/TASK.json new file mode 100644 index 0000000000..ebba49a09c --- /dev/null +++ b/research/query-thinned-controllers/TASK.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "3a23e9d9d2e67833515d1c60a17e966bcdcab43c", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct query-thinned complex and BIT productive controllers and carry their exact physical words, paid tails, ordinary BIT conversion and complete outer costs to conditional kappa 0.00296.", + "scope_change_reason": "Explicit user assignment to improve kappa using the new productive-helper mechanism. The current card predates the selected changed interface; this replaces its frozen local-packing question with a complete global native/query construction.", + "bottleneck_link": "Selected full-native path calls impose stage and idle transforms even where a paid rank-one shear suffices. Removing them changes the full target/paid moment; a stronger BIT admission is needed above the prior cap.", + "budget_minutes": 60, + "stop_rule": "Finish the two actual finite native/query words and all caller costs; reject the endpoint if physical query ownership, full invoice, paid completion, BIT cover/stock or any outer predicate fails.", + "outcome": "completed", + "evidence": "PROOF.md, RESULT.json, COMPLEX-CONTROLLER.json, BIT-CONTROLLER.json, VALIDATION.md", + "author": "Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, audit and writing; no subagents.", + "open_questions": [ + { + "question": "Can the arbitrary-column owned-query lowering receive an independent native/tape audit?", + "why_it_matters": "It is the new primitive interface connecting the physical word to the changed exponent.", + "first_step": "Replay one complex inverse query and one binary cover query at two column multiplicities, charging copy, matching, read and erasure.", + "blocked_by": "Independent native/tape review of the retained all-column contracts." + }, + { + "question": "Can a changed local query/native alphabet or branching controller exceed this complete moment?", + "why_it_matters": "The old all-native p7 screen does not constrain this changed alphabet.", + "first_step": "Define a different complete finite physical word and screen its full invoice before larger native reconstruction.", + "blocked_by": "No stronger complete native/query construction has been established." + } + ], + "upstream_checkpoint": { + "main": "2a13eb1827784206202db90e5dc8327cf8a250db", + "checked_at_utc": "2026-10-21T20:06:00Z", + "priority_revision": 7, + "selected_kappa": "0.0023", + "stronger_reviewed_conditional_kappa": "0.00268647" + }, + "overlap_coverage": { + "open_prs": "296 bodies, complete pagination, 2026-10-21T19:50:54Z", + "discussions": "3284 records, complete pagination, 2026-10-21T19:51:43Z", + "local_readmes": "sparse; incomplete", + "closed_pr_bodies": "not exhaustively searched", + "additional_checks": "PR4194 coded/clean hybrid differs; PR4433 higher-moment theorem adopted. Frontier rechecked at 19:33, 19:51 and 20:06 UTC, through #4439; no higher kappa found." + } +} diff --git a/research/query-thinned-controllers/VALIDATION.md b/research/query-thinned-controllers/VALIDATION.md new file mode 100644 index 0000000000..8e9598ece7 --- /dev/null +++ b/research/query-thinned-controllers/VALIDATION.md @@ -0,0 +1,44 @@ +# Validation and limits + +Environment: Linux x86_64, CPython **3.12.14** (bundled runtime). Initial +factor discovery also ran on CPython 3.14.8. Standard library only. No +subagents, Lean build, Docker run or full historical suite. + +Completed on 2026-10-21: + +- `python3.12 -B scripts/research_package.py --package research/query-thinned-controllers --check-only` + passes metadata and all 17 input pins. +- `python3.12 -B scripts/research_package.py --package research/query-thinned-controllers` + passes the complete registered replay. +- `python3.12 -O -B research/query-thinned-controllers/verify.py` passes + from a separate **Git-free export** containing this package and exactly the + declared input files. Its RESULT.json agrees with the normal replay. +- The two external rejection controls also run in that Git-free export under + optimized Python. Appending a comment to the pinned interval source rejects + with `Changed source`. Changing an emitted QUERY_SHEAR to LOCAL rejects the + physical-event equality check. Both altered export files were restored; + no canonical predecessor file was changed. +- Internal controls execute omitted-clear and omitted-erase query words, + reverse a query's actual orientation, change a Laurent coefficient, retain + the old BIT cap or atom, close the complex/epsilon gap, omit layout, and + request the unfunded outer endpoint. Their intended gates reject. + +The exact native contacts include 896 complex forward/inverse checks and +111 rational binary charts. Both complete physical event lists are replayed. +Two rational interval implementations agree on the strict native moments. +The complete charged tensor tails, effective compiler ranks, ordinary BIT +cover/conversion and nine-row outer ledger pass. All 54 strict outer +predicates, three inherited functional predicates and the added stock guard +are retained. + +The actual local full-native words and their all-column implementation are +reused from the pinned reviewed lineage. Their entire historical physical +stack was not rerun. New winning tensor/uniform words are specified by +finite algorithms; their enormous instruction lists have not been emitted. +No finite pass establishes an unconditional theorem or formal verification. + +The committed-byte preflight and source-history check both pass after +committing the package, with all 28 package/input files matching and the pinned +canonical base in publication ancestry. Hosted CI is reported separately. +All reports retain the inherited native, whole-job, owned-erasure, fixed-tape, +precision, analytic, prime-supply and exact-recovery proof boundaries. diff --git a/research/query-thinned-controllers/VERIFY.json b/research/query-thinned-controllers/VERIFY.json new file mode 100644 index 0000000000..768aad6d68 --- /dev/null +++ b/research/query-thinned-controllers/VERIFY.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/verify.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "research/kappa-rebuild/bit/bit_native_binding.py", + "research/kappa-rebuild/bit/complex_controller_factor.py", + "research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "research/pr4359-p7-padding/TENSOR.md", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/native_inventory.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate source blobs; replay both emitted physical controller words and exact boundary programs; native phase and rational chart checks; full query, completion, compiler, BIT cover and outer costs with negative controls." + } + ] +} diff --git a/research/query-thinned-controllers/controller.py b/research/query-thinned-controllers/controller.py new file mode 100644 index 0000000000..d4557e08cf --- /dev/null +++ b/research/query-thinned-controllers/controller.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +"""Exact native/query controller construction. Apache-2.0; Codex assistance.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import importlib.util +import json +from pathlib import Path +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def engines(): + reference = ROOT/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py' + load(reference, 'joint_pair_dag') + base = ROOT/'research/kappa-rebuild/bit' + bit = load(base/'mixed_productive_bit.py', 'mixed_productive_bit') + complex_ = load(base/'complex_controller_factor.py', 'query_complex_factor') + return bit, complex_ + + +def keep_mask(p, a): + b = p-1-a + return sum(1 << i for i in list(range(1, 2*p-2, 2))+ + list(range(0, 2*a, 2))+list(range(3*(p-1)-b, 3*(p-1)))) + + +def thick_stages(p): + return {0, 2*p, *range(1, 2*p, 2)} + + +def specialize_complex(coefficients, thick): + result = {} + for term, matrix in coefficients.items(): + key = (term[0],)+tuple(x if s in thick else 0 for s, x in enumerate(term[1:])) + out = result.setdefault(key, [[Q(0)]*len(matrix) for _ in matrix]) + for i, row in enumerate(matrix): + for j, value in enumerate(row): + out[i][j] += value + return {k: m for k, m in result.items() if any(any(row) for row in m)} + + +def specialize_bit(coefficients, thick): + keep = 1+sum(1 << (s+1) for s in thick) + out = {} + for term, matrix in coefficients.items(): + key = term & keep + old = out.setdefault(key, [0]*len(matrix)) + for i, row in enumerate(matrix): + old[i] ^= row + return {k: m for k, m in out.items() if any(m)} + + +def replay_events(events, p, kind): + """Literal second replay of the emitted word, including query-only gates.""" + _, engine = engines() + size, stages = 2*p, 2*p+1 + zero = (0,)*(stages+1) + matrix = [[{zero: Q(i == j)} if i == j else {} for j in range(size)] for i in range(size)] + for event in events: + op = event[0] + if op in ('LOCAL', 'QUERY_SHEAR'): + _, stage, pair, backward = event + x, y = 2*pair, 2*pair+1 + if backward: x, y = y, x + term = (1 if backward else -1,)+(0,)*stages + matrix[y] = [engine.plus(a, engine.monomial_times(b, term, -1 if backward else 1)) for a, b in zip(matrix[y], matrix[x])] + if op == 'LOCAL': + term = (0,)+tuple(int(s == stage) for s in range(stages)) + for role in (x, y): matrix[role] = [engine.monomial_times(a, term) for a in matrix[role]] + elif op == 'IDLE': + _, pair, selected = event + term = (0,)+tuple(int(s in selected) for s in range(stages)) + for role in (2*pair, 2*pair+1): matrix[role] = [engine.monomial_times(a, term) for a in matrix[role]] + elif op == 'ADD': + _, dst, src, *coefficient = event + c = coefficient[0] if coefficient else 1 + matrix[dst] = [engine.plus(a, b, c) for a, b in zip(matrix[dst], matrix[src])] + elif op in ('SWAP', 'SIGNED_SWAP'): + _, x, y = event + matrix[x], matrix[y] = matrix[y], [engine.monomial_times(a, zero, -1 if op == 'SIGNED_SWAP' else 1) for a in matrix[x]] + else: + raise ValueError('Unknown emitted event: '+op) + result = {} + for i, row in enumerate(matrix): + for j, poly in enumerate(row): + for key, value in poly.items(): + if kind == 'complex': + result.setdefault(key, [[Q(0)]*size for _ in range(size)])[i][j] += value + elif value.numerator % 2: + need(value.denominator == 1, 'Integral binary replay coefficient') + term = (key[0] % 2)+sum((exponent % 2) << (s+1) for s, exponent in enumerate(key[1:])) + result.setdefault(term, [0]*size)[i] ^= 1 << j + return {k: m for k, m in result.items() if any(any(r) for r in m)} if kind == 'complex' else {k: m for k, m in result.items() if any(m)} + + +def inventories(kind, p, a, diagonal, idles): + thick = thick_stages(p) + ports, block = (112, 8) if kind == 'complex' else (111, 7) + if kind == 'complex': + local = json.loads((ROOT/'research/kappa-rebuild/complex/full-identity-certificates/RESULT.json').read_text())['providers']['THREE-base'] + helpers = {int(k): v for k, v in local['helper_boundary']['widths'].items()} + children = {int(k): v for k, v in local['unsplit_replays']['forward']['paid_profile'].items()} + selected = [[s for s, x in enumerate(term[1:]) if x] for term in diagonal] + need(all(term[0] in (-1, 1) for term in diagonal), 'Only legal central Gaussian normalizers') + else: + helpers = {8: 439} + children = {1: 1323, 2: 1342, 3: 79, 4: 44, 5: 102, 6: 11, 7: 19} + selected = [[s for s in range(2*p+1) if term >> (s+1) & 1] for term in diagonal] + need(all(term & 1 for term in diagonal), 'Every binary main output retains its central rank-one factor') + targets = Counter({r: len(thick)*n for r, n in helpers.items()}) + paid = Counter({r: len(thick)*n for r, n in children.items()}) + thin_calls = ports*(2*p+1-len(thick)) + paid[1] += thin_calls + main = Counter() + for stages in selected: + need(set(stages) <= thick, 'No removed stage receives output credit') + main[1+block*len(stages)] += ports + targets.update(main) + idle = Counter() + for row in idles: + if row['retained']: + rank = block*len(thick.intersection(row['stages'])) + if rank: + idle[rank] += 2*ports + paid.update(idle) + # A second derivation uses only the declared prefix/suffix intervals. + expected_main = Counter({1+block*(p+2): 2*ports}) + expected_idle = Counter() + for length in (a, p-1-a): + for j in range(1, length+1): + expected_main[1+block*(j+1)] += 2*ports + expected_idle[block*(j+1)] += 2*ports + need(main == expected_main and idle == expected_idle, 'Literal and interval-derived complete invoices agree') + surplus = sum(r*n for r, n in targets.items())-sum(r*n for r, n in paid.items()) + need(surplus == (48*len(thick)-112 if kind == 'complex' else 48*len(thick)-111), 'Rank mass includes every query and lost helper') + return {'targets': dict(sorted(targets.items())), 'paid': dict(sorted(paid.items())), + 'main': dict(sorted(main.items())), 'whole_idle': dict(sorted(idle.items())), + 'productive_fields': sum(targets.values()), 'paid_calls': sum(paid.values()), + 'rank_surplus': surplus, 'thin_queries': thin_calls, + 'thick_calls': len(thick), 'thick_stages': sorted(thick), + 'raw_scalar_record_bound': 10**9, 'owned_streams_reused_sequentially': 1} + + +def run(kind, p, a): + bit, complex_ = engines() + mask = keep_mask(p, a) + thick = thick_stages(p) + if kind == 'complex': + coefficients, events, idles = complex_.controller(p, mask) + coefficients = specialize_complex(coefficients, thick) + factor = complex_.factor(coefficients) + need(factor is not None, 'Exact rational Laurent simultaneous factorization') + diagonal = factor['diagonal'] + boundaries = {'left': complex_.serialize_matrix(factor['left']), + 'right': complex_.serialize_matrix(factor['right']), + 'left_program': factor['left_program'], 'right_program': factor['right_program']} + need(all(Q(row[-1]) in (1, -1) for program in (factor['left_program'], factor['right_program']) + for row in program if row[0] in ('ADD', 'SCALE')), 'Unit scalar boundary coefficients') + else: + coefficients, events, idles = bit.physical_controller(p, mask) + coefficients = specialize_bit(coefficients, thick) + factor = bit.simultaneous_monomial_factor(coefficients) + need(factor is not None, 'Exact binary group-ring simultaneous factorization') + diagonal = factor['diagonal_monomials'] + boundaries = factor + invoice = inventories(kind, p, a, diagonal, idles) + new_events = [] + for row in events: + if row[0] == 'LOCAL' and row[1] not in thick: + new_events.append(['QUERY_SHEAR', *row[1:]]) + elif row[0] == 'IDLE': + selected = ([s for s in row[2] if s in thick] if kind == 'complex' else + [s for s in range(2*p+1) if row[2] >> (s+1) & 1 and s in thick]) + if selected: + new_events.append(['IDLE', row[1], selected]) + else: + new_events.append(row) + need(sum(row[0] == 'LOCAL' for row in new_events) == p+2, 'Exactly p+2 full native calls') + need(sum(row[0] == 'QUERY_SHEAR' for row in new_events) == p-1, 'Exactly p-1 copied-query shears') + return {'kind': kind, 'pairs': p, 'prefix_pairs': a, 'keep_mask': mask, + 'ambient_rank': 1+(8 if kind == 'complex' else 7)*(p+2), + 'diagonal': diagonal, 'boundaries': boundaries, + 'physical_events': new_events, 'invoice': invoice} + + +if __name__ == '__main__': + for kind, p, a in [('complex', 17, 8), ('bit', 16, 7)]: + row = run(kind, p, a) + path = HERE/(kind.upper()+'-CONTROLLER.json') + path.write_text(json.dumps(row, indent=2, sort_keys=True)+'\n') + print(kind, row['invoice'], flush=True) diff --git a/research/query-thinned-controllers/verify.py b/research/query-thinned-controllers/verify.py new file mode 100644 index 0000000000..f1114036ff --- /dev/null +++ b/research/query-thinned-controllers/verify.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +"""Exact finite replay for the conditional query-thinned construction. + +Apache-2.0. Prepared for Cinna Davis with substantial OpenAI Codex assistance. +Retains zxv's native/factor/tail work and Jacob Alan Sussman's integer flow. +""" +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import argparse +import json +import sys +sys.dont_write_bytecode = True +import controller as C +HERE, ROOT, need = C.HERE, C.ROOT, C.need + + +def encode(x): + if isinstance(x, Q): return str(x) + if isinstance(x, dict): return {str(k): encode(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): return [encode(v) for v in x] + return x + + +def authenticate(): + count = 0 + for row in json.loads((HERE/'SOURCES.json').read_text())['files']: + if row['usage'] != 'input': continue + path = ROOT/row['path']; raw = path.read_bytes() + need(not path.is_symlink(), 'No source alias') + need(sha256(raw).hexdigest() == row['sha256'], 'Changed source: '+row['path']) + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == row['git_blob'], 'Changed Git blob') + count += 1 + return count + + +def controllers(): + B, E = C.engines(); result = {} + for kind, p, a in [('complex', 17, 8), ('bit', 16, 7)]: + row = json.loads((HERE/(kind.upper()+'-CONTROLLER.json')).read_text()) + thick, mask = C.thick_stages(p), C.keep_mask(p, a) + if kind == 'complex': + coefficients, events, idles = E.controller(p, mask) + coefficients = C.specialize_complex(coefficients, thick) + left = [[Q(x) for x in r] for r in row['boundaries']['left']] + right = [[Q(x) for x in r] for r in row['boundaries']['right']] + diagonal = [tuple(term) for term in row['diagonal']] + transformed = {k: B.matrix_multiply(B.matrix_multiply(left, m), right) for k, m in coefficients.items()} + expected = {k: [[Q(i == j and diagonal[i] == k) for j in range(2*p)] for i in range(2*p)] for k in set(diagonal)} + need(transformed == expected, 'All exact rational Laurent coefficients, including signs and Q powers') + for name, matrix in [('left', left), ('right', right)]: + need(E.scalar_program(matrix) == row['boundaries'][name+'_program'], 'Literal unit scalar boundary program') + changed = dict(coefficients) + k = next(iter(changed)); changed[k] = [r[:] for r in changed[k]]; changed[k][0][0] += 1 + need(B.matrix_multiply(B.matrix_multiply(left, changed[k]), right) != expected.get(k), 'A changed physical coefficient is rejected') + else: + coefficients, events, idles = B.physical_controller(p, mask) + coefficients = C.specialize_bit(coefficients, thick) + fresh = B.simultaneous_monomial_factor(coefficients) + need(fresh == row['boundaries'], 'Exact binary physical operator and scalar boundaries') + diagonal = fresh['diagonal_monomials'] + need(C.replay_events(row['physical_events'], p, kind) == coefficients, + 'Emitted native/query/idle word equals the specialized physical source') + mutant = json.loads(json.dumps(row['physical_events'])) + # Every removed stage is forward; changing its direction must change + # the actual operator rather than merely a tariff field. + next(ev for ev in mutant if ev[0] == 'QUERY_SHEAR')[3] = True + need(C.replay_events(mutant, p, kind) != coefficients, 'Wrong query orientation rejected') + invoice = C.inventories(kind, p, a, diagonal, idles) + ports = 112 if kind == 'complex' else 111 + boundary_records = (sum(len(row['boundaries'][name+'_program']) for name in ('left', 'right')) + if kind == 'complex' else row['boundaries']['boundary_unit_ADDs_per_port']) + scalar_upper = (p+2)*10**6+16*invoice['thin_queries']+32*ports*(len(row['physical_events'])+boundary_records) + need(scalar_upper < invoice['raw_scalar_record_bound'], 'Conservative complete scalar/route count fits') + need(encode(invoice) == row['invoice'], 'Literal and closed-form complete '+kind+' invoice') + result[kind] = invoice + return result + + +def native_contacts(): + n = C.load(ROOT/'research/pr4359-p7-padding/native_inventory.py', 'thinned_native_phases') + phases = json.loads((ROOT/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json').read_text()) + axes = tuple(1 << i for i in range(17)); old = [(a, 1) for a in axes[:9]]; fresh = [(a, 1) for a in axes[9:]] + checks = 0 + for recipe in phases['recipes']: + q = recipe['q']; basis = recipe['idle_children'][0]['orthogonal_axes'][:8] + need(all((b&q).bit_count() % 2 == 0 for b in basis), 'Old eight-space perpendicular to q') + swaps = [b ^ axes[9+i] for i, b in enumerate(basis)] + route = tuple(e ^ n.act(swaps, sum(((e&v).bit_count() % 2) << i for i, v in enumerate(swaps))) for e in axes) + need(all(n.act(route, route[i]) == axes[i] for i in range(17)), 'Exact physical route inverse') + need(all((a&b).bit_count() % 2 == int(i == j) for i, a in enumerate(route) for j, b in enumerate(route)), 'Orthogonal physical route') + need(n.act(route, q) == q, 'Central query direction fixed') + need(n.polynomial(n.norm([(q, -1)]), 17) == n.polynomial(n.norm([(q, 1), (q, 2)]), 17), + 'Inverse thin Gaussian is one positive query and a physical translation') + for sign in (-1, 1): + raw = (n.norm(old), n.norm(old+[(q, -1)])) + entry = (n.norm(fresh+[(q, sign)]), n.norm(fresh)) + out0 = n.norm(fresh+[(a, sign) for a in axes[:9]]) + local_out = (out0, n.norm(list(out0)+[(q, -sign)])) + out = (n.norm(old+fresh), n.norm(old+fresh+[(q, -1)])) + for x, y in list(zip(raw, entry))+list(zip(local_out, out)): + n.contact(x, y, route, 17); checks += 1 + for x, y in zip(raw, out): + need(n.polynomial(n.norm(list(y)+[(a, -c) for a, c in x]), 17) == n.polynomial(n.norm(fresh), 17), 'Exactly the fresh eight-axis multiplier') + bit = C.load(ROOT/'research/kappa-rebuild/bit/bit_native_binding.py', 'thinned_binary_charts') + ports = json.loads((ROOT/'research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json').read_text())['ports'] + local = json.loads((ROOT/'research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json').read_text())['local'] + for direction in local['signed_directions']: + need({int(k): v for k, v in direction['profile'].items()} == C.engines()[0].LOCAL, + 'Every actual binary local child remains charged') + need(direction['unit_ADDs'] < 10**6 and direction['owned_COPY_episodes'] == 9, + 'Native binary scalar and owned-center bills retained') + for row in ports: + p = [[Q(x) for x in r] for r in row['central_projector']]; rho = [[Q(x) for x in r] for r in row['chart_15']] + active = [[p[i][j] if i < 8 and j < 8 else Q(i == j and i >= 8) for j in range(15)] for i in range(15)] + full = [[Q(i == j and i < 8) for j in range(15)] for i in range(15)] + need(bit.multiply(rho, rho) == bit.ident(15) and bit.multiply(bit.multiply(rho, active), rho) == full, 'BIT exact arbitrary-column chart') + need(bit.multiply(p, p) == p and sum(p[i][i] for i in range(8)) == 1, 'BIT query rank one') + # Formal independent X,Y,Z columns. Mutants execute the same word with + # an actual omitted operation; they are not merely different receipts. + for e in (-1, 1): + def execute(clear=True, erase=True): + x, y, z = {('X', 0): 1}, {('Y', 0): 1}, {('Z', 0): 1} + if clear: z = {} + for key, value in x.items(): z[key] = z.get(key, 0)+value + z = {(name, power+e): value for (name, power), value in z.items()} + for key, value in z.items(): y[key] = y.get(key, 0)+(-1 if e == 1 else 1)*value + if erase: z = {} + return x, y, z + expected = ({('X', 0): 1}, {('Y', 0): 1, ('X', e): -1 if e == 1 else 1}, {}) + need(execute() == expected, 'Completed arbitrary-input owned-query shear') + need(execute(clear=False) != expected and execute(erase=False) != expected, 'Clear/erase omission controls rejected') + return {'complex_contacts_and_inverses': checks, 'binary_charts': len(ports), + 'thin_paid_rank_per_port': 1, 'thin_productive_credit': 0, 'owned_stream_restored_zero': True} + + +def tail(E, invoice, tested, uniform, cutoff, floor, alpha_gap): + T, P = invoice['targets'], invoice['paid']; t, u, v = 1-tested, Q(1, 5), 1024 + target, paid = E.moment(T, t), E.moment(P, t) + alpha = E.divide(paid, target) + other = C.load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'separate_rational_moment_engine') + tl, th = other.moment(T, tested); pl, ph = other.moment(P, tested) + need(tl > ph and max(target[0], tl) <= min(target[1], th) + and max(paid[0], pl) <= min(paid[1], ph), 'Separate rational interval engine agrees') + gamma = E.divide(E.moment(P, t+u), E.mul(E.power(cutoff, u), target)) + delta = E.divide((Q(sum(T.values())*floor),)*2, E.mul(E.power(cutoff, tested), target)) + need(alpha[1] < 1-alpha_gap and gamma[1] < Q(31, 32) and delta[1] < Q(19, 20), 'Three completely charged tail ratios') + need(Q(31, 32)**128 < Q(1, 16) and Q(19, 20)**128 < Q(1, 16), 'Exact decay blocks') + surplus = 1-Q(1)/(1+v*alpha_gap)-Q(4, 2**32) + need(surplus > 0, 'Original and completion tails both fit') + need(cutoff**64 < floor**63 and max(T) < 256, 'Strict ranks after completion and splitting') + h = Q(1, 64); z, z0 = 1-uniform, (t+1-uniform)/2; gap = z0-t + B, debt = (5+8*h)*v, 1+8*v*(1-z0) + x = (gap*B+debt)/(h*gap); H0 = -((-x.numerator)//x.denominator) + x = H0*(1-z0)/(z-z0); H1 = x.numerator//x.denominator+1 + need(H0 >= 8*v and H0*h*gap >= gap*B+debt and H1*(z-z0) > H0*(1-z0), 'Effective integer compiler bound') + return {'tested_saving': tested, 'uniform_saving': uniform, 'alpha': E.display(alpha), + 'gamma': E.display(gamma), 'delta': E.display(delta), 'tensor_power': v, + 'cutoff_base': cutoff, 'target_floor_base': floor, 'tail_exponent': u, + 'normalized_surplus_lower': surplus, 'compiler_H0': H0, 'uniform_H1': H1, + 'uniform_N': '2^'+str(H1), 'winning_word_materialized': False} + + +def run(): + count = authenticate(); rows = controllers(); native = native_contacts() + E = C.load(ROOT/'research/higher-moment-strictification/verify.py', 'credited_exact_intervals') + kappa, tested = Q('.00296'), Q('.00296030'); d = (tested-kappa)/7 + complex_ = tail(E, rows['complex'], tested, kappa+6*d, 20, 21, Q(1, 30000000)) + bit = tail(E, rows['bit'], Q('.00346'), Q('.003459'), 17, 18, Q(1, 250000)) + before, after, atom, old = Q('.003459'), Q('.00345'), Q('.004'), Q('.0000384599') + ordinary, admitted = (1-atom)*after+atom*old, Q('.0034') + need(before > after and atom > ordinary > admitted and atom < 1-ordinary, 'Complete ordinary BIT conversion') + need(Q('.003') < ordinary and 2**26 > 256/(before-after), 'Old atom rejected and finite prime bound') + L = C.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'complete_outer_ledger') + params = {'kappa': kappa, 'tested_saving': tested, 'complex_uniform_saving': kappa+6*d, + 'b': kappa+5*d, 'a': kappa+4*d, 'q': kappa+3*d, 'bit_saving': admitted, + 'epsilon': 1-d, 'beta': 1-3*d, 'r0': d/10, 'stop': d, 'layout': d, 'd': d} + outer = L.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta']*(1-atom) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete predicate inventory') + need(all(x > 0 for group in ('strict_checks', 'functional_checks') for x in outer[group].values()), 'All outer predicates') + controls = {} + for label, changes in [('old_BIT_cap', {'bit_saving': Q('.0027')}), ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('unfunded_kappa', {'kappa': tested}), ('closed_epsilon', {'epsilon': Q(1)}), ('missing_layout', {'layout': Q(0)})]: + bad = L.ledger(dict(params, **changes)); failed = [k for k, v in bad['strict_checks'].items() if v <= 0] + need(failed, 'Reject '+label); controls[label] = failed + return encode({'schema': 'query-thinned-productive-controllers/1', 'status': 'PASS_CONDITIONAL_QUERY_THINNED_KAPPA_00296', + 'kappa': kappa, 'relative_gain_over_p7': kappa/Q('.00268647')-1, + 'source_inputs_authenticated': count, 'native': native, 'complex_invoice': rows['complex'], 'bit_invoice': rows['bit'], + 'complex_strictification': complex_, 'bit_strictification': bit, + 'ordinary_BIT': {'before_cover': before, 'after_cover': after, 'atom': atom, 'ordinary_saving': ordinary, + 'admitted': admitted, 'prime_rule': 'odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses'}, + 'outer': outer, 'minimum_outer_margin_minus_kappa': min(outer['margins'].values())-kappa, + 'negative_controls': controls, 'old_atom_rejected': True, + 'scope': 'Conditional native construction; all-column, erasure, whole-job matching, fixed-tape, precision, analytic, prime and exact-recovery premises retained. No unconditional theorem or selected promotion.'}) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('--write', action='store_true'); args = parser.parse_args() + result = run(); output = HERE/'RESULT.json' + if args.write: output.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: need(result == json.loads(output.read_text()), 'Complete receipt matches exact replay') + print(json.dumps({k: result[k] for k in ('status', 'kappa', 'source_inputs_authenticated', 'minimum_outer_margin_minus_kappa')}, sort_keys=True)) diff --git a/research/test-suite-locale-reads/SOURCES.json b/research/test-suite-locale-reads/SOURCES.json index be5f08378a..be5c7d2e9b 100644 --- a/research/test-suite-locale-reads/SOURCES.json +++ b/research/test-suite-locale-reads/SOURCES.json @@ -17,8 +17,9 @@ { "path": "docs/research/current-status.md", "usage": "input", - "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", - "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" + "git_blob": "532af84312cbfeb39a1e4659d8398deb560f1e4a", + "sha256": "54c843968d0b178369a7e56161be44c4692935c3f46ce261678aeedadb309891", + "pin": "head:7d05d73f96c27a9d360011e04af69b23fa903757:docs/research/current-status.md" }, { "path": "tests/test_research_current_status.py",