From c25a4ce22a887daf8cba8b3cfad72796752ab2ee Mon Sep 17 00:00:00 2001 From: ywz65 <154373401+ywz65@users.noreply.github.com> Date: Thu, 15 Oct 2026 05:31:13 -0700 Subject: [PATCH] Prove scoped unitary obstruction for the selected dirty reader --- .../selected-dirty-reader-z4/PREDECESSOR.json | 12 + research/selected-dirty-reader-z4/PROOF.md | 173 + research/selected-dirty-reader-z4/README.md | 112 + research/selected-dirty-reader-z4/RESULT.json | 22661 ++++++++++++++++ .../selected-dirty-reader-z4/SOURCES.json | 66 + research/selected-dirty-reader-z4/TASK.json | 106 + research/selected-dirty-reader-z4/VERIFY.json | 38 + .../inputs/PR2464-README.md | 246 + .../selected-dirty-reader-z4/test_verify.py | 90 + research/selected-dirty-reader-z4/verify.py | 336 + 10 files changed, 23840 insertions(+) create mode 100644 research/selected-dirty-reader-z4/PREDECESSOR.json create mode 100644 research/selected-dirty-reader-z4/PROOF.md create mode 100644 research/selected-dirty-reader-z4/README.md create mode 100644 research/selected-dirty-reader-z4/RESULT.json create mode 100644 research/selected-dirty-reader-z4/SOURCES.json create mode 100644 research/selected-dirty-reader-z4/TASK.json create mode 100644 research/selected-dirty-reader-z4/VERIFY.json create mode 100644 research/selected-dirty-reader-z4/inputs/PR2464-README.md create mode 100644 research/selected-dirty-reader-z4/test_verify.py create mode 100644 research/selected-dirty-reader-z4/verify.py diff --git a/research/selected-dirty-reader-z4/PREDECESSOR.json b/research/selected-dirty-reader-z4/PREDECESSOR.json new file mode 100644 index 0000000000..3f4be1a3f0 --- /dev/null +++ b/research/selected-dirty-reader-z4/PREDECESSOR.json @@ -0,0 +1,12 @@ +{ + "repository": "CrocSwap/integer-mult-bounds", + "pull_request": 2464, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2464", + "head_commit": "f364b97ff4700147fc06e622b79952b9fe6c4fa8", + "source_path": "research/z4-typed-echo-supplier-instance/README.md", + "git_blob": "2ebd3eb14505386023cd752dca8429bb123ebf79", + "sha256": "6de043bdef2f652ca3b179e0d61e0ac127a8981378ac4f5a5f800d200f122690", + "retained_path": "inputs/PR2464-README.md", + "usage": "Context and the explicit missing-child intertwiner handoff only; no executable code imported.", + "credit": "Aaron Wang with substantial opencode assistance; mechanism from Cinna Davis with OpenAI Codex assistance, extending Ross Richardson and Sagar Thakrar." +} diff --git a/research/selected-dirty-reader-z4/PROOF.md b/research/selected-dirty-reader-z4/PROOF.md new file mode 100644 index 0000000000..c34c0b28b2 --- /dev/null +++ b/research/selected-dirty-reader-z4/PROOF.md @@ -0,0 +1,173 @@ +# The full selected reader excludes a unitary paired-cycle intertwiner + +This is a scoped obstruction at one named local cut, conditional on the exact +native frame identities retained in the selected replay. It is not an +obstruction to every order-four action or to a different supplier contract. + +## 1. Object, ordering and boundary + +Use the `gauge44` provider in the pinned selected replay archive. Its 704 live +fields are the 112 source fields, 112 target fields and 480 arbitrary dirty +helpers, in that order. The eight output fields, in order, are + +``` +(92, 57, 81, 224, 11, 240, 9, 256). +``` + +The input cut is immediately before `phase: entry_adapters`, **after** all +7,400 zero-frame precondition/compensation scalar gates. The output cut is +immediately before `phase: centers`. These are half-open event indices +`[7401,12550)` in the exact forward emitted program. No centre COPY, descent, +ERASE, B block or final cleanup belongs to this reader. The omitted prefix is +invertible: every gate is an addition between distinct fields or a nonzero +scale. Therefore every tuple of 704 input payloads at the named cut is +attainable from an arbitrary dirty invocation input. No helper is assumed zero. + +Erase the unitary frame annotations, retaining the 3,451 scalar gates of this +segment. Replaying them on all 704 formal basis inputs and selecting the eight +output rows defines `A` in `Q^(8 x 704)`. An independent reverse covector +pullback gives exactly the same matrix. The committed `RESULT.json` contains +all entries, not just its diagonal norms. + +## 2. Scalar prefix invariant for every input field + +Let `H` be the common payload Hilbert space. In the retained native realization, +each frame `f` has an exact unitary operator `T_f` on `H`; a climb `f -> g` +implements exactly `T_g T_f^-1`. This is the exact-phase Clifford contract +retained in `CLIFFORD-REVIEW.json`, not a phase-free tableau assertion. The +frames are built from normalized Fourier, invertible address permutations and +unit-modulus phases, all unitary. Entry adapters, including the inverse right +residual wrappers for entering or hyperplane-ended helpers, are unitary too. + +Write `E_j` for the physical entry adapter on field `j`, and `s_j` for its +starting frame. For the arbitrary physical input payload `z_j`, define + +``` +u_j = T_(s_j)^-1 E_j z_j. +``` + +Thus `U_in = diag_j(T_(s_j)^-1 E_j)` is unitary on the full direct sum `H^704`. +The definition applies separately to **all** 704 fields, including all 480 +helpers and all 240 residual-adapter entries. It makes no assertion that +constants, Fourier characters or any one-dimensional subspace are invariant. + +The induction invariant after any prefix of A is + +``` +physical field r = T_(current[r]) sum_j a_(r,j) u_j, +``` + +where `a_(r,*)` is the corresponding row of the scalar prefix matrix. +Immediately after entry it holds with the identity matrix. For a climb, +left multiplication by `T_new T_old^-1` changes only the displayed frame. For +a scalar addition, source and target have the *same current frame*, so +linearity updates their coefficient rows exactly as the scalar replay does. +For a scale, the coefficient multiplies the entire row. These are all events. +The verifier checks the current frame of both operands of every addition, +each climb's old frame, nestedness and rank, all 704 entry wrappers, and the +eight exact output frames `(415,...,422)`. + +Consequently the actual native reader has the factorization + +``` +A_native = T_out (A tensor I_H) U_in, +T_out = diag(T_415,...,T_422). +``` + +This uses the retained exact transition identities. The new check authenticates +their bytes and global-phase review, checks the scalar/frame prefix, and +independently verifies bijectivity and phase ranges of all 6,088 serialized +monomials. It does not independently rerun every Clifford equality or claim +that checking monomial unitarity alone proves those equalities. The factorization +is valid at every payload size for which the retained exact unitary frame +realization applies; no all-size supplier or analytic-transfer obligation is +newly discharged here. + +## 3. Native Gram obstruction, including physical permutations + +Set `G = A A^T`. The exact diagonal is + +``` +(150, 130, 146, 134, 122, 126, 142, 146). +``` + +By the factorization, the `i,i` block of +`A_native A_native*` is `G_ii I_H`. This conclusion uses all 704 inputs: the +unitary input factor cancels, and unitary conjugation of a scalar identity +block leaves that block unchanged. + +Suppose an arbitrary unitary input action `P` on `H^704` and an output action +`Q_native` satisfy `A_native P = Q_native A_native`. Allow `Q_native` to be any +unitary block-permutation: its `i,sigma(i)` block is an arbitrary unitary +payload map `V_i`, and all other blocks in row `i` are zero. Gram invariance +then forces + +``` +G_ii I_H = V_i (G_(sigma(i),sigma(i)) I_H) V_i*; +hence G_ii = G_(sigma(i),sigma(i)). +``` + +When `sigma` has two cycles of length four, this is impossible: no value of the +diagonal occurs four times (the maximum multiplicity is two). The verifier +also enumerates all `8!/(4^2 2!) = 1260` such permutations and retains a failing +row for each. This covers arbitrary unitary input mixing, not merely signed +permutations or permutations of helpers. + +There are two different output actions worth distinguishing. A physical row +permutation is `Q tensor I_H`. A permutation of typed scalar outputs is +`T_out (Q tensor I_H) T_out^-1`; its nonzero blocks include transitions between +output frames. Both lie in the excluded block-permutation class. We do not +silently identify them. Adding signs or unitary payload rotations to either +does not repair the unequal scalar diagonal blocks. + +This rules out a direct embedding of the paired-cycle contract into the full +selected dirty reader at this cut with unitary input action. It neither proves +that the abstract PR1391/1410 echo is wrong nor asserts that PR2464 supplied +this missing embedding: PR2464 explicitly says no named host child exposes it. +The location of the unitary condition matters: the preceding 7,400 scalar gates +are invertible but need not be unitary. Conjugating an action that is unitary +before that prefix can give a nonunitary action at our cut. Such an earlier-cut +unitary action is outside this result unless its conjugate is also unitary here. + +## 4. Controls that delimit the conclusion + +The source-data restriction `R = A[:,0:112]` satisfies `R R^T = 56 I_8`. +For the fixed paired cycle `Q x = (x_3,x_0,x_1,x_2,x_7,x_4,x_5,x_6)`, every +transformed column of `R` is another signed column. The signed action +`P_data` constructed in the receipt is a permutation of all 112 columns, +has fourth power identity and satisfies `R P_data = Q R`. Deleting its negative +signs breaks the identity. Thus data-only inspection passes even though the +full interface fails. The helper-only row norms are +`(94,74,90,78,66,70,86,90)`. No clean-helper assumption is licensed. + +A smaller witness for the fixed `Q` is input field 224. Its column is +`h=(0,2,2,0,0,0,0,0)`, while `Qh=(0,0,2,2,0,0,0,0)` is absent, even up to +sign, among all 704 columns. This excludes a signed permutation directly; +the Gram argument is the stronger statement for every unitary input action. + +There is an explicit **nonunitary escape**, so no general intertwiner +impossibility is claimed. Define + +``` +J = [R^T/56; 0] (704 x 8), +P_t = I_704 + J (Q^t-I_8) A, t in Z/4Z. +``` + +Then `AJ=I`, so `A P_t = Q^t A`. Expanding the product and using `AJ=I` +gives `P_s P_t = P_(s+t)`, hence `P_4=I`. Since A is surjective and Q has +exact order four, `P_1` also has exact order four. The verifier checks the +right inverse and all 16 low-rank group-law products exactly. But for `e_224`, + +``` +||P_1 e_224||^2 = 1 + ||J(Q-I)h||^2 + = 1 + ||(Q-I)h||^2/56 = 8/7. +``` + +The first term and the correction have disjoint input supports. Thus P is not +unitary. This formula does not provide an executable native word, favorable +invoice, source restoration, precision bound or legal hosting schedule. Those +are the next questions if a paid nonorthogonal replacement is pursued. + +Output rescaling or nonunitary mixing, changed cuts, different copied totals, +or new host contracts are also outside the obstruction. No charge, selected +histogram, ceiling or kappa is changed by this result. diff --git a/research/selected-dirty-reader-z4/README.md b/research/selected-dirty-reader-z4/README.md new file mode 100644 index 0000000000..40974732c7 --- /dev/null +++ b/research/selected-dirty-reader-z4/README.md @@ -0,0 +1,112 @@ +# The selected dirty centre reader has no unitary paired-cycle intertwiner + +**One source-bound missing-interface obstruction; no new kappa or supplier +admission.** At the selected `gauge44` cut after zero-frame preconditioning and +before entry adapters, the full reader of eight centre totals cannot satisfy +`A_native P = Q_native A_native` when P is unitary and Q_native permutes the +eight output blocks as two four-cycles, even allowing a different unitary +payload map on each output edge. This includes both physical row permutations +and frame-conjugated output permutations. Every one of the 704 input fields is +arbitrary; the 480 helper fields cannot be discarded. + +The exact diagonal Gram blocks are the following scalar multiples of identity: + +``` +(150, 130, 146, 134, 122, 126, 142, 146). +``` + +A unitary input action preserves the Gram matrix, so output blocks in the same +cycle would need equal entries. No value occurs four times. The proof therefore +excludes all 1,260 relabellings of paired four-cycles and arbitrary unitary input +mixing, not just signed input permutations. + +The useful boundary is exposed by two controls. The 112-column **data-only** +reader has Gram `56 I` and an explicit signed order-four intertwiner; ignoring +helpers would report a misleading success. Conversely, the full reader has an +explicit **nonunitary** order-four intertwiner `P_t=I+J(Q^t-I)A`, with `AJ=I`. +It sends unit vector `e_224` to a vector of squared norm `8/7`. Thus paid +nonorthogonal implementations remain open. + +## Relation to the missing interface + +[PR1391's retained contract](../z4-persistent-pair-seed57/inputs/PR1391-README.md) +and [PR1410](../z4-persistent-pair-seed57/README.md) use an order-four action +whose output octet is two four-cycles. Their abstract selector children satisfy +the intertwining equality. [PR2464](https://github.com/CrocSwap/integer-mult-bounds/pull/2464), +pinned at `f364b97ff4700147fc06e622b79952b9fe6c4fa8`, explicitly leaves a named +host child exposing that equality open. Its exact README is retained in +[inputs/PR2464-README.md](inputs/PR2464-README.md), with source blob and SHA256 +in [PREDECESSOR.json](PREDECESSOR.json). + +This result reconstructs one actual selected reader and excludes its direct +unitary embedding at a named cut. It does not restate a generic absence of a +host, invalidate the abstract echo, or presume PR2464 had proved the missing +embedding. It does not cover arbitrary subquotients, paid changes of basis, +other cuts, output scalings, alternative totals or new contracts. + +## Exact certificate and native interpretation + +[PROOF.md](PROOF.md) gives the typed prefix induction for **every** live field. +The source segment is the half-open event range `[7401,12550)` of the pinned +forward program: 704 entry adapters, 3,451 scalar gates and 992 frame climbs. +All scalar operands share their current frame; the exact retained native +transition identities give `A_native=T_out (A tensor I) U_in`, with both frame +factors unitary. Hence its diagonal Gram blocks are the scalar row norms times +identity. No claim that Clifford wrappers fix constant payloads is used. + +[verify.py](verify.py) independently reconstructs the 8-by-704 scalar reader +both forward and by reverse covector pullback, checks the typed segment and all +6,088 serialized monomials for unitarity, enumerates the paired cycles, builds +the data-only signed action, and checks the explicit nonunitary escape. All +arithmetic and acceptance are exact, with no optimization-sensitive asserts. +[RESULT.json](RESULT.json) contains the complete reader, Gram matrix, each +rejection witness, and the positive control's signed permutation. Seven test +groups exercise byte drift, bad/missing entry wrappers, wrong scalar/climb +frames, singular monomials, dropped signs, helper omission and the escape. + +The native interpretation inherits the source's exact Clifford identities; it +does not rerun their complete independent compiler audit. The pre-entry prefix +is invertible but may be nonunitary. An action unitary **before** that prefix +can become nonunitary at our cut and is outside the excluded class. The result +does not change the centre charge, supply a new invoice, prove all-size +admission, or alter the selected record. + +## Reproduce + +From the repository root, with full Git history for source provenance: + +```sh +python3 scripts/research_package.py --package research/selected-dirty-reader-z4 --check-only +python3.12 scripts/research_package.py --package research/selected-dirty-reader-z4 +python3.12 -I -B -O research/selected-dirty-reader-z4/verify.py +python3.12 -I -B -O research/selected-dirty-reader-z4/test_verify.py +``` + +The registered replay uses only the standard library. Local replay was tested +with CPython 3.12.7 and 3.14.5, including optimized execution. The card's ceiling +and lever checks pass: sharing the centre by two has an ideal planning ceiling +1.90 times the selected local ceiling. That favorable relaxation motivated the +interface audit; it is not a claimed realized improvement. No selected cold +replay, full Lean build, hosted CI or independent human review is claimed. + +## Open next questions + +- Can the explicit nonunitary `P_t` be implemented with legal source restoration + and a favorable complete native invoice? Start by lowering the rank-eight + update `J(Q-I)A` at this cut, pricing the reads, intermediate storage, inverse, + precision and owner transport. An algebraic formula supplies none of those. +- Does a different cut or different set of copied totals admit the paired-cycle + interface? Start with its **full dirty-input** native reader and exact Gram + blocks before optimizing a schedule. This obstruction does not transfer + through arbitrary nonunitary preconditioning or new output normalization. + +## Credit + +New proof, checker and packaging by **ywz65**, with substantial **OpenAI Codex** +assistance; Apache-2.0. Selected source lineage: Rohan Arun's PR1094 on Jeremy +Kothe's retained word and its contributors. The local emitter and residual +wrappers retain DreamingOfClouds' Claude-assisted extensions of icekylinx's +Codex-assisted code and the chafreaky wrapper construction. The typed echo is +by Cinna Davis with OpenAI Codex assistance, extending Ross Richardson and +Sagar Thakrar. The PR2464 handoff is by Aaron Wang with opencode assistance. +Frozen sources and the selected frontier are unchanged. diff --git a/research/selected-dirty-reader-z4/RESULT.json b/research/selected-dirty-reader-z4/RESULT.json new file mode 100644 index 0000000000..2f22ff4663 --- /dev/null +++ b/research/selected-dirty-reader-z4/RESULT.json @@ -0,0 +1,22661 @@ +{ + "boundary": { + "event_counts": { + "adapter": 464, + "climb": 992, + "phase": 2, + "residual_adapter": 240, + "scalar": 3451 + }, + "event_range": [ + 7401, + 12550 + ], + "input_fields": 704, + "invertible_pre_entry_scalar_gates": 7400, + "monomial_unitarity_checks": 6088, + "output_fields": [ + 92, + 57, + 81, + 224, + 11, + 240, + 9, + 256 + ], + "output_frames": [ + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422 + ] + }, + "data_only_P_columns": [ + [ + 0, + 1 + ], + [ + 53, + 1 + ], + [ + 75, + 1 + ], + [ + 102, + 1 + ], + [ + 31, + 1 + ], + [ + 56, + 1 + ], + [ + 15, + 1 + ], + [ + 27, + 1 + ], + [ + 39, + -1 + ], + [ + 86, + 1 + ], + [ + 60, + 1 + ], + [ + 29, + 1 + ], + [ + 68, + 1 + ], + [ + 98, + 1 + ], + [ + 34, + 1 + ], + [ + 49, + 1 + ], + [ + 107, + -1 + ], + [ + 64, + 1 + ], + [ + 8, + 1 + ], + [ + 95, + 1 + ], + [ + 20, + -1 + ], + [ + 110, + -1 + ], + [ + 79, + -1 + ], + [ + 61, + -1 + ], + [ + 10, + -1 + ], + [ + 82, + 1 + ], + [ + 18, + -1 + ], + [ + 7, + -1 + ], + [ + 42, + 1 + ], + [ + 104, + 1 + ], + [ + 16, + 1 + ], + [ + 4, + 1 + ], + [ + 71, + 1 + ], + [ + 89, + 1 + ], + [ + 2, + 1 + ], + [ + 63, + -1 + ], + [ + 36, + 1 + ], + [ + 47, + 1 + ], + [ + 97, + 1 + ], + [ + 26, + 1 + ], + [ + 66, + 1 + ], + [ + 23, + -1 + ], + [ + 109, + -1 + ], + [ + 35, + -1 + ], + [ + 24, + -1 + ], + [ + 11, + -1 + ], + [ + 111, + 1 + ], + [ + 21, + 1 + ], + [ + 90, + 1 + ], + [ + 72, + 1 + ], + [ + 25, + 1 + ], + [ + 85, + 1 + ], + [ + 50, + 1 + ], + [ + 33, + 1 + ], + [ + 3, + 1 + ], + [ + 88, + 1 + ], + [ + 69, + 1 + ], + [ + 57, + -1 + ], + [ + 105, + 1 + ], + [ + 43, + 1 + ], + [ + 44, + 1 + ], + [ + 93, + 1 + ], + [ + 30, + 1 + ], + [ + 59, + 1 + ], + [ + 17, + -1 + ], + [ + 103, + -1 + ], + [ + 40, + -1 + ], + [ + 54, + 1 + ], + [ + 12, + 1 + ], + [ + 100, + 1 + ], + [ + 83, + 1 + ], + [ + 73, + 1 + ], + [ + 6, + 1 + ], + [ + 78, + 1 + ], + [ + 51, + 1 + ], + [ + 14, + 1 + ], + [ + 81, + -1 + ], + [ + 65, + 1 + ], + [ + 32, + 1 + ], + [ + 58, + 1 + ], + [ + 101, + 1 + ], + [ + 92, + -1 + ], + [ + 52, + 1 + ], + [ + 13, + 1 + ], + [ + 99, + 1 + ], + [ + 91, + 1 + ], + [ + 106, + 1 + ], + [ + 76, + 1 + ], + [ + 55, + 1 + ], + [ + 1, + 1 + ], + [ + 84, + 1 + ], + [ + 74, + 1 + ], + [ + 87, + 1 + ], + [ + 41, + 1 + ], + [ + 28, + 1 + ], + [ + 19, + -1 + ], + [ + 77, + -1 + ], + [ + 38, + -1 + ], + [ + 70, + 1 + ], + [ + 48, + 1 + ], + [ + 5, + 1 + ], + [ + 80, + 1 + ], + [ + 67, + 1 + ], + [ + 96, + 1 + ], + [ + 45, + -1 + ], + [ + 22, + -1 + ], + [ + 108, + -1 + ], + [ + 62, + -1 + ], + [ + 9, + -1 + ], + [ + 94, + -1 + ], + [ + 37, + -1 + ], + [ + 46, + -1 + ] + ], + "dirty_helper_witness": { + "Q_column": [ + "0", + "0", + "2", + "2", + "0", + "0", + "0", + "0" + ], + "column": [ + "0", + "2", + "2", + "0", + "0", + "0", + "0", + "0" + ], + "input": 224 + }, + "gram": [ + [ + "150", + "6", + "8", + "4", + "9", + "3", + "9", + "7" + ], + [ + "6", + "130", + "0", + "0", + "-1", + "1", + "7", + "9" + ], + [ + "8", + "0", + "146", + "2", + "5", + "5", + "9", + "9" + ], + [ + "4", + "0", + "2", + "134", + "1", + "1", + "5", + "9" + ], + [ + "9", + "-1", + "5", + "1", + "122", + "0", + "0", + "0" + ], + [ + "3", + "1", + "5", + "1", + "0", + "126", + "0", + "0" + ], + [ + "9", + "7", + "9", + "5", + "0", + "0", + "142", + "0" + ], + [ + "7", + "9", + "9", + "9", + "0", + "0", + "0", + "146" + ] + ], + "helper_only_row_norms": [ + 94, + 74, + 90, + 78, + 66, + 70, + 86, + 90 + ], + "limits": "Exact selected entry-adapter-to-centres cut; all 704 dirty input fields. Unitary input actions and unitary block-permutation output actions with paired 4-cycles excluded. Exact native frame identities inherited; no global supplier claim.", + "member_sha256": { + "CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "CLIFFORD-RECIPES.json": "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731", + "CLIFFORD-REVIEW.json": "cb0e10a8b284f176526c17177e91186ce09aa3e88b4f6acc561051daa072b0d0", + "LOCAL-CHECKS.json": "2b8b1891a736598010232bfb26abc31973b265a53a2009a3fcfd9138b5ecadb4", + "LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "RESIDUAL-ADAPTERS.json": "383f40aadd00a4ac700dfd0d4c22d6c6c0be9a9863116e4d69c7acd23bafae0c", + "SCALAR-FRAME-AUDIT.json": "0e2a979aae1b948e1bee6c49c218f3ce7d7df00814b3f53b3d0866497510a28b" + }, + "nonunitary_escape": { + "formula": "I + J (Q-I) A, J=[R^T/56;0]", + "low_rank_group_law_pairs": 16, + "norm_squared_on_e224": "8/7" + }, + "paired_cycle_rejections": [ + [ + [ + 1, + 2, + 3, + 0, + 5, + 6, + 7, + 4 + ], + 0 + ], + [ + [ + 1, + 2, + 3, + 0, + 5, + 7, + 4, + 6 + ], + 0 + ], + [ + [ + 1, + 2, + 3, + 0, + 6, + 4, + 7, + 5 + ], + 0 + ], + [ + [ + 1, + 2, + 3, + 0, + 6, + 7, + 5, + 4 + ], + 0 + ], + [ + [ + 1, + 2, + 3, + 0, + 7, + 4, + 5, + 6 + ], + 0 + ], + [ + [ + 1, + 2, + 3, + 0, + 7, + 6, + 4, + 5 + ], + 0 + ], + [ + [ + 1, + 2, + 4, + 5, + 0, + 6, + 7, + 3 + ], + 0 + ], + [ + [ + 1, + 2, + 4, + 5, + 0, + 7, + 3, + 6 + ], + 0 + ], + [ + [ + 1, + 2, + 4, + 6, + 0, + 3, + 7, + 5 + ], + 0 + ], + [ + [ + 1, + 2, + 4, + 6, + 0, + 7, + 5, + 3 + ], + 0 + ], + [ + [ + 1, + 2, + 4, + 7, + 0, + 3, + 5, + 6 + ], + 0 + ], + [ + [ + 1, + 2, + 4, + 7, + 0, + 6, + 3, + 5 + ], + 0 + ], + [ + [ + 1, + 2, + 5, + 4, + 6, + 0, + 7, + 3 + ], + 0 + ], + [ + [ + 1, + 2, + 5, + 4, + 7, + 0, + 3, + 6 + ], + 0 + ], + [ + [ + 1, + 2, + 5, + 6, + 3, + 0, + 7, + 4 + ], + 0 + ], + [ + [ + 1, + 2, + 5, + 6, + 7, + 0, + 4, + 3 + ], + 0 + ], + [ + [ + 1, + 2, + 5, + 7, + 3, + 0, + 4, + 6 + ], + 0 + ], + [ + [ + 1, + 2, + 5, + 7, + 6, + 0, + 3, + 4 + ], + 0 + ], + [ + [ + 1, + 2, + 6, + 4, + 5, + 7, + 0, + 3 + ], + 0 + ], + [ + [ + 1, + 2, + 6, + 4, + 7, + 3, + 0, + 5 + ], + 0 + ], + [ + [ + 1, + 2, + 6, + 5, + 3, + 7, + 0, + 4 + ], + 0 + ], + [ + [ + 1, + 2, + 6, + 5, + 7, + 4, + 0, + 3 + ], + 0 + ], + [ + [ + 1, + 2, + 6, + 7, + 3, + 4, + 0, + 5 + ], + 0 + ], + [ + [ + 1, + 2, + 6, + 7, + 5, + 3, + 0, + 4 + ], + 0 + ], + [ + [ + 1, + 2, + 7, + 4, + 5, + 6, + 3, + 0 + ], + 0 + ], + [ + [ + 1, + 2, + 7, + 4, + 6, + 3, + 5, + 0 + ], + 0 + ], + [ + [ + 1, + 2, + 7, + 5, + 3, + 6, + 4, + 0 + ], + 0 + ], + [ + [ + 1, + 2, + 7, + 5, + 6, + 4, + 3, + 0 + ], + 0 + ], + [ + [ + 1, + 2, + 7, + 6, + 3, + 4, + 5, + 0 + ], + 0 + ], + [ + [ + 1, + 2, + 7, + 6, + 5, + 3, + 4, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 0, + 2, + 5, + 6, + 7, + 4 + ], + 0 + ], + [ + [ + 1, + 3, + 0, + 2, + 5, + 7, + 4, + 6 + ], + 0 + ], + [ + [ + 1, + 3, + 0, + 2, + 6, + 4, + 7, + 5 + ], + 0 + ], + [ + [ + 1, + 3, + 0, + 2, + 6, + 7, + 5, + 4 + ], + 0 + ], + [ + [ + 1, + 3, + 0, + 2, + 7, + 4, + 5, + 6 + ], + 0 + ], + [ + [ + 1, + 3, + 0, + 2, + 7, + 6, + 4, + 5 + ], + 0 + ], + [ + [ + 1, + 3, + 4, + 5, + 6, + 0, + 7, + 2 + ], + 0 + ], + [ + [ + 1, + 3, + 4, + 5, + 7, + 0, + 2, + 6 + ], + 0 + ], + [ + [ + 1, + 3, + 4, + 6, + 5, + 7, + 0, + 2 + ], + 0 + ], + [ + [ + 1, + 3, + 4, + 6, + 7, + 2, + 0, + 5 + ], + 0 + ], + [ + [ + 1, + 3, + 4, + 7, + 5, + 6, + 2, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 4, + 7, + 6, + 2, + 5, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 5, + 4, + 0, + 6, + 7, + 2 + ], + 0 + ], + [ + [ + 1, + 3, + 5, + 4, + 0, + 7, + 2, + 6 + ], + 0 + ], + [ + [ + 1, + 3, + 5, + 6, + 2, + 7, + 0, + 4 + ], + 0 + ], + [ + [ + 1, + 3, + 5, + 6, + 7, + 4, + 0, + 2 + ], + 0 + ], + [ + [ + 1, + 3, + 5, + 7, + 2, + 6, + 4, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 5, + 7, + 6, + 4, + 2, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 6, + 4, + 0, + 2, + 7, + 5 + ], + 0 + ], + [ + [ + 1, + 3, + 6, + 4, + 0, + 7, + 5, + 2 + ], + 0 + ], + [ + [ + 1, + 3, + 6, + 5, + 2, + 0, + 7, + 4 + ], + 0 + ], + [ + [ + 1, + 3, + 6, + 5, + 7, + 0, + 4, + 2 + ], + 0 + ], + [ + [ + 1, + 3, + 6, + 7, + 2, + 4, + 5, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 6, + 7, + 5, + 2, + 4, + 0 + ], + 0 + ], + [ + [ + 1, + 3, + 7, + 4, + 0, + 2, + 5, + 6 + ], + 0 + ], + [ + [ + 1, + 3, + 7, + 4, + 0, + 6, + 2, + 5 + ], + 0 + ], + [ + [ + 1, + 3, + 7, + 5, + 2, + 0, + 4, + 6 + ], + 0 + ], + [ + [ + 1, + 3, + 7, + 5, + 6, + 0, + 2, + 4 + ], + 0 + ], + [ + [ + 1, + 3, + 7, + 6, + 2, + 4, + 0, + 5 + ], + 0 + ], + [ + [ + 1, + 3, + 7, + 6, + 5, + 2, + 0, + 4 + ], + 0 + ], + [ + [ + 1, + 4, + 0, + 5, + 2, + 6, + 7, + 3 + ], + 0 + ], + [ + [ + 1, + 4, + 0, + 5, + 2, + 7, + 3, + 6 + ], + 0 + ], + [ + [ + 1, + 4, + 0, + 6, + 2, + 3, + 7, + 5 + ], + 0 + ], + [ + [ + 1, + 4, + 0, + 6, + 2, + 7, + 5, + 3 + ], + 0 + ], + [ + [ + 1, + 4, + 0, + 7, + 2, + 3, + 5, + 6 + ], + 0 + ], + [ + [ + 1, + 4, + 0, + 7, + 2, + 6, + 3, + 5 + ], + 0 + ], + [ + [ + 1, + 4, + 3, + 5, + 6, + 7, + 0, + 2 + ], + 0 + ], + [ + [ + 1, + 4, + 3, + 5, + 7, + 6, + 2, + 0 + ], + 0 + ], + [ + [ + 1, + 4, + 3, + 6, + 5, + 0, + 7, + 2 + ], + 0 + ], + [ + [ + 1, + 4, + 3, + 6, + 7, + 2, + 5, + 0 + ], + 0 + ], + [ + [ + 1, + 4, + 3, + 7, + 5, + 0, + 2, + 6 + ], + 0 + ], + [ + [ + 1, + 4, + 3, + 7, + 6, + 2, + 0, + 5 + ], + 0 + ], + [ + [ + 1, + 4, + 5, + 0, + 3, + 6, + 7, + 2 + ], + 0 + ], + [ + [ + 1, + 4, + 5, + 0, + 3, + 7, + 2, + 6 + ], + 0 + ], + [ + [ + 1, + 4, + 5, + 2, + 6, + 7, + 0, + 3 + ], + 0 + ], + [ + [ + 1, + 4, + 5, + 2, + 7, + 6, + 3, + 0 + ], + 0 + ], + [ + [ + 1, + 4, + 5, + 6, + 7, + 3, + 2, + 0 + ], + 0 + ], + [ + [ + 1, + 4, + 5, + 7, + 6, + 3, + 0, + 2 + ], + 0 + ], + [ + [ + 1, + 4, + 6, + 0, + 3, + 2, + 7, + 5 + ], + 0 + ], + [ + [ + 1, + 4, + 6, + 0, + 3, + 7, + 5, + 2 + ], + 0 + ], + [ + [ + 1, + 4, + 6, + 2, + 5, + 0, + 7, + 3 + ], + 0 + ], + [ + [ + 1, + 4, + 6, + 2, + 7, + 3, + 5, + 0 + ], + 0 + ], + [ + [ + 1, + 4, + 6, + 5, + 7, + 2, + 3, + 0 + ], + 0 + ], + [ + [ + 1, + 4, + 6, + 7, + 5, + 0, + 3, + 2 + ], + 0 + ], + [ + [ + 1, + 4, + 7, + 0, + 3, + 2, + 5, + 6 + ], + 0 + ], + [ + [ + 1, + 4, + 7, + 0, + 3, + 6, + 2, + 5 + ], + 0 + ], + [ + [ + 1, + 4, + 7, + 2, + 5, + 0, + 3, + 6 + ], + 0 + ], + [ + [ + 1, + 4, + 7, + 2, + 6, + 3, + 0, + 5 + ], + 0 + ], + [ + [ + 1, + 4, + 7, + 5, + 6, + 2, + 0, + 3 + ], + 0 + ], + [ + [ + 1, + 4, + 7, + 6, + 5, + 0, + 2, + 3 + ], + 0 + ], + [ + [ + 1, + 5, + 0, + 4, + 6, + 2, + 7, + 3 + ], + 0 + ], + [ + [ + 1, + 5, + 0, + 4, + 7, + 2, + 3, + 6 + ], + 0 + ], + [ + [ + 1, + 5, + 0, + 6, + 3, + 2, + 7, + 4 + ], + 0 + ], + [ + [ + 1, + 5, + 0, + 6, + 7, + 2, + 4, + 3 + ], + 0 + ], + [ + [ + 1, + 5, + 0, + 7, + 3, + 2, + 4, + 6 + ], + 0 + ], + [ + [ + 1, + 5, + 0, + 7, + 6, + 2, + 3, + 4 + ], + 0 + ], + [ + [ + 1, + 5, + 3, + 4, + 6, + 7, + 2, + 0 + ], + 0 + ], + [ + [ + 1, + 5, + 3, + 4, + 7, + 6, + 0, + 2 + ], + 0 + ], + [ + [ + 1, + 5, + 3, + 6, + 0, + 4, + 7, + 2 + ], + 0 + ], + [ + [ + 1, + 5, + 3, + 6, + 2, + 7, + 4, + 0 + ], + 0 + ], + [ + [ + 1, + 5, + 3, + 7, + 0, + 4, + 2, + 6 + ], + 0 + ], + [ + [ + 1, + 5, + 3, + 7, + 2, + 6, + 0, + 4 + ], + 0 + ], + [ + [ + 1, + 5, + 4, + 0, + 6, + 3, + 7, + 2 + ], + 0 + ], + [ + [ + 1, + 5, + 4, + 0, + 7, + 3, + 2, + 6 + ], + 0 + ], + [ + [ + 1, + 5, + 4, + 2, + 6, + 7, + 3, + 0 + ], + 0 + ], + [ + [ + 1, + 5, + 4, + 2, + 7, + 6, + 0, + 3 + ], + 0 + ], + [ + [ + 1, + 5, + 4, + 6, + 3, + 7, + 2, + 0 + ], + 0 + ], + [ + [ + 1, + 5, + 4, + 7, + 3, + 6, + 0, + 2 + ], + 0 + ], + [ + [ + 1, + 5, + 6, + 0, + 2, + 3, + 7, + 4 + ], + 0 + ], + [ + [ + 1, + 5, + 6, + 0, + 7, + 3, + 4, + 2 + ], + 0 + ], + [ + [ + 1, + 5, + 6, + 2, + 0, + 4, + 7, + 3 + ], + 0 + ], + [ + [ + 1, + 5, + 6, + 2, + 3, + 7, + 4, + 0 + ], + 0 + ], + [ + [ + 1, + 5, + 6, + 4, + 2, + 7, + 3, + 0 + ], + 0 + ], + [ + [ + 1, + 5, + 6, + 7, + 0, + 4, + 3, + 2 + ], + 0 + ], + [ + [ + 1, + 5, + 7, + 0, + 2, + 3, + 4, + 6 + ], + 0 + ], + [ + [ + 1, + 5, + 7, + 0, + 6, + 3, + 2, + 4 + ], + 0 + ], + [ + [ + 1, + 5, + 7, + 2, + 0, + 4, + 3, + 6 + ], + 0 + ], + [ + [ + 1, + 5, + 7, + 2, + 3, + 6, + 0, + 4 + ], + 0 + ], + [ + [ + 1, + 5, + 7, + 4, + 2, + 6, + 0, + 3 + ], + 0 + ], + [ + [ + 1, + 5, + 7, + 6, + 0, + 4, + 2, + 3 + ], + 0 + ], + [ + [ + 1, + 6, + 0, + 4, + 5, + 7, + 2, + 3 + ], + 0 + ], + [ + [ + 1, + 6, + 0, + 4, + 7, + 3, + 2, + 5 + ], + 0 + ], + [ + [ + 1, + 6, + 0, + 5, + 3, + 7, + 2, + 4 + ], + 0 + ], + [ + [ + 1, + 6, + 0, + 5, + 7, + 4, + 2, + 3 + ], + 0 + ], + [ + [ + 1, + 6, + 0, + 7, + 3, + 4, + 2, + 5 + ], + 0 + ], + [ + [ + 1, + 6, + 0, + 7, + 5, + 3, + 2, + 4 + ], + 0 + ], + [ + [ + 1, + 6, + 3, + 4, + 5, + 2, + 7, + 0 + ], + 0 + ], + [ + [ + 1, + 6, + 3, + 4, + 7, + 0, + 5, + 2 + ], + 0 + ], + [ + [ + 1, + 6, + 3, + 5, + 0, + 7, + 4, + 2 + ], + 0 + ], + [ + [ + 1, + 6, + 3, + 5, + 2, + 4, + 7, + 0 + ], + 0 + ], + [ + [ + 1, + 6, + 3, + 7, + 0, + 2, + 4, + 5 + ], + 0 + ], + [ + [ + 1, + 6, + 3, + 7, + 2, + 0, + 5, + 4 + ], + 0 + ], + [ + [ + 1, + 6, + 4, + 0, + 5, + 7, + 3, + 2 + ], + 0 + ], + [ + [ + 1, + 6, + 4, + 0, + 7, + 2, + 3, + 5 + ], + 0 + ], + [ + [ + 1, + 6, + 4, + 2, + 5, + 3, + 7, + 0 + ], + 0 + ], + [ + [ + 1, + 6, + 4, + 2, + 7, + 0, + 5, + 3 + ], + 0 + ], + [ + [ + 1, + 6, + 4, + 5, + 3, + 2, + 7, + 0 + ], + 0 + ], + [ + [ + 1, + 6, + 4, + 7, + 3, + 0, + 5, + 2 + ], + 0 + ], + [ + [ + 1, + 6, + 5, + 0, + 2, + 7, + 3, + 4 + ], + 0 + ], + [ + [ + 1, + 6, + 5, + 0, + 7, + 4, + 3, + 2 + ], + 0 + ], + [ + [ + 1, + 6, + 5, + 2, + 0, + 7, + 4, + 3 + ], + 0 + ], + [ + [ + 1, + 6, + 5, + 2, + 3, + 4, + 7, + 0 + ], + 0 + ], + [ + [ + 1, + 6, + 5, + 4, + 2, + 3, + 7, + 0 + ], + 0 + ], + [ + [ + 1, + 6, + 5, + 7, + 0, + 3, + 4, + 2 + ], + 0 + ], + [ + [ + 1, + 6, + 7, + 0, + 2, + 4, + 3, + 5 + ], + 0 + ], + [ + [ + 1, + 6, + 7, + 0, + 5, + 2, + 3, + 4 + ], + 0 + ], + [ + [ + 1, + 6, + 7, + 2, + 0, + 3, + 4, + 5 + ], + 0 + ], + [ + [ + 1, + 6, + 7, + 2, + 3, + 0, + 5, + 4 + ], + 0 + ], + [ + [ + 1, + 6, + 7, + 4, + 2, + 0, + 5, + 3 + ], + 0 + ], + [ + [ + 1, + 6, + 7, + 5, + 0, + 2, + 4, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 0, + 4, + 5, + 6, + 3, + 2 + ], + 0 + ], + [ + [ + 1, + 7, + 0, + 4, + 6, + 3, + 5, + 2 + ], + 0 + ], + [ + [ + 1, + 7, + 0, + 5, + 3, + 6, + 4, + 2 + ], + 0 + ], + [ + [ + 1, + 7, + 0, + 5, + 6, + 4, + 3, + 2 + ], + 0 + ], + [ + [ + 1, + 7, + 0, + 6, + 3, + 4, + 5, + 2 + ], + 0 + ], + [ + [ + 1, + 7, + 0, + 6, + 5, + 3, + 4, + 2 + ], + 0 + ], + [ + [ + 1, + 7, + 3, + 4, + 5, + 2, + 0, + 6 + ], + 0 + ], + [ + [ + 1, + 7, + 3, + 4, + 6, + 0, + 2, + 5 + ], + 0 + ], + [ + [ + 1, + 7, + 3, + 5, + 0, + 6, + 2, + 4 + ], + 0 + ], + [ + [ + 1, + 7, + 3, + 5, + 2, + 4, + 0, + 6 + ], + 0 + ], + [ + [ + 1, + 7, + 3, + 6, + 0, + 2, + 5, + 4 + ], + 0 + ], + [ + [ + 1, + 7, + 3, + 6, + 2, + 0, + 4, + 5 + ], + 0 + ], + [ + [ + 1, + 7, + 4, + 0, + 5, + 6, + 2, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 4, + 0, + 6, + 2, + 5, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 4, + 2, + 5, + 3, + 0, + 6 + ], + 0 + ], + [ + [ + 1, + 7, + 4, + 2, + 6, + 0, + 3, + 5 + ], + 0 + ], + [ + [ + 1, + 7, + 4, + 5, + 3, + 2, + 0, + 6 + ], + 0 + ], + [ + [ + 1, + 7, + 4, + 6, + 3, + 0, + 2, + 5 + ], + 0 + ], + [ + [ + 1, + 7, + 5, + 0, + 2, + 6, + 4, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 5, + 0, + 6, + 4, + 2, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 5, + 2, + 0, + 6, + 3, + 4 + ], + 0 + ], + [ + [ + 1, + 7, + 5, + 2, + 3, + 4, + 0, + 6 + ], + 0 + ], + [ + [ + 1, + 7, + 5, + 4, + 2, + 3, + 0, + 6 + ], + 0 + ], + [ + [ + 1, + 7, + 5, + 6, + 0, + 3, + 2, + 4 + ], + 0 + ], + [ + [ + 1, + 7, + 6, + 0, + 2, + 4, + 5, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 6, + 0, + 5, + 2, + 4, + 3 + ], + 0 + ], + [ + [ + 1, + 7, + 6, + 2, + 0, + 3, + 5, + 4 + ], + 0 + ], + [ + [ + 1, + 7, + 6, + 2, + 3, + 0, + 4, + 5 + ], + 0 + ], + [ + [ + 1, + 7, + 6, + 4, + 2, + 0, + 3, + 5 + ], + 0 + ], + [ + [ + 1, + 7, + 6, + 5, + 0, + 2, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 3, + 1, + 5, + 6, + 7, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 3, + 1, + 5, + 7, + 4, + 6 + ], + 0 + ], + [ + [ + 2, + 0, + 3, + 1, + 6, + 4, + 7, + 5 + ], + 0 + ], + [ + [ + 2, + 0, + 3, + 1, + 6, + 7, + 5, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 3, + 1, + 7, + 4, + 5, + 6 + ], + 0 + ], + [ + [ + 2, + 0, + 3, + 1, + 7, + 6, + 4, + 5 + ], + 0 + ], + [ + [ + 2, + 0, + 4, + 5, + 1, + 6, + 7, + 3 + ], + 0 + ], + [ + [ + 2, + 0, + 4, + 5, + 1, + 7, + 3, + 6 + ], + 0 + ], + [ + [ + 2, + 0, + 4, + 6, + 1, + 3, + 7, + 5 + ], + 0 + ], + [ + [ + 2, + 0, + 4, + 6, + 1, + 7, + 5, + 3 + ], + 0 + ], + [ + [ + 2, + 0, + 4, + 7, + 1, + 3, + 5, + 6 + ], + 0 + ], + [ + [ + 2, + 0, + 4, + 7, + 1, + 6, + 3, + 5 + ], + 0 + ], + [ + [ + 2, + 0, + 5, + 4, + 6, + 1, + 7, + 3 + ], + 0 + ], + [ + [ + 2, + 0, + 5, + 4, + 7, + 1, + 3, + 6 + ], + 0 + ], + [ + [ + 2, + 0, + 5, + 6, + 3, + 1, + 7, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 5, + 6, + 7, + 1, + 4, + 3 + ], + 0 + ], + [ + [ + 2, + 0, + 5, + 7, + 3, + 1, + 4, + 6 + ], + 0 + ], + [ + [ + 2, + 0, + 5, + 7, + 6, + 1, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 6, + 4, + 5, + 7, + 1, + 3 + ], + 0 + ], + [ + [ + 2, + 0, + 6, + 4, + 7, + 3, + 1, + 5 + ], + 0 + ], + [ + [ + 2, + 0, + 6, + 5, + 3, + 7, + 1, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 6, + 5, + 7, + 4, + 1, + 3 + ], + 0 + ], + [ + [ + 2, + 0, + 6, + 7, + 3, + 4, + 1, + 5 + ], + 0 + ], + [ + [ + 2, + 0, + 6, + 7, + 5, + 3, + 1, + 4 + ], + 0 + ], + [ + [ + 2, + 0, + 7, + 4, + 5, + 6, + 3, + 1 + ], + 0 + ], + [ + [ + 2, + 0, + 7, + 4, + 6, + 3, + 5, + 1 + ], + 0 + ], + [ + [ + 2, + 0, + 7, + 5, + 3, + 6, + 4, + 1 + ], + 0 + ], + [ + [ + 2, + 0, + 7, + 5, + 6, + 4, + 3, + 1 + ], + 0 + ], + [ + [ + 2, + 0, + 7, + 6, + 3, + 4, + 5, + 1 + ], + 0 + ], + [ + [ + 2, + 0, + 7, + 6, + 5, + 3, + 4, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 1, + 0, + 5, + 6, + 7, + 4 + ], + 0 + ], + [ + [ + 2, + 3, + 1, + 0, + 5, + 7, + 4, + 6 + ], + 0 + ], + [ + [ + 2, + 3, + 1, + 0, + 6, + 4, + 7, + 5 + ], + 0 + ], + [ + [ + 2, + 3, + 1, + 0, + 6, + 7, + 5, + 4 + ], + 0 + ], + [ + [ + 2, + 3, + 1, + 0, + 7, + 4, + 5, + 6 + ], + 0 + ], + [ + [ + 2, + 3, + 1, + 0, + 7, + 6, + 4, + 5 + ], + 0 + ], + [ + [ + 2, + 3, + 4, + 5, + 6, + 7, + 0, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 4, + 5, + 7, + 6, + 1, + 0 + ], + 0 + ], + [ + [ + 2, + 3, + 4, + 6, + 5, + 0, + 7, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 4, + 6, + 7, + 1, + 5, + 0 + ], + 0 + ], + [ + [ + 2, + 3, + 4, + 7, + 5, + 0, + 1, + 6 + ], + 0 + ], + [ + [ + 2, + 3, + 4, + 7, + 6, + 1, + 0, + 5 + ], + 0 + ], + [ + [ + 2, + 3, + 5, + 4, + 6, + 7, + 1, + 0 + ], + 0 + ], + [ + [ + 2, + 3, + 5, + 4, + 7, + 6, + 0, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 5, + 6, + 0, + 4, + 7, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 5, + 6, + 1, + 7, + 4, + 0 + ], + 0 + ], + [ + [ + 2, + 3, + 5, + 7, + 0, + 4, + 1, + 6 + ], + 0 + ], + [ + [ + 2, + 3, + 5, + 7, + 1, + 6, + 0, + 4 + ], + 0 + ], + [ + [ + 2, + 3, + 6, + 4, + 5, + 1, + 7, + 0 + ], + 0 + ], + [ + [ + 2, + 3, + 6, + 4, + 7, + 0, + 5, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 6, + 5, + 0, + 7, + 4, + 1 + ], + 0 + ], + [ + [ + 2, + 3, + 6, + 5, + 1, + 4, + 7, + 0 + ], + 0 + ], + [ + [ + 2, + 3, + 6, + 7, + 0, + 1, + 4, + 5 + ], + 0 + ], + [ + [ + 2, + 3, + 6, + 7, + 1, + 0, + 5, + 4 + ], + 0 + ], + [ + [ + 2, + 3, + 7, + 4, + 5, + 1, + 0, + 6 + ], + 0 + ], + [ + [ + 2, + 3, + 7, + 4, + 6, + 0, + 1, + 5 + ], + 0 + ], + [ + [ + 2, + 3, + 7, + 5, + 0, + 6, + 1, + 4 + ], + 0 + ], + [ + [ + 2, + 3, + 7, + 5, + 1, + 4, + 0, + 6 + ], + 0 + ], + [ + [ + 2, + 3, + 7, + 6, + 0, + 1, + 5, + 4 + ], + 0 + ], + [ + [ + 2, + 3, + 7, + 6, + 1, + 0, + 4, + 5 + ], + 0 + ], + [ + [ + 2, + 4, + 1, + 5, + 0, + 6, + 7, + 3 + ], + 0 + ], + [ + [ + 2, + 4, + 1, + 5, + 0, + 7, + 3, + 6 + ], + 0 + ], + [ + [ + 2, + 4, + 1, + 6, + 0, + 3, + 7, + 5 + ], + 0 + ], + [ + [ + 2, + 4, + 1, + 6, + 0, + 7, + 5, + 3 + ], + 0 + ], + [ + [ + 2, + 4, + 1, + 7, + 0, + 3, + 5, + 6 + ], + 0 + ], + [ + [ + 2, + 4, + 1, + 7, + 0, + 6, + 3, + 5 + ], + 0 + ], + [ + [ + 2, + 4, + 3, + 5, + 6, + 0, + 7, + 1 + ], + 0 + ], + [ + [ + 2, + 4, + 3, + 5, + 7, + 0, + 1, + 6 + ], + 0 + ], + [ + [ + 2, + 4, + 3, + 6, + 5, + 7, + 0, + 1 + ], + 0 + ], + [ + [ + 2, + 4, + 3, + 6, + 7, + 1, + 0, + 5 + ], + 0 + ], + [ + [ + 2, + 4, + 3, + 7, + 5, + 6, + 1, + 0 + ], + 0 + ], + [ + [ + 2, + 4, + 3, + 7, + 6, + 1, + 5, + 0 + ], + 0 + ], + [ + [ + 2, + 4, + 5, + 0, + 6, + 3, + 7, + 1 + ], + 0 + ], + [ + [ + 2, + 4, + 5, + 0, + 7, + 3, + 1, + 6 + ], + 0 + ], + [ + [ + 2, + 4, + 5, + 1, + 6, + 7, + 3, + 0 + ], + 0 + ], + [ + [ + 2, + 4, + 5, + 1, + 7, + 6, + 0, + 3 + ], + 0 + ], + [ + [ + 2, + 4, + 5, + 6, + 3, + 7, + 1, + 0 + ], + 0 + ], + [ + [ + 2, + 4, + 5, + 7, + 3, + 6, + 0, + 1 + ], + 0 + ], + [ + [ + 2, + 4, + 6, + 0, + 5, + 7, + 3, + 1 + ], + 0 + ], + [ + [ + 2, + 4, + 6, + 0, + 7, + 1, + 3, + 5 + ], + 0 + ], + [ + [ + 2, + 4, + 6, + 1, + 5, + 3, + 7, + 0 + ], + 0 + ], + [ + [ + 2, + 4, + 6, + 1, + 7, + 0, + 5, + 3 + ], + 0 + ], + [ + [ + 2, + 4, + 6, + 5, + 3, + 1, + 7, + 0 + ], + 0 + ], + [ + [ + 2, + 4, + 6, + 7, + 3, + 0, + 5, + 1 + ], + 0 + ], + [ + [ + 2, + 4, + 7, + 0, + 5, + 6, + 1, + 3 + ], + 0 + ], + [ + [ + 2, + 4, + 7, + 0, + 6, + 1, + 5, + 3 + ], + 0 + ], + [ + [ + 2, + 4, + 7, + 1, + 5, + 3, + 0, + 6 + ], + 0 + ], + [ + [ + 2, + 4, + 7, + 1, + 6, + 0, + 3, + 5 + ], + 0 + ], + [ + [ + 2, + 4, + 7, + 5, + 3, + 1, + 0, + 6 + ], + 0 + ], + [ + [ + 2, + 4, + 7, + 6, + 3, + 0, + 1, + 5 + ], + 0 + ], + [ + [ + 2, + 5, + 1, + 4, + 6, + 0, + 7, + 3 + ], + 0 + ], + [ + [ + 2, + 5, + 1, + 4, + 7, + 0, + 3, + 6 + ], + 0 + ], + [ + [ + 2, + 5, + 1, + 6, + 3, + 0, + 7, + 4 + ], + 0 + ], + [ + [ + 2, + 5, + 1, + 6, + 7, + 0, + 4, + 3 + ], + 0 + ], + [ + [ + 2, + 5, + 1, + 7, + 3, + 0, + 4, + 6 + ], + 0 + ], + [ + [ + 2, + 5, + 1, + 7, + 6, + 0, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 5, + 3, + 4, + 0, + 6, + 7, + 1 + ], + 0 + ], + [ + [ + 2, + 5, + 3, + 4, + 0, + 7, + 1, + 6 + ], + 0 + ], + [ + [ + 2, + 5, + 3, + 6, + 1, + 7, + 0, + 4 + ], + 0 + ], + [ + [ + 2, + 5, + 3, + 6, + 7, + 4, + 0, + 1 + ], + 0 + ], + [ + [ + 2, + 5, + 3, + 7, + 1, + 6, + 4, + 0 + ], + 0 + ], + [ + [ + 2, + 5, + 3, + 7, + 6, + 4, + 1, + 0 + ], + 0 + ], + [ + [ + 2, + 5, + 4, + 0, + 3, + 6, + 7, + 1 + ], + 0 + ], + [ + [ + 2, + 5, + 4, + 0, + 3, + 7, + 1, + 6 + ], + 0 + ], + [ + [ + 2, + 5, + 4, + 1, + 6, + 7, + 0, + 3 + ], + 0 + ], + [ + [ + 2, + 5, + 4, + 1, + 7, + 6, + 3, + 0 + ], + 0 + ], + [ + [ + 2, + 5, + 4, + 6, + 7, + 3, + 1, + 0 + ], + 0 + ], + [ + [ + 2, + 5, + 4, + 7, + 6, + 3, + 0, + 1 + ], + 0 + ], + [ + [ + 2, + 5, + 6, + 0, + 1, + 7, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 5, + 6, + 0, + 7, + 4, + 3, + 1 + ], + 0 + ], + [ + [ + 2, + 5, + 6, + 1, + 0, + 7, + 4, + 3 + ], + 0 + ], + [ + [ + 2, + 5, + 6, + 1, + 3, + 4, + 7, + 0 + ], + 0 + ], + [ + [ + 2, + 5, + 6, + 4, + 1, + 3, + 7, + 0 + ], + 0 + ], + [ + [ + 2, + 5, + 6, + 7, + 0, + 3, + 4, + 1 + ], + 0 + ], + [ + [ + 2, + 5, + 7, + 0, + 1, + 6, + 4, + 3 + ], + 0 + ], + [ + [ + 2, + 5, + 7, + 0, + 6, + 4, + 1, + 3 + ], + 0 + ], + [ + [ + 2, + 5, + 7, + 1, + 0, + 6, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 5, + 7, + 1, + 3, + 4, + 0, + 6 + ], + 0 + ], + [ + [ + 2, + 5, + 7, + 4, + 1, + 3, + 0, + 6 + ], + 0 + ], + [ + [ + 2, + 5, + 7, + 6, + 0, + 3, + 1, + 4 + ], + 0 + ], + [ + [ + 2, + 6, + 1, + 4, + 5, + 7, + 0, + 3 + ], + 0 + ], + [ + [ + 2, + 6, + 1, + 4, + 7, + 3, + 0, + 5 + ], + 0 + ], + [ + [ + 2, + 6, + 1, + 5, + 3, + 7, + 0, + 4 + ], + 0 + ], + [ + [ + 2, + 6, + 1, + 5, + 7, + 4, + 0, + 3 + ], + 0 + ], + [ + [ + 2, + 6, + 1, + 7, + 3, + 4, + 0, + 5 + ], + 0 + ], + [ + [ + 2, + 6, + 1, + 7, + 5, + 3, + 0, + 4 + ], + 0 + ], + [ + [ + 2, + 6, + 3, + 4, + 0, + 1, + 7, + 5 + ], + 0 + ], + [ + [ + 2, + 6, + 3, + 4, + 0, + 7, + 5, + 1 + ], + 0 + ], + [ + [ + 2, + 6, + 3, + 5, + 1, + 0, + 7, + 4 + ], + 0 + ], + [ + [ + 2, + 6, + 3, + 5, + 7, + 0, + 4, + 1 + ], + 0 + ], + [ + [ + 2, + 6, + 3, + 7, + 1, + 4, + 5, + 0 + ], + 0 + ], + [ + [ + 2, + 6, + 3, + 7, + 5, + 1, + 4, + 0 + ], + 0 + ], + [ + [ + 2, + 6, + 4, + 0, + 3, + 1, + 7, + 5 + ], + 0 + ], + [ + [ + 2, + 6, + 4, + 0, + 3, + 7, + 5, + 1 + ], + 0 + ], + [ + [ + 2, + 6, + 4, + 1, + 5, + 0, + 7, + 3 + ], + 0 + ], + [ + [ + 2, + 6, + 4, + 1, + 7, + 3, + 5, + 0 + ], + 0 + ], + [ + [ + 2, + 6, + 4, + 5, + 7, + 1, + 3, + 0 + ], + 0 + ], + [ + [ + 2, + 6, + 4, + 7, + 5, + 0, + 3, + 1 + ], + 0 + ], + [ + [ + 2, + 6, + 5, + 0, + 1, + 3, + 7, + 4 + ], + 0 + ], + [ + [ + 2, + 6, + 5, + 0, + 7, + 3, + 4, + 1 + ], + 0 + ], + [ + [ + 2, + 6, + 5, + 1, + 0, + 4, + 7, + 3 + ], + 0 + ], + [ + [ + 2, + 6, + 5, + 1, + 3, + 7, + 4, + 0 + ], + 0 + ], + [ + [ + 2, + 6, + 5, + 4, + 1, + 7, + 3, + 0 + ], + 0 + ], + [ + [ + 2, + 6, + 5, + 7, + 0, + 4, + 3, + 1 + ], + 0 + ], + [ + [ + 2, + 6, + 7, + 0, + 1, + 4, + 5, + 3 + ], + 0 + ], + [ + [ + 2, + 6, + 7, + 0, + 5, + 1, + 4, + 3 + ], + 0 + ], + [ + [ + 2, + 6, + 7, + 1, + 0, + 3, + 5, + 4 + ], + 0 + ], + [ + [ + 2, + 6, + 7, + 1, + 3, + 0, + 4, + 5 + ], + 0 + ], + [ + [ + 2, + 6, + 7, + 4, + 1, + 0, + 3, + 5 + ], + 0 + ], + [ + [ + 2, + 6, + 7, + 5, + 0, + 1, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 1, + 4, + 5, + 6, + 3, + 0 + ], + 0 + ], + [ + [ + 2, + 7, + 1, + 4, + 6, + 3, + 5, + 0 + ], + 0 + ], + [ + [ + 2, + 7, + 1, + 5, + 3, + 6, + 4, + 0 + ], + 0 + ], + [ + [ + 2, + 7, + 1, + 5, + 6, + 4, + 3, + 0 + ], + 0 + ], + [ + [ + 2, + 7, + 1, + 6, + 3, + 4, + 5, + 0 + ], + 0 + ], + [ + [ + 2, + 7, + 1, + 6, + 5, + 3, + 4, + 0 + ], + 0 + ], + [ + [ + 2, + 7, + 3, + 4, + 0, + 1, + 5, + 6 + ], + 0 + ], + [ + [ + 2, + 7, + 3, + 4, + 0, + 6, + 1, + 5 + ], + 0 + ], + [ + [ + 2, + 7, + 3, + 5, + 1, + 0, + 4, + 6 + ], + 0 + ], + [ + [ + 2, + 7, + 3, + 5, + 6, + 0, + 1, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 3, + 6, + 1, + 4, + 0, + 5 + ], + 0 + ], + [ + [ + 2, + 7, + 3, + 6, + 5, + 1, + 0, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 4, + 0, + 3, + 1, + 5, + 6 + ], + 0 + ], + [ + [ + 2, + 7, + 4, + 0, + 3, + 6, + 1, + 5 + ], + 0 + ], + [ + [ + 2, + 7, + 4, + 1, + 5, + 0, + 3, + 6 + ], + 0 + ], + [ + [ + 2, + 7, + 4, + 1, + 6, + 3, + 0, + 5 + ], + 0 + ], + [ + [ + 2, + 7, + 4, + 5, + 6, + 1, + 0, + 3 + ], + 0 + ], + [ + [ + 2, + 7, + 4, + 6, + 5, + 0, + 1, + 3 + ], + 0 + ], + [ + [ + 2, + 7, + 5, + 0, + 1, + 3, + 4, + 6 + ], + 0 + ], + [ + [ + 2, + 7, + 5, + 0, + 6, + 3, + 1, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 5, + 1, + 0, + 4, + 3, + 6 + ], + 0 + ], + [ + [ + 2, + 7, + 5, + 1, + 3, + 6, + 0, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 5, + 4, + 1, + 6, + 0, + 3 + ], + 0 + ], + [ + [ + 2, + 7, + 5, + 6, + 0, + 4, + 1, + 3 + ], + 0 + ], + [ + [ + 2, + 7, + 6, + 0, + 1, + 4, + 3, + 5 + ], + 0 + ], + [ + [ + 2, + 7, + 6, + 0, + 5, + 1, + 3, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 6, + 1, + 0, + 3, + 4, + 5 + ], + 0 + ], + [ + [ + 2, + 7, + 6, + 1, + 3, + 0, + 5, + 4 + ], + 0 + ], + [ + [ + 2, + 7, + 6, + 4, + 1, + 0, + 5, + 3 + ], + 0 + ], + [ + [ + 2, + 7, + 6, + 5, + 0, + 1, + 4, + 3 + ], + 0 + ], + [ + [ + 3, + 0, + 1, + 2, + 5, + 6, + 7, + 4 + ], + 0 + ], + [ + [ + 3, + 0, + 1, + 2, + 5, + 7, + 4, + 6 + ], + 0 + ], + [ + [ + 3, + 0, + 1, + 2, + 6, + 4, + 7, + 5 + ], + 0 + ], + [ + [ + 3, + 0, + 1, + 2, + 6, + 7, + 5, + 4 + ], + 0 + ], + [ + [ + 3, + 0, + 1, + 2, + 7, + 4, + 5, + 6 + ], + 0 + ], + [ + [ + 3, + 0, + 1, + 2, + 7, + 6, + 4, + 5 + ], + 0 + ], + [ + [ + 3, + 0, + 4, + 5, + 6, + 1, + 7, + 2 + ], + 0 + ], + [ + [ + 3, + 0, + 4, + 5, + 7, + 1, + 2, + 6 + ], + 0 + ], + [ + [ + 3, + 0, + 4, + 6, + 5, + 7, + 1, + 2 + ], + 0 + ], + [ + [ + 3, + 0, + 4, + 6, + 7, + 2, + 1, + 5 + ], + 0 + ], + [ + [ + 3, + 0, + 4, + 7, + 5, + 6, + 2, + 1 + ], + 0 + ], + [ + [ + 3, + 0, + 4, + 7, + 6, + 2, + 5, + 1 + ], + 0 + ], + [ + [ + 3, + 0, + 5, + 4, + 1, + 6, + 7, + 2 + ], + 0 + ], + [ + [ + 3, + 0, + 5, + 4, + 1, + 7, + 2, + 6 + ], + 0 + ], + [ + [ + 3, + 0, + 5, + 6, + 2, + 7, + 1, + 4 + ], + 0 + ], + [ + [ + 3, + 0, + 5, + 6, + 7, + 4, + 1, + 2 + ], + 0 + ], + [ + [ + 3, + 0, + 5, + 7, + 2, + 6, + 4, + 1 + ], + 0 + ], + [ + [ + 3, + 0, + 5, + 7, + 6, + 4, + 2, + 1 + ], + 0 + ], + [ + [ + 3, + 0, + 6, + 4, + 1, + 2, + 7, + 5 + ], + 0 + ], + [ + [ + 3, + 0, + 6, + 4, + 1, + 7, + 5, + 2 + ], + 0 + ], + [ + [ + 3, + 0, + 6, + 5, + 2, + 1, + 7, + 4 + ], + 0 + ], + [ + [ + 3, + 0, + 6, + 5, + 7, + 1, + 4, + 2 + ], + 0 + ], + [ + [ + 3, + 0, + 6, + 7, + 2, + 4, + 5, + 1 + ], + 0 + ], + [ + [ + 3, + 0, + 6, + 7, + 5, + 2, + 4, + 1 + ], + 0 + ], + [ + [ + 3, + 0, + 7, + 4, + 1, + 2, + 5, + 6 + ], + 0 + ], + [ + [ + 3, + 0, + 7, + 4, + 1, + 6, + 2, + 5 + ], + 0 + ], + [ + [ + 3, + 0, + 7, + 5, + 2, + 1, + 4, + 6 + ], + 0 + ], + [ + [ + 3, + 0, + 7, + 5, + 6, + 1, + 2, + 4 + ], + 0 + ], + [ + [ + 3, + 0, + 7, + 6, + 2, + 4, + 1, + 5 + ], + 0 + ], + [ + [ + 3, + 0, + 7, + 6, + 5, + 2, + 1, + 4 + ], + 0 + ], + [ + [ + 3, + 2, + 0, + 1, + 5, + 6, + 7, + 4 + ], + 0 + ], + [ + [ + 3, + 2, + 0, + 1, + 5, + 7, + 4, + 6 + ], + 0 + ], + [ + [ + 3, + 2, + 0, + 1, + 6, + 4, + 7, + 5 + ], + 0 + ], + [ + [ + 3, + 2, + 0, + 1, + 6, + 7, + 5, + 4 + ], + 0 + ], + [ + [ + 3, + 2, + 0, + 1, + 7, + 4, + 5, + 6 + ], + 0 + ], + [ + [ + 3, + 2, + 0, + 1, + 7, + 6, + 4, + 5 + ], + 0 + ], + [ + [ + 3, + 2, + 4, + 5, + 6, + 7, + 1, + 0 + ], + 0 + ], + [ + [ + 3, + 2, + 4, + 5, + 7, + 6, + 0, + 1 + ], + 0 + ], + [ + [ + 3, + 2, + 4, + 6, + 5, + 1, + 7, + 0 + ], + 0 + ], + [ + [ + 3, + 2, + 4, + 6, + 7, + 0, + 5, + 1 + ], + 0 + ], + [ + [ + 3, + 2, + 4, + 7, + 5, + 1, + 0, + 6 + ], + 0 + ], + [ + [ + 3, + 2, + 4, + 7, + 6, + 0, + 1, + 5 + ], + 0 + ], + [ + [ + 3, + 2, + 5, + 4, + 6, + 7, + 0, + 1 + ], + 0 + ], + [ + [ + 3, + 2, + 5, + 4, + 7, + 6, + 1, + 0 + ], + 0 + ], + [ + [ + 3, + 2, + 5, + 6, + 0, + 7, + 4, + 1 + ], + 0 + ], + [ + [ + 3, + 2, + 5, + 6, + 1, + 4, + 7, + 0 + ], + 0 + ], + [ + [ + 3, + 2, + 5, + 7, + 0, + 6, + 1, + 4 + ], + 0 + ], + [ + [ + 3, + 2, + 5, + 7, + 1, + 4, + 0, + 6 + ], + 0 + ], + [ + [ + 3, + 2, + 6, + 4, + 5, + 0, + 7, + 1 + ], + 0 + ], + [ + [ + 3, + 2, + 6, + 4, + 7, + 1, + 5, + 0 + ], + 0 + ], + [ + [ + 3, + 2, + 6, + 5, + 0, + 4, + 7, + 1 + ], + 0 + ], + [ + [ + 3, + 2, + 6, + 5, + 1, + 7, + 4, + 0 + ], + 0 + ], + [ + [ + 3, + 2, + 6, + 7, + 0, + 1, + 5, + 4 + ], + 0 + ], + [ + [ + 3, + 2, + 6, + 7, + 1, + 0, + 4, + 5 + ], + 0 + ], + [ + [ + 3, + 2, + 7, + 4, + 5, + 0, + 1, + 6 + ], + 0 + ], + [ + [ + 3, + 2, + 7, + 4, + 6, + 1, + 0, + 5 + ], + 0 + ], + [ + [ + 3, + 2, + 7, + 5, + 0, + 4, + 1, + 6 + ], + 0 + ], + [ + [ + 3, + 2, + 7, + 5, + 1, + 6, + 0, + 4 + ], + 0 + ], + [ + [ + 3, + 2, + 7, + 6, + 0, + 1, + 4, + 5 + ], + 0 + ], + [ + [ + 3, + 2, + 7, + 6, + 1, + 0, + 5, + 4 + ], + 0 + ], + [ + [ + 3, + 4, + 0, + 5, + 6, + 2, + 7, + 1 + ], + 0 + ], + [ + [ + 3, + 4, + 0, + 5, + 7, + 2, + 1, + 6 + ], + 0 + ], + [ + [ + 3, + 4, + 0, + 6, + 5, + 7, + 2, + 1 + ], + 0 + ], + [ + [ + 3, + 4, + 0, + 6, + 7, + 1, + 2, + 5 + ], + 0 + ], + [ + [ + 3, + 4, + 0, + 7, + 5, + 6, + 1, + 2 + ], + 0 + ], + [ + [ + 3, + 4, + 0, + 7, + 6, + 1, + 5, + 2 + ], + 0 + ], + [ + [ + 3, + 4, + 1, + 5, + 6, + 7, + 2, + 0 + ], + 0 + ], + [ + [ + 3, + 4, + 1, + 5, + 7, + 6, + 0, + 2 + ], + 0 + ], + [ + [ + 3, + 4, + 1, + 6, + 5, + 2, + 7, + 0 + ], + 0 + ], + [ + [ + 3, + 4, + 1, + 6, + 7, + 0, + 5, + 2 + ], + 0 + ], + [ + [ + 3, + 4, + 1, + 7, + 5, + 2, + 0, + 6 + ], + 0 + ], + [ + [ + 3, + 4, + 1, + 7, + 6, + 0, + 2, + 5 + ], + 0 + ], + [ + [ + 3, + 4, + 5, + 1, + 0, + 6, + 7, + 2 + ], + 0 + ], + [ + [ + 3, + 4, + 5, + 1, + 0, + 7, + 2, + 6 + ], + 0 + ], + [ + [ + 3, + 4, + 5, + 2, + 6, + 0, + 7, + 1 + ], + 0 + ], + [ + [ + 3, + 4, + 5, + 2, + 7, + 0, + 1, + 6 + ], + 0 + ], + [ + [ + 3, + 4, + 5, + 6, + 2, + 1, + 7, + 0 + ], + 0 + ], + [ + [ + 3, + 4, + 5, + 7, + 2, + 1, + 0, + 6 + ], + 0 + ], + [ + [ + 3, + 4, + 6, + 1, + 0, + 2, + 7, + 5 + ], + 0 + ], + [ + [ + 3, + 4, + 6, + 1, + 0, + 7, + 5, + 2 + ], + 0 + ], + [ + [ + 3, + 4, + 6, + 2, + 5, + 7, + 0, + 1 + ], + 0 + ], + [ + [ + 3, + 4, + 6, + 2, + 7, + 1, + 0, + 5 + ], + 0 + ], + [ + [ + 3, + 4, + 6, + 5, + 2, + 7, + 1, + 0 + ], + 0 + ], + [ + [ + 3, + 4, + 6, + 7, + 2, + 0, + 1, + 5 + ], + 0 + ], + [ + [ + 3, + 4, + 7, + 1, + 0, + 2, + 5, + 6 + ], + 0 + ], + [ + [ + 3, + 4, + 7, + 1, + 0, + 6, + 2, + 5 + ], + 0 + ], + [ + [ + 3, + 4, + 7, + 2, + 5, + 6, + 1, + 0 + ], + 0 + ], + [ + [ + 3, + 4, + 7, + 2, + 6, + 1, + 5, + 0 + ], + 0 + ], + [ + [ + 3, + 4, + 7, + 5, + 2, + 6, + 0, + 1 + ], + 0 + ], + [ + [ + 3, + 4, + 7, + 6, + 2, + 0, + 5, + 1 + ], + 0 + ], + [ + [ + 3, + 5, + 0, + 4, + 2, + 6, + 7, + 1 + ], + 0 + ], + [ + [ + 3, + 5, + 0, + 4, + 2, + 7, + 1, + 6 + ], + 0 + ], + [ + [ + 3, + 5, + 0, + 6, + 1, + 7, + 2, + 4 + ], + 0 + ], + [ + [ + 3, + 5, + 0, + 6, + 7, + 4, + 2, + 1 + ], + 0 + ], + [ + [ + 3, + 5, + 0, + 7, + 1, + 6, + 4, + 2 + ], + 0 + ], + [ + [ + 3, + 5, + 0, + 7, + 6, + 4, + 1, + 2 + ], + 0 + ], + [ + [ + 3, + 5, + 1, + 4, + 6, + 7, + 0, + 2 + ], + 0 + ], + [ + [ + 3, + 5, + 1, + 4, + 7, + 6, + 2, + 0 + ], + 0 + ], + [ + [ + 3, + 5, + 1, + 6, + 0, + 7, + 4, + 2 + ], + 0 + ], + [ + [ + 3, + 5, + 1, + 6, + 2, + 4, + 7, + 0 + ], + 0 + ], + [ + [ + 3, + 5, + 1, + 7, + 0, + 6, + 2, + 4 + ], + 0 + ], + [ + [ + 3, + 5, + 1, + 7, + 2, + 4, + 0, + 6 + ], + 0 + ], + [ + [ + 3, + 5, + 4, + 1, + 6, + 0, + 7, + 2 + ], + 0 + ], + [ + [ + 3, + 5, + 4, + 1, + 7, + 0, + 2, + 6 + ], + 0 + ], + [ + [ + 3, + 5, + 4, + 2, + 0, + 6, + 7, + 1 + ], + 0 + ], + [ + [ + 3, + 5, + 4, + 2, + 0, + 7, + 1, + 6 + ], + 0 + ], + [ + [ + 3, + 5, + 4, + 6, + 1, + 2, + 7, + 0 + ], + 0 + ], + [ + [ + 3, + 5, + 4, + 7, + 1, + 2, + 0, + 6 + ], + 0 + ], + [ + [ + 3, + 5, + 6, + 1, + 2, + 0, + 7, + 4 + ], + 0 + ], + [ + [ + 3, + 5, + 6, + 1, + 7, + 0, + 4, + 2 + ], + 0 + ], + [ + [ + 3, + 5, + 6, + 2, + 1, + 7, + 0, + 4 + ], + 0 + ], + [ + [ + 3, + 5, + 6, + 2, + 7, + 4, + 0, + 1 + ], + 0 + ], + [ + [ + 3, + 5, + 6, + 4, + 7, + 2, + 1, + 0 + ], + 0 + ], + [ + [ + 3, + 5, + 6, + 7, + 0, + 2, + 1, + 4 + ], + 0 + ], + [ + [ + 3, + 5, + 7, + 1, + 2, + 0, + 4, + 6 + ], + 0 + ], + [ + [ + 3, + 5, + 7, + 1, + 6, + 0, + 2, + 4 + ], + 0 + ], + [ + [ + 3, + 5, + 7, + 2, + 1, + 6, + 4, + 0 + ], + 0 + ], + [ + [ + 3, + 5, + 7, + 2, + 6, + 4, + 1, + 0 + ], + 0 + ], + [ + [ + 3, + 5, + 7, + 4, + 6, + 2, + 0, + 1 + ], + 0 + ], + [ + [ + 3, + 5, + 7, + 6, + 0, + 2, + 4, + 1 + ], + 0 + ], + [ + [ + 3, + 6, + 0, + 4, + 2, + 1, + 7, + 5 + ], + 0 + ], + [ + [ + 3, + 6, + 0, + 4, + 2, + 7, + 5, + 1 + ], + 0 + ], + [ + [ + 3, + 6, + 0, + 5, + 1, + 2, + 7, + 4 + ], + 0 + ], + [ + [ + 3, + 6, + 0, + 5, + 7, + 2, + 4, + 1 + ], + 0 + ], + [ + [ + 3, + 6, + 0, + 7, + 1, + 4, + 5, + 2 + ], + 0 + ], + [ + [ + 3, + 6, + 0, + 7, + 5, + 1, + 4, + 2 + ], + 0 + ], + [ + [ + 3, + 6, + 1, + 4, + 5, + 0, + 7, + 2 + ], + 0 + ], + [ + [ + 3, + 6, + 1, + 4, + 7, + 2, + 5, + 0 + ], + 0 + ], + [ + [ + 3, + 6, + 1, + 5, + 0, + 4, + 7, + 2 + ], + 0 + ], + [ + [ + 3, + 6, + 1, + 5, + 2, + 7, + 4, + 0 + ], + 0 + ], + [ + [ + 3, + 6, + 1, + 7, + 0, + 2, + 5, + 4 + ], + 0 + ], + [ + [ + 3, + 6, + 1, + 7, + 2, + 0, + 4, + 5 + ], + 0 + ], + [ + [ + 3, + 6, + 4, + 1, + 5, + 7, + 0, + 2 + ], + 0 + ], + [ + [ + 3, + 6, + 4, + 1, + 7, + 2, + 0, + 5 + ], + 0 + ], + [ + [ + 3, + 6, + 4, + 2, + 0, + 1, + 7, + 5 + ], + 0 + ], + [ + [ + 3, + 6, + 4, + 2, + 0, + 7, + 5, + 1 + ], + 0 + ], + [ + [ + 3, + 6, + 4, + 5, + 1, + 7, + 2, + 0 + ], + 0 + ], + [ + [ + 3, + 6, + 4, + 7, + 1, + 0, + 2, + 5 + ], + 0 + ], + [ + [ + 3, + 6, + 5, + 1, + 2, + 7, + 0, + 4 + ], + 0 + ], + [ + [ + 3, + 6, + 5, + 1, + 7, + 4, + 0, + 2 + ], + 0 + ], + [ + [ + 3, + 6, + 5, + 2, + 1, + 0, + 7, + 4 + ], + 0 + ], + [ + [ + 3, + 6, + 5, + 2, + 7, + 0, + 4, + 1 + ], + 0 + ], + [ + [ + 3, + 6, + 5, + 4, + 7, + 1, + 2, + 0 + ], + 0 + ], + [ + [ + 3, + 6, + 5, + 7, + 0, + 1, + 2, + 4 + ], + 0 + ], + [ + [ + 3, + 6, + 7, + 1, + 2, + 4, + 0, + 5 + ], + 0 + ], + [ + [ + 3, + 6, + 7, + 1, + 5, + 2, + 0, + 4 + ], + 0 + ], + [ + [ + 3, + 6, + 7, + 2, + 1, + 4, + 5, + 0 + ], + 0 + ], + [ + [ + 3, + 6, + 7, + 2, + 5, + 1, + 4, + 0 + ], + 0 + ], + [ + [ + 3, + 6, + 7, + 4, + 5, + 0, + 2, + 1 + ], + 0 + ], + [ + [ + 3, + 6, + 7, + 5, + 0, + 4, + 2, + 1 + ], + 0 + ], + [ + [ + 3, + 7, + 0, + 4, + 2, + 1, + 5, + 6 + ], + 0 + ], + [ + [ + 3, + 7, + 0, + 4, + 2, + 6, + 1, + 5 + ], + 0 + ], + [ + [ + 3, + 7, + 0, + 5, + 1, + 2, + 4, + 6 + ], + 0 + ], + [ + [ + 3, + 7, + 0, + 5, + 6, + 2, + 1, + 4 + ], + 0 + ], + [ + [ + 3, + 7, + 0, + 6, + 1, + 4, + 2, + 5 + ], + 0 + ], + [ + [ + 3, + 7, + 0, + 6, + 5, + 1, + 2, + 4 + ], + 0 + ], + [ + [ + 3, + 7, + 1, + 4, + 5, + 0, + 2, + 6 + ], + 0 + ], + [ + [ + 3, + 7, + 1, + 4, + 6, + 2, + 0, + 5 + ], + 0 + ], + [ + [ + 3, + 7, + 1, + 5, + 0, + 4, + 2, + 6 + ], + 0 + ], + [ + [ + 3, + 7, + 1, + 5, + 2, + 6, + 0, + 4 + ], + 0 + ], + [ + [ + 3, + 7, + 1, + 6, + 0, + 2, + 4, + 5 + ], + 0 + ], + [ + [ + 3, + 7, + 1, + 6, + 2, + 0, + 5, + 4 + ], + 0 + ], + [ + [ + 3, + 7, + 4, + 1, + 5, + 6, + 2, + 0 + ], + 0 + ], + [ + [ + 3, + 7, + 4, + 1, + 6, + 2, + 5, + 0 + ], + 0 + ], + [ + [ + 3, + 7, + 4, + 2, + 0, + 1, + 5, + 6 + ], + 0 + ], + [ + [ + 3, + 7, + 4, + 2, + 0, + 6, + 1, + 5 + ], + 0 + ], + [ + [ + 3, + 7, + 4, + 5, + 1, + 6, + 0, + 2 + ], + 0 + ], + [ + [ + 3, + 7, + 4, + 6, + 1, + 0, + 5, + 2 + ], + 0 + ], + [ + [ + 3, + 7, + 5, + 1, + 2, + 6, + 4, + 0 + ], + 0 + ], + [ + [ + 3, + 7, + 5, + 1, + 6, + 4, + 2, + 0 + ], + 0 + ], + [ + [ + 3, + 7, + 5, + 2, + 1, + 0, + 4, + 6 + ], + 0 + ], + [ + [ + 3, + 7, + 5, + 2, + 6, + 0, + 1, + 4 + ], + 0 + ], + [ + [ + 3, + 7, + 5, + 4, + 6, + 1, + 0, + 2 + ], + 0 + ], + [ + [ + 3, + 7, + 5, + 6, + 0, + 1, + 4, + 2 + ], + 0 + ], + [ + [ + 3, + 7, + 6, + 1, + 2, + 4, + 5, + 0 + ], + 0 + ], + [ + [ + 3, + 7, + 6, + 1, + 5, + 2, + 4, + 0 + ], + 0 + ], + [ + [ + 3, + 7, + 6, + 2, + 1, + 4, + 0, + 5 + ], + 0 + ], + [ + [ + 3, + 7, + 6, + 2, + 5, + 1, + 0, + 4 + ], + 0 + ], + [ + [ + 3, + 7, + 6, + 4, + 5, + 0, + 1, + 2 + ], + 0 + ], + [ + [ + 3, + 7, + 6, + 5, + 0, + 4, + 1, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 1, + 5, + 2, + 6, + 7, + 3 + ], + 0 + ], + [ + [ + 4, + 0, + 1, + 5, + 2, + 7, + 3, + 6 + ], + 0 + ], + [ + [ + 4, + 0, + 1, + 6, + 2, + 3, + 7, + 5 + ], + 0 + ], + [ + [ + 4, + 0, + 1, + 6, + 2, + 7, + 5, + 3 + ], + 0 + ], + [ + [ + 4, + 0, + 1, + 7, + 2, + 3, + 5, + 6 + ], + 0 + ], + [ + [ + 4, + 0, + 1, + 7, + 2, + 6, + 3, + 5 + ], + 0 + ], + [ + [ + 4, + 0, + 3, + 5, + 6, + 7, + 1, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 3, + 5, + 7, + 6, + 2, + 1 + ], + 0 + ], + [ + [ + 4, + 0, + 3, + 6, + 5, + 1, + 7, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 3, + 6, + 7, + 2, + 5, + 1 + ], + 0 + ], + [ + [ + 4, + 0, + 3, + 7, + 5, + 1, + 2, + 6 + ], + 0 + ], + [ + [ + 4, + 0, + 3, + 7, + 6, + 2, + 1, + 5 + ], + 0 + ], + [ + [ + 4, + 0, + 5, + 1, + 3, + 6, + 7, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 5, + 1, + 3, + 7, + 2, + 6 + ], + 0 + ], + [ + [ + 4, + 0, + 5, + 2, + 6, + 7, + 1, + 3 + ], + 0 + ], + [ + [ + 4, + 0, + 5, + 2, + 7, + 6, + 3, + 1 + ], + 0 + ], + [ + [ + 4, + 0, + 5, + 6, + 7, + 3, + 2, + 1 + ], + 0 + ], + [ + [ + 4, + 0, + 5, + 7, + 6, + 3, + 1, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 6, + 1, + 3, + 2, + 7, + 5 + ], + 0 + ], + [ + [ + 4, + 0, + 6, + 1, + 3, + 7, + 5, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 6, + 2, + 5, + 1, + 7, + 3 + ], + 0 + ], + [ + [ + 4, + 0, + 6, + 2, + 7, + 3, + 5, + 1 + ], + 0 + ], + [ + [ + 4, + 0, + 6, + 5, + 7, + 2, + 3, + 1 + ], + 0 + ], + [ + [ + 4, + 0, + 6, + 7, + 5, + 1, + 3, + 2 + ], + 0 + ], + [ + [ + 4, + 0, + 7, + 1, + 3, + 2, + 5, + 6 + ], + 0 + ], + [ + [ + 4, + 0, + 7, + 1, + 3, + 6, + 2, + 5 + ], + 0 + ], + [ + [ + 4, + 0, + 7, + 2, + 5, + 1, + 3, + 6 + ], + 0 + ], + [ + [ + 4, + 0, + 7, + 2, + 6, + 3, + 1, + 5 + ], + 0 + ], + [ + [ + 4, + 0, + 7, + 5, + 6, + 2, + 1, + 3 + ], + 0 + ], + [ + [ + 4, + 0, + 7, + 6, + 5, + 1, + 2, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 0, + 5, + 1, + 6, + 7, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 0, + 5, + 1, + 7, + 3, + 6 + ], + 0 + ], + [ + [ + 4, + 2, + 0, + 6, + 1, + 3, + 7, + 5 + ], + 0 + ], + [ + [ + 4, + 2, + 0, + 6, + 1, + 7, + 5, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 0, + 7, + 1, + 3, + 5, + 6 + ], + 0 + ], + [ + [ + 4, + 2, + 0, + 7, + 1, + 6, + 3, + 5 + ], + 0 + ], + [ + [ + 4, + 2, + 3, + 5, + 6, + 1, + 7, + 0 + ], + 0 + ], + [ + [ + 4, + 2, + 3, + 5, + 7, + 1, + 0, + 6 + ], + 0 + ], + [ + [ + 4, + 2, + 3, + 6, + 5, + 7, + 1, + 0 + ], + 0 + ], + [ + [ + 4, + 2, + 3, + 6, + 7, + 0, + 1, + 5 + ], + 0 + ], + [ + [ + 4, + 2, + 3, + 7, + 5, + 6, + 0, + 1 + ], + 0 + ], + [ + [ + 4, + 2, + 3, + 7, + 6, + 0, + 5, + 1 + ], + 0 + ], + [ + [ + 4, + 2, + 5, + 0, + 6, + 7, + 3, + 1 + ], + 0 + ], + [ + [ + 4, + 2, + 5, + 0, + 7, + 6, + 1, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 5, + 1, + 6, + 3, + 7, + 0 + ], + 0 + ], + [ + [ + 4, + 2, + 5, + 1, + 7, + 3, + 0, + 6 + ], + 0 + ], + [ + [ + 4, + 2, + 5, + 6, + 3, + 7, + 0, + 1 + ], + 0 + ], + [ + [ + 4, + 2, + 5, + 7, + 3, + 6, + 1, + 0 + ], + 0 + ], + [ + [ + 4, + 2, + 6, + 0, + 5, + 3, + 7, + 1 + ], + 0 + ], + [ + [ + 4, + 2, + 6, + 0, + 7, + 1, + 5, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 6, + 1, + 5, + 7, + 3, + 0 + ], + 0 + ], + [ + [ + 4, + 2, + 6, + 1, + 7, + 0, + 3, + 5 + ], + 0 + ], + [ + [ + 4, + 2, + 6, + 5, + 3, + 0, + 7, + 1 + ], + 0 + ], + [ + [ + 4, + 2, + 6, + 7, + 3, + 1, + 5, + 0 + ], + 0 + ], + [ + [ + 4, + 2, + 7, + 0, + 5, + 3, + 1, + 6 + ], + 0 + ], + [ + [ + 4, + 2, + 7, + 0, + 6, + 1, + 3, + 5 + ], + 0 + ], + [ + [ + 4, + 2, + 7, + 1, + 5, + 6, + 0, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 7, + 1, + 6, + 0, + 5, + 3 + ], + 0 + ], + [ + [ + 4, + 2, + 7, + 5, + 3, + 0, + 1, + 6 + ], + 0 + ], + [ + [ + 4, + 2, + 7, + 6, + 3, + 1, + 0, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 0, + 5, + 6, + 7, + 2, + 1 + ], + 0 + ], + [ + [ + 4, + 3, + 0, + 5, + 7, + 6, + 1, + 2 + ], + 0 + ], + [ + [ + 4, + 3, + 0, + 6, + 5, + 2, + 7, + 1 + ], + 0 + ], + [ + [ + 4, + 3, + 0, + 6, + 7, + 1, + 5, + 2 + ], + 0 + ], + [ + [ + 4, + 3, + 0, + 7, + 5, + 2, + 1, + 6 + ], + 0 + ], + [ + [ + 4, + 3, + 0, + 7, + 6, + 1, + 2, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 1, + 5, + 6, + 2, + 7, + 0 + ], + 0 + ], + [ + [ + 4, + 3, + 1, + 5, + 7, + 2, + 0, + 6 + ], + 0 + ], + [ + [ + 4, + 3, + 1, + 6, + 5, + 7, + 2, + 0 + ], + 0 + ], + [ + [ + 4, + 3, + 1, + 6, + 7, + 0, + 2, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 1, + 7, + 5, + 6, + 0, + 2 + ], + 0 + ], + [ + [ + 4, + 3, + 1, + 7, + 6, + 0, + 5, + 2 + ], + 0 + ], + [ + [ + 4, + 3, + 5, + 0, + 1, + 6, + 7, + 2 + ], + 0 + ], + [ + [ + 4, + 3, + 5, + 0, + 1, + 7, + 2, + 6 + ], + 0 + ], + [ + [ + 4, + 3, + 5, + 2, + 6, + 1, + 7, + 0 + ], + 0 + ], + [ + [ + 4, + 3, + 5, + 2, + 7, + 1, + 0, + 6 + ], + 0 + ], + [ + [ + 4, + 3, + 5, + 6, + 2, + 0, + 7, + 1 + ], + 0 + ], + [ + [ + 4, + 3, + 5, + 7, + 2, + 0, + 1, + 6 + ], + 0 + ], + [ + [ + 4, + 3, + 6, + 0, + 1, + 2, + 7, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 6, + 0, + 1, + 7, + 5, + 2 + ], + 0 + ], + [ + [ + 4, + 3, + 6, + 2, + 5, + 7, + 1, + 0 + ], + 0 + ], + [ + [ + 4, + 3, + 6, + 2, + 7, + 0, + 1, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 6, + 5, + 2, + 7, + 0, + 1 + ], + 0 + ], + [ + [ + 4, + 3, + 6, + 7, + 2, + 1, + 0, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 7, + 0, + 1, + 2, + 5, + 6 + ], + 0 + ], + [ + [ + 4, + 3, + 7, + 0, + 1, + 6, + 2, + 5 + ], + 0 + ], + [ + [ + 4, + 3, + 7, + 2, + 5, + 6, + 0, + 1 + ], + 0 + ], + [ + [ + 4, + 3, + 7, + 2, + 6, + 0, + 5, + 1 + ], + 0 + ], + [ + [ + 4, + 3, + 7, + 5, + 2, + 6, + 1, + 0 + ], + 0 + ], + [ + [ + 4, + 3, + 7, + 6, + 2, + 1, + 5, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 0, + 1, + 6, + 7, + 2, + 3 + ], + 0 + ], + [ + [ + 4, + 5, + 0, + 1, + 7, + 6, + 3, + 2 + ], + 0 + ], + [ + [ + 4, + 5, + 0, + 2, + 3, + 6, + 7, + 1 + ], + 0 + ], + [ + [ + 4, + 5, + 0, + 2, + 3, + 7, + 1, + 6 + ], + 0 + ], + [ + [ + 4, + 5, + 0, + 6, + 7, + 3, + 1, + 2 + ], + 0 + ], + [ + [ + 4, + 5, + 0, + 7, + 6, + 3, + 2, + 1 + ], + 0 + ], + [ + [ + 4, + 5, + 1, + 0, + 6, + 7, + 3, + 2 + ], + 0 + ], + [ + [ + 4, + 5, + 1, + 0, + 7, + 6, + 2, + 3 + ], + 0 + ], + [ + [ + 4, + 5, + 1, + 2, + 6, + 3, + 7, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 1, + 2, + 7, + 3, + 0, + 6 + ], + 0 + ], + [ + [ + 4, + 5, + 1, + 6, + 3, + 7, + 0, + 2 + ], + 0 + ], + [ + [ + 4, + 5, + 1, + 7, + 3, + 6, + 2, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 3, + 0, + 2, + 6, + 7, + 1 + ], + 0 + ], + [ + [ + 4, + 5, + 3, + 0, + 2, + 7, + 1, + 6 + ], + 0 + ], + [ + [ + 4, + 5, + 3, + 1, + 6, + 2, + 7, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 3, + 1, + 7, + 2, + 0, + 6 + ], + 0 + ], + [ + [ + 4, + 5, + 3, + 6, + 1, + 0, + 7, + 2 + ], + 0 + ], + [ + [ + 4, + 5, + 3, + 7, + 1, + 0, + 2, + 6 + ], + 0 + ], + [ + [ + 4, + 5, + 6, + 0, + 7, + 2, + 1, + 3 + ], + 0 + ], + [ + [ + 4, + 5, + 6, + 1, + 2, + 7, + 0, + 3 + ], + 0 + ], + [ + [ + 4, + 5, + 6, + 2, + 1, + 0, + 7, + 3 + ], + 0 + ], + [ + [ + 4, + 5, + 6, + 7, + 1, + 0, + 3, + 2 + ], + 0 + ], + [ + [ + 4, + 5, + 6, + 7, + 2, + 3, + 0, + 1 + ], + 0 + ], + [ + [ + 4, + 5, + 6, + 7, + 3, + 2, + 1, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 7, + 0, + 6, + 2, + 3, + 1 + ], + 0 + ], + [ + [ + 4, + 5, + 7, + 1, + 2, + 6, + 3, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 7, + 2, + 1, + 0, + 3, + 6 + ], + 0 + ], + [ + [ + 4, + 5, + 7, + 6, + 1, + 0, + 2, + 3 + ], + 0 + ], + [ + [ + 4, + 5, + 7, + 6, + 2, + 3, + 1, + 0 + ], + 0 + ], + [ + [ + 4, + 5, + 7, + 6, + 3, + 2, + 0, + 1 + ], + 0 + ], + [ + [ + 4, + 6, + 0, + 1, + 5, + 2, + 7, + 3 + ], + 0 + ], + [ + [ + 4, + 6, + 0, + 1, + 7, + 3, + 5, + 2 + ], + 0 + ], + [ + [ + 4, + 6, + 0, + 2, + 3, + 1, + 7, + 5 + ], + 0 + ], + [ + [ + 4, + 6, + 0, + 2, + 3, + 7, + 5, + 1 + ], + 0 + ], + [ + [ + 4, + 6, + 0, + 5, + 7, + 1, + 3, + 2 + ], + 0 + ], + [ + [ + 4, + 6, + 0, + 7, + 5, + 2, + 3, + 1 + ], + 0 + ], + [ + [ + 4, + 6, + 1, + 0, + 5, + 3, + 7, + 2 + ], + 0 + ], + [ + [ + 4, + 6, + 1, + 0, + 7, + 2, + 5, + 3 + ], + 0 + ], + [ + [ + 4, + 6, + 1, + 2, + 5, + 7, + 3, + 0 + ], + 0 + ], + [ + [ + 4, + 6, + 1, + 2, + 7, + 0, + 3, + 5 + ], + 0 + ], + [ + [ + 4, + 6, + 1, + 5, + 3, + 0, + 7, + 2 + ], + 0 + ], + [ + [ + 4, + 6, + 1, + 7, + 3, + 2, + 5, + 0 + ], + 0 + ], + [ + [ + 4, + 6, + 3, + 0, + 2, + 1, + 7, + 5 + ], + 0 + ], + [ + [ + 4, + 6, + 3, + 0, + 2, + 7, + 5, + 1 + ], + 0 + ], + [ + [ + 4, + 6, + 3, + 1, + 5, + 7, + 2, + 0 + ], + 0 + ], + [ + [ + 4, + 6, + 3, + 1, + 7, + 0, + 2, + 5 + ], + 0 + ], + [ + [ + 4, + 6, + 3, + 5, + 1, + 7, + 0, + 2 + ], + 0 + ], + [ + [ + 4, + 6, + 3, + 7, + 1, + 2, + 0, + 5 + ], + 0 + ], + [ + [ + 4, + 6, + 5, + 0, + 7, + 1, + 2, + 3 + ], + 0 + ], + [ + [ + 4, + 6, + 5, + 1, + 2, + 0, + 7, + 3 + ], + 0 + ], + [ + [ + 4, + 6, + 5, + 2, + 1, + 7, + 0, + 3 + ], + 0 + ], + [ + [ + 4, + 6, + 5, + 7, + 1, + 3, + 0, + 2 + ], + 0 + ], + [ + [ + 4, + 6, + 5, + 7, + 2, + 0, + 3, + 1 + ], + 0 + ], + [ + [ + 4, + 6, + 5, + 7, + 3, + 1, + 2, + 0 + ], + 0 + ], + [ + [ + 4, + 6, + 7, + 0, + 5, + 3, + 2, + 1 + ], + 0 + ], + [ + [ + 4, + 6, + 7, + 1, + 2, + 3, + 5, + 0 + ], + 0 + ], + [ + [ + 4, + 6, + 7, + 2, + 1, + 3, + 0, + 5 + ], + 0 + ], + [ + [ + 4, + 6, + 7, + 5, + 1, + 2, + 0, + 3 + ], + 0 + ], + [ + [ + 4, + 6, + 7, + 5, + 2, + 1, + 3, + 0 + ], + 0 + ], + [ + [ + 4, + 6, + 7, + 5, + 3, + 0, + 2, + 1 + ], + 0 + ], + [ + [ + 4, + 7, + 0, + 1, + 5, + 2, + 3, + 6 + ], + 0 + ], + [ + [ + 4, + 7, + 0, + 1, + 6, + 3, + 2, + 5 + ], + 0 + ], + [ + [ + 4, + 7, + 0, + 2, + 3, + 1, + 5, + 6 + ], + 0 + ], + [ + [ + 4, + 7, + 0, + 2, + 3, + 6, + 1, + 5 + ], + 0 + ], + [ + [ + 4, + 7, + 0, + 5, + 6, + 1, + 2, + 3 + ], + 0 + ], + [ + [ + 4, + 7, + 0, + 6, + 5, + 2, + 1, + 3 + ], + 0 + ], + [ + [ + 4, + 7, + 1, + 0, + 5, + 3, + 2, + 6 + ], + 0 + ], + [ + [ + 4, + 7, + 1, + 0, + 6, + 2, + 3, + 5 + ], + 0 + ], + [ + [ + 4, + 7, + 1, + 2, + 5, + 6, + 0, + 3 + ], + 0 + ], + [ + [ + 4, + 7, + 1, + 2, + 6, + 0, + 5, + 3 + ], + 0 + ], + [ + [ + 4, + 7, + 1, + 5, + 3, + 0, + 2, + 6 + ], + 0 + ], + [ + [ + 4, + 7, + 1, + 6, + 3, + 2, + 0, + 5 + ], + 0 + ], + [ + [ + 4, + 7, + 3, + 0, + 2, + 1, + 5, + 6 + ], + 0 + ], + [ + [ + 4, + 7, + 3, + 0, + 2, + 6, + 1, + 5 + ], + 0 + ], + [ + [ + 4, + 7, + 3, + 1, + 5, + 6, + 0, + 2 + ], + 0 + ], + [ + [ + 4, + 7, + 3, + 1, + 6, + 0, + 5, + 2 + ], + 0 + ], + [ + [ + 4, + 7, + 3, + 5, + 1, + 6, + 2, + 0 + ], + 0 + ], + [ + [ + 4, + 7, + 3, + 6, + 1, + 2, + 5, + 0 + ], + 0 + ], + [ + [ + 4, + 7, + 5, + 0, + 6, + 1, + 3, + 2 + ], + 0 + ], + [ + [ + 4, + 7, + 5, + 1, + 2, + 0, + 3, + 6 + ], + 0 + ], + [ + [ + 4, + 7, + 5, + 2, + 1, + 6, + 3, + 0 + ], + 0 + ], + [ + [ + 4, + 7, + 5, + 6, + 1, + 3, + 2, + 0 + ], + 0 + ], + [ + [ + 4, + 7, + 5, + 6, + 2, + 0, + 1, + 3 + ], + 0 + ], + [ + [ + 4, + 7, + 5, + 6, + 3, + 1, + 0, + 2 + ], + 0 + ], + [ + [ + 4, + 7, + 6, + 0, + 5, + 3, + 1, + 2 + ], + 0 + ], + [ + [ + 4, + 7, + 6, + 1, + 2, + 3, + 0, + 5 + ], + 0 + ], + [ + [ + 4, + 7, + 6, + 2, + 1, + 3, + 5, + 0 + ], + 0 + ], + [ + [ + 4, + 7, + 6, + 5, + 1, + 2, + 3, + 0 + ], + 0 + ], + [ + [ + 4, + 7, + 6, + 5, + 2, + 1, + 0, + 3 + ], + 0 + ], + [ + [ + 4, + 7, + 6, + 5, + 3, + 0, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 1, + 4, + 6, + 2, + 7, + 3 + ], + 0 + ], + [ + [ + 5, + 0, + 1, + 4, + 7, + 2, + 3, + 6 + ], + 0 + ], + [ + [ + 5, + 0, + 1, + 6, + 3, + 2, + 7, + 4 + ], + 0 + ], + [ + [ + 5, + 0, + 1, + 6, + 7, + 2, + 4, + 3 + ], + 0 + ], + [ + [ + 5, + 0, + 1, + 7, + 3, + 2, + 4, + 6 + ], + 0 + ], + [ + [ + 5, + 0, + 1, + 7, + 6, + 2, + 3, + 4 + ], + 0 + ], + [ + [ + 5, + 0, + 3, + 4, + 6, + 7, + 2, + 1 + ], + 0 + ], + [ + [ + 5, + 0, + 3, + 4, + 7, + 6, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 3, + 6, + 1, + 4, + 7, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 3, + 6, + 2, + 7, + 4, + 1 + ], + 0 + ], + [ + [ + 5, + 0, + 3, + 7, + 1, + 4, + 2, + 6 + ], + 0 + ], + [ + [ + 5, + 0, + 3, + 7, + 2, + 6, + 1, + 4 + ], + 0 + ], + [ + [ + 5, + 0, + 4, + 1, + 6, + 3, + 7, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 4, + 1, + 7, + 3, + 2, + 6 + ], + 0 + ], + [ + [ + 5, + 0, + 4, + 2, + 6, + 7, + 3, + 1 + ], + 0 + ], + [ + [ + 5, + 0, + 4, + 2, + 7, + 6, + 1, + 3 + ], + 0 + ], + [ + [ + 5, + 0, + 4, + 6, + 3, + 7, + 2, + 1 + ], + 0 + ], + [ + [ + 5, + 0, + 4, + 7, + 3, + 6, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 6, + 1, + 2, + 3, + 7, + 4 + ], + 0 + ], + [ + [ + 5, + 0, + 6, + 1, + 7, + 3, + 4, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 6, + 2, + 1, + 4, + 7, + 3 + ], + 0 + ], + [ + [ + 5, + 0, + 6, + 2, + 3, + 7, + 4, + 1 + ], + 0 + ], + [ + [ + 5, + 0, + 6, + 4, + 2, + 7, + 3, + 1 + ], + 0 + ], + [ + [ + 5, + 0, + 6, + 7, + 1, + 4, + 3, + 2 + ], + 0 + ], + [ + [ + 5, + 0, + 7, + 1, + 2, + 3, + 4, + 6 + ], + 0 + ], + [ + [ + 5, + 0, + 7, + 1, + 6, + 3, + 2, + 4 + ], + 0 + ], + [ + [ + 5, + 0, + 7, + 2, + 1, + 4, + 3, + 6 + ], + 0 + ], + [ + [ + 5, + 0, + 7, + 2, + 3, + 6, + 1, + 4 + ], + 0 + ], + [ + [ + 5, + 0, + 7, + 4, + 2, + 6, + 1, + 3 + ], + 0 + ], + [ + [ + 5, + 0, + 7, + 6, + 1, + 4, + 2, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 0, + 4, + 6, + 1, + 7, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 0, + 4, + 7, + 1, + 3, + 6 + ], + 0 + ], + [ + [ + 5, + 2, + 0, + 6, + 3, + 1, + 7, + 4 + ], + 0 + ], + [ + [ + 5, + 2, + 0, + 6, + 7, + 1, + 4, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 0, + 7, + 3, + 1, + 4, + 6 + ], + 0 + ], + [ + [ + 5, + 2, + 0, + 7, + 6, + 1, + 3, + 4 + ], + 0 + ], + [ + [ + 5, + 2, + 3, + 4, + 1, + 6, + 7, + 0 + ], + 0 + ], + [ + [ + 5, + 2, + 3, + 4, + 1, + 7, + 0, + 6 + ], + 0 + ], + [ + [ + 5, + 2, + 3, + 6, + 0, + 7, + 1, + 4 + ], + 0 + ], + [ + [ + 5, + 2, + 3, + 6, + 7, + 4, + 1, + 0 + ], + 0 + ], + [ + [ + 5, + 2, + 3, + 7, + 0, + 6, + 4, + 1 + ], + 0 + ], + [ + [ + 5, + 2, + 3, + 7, + 6, + 4, + 0, + 1 + ], + 0 + ], + [ + [ + 5, + 2, + 4, + 0, + 6, + 7, + 1, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 4, + 0, + 7, + 6, + 3, + 1 + ], + 0 + ], + [ + [ + 5, + 2, + 4, + 1, + 3, + 6, + 7, + 0 + ], + 0 + ], + [ + [ + 5, + 2, + 4, + 1, + 3, + 7, + 0, + 6 + ], + 0 + ], + [ + [ + 5, + 2, + 4, + 6, + 7, + 3, + 0, + 1 + ], + 0 + ], + [ + [ + 5, + 2, + 4, + 7, + 6, + 3, + 1, + 0 + ], + 0 + ], + [ + [ + 5, + 2, + 6, + 0, + 1, + 7, + 4, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 6, + 0, + 3, + 4, + 7, + 1 + ], + 0 + ], + [ + [ + 5, + 2, + 6, + 1, + 0, + 7, + 3, + 4 + ], + 0 + ], + [ + [ + 5, + 2, + 6, + 1, + 7, + 4, + 3, + 0 + ], + 0 + ], + [ + [ + 5, + 2, + 6, + 4, + 0, + 3, + 7, + 1 + ], + 0 + ], + [ + [ + 5, + 2, + 6, + 7, + 1, + 3, + 4, + 0 + ], + 0 + ], + [ + [ + 5, + 2, + 7, + 0, + 1, + 6, + 3, + 4 + ], + 0 + ], + [ + [ + 5, + 2, + 7, + 0, + 3, + 4, + 1, + 6 + ], + 0 + ], + [ + [ + 5, + 2, + 7, + 1, + 0, + 6, + 4, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 7, + 1, + 6, + 4, + 0, + 3 + ], + 0 + ], + [ + [ + 5, + 2, + 7, + 4, + 0, + 3, + 1, + 6 + ], + 0 + ], + [ + [ + 5, + 2, + 7, + 6, + 1, + 3, + 0, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 0, + 4, + 6, + 7, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 3, + 0, + 4, + 7, + 6, + 2, + 1 + ], + 0 + ], + [ + [ + 5, + 3, + 0, + 6, + 1, + 7, + 4, + 2 + ], + 0 + ], + [ + [ + 5, + 3, + 0, + 6, + 2, + 4, + 7, + 1 + ], + 0 + ], + [ + [ + 5, + 3, + 0, + 7, + 1, + 6, + 2, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 0, + 7, + 2, + 4, + 1, + 6 + ], + 0 + ], + [ + [ + 5, + 3, + 1, + 4, + 2, + 6, + 7, + 0 + ], + 0 + ], + [ + [ + 5, + 3, + 1, + 4, + 2, + 7, + 0, + 6 + ], + 0 + ], + [ + [ + 5, + 3, + 1, + 6, + 0, + 7, + 2, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 1, + 6, + 7, + 4, + 2, + 0 + ], + 0 + ], + [ + [ + 5, + 3, + 1, + 7, + 0, + 6, + 4, + 2 + ], + 0 + ], + [ + [ + 5, + 3, + 1, + 7, + 6, + 4, + 0, + 2 + ], + 0 + ], + [ + [ + 5, + 3, + 4, + 0, + 6, + 1, + 7, + 2 + ], + 0 + ], + [ + [ + 5, + 3, + 4, + 0, + 7, + 1, + 2, + 6 + ], + 0 + ], + [ + [ + 5, + 3, + 4, + 2, + 1, + 6, + 7, + 0 + ], + 0 + ], + [ + [ + 5, + 3, + 4, + 2, + 1, + 7, + 0, + 6 + ], + 0 + ], + [ + [ + 5, + 3, + 4, + 6, + 0, + 2, + 7, + 1 + ], + 0 + ], + [ + [ + 5, + 3, + 4, + 7, + 0, + 2, + 1, + 6 + ], + 0 + ], + [ + [ + 5, + 3, + 6, + 0, + 2, + 1, + 7, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 6, + 0, + 7, + 1, + 4, + 2 + ], + 0 + ], + [ + [ + 5, + 3, + 6, + 2, + 0, + 7, + 1, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 6, + 2, + 7, + 4, + 1, + 0 + ], + 0 + ], + [ + [ + 5, + 3, + 6, + 4, + 7, + 2, + 0, + 1 + ], + 0 + ], + [ + [ + 5, + 3, + 6, + 7, + 1, + 2, + 0, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 7, + 0, + 2, + 1, + 4, + 6 + ], + 0 + ], + [ + [ + 5, + 3, + 7, + 0, + 6, + 1, + 2, + 4 + ], + 0 + ], + [ + [ + 5, + 3, + 7, + 2, + 0, + 6, + 4, + 1 + ], + 0 + ], + [ + [ + 5, + 3, + 7, + 2, + 6, + 4, + 0, + 1 + ], + 0 + ], + [ + [ + 5, + 3, + 7, + 4, + 6, + 2, + 1, + 0 + ], + 0 + ], + [ + [ + 5, + 3, + 7, + 6, + 1, + 2, + 4, + 0 + ], + 0 + ], + [ + [ + 5, + 4, + 0, + 1, + 6, + 7, + 3, + 2 + ], + 0 + ], + [ + [ + 5, + 4, + 0, + 1, + 7, + 6, + 2, + 3 + ], + 0 + ], + [ + [ + 5, + 4, + 0, + 2, + 6, + 3, + 7, + 1 + ], + 0 + ], + [ + [ + 5, + 4, + 0, + 2, + 7, + 3, + 1, + 6 + ], + 0 + ], + [ + [ + 5, + 4, + 0, + 6, + 3, + 7, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 4, + 0, + 7, + 3, + 6, + 2, + 1 + ], + 0 + ], + [ + [ + 5, + 4, + 1, + 0, + 6, + 7, + 2, + 3 + ], + 0 + ], + [ + [ + 5, + 4, + 1, + 0, + 7, + 6, + 3, + 2 + ], + 0 + ], + [ + [ + 5, + 4, + 1, + 2, + 3, + 6, + 7, + 0 + ], + 0 + ], + [ + [ + 5, + 4, + 1, + 2, + 3, + 7, + 0, + 6 + ], + 0 + ], + [ + [ + 5, + 4, + 1, + 6, + 7, + 3, + 0, + 2 + ], + 0 + ], + [ + [ + 5, + 4, + 1, + 7, + 6, + 3, + 2, + 0 + ], + 0 + ], + [ + [ + 5, + 4, + 3, + 0, + 6, + 2, + 7, + 1 + ], + 0 + ], + [ + [ + 5, + 4, + 3, + 0, + 7, + 2, + 1, + 6 + ], + 0 + ], + [ + [ + 5, + 4, + 3, + 1, + 2, + 6, + 7, + 0 + ], + 0 + ], + [ + [ + 5, + 4, + 3, + 1, + 2, + 7, + 0, + 6 + ], + 0 + ], + [ + [ + 5, + 4, + 3, + 6, + 0, + 1, + 7, + 2 + ], + 0 + ], + [ + [ + 5, + 4, + 3, + 7, + 0, + 1, + 2, + 6 + ], + 0 + ], + [ + [ + 5, + 4, + 6, + 0, + 2, + 7, + 1, + 3 + ], + 0 + ], + [ + [ + 5, + 4, + 6, + 1, + 7, + 2, + 0, + 3 + ], + 0 + ], + [ + [ + 5, + 4, + 6, + 2, + 0, + 1, + 7, + 3 + ], + 0 + ], + [ + [ + 5, + 4, + 6, + 7, + 0, + 1, + 3, + 2 + ], + 0 + ], + [ + [ + 5, + 4, + 6, + 7, + 2, + 3, + 1, + 0 + ], + 0 + ], + [ + [ + 5, + 4, + 6, + 7, + 3, + 2, + 0, + 1 + ], + 0 + ], + [ + [ + 5, + 4, + 7, + 0, + 2, + 6, + 3, + 1 + ], + 0 + ], + [ + [ + 5, + 4, + 7, + 1, + 6, + 2, + 3, + 0 + ], + 0 + ], + [ + [ + 5, + 4, + 7, + 2, + 0, + 1, + 3, + 6 + ], + 0 + ], + [ + [ + 5, + 4, + 7, + 6, + 0, + 1, + 2, + 3 + ], + 0 + ], + [ + [ + 5, + 4, + 7, + 6, + 2, + 3, + 0, + 1 + ], + 0 + ], + [ + [ + 5, + 4, + 7, + 6, + 3, + 2, + 1, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 0, + 1, + 2, + 4, + 7, + 3 + ], + 0 + ], + [ + [ + 5, + 6, + 0, + 1, + 3, + 7, + 4, + 2 + ], + 0 + ], + [ + [ + 5, + 6, + 0, + 2, + 1, + 3, + 7, + 4 + ], + 0 + ], + [ + [ + 5, + 6, + 0, + 2, + 7, + 3, + 4, + 1 + ], + 0 + ], + [ + [ + 5, + 6, + 0, + 4, + 1, + 7, + 3, + 2 + ], + 0 + ], + [ + [ + 5, + 6, + 0, + 7, + 2, + 4, + 3, + 1 + ], + 0 + ], + [ + [ + 5, + 6, + 1, + 0, + 2, + 7, + 4, + 3 + ], + 0 + ], + [ + [ + 5, + 6, + 1, + 0, + 3, + 4, + 7, + 2 + ], + 0 + ], + [ + [ + 5, + 6, + 1, + 2, + 0, + 7, + 3, + 4 + ], + 0 + ], + [ + [ + 5, + 6, + 1, + 2, + 7, + 4, + 3, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 1, + 4, + 0, + 3, + 7, + 2 + ], + 0 + ], + [ + [ + 5, + 6, + 1, + 7, + 2, + 3, + 4, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 3, + 0, + 1, + 2, + 7, + 4 + ], + 0 + ], + [ + [ + 5, + 6, + 3, + 0, + 7, + 2, + 4, + 1 + ], + 0 + ], + [ + [ + 5, + 6, + 3, + 1, + 0, + 7, + 2, + 4 + ], + 0 + ], + [ + [ + 5, + 6, + 3, + 1, + 7, + 4, + 2, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 3, + 4, + 7, + 1, + 0, + 2 + ], + 0 + ], + [ + [ + 5, + 6, + 3, + 7, + 2, + 1, + 0, + 4 + ], + 0 + ], + [ + [ + 5, + 6, + 4, + 0, + 1, + 7, + 2, + 3 + ], + 0 + ], + [ + [ + 5, + 6, + 4, + 1, + 0, + 2, + 7, + 3 + ], + 0 + ], + [ + [ + 5, + 6, + 4, + 2, + 7, + 1, + 0, + 3 + ], + 0 + ], + [ + [ + 5, + 6, + 4, + 7, + 0, + 2, + 3, + 1 + ], + 0 + ], + [ + [ + 5, + 6, + 4, + 7, + 1, + 3, + 2, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 4, + 7, + 3, + 1, + 0, + 2 + ], + 0 + ], + [ + [ + 5, + 6, + 7, + 0, + 3, + 4, + 2, + 1 + ], + 0 + ], + [ + [ + 5, + 6, + 7, + 1, + 3, + 2, + 4, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 7, + 2, + 3, + 1, + 0, + 4 + ], + 0 + ], + [ + [ + 5, + 6, + 7, + 4, + 0, + 3, + 2, + 1 + ], + 0 + ], + [ + [ + 5, + 6, + 7, + 4, + 1, + 2, + 3, + 0 + ], + 0 + ], + [ + [ + 5, + 6, + 7, + 4, + 2, + 1, + 0, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 0, + 1, + 2, + 4, + 3, + 6 + ], + 0 + ], + [ + [ + 5, + 7, + 0, + 1, + 3, + 6, + 2, + 4 + ], + 0 + ], + [ + [ + 5, + 7, + 0, + 2, + 1, + 3, + 4, + 6 + ], + 0 + ], + [ + [ + 5, + 7, + 0, + 2, + 6, + 3, + 1, + 4 + ], + 0 + ], + [ + [ + 5, + 7, + 0, + 4, + 1, + 6, + 2, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 0, + 6, + 2, + 4, + 1, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 1, + 0, + 2, + 6, + 3, + 4 + ], + 0 + ], + [ + [ + 5, + 7, + 1, + 0, + 3, + 4, + 2, + 6 + ], + 0 + ], + [ + [ + 5, + 7, + 1, + 2, + 0, + 6, + 4, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 1, + 2, + 6, + 4, + 0, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 1, + 4, + 0, + 3, + 2, + 6 + ], + 0 + ], + [ + [ + 5, + 7, + 1, + 6, + 2, + 3, + 0, + 4 + ], + 0 + ], + [ + [ + 5, + 7, + 3, + 0, + 1, + 2, + 4, + 6 + ], + 0 + ], + [ + [ + 5, + 7, + 3, + 0, + 6, + 2, + 1, + 4 + ], + 0 + ], + [ + [ + 5, + 7, + 3, + 1, + 0, + 6, + 4, + 2 + ], + 0 + ], + [ + [ + 5, + 7, + 3, + 1, + 6, + 4, + 0, + 2 + ], + 0 + ], + [ + [ + 5, + 7, + 3, + 4, + 6, + 1, + 2, + 0 + ], + 0 + ], + [ + [ + 5, + 7, + 3, + 6, + 2, + 1, + 4, + 0 + ], + 0 + ], + [ + [ + 5, + 7, + 4, + 0, + 1, + 6, + 3, + 2 + ], + 0 + ], + [ + [ + 5, + 7, + 4, + 1, + 0, + 2, + 3, + 6 + ], + 0 + ], + [ + [ + 5, + 7, + 4, + 2, + 6, + 1, + 3, + 0 + ], + 0 + ], + [ + [ + 5, + 7, + 4, + 6, + 0, + 2, + 1, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 4, + 6, + 1, + 3, + 0, + 2 + ], + 0 + ], + [ + [ + 5, + 7, + 4, + 6, + 3, + 1, + 2, + 0 + ], + 0 + ], + [ + [ + 5, + 7, + 6, + 0, + 3, + 4, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 7, + 6, + 1, + 3, + 2, + 0, + 4 + ], + 0 + ], + [ + [ + 5, + 7, + 6, + 2, + 3, + 1, + 4, + 0 + ], + 0 + ], + [ + [ + 5, + 7, + 6, + 4, + 0, + 3, + 1, + 2 + ], + 0 + ], + [ + [ + 5, + 7, + 6, + 4, + 1, + 2, + 0, + 3 + ], + 0 + ], + [ + [ + 5, + 7, + 6, + 4, + 2, + 1, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 0, + 1, + 4, + 5, + 7, + 2, + 3 + ], + 0 + ], + [ + [ + 6, + 0, + 1, + 4, + 7, + 3, + 2, + 5 + ], + 0 + ], + [ + [ + 6, + 0, + 1, + 5, + 3, + 7, + 2, + 4 + ], + 0 + ], + [ + [ + 6, + 0, + 1, + 5, + 7, + 4, + 2, + 3 + ], + 0 + ], + [ + [ + 6, + 0, + 1, + 7, + 3, + 4, + 2, + 5 + ], + 0 + ], + [ + [ + 6, + 0, + 1, + 7, + 5, + 3, + 2, + 4 + ], + 0 + ], + [ + [ + 6, + 0, + 3, + 4, + 5, + 2, + 7, + 1 + ], + 0 + ], + [ + [ + 6, + 0, + 3, + 4, + 7, + 1, + 5, + 2 + ], + 0 + ], + [ + [ + 6, + 0, + 3, + 5, + 1, + 7, + 4, + 2 + ], + 0 + ], + [ + [ + 6, + 0, + 3, + 5, + 2, + 4, + 7, + 1 + ], + 0 + ], + [ + [ + 6, + 0, + 3, + 7, + 1, + 2, + 4, + 5 + ], + 0 + ], + [ + [ + 6, + 0, + 3, + 7, + 2, + 1, + 5, + 4 + ], + 0 + ], + [ + [ + 6, + 0, + 4, + 1, + 5, + 7, + 3, + 2 + ], + 0 + ], + [ + [ + 6, + 0, + 4, + 1, + 7, + 2, + 3, + 5 + ], + 0 + ], + [ + [ + 6, + 0, + 4, + 2, + 5, + 3, + 7, + 1 + ], + 0 + ], + [ + [ + 6, + 0, + 4, + 2, + 7, + 1, + 5, + 3 + ], + 0 + ], + [ + [ + 6, + 0, + 4, + 5, + 3, + 2, + 7, + 1 + ], + 0 + ], + [ + [ + 6, + 0, + 4, + 7, + 3, + 1, + 5, + 2 + ], + 0 + ], + [ + [ + 6, + 0, + 5, + 1, + 2, + 7, + 3, + 4 + ], + 0 + ], + [ + [ + 6, + 0, + 5, + 1, + 7, + 4, + 3, + 2 + ], + 0 + ], + [ + [ + 6, + 0, + 5, + 2, + 1, + 7, + 4, + 3 + ], + 0 + ], + [ + [ + 6, + 0, + 5, + 2, + 3, + 4, + 7, + 1 + ], + 0 + ], + [ + [ + 6, + 0, + 5, + 4, + 2, + 3, + 7, + 1 + ], + 0 + ], + [ + [ + 6, + 0, + 5, + 7, + 1, + 3, + 4, + 2 + ], + 0 + ], + [ + [ + 6, + 0, + 7, + 1, + 2, + 4, + 3, + 5 + ], + 0 + ], + [ + [ + 6, + 0, + 7, + 1, + 5, + 2, + 3, + 4 + ], + 0 + ], + [ + [ + 6, + 0, + 7, + 2, + 1, + 3, + 4, + 5 + ], + 0 + ], + [ + [ + 6, + 0, + 7, + 2, + 3, + 1, + 5, + 4 + ], + 0 + ], + [ + [ + 6, + 0, + 7, + 4, + 2, + 1, + 5, + 3 + ], + 0 + ], + [ + [ + 6, + 0, + 7, + 5, + 1, + 2, + 4, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 0, + 4, + 5, + 7, + 1, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 0, + 4, + 7, + 3, + 1, + 5 + ], + 0 + ], + [ + [ + 6, + 2, + 0, + 5, + 3, + 7, + 1, + 4 + ], + 0 + ], + [ + [ + 6, + 2, + 0, + 5, + 7, + 4, + 1, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 0, + 7, + 3, + 4, + 1, + 5 + ], + 0 + ], + [ + [ + 6, + 2, + 0, + 7, + 5, + 3, + 1, + 4 + ], + 0 + ], + [ + [ + 6, + 2, + 3, + 4, + 1, + 0, + 7, + 5 + ], + 0 + ], + [ + [ + 6, + 2, + 3, + 4, + 1, + 7, + 5, + 0 + ], + 0 + ], + [ + [ + 6, + 2, + 3, + 5, + 0, + 1, + 7, + 4 + ], + 0 + ], + [ + [ + 6, + 2, + 3, + 5, + 7, + 1, + 4, + 0 + ], + 0 + ], + [ + [ + 6, + 2, + 3, + 7, + 0, + 4, + 5, + 1 + ], + 0 + ], + [ + [ + 6, + 2, + 3, + 7, + 5, + 0, + 4, + 1 + ], + 0 + ], + [ + [ + 6, + 2, + 4, + 0, + 5, + 1, + 7, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 4, + 0, + 7, + 3, + 5, + 1 + ], + 0 + ], + [ + [ + 6, + 2, + 4, + 1, + 3, + 0, + 7, + 5 + ], + 0 + ], + [ + [ + 6, + 2, + 4, + 1, + 3, + 7, + 5, + 0 + ], + 0 + ], + [ + [ + 6, + 2, + 4, + 5, + 7, + 0, + 3, + 1 + ], + 0 + ], + [ + [ + 6, + 2, + 4, + 7, + 5, + 1, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 2, + 5, + 0, + 1, + 4, + 7, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 5, + 0, + 3, + 7, + 4, + 1 + ], + 0 + ], + [ + [ + 6, + 2, + 5, + 1, + 0, + 3, + 7, + 4 + ], + 0 + ], + [ + [ + 6, + 2, + 5, + 1, + 7, + 3, + 4, + 0 + ], + 0 + ], + [ + [ + 6, + 2, + 5, + 4, + 0, + 7, + 3, + 1 + ], + 0 + ], + [ + [ + 6, + 2, + 5, + 7, + 1, + 4, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 2, + 7, + 0, + 1, + 3, + 5, + 4 + ], + 0 + ], + [ + [ + 6, + 2, + 7, + 0, + 3, + 1, + 4, + 5 + ], + 0 + ], + [ + [ + 6, + 2, + 7, + 1, + 0, + 4, + 5, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 7, + 1, + 5, + 0, + 4, + 3 + ], + 0 + ], + [ + [ + 6, + 2, + 7, + 4, + 0, + 1, + 3, + 5 + ], + 0 + ], + [ + [ + 6, + 2, + 7, + 5, + 1, + 0, + 3, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 0, + 4, + 5, + 1, + 7, + 2 + ], + 0 + ], + [ + [ + 6, + 3, + 0, + 4, + 7, + 2, + 5, + 1 + ], + 0 + ], + [ + [ + 6, + 3, + 0, + 5, + 1, + 4, + 7, + 2 + ], + 0 + ], + [ + [ + 6, + 3, + 0, + 5, + 2, + 7, + 4, + 1 + ], + 0 + ], + [ + [ + 6, + 3, + 0, + 7, + 1, + 2, + 5, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 0, + 7, + 2, + 1, + 4, + 5 + ], + 0 + ], + [ + [ + 6, + 3, + 1, + 4, + 2, + 0, + 7, + 5 + ], + 0 + ], + [ + [ + 6, + 3, + 1, + 4, + 2, + 7, + 5, + 0 + ], + 0 + ], + [ + [ + 6, + 3, + 1, + 5, + 0, + 2, + 7, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 1, + 5, + 7, + 2, + 4, + 0 + ], + 0 + ], + [ + [ + 6, + 3, + 1, + 7, + 0, + 4, + 5, + 2 + ], + 0 + ], + [ + [ + 6, + 3, + 1, + 7, + 5, + 0, + 4, + 2 + ], + 0 + ], + [ + [ + 6, + 3, + 4, + 0, + 5, + 7, + 1, + 2 + ], + 0 + ], + [ + [ + 6, + 3, + 4, + 0, + 7, + 2, + 1, + 5 + ], + 0 + ], + [ + [ + 6, + 3, + 4, + 2, + 1, + 0, + 7, + 5 + ], + 0 + ], + [ + [ + 6, + 3, + 4, + 2, + 1, + 7, + 5, + 0 + ], + 0 + ], + [ + [ + 6, + 3, + 4, + 5, + 0, + 7, + 2, + 1 + ], + 0 + ], + [ + [ + 6, + 3, + 4, + 7, + 0, + 1, + 2, + 5 + ], + 0 + ], + [ + [ + 6, + 3, + 5, + 0, + 2, + 7, + 1, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 5, + 0, + 7, + 4, + 1, + 2 + ], + 0 + ], + [ + [ + 6, + 3, + 5, + 2, + 0, + 1, + 7, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 5, + 2, + 7, + 1, + 4, + 0 + ], + 0 + ], + [ + [ + 6, + 3, + 5, + 4, + 7, + 0, + 2, + 1 + ], + 0 + ], + [ + [ + 6, + 3, + 5, + 7, + 1, + 0, + 2, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 7, + 0, + 2, + 4, + 1, + 5 + ], + 0 + ], + [ + [ + 6, + 3, + 7, + 0, + 5, + 2, + 1, + 4 + ], + 0 + ], + [ + [ + 6, + 3, + 7, + 2, + 0, + 4, + 5, + 1 + ], + 0 + ], + [ + [ + 6, + 3, + 7, + 2, + 5, + 0, + 4, + 1 + ], + 0 + ], + [ + [ + 6, + 3, + 7, + 4, + 5, + 1, + 2, + 0 + ], + 0 + ], + [ + [ + 6, + 3, + 7, + 5, + 1, + 4, + 2, + 0 + ], + 0 + ], + [ + [ + 6, + 4, + 0, + 1, + 5, + 3, + 7, + 2 + ], + 0 + ], + [ + [ + 6, + 4, + 0, + 1, + 7, + 2, + 5, + 3 + ], + 0 + ], + [ + [ + 6, + 4, + 0, + 2, + 5, + 7, + 3, + 1 + ], + 0 + ], + [ + [ + 6, + 4, + 0, + 2, + 7, + 1, + 3, + 5 + ], + 0 + ], + [ + [ + 6, + 4, + 0, + 5, + 3, + 1, + 7, + 2 + ], + 0 + ], + [ + [ + 6, + 4, + 0, + 7, + 3, + 2, + 5, + 1 + ], + 0 + ], + [ + [ + 6, + 4, + 1, + 0, + 5, + 2, + 7, + 3 + ], + 0 + ], + [ + [ + 6, + 4, + 1, + 0, + 7, + 3, + 5, + 2 + ], + 0 + ], + [ + [ + 6, + 4, + 1, + 2, + 3, + 0, + 7, + 5 + ], + 0 + ], + [ + [ + 6, + 4, + 1, + 2, + 3, + 7, + 5, + 0 + ], + 0 + ], + [ + [ + 6, + 4, + 1, + 5, + 7, + 0, + 3, + 2 + ], + 0 + ], + [ + [ + 6, + 4, + 1, + 7, + 5, + 2, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 4, + 3, + 0, + 5, + 7, + 2, + 1 + ], + 0 + ], + [ + [ + 6, + 4, + 3, + 0, + 7, + 1, + 2, + 5 + ], + 0 + ], + [ + [ + 6, + 4, + 3, + 1, + 2, + 0, + 7, + 5 + ], + 0 + ], + [ + [ + 6, + 4, + 3, + 1, + 2, + 7, + 5, + 0 + ], + 0 + ], + [ + [ + 6, + 4, + 3, + 5, + 0, + 7, + 1, + 2 + ], + 0 + ], + [ + [ + 6, + 4, + 3, + 7, + 0, + 2, + 1, + 5 + ], + 0 + ], + [ + [ + 6, + 4, + 5, + 0, + 2, + 1, + 7, + 3 + ], + 0 + ], + [ + [ + 6, + 4, + 5, + 1, + 7, + 0, + 2, + 3 + ], + 0 + ], + [ + [ + 6, + 4, + 5, + 2, + 0, + 7, + 1, + 3 + ], + 0 + ], + [ + [ + 6, + 4, + 5, + 7, + 0, + 3, + 1, + 2 + ], + 0 + ], + [ + [ + 6, + 4, + 5, + 7, + 2, + 1, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 4, + 5, + 7, + 3, + 0, + 2, + 1 + ], + 0 + ], + [ + [ + 6, + 4, + 7, + 0, + 2, + 3, + 5, + 1 + ], + 0 + ], + [ + [ + 6, + 4, + 7, + 1, + 5, + 3, + 2, + 0 + ], + 0 + ], + [ + [ + 6, + 4, + 7, + 2, + 0, + 3, + 1, + 5 + ], + 0 + ], + [ + [ + 6, + 4, + 7, + 5, + 0, + 2, + 1, + 3 + ], + 0 + ], + [ + [ + 6, + 4, + 7, + 5, + 2, + 0, + 3, + 1 + ], + 0 + ], + [ + [ + 6, + 4, + 7, + 5, + 3, + 1, + 2, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 0, + 1, + 2, + 7, + 4, + 3 + ], + 0 + ], + [ + [ + 6, + 5, + 0, + 1, + 3, + 4, + 7, + 2 + ], + 0 + ], + [ + [ + 6, + 5, + 0, + 2, + 1, + 7, + 3, + 4 + ], + 0 + ], + [ + [ + 6, + 5, + 0, + 2, + 7, + 4, + 3, + 1 + ], + 0 + ], + [ + [ + 6, + 5, + 0, + 4, + 1, + 3, + 7, + 2 + ], + 0 + ], + [ + [ + 6, + 5, + 0, + 7, + 2, + 3, + 4, + 1 + ], + 0 + ], + [ + [ + 6, + 5, + 1, + 0, + 2, + 4, + 7, + 3 + ], + 0 + ], + [ + [ + 6, + 5, + 1, + 0, + 3, + 7, + 4, + 2 + ], + 0 + ], + [ + [ + 6, + 5, + 1, + 2, + 0, + 3, + 7, + 4 + ], + 0 + ], + [ + [ + 6, + 5, + 1, + 2, + 7, + 3, + 4, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 1, + 4, + 0, + 7, + 3, + 2 + ], + 0 + ], + [ + [ + 6, + 5, + 1, + 7, + 2, + 4, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 3, + 0, + 1, + 7, + 2, + 4 + ], + 0 + ], + [ + [ + 6, + 5, + 3, + 0, + 7, + 4, + 2, + 1 + ], + 0 + ], + [ + [ + 6, + 5, + 3, + 1, + 0, + 2, + 7, + 4 + ], + 0 + ], + [ + [ + 6, + 5, + 3, + 1, + 7, + 2, + 4, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 3, + 4, + 7, + 0, + 1, + 2 + ], + 0 + ], + [ + [ + 6, + 5, + 3, + 7, + 2, + 0, + 1, + 4 + ], + 0 + ], + [ + [ + 6, + 5, + 4, + 0, + 1, + 2, + 7, + 3 + ], + 0 + ], + [ + [ + 6, + 5, + 4, + 1, + 0, + 7, + 2, + 3 + ], + 0 + ], + [ + [ + 6, + 5, + 4, + 2, + 7, + 0, + 1, + 3 + ], + 0 + ], + [ + [ + 6, + 5, + 4, + 7, + 0, + 3, + 2, + 1 + ], + 0 + ], + [ + [ + 6, + 5, + 4, + 7, + 1, + 2, + 3, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 4, + 7, + 3, + 0, + 1, + 2 + ], + 0 + ], + [ + [ + 6, + 5, + 7, + 0, + 3, + 2, + 4, + 1 + ], + 0 + ], + [ + [ + 6, + 5, + 7, + 1, + 3, + 4, + 2, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 7, + 2, + 3, + 0, + 1, + 4 + ], + 0 + ], + [ + [ + 6, + 5, + 7, + 4, + 0, + 2, + 3, + 1 + ], + 0 + ], + [ + [ + 6, + 5, + 7, + 4, + 1, + 3, + 2, + 0 + ], + 0 + ], + [ + [ + 6, + 5, + 7, + 4, + 2, + 0, + 1, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 0, + 1, + 2, + 3, + 4, + 5 + ], + 0 + ], + [ + [ + 6, + 7, + 0, + 1, + 3, + 2, + 5, + 4 + ], + 0 + ], + [ + [ + 6, + 7, + 0, + 2, + 1, + 4, + 3, + 5 + ], + 0 + ], + [ + [ + 6, + 7, + 0, + 2, + 5, + 1, + 3, + 4 + ], + 0 + ], + [ + [ + 6, + 7, + 0, + 4, + 1, + 2, + 5, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 0, + 5, + 2, + 1, + 4, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 1, + 0, + 2, + 3, + 5, + 4 + ], + 0 + ], + [ + [ + 6, + 7, + 1, + 0, + 3, + 2, + 4, + 5 + ], + 0 + ], + [ + [ + 6, + 7, + 1, + 2, + 0, + 4, + 5, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 1, + 2, + 5, + 0, + 4, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 1, + 4, + 0, + 2, + 3, + 5 + ], + 0 + ], + [ + [ + 6, + 7, + 1, + 5, + 2, + 0, + 3, + 4 + ], + 0 + ], + [ + [ + 6, + 7, + 3, + 0, + 1, + 4, + 2, + 5 + ], + 0 + ], + [ + [ + 6, + 7, + 3, + 0, + 5, + 1, + 2, + 4 + ], + 0 + ], + [ + [ + 6, + 7, + 3, + 1, + 0, + 4, + 5, + 2 + ], + 0 + ], + [ + [ + 6, + 7, + 3, + 1, + 5, + 0, + 4, + 2 + ], + 0 + ], + [ + [ + 6, + 7, + 3, + 4, + 5, + 2, + 1, + 0 + ], + 0 + ], + [ + [ + 6, + 7, + 3, + 5, + 2, + 4, + 1, + 0 + ], + 0 + ], + [ + [ + 6, + 7, + 4, + 0, + 1, + 3, + 5, + 2 + ], + 0 + ], + [ + [ + 6, + 7, + 4, + 1, + 0, + 3, + 2, + 5 + ], + 0 + ], + [ + [ + 6, + 7, + 4, + 2, + 5, + 3, + 1, + 0 + ], + 0 + ], + [ + [ + 6, + 7, + 4, + 5, + 0, + 1, + 2, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 4, + 5, + 1, + 0, + 3, + 2 + ], + 0 + ], + [ + [ + 6, + 7, + 4, + 5, + 3, + 2, + 1, + 0 + ], + 0 + ], + [ + [ + 6, + 7, + 5, + 0, + 3, + 1, + 4, + 2 + ], + 0 + ], + [ + [ + 6, + 7, + 5, + 1, + 3, + 0, + 2, + 4 + ], + 0 + ], + [ + [ + 6, + 7, + 5, + 2, + 3, + 4, + 1, + 0 + ], + 0 + ], + [ + [ + 6, + 7, + 5, + 4, + 0, + 1, + 3, + 2 + ], + 0 + ], + [ + [ + 6, + 7, + 5, + 4, + 1, + 0, + 2, + 3 + ], + 0 + ], + [ + [ + 6, + 7, + 5, + 4, + 2, + 3, + 1, + 0 + ], + 0 + ], + [ + [ + 7, + 0, + 1, + 4, + 5, + 6, + 3, + 2 + ], + 0 + ], + [ + [ + 7, + 0, + 1, + 4, + 6, + 3, + 5, + 2 + ], + 0 + ], + [ + [ + 7, + 0, + 1, + 5, + 3, + 6, + 4, + 2 + ], + 0 + ], + [ + [ + 7, + 0, + 1, + 5, + 6, + 4, + 3, + 2 + ], + 0 + ], + [ + [ + 7, + 0, + 1, + 6, + 3, + 4, + 5, + 2 + ], + 0 + ], + [ + [ + 7, + 0, + 1, + 6, + 5, + 3, + 4, + 2 + ], + 0 + ], + [ + [ + 7, + 0, + 3, + 4, + 5, + 2, + 1, + 6 + ], + 0 + ], + [ + [ + 7, + 0, + 3, + 4, + 6, + 1, + 2, + 5 + ], + 0 + ], + [ + [ + 7, + 0, + 3, + 5, + 1, + 6, + 2, + 4 + ], + 0 + ], + [ + [ + 7, + 0, + 3, + 5, + 2, + 4, + 1, + 6 + ], + 0 + ], + [ + [ + 7, + 0, + 3, + 6, + 1, + 2, + 5, + 4 + ], + 0 + ], + [ + [ + 7, + 0, + 3, + 6, + 2, + 1, + 4, + 5 + ], + 0 + ], + [ + [ + 7, + 0, + 4, + 1, + 5, + 6, + 2, + 3 + ], + 0 + ], + [ + [ + 7, + 0, + 4, + 1, + 6, + 2, + 5, + 3 + ], + 0 + ], + [ + [ + 7, + 0, + 4, + 2, + 5, + 3, + 1, + 6 + ], + 0 + ], + [ + [ + 7, + 0, + 4, + 2, + 6, + 1, + 3, + 5 + ], + 0 + ], + [ + [ + 7, + 0, + 4, + 5, + 3, + 2, + 1, + 6 + ], + 0 + ], + [ + [ + 7, + 0, + 4, + 6, + 3, + 1, + 2, + 5 + ], + 0 + ], + [ + [ + 7, + 0, + 5, + 1, + 2, + 6, + 4, + 3 + ], + 0 + ], + [ + [ + 7, + 0, + 5, + 1, + 6, + 4, + 2, + 3 + ], + 0 + ], + [ + [ + 7, + 0, + 5, + 2, + 1, + 6, + 3, + 4 + ], + 0 + ], + [ + [ + 7, + 0, + 5, + 2, + 3, + 4, + 1, + 6 + ], + 0 + ], + [ + [ + 7, + 0, + 5, + 4, + 2, + 3, + 1, + 6 + ], + 0 + ], + [ + [ + 7, + 0, + 5, + 6, + 1, + 3, + 2, + 4 + ], + 0 + ], + [ + [ + 7, + 0, + 6, + 1, + 2, + 4, + 5, + 3 + ], + 0 + ], + [ + [ + 7, + 0, + 6, + 1, + 5, + 2, + 4, + 3 + ], + 0 + ], + [ + [ + 7, + 0, + 6, + 2, + 1, + 3, + 5, + 4 + ], + 0 + ], + [ + [ + 7, + 0, + 6, + 2, + 3, + 1, + 4, + 5 + ], + 0 + ], + [ + [ + 7, + 0, + 6, + 4, + 2, + 1, + 3, + 5 + ], + 0 + ], + [ + [ + 7, + 0, + 6, + 5, + 1, + 2, + 3, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 0, + 4, + 5, + 6, + 3, + 1 + ], + 0 + ], + [ + [ + 7, + 2, + 0, + 4, + 6, + 3, + 5, + 1 + ], + 0 + ], + [ + [ + 7, + 2, + 0, + 5, + 3, + 6, + 4, + 1 + ], + 0 + ], + [ + [ + 7, + 2, + 0, + 5, + 6, + 4, + 3, + 1 + ], + 0 + ], + [ + [ + 7, + 2, + 0, + 6, + 3, + 4, + 5, + 1 + ], + 0 + ], + [ + [ + 7, + 2, + 0, + 6, + 5, + 3, + 4, + 1 + ], + 0 + ], + [ + [ + 7, + 2, + 3, + 4, + 1, + 0, + 5, + 6 + ], + 0 + ], + [ + [ + 7, + 2, + 3, + 4, + 1, + 6, + 0, + 5 + ], + 0 + ], + [ + [ + 7, + 2, + 3, + 5, + 0, + 1, + 4, + 6 + ], + 0 + ], + [ + [ + 7, + 2, + 3, + 5, + 6, + 1, + 0, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 3, + 6, + 0, + 4, + 1, + 5 + ], + 0 + ], + [ + [ + 7, + 2, + 3, + 6, + 5, + 0, + 1, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 4, + 0, + 5, + 1, + 3, + 6 + ], + 0 + ], + [ + [ + 7, + 2, + 4, + 0, + 6, + 3, + 1, + 5 + ], + 0 + ], + [ + [ + 7, + 2, + 4, + 1, + 3, + 0, + 5, + 6 + ], + 0 + ], + [ + [ + 7, + 2, + 4, + 1, + 3, + 6, + 0, + 5 + ], + 0 + ], + [ + [ + 7, + 2, + 4, + 5, + 6, + 0, + 1, + 3 + ], + 0 + ], + [ + [ + 7, + 2, + 4, + 6, + 5, + 1, + 0, + 3 + ], + 0 + ], + [ + [ + 7, + 2, + 5, + 0, + 1, + 4, + 3, + 6 + ], + 0 + ], + [ + [ + 7, + 2, + 5, + 0, + 3, + 6, + 1, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 5, + 1, + 0, + 3, + 4, + 6 + ], + 0 + ], + [ + [ + 7, + 2, + 5, + 1, + 6, + 3, + 0, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 5, + 4, + 0, + 6, + 1, + 3 + ], + 0 + ], + [ + [ + 7, + 2, + 5, + 6, + 1, + 4, + 0, + 3 + ], + 0 + ], + [ + [ + 7, + 2, + 6, + 0, + 1, + 3, + 4, + 5 + ], + 0 + ], + [ + [ + 7, + 2, + 6, + 0, + 3, + 1, + 5, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 6, + 1, + 0, + 4, + 3, + 5 + ], + 0 + ], + [ + [ + 7, + 2, + 6, + 1, + 5, + 0, + 3, + 4 + ], + 0 + ], + [ + [ + 7, + 2, + 6, + 4, + 0, + 1, + 5, + 3 + ], + 0 + ], + [ + [ + 7, + 2, + 6, + 5, + 1, + 0, + 4, + 3 + ], + 0 + ], + [ + [ + 7, + 3, + 0, + 4, + 5, + 1, + 2, + 6 + ], + 0 + ], + [ + [ + 7, + 3, + 0, + 4, + 6, + 2, + 1, + 5 + ], + 0 + ], + [ + [ + 7, + 3, + 0, + 5, + 1, + 4, + 2, + 6 + ], + 0 + ], + [ + [ + 7, + 3, + 0, + 5, + 2, + 6, + 1, + 4 + ], + 0 + ], + [ + [ + 7, + 3, + 0, + 6, + 1, + 2, + 4, + 5 + ], + 0 + ], + [ + [ + 7, + 3, + 0, + 6, + 2, + 1, + 5, + 4 + ], + 0 + ], + [ + [ + 7, + 3, + 1, + 4, + 2, + 0, + 5, + 6 + ], + 0 + ], + [ + [ + 7, + 3, + 1, + 4, + 2, + 6, + 0, + 5 + ], + 0 + ], + [ + [ + 7, + 3, + 1, + 5, + 0, + 2, + 4, + 6 + ], + 0 + ], + [ + [ + 7, + 3, + 1, + 5, + 6, + 2, + 0, + 4 + ], + 0 + ], + [ + [ + 7, + 3, + 1, + 6, + 0, + 4, + 2, + 5 + ], + 0 + ], + [ + [ + 7, + 3, + 1, + 6, + 5, + 0, + 2, + 4 + ], + 0 + ], + [ + [ + 7, + 3, + 4, + 0, + 5, + 6, + 2, + 1 + ], + 0 + ], + [ + [ + 7, + 3, + 4, + 0, + 6, + 2, + 5, + 1 + ], + 0 + ], + [ + [ + 7, + 3, + 4, + 2, + 1, + 0, + 5, + 6 + ], + 0 + ], + [ + [ + 7, + 3, + 4, + 2, + 1, + 6, + 0, + 5 + ], + 0 + ], + [ + [ + 7, + 3, + 4, + 5, + 0, + 6, + 1, + 2 + ], + 0 + ], + [ + [ + 7, + 3, + 4, + 6, + 0, + 1, + 5, + 2 + ], + 0 + ], + [ + [ + 7, + 3, + 5, + 0, + 2, + 6, + 4, + 1 + ], + 0 + ], + [ + [ + 7, + 3, + 5, + 0, + 6, + 4, + 2, + 1 + ], + 0 + ], + [ + [ + 7, + 3, + 5, + 2, + 0, + 1, + 4, + 6 + ], + 0 + ], + [ + [ + 7, + 3, + 5, + 2, + 6, + 1, + 0, + 4 + ], + 0 + ], + [ + [ + 7, + 3, + 5, + 4, + 6, + 0, + 1, + 2 + ], + 0 + ], + [ + [ + 7, + 3, + 5, + 6, + 1, + 0, + 4, + 2 + ], + 0 + ], + [ + [ + 7, + 3, + 6, + 0, + 2, + 4, + 5, + 1 + ], + 0 + ], + [ + [ + 7, + 3, + 6, + 0, + 5, + 2, + 4, + 1 + ], + 0 + ], + [ + [ + 7, + 3, + 6, + 2, + 0, + 4, + 1, + 5 + ], + 0 + ], + [ + [ + 7, + 3, + 6, + 2, + 5, + 0, + 1, + 4 + ], + 0 + ], + [ + [ + 7, + 3, + 6, + 4, + 5, + 1, + 0, + 2 + ], + 0 + ], + [ + [ + 7, + 3, + 6, + 5, + 1, + 4, + 0, + 2 + ], + 0 + ], + [ + [ + 7, + 4, + 0, + 1, + 5, + 3, + 2, + 6 + ], + 0 + ], + [ + [ + 7, + 4, + 0, + 1, + 6, + 2, + 3, + 5 + ], + 0 + ], + [ + [ + 7, + 4, + 0, + 2, + 5, + 6, + 1, + 3 + ], + 0 + ], + [ + [ + 7, + 4, + 0, + 2, + 6, + 1, + 5, + 3 + ], + 0 + ], + [ + [ + 7, + 4, + 0, + 5, + 3, + 1, + 2, + 6 + ], + 0 + ], + [ + [ + 7, + 4, + 0, + 6, + 3, + 2, + 1, + 5 + ], + 0 + ], + [ + [ + 7, + 4, + 1, + 0, + 5, + 2, + 3, + 6 + ], + 0 + ], + [ + [ + 7, + 4, + 1, + 0, + 6, + 3, + 2, + 5 + ], + 0 + ], + [ + [ + 7, + 4, + 1, + 2, + 3, + 0, + 5, + 6 + ], + 0 + ], + [ + [ + 7, + 4, + 1, + 2, + 3, + 6, + 0, + 5 + ], + 0 + ], + [ + [ + 7, + 4, + 1, + 5, + 6, + 0, + 2, + 3 + ], + 0 + ], + [ + [ + 7, + 4, + 1, + 6, + 5, + 2, + 0, + 3 + ], + 0 + ], + [ + [ + 7, + 4, + 3, + 0, + 5, + 6, + 1, + 2 + ], + 0 + ], + [ + [ + 7, + 4, + 3, + 0, + 6, + 1, + 5, + 2 + ], + 0 + ], + [ + [ + 7, + 4, + 3, + 1, + 2, + 0, + 5, + 6 + ], + 0 + ], + [ + [ + 7, + 4, + 3, + 1, + 2, + 6, + 0, + 5 + ], + 0 + ], + [ + [ + 7, + 4, + 3, + 5, + 0, + 6, + 2, + 1 + ], + 0 + ], + [ + [ + 7, + 4, + 3, + 6, + 0, + 2, + 5, + 1 + ], + 0 + ], + [ + [ + 7, + 4, + 5, + 0, + 2, + 1, + 3, + 6 + ], + 0 + ], + [ + [ + 7, + 4, + 5, + 1, + 6, + 0, + 3, + 2 + ], + 0 + ], + [ + [ + 7, + 4, + 5, + 2, + 0, + 6, + 3, + 1 + ], + 0 + ], + [ + [ + 7, + 4, + 5, + 6, + 0, + 3, + 2, + 1 + ], + 0 + ], + [ + [ + 7, + 4, + 5, + 6, + 2, + 1, + 0, + 3 + ], + 0 + ], + [ + [ + 7, + 4, + 5, + 6, + 3, + 0, + 1, + 2 + ], + 0 + ], + [ + [ + 7, + 4, + 6, + 0, + 2, + 3, + 1, + 5 + ], + 0 + ], + [ + [ + 7, + 4, + 6, + 1, + 5, + 3, + 0, + 2 + ], + 0 + ], + [ + [ + 7, + 4, + 6, + 2, + 0, + 3, + 5, + 1 + ], + 0 + ], + [ + [ + 7, + 4, + 6, + 5, + 0, + 2, + 3, + 1 + ], + 0 + ], + [ + [ + 7, + 4, + 6, + 5, + 2, + 0, + 1, + 3 + ], + 0 + ], + [ + [ + 7, + 4, + 6, + 5, + 3, + 1, + 0, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 0, + 1, + 2, + 6, + 3, + 4 + ], + 0 + ], + [ + [ + 7, + 5, + 0, + 1, + 3, + 4, + 2, + 6 + ], + 0 + ], + [ + [ + 7, + 5, + 0, + 2, + 1, + 6, + 4, + 3 + ], + 0 + ], + [ + [ + 7, + 5, + 0, + 2, + 6, + 4, + 1, + 3 + ], + 0 + ], + [ + [ + 7, + 5, + 0, + 4, + 1, + 3, + 2, + 6 + ], + 0 + ], + [ + [ + 7, + 5, + 0, + 6, + 2, + 3, + 1, + 4 + ], + 0 + ], + [ + [ + 7, + 5, + 1, + 0, + 2, + 4, + 3, + 6 + ], + 0 + ], + [ + [ + 7, + 5, + 1, + 0, + 3, + 6, + 2, + 4 + ], + 0 + ], + [ + [ + 7, + 5, + 1, + 2, + 0, + 3, + 4, + 6 + ], + 0 + ], + [ + [ + 7, + 5, + 1, + 2, + 6, + 3, + 0, + 4 + ], + 0 + ], + [ + [ + 7, + 5, + 1, + 4, + 0, + 6, + 2, + 3 + ], + 0 + ], + [ + [ + 7, + 5, + 1, + 6, + 2, + 4, + 0, + 3 + ], + 0 + ], + [ + [ + 7, + 5, + 3, + 0, + 1, + 6, + 4, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 3, + 0, + 6, + 4, + 1, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 3, + 1, + 0, + 2, + 4, + 6 + ], + 0 + ], + [ + [ + 7, + 5, + 3, + 1, + 6, + 2, + 0, + 4 + ], + 0 + ], + [ + [ + 7, + 5, + 3, + 4, + 6, + 0, + 2, + 1 + ], + 0 + ], + [ + [ + 7, + 5, + 3, + 6, + 2, + 0, + 4, + 1 + ], + 0 + ], + [ + [ + 7, + 5, + 4, + 0, + 1, + 2, + 3, + 6 + ], + 0 + ], + [ + [ + 7, + 5, + 4, + 1, + 0, + 6, + 3, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 4, + 2, + 6, + 0, + 3, + 1 + ], + 0 + ], + [ + [ + 7, + 5, + 4, + 6, + 0, + 3, + 1, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 4, + 6, + 1, + 2, + 0, + 3 + ], + 0 + ], + [ + [ + 7, + 5, + 4, + 6, + 3, + 0, + 2, + 1 + ], + 0 + ], + [ + [ + 7, + 5, + 6, + 0, + 3, + 2, + 1, + 4 + ], + 0 + ], + [ + [ + 7, + 5, + 6, + 1, + 3, + 4, + 0, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 6, + 2, + 3, + 0, + 4, + 1 + ], + 0 + ], + [ + [ + 7, + 5, + 6, + 4, + 0, + 2, + 1, + 3 + ], + 0 + ], + [ + [ + 7, + 5, + 6, + 4, + 1, + 3, + 0, + 2 + ], + 0 + ], + [ + [ + 7, + 5, + 6, + 4, + 2, + 0, + 3, + 1 + ], + 0 + ], + [ + [ + 7, + 6, + 0, + 1, + 2, + 3, + 5, + 4 + ], + 0 + ], + [ + [ + 7, + 6, + 0, + 1, + 3, + 2, + 4, + 5 + ], + 0 + ], + [ + [ + 7, + 6, + 0, + 2, + 1, + 4, + 5, + 3 + ], + 0 + ], + [ + [ + 7, + 6, + 0, + 2, + 5, + 1, + 4, + 3 + ], + 0 + ], + [ + [ + 7, + 6, + 0, + 4, + 1, + 2, + 3, + 5 + ], + 0 + ], + [ + [ + 7, + 6, + 0, + 5, + 2, + 1, + 3, + 4 + ], + 0 + ], + [ + [ + 7, + 6, + 1, + 0, + 2, + 3, + 4, + 5 + ], + 0 + ], + [ + [ + 7, + 6, + 1, + 0, + 3, + 2, + 5, + 4 + ], + 0 + ], + [ + [ + 7, + 6, + 1, + 2, + 0, + 4, + 3, + 5 + ], + 0 + ], + [ + [ + 7, + 6, + 1, + 2, + 5, + 0, + 3, + 4 + ], + 0 + ], + [ + [ + 7, + 6, + 1, + 4, + 0, + 2, + 5, + 3 + ], + 0 + ], + [ + [ + 7, + 6, + 1, + 5, + 2, + 0, + 4, + 3 + ], + 0 + ], + [ + [ + 7, + 6, + 3, + 0, + 1, + 4, + 5, + 2 + ], + 0 + ], + [ + [ + 7, + 6, + 3, + 0, + 5, + 1, + 4, + 2 + ], + 0 + ], + [ + [ + 7, + 6, + 3, + 1, + 0, + 4, + 2, + 5 + ], + 0 + ], + [ + [ + 7, + 6, + 3, + 1, + 5, + 0, + 2, + 4 + ], + 0 + ], + [ + [ + 7, + 6, + 3, + 4, + 5, + 2, + 0, + 1 + ], + 0 + ], + [ + [ + 7, + 6, + 3, + 5, + 2, + 4, + 0, + 1 + ], + 0 + ], + [ + [ + 7, + 6, + 4, + 0, + 1, + 3, + 2, + 5 + ], + 0 + ], + [ + [ + 7, + 6, + 4, + 1, + 0, + 3, + 5, + 2 + ], + 0 + ], + [ + [ + 7, + 6, + 4, + 2, + 5, + 3, + 0, + 1 + ], + 0 + ], + [ + [ + 7, + 6, + 4, + 5, + 0, + 1, + 3, + 2 + ], + 0 + ], + [ + [ + 7, + 6, + 4, + 5, + 1, + 0, + 2, + 3 + ], + 0 + ], + [ + [ + 7, + 6, + 4, + 5, + 3, + 2, + 0, + 1 + ], + 0 + ], + [ + [ + 7, + 6, + 5, + 0, + 3, + 1, + 2, + 4 + ], + 0 + ], + [ + [ + 7, + 6, + 5, + 1, + 3, + 0, + 4, + 2 + ], + 0 + ], + [ + [ + 7, + 6, + 5, + 2, + 3, + 4, + 0, + 1 + ], + 0 + ], + [ + [ + 7, + 6, + 5, + 4, + 0, + 1, + 2, + 3 + ], + 0 + ], + [ + [ + 7, + 6, + 5, + 4, + 1, + 0, + 3, + 2 + ], + 0 + ], + [ + [ + 7, + 6, + 5, + 4, + 2, + 3, + 0, + 1 + ], + 0 + ] + ], + "reader": [ + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "1", + "1", + "1", + "0", + "0", + "0", + "0", + "1", + "1", + "1", + "0", + "0", + "1", + "1", + "1", + "1", + "0", + "1", + "0", + "0", + "0", + "1", + "1", + "1", + "1", + "1", + "0", + "0", + "1", + "1", + "1", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "1", + "1", + "1", + "0", + "0", + "0", + "1", + "1", + "1", + "1", + "0", + "0", + "0", + "1", + "1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "1", + "1", + "0", + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "1", + "1", + "1", + "1", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "1", + "1", + "1", + "1", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "2", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "1", + "1", + "1", + "2", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "1", + "1", + "1", + "2", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "2", + "0", + "0", + "1", + "-2", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "2", + "0", + "0", + "1", + "-2", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "2", + "0", + "0", + "1", + "-2", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "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", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "1", + "0", + "0", + "-1", + "1", + "-1", + "1", + "1", + "1", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-2", + "1", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-2", + "1", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "1", + "1", + "1", + "1", + "1", + "-1", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "-1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "-1", + "1", + "1", + "1", + "1", + "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", + "1", + "1", + "1", + "1", + "-1", + "1", + "0", + "0", + "-1", + "1", + "1", + "1", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "1", + "-1", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "-1", + "-1", + "2", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "-2", + "0", + "0", + "1", + "-2", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "-2", + "0", + "0", + "1", + "-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", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-2", + "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", + "1", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "1", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "2", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "1", + "1", + "1", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "1", + "1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "-1", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "1", + "1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "-1", + "-1", + "-1", + "0", + "0", + "1", + "1", + "1", + "1", + "1", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "-1", + "1", + "1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "1", + "0", + "1", + "-1", + "0", + "0", + "0", + "1", + "0", + "1", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "-1", + "-1", + "-1", + "1", + "1", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "1", + "-1", + "0", + "0", + "1", + "1", + "-2", + "0", + "1", + "1", + "-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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "-2", + "0", + "0", + "1", + "-2", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-2", + "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", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-2", + "1", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "1", + "0", + "1", + "0", + "-1", + "-1", + "1", + "0", + "1", + "1", + "0", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "0", + "-1", + "0", + "-1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "1", + "1", + "1", + "1", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "-1", + "0", + "-1", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "-1", + "-1", + "0", + "-1", + "0", + "-1", + "-1", + "0", + "1", + "0", + "1", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "1", + "0", + "-1", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "2", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "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", + "-1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "-1", + "-2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "-1", + "-2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "-1", + "2", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "2", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "2", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "-1", + "1", + "0", + "0", + "1", + "-1", + "-1", + "1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "-1", + "1", + "0", + "1", + "-1", + "0", + "-1", + "1", + "1", + "-1", + "0", + "0", + "0", + "-1", + "1", + "0", + "1", + "-1", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "1", + "-1", + "0", + "-1", + "1", + "1", + "-1", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "1", + "-1", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "1", + "-1", + "0", + "0", + "1", + "1", + "-2", + "0", + "1", + "1", + "-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", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "-1", + "-2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "-1", + "1", + "1", + "-1", + "0", + "0", + "1", + "-1", + "0", + "0", + "1", + "1", + "-2", + "0", + "1", + "1", + "-2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "1", + "-1", + "0", + "0", + "1", + "1", + "-1", + "-1", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "-1", + "-1", + "0", + "-1", + "-1", + "0", + "1", + "1", + "1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "-1", + "-1", + "0", + "1", + "1", + "-1", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "1", + "1", + "1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "1", + "-1", + "-1", + "0", + "0", + "-1", + "1", + "-1", + "1", + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "-1", + "-1", + "0", + "0", + "1", + "-1", + "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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "2", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1", + "-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", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-3", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-3", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-3", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "2", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "2", + "-1", + "-1", + "2", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "-1", + "-1", + "1", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "-1", + "0", + "1", + "1", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "-1", + "1", + "1", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "1", + "1", + "1", + "-1", + "0", + "0", + "-1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "0", + "0", + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "1", + "1", + "0", + "0", + "1", + "0", + "0", + "1", + "0", + "0", + "-1", + "1", + "0", + "0", + "-1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "-1", + "0", + "1", + "1", + "1", + "1", + "0", + "1", + "1", + "0", + "-1", + "0", + "0", + "-1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "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", + "1", + "-1", + "0", + "0", + "1", + "1", + "-2", + "0", + "1", + "1", + "-2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1", + "-2", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1", + "-2", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-3", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-3", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "1", + "-1", + "0", + "0", + "1", + "-1", + "0", + "0", + "1", + "1", + "-2", + "0", + "1", + "1", + "-2", + "0", + "1", + "-1", + "0", + "0", + "1", + "-1", + "0", + "0", + "1", + "1", + "-2", + "0", + "1", + "1", + "-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", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "row_norms": [ + 150, + 130, + 146, + 134, + 122, + 126, + 142, + 146 + ], + "status": "PASS_SELECTED_DIRTY_READER_Z4" +} diff --git a/research/selected-dirty-reader-z4/SOURCES.json b/research/selected-dirty-reader-z4/SOURCES.json new file mode 100644 index 0000000000..21462987f0 --- /dev/null +++ b/research/selected-dirty-reader-z4/SOURCES.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/z4-persistent-pair-seed57/README.md", + "usage": "input", + "git_blob": "001929a89cd64f4bbb0d4194c6bde96f45b7ded2", + "sha256": "6dda7d5b83b41c71d73711401edbc146271a546a518ef6b038b0bdbb6578d405" + }, + { + "path": "research/z4-persistent-pair-seed57/inputs/PR1391-README.md", + "usage": "input", + "git_blob": "36a48934ed30877d22e59cf420e2121cb47b5ea4", + "sha256": "401c07ebffcb007b59a8fb0f08c2505f6eb28af2c5d72efe04389c09a69f8b89" + }, + { + "path": "research/complex-sw4-frame8/local/hpe_emit_local.py", + "usage": "input", + "git_blob": "534fdc71f7641c704575efc038363d7eb206b2df", + "sha256": "7e4a6fbc38c8228157b6311457d1496bf460291393043932d2c365f004f77805" + }, + { + "path": "research/complex-sw4-frame8/local/hpe_adapters_local.py", + "usage": "input", + "git_blob": "8f77ccf02d01330a197e1c8127ac62b13923c57c", + "sha256": "eb0b5c6c7161e18dc22168da3211448d321586edd15bcfb4b4741174d36993cf" + }, + { + "path": "research/complex-sw4-frame8/vendor/main/research/complex-k492-owner-repair/vendor/multicold/vendor/pr559/notes/general-clifford-frames.tex", + "usage": "input", + "git_blob": "0367eeb005298601f28a673861d6f71bf1d0ebbb", + "sha256": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54" + } + ], + "pending_context": { + "repository": "CrocSwap/integer-mult-bounds", + "pull_request": 2464, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2464", + "head_commit": "f364b97ff4700147fc06e622b79952b9fe6c4fa8", + "source_path": "research/z4-typed-echo-supplier-instance/README.md", + "git_blob": "2ebd3eb14505386023cd752dca8429bb123ebf79", + "sha256": "6de043bdef2f652ca3b179e0d61e0ac127a8981378ac4f5a5f800d200f122690", + "retained_path": "inputs/PR2464-README.md", + "usage": "Context and the explicit missing-child intertwiner handoff only; no executable code imported.", + "credit": "Aaron Wang with substantial opencode assistance; mechanism from Cinna Davis with OpenAI Codex assistance, extending Ross Richardson and Sagar Thakrar." + } +} diff --git a/research/selected-dirty-reader-z4/TASK.json b/research/selected-dirty-reader-z4/TASK.json new file mode 100644 index 0000000000..7ea70fb84f --- /dev/null +++ b/research/selected-dirty-reader-z4/TASK.json @@ -0,0 +1,106 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...).", + "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": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "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": [ + "Removing copies without a replacement contract for the decoder's copied totals." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "changed", + "actual_scope": "Exclude unitary paired-four-cycle input/output intertwining for the full selected gauge44 dirty centre reader at the post-precondition/pre-entry-adapter cut, with exact native frame justification.", + "scope_change_reason": "PR2464 leaves the actual selected reader intertwiner unconstructed. The original centre-sharing gain is only a favorable relaxation until that contract is exposed. This result resolves one precise missing admission class rather than inventing a saved centre charge.", + "bottleneck_link": "Centre sharing targets 64 rank units per call. A data-only reader passes the symmetry test, but arbitrary helpers make the actual full reader fail every paired four-cycle Gram condition. This blocks direct unitary realization at this cut before any claimed sharing invoice.", + "budget_minutes": 60, + "stop_rule": "Stop after reconstructing the exact full reader, proving the native Gram obstruction at the named cut, checking meaningful positive/failure controls, and preserving explicit nonunitary and changed-cut escapes. Do not search seeds or claim a universal barrier.", + "outcome": "negative-result", + "evidence": "PROOF.md and RESULT.json: 704 full input fields, 3451 scalar gates and 992 typed climbs; two exact matrix derivations; 1260 paired-cycle rejections; signed data-only positive control; explicit nonunitary order-four escape with norm squared 8/7; seven test groups.", + "author": "ywz65", + "ai_assistance": "Substantial OpenAI Codex assistance in source inspection, proof development, code, tests and packaging. Independent agent review requested before publication; no independent human review claimed.", + "open_questions": [ + { + "question": "Can the explicit nonunitary P_t be lowered to a favorable legal native word?", + "why_it_matters": "It algebraically escapes this obstruction but may cost more than the centre savings.", + "first_step": "Lower J(Q-I)A at the named cut and charge all reads, inverse/restoration, scratch, precision and owner transport.", + "blocked_by": "No executable native realization or complete invoice is supplied." + }, + { + "question": "Does a different cut or set of copied totals admit the paired-cycle contract?", + "why_it_matters": "The precondition is nonunitary and may change the admissible action class; the theorem is cut-specific.", + "first_step": "Construct the full dirty-input reader and exact native Gram blocks before scheduling an echo.", + "blocked_by": "A new cut and its host/total-delivery contract must be named and source-bound." + } + ], + "freshness": { + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "round_start_utc": "2026-10-15T11:51:00Z", + "guidance_change": "none", + "overlap": { + "open_pr_records": 669, + "open_pr_time": "2026-10-15T11:51:30.587252Z", + "discussion_records": 1192, + "discussion_time": "2026-10-15T11:55:06.327548Z", + "complete_pagination": true, + "limits": "Bodies, discussion comments and local metadata; not every code diff. No conflicting exact scope found within this coverage." + }, + "before_review_check_utc": "2026-10-15T12:29:53.906893Z", + "before_review_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2" + }, + "claim": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2464#issuecomment-6191718626", + "status": "LOCAL-ONLY pending independent review", + "expires_utc": "2026-10-15T13:20:00Z" + }, + "first_working_example": { + "commands": [ + "python -B research/complex-local-word-ceiling/verify.py", + "python -B research/complex-local-word-ceiling/levers.py" + ], + "outcome": "PASS_COMPLEX_LOCAL_WORD_CEILING; baseline a_cap=0.00169005410908900006; shared-by-two ideal a_cap approximately0.003213 (1.90x), a planning relaxation only." + }, + "local_environment": { + "registered_python": "CPython3.12.7", + "additional_python": "CPython3.14.5", + "platform": "Windows", + "dependencies": "standard library only", + "scope": "Local focused replay only; no selected cold replay, complete native compiler audit, Lean build or hosted CI." + } +} diff --git a/research/selected-dirty-reader-z4/VERIFY.json b/research/selected-dirty-reader-z4/VERIFY.json new file mode 100644 index 0000000000..a418b30d4b --- /dev/null +++ b/research/selected-dirty-reader-z4/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/z4-persistent-pair-seed57/README.md", + "research/z4-persistent-pair-seed57/inputs/PR1391-README.md", + "research/complex-sw4-frame8/local/hpe_emit_local.py", + "research/complex-sw4-frame8/local/hpe_adapters_local.py", + "research/complex-sw4-frame8/vendor/main/research/complex-k492-owner-repair/vendor/multicold/vendor/pr559/notes/general-clifford-frames.tex" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticate source bytes and native typed segment; dual full-reader reconstruction; all1260 paired-cycle exclusions; data-only signed positive and nonunitary escape." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-O", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "Seven groups: source drift, scalar/climb frames, missing/wrong helper wrapper, singular monomial, missing signs, misleading clean-helper restriction and explicit nonunitary escape." + } + ] +} diff --git a/research/selected-dirty-reader-z4/inputs/PR2464-README.md b/research/selected-dirty-reader-z4/inputs/PR2464-README.md new file mode 100644 index 0000000000..2ebd3eb145 --- /dev/null +++ b/research/selected-dirty-reader-z4/inputs/PR2464-README.md @@ -0,0 +1,246 @@ +# z4 typed echo as a supplier instance: priced, and blocked in one obligation + +**Supplier instantiation of a certified mechanism; no new kappa and no change to +the selected record.** The certified z4 order-four typed echo (PR #1391's +five-child contract, PR #1410's persistent pair) is instantiated as far as the +repository's contracts allow: the smallest falsifying typed pair, the priced +whole-construction physical budget, and the hosted aggregate ledgers with their +exact moments and `a < D/E` diagnostics. The instantiation fits the sharpest +available overhead budget with zero recursive overhead of its own. It is +blocked in exactly one obligation, **hosting**: the named host's contract keeps +`COPY/ERASE` windows sequential and immutable and delivers totals per call, +while the typed echo must defer the first wrapper's restoration across the +second call's window. Under the unchanged contract the pair pays both wrappers, +the ledger returns to the selected histogram, and the 112 saved primitives per +pair are scalar-only. + +Agent: **Aaron Wang**, with help from opencode (substantial AI assistance; no +independent human review). Task card: [TASK.json](TASK.json) (card +`centre-path-sharing`, scope changed to the assigned kappa-blocker KB1 request; +see the recorded reason). Claim: +[discussion comment](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18947139). + +## The mechanism, rebuilt and falsified at the smallest instance + +The typed echo composes children `C_i(D,W) = (D + R_i W, P W)` with the +order-four intertwiner `R_i P = Q R_i`; a complete root echo maps +`(D, X, W) -> (D + sum R_i X, X, W)` for arbitrary dirty `D`, `X`, `W`. The +boundary schedule costs `g(k)`; this package re-derives it by an independent +dynamic program and checks it against the pinned brute force: + +| children k | 1 | 2 | 3 | 5 | 10 | +|---:|---:|---:|---:|---:|---:| +| boundary g(k) | 60 | 88 | 116 | 140 | 248 | + +**Smallest falsifying instance first: the `k = 2` typed pair.** Two one-child +echoes on children 0 and 1, fused into one two-child echo. All `4^2 = 16` phase +paths enumerated; the minimum is `g(2) = 88`. The joint word, the two separate +words and their sequential composition agree exactly as integer maps on all 56 +basis columns, which by linearity is every dirty state of `(D, X, W)`; the +literal reversed word is an exact inverse. Three schedule mutants (wrong first +output phase, omitted terminal gap, forward word substituted for the inverse) +all produce different maps and are rejected. + +Complete invoices (ADD, NEG), reproduced from the pinned predecessor numbers: + +| schedule | ADD | NEG | total | comparison | +|---|---:|---:|---:|---| +| five-child echo | 920 | 88 | 1,008 | eager 1,328 (PR #1391) | +| ten-child joint echo | 1,720 | 184 | 1,904 | two separate 2,016 (PR #1410) | +| two-child joint echo | 440 | 56 | 496 | two separate 608 (this package) | + +Prefix row-L1 peaks (the precision proxy of the predecessor packages) are 4 at +`k = 1`, 10 at `k = 2`, 20 at `k = 5`, 30 for two separate five-child calls and +42 for the joint ten-child call, reproducing PR #1410's 30/42 exactly. + +## Priced whole-construction budget + +The predecessor packages price primitives, reads and writes, and leave +"address travel, coefficient fetches and descriptor storage" unpriced. Declared +model (one machine, both schedules priced in it): rows of width 73 on a +row-indexed tape; one dispatch, one instruction fetch and one coefficient fetch +per record; ADD reads two rows and writes one, NEG reads and writes one; address +travel is `2 * max(source, target)` row-index steps per record, the +visit-source/visit-target/return convention of +`research/mutable-source-persistent-connector`; descriptor storage is 16 bits +per record plus one 128-bit call record; data storage is `56 * width` cells. + +| quantity | two separate calls (k=2) | joint k=2 | saving per pair | +|---|---:|---:|---:| +| primitives | 608 | 496 | 112 | +| dispatches | 608 | 496 | 112 | +| instruction fetches | 608 | 496 | 112 | +| coefficient fetches | 608 | 496 | 112 | +| reads | 1,168 | 936 | 232 | +| writes | 608 | 496 | 112 | +| address travel (row steps) | 53,024 | 36,944 | 16,080 | +| descriptor bits | 9,984 | 8,064 | 1,920 | +| data storage cells | 4,088 | 4,088 | 0 | + +The `k = 5+5` versus `k = 10` pair has identical savings. The saving is real at +every charged level of this model except storage, and it is scalar: no charged +quantity in the moment ledger moves. + +## Hosted ledgers, exact moments, and `a < D/E` + +The named host is the binding selected complex ledger (width `m = 73`, live +stock `W = 14,336`, `N = 144` calls, published histogram, no surcharge). The +typed echo applied to consecutive same-source call pairs is the shared-centre +ledger of `research/centre-sharing-overhead-budget`: the shared rank-8 centre +children go from 1,152 to 576 and the coverage identity from `72W + 64N` to +`72W + 32N`. Exact rational enclosures (independent atanh/Taylor engine, no +import of the retained pricing engines): + +| ledger | rank mass | D | `a < D/E` | exact moment root `a*` | +|---|---:|---:|---:|---| +| selected baseline | 1,041,408 | 5,120 | 0.0016805907097543218 | [0.001675462676, 0.001675462677] | +| shared k=2 typed echo | 1,036,800 | 9,728 | 0.003203836729943888 | [0.003185242415, 0.003185242416] | + +The baseline `D/E` matches the published 0.001680590709754321699421 to 2.4e-25 +(printing precision) and the baseline root is the recorded complex endpoint +0.0016754626768081035, whose moment residual sits in the published +`-1.30e-24` band; the next `10^-24` grid point is rejected. At the recorded bit +endpoint 0.0017334270395898442 the shared ledger gives `f(a) - 1 = -4.25e-3`, +matching `research/centre-sharing-overhead-budget`'s table entry for `k = 2`. +So with sharing the complex side stops binding and the whole bound becomes +bit-limited at `kappa = 0.001730427469823602` (+3.4536% on the selected +0.001672660197076918), which is that package's published figure, here reached +by a concrete mechanism rather than a relaxation. + +**`a < D/E` is a screen, not the acceptance test** (a control enforces this: +the exact moment at `D/E` exceeds 1 strictly). The exact moments above are the +acceptance tests. + +## Delta-H: the instantiation fits the sharpest overhead budget + +`research/centre-sharing-overhead-budget` prices the sharing lever's overhead +`Delta-H` as extra paid children: sharing saves 32 rank units per call, and the +overhead must stay under about 30.5-30.8 units per call to keep the full ++3.4536% gain, or 31.9-32.0 for any gain. The typed echo eliminates one +wrapper per pair: 8 rank-8 children, 64 rank units per pair, 32 per call. Its +own added work is scalar (frame powers, the two 24-ADD copy edges, the boundary +schedule), so its recursive overhead is 0 rank units and the elimination lands +entirely inside the budget. The measured scalar side also falls (table above). + +## The one obstruction: hosting (window lifetime and totals delivery) + +The fused pair defers the first call wrapper's `W -= X` (the ERASE analogue) +past the second call's child block. The smallest instance exhibits it exactly: +in the `k = 2` joint word all 24 work rows are dirty at the second block's +entry, where the separate schedule has already restored. The named host's +pinned contract, `research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt`, +states that `COPY/ERASE` windows remain sequential and immutable, and the +coverage identity charges one centre path per call because each call's totals +are copied out and its private temporary erased within that call. The typed +carry needs the opposite: one window spanning the pair, the first call's totals +delivered at the pair end, and uninterrupted ownership of the temporary across +the boundary. + +Everything else is charged and closes: + +- **Moment:** the shared ledger above, with `Delta-H` inside the sharp budget. +- **Scalar price:** fully paid, and smaller than the separate schedule. +- **Dirty state and restoration:** exact on all 56 basis columns. +- **Precision:** quantified but not closed (see the open questions); the carry + raises prefix row-L1 from 30 to 42 at the persistent pair. + +Under the unchanged contract the pair pays both wrappers: the histogram stays +`n_8 = 1152`, the moment is exactly the selected one, and no kappa change +follows from 112 saved primitives. The contract change would also require a +child exposing the order-four intertwiner `R P = Q R` (the certified typed +contract; no named host child exposes one) and a common sink for the pair's +totals, the first blocker of PR #1748. + +The source-bound side of the same obstruction is already recorded on the named +schedule: `research/selected-centre-adjacent-pair-seed01fcb1` censused all 143 +adjacent ordered call pairs of the pinned selected 144-call schedule and found +no pair sharing a single physical owner among its eight centre source rows, so +no adjacent pair meets even a zero-transport shared-source boundary. That +census leaves aliases, copied values, nontrivial linear maps between owners, +nonadjacent calls and a changed schedule open; those escapes are paid owner or +chart transport, which is this same hosting obligation. This package does not +rerun that census; it adds the window-lifetime and delivery side at the word +level and prices the mechanism. + +**Bounded pivot (one): the single-call realization.** Make the pair one +supplier call from the start, so its single window stays sequential and +immutable. The per-call totals-delivery contract then makes the fused call copy +both calls' totals: 16 rank-8 children per pair, 128 rank units, exactly the +two-wrapper baseline. The ledger returns to the selected histogram and the +moment is identical (checked exactly). Delivering one shared set of totals +instead is the same common-sink contract change the obstruction names, so the +pivot does not escape the obligation. The route stops here. + +## Reproduce + +Python 3.12+ standard library and `git`, from the repository root: + +```sh +python3 -B research/z4-typed-echo-supplier-instance/verify.py +python3 scripts/research_package.py --package research/z4-typed-echo-supplier-instance --check-only +``` + +Expected final line: + +```text +PASS_Z4_TYPED_ECHO_SUPPLIER_INSTANCE smallest_k2 whole_price saved=112 D_over_E_shared=306866593893834978883114841401737599624288907847049/95780971304118053647396689196894323976171195136475136 controls=51 no_new_kappa +``` + +`--write` regenerates [RESULT.json](RESULT.json); the default run recomputes +and rejects drift. The engine re-checks the pinned PR #1391 emitter and +certificate hashes before importing the word emitter; all other arithmetic +(boundary recurrence, maps, invoices, tape model, ledger moments, `ln`/`exp` +enclosures) is implemented independently in this package. 51 controls cover the +mechanism reproductions, the smallest-instance map and inverse identities, +three schedule mutants, the wrapper counts and the deferred-restoration +witness, the whole-price dispatch charges, the row-L1 reproduction, both +coverage identities, the published `D/E` and moment-residual bands, the +`D/E`-is-not-acceptance control, the `Delta-H` budget fit, the pivot's +identical moment, and three mutated-ledger rejections. + +**Not checked:** any native or hosted emission, the registered 3.12 replay +environment beyond this file's commands, the complex host's precision bucket +law, all-size/compiler, common-label/mutable-source realization, tape, +analytic transfer and the bit H1-H5 obligations. This is not a multiplication +theorem and does not admit any supplier. + +## Open next questions + +- **Does a named selected supplier admit a widened `COPY/ERASE` window with + per-pair totals delivery?** This is the single contract change the + instantiation needs; the shared ledger would then accept at `a* = 0.0031852` + and move the binding side to the bit primitive. First step: inspect one + retained supplier's owner-map window definitions and totals schedule for a + consecutive same-sink pair, and price the widened window as extra live + families. Blocked by the pinned immutable-window sentence and the absence of + a child exposing `R P = Q R`. +- **Can a named host price the carry's precision envelope?** The measured cost + is the prefix row-L1 rise 30 to 42. First step: propagate the joint word's + exact prefix coefficient envelope through a host's fixed precision buckets + (the 192/512-bit conventions used in the bit invoice). Blocked by the complex + host's bucket law not being pinned in a chargeable form. + +## Credit and scope + +Mechanism and certified invoices: **PR #1391** (order-four paired frames) and +**PR #1410** (persistent pair), both by Cinna Davis with OpenAI Codex +assistance, extending Ross Richardson's PR #1287 and Sagar Thakrar's PR #1227; +the heterogeneous variants are PR #1768 and PR #2098. The shared-centre +scalar-macro halves are **PR #1708** (1337isnot1337) and **PR #1748** +(ToikY). The lever's sharp overhead budgets and the bit-limited kappa figure +are `research/centre-sharing-overhead-budget` (rtyu193-rgb); the adjacent-pair +owner census is `research/selected-centre-adjacent-pair-seed01fcb1`; the moment +enclosure technique and the published `D/E` are `research/selected-suppliers-de-diagnostic` +(Navinor) and the pricing model is Douglas Colkitt's +`research/complex-local-word-ceiling` with PR #1012's coverage identity. The +immutable-window sentence is from the PR #386 bit geometry (Dylan Crow lineage) +as pinned in `research/split-centres-global`. The tape convention is +`research/mutable-source-persistent-connector` (woklerx). The task-draw scope +change and its reason are recorded in [TASK.json](TASK.json); the pair-collision +check and overlap refresh are recorded there and in the claim. + +New package material is Apache-2.0. Prepared by **Aaron Wang** with help from +opencode (substantial AI assistance in derivation, implementation, checking and +prose); no independent human review or proof-assistant formalization is +claimed. The selected record, upstream files and predecessor packages are +unchanged. diff --git a/research/selected-dirty-reader-z4/test_verify.py b/research/selected-dirty-reader-z4/test_verify.py new file mode 100644 index 0000000000..bc0cfc050d --- /dev/null +++ b/research/selected-dirty-reader-z4/test_verify.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Meaningful controls for the selected-reader boundary and exact obstruction.""" +import copy +import importlib.util +from pathlib import Path +import tempfile +import unittest + +SPEC = importlib.util.spec_from_file_location("reader_audit", Path(__file__).with_name("verify.py")) +v = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(v) + + +class Controls(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.data = v.load() + cls.gates, _ = v.typed_segment(cls.data) + cls.A = v.reader(cls.gates) + full = cls.data["LOCAL-PROGRAMS.json.gz"]["forward"] + cls.segment = full[full.index(["phase", "entry_adapters"]):full.index(["phase", "centers"])] + + def test_live_source_byte_drift(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + path = root / v.ARCHIVE + path.parent.mkdir(parents=True) + path.write_bytes((v.ROOT / v.ARCHIVE).read_bytes() + b"drift") + with self.assertRaisesRegex(ValueError, "live source hash"): + v.load(root) + + def test_frame_mismatch_and_missing_helper_entry(self): + events = copy.deepcopy(self.segment) + gate = next(e for e in events if e[0] == "scalar") + gate[2] = -1 + with self.assertRaisesRegex(ValueError, "scalar target frame"): + v.typed_segment(self.data, events) + events = [e for e in self.segment if not (e[0] in ("adapter", "residual_adapter") and e[2] == 224)] + with self.assertRaisesRegex(ValueError, "complete entry inventory"): + v.typed_segment(self.data, events) + + def test_wrong_climb_and_residual_wrapper(self): + events = copy.deepcopy(self.segment) + next(e for e in events if e[0] == "climb")[3] = -1 + with self.assertRaisesRegex(ValueError, "climb source frame"): + v.typed_segment(self.data, events) + events = copy.deepcopy(self.segment) + e = next(e for e in events if e[0] == "residual_adapter") + e[0], e[1] = "adapter", "old_to_new" + with self.assertRaisesRegex(ValueError, "actual entry wrapper kind"): + v.typed_segment(self.data, events) + + def test_nonbijective_native_monomial(self): + recipe = copy.deepcopy(self.data["CLIFFORD-RECIPES.json"]["children"][0]["left"]) + recipe["matrix_rows"][0] = 0 + with self.assertRaisesRegex(ValueError, "invertible monomial"): + v.monomial(recipe) + + def test_data_only_positive_is_insufficient(self): + R = [row[:112] for row in self.A] + self.assertEqual(v.gram(R), [[v.F(56 if i == j else 0) for j in range(8)] for i in range(8)]) + with self.assertRaisesRegex(ValueError, "paired cycle survives"): + v.rejects_every_paired_cycle([56]*8) + self.assertEqual(len(v.rejects_every_paired_cycle(v.NORMS)), 1260) + + def test_drop_negative_signs_breaks_data_intertwiner(self): + columns = list(zip(*(row[:112] for row in self.A))) + index = {c: j for j, c in enumerate(columns)} + P = [] + for c in columns: + target = tuple(c[i] for i in v.Q_ROWS) + sign = 1 if target in index else -1 + P.append((index[tuple(sign*x for x in target)], sign)) + v.check_signed_intertwiner(columns, P) + with self.assertRaisesRegex(ValueError, "RP equals QR"): + v.check_signed_intertwiner(columns, [(j, 1) for j, _ in P]) + + def test_actual_helper_witness_and_paid_escape(self): + h = [r[224] for r in self.A] + self.assertEqual(h, [0, 2, 2, 0, 0, 0, 0, 0]) + qh = tuple(h[i] for i in v.Q_ROWS) + self.assertNotIn(qh, set(zip(*self.A))) + self.assertNotIn(tuple(-x for x in qh), set(zip(*self.A))) + R = [row[:112] for row in self.A] + delta = [sum(R[k][j]*(qh[k]-h[k])/56 for k in range(8)) for j in range(112)] + self.assertEqual(1 + sum(x*x for x in delta), v.F(8, 7)) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/selected-dirty-reader-z4/verify.py b/research/selected-dirty-reader-z4/verify.py new file mode 100644 index 0000000000..23260ccb3a --- /dev/null +++ b/research/selected-dirty-reader-z4/verify.py @@ -0,0 +1,336 @@ +#!/usr/bin/env python3 +"""Selected dirty centre reader: a source-bound paired-cycle obstruction. + +By ywz65 with substantial OpenAI Codex assistance. Apache-2.0. +Native interpretation retains the pinned exact unitary-frame identities. +""" +import argparse +from collections import Counter +from fractions import Fraction as F +import gzip +import hashlib +import io +import itertools +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +ARCHIVE = "research/community-frontier1094-audit/selected-replay.tar.gz" +PREFIX = "candidate/strict/global/base/providers/gauge44/" +MEMBERS = { + "CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "LOCAL-CHECKS.json": "2b8b1891a736598010232bfb26abc31973b265a53a2009a3fcfd9138b5ecadb4", + "SCALAR-FRAME-AUDIT.json": "0e2a979aae1b948e1bee6c49c218f3ce7d7df00814b3f53b3d0866497510a28b", + "CLIFFORD-RECIPES.json": "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731", + "CLIFFORD-REVIEW.json": "cb0e10a8b284f176526c17177e91186ce09aa3e88b4f6acc561051daa072b0d0", + "RESIDUAL-ADAPTERS.json": "383f40aadd00a4ac700dfd0d4c22d6c6c0be9a9863116e4d69c7acd23bafae0c", +} +Q_ROWS = (3, 0, 1, 2, 7, 4, 5, 6) +CENTRES = (92, 57, 81, 224, 11, 240, 9, 256) +NORMS = (150, 130, 146, 134, 122, 126, 142, 146) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def encoded(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str).encode() + + +def load(root=ROOT): + sources = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + inputs = {} + for pin in sources["files"]: + if pin["usage"] == "input": + raw = (root / pin["path"]).read_bytes() + need(digest(raw) == pin["sha256"], "live source hash: " + pin["path"]) + inputs[pin["path"]] = raw + predecessor = json.loads((HERE / "PREDECESSOR.json").read_text(encoding="utf-8")) + need(predecessor["head_commit"] == "f364b97ff4700147fc06e622b79952b9fe6c4fa8" and + predecessor["sha256"] == "6de043bdef2f652ca3b179e0d61e0ac127a8981378ac4f5a5f800d200f122690", + "PR2464 handoff pin") + need(digest((HERE / predecessor["retained_path"]).read_bytes()) == predecessor["sha256"], + "retained PR2464 handoff bytes") + decoded = {} + with tarfile.open(fileobj=io.BytesIO(inputs[ARCHIVE]), mode="r:gz") as archive: + for name, expected in MEMBERS.items(): + matches = [m for m in archive.getmembers() if m.name == PREFIX + name] + need(len(matches) == 1 and matches[0].isfile(), "unique member: " + name) + raw = archive.extractfile(matches[0]).read() + need(digest(raw) == expected, "member hash: " + name) + decoded[name] = json.loads(gzip.decompress(raw) if name.endswith(".gz") else raw) + return decoded + + +def binary_basis(vectors): + basis = {} + for vector in vectors: + for bit in sorted(basis, reverse=True): + if vector >> bit & 1: + vector ^= basis[bit] + if vector: + basis[vector.bit_length() - 1] = vector + return basis + + +def monomial(recipe): + """A bijective affine address map times powers of i is exactly unitary.""" + rows = recipe["matrix_rows"] + need(len(rows) == 9 and all(type(r) is int and 0 <= r < 512 for r in rows), "monomial rows") + need(len(binary_basis(rows)) == 9, "invertible monomial") + need(type(recipe["offset"]) is int and 0 <= recipe["offset"] < 512, "monomial offset") + need(type(recipe["phase"]) is int and recipe["phase"] in range(4), "unit phase") + need(len(recipe["linear_Z4"]) == len(recipe["quadratic_rows"]) == 9, "phase dimensions") + need(all(type(x) is int and x in range(4) for x in recipe["linear_Z4"]), "linear phase") + need(all(type(x) is int and 0 <= x < 512 for x in recipe["quadratic_rows"]), "quadratic phase") + + +def typed_segment(data, events=None): + word = data["CANONICAL-WORD.json.gz"] + complete = data["LOCAL-PROGRAMS.json.gz"]["forward"] + need(digest(encoded(complete)) == data["LOCAL-CHECKS.json"]["forward"]["sha256"], "emitted program binding") + need((word["v"], word["R"], word["h"]) == (112, 480, 9), "selected dimensions") + need(tuple(word["centers"]) == CENTRES, "ordered centre fields") + first = complete.index(["phase", "entry_adapters"]) + last = complete.index(["phase", "centers"]) + prefix_scalars = 0 + for event in complete[:first]: + if event == ["phase", "zero_frame_precondition"]: + continue + need(event[0] == "scalar", "invertible pre-entry prefix") + op, frame = event[1:] + need(op[0] in ("add", "scale") and frame == 0, "zero-frame prefix alphabet") + fields = [op[1]] + ([op[2]] if op[0] == "add" else []) + need(all(f[0] == "L" and word["start"][f[1]] == 0 for f in fields), "prefix field frame") + if op[0] == "add": + need(op[1] != op[2] and F(op[3], op[4]) != 0, "invertible prefix addition") + else: + need(F(op[2], op[3]) != 0, "invertible prefix scale") + prefix_scalars += 1 + segment = complete[first:last] if events is None else events + frames = word["frames"] + current = list(word["start"]) + need(len(current) == 704, "all arbitrary input fields") + wrapped = {r for r in range(224, 704) if current[r] != 0 or word["final"][r] != 1} + children = {(r["old"], r["new"]): r for r in data["CLIFFORD-RECIPES.json"]["children"]} + seen, scalar, kinds = set(), [], Counter() + for event in segment: + kind = event[0] + kinds[kind] += 1 + if kind in ("adapter", "residual_adapter"): + if kind == "adapter": + need(event[1] == "old_to_new", "entry direction") + else: + need(event[1] == "pre", "residual entry direction") + field, frame = event[2:4] + need(field not in seen and current[field] == frame, "one typed entry per field") + need((kind == "residual_adapter") == (field in wrapped), "actual entry wrapper kind") + if kind == "residual_adapter": + terminal = event[4] if len(event) == 5 else 1 + need(terminal == word["final"][field], "residual terminal frame") + key = str(frame) if terminal == 1 else str(frame) + ":" + str(terminal) + need(key in data["RESIDUAL-ADAPTERS.json"]["recipes"], "residual recipe binding") + seen.add(field) + elif kind == "climb": + _, part, field, old, new, rank = event + need(part == "A" and current[field] == old, "climb source frame") + need(len(binary_basis(frames[old] + frames[new])) == len(frames[new]), "nested frames") + need(rank == len(frames[new]) - len(frames[old]) > 0, "climb rank") + need((old, new) in children and children[old, new]["rank"] == rank, "emitted child recipe") + current[field] = new + elif kind == "scalar": + op, frame = event[1:] + need(op[0] in ("add", "scale") and op[1][0] == "L", "A scalar alphabet") + target = op[1][1] + need(current[target] == frame, "scalar target frame") + if op[0] == "add": + need(op[2][0] == "L" and op[2][1] != target, "independent scalar source") + need(current[op[2][1]] == frame, "scalar source frame") + need(F(op[3], op[4]) != 0, "nonzero addition") + else: + need(F(op[2], op[3]) != 0, "invertible scale") + scalar.append(op) + else: + need(event in (["phase", "entry_adapters"], ["phase", "A"]), "known segment event") + need(seen == set(range(704)), "complete entry inventory") + need([current[c] for c in CENTRES] == word["center_frames"], "exact output frames") + need(len(scalar) == 3451 and kinds["climb"] == 992, "exact segment extent") + # Bind the inherited exact frame identities; independently check unitarity + # of every emitted local monomial, without pretending it fixes constants. + review = data["CLIFFORD-REVIEW.json"] + need(review["all_child_equalities_include_global_phase"] is True, "retained exact phase contract") + need(review["recipe_sha256"] == MEMBERS["CLIFFORD-RECIPES.json"], "retained recipe binding") + need(review["canonical_word_sha256"] == MEMBERS["CANONICAL-WORD.json.gz"], "retained word binding") + audit = data["SCALAR-FRAME-AUDIT.json"] + need(audit["status"] == "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES" and + audit["live_columns_each_orientation"] == 704 and audit["helpers"] == 480, + "retained scalar-frame audit") + recipes = data["CLIFFORD-RECIPES.json"]["children"] + data["CLIFFORD-RECIPES.json"]["endpoint_adapters"] + recipes += list(data["RESIDUAL-ADAPTERS.json"]["recipes"].values()) + checks = 0 + for recipe in recipes: + for side in ("left", "right"): + if recipe[side] is not None: + monomial(recipe[side]) + checks += 1 + return scalar, {"event_range": [first, last], "event_counts": dict(kinds), "monomial_unitarity_checks": checks, + "invertible_pre_entry_scalar_gates": prefix_scalars, + "input_fields": 704, "output_fields": list(CENTRES), "output_frames": word["center_frames"]} + + +def sparse_add(target, source, coefficient): + for index, value in source.items(): + target[index] = target.get(index, F(0)) + coefficient * value + if not target[index]: + del target[index] + + +def reader(gates): + rows = [{i: F(1)} for i in range(704)] + for gate in gates: + target = gate[1][1] + if gate[0] == "scale": + rows[target] = {i: x * F(gate[2], gate[3]) for i, x in rows[target].items()} + else: + sparse_add(rows[target], rows[gate[2][1]], F(gate[3], gate[4])) + result = [rows[i] for i in CENTRES] + # Separate reverse pullback of eight covectors through the scalar word. + reverse = [{i: F(1)} for i in CENTRES] + for gate in reversed(gates): + target = gate[1][1] + for row in reverse: + value = row.get(target, F(0)) + if gate[0] == "scale": + if value: + row[target] = value * F(gate[2], gate[3]) + elif value: + sparse_add(row, {gate[2][1]: value}, F(gate[3], gate[4])) + need(result == reverse, "independent full-input pullback") + return [[row.get(j, F(0)) for j in range(704)] for row in result] + + +def gram(rows): + return [[sum(a*b for a, b in zip(r, s)) for s in rows] for r in rows] + + +def cycles(permutation): + todo, result = set(range(len(permutation))), [] + while todo: + at, cycle = min(todo), [] + while at in todo: + todo.remove(at) + cycle.append(at) + at = permutation[at] + result.append(cycle) + return result + + +def rejects_every_paired_cycle(diagonal): + rejected = [] + for permutation in itertools.permutations(range(8)): + if sorted(map(len, cycles(permutation))) == [4, 4]: + witnesses = [i for i in range(8) if diagonal[i] != diagonal[permutation[i]]] + need(bool(witnesses), "paired cycle survives diagonal Gram condition") + rejected.append([permutation, witnesses[0]]) + need(len(rejected) == 1260, "all paired-cycle output relabellings") + return rejected + + +def check_signed_intertwiner(columns, P): + need(len(P) == len(columns), "signed action dimension") + need(len({p for p, _ in P}) == len(P), "data-only signed permutation") + for j in range(len(P)): + at, sign = j, 1 + for _ in range(4): + at, edge = P[at] + sign *= edge + need((at, sign) == (j, 1), "data-only P fourth power") + need(tuple(P[j][1]*x for x in columns[P[j][0]]) == + tuple(columns[j][i] for i in Q_ROWS), "RP equals QR") + + +def multiply(left, right): + return [[sum(a*b for a, b in zip(row, col)) for col in zip(*right)] for row in left] + + +def calculate(): + data = load() + gates, boundary = typed_segment(data) + A = reader(gates) + G = gram(A) + diagonal = tuple(G[i][i] for i in range(8)) + need(diagonal == NORMS, "actual arbitrary-dirty row norms") + need(max(Counter(diagonal).values()) == 2, "no possible four-cycle of equal row norms") + rejected = rejects_every_paired_cycle(diagonal) + R = [row[:112] for row in A] + need(gram(R) == [[F(56 if i == j else 0) for j in range(8)] for i in range(8)], "data-only positive Gram control") + columns = list(zip(*R)) + index = {column: j for j, column in enumerate(columns)} + need(len(index) == 112 and len({min(c, tuple(-x for x in c)) for c in columns}) == 112, "unique signed data columns") + P = [] + for column in columns: + target = tuple(column[i] for i in Q_ROWS) + sign = 1 if target in index else -1 + need(tuple(sign*x for x in target) in index, "data-only signed intertwiner exists") + P.append((index[tuple(sign*x for x in target)], sign)) + check_signed_intertwiner(columns, P) + need(any(sign < 0 for _, sign in P), "unsigned-permutation mutation changes the positive control") + helper = [row[224] for row in A] + transformed = [helper[i] for i in Q_ROWS] + all_columns = set(zip(*A)) + need(tuple(transformed) not in all_columns and tuple(-x for x in transformed) not in all_columns, "explicit absent dirty helper image") + # J = [R^T/56; 0] is a right inverse of A. Thus the deliberately + # nonunitary P_t = I + J(Q^t-I)A supplies an algebraic escape, for t=1..4. + J = [[R[k][j] / 56 for k in range(8)] for j in range(112)] + need([[sum(A[i][j]*J[j][k] for j in range(112)) for k in range(8)] for i in range(8)] == + [[F(i == k) for k in range(8)] for i in range(8)], "explicit right inverse") + identity = [[F(i == j) for j in range(8)] for i in range(8)] + powers = [identity] + for _ in range(4): + powers.append([powers[-1][i] for i in Q_ROWS]) + need(powers[4] == identity and powers[2] != identity, "exact order four") + differences = [[[power[i][j]-identity[i][j] for j in range(8)] for i in range(8)] for power in powers[:4]] + for s, t in itertools.product(range(4), repeat=2): + product = multiply(differences[s], differences[t]) + need([[differences[s][i][j]+differences[t][i][j]+product[i][j] for j in range(8)] for i in range(8)] == + differences[(s+t) % 4], "nonunitary low-rank group law") + difference = [x-y for x, y in zip(transformed, helper)] + delta = [sum(row[k]*difference[k] for k in range(8)) for row in J] + escape_norm = 1 + sum(x*x for x in delta) + need(escape_norm == F(8, 7), "nonunitary escape boundary") + return {"status": "PASS_SELECTED_DIRTY_READER_Z4", "member_sha256": MEMBERS, "boundary": boundary, + "reader": [[str(x) for x in row] for row in A], "gram": [[str(x) for x in row] for row in G], + "row_norms": list(NORMS), "helper_only_row_norms": [n-56 for n in NORMS], + "paired_cycle_rejections": rejected, "data_only_P_columns": P, + "dirty_helper_witness": {"input": 224, "column": helper, "Q_column": transformed}, + "nonunitary_escape": {"formula": "I + J (Q-I) A, J=[R^T/56;0]", "norm_squared_on_e224": str(escape_norm), + "low_rank_group_law_pairs": 16}, + "limits": "Exact selected entry-adapter-to-centres cut; all 704 dirty input fields. Unitary input actions and unitary block-permutation output actions with paired 4-cycles excluded. Exact native frame identities inherited; no global supplier claim."} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = calculate() + text = json.dumps(result, sort_keys=True, indent=2, default=str) + "\n" + path = HERE / "RESULT.json" + if args.write_result: + with path.open("x", encoding="utf-8", newline="\n") as out: + out.write(text) + else: + need(path.read_text(encoding="utf-8") == text, "committed receipt mismatch") + print("PASS_SELECTED_DIRTY_READER_Z4 inputs=704 rows=8 paired_cycles=1260 data_only_control=pass nonunitary_escape=8/7 no_new_kappa") + + +if __name__ == "__main__": + main()