From e4a109415e7f85224588d27bce352b7037e3727c Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 20:57:57 +0000 Subject: [PATCH 01/11] Draft p104-carrier-code-uniqueness package (certificate pending) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYmAARGrLk38Gj9eUPzP --- .../p104-carrier-code-uniqueness/PROOF.md | 215 ++++++++++++++++++ .../p104-carrier-code-uniqueness/README.md | 136 +++++++++++ .../p104-carrier-code-uniqueness/SOURCES.json | 30 +++ .../p104-carrier-code-uniqueness/TASK.json | 81 +++++++ .../p104-carrier-code-uniqueness/VERIFY.json | 34 +++ .../p104-carrier-code-uniqueness/code8.py | 153 +++++++++++++ research/p104-carrier-code-uniqueness/gen8.py | 35 +++ .../p104-carrier-code-uniqueness/replay.py | 188 +++++++++++++++ .../p104-carrier-code-uniqueness/verify.py | 201 ++++++++++++++++ .../p104-carrier-code-uniqueness/wordcode.py | 112 +++++++++ 10 files changed, 1185 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/PROOF.md create mode 100644 research/p104-carrier-code-uniqueness/README.md create mode 100644 research/p104-carrier-code-uniqueness/SOURCES.json create mode 100644 research/p104-carrier-code-uniqueness/TASK.json create mode 100644 research/p104-carrier-code-uniqueness/VERIFY.json create mode 100644 research/p104-carrier-code-uniqueness/code8.py create mode 100644 research/p104-carrier-code-uniqueness/gen8.py create mode 100644 research/p104-carrier-code-uniqueness/replay.py create mode 100644 research/p104-carrier-code-uniqueness/verify.py create mode 100644 research/p104-carrier-code-uniqueness/wordcode.py diff --git a/research/p104-carrier-code-uniqueness/PROOF.md b/research/p104-carrier-code-uniqueness/PROOF.md new file mode 100644 index 0000000000..45cd6daafd --- /dev/null +++ b/research/p104-carrier-code-uniqueness/PROOF.md @@ -0,0 +1,215 @@ +# Proof: the length-8 P104 decoding code is unique + +Prepared for Matarener with Claude (Anthropic), via Claude Code. + +## 1. Setting + +We use the P104 local word in the accumulated-block schema +(`p104-accumulated-block-composition/2`). The pinned inputs are the PR5907 +word (`research/p104-helper468-rung-removal/WORD.json.gz`) and the selected +PR6030 word (`research/p104-helper470-twin-rung-removal/WORD.json.gz`). +The checker rules used below are the following: + +- Each role carries a row and sits in a frame, which is a subspace of `F_2^9`. +- `ADD`, `COPY` and `SCALE` act only between roles in the same frame. +- `COPY` writes only into owned roles. +- `INIT` and `CLEAR` empty an owned row. +- A public role only moves up: its frame grows. +- An owned role only moves down: its frame shrinks. +- The paid cost of a move is the dimension difference. + +There are 104 live roles. Live `l` starts in ``, where `q_l` is an +odd-weight port vector. Its partner `l + 112` starts at `{0}` and ends in +the hyperplane `q_l^perp`. The live projection of the partner's final row is +`e_l`. Ports `i` and `j` *conflict* when ` = 1`. Because every port +has odd weight, `q_l` does not lie in `q_l^perp`. + +## 2. From words to decoding codes + +**Lemma 1 (frame decomposition).** Split every public row into two parts: + +- a *lives-in-frame* part, which grows only by ADDs between public roles; +- an *owned-delivered* part, which collects everything received from owned roles. + +Then the lives-in-frame part of a public role is always supported on lives +whose ports lie in the role's current frame. + +*Proof.* The claim holds at the start, since live `l` holds `e_l` in `` +and every other public role is empty. An ADD from public role `s` into public +role `r` happens in a common frame `F`. By induction, the support of the source +lies on ports in `F`. A public role's frame only grows, so the support stays +inside its later frames. SCALE preserves supports, and COPY never targets a +public role. Owned content enters only the owned-delivered part. ∎ + +`wordcode.decompose` checks this invariant after every event of both words. + +**Corollary 2.** Let `w_l` be the owned-delivered part of partner `l + 112` at +the end. Then `w_l[l] = 1` and `w_l[m] = 0` for every port `m` that conflicts +with `l`. + +*Proof.* The partner's frame only grows and ends at `q_l^perp`, so it always +lies inside `q_l^perp`. By Lemma 1, the lives-in-frame part is supported on +ports in `q_l^perp`. That set contains neither `l` nor any port conflicting +with `l`. The endpoint is `e_l = lives-in-frame + w_l`, which gives the claim +on those coordinates. ∎ + +**Definition.** A *decoding code* over a field `K` is a subspace +`W <= K^104` that contains, for every port `l`, a vector `w_l` with +`w_l[l] = 1` and `w_l[m] = 0` for every `m` conflicting with `l`. + +Let `T` be a conflict clique of size 8; `T_INDEX` is one. Then the vectors +`w_t` for `t` in `T`, restricted to `T`, form the identity, so +`dim W >= 8`. By Corollary 2, the span of the partner parts `w_l` of any legal +word is a decoding code over `Q`. + +**Reduction mod 3.** Assume all scalars of the word are dyadic, so every row +is 3-integral. Let `W` be a decoding code over `Q` of dimension 8 that is +spanned by 3-integral decoding vectors. Then the reduction mod 3 of the +saturated lattice `W ∩ Z_(3)^104` is an 8-dimensional decoding code over +`F_3`. Reducing a 3-primitive multiple of a nonzero vector of `W` gives a +nonzero vector whose support is contained in the original support. + +## 3. The finite model over F_3 + +Let `W` be an 8-dimensional decoding code over `F_3`. Restriction to `T` is +then a bijection `W -> F_3^T`, so the vectors `w_t` (`t` in `T`) form a basis. + +For a port `j` outside `T`, write `w_j = sum_t a_{j,t} w_t`. Evaluating at +`t'` in `T` gives `a_{j,t'} = w_j[t']`, which is 0 when `t'` conflicts with +`j`. So `a_j` is supported on `T_j`, the members of `T` orthogonal to `q_j`. +For every `j` outside `T`, `|T_j| = 4`; `Model.__init__` asserts this. + +The unknowns are: + +- the 384 trits `x_{t,m} = w_t[m]`, for `m` not conflicting with `t`; +- the coefficient vectors `a_j`. + +On the clique the values are fixed: `w_t[t] = 1`, and `w_t[m] = 0` for every +`m` conflicting with `t`, which includes `T \ {t}`. Port `j` contributes these +equations, which are linear in `x` once `a_j` is fixed: + +- `sum_t a_{j,t} x_{t,j} = 1`; +- `sum_t a_{j,t} w_t[m] = 0` for every `m` conflicting with `j`. + +`Model.equations` builds exactly these. + +**Gauge.** A diagonal sign matrix `D` maps decoding codes to decoding codes +(`w_l -> D_ll^{-1} w_l D`). It preserves zero patterns and weights, and sends +`a_{j,t}` to `D_jj^{-1} a_{j,t} D_tt`. + +The search assigns ports one at a time. It keeps a partition of `T` into sign +classes, where two members are in the same class once their relative sign is +fixed by an assigned `a_j`. An option `a_j` is *canonical* when two conditions +hold: + +1. its first nonzero entry is 1; +2. on the first member of every class it meets that is not the class of its + first entry, its entry is 1. + +*Completeness.* Take any solution and any node on its path. Fix the first +entry with `D_jj`. Then flip, one at a time, each further class that `a_j` +meets. A flip negates `D_tt` on the whole class, and also `D_{j'j'}` for every +earlier port `j'` whose support lies in that class. Earlier options keep their +form, because the support of each earlier option lies inside a single merged +class. The result is a gauge-equivalent solution that agrees with the node and +is canonical at `j`. By induction every solution is gauge-equivalent to one +reached by the search. + +*Branching.* At a node with free ports `R`, the completions are the disjoint +union, over the canonical consistent options `c` of any single port `j` in +`R`, of the completions below `(j, c)`. So any branching order gives a +complete enumeration. `gen8.py` picks the most constrained port (MRV); the +replay simply accepts the port named in the certificate. Consistency means the +accumulated linear system over `F_3` has no row `0 = 1`. It is maintained by +exact incremental Gaussian elimination on bitmasks. + +## 4. The certificate + +`gen8.py` wrote a pre-order token stream: + +- `n j`: an internal node branching on `j`; +- `d j`: a dead node, where `j` has no canonical consistent option; +- `s`: a leaf with all 96 ports assigned. + +The root options are split into four parts by option index modulo 4. The parts +were generated on Kaggle, one process per part, and are stored in +`cert/part*.txt.gz`. Their node counts are in `RESULT.json`. + +`replay.replay` re-runs the model along the stream and checks the following: + +- At every internal node it recomputes all canonical consistent options of the + named port and descends into each in order. +- At every dead node it checks that there is no such option. +- At every leaf it checks that no port is left. +- Every stream must end exactly when its subtree ends. + +The certificate is therefore only a branching schedule. Every claim about +options is recomputed, so a wrong certificate can fail but cannot hide a +solution. + +## 5. Result + +**Theorem 3.** Up to the sign gauge, there is exactly one 8-dimensional +decoding code over `F_3` on the 104 P104 ports. The four parts contain one +leaf in total, and its linear system has no free variable. The code `C*` has +these properties: + +- its decoding vectors are unique at every port; +- its decoding matrix `M = (w_l[m])` is sign-equivalent to `M^T`, so the + column code is `C*` up to signs; +- its weight distribution is the one recorded in `RESULT.json`, with + minimum weight 49 (208 words), then 52 (32), 62 (16), 65 (448), and so on. + +The weight-52 owned deliveries of both pinned words (ten each) span exactly +`C*` up to signs. + +**Lemma 4 (frame capacity).** A hyperplane of `F_2^9` contains at most 60 +ports, and a subspace of codimension 2 contains at most 36. `verify.py` +checks this by enumerating all subspaces. Hence any 49 ports span a space of +dimension at least 8. + +## 6. Scoped cost corollary + +**Corollary 5.** Take a legal word with dyadic scalars whose partner code +`W_P = span{w_l}` has dimension 8. Assume `W_P` has a basis `v_1, ..., v_8` +of delivered vectors, each carried down one owned chain. A chain is a +sequence of owned lives linked by same-frame COPY/ADD, and its cost is its +total paid descent. Make two single-stage assumptions: + +- the live support of `v_c` lies on ports of the chain's root frame; +- every partner `l` with `a_{l,c} != 0` in `w_l = sum_c a_{l,c} v_c` receives + `v_c` from that chain, in a common frame. + +Then every chain costs at least 7, so the eight chains cost at least 56 per +call. This is exactly what the PR5907 word pays: chains 8→4→3→1 four times, +8→7→1 three times and 8→5→1 once. + +*Proof.* Reducing `W_P` mod 3 gives `C*` up to signs (section 2 and +Theorem 3). So `v_c` has at least 49 nonzero live coordinates. By Lemma 4, +its root frame has dimension at least 8. + +The vector `(a_{l,c})_l` is the functional "coefficient of `v_c`" evaluated +on the `w_l`. It is therefore a nonzero vector of the column space of `M` +over `Q`. That column space reduces mod 3 to the column code of `C*`, which is +`C*` up to signs. So at least 49 partners receive `v_c`. + +A receiving partner's frame lies inside `q_l^perp`. The chain's frames only +shrink, so its lowest frame `B` lies in `q_l^perp` for every receiver, that +is, in the orthogonal complement of the span of at least 49 ports. That span +has dimension at least 8, so `dim B <= 1`. The chain descends from dimension +at least 8 to at most 1, so it costs at least 7. ∎ + +## 7. Limits + +- **Larger partner codes are open.** The corollary needs `dim W_P = 8`. + The selected PR6030 word has `dim W_P = 9` mod 3: one bookkeeping direction + outside `C*`. Its ten weight-52 carrier deliveries still span `C*`. So the + corollary describes PR6030's carriers but does not bound PR6030 as written. + Codes of dimension 9 or more, and their cheapest carriers, are not + classified here. +- **Multi-stage designs are not covered.** In such designs partners receive + mixtures relayed through public roles, so a carrier's receivers are not + forced to reach 49. +- **No new kappa is claimed.** The result removes "cheaper carriers for the + same eight-dimensional code" as a source of paid-H1 savings in the local + word. diff --git a/research/p104-carrier-code-uniqueness/README.md b/research/p104-carrier-code-uniqueness/README.md new file mode 100644 index 0000000000..b041eb1211 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/README.md @@ -0,0 +1,136 @@ +# The eight-carrier code of the P104 local word is unique + +**This is a scoped negative result. No new κ is claimed.** + +Every legal P104 local word decodes through owned deliveries. The owned part +`w_l` delivered to partner `l + 112` has two properties. Its coordinate at `l` +is 1. It is zero on the 55 ports that conflict with `l`, where ports `i` and +`j` conflict when ` = 1`. So the span of the `w_l` is a *decoding +code* over the 104 ports. It has dimension at least 8, because the conflict +graph contains 8-cliques. + +This package proves, with computer assistance, that over `F_3` there is +**exactly one 8-dimensional decoding code, up to sign changes of the +coordinates**. Its minimum weight is **49**. + +The code is the one that the eight carriers of the PR5907 and PR6030 words +already deliver. In each word, the ten owned deliveries of support 52 span it +exactly. Any 49 ports span a space of dimension at least 8, since at most 36 +ports fit in a codimension-2 subspace. It follows that, in a single-stage +design whose partner code is 8-dimensional: + +- every carrier needs a root frame of dimension at least 8; +- every carrier must land in a frame of dimension at most 1. + +So each carrier pays at least 7, which is 56 per call. That is exactly what +the PR5907 word pays. The paid H1 of the local word therefore cannot be cut by +cheaper carriers for any eight-dimensional code, not only for PR5907's. + +**Card:** `complex-rank-shape-decoder`, refined to the decoder code of the +local word. See [TASK.json](TASK.json). + +**Base:** canonical main `3f0152a32eeebac0df11946dbd50cabe5a7f7839`. Inputs are +pinned in [SOURCES.json](SOURCES.json). + +## What is proved + +The full statements and proofs are in [PROOF.md](PROOF.md). + +1. **Lemma 1, frame decomposition.** A public row's lives-in-frame part stays + on ports of its frame. It follows that partner parts `w_l` give a decoding + code. Dyadic scalars make this code reduce mod 3 to a decoding code of the + same dimension, and supports can only shrink under the reduction. +2. **Theorem 3, uniqueness.** We fix the conflict clique + `T = {1, 5, 18, 20, 80, 85, 100, 103}`. An 8-dimensional code is then + determined by 384 trits `w_t[m]`, plus, for every other port, a + combination of the four clique members orthogonal to it. + + The search is a depth-first enumeration over `F_3`. It uses exact + incremental Gaussian elimination and a complete sign gauge on `T`. It finds + one solution, and that solution has no free variable. + + The solution's decoding matrix is sign-symmetric, so the row and column + codes agree. The weight distribution is 49 (208), 52 (32), 62 (16), + 65 (448), 68 (1504), 69 (1408), 70 (512), 71 (192), 72 (768), 73 (1024), + 75 (64) and 76 (384). +3. **Corollary 5, scoped cost floor.** Assume a partner code of dimension 8, + dyadic scalars, and a basis of eight delivered vectors, each carried down + one owned chain directly to its receivers. Then every chain costs at + least 7. + +| Word | Weight-52 owned deliveries | Their rank mod 3 | Same code as the solution | Partner-code rank mod 3 | +|---|---:|---:|---|---:| +| PR5907 (`p104-helper468-rung-removal`) | 10 | 8 | yes, up to signs | 8 | +| PR6030, selected (`p104-helper470-twin-rung-removal`) | 10 | 8 | yes, up to signs | 9 | + +PR6030's partner code has one bookkeeping direction outside the unique code. +Corollary 5 therefore describes its carriers but does not bound the word as +written. + +## Certificate + +[gen8.py](gen8.py) and [code8.py](code8.py) wrote a pre-order certificate of +the search. Its four parts are split by root option, and each was generated in +one Kaggle process. + + + +[verify.py](verify.py) needs no trust in the certificate. At every node it +recomputes all canonical consistent options of the named port, descends into +each, and checks that dead nodes have none. The certificate only says in which +order to branch. + +## Verification + +```sh +python3.12 -B research/p104-carrier-code-uniqueness/verify.py --parts 0,1 +python3.12 -B research/p104-carrier-code-uniqueness/verify.py --parts 2,3 +``` + +The verifier uses only the standard library ([replay.py](replay.py), +[wordcode.py](wordcode.py)). Each command does the following: + +1. Authenticates the pinned words. +2. Checks the structure: the ports agree between the words, all 104 have odd + weight, the conflict graph is 55-regular, `T` is a clique, + `f(8) = 60` and `f(7) = 36` (by enumerating all hyperplanes and all + codimension-2 subspaces). +3. Replays the Lemma-1 decomposition of both words. This checks the frame + invariant after every event and every partner endpoint. It also checks + that the weight-52 deliveries span an 8-dimensional decoding code that + satisfies the model equations. +4. Replays its two certificate parts. +5. For the part that holds the solution, checks the solution: it decodes, it + is sign-symmetric, its weight distribution and minimum weight are as + stated, and it is sign-equivalent to both words' codes. +6. Runs the controls: + - one trit changed in the code breaks the model equations; + - a certificate whose first internal node is marked dead is rejected; + - a certificate whose first dead node is replaced by a leaf is rejected. +7. Compares its sections of [RESULT.json](RESULT.json). It also checks that + the recorded parts cover every root option and contain exactly one + solution. + +The final marker is `PASS_P104_CARRIER_CODE_UNIQUENESS`. + +## Limits and open questions + +- **Partner codes of dimension 9 or more are not classified.** PR6030 is one, + because of a bookkeeping direction. A cheaper design would need carriers + that are each cheap but together decode. The clique and cover bounds alone + do not exclude this. +- **Multi-stage relays are outside Corollary 5.** In a relay, partners receive + mixtures through public roles. +- **This is not a κ improvement.** The 56 paid H1 per call in owned descents is + forced only within the stated scope. The larger local-word lever remains the + fragmentation of public and helper lifts; see + [`research/fragmentation-ceiling`](../fragmentation-ceiling/README.md). + +## Credits and scope + +- The local word lineage is aliromman's PR5827 and DreamingOfClouds's PR5907 + and PR6030. +- The checker rules are taken from PR5827's verifier, as used by those + packages. +- The decoding-code view, the enumeration, the certificate and this package + are by Matarener, prepared with Claude (Anthropic) via Claude Code. diff --git a/research/p104-carrier-code-uniqueness/SOURCES.json b/research/p104-carrier-code-uniqueness/SOURCES.json new file mode 100644 index 0000000000..6badc7599b --- /dev/null +++ b/research/p104-carrier-code-uniqueness/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "3f0152a32eeebac0df11946dbd50cabe5a7f7839", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/p104-helper468-rung-removal/WORD.json.gz", + "usage": "input", + "git_blob": "7ffe7b500b02b9d0de49a85ec53e36004f1a411f", + "sha256": "b69a9cb3a26d4f40aa7ad14f814b188fe16a782999f6f56292538e447d67b284" + }, + { + "path": "research/p104-helper470-twin-rung-removal/WORD.json.gz", + "usage": "input", + "git_blob": "22f9ab02d1b73ea0aa4b07ce445a14cc2602c760", + "sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f" + } + ] +} diff --git a/research/p104-carrier-code-uniqueness/TASK.json b/research/p104-carrier-code-uniqueness/TASK.json new file mode 100644 index 0000000000..b76376c1f6 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/TASK.json @@ -0,0 +1,81 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 8, + "base_commit": "3f0152a32eeebac0df11946dbd50cabe5a7f7839", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a legal decoder or coframe change improve the full signed moment, including changed helper targets?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Price one complete changed itinerary with both paid and productive histograms. Check #5693/#5698 for overlap and their exact hypotheses before another coframe search. Use the signed invoice preflight where its boundary contract agrees; an inconclusive concave comparison is not a power crossing. Stop if an optimistic complete budget fails at the chosen target or native delivery remains unspecified.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "coframe", + "signed moment", + "5693", + "5698" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Decoder code of the P104 local word: classify, over F_3, the 8-dimensional decoding codes on the 104 ports (vectors w_l with w_l[l] = 1 and zero on the 55 conflicting ports) that the owned deliveries of any legal word must span; show the code is unique up to coordinate signs with minimum weight 49, identify it with the carriers of PR5907 and the selected PR6030 word, and derive the scoped floor of 7 paid H1 per carrier (56 per call) for single-stage designs with an 8-dimensional partner code.", + "scope_change_reason": "The card asks whether a legal decoder change can improve the full moment. In the local word the only paid mass not fixed by the contract is the owned descent of the carriers (56 per call on PR5907), and a cheaper decoder would need a different 8-dimensional code with lighter vectors. The question therefore reduces to classifying those codes; the result is an obstruction for that whole class, not a priced itinerary.", + "bottleneck_link": "Each unit of owned descent per call is 18 units of rank-mass surplus on the PR5907 invoice (about 7.45e-5 in kappa). Theorem 3 with Lemma 4 shows that the 56 units per call cannot be reduced by re-shaping eight carriers on any code, so local-word savings must come from fragmentation of public and helper lifts or from designs outside the scope (partner codes of dimension >= 9, multi-stage relays).", + "budget_minutes": 600, + "stop_rule": "Stop when the four certificate parts replay with exactly one solution in total and no free variable, the solution's row and column codes have minimum weight 49 and are sign-equivalent to the weight-52 delivery codes of both pinned words, f(7) = 36 is confirmed, and the three controls are rejected.", + "outcome": "completed", + "evidence": "research/p104-carrier-code-uniqueness/RESULT.json", + "author": "Matarener", + "ai_assistance": "Prepared with Claude (Anthropic) via Claude Code; certificate generated on Kaggle.", + "open_questions": [ + { + "question": "Is there a legal word whose partner code has dimension 9 or more and whose carriers pay fewer than 56 per call in total?", + "why_it_matters": "It is the only single-stage escape from Corollary 5; PR6030 already has a 9-dimensional partner code through one bookkeeping direction.", + "first_step": "Extend code8.Model with a ninth basis vector outside the clique frame and enumerate codes in which some carrier vector has weight at most 36.", + "blocked_by": "The search space grows by the extra basis vector; no certificate yet." + }, + { + "question": "Can a multi-stage relay (partners receiving mixtures through public roles) reduce owned descent below 56 per call?", + "why_it_matters": "Corollary 5 bounds receivers only for direct deliveries; relays move the cost into public lifts, whose price must be compared.", + "first_step": "Price one relay of a single carrier with the exact invoice of the PR5907 word.", + "blocked_by": "A legal relay construction." + } + ] +} diff --git a/research/p104-carrier-code-uniqueness/VERIFY.json b/research/p104-carrier-code-uniqueness/VERIFY.json new file mode 100644 index 0000000000..1e54029242 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-helper468-rung-removal/WORD.json.gz", + "research/p104-helper470-twin-rung-removal/WORD.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--parts", + "0,1" + ], + "timeout_seconds": 600, + "checks": "Authenticate pinned inputs; structure (ports, 55-regular conflict graph, clique T, f(8) = 60, f(7) = 36); Lemma-1 replay of both words with frame invariant and partner endpoints; weight-52 delivery codes pass the model equations; replay of certificate parts 0,1 with all options recomputed at every node; solution checks where present; controls; RESULT.json sections and totals." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--parts", + "2,3" + ], + "timeout_seconds": 600, + "checks": "Authenticate pinned inputs; structure (ports, 55-regular conflict graph, clique T, f(8) = 60, f(7) = 36); Lemma-1 replay of both words with frame invariant and partner endpoints; weight-52 delivery codes pass the model equations; replay of certificate parts 2,3 with all options recomputed at every node; solution checks where present; controls; RESULT.json sections and totals." + } + ] +} diff --git a/research/p104-carrier-code-uniqueness/code8.py b/research/p104-carrier-code-uniqueness/code8.py new file mode 100644 index 0000000000..b0703a2b43 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/code8.py @@ -0,0 +1,153 @@ +"""Core of the length-8 index-code enumeration over GF(3) for the 104 P104 ports (standard library only). + +Model (see PROOF.md). Ports q_0..q_103 in F_2^9; i, j conflict iff = 1 (each q_i has odd weight). +A code is an 8-dimensional space W of vectors over the 104 ports such that for every port l some w_l in W has +w_l[l] = 1 and w_l[m] = 0 for every m conflicting with l. Fix a conflict clique T of size 8: then (w_t)_{t in T} +restricted to T is the identity, so they are a basis and every w_j = sum_{t in T_j} c_{j,t} w_t, where T_j are the +four members of T orthogonal to q_j. Unknowns: w_t[m] for m not conflicting with t (8 x 48 = 384 trits). +Gauge: rescaling coordinates by signs (diagonal D) maps codes to codes with the same zero pattern and weights; +it normalises c_j (first nonzero = 1) and is tracked on T by sign classes (canonical()). +Search: depth-first over the 96 non-clique ports, choosing at every node the port with the fewest consistent canonical +options (first port with one option, else the minimum); equations kept in incremental Gaussian elimination over +GF(3) on (ones, twos) bitmasks. Apache-2.0.""" +import itertools + +T_INDEX = [1, 5, 18, 20, 80, 85, 100, 103] + + +def dot(a, b): + return bin(a & b).count('1') & 1 + + +class Model: + def __init__(self, ports, T=T_INDEX): + self.P = list(ports); self.N = N = len(self.P) + P = self.P + assert N == 104 and len(set(P)) == 104 and all(bin(q).count('1') & 1 for q in P), 'ports' + self.T = list(T) + assert all(dot(P[a], P[b]) for a in T for b in T if a != b), 'T is not a conflict clique' + self.conf = [[m for m in range(N) if m != j and dot(P[j], P[m])] for j in range(N)] + self.nonconf = [[m for m in range(N) if m != j and not dot(P[j], P[m])] for j in range(N)] + self.var = {} + for t in T: + for m in self.nonconf[t]: + self.var[t, m] = len(self.var) + self.NV = len(self.var); self.RHS = 1 << self.NV + self.others = [j for j in range(N) if j not in T] + self.Tj = {j: [t for t in T if not dot(P[t], P[j])] for j in self.others} + assert all(len(v) == 4 for v in self.Tj.values()), 'T_j size' + self.OPT = [c for c in itertools.product((0, 1, 2), repeat=4) + if any(c) and [x for x in c if x][0] == 1] + assert len(self.OPT) == 40 + self.EQS = {(j, c): self.equations(j, c) for j in self.others for c in self.OPT} + self.pivots = {}; self.stack = [] + + # ---- GF(3) rows as (ones, twos) bitmasks; bit NV is the right-hand side + @staticmethod + def add(x, y): + x1, x2 = x; y1, y2 = y + return ((x1 & ~y1 & ~y2) | (y1 & ~x1 & ~x2) | (x2 & y2), (x2 & ~y1 & ~y2) | (y2 & ~x1 & ~x2) | (x1 & y1)) + + def equations(self, j, c): + eqs = []; cd = {t: k for t, k in zip(self.Tj[j], c) if k} + for m in self.conf[j]: + r1 = r2 = 0 + for t, k in cd.items(): + v = self.var.get((t, m)) + if v is None: + continue + if k == 1: r1 |= 1 << v + else: r2 |= 1 << v + if r1 | r2: + eqs.append((r1, r2)) + r1 = r2 = 0 + for t, k in cd.items(): + v = self.var[t, j] + if k == 1: r1 |= 1 << v + else: r2 |= 1 << v + eqs.append((r1 | self.RHS, r2)) + return eqs + + def push(self, row): + r1, r2 = row; piv = self.pivots; RHS = self.RHS + while True: + bits = (r1 | r2) & ~RHS + if not bits: + return not (r1 | r2) + c = (bits & -bits).bit_length() - 1 + p = piv.get(c) + if p is None: + if r2 >> c & 1: + r1, r2 = r2, r1 + piv[c] = (r1, r2); self.stack.append(c); return True + if r1 >> c & 1: + r1, r2 = self.add((r1, r2), (p[1], p[0])) + else: + r1, r2 = self.add((r1, r2), p) + + def mark(self): + return len(self.stack) + + def undo(self, k): + while len(self.stack) > k: + self.pivots.pop(self.stack.pop()) + + def apply(self, j, c): + """push the equations of (j, c); on inconsistency undo and return False""" + mk = self.mark() + for eq in self.EQS[j, c]: + if not self.push(eq): + self.undo(mk); return False + return True + + def consistent(self, j, c): + mk = self.mark(); ok = self.apply(j, c) + if ok: + self.undo(mk) + return ok + + # ---- sign gauge on T + def canonical(self, j, c, cls): + sup = [(t, k) for t, k in zip(self.Tj[j], c) if k] + seen = {cls[sup[0][0]]} + for t, k in sup[1:]: + q = cls[t] + if q in seen: + continue + if k != 1: + return False + seen.add(q) + return True + + def merged(self, j, c, cls): + ids = {cls[t] for t, k in zip(self.Tj[j], c) if k}; new = min(ids) + return {t: (new if q in ids else q) for t, q in cls.items()} + + def options(self, j, cls): + return [c for c in self.OPT if self.canonical(j, c, cls) and self.consistent(j, c)] + + def choose(self, rest, cls): + """MRV choice: (port, options) or (port, []) for a dead node""" + best = None + for j in sorted(rest): + ok = self.options(j, cls) + if not ok: + return j, [] + if best is None or len(ok) < len(best[1]): + best = (j, ok) + if len(ok) == 1: + break + return best + + def solution(self): + """back-substitute the unique solution (requires no free variables); returns the 104 x 104 matrix w (rows w_l)""" + assert len(self.pivots) == self.NV, 'free variables' + x = [0] * self.NV + for c in sorted(self.pivots, reverse=True): + r1, r2 = self.pivots[c] + s = 1 if r1 >> self.NV & 1 else (2 if r2 >> self.NV & 1 else 0) + for cc in range(c + 1, self.NV): + if r1 >> cc & 1: s -= x[cc] + elif r2 >> cc & 1: s -= 2 * x[cc] + x[c] = s % 3 + return x diff --git a/research/p104-carrier-code-uniqueness/gen8.py b/research/p104-carrier-code-uniqueness/gen8.py new file mode 100644 index 0000000000..9dd25b00ff --- /dev/null +++ b/research/p104-carrier-code-uniqueness/gen8.py @@ -0,0 +1,35 @@ +"""Generate the search certificate (pre-order tree) for one part of the root options. Apache-2.0. +usage: gen8.py PORTS.json PART NPARTS OUT [MAXDEPTH] +Tokens (one per line): 'n j' internal node branching on port j; 'd j' dead node (port j has no consistent canonical +option); 's' complete solution; 'x' (only with MAXDEPTH, for smoke tests) node cut at depth MAXDEPTH.""" +import json, sys, time +from code8 import Model +ports = json.load(open(sys.argv[1])); PART, NP = int(sys.argv[2]), int(sys.argv[3]); OUT = open(sys.argv[4], 'w') +MAXD = int(sys.argv[5]) if len(sys.argv) > 5 else 10**9 +M = Model(ports); t0 = time.time(); last = [t0]; cnt = [0, 0, 0]; maxdepth = [0] +print('START part', PART, 'of', NP, 'variables', M.NV, flush=True) +# wrap apply/undo with explicit marks +def rec2(d, rest, cls): + if time.time() - last[0] > 60: + last[0] = time.time() + print('progress %.0fs nodes %d dead %d solutions %d maxdepth %d' % (time.time() - t0, cnt[0], cnt[1], cnt[2], maxdepth[0]), flush=True); OUT.flush() + maxdepth[0] = max(maxdepth[0], d) + if not rest: + OUT.write('s\n'); cnt[2] += 1; M.solution() + print('SOLUTION at %.0fs' % (time.time() - t0), flush=True); return + if d >= MAXD: + OUT.write('x\n'); return + j, opts = M.choose(rest, cls) + if not opts: + OUT.write('d %d\n' % j); cnt[1] += 1; return + OUT.write('n %d\n' % j); cnt[0] += 1 + if d == 0: + opts = [c for i, c in enumerate(opts) if i % NP == PART] + print('root port', j, 'options in this part', len(opts), flush=True) + for c in opts: + mk = M.mark(); assert M.apply(j, c) + rec2(d + 1, rest - {j}, M.merged(j, c, cls)) + M.undo(mk) +rec2(0, frozenset(M.others), {t: i for i, t in enumerate(M.T)}) +OUT.close() +print('DONE part %d of %d internal %d dead %d solutions %d maxdepth %d time %.0fs' % (PART, NP, cnt[0], cnt[1], cnt[2], maxdepth[0], time.time() - t0), flush=True) diff --git a/research/p104-carrier-code-uniqueness/replay.py b/research/p104-carrier-code-uniqueness/replay.py new file mode 100644 index 0000000000..5c5c147c13 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/replay.py @@ -0,0 +1,188 @@ +"""Certificate replay and code facts for the length-8 P104 decoding code. Apache-2.0. + +Prepared for Matarener with Claude (Anthropic), via Claude Code. Python 3.12, standard library only. + +replay() re-runs the enumeration of code8.Model along a pre-order certificate written by gen8.py. At every internal +node it recomputes ALL canonical consistent options of the named port and descends into one subtree per option; at a +dead node it checks that the named port has none; at a solution leaf it back-substitutes the solution. The port named +by the certificate is only a branching choice: below any node the set of completions is the disjoint union over the +options of the chosen port, so any choice gives a complete enumeration (PROOF.md, section 3). Root options are spread +over the part files by option index modulo the number of parts, exactly as gen8.py splits them. +""" +import gzip +import itertools +import time + +from code8 import Model, dot + + +def tokens(path): + raw = open(path, 'rb').read() + if path.endswith('.gz'): + raw = gzip.decompress(raw) + return iter([x for x in raw.decode('ascii').split('\n') if x]) + + +def replay(ports, streams, nparts, log=print): + """Replay certificate parts; streams maps part numbers (a subset of range(nparts)) to token iterators.""" + parts = sorted(streams) + if not parts or not set(parts) <= set(range(nparts)): + raise ValueError('bad part selection') + M = Model(ports) + st = {p: {'internal': 0, 'dead': 0, 'solutions': 0} for p in parts} + sols = []; t0 = time.time(); last = [t0] + + def node(d, rest, cls, s, rec): + if time.time() - last[0] > 60: + last[0] = time.time() + log('replay progress %.0fs %s' % (time.time() - t0, st)) + x = next(s, None) + if x is None: + raise ValueError('certificate ends early') + if x == 's': + if rest: + raise ValueError('solution token with unassigned ports') + rec['solutions'] += 1; sols.append(M.solution()); return + kind, j = x.split(); j = int(j) + if j not in rest: + raise ValueError('port %d is not free' % j) + opts = M.options(j, cls) + if kind == 'd': + if opts: + raise ValueError('dead node at port %d has %d options' % (j, len(opts))) + rec['dead'] += 1; return + if kind != 'n' or not opts: + raise ValueError('bad internal node at port %d' % j) + rec['internal'] += 1 + for c in opts: + mk = M.mark() + if not M.apply(j, c): + raise ValueError('option lost consistency') + node(d + 1, rest - {j}, M.merged(j, c, cls), s, rec) + M.undo(mk) + + rest = frozenset(M.others); cls = {t: i for i, t in enumerate(M.T)} + roots = {p: next(streams[p], None) for p in parts} + if len(set(roots.values())) != 1 or not str(roots[parts[0]]).startswith('n '): + raise ValueError('parts disagree on the root') + j = int(roots[parts[0]].split()[1]); opts = M.options(j, cls) + root = {'port': j, 'options': len(opts)} + for i, c in enumerate(opts): + p = i % nparts + if p not in streams: + continue + st[p]['root_options'] = st[p].get('root_options', 0) + 1 + mk = M.mark() + if not M.apply(j, c): + raise ValueError('root option lost consistency') + node(1, rest - {j}, M.merged(j, c, cls), streams[p], st[p]) + M.undo(mk) + for p in parts: + st[p]['internal'] += 1 # the root node, counted in every part as gen8.py does + if next(streams[p], None) is not None: + raise ValueError('trailing tokens in part %d' % p) + return M, root, st, sols + + +def code_basis(M, x): + """rows w_t (t in the clique T) of the code from a solution vector x of the model""" + basis = [] + for t in M.T: + row = [0] * M.N; row[t] = 1 + for m in M.nonconf[t]: + row[m] = x[M.var[t, m]] + basis.append(row) + return basis + + +def decoding_rows(basis, ports): + """for an F_3 space with a decoding vector at every port: the vector w_l with w_l[l] = 1, zero on conflicts of l + (unique when the space restricted to the closed conflict neighbourhood is injective); None if some port fails""" + N = len(ports); k = len(basis); rows = [] + for l in range(N): + cols = [l] + [m for m in range(N) if m != l and dot(ports[l], ports[m])] + A = [[basis[i][c] for i in range(k)] + [1 if c == l else 0] for c in cols] + piv = []; r = 0 + for c in range(k): + p = next((i for i in range(r, len(A)) if A[i][c]), None) + if p is None: + continue + A[r], A[p] = A[p], A[r]; inv = pow(A[r][c], -1, 3); A[r] = [(v * inv) % 3 for v in A[r]] + for i in range(len(A)): + if i != r and A[i][c]: + f = A[i][c]; A[i] = [(v - f * y) % 3 for v, y in zip(A[i], A[r])] + piv.append(c); r += 1 + if len(piv) != k or any(not any(row[:k]) and row[k] for row in A): + return None + a = [0] * k + for i, c in enumerate(piv): + a[c] = A[i][k] + rows.append([sum(a[i] * basis[i][m] for i in range(k)) % 3 for m in range(N)]) + return rows + + +def rref3(vecs): + basis = []; piv = [] + for v in vecs: + v = [x % 3 for x in v] + for b, p in zip(basis, piv): + if v[p]: + k = v[p]; v = [(x - k * y) % 3 for x, y in zip(v, b)] + nz = [i for i, x in enumerate(v) if x] + if nz: + p = nz[0]; k = pow(v[p], -1, 3); v = [(x * k) % 3 for x in v] + for i, b in enumerate(basis): + if b[p]: + kk = b[p]; basis[i] = [(x - kk * y) % 3 for x, y in zip(b, v)] + basis.append(v); piv.append(p) + return basis + + +def weight_distribution(basis): + """Hamming weights of all nonzero vectors of the F_3 span of `basis` (rows linearly independent)""" + dist = {} + for coef in itertools.product((0, 1, 2), repeat=len(basis)): + if not any(coef): + continue + v = [sum(c * b[m] for c, b in zip(coef, basis)) % 3 for m in range(len(basis[0]))] + w = sum(1 for x in v if x); dist[w] = dist.get(w, 0) + 1 + return dist + + +def sign_equivalent(M1, M2): + """is there a diagonal d in {1, 2}^N with M2[l][m] = d_l^-1 M1[l][m] d_m for all l, m?""" + N = len(M1) + if any((M1[l][m] == 0) != (M2[l][m] == 0) for l in range(N) for m in range(N)): + return False + d = [0] * N + for s in range(N): + if d[s]: + continue + d[s] = 1; stack = [s] + while stack: + l = stack.pop() + for m in range(N): + if M1[l][m] and l != m: + want = (d[l] * M2[l][m] * pow(M1[l][m], -1, 3)) % 3 + if d[m] == 0: + d[m] = want; stack.append(m) + elif d[m] != want: + return False + return all(M2[l][m] == (pow(d[l], -1, 3) * M1[l][m] * d[m]) % 3 for l in range(N) for m in range(N)) + + +def max_ports_in_codim(ports, codim): + """f(9 - codim): the largest number of ports inside a subspace of codimension `codim` of F_2^9 (= Y^perp, dim Y = codim)""" + best = 0; seen = set() + for Y in itertools.combinations(range(1, 512), codim): + span = {0} + for y in Y: + span |= {s ^ y for s in span} + if len(span) != 1 << codim: + continue + key = frozenset(span) + if key in seen: + continue + seen.add(key) + best = max(best, sum(1 for q in ports if all(not dot(q, y) for y in Y))) + return best diff --git a/research/p104-carrier-code-uniqueness/verify.py b/research/p104-carrier-code-uniqueness/verify.py new file mode 100644 index 0000000000..bce63b0cb8 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/verify.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +"""Verify that the length-8 decoding code of the 104 P104 ports is unique over F_3 and has minimum weight 49. Apache-2.0. + +Prepared for Matarener with Claude (Anthropic), via Claude Code. Python 3.12, standard library only. +usage: verify.py [--parts 0,1,2,3] [--write] + +Checks: (0) pinned inputs; (1) structure: the 104 ports read from both pinned words agree, have odd weight, the +conflict graph ( = 1) is 55-regular, T_INDEX is a conflict 8-clique, and the largest numbers of ports in a +hyperplane and in a codimension-2 subspace of F_2^9 are 60 and 36; (2) the selected parts of the search certificate +(cert/part*.txt.gz, written by gen8.py) replay completely: every internal node lists all canonical consistent options of +its port, every dead node has none, no token is left over; the per-part node and solution counts equal RESULT.json and +the recorded counts over all four parts add up to exactly one solution; (3) a replayed solution has no free variable, +decodes at every port, its decoding matrix is sign-equivalent to its transpose, and the row and column spaces have +minimum weight 49 with the recorded weight distribution; (4) on both pinned words (PR5907 and the selected PR6030): +all scalars are dyadic, the Lemma-1 decomposition keeps the frame invariant and the partner endpoints, the ten +weight-52 owned deliveries span an 8-dimensional code with the decoding property whose decoding matrix is +sign-equivalent to the replayed solution (when the solution is in the selected parts) and passes the model equations; +(5) controls: one trit changed in that code breaks the model equations; a certificate whose first internal node below +the root is marked dead (its port has options) is rejected, and so is one whose first dead node is replaced by a +solution leaf; (6) the receipt equals RESULT.json. +""" +from hashlib import sha256 +from pathlib import Path +import itertools +import json +import sys +import time + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(HERE)) +from code8 import Model, T_INDEX, dot # noqa: E402 +from replay import (code_basis, decoding_rows, max_ports_in_codim, replay, rref3, sign_equivalent, # noqa: E402 + tokens, weight_distribution) +from wordcode import decompose, dyadic, load, m3 # noqa: E402 + +WORDS = {'pr5907': 'research/p104-helper468-rung-removal/WORD.json.gz', + 'pr6030': 'research/p104-helper470-twin-rung-removal/WORD.json.gz'} +NPARTS = 4 + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def cert(p): + return str(HERE / 'cert' / ('part%d.txt.gz' % p)) + + +def wd_json(d): + return {str(k): d[k] for k in sorted(d)} + + +def model_fixture(ports, rows): + """push a code given by its decoding rows through the model equations (after the sign gauge c_{j,first} = 1)""" + M = Model(ports) + d = [1] * M.N + for j in M.others: + first = next(t for t in M.Tj[j] if rows[j][t]) + d[j] = rows[j][first] # D^-1 M D with d_t = 1 on T makes the first coefficient 1 + g = [[(pow(d[l], -1, 3) * rows[l][m] * d[m]) % 3 for m in range(M.N)] for l in range(M.N)] + for (t, m), v in M.var.items(): + row = (1 << v) | (M.RHS if g[t][m] == 1 else 0), (M.RHS if g[t][m] == 2 else 0) + if not M.push(row): + return False + for j in M.others: + c = tuple(g[j][t] for t in M.Tj[j]) + if c not in M.OPT or not M.apply(j, c): + return False + return len(M.pivots) == M.NV + + +def tampered(p, mode): + """token stream of part p with one defect near its start: 'sol' turns the first dead node into a solution leaf, + 'dead' turns the first internal node below the root into a dead node (its port has options)""" + src = tokens(cert(p)); yield next(src); done = False + for x in src: + if not done and mode == 'sol' and x.startswith('d '): + done = True; yield 's'; continue + if not done and mode == 'dead' and x.startswith('n '): + done = True; yield 'd' + x[1:]; continue + yield x + + +def expect_failure(fn, text): + try: + fn() + except ValueError as ex: + need(text in str(ex), 'expected rejection "%s", got "%s"' % (text, ex)) + return str(ex) + raise ValueError('control accepted: ' + text) + + +def main(argv): + t0 = time.time() + parts = list(range(NPARTS)); write = '--write' in argv + if '--parts' in argv: + parts = sorted({int(x) for x in argv[argv.index('--parts') + 1].split(',')}) + pins = json.loads((HERE / 'SOURCES.json').read_text()) + for row in pins['files']: + if row['usage'] == 'input': + need(sha256((ROOT / row['path']).read_bytes()).hexdigest() == row['sha256'], 'source pin ' + row['path']) + print('pins ok', flush=True) + R = {'parts': {}} + + # (1) structure + words = {k: load(ROOT / v) for k, v in WORDS.items()} + port_lists = {} + for k, w in words.items(): + ports, W, D = decompose(w) + port_lists[k] = ports + ports = port_lists['pr5907'] + need(port_lists['pr6030'] == ports, 'the two words have the same ports in the same live order') + need(len(set(ports)) == 104 and all(bin(q).count('1') & 1 for q in ports), 'ports: 104 distinct odd vectors') + degrees = {sum(1 for m in ports if m != q and dot(q, m)) for q in ports} + need(degrees == {55}, 'conflict graph is 55-regular') + need(all(dot(ports[a], ports[b]) for a in T_INDEX for b in T_INDEX if a != b), 'T is a conflict clique') + f8, f7 = max_ports_in_codim(ports, 1), max_ports_in_codim(ports, 2) + need((f8, f7) == (60, 36), 'f(8) = 60 and f(7) = 36') + R['structure'] = {'ports': 104, 'conflict_degree': 55, 'clique': T_INDEX, 'f8_hyperplane': f8, 'f7_codim2': f7} + print('structure', R['structure'], flush=True) + + # (4) the words + R['words'] = {}; word_rows = {} + for k, w in words.items(): + need(dyadic(w), k + ': all scalars dyadic') + _, W, D = decompose(w) + W3 = [[m3(x) for x in r] for r in W] + heavy = sorted(v for v, s in D.items() if s == 52) + B = rref3(heavy); rows = decoding_rows(B, ports) + need(len(B) == 8 and rows is not None, k + ': weight-52 deliveries span an 8-dim decoding code') + need(model_fixture(ports, rows), k + ': the code passes the model equations') + word_rows[k] = rows + R['words'][k] = {'path': WORDS[k], 'dyadic': True, 'owned_deliveries': len(D), + 'delivery_supports': sorted(D.values()), 'weight52_deliveries': len(heavy), + 'weight52_rank': len(B), 'all_deliveries_rank_mod3': len(rref3(list(D))), + 'partner_owned_parts_rank_mod3': len(rref3(W3)), + 'partner_owned_parts_inside_code': len(rref3(B + W3)) == 8, + 'code_weight_distribution': wd_json(weight_distribution(B))} + print(k, R['words'][k], flush=True) + need(sign_equivalent(word_rows['pr5907'], word_rows['pr6030']), 'the two words carry sign-equivalent codes') + + # (5) controls that do not need the certificate + bad = [r[:] for r in word_rows['pr5907']] + t = T_INDEX[0]; m = next(m for m in range(104) if m != t and not dot(ports[t], ports[m])) + bad[t][m] = (bad[t][m] + 1) % 3 + need(not model_fixture(ports, bad), 'control: one changed trit breaks the model equations') + R['controls'] = {'changed_trit_rejected': True} + + # (2) certificate replay + M, root, st, sols = replay(ports, {p: tokens(cert(p)) for p in parts}, NPARTS) + R['root'] = root + for p in parts: + R['parts'][str(p)] = st[p] + print('replayed parts', parts, R['parts'], '%.0fs' % (time.time() - t0), flush=True) + + # (3) the solution + if sols: + need(len(sols) == 1, 'one solution') + basis = code_basis(M, sols[0]); rows = decoding_rows(basis, ports) + need(rows is not None, 'the solution decodes at every port') + cols = [[rows[l][m] for l in range(104)] for m in range(104)] + need(sign_equivalent(rows, cols), 'decoding matrix is sign-equivalent to its transpose') + wr, wc = weight_distribution(rref3(rows)), weight_distribution(rref3(cols)) + need(min(wr) == 49 and wr == wc and len(rref3(cols)) == 8, 'row and column codes: dim 8, minimum weight 49') + for k in WORDS: + need(sign_equivalent(rows, word_rows[k]), k + ': word code is sign-equivalent to the solution') + R['solution'] = {'free_variables': M.NV - len(M.pivots), 'decodes': True, 'symmetric_up_to_signs': True, + 'weight_distribution': wd_json(wr), 'min_weight': min(wr), + 'sign_equivalent_to': sorted(WORDS)} + print('solution', R['solution'], flush=True) + + # (5) certificate controls on the first selected part + p = parts[0] + R['controls']['dead_node_with_options_rejected'] = bool(expect_failure( + lambda: replay(ports, {p: tampered(p, 'dead')}, NPARTS), 'options')) + R['controls']['early_solution_leaf_rejected'] = bool(expect_failure( + lambda: replay(ports, {p: tampered(p, 'sol')}, NPARTS), 'unassigned ports')) + + # (6) receipt + path = HERE / 'RESULT.json' + old = json.loads(path.read_text()) if path.exists() else {} + if write: + merged = dict(old); merged.update({k: v for k, v in R.items() if k != 'parts'}) + merged['parts'] = dict(old.get('parts', {})); merged['parts'].update(R['parts']) + path.write_text(json.dumps(merged, indent=1, sort_keys=True) + '\n'); old = merged + for k, v in R.items(): + if k == 'parts': + for p, s in v.items(): + need(old['parts'].get(p) == s, 'RESULT.json part ' + p) + else: + need(old.get(k) == v, 'RESULT.json section ' + k) + need(sorted(old['parts']) == [str(p) for p in range(NPARTS)], 'RESULT.json records all parts') + need(sum(s['solutions'] for s in old['parts'].values()) == 1, 'exactly one solution over all parts') + need(sum(s['root_options'] for s in old['parts'].values()) == old['root']['options'], 'root options covered') + print('PASS_P104_CARRIER_CODE_UNIQUENESS parts %s, %.0fs' % (parts, time.time() - t0), flush=True) + + +if __name__ == '__main__': + main(sys.argv[1:]) diff --git a/research/p104-carrier-code-uniqueness/wordcode.py b/research/p104-carrier-code-uniqueness/wordcode.py new file mode 100644 index 0000000000..9b9410b07b --- /dev/null +++ b/research/p104-carrier-code-uniqueness/wordcode.py @@ -0,0 +1,112 @@ +"""The owned-delivery code of an actual P104 local word (accumulated-block schema 2). Apache-2.0. + +Prepared for Matarener with Claude (Anthropic), via Claude Code. Python 3.12, standard library only. + +decompose() replays the word with exact rationals and splits every public row into a lives-in-frame part and an +owned-delivered part (Lemma 1 of PROOF.md): the lives-in-frame part only grows by ADDs between public roles, which share +a frame, so its live coordinates always sit on ports of the role's current frame; everything a public role receives +from an owned field goes to the owned-delivered part. The function checks that invariant after every event, checks +the partner endpoints (the live projection of partner l + 112 is e_l), and returns the owned-delivered parts w_l of the +104 partners together with every distinct owned-to-public delivered vector (live coordinates). +""" +from fractions import Fraction as Q +import gzip +import json + + +def load(path): + return json.loads(gzip.decompress(open(path, 'rb').read())) + + +def spans(w): + out = [] + for basis in w['frames']: + s = {0} + for v in basis: + s |= {x ^ v for x in s} + out.append(frozenset(s)) + return out + + +def dyadic(w): + """True when every scalar of the program lies in Z[1/2] (so every row is 3-integral)""" + for e in w['program']: + if e[0] in ('ADD', 'COPY', 'SCALE'): + q = Q(e[-2]); d = q.denominator + if q == 0 or d & (d - 1): + return False + return True + + +def m3(q): + return (q.numerator * pow(q.denominator, -1, 3)) % 3 + + +def decompose(w): + S = spans(w); n, m = w['public'], w['owned_fields'] + live = sorted(w['live']) + port = {l: [x for x in S[w['initial'][l]] if x][0] for l in live} + cur = list(w['initial']) + [None] * m + lp = [dict() for _ in range(n)] # lives-in-frame part of every public role (keys: live roles) + od = [dict() for _ in range(n)] # owned-delivered part of every public role + orow = [dict() for _ in range(m)] # owned rows (live coordinates) + for l in live: + lp[l] = {l: Q(1)} + deliveries = {} + + def addto(t, src, q): + for k, v in src.items(): + x = t.get(k, 0) + q * v + if x: + t[k] = x + else: + t.pop(k, None) + + for i, e in enumerate(w['program']): + op, r = e[0], e[1] + if op == 'MOVE': + cur[r] = e[3]; continue + if op in ('INIT', 'CLEAR'): + if r < n: + raise ValueError('INIT/CLEAR on a public role at event %d' % i) + orow[r - n] = {}; cur[r] = e[2] if op == 'INIT' else None; continue + q = Q(e[-2]) + if op == 'SCALE': + if r < n: + lp[r] = {k: q * v for k, v in lp[r].items()}; od[r] = {k: q * v for k, v in od[r].items()} + else: + orow[r - n] = {k: q * v for k, v in orow[r - n].items()} + continue + s = e[2] + if r < n: + if op == 'COPY': + raise ValueError('COPY into a public role at event %d' % i) + if s < n: + addto(lp[r], lp[s], q); addto(od[r], od[s], q) + else: + addto(od[r], orow[s - n], q) + vec = tuple(orow[s - n].get(l, Q(0)) for l in live) + if any(vec): + key = tuple(m3(x) for x in vec) + deliveries.setdefault(key, sum(1 for x in vec if x)) + F = S[cur[r]] + if not all(port[k] in F for k in lp[r]): + raise ValueError('frame invariant broken at event %d' % i) + else: + t = {} if op == 'COPY' else orow[r - n] + if s < n: + addto(t, lp[s], q); addto(t, od[s], q) + else: + addto(t, orow[s - n], q) + orow[r - n] = t + W = [] + for l in live: + p = l + 112 + F = S[cur[p]] + if not (all(port[k] in F for k in lp[p]) and l not in lp[p]): + raise ValueError('partner %d: lives-in-frame part leaves its frame or contains its own live' % p) + full = dict(lp[p]); addto(full, od[p], Q(1)) + if full != {l: Q(1)}: + raise ValueError('partner %d: live projection is not e_l' % p) + W.append([od[p].get(k, Q(0)) for k in live]) + return [port[l] for l in live], W, deliveries From ff99ceeefc164424c6171bbd09ce6616e3c2f549 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 21:33:59 +0000 Subject: [PATCH 02/11] p104-carrier-code-uniqueness: Lean formalisation of the word-to-code reduction and the carrier cost floor Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYmAARGrLk38Gj9eUPzP --- .../lean/.gitignore | 1 + .../lean/Audit.lean | 16 + .../lean/CarrierCode.lean | 2 + .../lean/CarrierCode/Cost.lean | 163 +++++++++ .../lean/CarrierCode/Word.lean | 321 ++++++++++++++++++ .../lean/lake-manifest.json | 117 +++++++ .../lean/lakefile.toml | 10 + .../lean/lean-toolchain | 1 + 8 files changed, 631 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/lean/.gitignore create mode 100644 research/p104-carrier-code-uniqueness/lean/Audit.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/Cost.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/Word.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/lake-manifest.json create mode 100644 research/p104-carrier-code-uniqueness/lean/lakefile.toml create mode 100644 research/p104-carrier-code-uniqueness/lean/lean-toolchain diff --git a/research/p104-carrier-code-uniqueness/lean/.gitignore b/research/p104-carrier-code-uniqueness/lean/.gitignore new file mode 100644 index 0000000000..01f8cdb637 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/.gitignore @@ -0,0 +1 @@ +.lake/ diff --git a/research/p104-carrier-code-uniqueness/lean/Audit.lean b/research/p104-carrier-code-uniqueness/lean/Audit.lean new file mode 100644 index 0000000000..f51231a2ee --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/Audit.lean @@ -0,0 +1,16 @@ +import CarrierCode + +#print axioms CarrierCode.State.step_row +#print axioms CarrierCode.State.inv_init +#print axioms CarrierCode.State.inv_run +#print axioms CarrierCode.State.decoding_vector +#print axioms CarrierCode.finrank_add_orth +#print axioms CarrierCode.root_dim +#print axioms CarrierCode.landing_dim +#print axioms CarrierCode.chain_cost +#print axioms CarrierCode.span_of_clique +#print axioms CarrierCode.carriers_cost +#print axioms CarrierCode.State.step_map +#print axioms CarrierCode.State.run_map +#print axioms CarrierCode.State.legalRun_map +#print axioms CarrierCode.State.row_map diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode.lean new file mode 100644 index 0000000000..5931234c55 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode.lean @@ -0,0 +1,2 @@ +import CarrierCode.Word +import CarrierCode.Cost diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/Cost.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/Cost.lean new file mode 100644 index 0000000000..29b52ea10e --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/Cost.lean @@ -0,0 +1,163 @@ +import CarrierCode.Word + +/-! +# Decoding codes and the scoped carrier cost floor (Lemma 4 consequences and Corollary 5 of PROOF.md) + +The finite search of the package is used only through `CodeFact`: every 8-dimensional decoding code over `K` on the +ports has minimum weight at least 49, in rows (vectors of the code) and in columns (any linear functional evaluated +on the decoding vectors). It is established by the certificate replay in `verify.py`, not here. The frame capacity +`Capacity` (at most 36 ports in a subspace of dimension at most 7) is checked by enumeration in `verify.py`. +-/ + +namespace CarrierCode + +open Module + +attribute [local instance] Classical.propDecidable + +variable {K : Type*} [Field K] {L : Type*} [Fintype L] (port : L → V9) + +/-- `W` is a decoding code with decoding vectors `w`. -/ +def IsDecoding (W : Submodule K (L → K)) (w : L → L → K) : Prop := + ∀ ℓ, w ℓ ∈ W ∧ w ℓ ℓ = 1 ∧ ∀ m, m ≠ ℓ → Conflict (port m) (port ℓ) → w ℓ m = 0 + +/-- The statement certified by the search (Theorem 3 with the weight facts of `verify.py`). -/ +def CodeFact (K : Type*) [Field K] : Prop := + ∀ (W : Submodule K (L → K)) (w : L → L → K), IsDecoding port W w → finrank K W = 8 → + (∀ v ∈ W, v ≠ 0 → 49 ≤ (Finset.univ.filter fun m => v m ≠ 0).card) ∧ + (∀ φ : (L → K) →ₗ[K] K, (∃ ℓ, φ (w ℓ) ≠ 0) → 49 ≤ (Finset.univ.filter fun ℓ => φ (w ℓ) ≠ 0).card) + +/-- Lemma 4 as used: at most 36 ports in a subspace of dimension at most 7 (checked in `verify.py`). -/ +def Capacity : Prop := + ∀ S : Frame, finrank (ZMod 2) S ≤ 7 → (Finset.univ.filter fun m => port m ∈ S).card ≤ 36 + +/-- A frame holding at least 49 ports has dimension at least 8. -/ +theorem root_dim (hcap : Capacity port) (F : Frame) (s : Finset L) (hs : 49 ≤ s.card) + (hF : ∀ m ∈ s, port m ∈ F) : 8 ≤ finrank (ZMod 2) F := by + by_contra h + have h1 := hcap F (by omega) + have : s ⊆ Finset.univ.filter fun m => port m ∈ F := fun m hm => by simp [hF m hm] + have := Finset.card_le_card this + omega + +/-- The dot-product form on `F₂⁹`. -/ +def dotForm : LinearMap.BilinForm (ZMod 2) V9 := Matrix.toBilin' 1 + +theorem dotForm_apply (x y : V9) : dotForm x y = x ⬝ᵥ y := by + simp [dotForm, Matrix.toBilin'_apply', dotProduct] + +/-- `dim B + dim B^⊥ = 9` for the dot product on `F₂⁹`. -/ +theorem finrank_add_orth (B : Frame) : + finrank (ZMod 2) B + finrank (ZMod 2) (dotForm.orthogonal B) = 9 := by + have h := dotForm.finrank_add_finrank_orthogonal' B + have hker : LinearMap.ker dotForm = ⊥ := by + rw [eq_bot_iff] + intro x hx + rw [Submodule.mem_bot] + funext i + have := congrArg (fun f => f (Pi.single i 1)) (LinearMap.mem_ker.mp hx) + simp only [dotForm_apply, LinearMap.zero_apply] at this + simpa [dotProduct_single] using this + rw [show (dotForm.ker : Submodule (ZMod 2) V9) = LinearMap.ker dotForm from rfl, hker, inf_bot_eq, + finrank_bot, add_zero, Module.finrank_fin_fun] at h + exact h + +/-- A frame orthogonal to at least 49 ports has dimension at most 1. -/ +theorem landing_dim (hcap : Capacity port) (B : Frame) (s : Finset L) (hs : 49 ≤ s.card) + (hB : ∀ ℓ ∈ s, ∀ b ∈ B, b ⬝ᵥ port ℓ = 0) : finrank (ZMod 2) B ≤ 1 := by + have hperp : ∀ ℓ ∈ s, port ℓ ∈ dotForm.orthogonal B := by + intro ℓ hℓ + rw [LinearMap.BilinForm.mem_orthogonal_iff] + intro b hb + rw [dotForm_apply] + exact hB ℓ hℓ b hb + have h8 := root_dim port hcap _ s hs hperp + have := finrank_add_orth B + omega + +/-- Corollary 5, one chain. A delivered vector `v` of a code with `CodeFact` has at least 49 live coordinates, so a +root frame holding their ports has dimension at least 8; at least 49 receivers in frames inside `q_ℓ^⊥` force the +lowest frame `B` of the chain to dimension at most 1; the chain's paid descent is at least 7. -/ +theorem chain_cost (hcap : Capacity port) (W : Submodule K (L → K)) (w : L → L → K) + (hfact : (∀ v ∈ W, v ≠ 0 → 49 ≤ (Finset.univ.filter fun m => v m ≠ 0).card) ∧ + (∀ φ : (L → K) →ₗ[K] K, (∃ ℓ, φ (w ℓ) ≠ 0) → 49 ≤ (Finset.univ.filter fun ℓ => φ (w ℓ) ≠ 0).card)) + (v : L → K) (hvW : v ∈ W) (hv : v ≠ 0) (φ : (L → K) →ₗ[K] K) (hφ : ∃ ℓ, φ (w ℓ) ≠ 0) + (root B : Frame) (hroot : ∀ m, v m ≠ 0 → port m ∈ root) + (hrecv : ∀ ℓ, φ (w ℓ) ≠ 0 → ∀ b ∈ B, b ⬝ᵥ port ℓ = 0) : + 7 ≤ finrank (ZMod 2) root - finrank (ZMod 2) B := by + have h1 := root_dim port hcap root _ (hfact.1 v hvW hv) (fun m hm => hroot m (by simpa using hm)) + have h2 := landing_dim port hcap B _ (hfact.2 φ hφ) (fun ℓ hℓ => hrecv ℓ (by simpa using hℓ)) + omega + +/-- With a conflict clique of size 8, the decoding vectors of an 8-dimensional decoding code span it. -/ +theorem span_of_clique (W : Submodule K (L → K)) (w : L → L → K) (hW : IsDecoding port W w) + (h8 : finrank K W = 8) (T : Fin 8 → L) (hT : Function.Injective T) + (hcl : ∀ i j, i ≠ j → Conflict (port (T i)) (port (T j))) : + Submodule.span K (Set.range w) = W := by + have hle : Submodule.span K (Set.range w) ≤ W := + Submodule.span_le.mpr (by rintro _ ⟨ℓ, rfl⟩; exact (hW ℓ).1) + have hli : LinearIndependent K (fun i => w (T i)) := by + rw [Fintype.linearIndependent_iff] + intro g hg j + have := congrFun hg (T j) + simp only [Finset.sum_apply, Pi.smul_apply, smul_eq_mul, Pi.zero_apply] at this + rw [Finset.sum_eq_single j] at this + · simpa [(hW (T j)).2.1] using this + · intro i _ hij + rw [(hW (T i)).2.2 (T j) (fun h => hij (hT h).symm) (hcl j i (Ne.symm hij)), mul_zero] + · simp + have h8' : 8 ≤ finrank K (Submodule.span K (Set.range w)) := by + have h1 := finrank_span_eq_card hli + have h2 : Submodule.span K (Set.range fun i => w (T i)) ≤ Submodule.span K (Set.range w) := + Submodule.span_mono (by rintro _ ⟨i, rfl⟩; exact ⟨T i, rfl⟩) + have := Submodule.finrank_mono h2 + simp only [Fintype.card_fin] at h1 + omega + exact Submodule.eq_of_le_of_finrank_eq hle (le_antisymm (Submodule.finrank_mono hle) (by omega)) + +/-- Corollary 5. Let `W` be an 8-dimensional decoding code with decoding vectors `w`, under `CodeFact` and +`Capacity`, and let `v : Fin 8 → (L → K)` be a basis of `W`. Suppose chain `c` carries `v c` down from a root frame +holding the ports of its support to a lowest frame `B c` that lies in `q_ℓ^⊥` for every partner `ℓ` whose decoding +vector uses `v c` (nonzero coordinate). Then every chain pays at least 7, and the eight chains at least 56. -/ +theorem carriers_cost (hcode : CodeFact port K) (hcap : Capacity port) (W : Submodule K (L → K)) (w : L → L → K) + (hW : IsDecoding port W w) (h8 : finrank K W = 8) (hspan : Submodule.span K (Set.range w) = W) + (v : Basis (Fin 8) K W) + (root B : Fin 8 → Frame) (hroot : ∀ c m, (v c : L → K) m ≠ 0 → port m ∈ root c) + (hrecv : ∀ c ℓ, v.repr ⟨w ℓ, (hW ℓ).1⟩ c ≠ 0 → ∀ b ∈ B c, b ⬝ᵥ port ℓ = 0) : + (∀ c, 7 ≤ finrank (ZMod 2) (root c) - finrank (ZMod 2) (B c)) ∧ + 56 ≤ ∑ c, (finrank (ZMod 2) (root c) - finrank (ZMod 2) (B c)) := by + have hfact := hcode W w hW h8 + have each : ∀ c, 7 ≤ finrank (ZMod 2) (root c) - finrank (ZMod 2) (B c) := by + intro c + -- the coordinate functional of `v c`, extended from `W` to the ambient space + obtain ⟨φ, hφ⟩ := LinearMap.exists_extend (v.coord c) + have hφw : ∀ ℓ, φ (w ℓ) = v.repr ⟨w ℓ, (hW ℓ).1⟩ c := by + intro ℓ + have := congrArg (fun f => f ⟨w ℓ, (hW ℓ).1⟩) hφ + simpa using this + have hvc : (v c : L → K) ≠ 0 := by + intro h0 + exact v.ne_zero c (Subtype.ext (by simpa using h0)) + have hex : ∃ ℓ, φ (w ℓ) ≠ 0 := by + by_contra hno + push Not at hno + have hzero : ∀ x ∈ W, φ x = 0 := by + intro x hx + rw [← hspan] at hx + induction hx using Submodule.span_induction with + | mem y hy => obtain ⟨ℓ, rfl⟩ := hy; exact hno ℓ + | zero => simp + | add a b _ _ ha hb => simp [ha, hb] + | smul a b _ hb => simp [hb] + have h1 : φ (v c) = 1 := by + have := congrArg (fun f => f (v c)) hφ + simpa using this + rw [hzero _ (v c).2] at h1 + exact zero_ne_one h1 + exact chain_cost port hcap W w hfact (v c) (v c).2 hvc φ hex (root c) (B c) (hroot c) + (fun ℓ hℓ => hrecv c ℓ (by rwa [← hφw])) + refine ⟨each, ?_⟩ + calc 56 = ∑ _c : Fin 8, 7 := by simp + _ ≤ _ := Finset.sum_le_sum fun c _ => each c + +end CarrierCode diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/Word.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/Word.lean new file mode 100644 index 0000000000..47bd4fb117 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/Word.lean @@ -0,0 +1,321 @@ +import Mathlib + +/-! +# Frame decomposition of a P104 local word (Lemma 1 and Corollary 2 of PROOF.md) + +A word acts on public roles `P` and owned roles `O`. Every role sits in a frame, a subspace of `F₂⁹`, and carries a +row; we keep only the live coordinates of rows (functions `L → R`), which is legitimate because every operation is +linear. Public roles only move up, operations act only between roles in the same frame, and `COPY` only targets +owned roles. + +The decomposition splits a public row into a *lives-in-frame* part `lp`, which only grows by ADDs between public +roles, and an *owned-delivered* part `od`, which collects everything received from owned roles. We prove: + +* `row = lp + od` on public roles, and `lp r m ≠ 0 → port m ∈ frame r` (Lemma 1); +* `od r` lies in the span of the owned rows delivered so far; +* at a partner whose final row is `e_ℓ` and whose final frame is `q_ℓ^⊥`, the owned part is `1` at `ℓ` and `0` at + every port conflicting with `ℓ` (Corollary 2). +-/ + +namespace CarrierCode + +/-- The space `F₂⁹` of port vectors. -/ +abbrev V9 := Fin 9 → ZMod 2 + +/-- The frames: subspaces of `F₂⁹`. -/ +abbrev Frame := Submodule (ZMod 2) V9 + +/-- Port vectors `q_i, q_j` conflict when their dot product is one. -/ +def Conflict (x y : V9) : Prop := x ⬝ᵥ y = 1 + +/-- The hyperplane `q^⊥`. -/ +def perp (q : V9) : Frame where + carrier := {x | x ⬝ᵥ q = 0} + add_mem' {a b} ha hb := by simp_all [add_dotProduct] + zero_mem' := by simp + smul_mem' c x hx := by simp_all [smul_dotProduct] + +variable {R : Type*} [CommRing R] {L P O : Type*} [DecidableEq P] [DecidableEq O] + +/-- Events of a word (live projections of the checker's operations). -/ +inductive Event (R P O : Type*) + | moveP (r : P) (F : Frame) + | moveO (o : O) (F : Frame) + | init (o : O) (F : Frame) + | clear (o : O) + | scaleP (r : P) (c : R) + | scaleO (o : O) (c : R) + | addPP (r s : P) (c : R) + | addOP (r : P) (o : O) (c : R) + | addPO (o : O) (s : P) (c : R) + | addOO (o o' : O) (c : R) + | copyPO (o : O) (s : P) (c : R) + | copyOO (o o' : O) (c : R) + +/-- State: frames, the decomposed public rows, the owned rows and the list of delivered owned rows. -/ +structure State (R L P O : Type*) where + fP : P → Frame + fO : O → Frame + lp : P → L → R + od : P → L → R + ow : O → L → R + delivered : List (L → R) + +namespace State + +/-- The actual public row. -/ +def row (S : State R L P O) (r : P) : L → R := S.lp r + S.od r + +/-- Legality of an event in a state (frame rules of the checker). -/ +def Legal (S : State R L P O) : Event R P O → Prop + | .moveP r F => S.fP r ≤ F + | .moveO o F => F ≤ S.fO o + | .init _ _ => True + | .clear _ => True + | .scaleP _ _ => True + | .scaleO _ _ => True + | .addPP r s _ => S.fP r = S.fP s + | .addOP r o _ => S.fP r = S.fO o + | .addPO o s _ => S.fO o = S.fP s + | .addOO o o' _ => S.fO o = S.fO o' + | .copyPO o s _ => S.fO o = S.fP s + | .copyOO o o' _ => S.fO o = S.fO o' + +/-- One step of the decomposed semantics. -/ +def step (S : State R L P O) : Event R P O → State R L P O + | .moveP r F => { S with fP := Function.update S.fP r F } + | .moveO o F => { S with fO := Function.update S.fO o F } + | .init o F => { S with fO := Function.update S.fO o F, ow := Function.update S.ow o 0 } + | .clear o => { S with ow := Function.update S.ow o 0 } + | .scaleP r c => { S with lp := Function.update S.lp r (c • S.lp r), od := Function.update S.od r (c • S.od r) } + | .scaleO o c => { S with ow := Function.update S.ow o (c • S.ow o) } + | .addPP r s c => + { S with lp := Function.update S.lp r (S.lp r + c • S.lp s), + od := Function.update S.od r (S.od r + c • S.od s) } + | .addOP r o c => + { S with od := Function.update S.od r (S.od r + c • S.ow o), delivered := S.ow o :: S.delivered } + | .addPO o s c => { S with ow := Function.update S.ow o (S.ow o + c • S.row s) } + | .addOO o o' c => { S with ow := Function.update S.ow o (S.ow o + c • S.ow o') } + | .copyPO o s c => { S with ow := Function.update S.ow o (c • S.row s) } + | .copyOO o o' c => { S with ow := Function.update S.ow o (c • S.ow o') } + +/-- Run a list of events. -/ +def run (S : State R L P O) : List (Event R P O) → State R L P O + | [] => S + | e :: es => (S.step e).run es + +/-- Every event of the list is legal when it is applied. -/ +def LegalRun (S : State R L P O) : List (Event R P O) → Prop + | [] => True + | e :: es => S.Legal e ∧ (S.step e).LegalRun es + +/-- The real row semantics (no decomposition), to check that `row = lp + od` is the checker's row. -/ +def stepRow (fP : P → Frame) (fO : O → Frame) (pr : P → L → R) (ow : O → L → R) : + Event R P O → (P → Frame) × (O → Frame) × (P → L → R) × (O → L → R) + | .moveP r F => (Function.update fP r F, fO, pr, ow) + | .moveO o F => (fP, Function.update fO o F, pr, ow) + | .init o F => (fP, Function.update fO o F, pr, Function.update ow o 0) + | .clear o => (fP, fO, pr, Function.update ow o 0) + | .scaleP r c => (fP, fO, Function.update pr r (c • pr r), ow) + | .scaleO o c => (fP, fO, pr, Function.update ow o (c • ow o)) + | .addPP r s c => (fP, fO, Function.update pr r (pr r + c • pr s), ow) + | .addOP r o c => (fP, fO, Function.update pr r (pr r + c • ow o), ow) + | .addPO o s c => (fP, fO, pr, Function.update ow o (ow o + c • pr s)) + | .addOO o o' c => (fP, fO, pr, Function.update ow o (ow o + c • ow o')) + | .copyPO o s c => (fP, fO, pr, Function.update ow o (c • pr s)) + | .copyOO o o' c => (fP, fO, pr, Function.update ow o (c • ow o')) + +/-- The decomposed step projects to the real step. -/ +theorem step_row (S : State R L P O) (e : Event R P O) : + stepRow S.fP S.fO S.row S.ow e = ((S.step e).fP, (S.step e).fO, (S.step e).row, (S.step e).ow) := by + cases e with + | moveP r F => rfl + | moveO o F => rfl + | init o F => rfl + | clear o => rfl + | scaleP r c => + simp only [stepRow, step, Prod.mk.injEq, true_and, and_true] + funext x; by_cases h : x = r + · subst h; simp [row, smul_add] + · simp [row, Function.update_of_ne h] + | scaleO o c => rfl + | addPP r s c => + simp only [stepRow, step, Prod.mk.injEq, true_and, and_true] + funext x; by_cases h : x = r + · subst h; simp only [row, Function.update_self]; module + · simp [row, Function.update_of_ne h] + | addOP r o c => + simp only [stepRow, step, Prod.mk.injEq, true_and, and_true] + funext x; by_cases h : x = r + · subst h; simp only [row, Function.update_self]; abel + · simp [row, Function.update_of_ne h] + | addPO o s c => rfl + | addOO o o' c => rfl + | copyPO o s c => rfl + | copyOO o o' c => rfl + +variable (port : L → V9) + +/-- Lemma 1 invariant: the lives-in-frame part sits on ports of the current frame; owned parts lie in the span of +the delivered owned rows. -/ +def Inv (S : State R L P O) : Prop := + (∀ r m, S.lp r m ≠ 0 → port m ∈ S.fP r) ∧ ∀ r, S.od r ∈ Submodule.span R {v | v ∈ S.delivered} + +theorem inv_step (S : State R L P O) (e : Event R P O) (h : Inv port S) (hl : S.Legal e) : + Inv port (S.step e) := by + obtain ⟨h1, h2⟩ := h + have mono : ∀ (S' : State R L P O), S.delivered ⊆ S'.delivered → + Submodule.span R {v | v ∈ S.delivered} ≤ Submodule.span R {v | v ∈ S'.delivered} := + fun S' hs => Submodule.span_mono (fun v hv => hs hv) + cases e with + | moveP r F => + refine ⟨fun x m hm => ?_, h2⟩ + by_cases hx : x = r + · subst hx; simp only [step, Function.update_self]; exact hl (h1 x m hm) + · simpa [step, Function.update_of_ne hx] using h1 x m hm + | moveO o F => exact ⟨h1, h2⟩ + | init o F => exact ⟨h1, h2⟩ + | clear o => exact ⟨h1, h2⟩ + | scaleP r c => + refine ⟨fun x m hm => ?_, fun x => ?_⟩ + · by_cases hx : x = r + · subst hx + simp only [step, Function.update_self, Pi.smul_apply, smul_eq_mul] at hm ⊢ + exact h1 x m (right_ne_zero_of_mul hm) + · simpa [step, Function.update_of_ne hx] using h1 x m (by simpa [step, Function.update_of_ne hx] using hm) + · by_cases hx : x = r + · subst hx; simp only [step, Function.update_self]; exact Submodule.smul_mem _ c (h2 x) + · simpa [step, Function.update_of_ne hx] using h2 x + | scaleO o c => exact ⟨h1, h2⟩ + | addPP r s c => + refine ⟨fun x m hm => ?_, fun x => ?_⟩ + · by_cases hx : x = r + · subst hx + simp only [step, Function.update_self, Pi.add_apply, Pi.smul_apply, smul_eq_mul] at hm ⊢ + by_cases ha : S.lp x m = 0 + · rw [ha, zero_add] at hm + have := h1 s m (right_ne_zero_of_mul hm) + rwa [show S.fP x = S.fP s from hl] + · exact h1 x m ha + · simpa [step, Function.update_of_ne hx] using h1 x m (by simpa [step, Function.update_of_ne hx] using hm) + · by_cases hx : x = r + · subst hx; simp only [step, Function.update_self] + exact Submodule.add_mem _ (h2 x) (Submodule.smul_mem _ c (h2 s)) + · simpa [step, Function.update_of_ne hx] using h2 x + | addOP r o c => + refine ⟨h1, fun x => ?_⟩ + have hsub : Submodule.span R {v | v ∈ S.delivered} ≤ + Submodule.span R {v | v ∈ (S.step (.addOP r o c)).delivered} := + mono _ (fun v hv => List.mem_cons_of_mem _ hv) + have hnew : S.ow o ∈ Submodule.span R {v | v ∈ (S.step (.addOP r o c)).delivered} := + Submodule.subset_span (by simp [step]) + by_cases hx : x = r + · subst hx; simp only [step, Function.update_self] + exact Submodule.add_mem _ (hsub (h2 x)) (Submodule.smul_mem _ c hnew) + · simp only [step, Function.update_of_ne hx]; exact hsub (h2 x) + | addPO o s c => exact ⟨h1, h2⟩ + | addOO o o' c => exact ⟨h1, h2⟩ + | copyPO o s c => exact ⟨h1, h2⟩ + | copyOO o o' c => exact ⟨h1, h2⟩ + +omit [DecidableEq O] in +/-- The initial state satisfies the invariant: live `ℓ` holds `e_ℓ` in a frame containing its port, every other +public row is empty, and nothing has been delivered. -/ +theorem inv_init [DecidableEq L] (fP : P → Frame) (fO : O → Frame) (ow : O → L → R) (live : L → P) + (hlive : ∀ ℓ, port ℓ ∈ fP (live ℓ)) : + Inv port (⟨fP, fO, fun r m => if live m = r then 1 else 0, fun _ => 0, ow, []⟩ : State R L P O) := by + refine ⟨fun r m hm => ?_, fun r => Submodule.zero_mem _⟩ + by_cases h : live m = r + · subst h; exact hlive m + · simp [h] at hm + +/-- Lemma 1 along a legal run. -/ +theorem inv_run (S : State R L P O) (es : List (Event R P O)) (h : Inv port S) (hl : S.LegalRun es) : + Inv port (S.run es) := by + induction es generalizing S with + | nil => exact h + | cons e es ih => exact ih _ (inv_step port S e h hl.1) hl.2 + +/-- Corollary 2. At the end of a legal run from an invariant state, let partner `p` of live `ℓ` sit in the frame +`q_ℓ^⊥` with row `e_ℓ`, where `q_ℓ` has odd weight (`q_ℓ ⬝ᵥ q_ℓ = 1`) and `port = q`. Then its owned-delivered part +`w` lies in the span of the delivered owned rows, `w ℓ = 1`, and `w m = 0` for every `m ≠ ℓ` conflicting with `ℓ`. -/ +theorem decoding_vector [DecidableEq L] (S : State R L P O) (es : List (Event R P O)) (h : Inv port S) + (hl : S.LegalRun es) (ℓ : L) (p : P) (hodd : port ℓ ⬝ᵥ port ℓ = 1) + (hframe : (S.run es).fP p = perp (port ℓ)) (hrow : (S.run es).row p = Pi.single ℓ 1) : + (S.run es).od p ∈ Submodule.span R {v | v ∈ (S.run es).delivered} ∧ + (S.run es).od p ℓ = 1 ∧ ∀ m, m ≠ ℓ → Conflict (port m) (port ℓ) → (S.run es).od p m = 0 := by + obtain ⟨h1, h2⟩ := inv_run port S es h hl + set T := S.run es + have hlp : ∀ m, Conflict (port m) (port ℓ) → T.lp p m = 0 := by + intro m hm + by_contra hne + have := h1 p m hne + rw [hframe] at this + change port m ⬝ᵥ port ℓ = 0 at this + rw [show port m ⬝ᵥ port ℓ = 1 from hm] at this + exact one_ne_zero this + have hrm : ∀ m, T.od p m = (Pi.single ℓ (1 : R) : L → R) m - T.lp p m := by + intro m; rw [← hrow]; simp [row] + refine ⟨h2 p, ?_, fun m hm hc => ?_⟩ + · rw [hrm, hlp ℓ hodd]; simp + · rw [hrm, hlp m hc]; simp [hm] + +section Map + +variable {S' : Type*} [CommRing S'] (f : R →+* S') + +/-- Map the scalars of an event along a ring hom (e.g. dyadic rationals to `ZMod 3`). -/ +def _root_.CarrierCode.Event.map : Event R P O → Event S' P O + | .moveP r F => .moveP r F + | .moveO o F => .moveO o F + | .init o F => .init o F + | .clear o => .clear o + | .scaleP r c => .scaleP r (f c) + | .scaleO o c => .scaleO o (f c) + | .addPP r s c => .addPP r s (f c) + | .addOP r o c => .addOP r o (f c) + | .addPO o s c => .addPO o s (f c) + | .addOO o o' c => .addOO o o' (f c) + | .copyPO o s c => .copyPO o s (f c) + | .copyOO o o' c => .copyOO o o' (f c) + +/-- Map every row of a state along a ring hom. -/ +def map (S : State R L P O) : State S' L P O := + ⟨S.fP, S.fO, fun r => f ∘ S.lp r, fun r => f ∘ S.od r, fun o => f ∘ S.ow o, S.delivered.map (f ∘ ·)⟩ + +omit [DecidableEq P] [DecidableEq O] in +theorem comp_update {X : Type*} [DecidableEq X] (g : X → L → R) (x : X) (v : L → R) : + (fun y => (f : R → S') ∘ Function.update g x v y) = Function.update (fun y => (f : R → S') ∘ g y) x (f ∘ v) := by + funext y; by_cases h : y = x + · subst h; simp + · simp [Function.update_of_ne h] + +theorem step_map (S : State R L P O) (e : Event R P O) : (S.step e).map f = (S.map f).step (e.map f) := by + cases e <;> simp only [step, map, Event.map, row, comp_update] <;> congr 1 <;> + (try (congr 1; funext m; simp; try ring)) + +omit [DecidableEq P] [DecidableEq O] in +theorem legal_map (S : State R L P O) (e : Event R P O) : (S.map f).Legal (e.map f) ↔ S.Legal e := by + cases e <;> rfl + +theorem run_map (S : State R L P O) (es : List (Event R P O)) : + (S.run es).map f = (S.map f).run (es.map (Event.map f)) := by + induction es generalizing S with + | nil => rfl + | cons e es ih => simp only [run, List.map_cons]; rw [ih, step_map] + +theorem legalRun_map (S : State R L P O) (es : List (Event R P O)) : + (S.map f).LegalRun (es.map (Event.map f)) ↔ S.LegalRun es := by + induction es generalizing S with + | nil => rfl + | cons e es ih => simp only [LegalRun, List.map_cons, legal_map, ← step_map, ih] + +omit [DecidableEq P] [DecidableEq O] in +theorem row_map (S : State R L P O) (r : P) : (S.map f).row r = f ∘ S.row r := by + funext m; simp [row, map] + +end Map + +end State + +end CarrierCode diff --git a/research/p104-carrier-code-uniqueness/lean/lake-manifest.json b/research/p104-carrier-code-uniqueness/lean/lake-manifest.json new file mode 100644 index 0000000000..88757f6cc3 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/lake-manifest.json @@ -0,0 +1,117 @@ +{ + "version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [ + { + "url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, + "scope": "", + "rev": "55b7917b472489c7c56a0fa6393af05cfd536599", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "55b7917b472489c7c56a0fa6393af05cfd536599", + "inherited": false, + "configFile": "lakefile.lean" + }, + { + "url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "b1c4a69a7e247ab7df20460212001673d74f08c0", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "0498c7c070c143a3bf7379f4d99a2c63bb9d9715", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "18a90119a5d316358fde6c86e0ca24e59212e32c", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "b1436dc749e722c9920036b52cdc43b3451d0b69", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean" + }, + { + "url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "57d3325be72a842920813bcb40f96a6f7393c185", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ee41917ae11d38479fb8fb24745f7ca4bf0a784d", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "2c810760f0a0c4536b397dbe30ca9b2f2f467366", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "da07ca808b6718cb2aed14dba154e5a08b8f8ecf", + "name": "Cli", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.33.0-rc1", + "inherited": true, + "configFile": "lakefile.toml" + } + ], + "name": "CarrierCode", + "lakeDir": ".lake", + "fixedToolchain": false +} diff --git a/research/p104-carrier-code-uniqueness/lean/lakefile.toml b/research/p104-carrier-code-uniqueness/lean/lakefile.toml new file mode 100644 index 0000000000..e2a450f34f --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/lakefile.toml @@ -0,0 +1,10 @@ +name = "CarrierCode" +defaultTargets = ["CarrierCode"] + +[[require]] +name = "mathlib" +git = "https://github.com/leanprover-community/mathlib4.git" +rev = "55b7917b472489c7c56a0fa6393af05cfd536599" + +[[lean_lib]] +name = "CarrierCode" diff --git a/research/p104-carrier-code-uniqueness/lean/lean-toolchain b/research/p104-carrier-code-uniqueness/lean/lean-toolchain new file mode 100644 index 0000000000..fd85b262bf --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.33.0-rc1 From 41a113809b1d8e98bd1e9332481d85e5fba4d49c Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 21:34:31 +0000 Subject: [PATCH 03/11] p104-carrier-code-uniqueness: README Lean section Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYmAARGrLk38Gj9eUPzP --- .../p104-carrier-code-uniqueness/README.md | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/research/p104-carrier-code-uniqueness/README.md b/research/p104-carrier-code-uniqueness/README.md index b041eb1211..ea1046dd63 100644 --- a/research/p104-carrier-code-uniqueness/README.md +++ b/research/p104-carrier-code-uniqueness/README.md @@ -113,6 +113,54 @@ The verifier uses only the standard library ([replay.py](replay.py), The final marker is `PASS_P104_CARRIER_CODE_UNIQUENESS`. +## Lean + +[`lean/`](lean) formalises everything in PROOF.md except the finite search. It +uses the same Mathlib revision as `fragmentation-ceiling`. + +**Machine-checked:** + +- [`CarrierCode/Word.lean`](lean/CarrierCode/Word.lean) models a word as a + list of events with the checker's frame rules. It proves: + - Lemma 1, the frame invariant along any legal run (`inv_run`), starting + from the initial state (`inv_init`), together with the fact that owned + parts lie in the span of the delivered owned rows; + - that `row = lp + od` is the real row semantics (`step_row`); + - Corollary 2 (`decoding_vector`); + - that the word's arithmetic commutes with any ring hom (`run_map`, + `legalRun_map`, `row_map`), which is the formal reduction of a dyadic + word to `ZMod 3`. +- [`CarrierCode/Cost.lean`](lean/CarrierCode/Cost.lean) proves: + - `dim B + dim B^⊥ = 9` for the dot product; + - that a frame holding at least 49 ports has dimension at least 8, and a + frame orthogonal to at least 49 ports has dimension at most 1; + - that the decoding vectors of an 8-clique span the code + (`span_of_clique`); + - Corollary 5 (`carriers_cost`): at least 7 per chain and at least 56 for + the eight chains. + +**Taken as hypotheses, checked by `verify.py`:** + +- `CodeFact`: every 8-dimensional decoding code has row and column minimum + weight at least 49. This is Theorem 3 together with the weight facts. It is + established by the certificate replay. +- `Capacity`: at most 36 ports lie in a subspace of dimension at most 7. This + is Lemma 4, checked by enumeration. + +Both are finite computations that are too large for kernel `decide`, and the +axiom policy rules out `native_decide`. + +To build and audit, run from the repository root: + +```sh +cd research/p104-carrier-code-uniqueness/lean && lake exe cache get && lake build && cd - +python3 scripts/check_lean_axioms.py --project research/p104-carrier-code-uniqueness/lean \ + --audit research/p104-carrier-code-uniqueness/lean/Audit.lean +``` + +The audit reports `propext`, `Classical.choice` and `Quot.sound` only, for all +14 declarations. + ## Limits and open questions - **Partner codes of dimension 9 or more are not classified.** PR6030 is one, From 9802617598902acba1d55674a00635ce6daa0cc8 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 21:55:27 +0000 Subject: [PATCH 04/11] p104-carrier-code-uniqueness: E8 root-line structure of the ports and the code Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYmAARGrLk38Gj9eUPzP --- .../p104-carrier-code-uniqueness/PROOF.md | 28 +++++++++++++++++++ .../p104-carrier-code-uniqueness/verify.py | 22 ++++++++++++++- 2 files changed, 49 insertions(+), 1 deletion(-) diff --git a/research/p104-carrier-code-uniqueness/PROOF.md b/research/p104-carrier-code-uniqueness/PROOF.md index 45cd6daafd..d8d51f3a2b 100644 --- a/research/p104-carrier-code-uniqueness/PROOF.md +++ b/research/p104-carrier-code-uniqueness/PROOF.md @@ -168,6 +168,34 @@ ports, and a subspace of codimension 2 contains at most 36. `verify.py` checks this by enumerating all subspaces. Hence any 49 ports span a space of dimension at least 8. +## 5a. Why the code exists: E8 + +The ports are 104 of the 120 root lines of `E8`. We write `E8` in `A8` +coordinates, so the root lines are `±(e_i − e_j)` and `±(2/3 on a 3-set, +−1/3 elsewhere)`. A port `q` of weight 7, with zeros at `i` and `j`, gives the +root `e_i − e_j`. A port of weight 3 gives the root with `2/3` on its three +coordinates. + +These roots have norm 2. Two ports conflict (` = 1` over `F_2`) exactly +when their roots are orthogonal. The code `C*` is, up to signs, the Gram +matrix of these roots divided by 2. Over `Q` its eigenvalues are 13 (eight +times) and 0 (96 times). The missing lines are 14 of weight 3 and 2 of +weight 7. `verify.py` checks the norms, the orthogonality and the sign equivalence. + +In clique coordinates every other root is `½(±r_a ± r_b ± r_c ± r_d)` over a +block of the Steiner system `S(3,4,8)`: there are 14 blocks with 8 lines +each, and 96 of these 112 lines are ports. The finite model of section 3 then +reads as follows. For each line `j` there are two 4-vectors `α_j, β_j` on its +block, with `<α_j, β_j> = 1` and `<α_j, β_k> = 0` for orthogonal pairs. + +The `E8` solution is `α_j = β_j = ε_j`, the sign pattern of the root. This +works because `4 ≡ 1` mod 3. + +A hand proof of uniqueness is open. Subsystems of three blocks through a pair +of clique points do not force full supports: every probed degenerate support +is locally consistent. So the uniqueness depends on how all 14 blocks fit +together. + ## 6. Scoped cost corollary **Corollary 5.** Take a legal word with dyadic scalars whose partner code diff --git a/research/p104-carrier-code-uniqueness/verify.py b/research/p104-carrier-code-uniqueness/verify.py index bce63b0cb8..1af734b565 100644 --- a/research/p104-carrier-code-uniqueness/verify.py +++ b/research/p104-carrier-code-uniqueness/verify.py @@ -19,6 +19,7 @@ the root is marked dead (its port has options) is rejected, and so is one whose first dead node is replaced by a solution leaf; (6) the receipt equals RESULT.json. """ +from fractions import Fraction from hashlib import sha256 from pathlib import Path import itertools @@ -44,6 +45,16 @@ def need(ok, why): raise ValueError(why) +def e8_root(q): + """the E8 root (A8 coordinates) of an odd port: weight 7 -> e_i - e_j at its zeros, weight 3 -> 2/3 on it, -1/3 off""" + c = [(q >> k) & 1 for k in range(9)] + if sum(c) == 7: + i, j = [k for k in range(9) if not c[k]] + return [Fraction(1) if k == i else Fraction(-1) if k == j else Fraction(0) for k in range(9)] + need(sum(c) == 3, 'ports have weight 3 or 7') + return [Fraction(2, 3) if c[k] else Fraction(-1, 3) for k in range(9)] + + def cert(p): return str(HERE / 'cert' / ('part%d.txt.gz' % p)) @@ -118,7 +129,14 @@ def main(argv): need(all(dot(ports[a], ports[b]) for a in T_INDEX for b in T_INDEX if a != b), 'T is a conflict clique') f8, f7 = max_ports_in_codim(ports, 1), max_ports_in_codim(ports, 2) need((f8, f7) == (60, 36), 'f(8) = 60 and f(7) = 36') - R['structure'] = {'ports': 104, 'conflict_degree': 55, 'clique': T_INDEX, 'f8_hyperplane': f8, 'f7_codim2': f7} + roots = [e8_root(q) for q in ports] + G = [[sum(x * y for x, y in zip(a, b)) for b in roots] for a in roots] + need(all(G[i][i] == 2 for i in range(104)), 'E8 roots have norm 2') + need(all((G[i][j] == 0) == bool(dot(ports[i], ports[j])) for i in range(104) for j in range(104) if i != j), + 'conflict is orthogonality of E8 roots') + e8_half = [[m3(x / 2) for x in r] for r in G] + R['structure'] = {'ports': 104, 'conflict_degree': 55, 'clique': T_INDEX, 'f8_hyperplane': f8, 'f7_codim2': f7, + 'e8_root_lines': 104, 'conflict_is_e8_orthogonality': True} print('structure', R['structure'], flush=True) # (4) the words @@ -140,6 +158,8 @@ def main(argv): 'code_weight_distribution': wd_json(weight_distribution(B))} print(k, R['words'][k], flush=True) need(sign_equivalent(word_rows['pr5907'], word_rows['pr6030']), 'the two words carry sign-equivalent codes') + need(sign_equivalent(e8_half, word_rows['pr5907']), 'the word code is the E8 Gram matrix / 2 mod 3, up to signs') + R['words']['e8_gram_half_sign_equivalent'] = True # (5) controls that do not need the certificate bad = [r[:] for r in word_rows['pr5907']] From f7d6431080b375914216d76a8a6426f50c524471 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 22:09:41 +0000 Subject: [PATCH 05/11] p104-carrier-code-uniqueness: certificate, RESULT.json, open questions Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYmAARGrLk38Gj9eUPzP --- .../p104-carrier-code-uniqueness/README.md | 20 ++- .../p104-carrier-code-uniqueness/RESULT.json | 165 ++++++++++++++++++ .../p104-carrier-code-uniqueness/TASK.json | 6 + .../cert/part0.txt.gz | Bin 0 -> 54066 bytes .../cert/part1.txt.gz | Bin 0 -> 54527 bytes .../cert/part2.txt.gz | Bin 0 -> 46113 bytes .../cert/part3.txt.gz | Bin 0 -> 53634 bytes .../p104-carrier-code-uniqueness/replay.py | 2 + .../p104-carrier-code-uniqueness/verify.py | 3 +- 9 files changed, 193 insertions(+), 3 deletions(-) create mode 100644 research/p104-carrier-code-uniqueness/RESULT.json create mode 100644 research/p104-carrier-code-uniqueness/cert/part0.txt.gz create mode 100644 research/p104-carrier-code-uniqueness/cert/part1.txt.gz create mode 100644 research/p104-carrier-code-uniqueness/cert/part2.txt.gz create mode 100644 research/p104-carrier-code-uniqueness/cert/part3.txt.gz diff --git a/research/p104-carrier-code-uniqueness/README.md b/research/p104-carrier-code-uniqueness/README.md index ea1046dd63..d8bbe25f53 100644 --- a/research/p104-carrier-code-uniqueness/README.md +++ b/research/p104-carrier-code-uniqueness/README.md @@ -73,7 +73,19 @@ written. the search. Its four parts are split by root option, and each was generated in one Kaggle process. - +The search branches first on port 0, which has 15 canonical options. The +four parts hold: + +| Part | Root options | Internal nodes | Dead nodes | Leaves | Generation time | +|---|---:|---:|---:|---:|---:| +| 0 | 4 | 48,696 | 26,162 | 0 | 4,411 s | +| 1 | 4 | 48,328 | 25,730 | 0 | 4,389 s | +| 2 | 4 | 40,897 | 27,884 | **1** | 4,814 s | +| 3 | 3 | 49,050 | 21,251 | 0 | 3,715 s | + +Each part is about 50 KB gzipped. An earlier, independent run of the same +enumeration also found exactly one solution, with identical node totals in +every part. The replay takes about 107 s per pair of parts. [verify.py](verify.py) needs no trust in the certificate. At every node it recomputes all canonical consistent options of the named port, descends into @@ -161,7 +173,11 @@ python3 scripts/check_lean_axioms.py --project research/p104-carrier-code-unique The audit reports `propext`, `Classical.choice` and `Quot.sound` only, for all 14 declarations. -## Limits and open questions +## Open next questions + +- **A hand proof of uniqueness.** We have no proof that does not rely on the + certificate. PROOF.md §5a reduces the question to 14 blocks of + `S(3,4,8)`, but local subsystems do not force the answer. - **Partner codes of dimension 9 or more are not classified.** PR6030 is one, because of a bookkeeping direction. A cheaper design would need carriers diff --git a/research/p104-carrier-code-uniqueness/RESULT.json b/research/p104-carrier-code-uniqueness/RESULT.json new file mode 100644 index 0000000000..a269091fdc --- /dev/null +++ b/research/p104-carrier-code-uniqueness/RESULT.json @@ -0,0 +1,165 @@ +{ + "controls": { + "changed_trit_rejected": true, + "dead_node_with_options_rejected": true, + "early_solution_leaf_rejected": true + }, + "parts": { + "0": { + "dead": 26162, + "internal": 48696, + "root_options": 4, + "solutions": 0 + }, + "1": { + "dead": 25730, + "internal": 48328, + "root_options": 4, + "solutions": 0 + }, + "2": { + "dead": 27884, + "internal": 40897, + "root_options": 4, + "solutions": 1 + }, + "3": { + "dead": 21251, + "internal": 49050, + "root_options": 3, + "solutions": 0 + } + }, + "root": { + "options": 15, + "port": 0 + }, + "solution": { + "decodes": true, + "free_variables": 0, + "min_weight": 49, + "sign_equivalent_to": [ + "pr5907", + "pr6030" + ], + "symmetric_up_to_signs": true, + "weight_distribution": { + "49": 208, + "52": 32, + "62": 16, + "65": 448, + "68": 1504, + "69": 1408, + "70": 512, + "71": 192, + "72": 768, + "73": 1024, + "75": 64, + "76": 384 + } + }, + "structure": { + "clique": [ + 1, + 5, + 18, + 20, + 80, + 85, + 100, + 103 + ], + "conflict_degree": 55, + "conflict_is_e8_orthogonality": true, + "e8_root_lines": 104, + "f7_codim2": 36, + "f8_hyperplane": 60, + "ports": 104 + }, + "words": { + "e8_gram_half_sign_equivalent": true, + "pr5907": { + "all_deliveries_rank_mod3": 13, + "code_weight_distribution": { + "49": 208, + "52": 32, + "62": 16, + "65": 448, + "68": 1504, + "69": 1408, + "70": 512, + "71": 192, + "72": 768, + "73": 1024, + "75": 64, + "76": 384 + }, + "delivery_supports": [ + 32, + 32, + 32, + 45, + 51, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52 + ], + "dyadic": true, + "owned_deliveries": 15, + "partner_owned_parts_inside_code": true, + "partner_owned_parts_rank_mod3": 8, + "path": "research/p104-helper468-rung-removal/WORD.json.gz", + "weight52_deliveries": 10, + "weight52_rank": 8 + }, + "pr6030": { + "all_deliveries_rank_mod3": 13, + "code_weight_distribution": { + "49": 208, + "52": 32, + "62": 16, + "65": 448, + "68": 1504, + "69": 1408, + "70": 512, + "71": 192, + "72": 768, + "73": 1024, + "75": 64, + "76": 384 + }, + "delivery_supports": [ + 32, + 32, + 32, + 45, + 51, + 51, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52 + ], + "dyadic": true, + "owned_deliveries": 16, + "partner_owned_parts_inside_code": false, + "partner_owned_parts_rank_mod3": 9, + "path": "research/p104-helper470-twin-rung-removal/WORD.json.gz", + "weight52_deliveries": 10, + "weight52_rank": 8 + } + } +} diff --git a/research/p104-carrier-code-uniqueness/TASK.json b/research/p104-carrier-code-uniqueness/TASK.json index b76376c1f6..918491f39d 100644 --- a/research/p104-carrier-code-uniqueness/TASK.json +++ b/research/p104-carrier-code-uniqueness/TASK.json @@ -76,6 +76,12 @@ "why_it_matters": "Corollary 5 bounds receivers only for direct deliveries; relays move the cost into public lifts, whose price must be compared.", "first_step": "Price one relay of a single carrier with the exact invoice of the PR5907 word.", "blocked_by": "A legal relay construction." + }, + { + "question": "Is there a computer-free proof that the E8 Gram code is the only 8-dimensional decoding code on these 104 root lines over F_3?", + "why_it_matters": "It would replace the certificate by an argument that extends to other port sets drawn from E8 root lines.", + "first_step": "Work in clique coordinates (PROOF.md section 5a): show that the cross-block conditions force every alpha_j to have full support on its S(3,4,8) block.", + "blocked_by": "Local subsystems of three blocks admit degenerate supports, so the argument has to be global." } ] } diff --git a/research/p104-carrier-code-uniqueness/cert/part0.txt.gz b/research/p104-carrier-code-uniqueness/cert/part0.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..0be72d56f1c1b542f2987817e98e95f2a7434cc8 GIT binary patch literal 54066 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 E01qV6g8%>k literal 0 HcmV?d00001 diff --git a/research/p104-carrier-code-uniqueness/cert/part2.txt.gz b/research/p104-carrier-code-uniqueness/cert/part2.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..f0357d08b4f41b6139e7e9c3a4c611d6e710cfa5 GIT binary patch literal 46113 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%0Db|Zp->^)K%ZH0)`v_m$@l+0Gd_!{Bn4BfP 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 literal 0 HcmV?d00001 diff --git a/research/p104-carrier-code-uniqueness/replay.py b/research/p104-carrier-code-uniqueness/replay.py index 5c5c147c13..cb77c4dbc0 100644 --- a/research/p104-carrier-code-uniqueness/replay.py +++ b/research/p104-carrier-code-uniqueness/replay.py @@ -42,6 +42,8 @@ def node(d, rest, cls, s, rec): if x == 's': if rest: raise ValueError('solution token with unassigned ports') + if len(M.pivots) != M.NV: + raise ValueError('free variables at a solution leaf') rec['solutions'] += 1; sols.append(M.solution()); return kind, j = x.split(); j = int(j) if j not in rest: diff --git a/research/p104-carrier-code-uniqueness/verify.py b/research/p104-carrier-code-uniqueness/verify.py index 1af734b565..53ca0b82c2 100644 --- a/research/p104-carrier-code-uniqueness/verify.py +++ b/research/p104-carrier-code-uniqueness/verify.py @@ -186,7 +186,8 @@ def main(argv): need(min(wr) == 49 and wr == wc and len(rref3(cols)) == 8, 'row and column codes: dim 8, minimum weight 49') for k in WORDS: need(sign_equivalent(rows, word_rows[k]), k + ': word code is sign-equivalent to the solution') - R['solution'] = {'free_variables': M.NV - len(M.pivots), 'decodes': True, 'symmetric_up_to_signs': True, + R['solution'] = {'free_variables': 0, # replay rejects a leaf with free variables + 'decodes': True, 'symmetric_up_to_signs': True, 'weight_distribution': wd_json(wr), 'min_weight': min(wr), 'sign_equivalent_to': sorted(WORDS)} print('solution', R['solution'], flush=True) From 48be6e567c02ad6df9f9a36d2bf1987ad31ad797 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 22:40:23 +0000 Subject: [PATCH 06/11] lean: general steps of the search-free E8 uniqueness proof (frame factorisation, frame sums, A2 trick, coboundary) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYm9RueiYCeCpQh8oBuC --- .../lean/CarrierCode/E8.lean | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8.lean diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8.lean new file mode 100644 index 0000000000..e56d201d9c --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8.lean @@ -0,0 +1,68 @@ +import Mathlib + +/-! +# Search-free uniqueness of the length-8 decoding code: the general steps (E8-PROOF.md) + +This file proves the steps of the E8 argument that do not depend on the concrete port data. + +* `frame_factor` (step 1): if `M = A * B` with inner dimension 8 and `M` is the identity on a frame `f`, then + `M = M[:, f] * M[f, :]`. +* `frame_sum` (step 2): consequently the diagonal entry gives `∑_{x ∈ f} M t x * M x t = M t t`. +* `a2_trick` (step 4): in characteristic 3, symmetry along an A2 triangle forces `r_x ⬝ v_t = 0`. +* `coboundary` (step 5): a ±1 function on pairs of `Fin n` with trivial triangle products is a coboundary. +-/ + +namespace CarrierCode.E8 + +open Matrix + +variable {K : Type*} [Field K] {L : Type*} + +/-- Step 1. A rank-8 factorisation that is the identity on a frame factors through that frame. -/ +theorem frame_factor (A : Matrix L (Fin 8) K) (B : Matrix (Fin 8) L K) (f : Fin 8 → L) + (hf : (A * B).submatrix f f = 1) : + A * B = (A * B).submatrix id f * (A * B).submatrix f id := by + have h1 : A.submatrix f id * B.submatrix id f = 1 := by + rw [← hf]; ext i j; simp [Matrix.mul_apply] + have h2 : B.submatrix id f * A.submatrix f id = 1 := mul_eq_one_comm.mp h1 + have e1 : (A * B).submatrix id f = A * B.submatrix id f := by ext i j; simp [Matrix.mul_apply] + have e2 : (A * B).submatrix f id = A.submatrix f id * B := by ext i j; simp [Matrix.mul_apply] + rw [e1, e2, Matrix.mul_assoc, ← Matrix.mul_assoc (B.submatrix id f), h2, Matrix.one_mul] + +/-- Step 2. The frame sums of `N t x = M t x * M x t`. -/ +theorem frame_sum (A : Matrix L (Fin 8) K) (B : Matrix (Fin 8) L K) (f : Fin 8 → L) + (hf : (A * B).submatrix f f = 1) (t : L) : + ∑ k, (A * B) t (f k) * (A * B) (f k) t = (A * B) t t := by + conv_rhs => rw [frame_factor A B f hf] + simp [Matrix.mul_apply] + +/-- Step 4. The A2 trick: `r_y = r_t - r_x`, each `v_a ⟂ r_a`, and the symmetry relations along the triangle force +`r_x ⬝ v_t = 0` in characteristic 3. -/ +theorem a2_trick {n : Type*} [Fintype n] (rt rx ry vt vx vy : n → ZMod 3) (hy : ry = rt - rx) + (ht : rt ⬝ᵥ vt = 0) (hx : rx ⬝ᵥ vx = 0) (hyy : ry ⬝ᵥ vy = 0) + (stx : rx ⬝ᵥ vt = rt ⬝ᵥ vx) (sty : ry ⬝ᵥ vt = rt ⬝ᵥ vy) (sxy : rx ⬝ᵥ vy = ry ⬝ᵥ vx) : + rx ⬝ᵥ vt = 0 := by + subst hy + have a : (rt - rx) ⬝ᵥ vt = -(rx ⬝ᵥ vt) := by rw [sub_dotProduct, ht, zero_sub] + have b : rt ⬝ᵥ vy = rx ⬝ᵥ vy := by + have : rt = (rt - rx) + rx := by abel + rw [this, add_dotProduct, hyy, zero_add] + have c : (rt - rx) ⬝ᵥ vx = rt ⬝ᵥ vx := by rw [sub_dotProduct, hx, sub_zero] + have key : -(rx ⬝ᵥ vt) = rx ⬝ᵥ vt := by rw [← a, sty, b, sxy, c, ← stx] + have h2 : (2 : ZMod 3) * (rx ⬝ᵥ vt) = 0 := by linear_combination -key + have h2' : (2 : ZMod 3) ≠ 0 := by decide + exact (mul_eq_zero.mp h2).resolve_left h2' + +/-- Step 5. On a complete graph, a sign function with trivial triangle products is a coboundary. -/ +theorem coboundary {n : ℕ} (ρ : Fin (n + 1) → Fin (n + 1) → ℤˣ) (hsym : ∀ a b, ρ a b = ρ b a) + (htri : ∀ a b c, ρ a b * ρ b c * ρ c a = 1) : + ∃ d : Fin (n + 1) → ℤˣ, ∀ a b, ρ a b = d a * d b := by + refine ⟨fun a => ρ 0 a, fun a b => ?_⟩ + have hu : ∀ u : ℤˣ, u * u = 1 := fun u => Int.units_mul_self u + have h := htri 0 a b + rw [hsym b 0] at h + calc ρ a b = (ρ 0 a * ρ 0 a) * ρ a b * (ρ 0 b * ρ 0 b) := by rw [hu, hu, one_mul, mul_one] + _ = ρ 0 a * (ρ 0 a * ρ a b * ρ 0 b) * ρ 0 b := by group + _ = ρ 0 a * ρ 0 b := by rw [h, mul_one] + +end CarrierCode.E8 From 9c1e538f6dbbb71cc3508a736b991450f1cda8a5 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 23:32:55 +0000 Subject: [PATCH 07/11] E8 Lean: data layer, frame check (kernel), step 3 assembled from certificates Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYm9RueiYCeCpQh8oBuC --- .../lean/CarrierCode/E8Cert.lean | 427 +++++++++ .../lean/CarrierCode/E8CheckFrames.lean | 9 + .../lean/CarrierCode/E8Data.lean | 873 ++++++++++++++++++ .../lean/CarrierCode/E8Defs.lean | 117 +++ .../lean/CarrierCode/E8Step3.lean | 214 +++++ 5 files changed, 1640 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Cert.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8CheckFrames.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step3.lean diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Cert.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Cert.lean new file mode 100644 index 0000000000..7cb0f29e32 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Cert.lean @@ -0,0 +1,427 @@ +/-! Generated by Matarener/Internal local-topology-2026-10-27/e8hand/gen_lean_cert.py: step-3 certificates. -/ + +namespace CarrierCode.E8 + +def seedData : List (List Nat) := [ + [84, 85, 90, 91, 92, 93, 94], + [78, 84, 90, 95, 96, 97, 98], + [84, 86, 91, 95, 99, 100, 101], + [82, 84, 88, 93, 97, 100, 102], + [82, 83, 89, 94, 98, 101, 103], + [79, 89, 90, 91, 92, 93, 94], + [80, 89, 90, 95, 96, 97, 98], + [81, 89, 91, 95, 99, 100, 101], + [82, 89, 92, 96, 99, 102, 103], + [83, 87, 89, 93, 97, 100, 102], + [84, 87, 88, 94, 98, 101, 103], + [81, 86, 94, 95, 99, 100, 101], + [82, 87, 94, 96, 99, 102, 103], + [84, 89, 92, 93, 98, 101, 103], + [81, 86, 91, 98, 99, 100, 101], + [82, 87, 92, 98, 99, 102, 103], + [83, 88, 93, 96, 98, 100, 102], + [84, 89, 94, 96, 97, 101, 103], + [83, 88, 93, 97, 99, 101, 102], + [83, 88, 93, 97, 99, 100, 103], + [84, 89, 94, 98, 99, 101, 102], + [84, 89, 94, 98, 101, 102, 103], + [84, 89, 90, 91, 92, 93, 94], + [84, 89, 90, 95, 96, 97, 98], + [84, 89, 91, 95, 99, 100, 101], + [84, 89, 92, 96, 99, 102, 103], + [84, 87, 89, 93, 97, 100, 102], + [83, 87, 88, 94, 98, 101, 103], + [84, 85, 94, 95, 96, 97, 98], + [84, 87, 94, 96, 99, 102, 103], + [84, 88, 92, 94, 97, 100, 102], + [84, 86, 91, 98, 99, 100, 101], + [84, 88, 93, 96, 98, 100, 102], + [83, 89, 94, 96, 97, 101, 103], + [84, 87, 92, 96, 101, 102, 103], + [83, 89, 94, 98, 99, 100, 103], + [84, 88, 93, 97, 99, 100, 103], + [83, 89, 94, 98, 99, 101, 102], + [82, 89, 94, 98, 101, 102, 103], + [80, 89, 94, 95, 96, 97, 98], + [81, 89, 94, 95, 99, 100, 101], + [83, 89, 92, 94, 97, 100, 102], + [84, 88, 92, 93, 98, 101, 103], + [82, 89, 92, 98, 99, 102, 103], + [83, 89, 93, 96, 98, 100, 102], + [84, 88, 94, 96, 97, 101, 103], + [82, 89, 92, 96, 101, 102, 103], + [83, 89, 93, 97, 99, 101, 102], + [84, 88, 94, 98, 99, 100, 103], + [83, 89, 93, 97, 99, 100, 103], + [84, 88, 94, 98, 99, 101, 102], + [84, 87, 94, 98, 101, 102, 103], + [81, 86, 94, 98, 99, 100, 101], + [82, 87, 94, 98, 99, 102, 103], + [83, 88, 94, 96, 98, 100, 102], + [84, 89, 93, 96, 97, 101, 103], + [83, 88, 94, 97, 99, 101, 102], + [84, 89, 93, 98, 99, 100, 103], + [83, 88, 94, 97, 99, 100, 103], + [84, 89, 93, 98, 99, 101, 102], + [84, 89, 92, 98, 101, 102, 103], + [82, 87, 92, 98, 101, 102, 103], + [83, 88, 93, 98, 99, 101, 102], + [84, 89, 94, 97, 99, 100, 103], + [83, 88, 93, 98, 99, 100, 103], + [84, 89, 94, 97, 99, 101, 102], + [84, 89, 94, 96, 101, 102, 103], + [83, 88, 93, 96, 97, 101, 103], + [84, 89, 94, 96, 98, 100, 102], + [84, 89, 94, 98, 99, 102, 103], + [38, 79, 80, 81, 82, 83, 84], + [51, 78, 85, 86, 87, 88, 89], + [60, 85, 90, 91, 92, 93, 94], + [66, 80, 90, 95, 96, 97, 98], + [69, 86, 91, 95, 99, 100, 101], + [68, 87, 92, 96, 99, 102, 103], + [69, 83, 88, 93, 97, 100, 102], + [69, 84, 89, 94, 98, 101, 103], + [51, 80, 85, 86, 87, 88, 89], + [60, 85, 90, 91, 92, 93, 94], + [66, 78, 90, 95, 96, 97, 98], + [69, 86, 91, 95, 99, 100, 101], + [68, 87, 92, 96, 99, 102, 103], + [69, 84, 88, 93, 97, 100, 102], + [69, 83, 89, 94, 98, 101, 103], + [60, 79, 90, 91, 92, 93, 94], + [69, 81, 91, 95, 99, 100, 101], + [68, 82, 92, 96, 99, 102, 103], + [69, 83, 89, 93, 97, 100, 102], + [69, 84, 88, 94, 98, 101, 103], + [66, 80, 85, 95, 96, 97, 98], + [69, 81, 86, 95, 99, 100, 101], + [68, 82, 87, 96, 99, 102, 103], + [69, 83, 88, 94, 97, 100, 102], + [69, 84, 89, 93, 98, 101, 103], + [69, 81, 86, 91, 99, 100, 101], + [68, 82, 87, 92, 99, 102, 103], + [69, 83, 88, 93, 98, 100, 102], + [69, 84, 89, 94, 97, 101, 103], + [69, 82, 87, 92, 96, 102, 103], + [68, 83, 88, 93, 97, 101, 102], + [67, 84, 89, 94, 98, 100, 103], + [69, 83, 88, 93, 97, 100, 103], + [69, 84, 89, 94, 98, 101, 102]] + +def wData : List (List (List Nat)) := [ + [[2, 1, 1, 1, 1, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [2, 1, 0, 1, 1, 2, 0, 0]], + [[1, 2, 0, 2, 2, 1, 1, 1], [1, 2, 1, 2, 2, 0, 0, 0], [2, 0, 2, 1, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [0, 0, 0, 0, 0, 0, 1, 1]], + [[2, 1, 1, 1, 1, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [2, 1, 0, 1, 1, 2, 0, 0]], + [[1, 2, 0, 2, 2, 1, 0, 0], [1, 2, 1, 2, 2, 0, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [0, 0, 1, 0, 0, 0, 0, 1]], + [[0, 0, 2, 0, 1, 2, 2, 2], [2, 1, 2, 1, 0, 2, 2, 2], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [1, 2, 2, 2, 1, 2, 1, 2]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [0, 1, 2, 1, 1, 2, 0, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [0, 1, 2, 1, 1, 2, 0, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [0, 1, 2, 1, 1, 2, 0, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [2, 1, 2, 1, 0, 2, 2, 2], [0, 1, 2, 1, 1, 2, 0, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [0, 2, 1, 2, 2, 1, 0, 0], [1, 2, 1, 2, 2, 0, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [1, 0, 0, 0, 0, 0, 0, 1]], + [[0, 2, 1, 2, 2, 1, 1, 1], [2, 0, 0, 0, 1, 2, 2, 2], [2, 1, 2, 1, 0, 2, 2, 2], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [2, 2, 1, 2, 1, 2, 1, 2]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [1, 2, 1, 0, 0, 0, 1, 1]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [2, 1, 2, 1, 0, 2, 2, 2], [1, 2, 1, 0, 0, 0, 1, 1]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [1, 2, 1, 1, 2, 1, 1, 1], [2, 1, 2, 1, 0, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [0, 0, 0, 1, 0, 0, 2, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [0, 2, 0, 0, 2, 0, 0, 0], [1, 2, 1, 2, 2, 1, 0, 1], [2, 1, 2, 1, 0, 2, 2, 2], [1, 0, 1, 2, 0, 0, 1, 1]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [0, 2, 0, 0, 2, 0, 0, 0], [1, 2, 1, 2, 2, 1, 1, 0], [2, 1, 2, 1, 0, 2, 2, 2], [1, 0, 1, 2, 0, 0, 1, 1]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 0, 2, 1, 0, 0, 2, 2], [1, 2, 1, 2, 2, 0, 1, 1], [1, 2, 1, 2, 2, 1, 1, 0], [2, 2, 2, 1, 2, 1, 1, 2]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [1, 1, 1, 2, 2, 1, 1, 1], [2, 1, 2, 1, 0, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [0, 1, 0, 0, 0, 0, 2, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [0, 2, 0, 2, 2, 1, 0, 1], [1, 2, 1, 2, 2, 0, 1, 1], [1, 0, 1, 0, 0, 0, 0, 0]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [0, 2, 0, 2, 2, 1, 1, 0], [1, 0, 1, 0, 0, 0, 0, 0], [1, 2, 1, 2, 2, 0, 1, 1]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [2, 0, 2, 0, 1, 2, 0, 2], [2, 2, 2, 2, 1, 2, 1, 1], [2, 1, 2, 1, 0, 2, 2, 2]], + [[0, 2, 1, 2, 2, 1, 1, 1], [1, 2, 0, 2, 2, 1, 1, 1], [2, 0, 2, 1, 1, 2, 2, 2], [2, 1, 2, 0, 1, 2, 2, 2], [1, 2, 1, 2, 2, 1, 1, 0], [0, 2, 0, 2, 0, 0, 0, 0], [1, 0, 1, 0, 2, 1, 0, 1]], + [[1, 1, 0, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 2, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 2, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 2, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 2, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 0, 2, 0, 0, 2, 1, 1], [1, 1, 2, 1, 1, 1, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [0, 2, 0, 2, 2, 0, 0, 1]], + [[1, 1, 0, 1, 1, 0, 0, 0], [1, 1, 1, 1, 2, 0, 0, 0], [2, 0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [1, 1, 1, 1, 0, 2, 1, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 1, 1, 0, 0, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 1, 1, 1, 2, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [0, 1, 0, 1, 0, 0, 0, 0], [2, 1, 0, 2, 2, 2, 0, 0]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [1, 2, 0, 1, 1, 1, 0, 0], [1, 1, 2, 1, 1, 1, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [1, 0, 2, 1, 1, 1, 1, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [2, 2, 0, 1, 2, 2, 0, 0]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [1, 1, 0, 2, 1, 1, 0, 0], [1, 1, 2, 1, 1, 1, 2, 2], [2, 2, 2, 2, 2, 2, 2, 1], [1, 1, 2, 0, 1, 1, 1, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 2, 2, 0, 0, 2, 2, 2], [2, 0, 0, 0, 2, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 0, 0, 2, 2, 0, 2, 0]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 2, 0, 0, 1, 2, 1]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 1, 0, 1, 2, 0, 0, 1], [2, 0, 0, 0, 2, 0, 0, 0], [1, 1, 2, 1, 0, 2, 1, 1]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 0, 1, 0, 0, 2, 2, 1], [0, 2, 1, 2, 2, 0, 0, 0], [1, 1, 2, 1, 1, 1, 2, 2]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 1, 0, 1, 2, 0, 1, 0], [1, 1, 2, 1, 0, 2, 1, 1], [2, 0, 0, 0, 2, 0, 0, 0]], + [[1, 1, 0, 1, 1, 0, 0, 0], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [2, 2, 0, 2, 1, 0, 2, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [2, 0, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [0, 1, 2, 2, 2, 2, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [0, 1, 2, 2, 2, 2, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 2, 1, 1, 1, 1, 0, 0], [2, 1, 1, 1, 1, 1, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 0, 1, 1, 1, 1, 1, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [2, 0, 0, 2, 0, 2, 2, 2], [0, 0, 2, 0, 2, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [0, 2, 2, 0, 2, 0, 2, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 1], [0, 1, 0, 1, 0, 0, 0, 0], [0, 2, 2, 1, 2, 2, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 1, 2, 1, 1, 0, 0], [2, 1, 1, 1, 1, 1, 2, 2], [2, 2, 2, 2, 2, 2, 2, 1], [2, 1, 1, 0, 1, 1, 1, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 0, 0, 0, 2, 2, 2], [0, 0, 2, 0, 2, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [0, 0, 2, 2, 2, 0, 2, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 1, 0, 1, 0, 0, 0, 0], [2, 0, 1, 0, 0, 1, 2, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 0, 2, 0, 0, 2, 1, 2], [2, 1, 1, 1, 1, 1, 2, 2], [1, 2, 0, 2, 2, 0, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 1, 1, 2, 0, 0, 1], [0, 0, 2, 0, 2, 0, 0, 0], [2, 1, 1, 1, 0, 2, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 0, 2, 0, 0, 2, 2, 1], [1, 2, 0, 2, 2, 0, 0, 0], [2, 1, 1, 1, 1, 1, 2, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 1, 1, 2, 0, 1, 0], [2, 1, 1, 1, 0, 2, 1, 1], [0, 0, 2, 0, 2, 0, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 2, 2, 2, 1, 0, 2, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 1, 2], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 1], [0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [2, 0, 2, 0, 2, 0, 2, 2], [0, 2, 0, 0, 0, 2, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [0, 2, 0, 2, 0, 2, 2, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 2, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2, 1], [1, 1, 1, 1, 1, 1, 0, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [0, 2, 0, 1, 1, 1, 0, 1], [0, 2, 0, 0, 0, 2, 0, 0], [2, 0, 2, 1, 1, 1, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 0, 2, 2, 0, 2, 2, 0], [1, 1, 1, 2, 1, 1, 1, 1], [0, 2, 0, 0, 2, 0, 2, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [0, 2, 0, 1, 1, 1, 1, 0], [2, 0, 2, 1, 1, 1, 1, 1], [0, 2, 0, 0, 0, 2, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 0, 2, 2, 0, 2, 0, 2], [0, 2, 0, 0, 2, 0, 2, 2], [1, 1, 1, 2, 1, 1, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [2, 0, 2, 2, 2, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [1, 0, 1, 1, 0, 1, 0, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [0, 1, 0, 1, 1, 0, 0, 1], [0, 1, 0, 1, 0, 0, 0, 0], [0, 2, 0, 1, 2, 2, 0, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [0, 1, 0, 2, 1, 1, 0, 1], [0, 0, 0, 2, 0, 2, 0, 0], [2, 1, 2, 0, 1, 1, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 0, 0, 2, 2, 0], [1, 2, 1, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 2, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [0, 1, 0, 2, 1, 1, 1, 0], [2, 1, 2, 0, 1, 1, 1, 1], [0, 0, 0, 2, 0, 2, 0, 0]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 0, 0, 2, 0, 2], [0, 0, 0, 2, 2, 0, 2, 2], [1, 2, 1, 1, 1, 1, 1, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [1, 1, 1, 0, 0, 1, 0, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [1, 0, 1, 0, 0, 2, 2, 2], [2, 1, 2, 0, 1, 1, 1, 1], [0, 1, 0, 1, 1, 0, 0, 1], [2, 1, 2, 1, 1, 1, 2, 1]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 1, 2, 0, 1, 1], [0, 0, 0, 2, 2, 0, 2, 2], [0, 1, 0, 1, 1, 0, 0, 1], [0, 0, 0, 0, 2, 0, 0, 2]], + [[1, 2, 2, 2, 2, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 2, 0, 2, 1, 0, 2, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 2, 1, 1, 1, 2, 2, 2], [2, 1, 1, 2, 1, 2, 2, 2], [0, 0, 2, 0, 0, 0, 0, 1], [0, 0, 2, 0, 0, 0, 1, 0], [1, 1, 0, 1, 2, 1, 1, 1], [2, 0, 1, 0, 0, 0, 2, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 2, 1, 1, 2, 1, 1, 1], [0, 1, 0, 2, 0, 0, 0, 0], [1, 2, 1, 1, 2, 1, 1, 2], [1, 2, 1, 1, 2, 1, 2, 1], [2, 0, 2, 2, 1, 2, 2, 2], [0, 2, 0, 1, 2, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 0, 1, 0, 0, 0, 0, 0], [1, 1, 2, 2, 1, 2, 2, 2], [2, 0, 0, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 1, 2, 1, 1, 1], [1, 0, 2, 0, 0, 0, 2, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [1, 0, 2, 0, 0, 0, 0, 0], [2, 2, 1, 1, 1, 2, 2, 2], [0, 0, 2, 0, 0, 0, 0, 1], [0, 0, 2, 0, 0, 0, 1, 0], [1, 1, 0, 1, 2, 1, 1, 1], [2, 0, 1, 0, 0, 0, 2, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 0, 1, 0, 0, 0, 0, 0], [1, 2, 2, 1, 1, 2, 2, 2], [1, 1, 2, 2, 1, 2, 2, 2], [2, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 1, 2, 1, 1, 1], [1, 0, 2, 0, 0, 0, 2, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 0, 1, 0, 0, 0, 0, 0], [1, 2, 2, 1, 1, 2, 2, 2], [1, 1, 2, 2, 1, 2, 2, 2], [1, 0, 2, 0, 0, 2, 2, 0], [1, 1, 2, 1, 2, 2, 2, 2], [1, 0, 2, 0, 0, 0, 2, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 0, 1, 0, 0, 0, 1, 1], [1, 0, 2, 0, 0, 0, 1, 1], [0, 2, 0, 1, 1, 2, 0, 0], [0, 1, 0, 2, 1, 2, 0, 0], [0, 0, 0, 0, 0, 2, 0, 1], [1, 0, 1, 0, 0, 0, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [0, 2, 2, 2, 1, 2, 2, 2], [2, 2, 0, 2, 1, 2, 2, 2], [1, 1, 1, 0, 2, 1, 1, 1], [1, 0, 1, 1, 2, 1, 1, 1], [1, 2, 1, 2, 1, 1, 1, 2], [2, 2, 2, 2, 1, 2, 0, 2]], + [[2, 0, 2, 0, 0, 2, 2, 2], [0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [1, 1, 2, 1, 1, 1, 1, 1], [0, 2, 0, 0, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 2, 1, 2, 2, 2, 2, 2], [0, 0, 0, 2, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 2, 0, 2, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [0, 2, 0, 2, 2, 2, 0, 0], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [1, 1, 1, 1, 0, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [0, 2, 0, 0, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 2, 0, 2, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [0, 2, 0, 2, 2, 2, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [2, 2, 1, 2, 2, 2, 2, 2], [1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 2, 0, 0, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 2, 0, 2, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 2, 0, 2, 2, 2, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 1, 1, 1], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [1, 1, 1, 1, 1, 1, 2, 1], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 2, 0, 2, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 2, 2, 2, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [1, 1, 1, 1, 0, 1, 1, 1], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 2, 1]], + [[1, 0, 1, 0, 0, 1, 1, 1], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [2, 2, 2, 2, 0, 2, 2, 2], [0, 1, 0, 1, 1, 1, 0, 0]], + [[1, 0, 1, 0, 0, 1, 1, 1], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 2, 0, 2, 2, 2, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0]], + [[1, 0, 1, 0, 0, 1, 1, 1], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [1, 1, 1, 1, 0, 1, 1, 1], [0, 1, 0, 1, 1, 0, 1, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [0, 2, 0, 2, 2, 2, 0, 0]], + [[2, 0, 2, 0, 0, 2, 2, 2], [2, 1, 1, 1, 1, 1, 1, 1], [1, 1, 2, 1, 1, 1, 1, 1], [0, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 0, 2, 0, 0, 0], [0, 1, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 0, 1, 1, 1]]] + +def comb0 : List (List (Nat × Nat)) := [[], [(57, 1), (58, 1), (60, 2), (63, 2), (66, 2), (67, 1), (72, 1), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(57, 1), (60, 2), (63, 2), (66, 2), (67, 1), (71, 2), (72, 1), (74, 1), (117, 2), (121, 2), (233, 2), (234, 1), (291, 1)], [(57, 1), (60, 1), (63, 2), (66, 2), (67, 2), (72, 1), (117, 2), (121, 1), (173, 1), (233, 2), (234, 1), (291, 1)], [(57, 1), (60, 1), (63, 2), (66, 1), (67, 2), (72, 2), (117, 2), (121, 1), (233, 2), (234, 2), (291, 1)], [(57, 2), (60, 2), (63, 1), (66, 2), (67, 1), (72, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [], [], [(57, 1), (60, 2), (63, 1), (66, 2), (67, 1), (72, 1), (75, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [(57, 1), (60, 2), (63, 2), (64, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (77, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [(57, 1), (60, 2), (63, 2), (66, 2), (67, 1), (72, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [], [], [], [], [], [(57, 2), (58, 1), (60, 1), (63, 1), (64, 1), (65, 2), (66, 1), (68, 1), (71, 2), (72, 2), (74, 1), (115, 2), (117, 1), (127, 2), (131, 1), (291, 2)], [], [], [], [], [], [(57, 1), (58, 2), (60, 2), (63, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 2), (72, 1), (74, 1), (115, 1), (117, 1), (121, 1), (127, 1), (131, 2), (291, 2)], [(57, 1), (58, 1), (60, 2), (63, 2), (65, 1), (66, 1), (68, 2), (71, 2), (72, 2), (74, 1), (115, 2), (117, 1), (127, 2), (131, 1), (291, 2)], [(57, 1), (58, 2), (60, 1), (63, 2), (65, 2), (66, 2), (68, 1), (71, 2), (72, 1), (74, 1), (115, 2), (117, 1), (127, 2), (131, 1), (291, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [(57, 2), (58, 1), (60, 1), (63, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 1), (72, 2), (74, 2), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 1), (60, 1), (63, 1), (65, 1), (67, 1), (68, 2), (71, 1), (74, 2), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 1), (60, 1), (63, 1), (65, 1), (66, 1), (67, 1), (68, 2), (71, 1), (72, 2), (74, 2), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 2), (63, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (72, 2), (74, 1), (115, 1), (121, 2), (127, 1), (131, 2), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 1), (60, 1), (63, 1), (65, 1), (67, 1), (68, 2), (71, 2), (74, 1), (115, 2), (117, 2), (121, 2), (127, 1), (131, 2), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 2), (60, 1), (63, 1), (64, 2), (65, 1), (66, 1), (67, 1), (68, 2), (71, 2), (72, 2), (74, 1), (115, 1), (117, 2), (120, 1), (121, 2), (127, 1), (131, 2), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 2), (60, 1), (63, 1), (65, 2), (66, 1), (68, 1), (71, 1), (72, 2), (74, 2), (115, 1), (117, 2), (127, 1), (131, 2), (173, 2), (174, 1), (233, 2), (234, 1), (291, 1)], [(57, 2), (58, 2), (60, 1), (63, 1), (65, 2), (66, 2), (68, 1), (71, 1), (72, 1), (74, 2), (115, 1), (117, 2), (127, 1), (131, 2), (233, 2), (236, 1), (291, 1)], [(57, 2), (58, 2), (60, 2), (63, 1), (64, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (115, 1), (117, 2), (127, 1), (131, 2), (173, 2), (181, 1), (233, 2), (234, 1), (291, 1)], [], [], [], [], [], [], [], [], [], [(58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (74, 1), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(58, 1), (65, 2), (67, 1), (68, 2), (71, 2), (74, 1), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(58, 1), (65, 1), (67, 2), (68, 2), (71, 2), (74, 1), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(58, 1), (65, 2), (67, 1), (68, 1), (71, 2), (73, 1), (74, 1), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (72, 2), (74, 2), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(60, 1), (65, 1), (67, 1), (68, 2), (71, 1), (74, 2), (80, 1), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [(58, 1), (64, 1), (65, 2), (67, 1), (68, 1), (71, 2), (74, 1), (115, 2), (117, 2), (120, 2), (121, 2), (127, 2), (130, 1), (131, 1), (233, 2), (234, 1), (291, 1)], [(58, 2), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (72, 2), (74, 1), (115, 1), (117, 2), (121, 2), (127, 2), (131, 2), (233, 2), (234, 1), (291, 1)], [(58, 1), (60, 1), (65, 1), (67, 1), (68, 2), (71, 2), (74, 1), (115, 1), (117, 2), (121, 2), (127, 1), (131, 2), (137, 1), (233, 2), (234, 1), (291, 1)], [], [(57, 2), (58, 2), (65, 1), (67, 2), (68, 2), (71, 1), (74, 2), (115, 1), (117, 1), (121, 1), (127, 1), (131, 2), (233, 2), (234, 1), (291, 2), (314, 1)], [], [(58, 1), (64, 2), (65, 1), (67, 2), (68, 2), (71, 1), (74, 2), (99, 1), (115, 2), (121, 1), (127, 2), (131, 1), (233, 1), (234, 2)], [(58, 2), (64, 2), (65, 1), (67, 2), (68, 2), (71, 2), (74, 1), (115, 1), (121, 1), (127, 1), (131, 2), (157, 1), (233, 1), (234, 2)], [(58, 2), (65, 2), (66, 1), (67, 1), (68, 1), (71, 1), (72, 2), (74, 2), (115, 1), (117, 1), (120, 2), (121, 2), (127, 1), (131, 2), (233, 2), (234, 1), (291, 2), (392, 1)], [(58, 2), (60, 1), (64, 2), (65, 1), (67, 1), (68, 2), (71, 1), (74, 2), (115, 1), (121, 2), (127, 1), (131, 2), (173, 2), (216, 1), (233, 1), (234, 2)], [(58, 2), (60, 1), (64, 2), (65, 1), (66, 1), (67, 1), (68, 2), (71, 1), (72, 2), (74, 2), (115, 1), (121, 2), (127, 1), (131, 2), (233, 1), (234, 1), (274, 1)], [(57, 2), (58, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (71, 2), (72, 2), (74, 1), (75, 2), (115, 2), (117, 1), (120, 1), (127, 2), (130, 2), (131, 1), (291, 2), (470, 1)], [], [(57, 1), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (115, 1), (121, 2), (127, 1), (131, 2), (233, 2), (234, 1)], [(60, 2), (66, 2), (67, 1), (71, 1), (72, 1), (74, 2), (114, 1), (121, 2), (233, 2), (234, 1)], [(60, 2), (64, 1), (65, 1), (68, 2), (117, 1), (120, 2), (291, 2), (293, 1)], [(66, 2), (72, 1), (172, 1), (173, 2), (233, 2), (234, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb1 : List (List (Nat × Nat)) := [[(1, 1), (6, 1), (9, 1), (10, 2), (15, 1), (16, 2), (18, 2), (115, 2), (117, 2), (121, 2), (127, 2), (131, 1), (233, 2), (234, 1), (291, 1)], [], [(1, 1), (8, 1), (10, 2), (18, 2), (117, 2), (121, 2), (233, 2), (234, 1), (291, 1)], [(1, 2), (6, 1), (7, 2), (8, 1), (10, 2), (18, 1), (117, 2), (121, 1), (173, 1), (233, 2), (234, 1), (291, 1)], [(1, 2), (8, 2), (10, 1), (18, 1), (117, 2), (121, 1), (233, 2), (234, 2), (291, 1)], [], [(0, 1), (1, 1), (3, 2), (6, 1), (9, 1), (10, 2), (15, 1), (17, 2), (18, 2), (20, 2), (115, 2), (117, 2), (120, 1), (121, 2), (127, 2), (130, 2), (131, 1), (233, 2), (234, 1), (291, 1), (470, 1)], [], [], [], [], [], [], [], [(1, 1), (8, 1), (10, 2), (18, 2), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [(0, 2), (1, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (15, 2), (18, 1), (20, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [(1, 1), (6, 1), (8, 1), (10, 2), (18, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [(1, 1), (8, 2), (10, 2), (18, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [], [], [(0, 2), (1, 1), (3, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1), (15, 2), (17, 1), (20, 1), (120, 2), (130, 1), (470, 2)], [], [], [], [], [(0, 1), (1, 1), (3, 2), (6, 1), (7, 2), (11, 1), (15, 1), (17, 2), (18, 2), (20, 2), (117, 2), (120, 1), (121, 1), (130, 2), (291, 1), (470, 1)], [], [], [(0, 1), (1, 2), (3, 2), (7, 2), (8, 1), (9, 2), (11, 1), (16, 1), (17, 2), (18, 2), (20, 2), (115, 1), (117, 2), (120, 1), (127, 1), (130, 2), (131, 2), (291, 1), (470, 1)], [(0, 2), (1, 1), (3, 2), (6, 1), (7, 2), (11, 1), (12, 2), (15, 1), (17, 2), (18, 2), (20, 2), (115, 1), (117, 2), (120, 1), (127, 1), (130, 2), (131, 2), (291, 1), (470, 1)], [(0, 1), (1, 1), (7, 2), (8, 1), (9, 2), (11, 1), (15, 1), (17, 2), (18, 2), (20, 2), (115, 1), (117, 2), (120, 1), (127, 1), (130, 2), (131, 2), (291, 1), (470, 1)], [], [], [], [], [], [], [(0, 1), (3, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (15, 1), (17, 2), (20, 2), (115, 1), (120, 1), (121, 2), (127, 1), (130, 2), (131, 2), (233, 2), (234, 1), (470, 1)], [(0, 1), (3, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 1), (16, 1), (17, 2), (20, 2), (115, 1), (120, 1), (121, 2), (127, 1), (130, 2), (131, 2), (233, 2), (234, 1), (470, 1)], [(0, 1), (3, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (16, 1), (17, 2), (20, 2), (115, 1), (120, 1), (121, 2), (127, 1), (130, 2), (131, 2), (233, 2), (234, 1), (470, 1)], [], [], [], [(0, 1), (3, 2), (6, 2), (7, 1), (8, 1), (10, 2), (11, 1), (15, 1), (17, 2), (20, 2), (117, 1), (120, 1), (121, 2), (130, 2), (233, 2), (234, 1), (470, 1)], [(0, 1), (3, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (15, 1), (17, 2), (20, 2), (115, 1), (120, 1), (121, 2), (130, 2), (233, 2), (234, 1), (470, 1)], [(0, 1), (3, 1), (6, 2), (7, 1), (8, 1), (10, 2), (11, 2), (15, 1), (17, 2), (20, 2), (120, 2), (121, 2), (130, 2), (233, 2), (234, 1), (470, 1)], [(0, 2), (1, 1), (3, 2), (6, 1), (8, 1), (10, 2), (11, 1), (12, 2), (15, 2), (17, 2), (18, 1), (20, 1), (120, 1), (130, 2), (173, 2), (174, 1), (233, 2), (234, 1), (470, 1)], [(0, 2), (1, 1), (3, 2), (6, 2), (7, 2), (11, 1), (12, 2), (15, 2), (17, 2), (18, 1), (20, 1), (120, 1), (130, 2), (233, 2), (236, 1), (470, 1)], [(0, 1), (1, 2), (3, 1), (6, 1), (7, 2), (8, 1), (10, 2), (11, 2), (15, 1), (17, 2), (18, 1), (20, 2), (120, 1), (130, 2), (173, 2), (181, 1), (233, 2), (234, 1), (470, 1)], [], [], [], [], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 2), (8, 1), (10, 2), (11, 2), (15, 2), (17, 1), (18, 1), (20, 1), (117, 1), (120, 2), (121, 2), (130, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [(0, 2), (1, 2), (3, 1), (6, 2), (7, 1), (11, 2), (15, 2), (17, 1), (18, 1), (20, 1), (117, 1), (120, 2), (121, 2), (130, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 2), (8, 1), (10, 2), (11, 1), (15, 2), (16, 1), (17, 1), (18, 1), (20, 1), (117, 1), (120, 2), (121, 2), (130, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [(0, 2), (1, 2), (3, 1), (6, 2), (7, 2), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (17, 2), (18, 1), (20, 1), (117, 1), (120, 2), (121, 2), (130, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [(0, 1), (3, 1), (6, 1), (7, 1), (8, 1), (9, 2), (10, 2), (11, 2), (12, 1), (15, 1), (16, 1), (17, 1), (18, 1), (20, 1), (22, 1), (117, 1), (120, 2), (121, 2), (130, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [], [], [], [], [], [], [(0, 2), (1, 2), (3, 2), (6, 1), (7, 2), (8, 1), (10, 2), (11, 1), (15, 2), (17, 1), (18, 1), (20, 1), (117, 1), (120, 1), (121, 2), (130, 2), (233, 2), (234, 1), (291, 2), (470, 2)], [(0, 2), (1, 2), (3, 1), (6, 2), (7, 2), (9, 1), (10, 2), (11, 1), (15, 2), (17, 1), (18, 1), (20, 1), (115, 2), (117, 1), (120, 2), (121, 2), (130, 1), (131, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [(0, 2), (1, 2), (3, 1), (6, 2), (7, 2), (9, 1), (10, 2), (11, 1), (15, 2), (17, 1), (18, 1), (20, 1), (115, 2), (117, 1), (120, 2), (121, 2), (127, 2), (130, 1), (131, 1), (137, 1), (233, 2), (234, 1), (291, 2), (470, 2)], [], [(0, 1), (1, 1), (3, 2), (6, 2), (8, 2), (9, 2), (10, 2), (11, 2), (12, 1), (15, 1), (17, 1), (18, 2), (20, 2), (117, 2), (120, 1), (121, 1), (130, 2), (233, 2), (234, 1), (291, 1), (314, 1), (470, 1)], [(0, 1), (1, 1), (3, 1), (6, 1), (7, 1), (9, 2), (10, 1), (11, 2), (12, 1), (15, 1), (16, 1), (17, 1), (18, 2), (20, 1), (44, 1), (117, 2), (120, 2), (121, 1), (130, 1), (233, 1), (234, 2), (291, 1), (470, 2)], [], [(0, 1), (1, 1), (3, 1), (6, 2), (7, 1), (8, 2), (10, 1), (11, 2), (12, 1), (15, 2), (17, 1), (18, 2), (20, 1), (115, 2), (117, 2), (120, 2), (121, 1), (127, 2), (130, 1), (131, 1), (157, 1), (233, 1), (234, 2), (291, 1), (470, 2)], [(0, 2), (1, 2), (3, 2), (6, 2), (7, 2), (9, 1), (10, 2), (11, 1), (16, 2), (17, 1), (20, 1), (115, 2), (120, 1), (121, 2), (127, 2), (130, 1), (131, 1), (233, 2), (234, 1), (392, 1), (470, 2)], [(0, 2), (1, 2), (3, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 2), (16, 2), (17, 1), (20, 1), (115, 2), (117, 2), (120, 2), (121, 2), (127, 2), (130, 1), (131, 1), (173, 2), (216, 1), (233, 1), (234, 2), (291, 1), (470, 2)], [(0, 2), (1, 2), (3, 1), (7, 1), (9, 1), (10, 2), (11, 2), (16, 2), (17, 1), (20, 1), (115, 2), (117, 2), (120, 2), (121, 2), (127, 2), (130, 1), (131, 1), (233, 1), (234, 1), (274, 1), (291, 1), (470, 2)], [], [(1, 1), (6, 2), (8, 2), (9, 2), (10, 2), (15, 2), (16, 1), (115, 1), (121, 2), (127, 1), (131, 2), (233, 2), (234, 1)], [], [(1, 1), (6, 2), (8, 1), (10, 2), (114, 1), (121, 2), (233, 2), (234, 1)], [(3, 1), (11, 2), (117, 1), (120, 2), (291, 2), (293, 1)], [(6, 2), (7, 1), (8, 1), (10, 2), (172, 1), (173, 2), (233, 2), (234, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb2 : List (List (Nat × Nat)) := [[(3, 2), (9, 1), (13, 2), (18, 1), (19, 1), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(3, 2), (9, 1), (13, 1), (18, 2), (58, 2), (64, 2), (233, 2), (234, 1), (291, 1)], [], [(3, 2), (9, 1), (13, 2), (18, 1), (58, 1), (64, 2), (173, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (2, 1), (3, 1), (9, 2), (13, 2), (18, 1), (58, 2), (64, 1), (233, 2), (234, 2), (291, 1)], [], [], [(0, 1), (2, 2), (3, 2), (6, 1), (9, 1), (13, 1), (18, 1), (58, 1), (64, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [(0, 1), (2, 2), (3, 2), (9, 1), (13, 2), (18, 1), (57, 2), (58, 1), (64, 2), (75, 1), (233, 2), (234, 1), (291, 2)], [], [], [(0, 1), (2, 2), (3, 2), (9, 1), (13, 1), (18, 2), (58, 1), (64, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [(0, 1), (2, 2), (3, 2), (9, 1), (13, 2), (18, 1), (58, 1), (64, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (18, 1), (71, 2), (74, 1), (291, 2)], [], [], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (18, 2), (19, 2), (71, 2), (74, 1), (291, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 2), (6, 1), (7, 2), (15, 1), (16, 2), (18, 2), (19, 2), (71, 2), (74, 1), (291, 2)], [(1, 2), (3, 1), (4, 1), (6, 1), (7, 1), (9, 1), (13, 1), (18, 1), (71, 2), (74, 1), (291, 2)], [], [], [], [(0, 1), (1, 1), (2, 2), (4, 2), (6, 1), (7, 2), (9, 1), (18, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [], [(0, 2), (1, 1), (2, 2), (4, 2), (6, 1), (7, 2), (9, 1), (13, 2), (19, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (9, 1), (13, 2), (19, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 1), (7, 2), (9, 1), (18, 2), (60, 1), (64, 2), (71, 1), (74, 2), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 1), (2, 2), (4, 2), (6, 1), (7, 2), (9, 1), (18, 2), (58, 1), (64, 2), (71, 1), (74, 2), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (18, 2), (71, 1), (74, 2), (233, 2), (234, 1), (291, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 1), (7, 2), (9, 1), (13, 2), (58, 1), (64, 2), (71, 1), (74, 2), (173, 2), (174, 1), (233, 2), (234, 1), (291, 1)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (13, 2), (71, 1), (74, 2), (233, 2), (236, 1), (291, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 1), (7, 2), (9, 1), (13, 2), (58, 1), (64, 2), (71, 1), (74, 2), (173, 2), (181, 1), (233, 2), (234, 1), (291, 1)], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (13, 2), (18, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 2), (2, 2), (4, 2), (6, 2), (7, 1), (9, 1), (13, 2), (18, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (5, 1), (6, 2), (7, 1), (9, 1), (13, 2), (18, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [], [], [(0, 1), (1, 2), (2, 2), (4, 1), (6, 2), (7, 1), (9, 1), (13, 2), (16, 1), (18, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (13, 2), (17, 1), (18, 2), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (13, 1), (19, 2), (22, 1), (58, 1), (64, 2), (71, 2), (74, 1), (233, 2), (234, 1), (291, 1)], [], [], [], [(0, 1), (1, 2), (2, 2), (4, 1), (6, 2), (7, 1), (9, 2), (13, 2), (18, 2), (58, 1), (64, 1), (71, 2), (73, 1), (74, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (13, 2), (18, 2), (64, 2), (71, 2), (74, 2), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (13, 2), (18, 2), (64, 2), (71, 1), (74, 2), (80, 1), (233, 2), (234, 1), (291, 1)], [], [], [], [], [(1, 1), (2, 1), (4, 2), (6, 1), (7, 2), (9, 1), (13, 1), (17, 2), (18, 1), (57, 2), (58, 2), (64, 2), (71, 1), (74, 2), (233, 2), (234, 1), (291, 2), (314, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (9, 2), (13, 1), (18, 1), (19, 2), (44, 1), (58, 2), (64, 1), (71, 2), (74, 1), (233, 1), (234, 2)], [(1, 1), (4, 2), (6, 2), (7, 2), (9, 1), (13, 1), (58, 1), (64, 1), (71, 1), (74, 2), (99, 1), (233, 1), (234, 2)], [], [(1, 2), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (19, 1), (58, 1), (64, 2), (71, 1), (74, 2), (233, 2), (234, 1), (291, 2), (392, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 2), (7, 1), (9, 2), (13, 1), (19, 1), (58, 2), (64, 1), (71, 1), (74, 2), (173, 2), (216, 1), (233, 1), (234, 2)], [(1, 1), (4, 2), (6, 2), (7, 1), (9, 1), (13, 1), (19, 1), (58, 1), (64, 2), (71, 1), (74, 2), (233, 1), (234, 1), (274, 1)], [(1, 2), (2, 1), (6, 2), (7, 1), (17, 2), (18, 1), (57, 1), (71, 2), (74, 1), (75, 2), (291, 2), (470, 1)], [(0, 2), (2, 1), (3, 2), (9, 1), (18, 1), (19, 2), (58, 1), (64, 2), (71, 1), (74, 2), (233, 2), (234, 1)], [(0, 2), (2, 1), (3, 2), (9, 1), (57, 1), (64, 2), (233, 2), (234, 1)], [], [(2, 1), (5, 2), (291, 2), (293, 1)], [(0, 2), (2, 1), (3, 2), (9, 1), (58, 1), (64, 2), (172, 1), (173, 2), (233, 2), (234, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb3 : List (List (Nat × Nat)) := [[(0, 2), (2, 1), (7, 1), (10, 2), (12, 1), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (117, 2), (233, 2), (234, 1), (291, 1)], [(0, 1), (2, 2), (6, 1), (7, 1), (8, 2), (10, 2), (58, 2), (64, 2), (115, 1), (117, 2), (233, 2), (234, 1), (291, 1)], [(0, 2), (2, 1), (3, 1), (7, 1), (9, 2), (10, 2), (58, 1), (64, 2), (115, 2), (117, 2), (233, 2), (234, 1), (291, 1)], [], [(0, 1), (2, 1), (5, 1), (7, 2), (10, 1), (58, 2), (64, 1), (115, 1), (117, 1), (120, 1), (233, 2), (234, 2), (291, 2), (293, 2)], [], [], [], [], [(0, 2), (2, 2), (5, 2), (7, 1), (8, 2), (10, 2), (18, 1), (58, 1), (64, 2), (115, 2), (117, 2), (120, 2), (233, 2), (234, 1), (291, 1), (293, 1)], [], [], [], [], [], [], [(0, 2), (2, 2), (5, 2), (6, 1), (7, 1), (8, 2), (10, 2), (58, 1), (64, 2), (115, 2), (117, 2), (120, 2), (233, 2), (234, 1), (291, 1), (293, 1)], [], [(2, 1), (3, 1), (5, 2), (7, 1), (9, 2), (10, 2), (58, 1), (64, 2), (115, 2), (117, 2), (120, 2), (233, 2), (234, 1), (291, 1), (293, 1)], [(0, 2), (2, 2), (5, 2), (7, 1), (10, 2), (58, 1), (64, 2), (115, 2), (117, 2), (120, 2), (233, 2), (234, 1), (291, 1), (293, 1)], [], [(0, 2), (2, 1), (4, 1), (7, 1), (9, 2), (10, 2), (58, 1), (64, 2), (115, 2), (117, 1), (233, 2), (234, 1), (291, 2)], [], [], [], [], [(3, 1), (5, 2), (6, 1), (7, 2), (9, 2), (12, 1), (18, 2), (19, 1), (58, 1), (64, 2), (66, 1), (72, 2), (115, 2), (117, 2), (120, 2), (291, 1), (293, 1)], [], [], [], [(2, 2), (3, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 2), (12, 2), (18, 1), (19, 2), (58, 2), (64, 1), (66, 2), (72, 1), (115, 2), (117, 2), (120, 2), (291, 1), (293, 1)], [], [(3, 1), (5, 2), (6, 2), (7, 1), (9, 2), (12, 1), (18, 1), (19, 2), (58, 1), (64, 2), (66, 1), (72, 2), (115, 2), (117, 2), (120, 2), (291, 1), (293, 1)], [], [], [], [(2, 2), (3, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 2), (12, 2), (18, 1), (19, 2), (58, 1), (64, 2), (66, 1), (72, 2), (115, 2), (117, 2), (120, 2), (291, 1), (293, 1)], [], [(2, 2), (3, 1), (6, 1), (7, 2), (8, 1), (9, 1), (12, 1), (18, 1), (19, 1), (21, 1), (58, 1), (64, 2), (66, 1), (72, 2), (115, 2), (117, 1), (291, 2)], [(0, 2), (3, 2), (5, 2), (6, 1), (8, 1), (9, 1), (10, 2), (12, 1), (18, 1), (19, 2), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (5, 2), (6, 2), (7, 2), (9, 2), (10, 2), (12, 1), (18, 1), (19, 2), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [], [(0, 2), (2, 1), (3, 2), (5, 1), (6, 2), (7, 2), (9, 2), (10, 2), (12, 1), (18, 1), (19, 2), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [(2, 2), (3, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 1), (10, 2), (12, 2), (18, 1), (19, 2), (58, 2), (60, 1), (66, 2), (72, 1), (115, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [], [(3, 2), (5, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 2), (12, 2), (18, 1), (19, 2), (58, 2), (64, 1), (66, 2), (72, 1), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [(0, 2), (3, 1), (5, 2), (6, 2), (7, 2), (9, 2), (10, 2), (12, 2), (18, 1), (19, 2), (66, 2), (72, 1), (117, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [], [(0, 2), (2, 1), (3, 1), (5, 1), (6, 2), (7, 2), (9, 2), (10, 2), (12, 2), (18, 1), (19, 2), (66, 2), (72, 1), (117, 1), (120, 2), (233, 2), (234, 1), (291, 2), (293, 2)], [], [(2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (12, 2), (18, 1), (19, 2), (58, 2), (64, 1), (66, 2), (72, 1), (115, 1), (117, 1), (120, 1), (233, 2), (236, 1), (291, 2), (293, 2)], [], [(0, 2), (2, 1), (3, 1), (5, 2), (6, 1), (9, 2), (10, 2), (12, 1), (18, 2), (19, 1), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [(0, 2), (2, 1), (3, 2), (5, 2), (6, 1), (9, 1), (10, 2), (12, 1), (18, 2), (19, 1), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [], [(0, 2), (2, 1), (3, 2), (4, 2), (5, 2), (6, 1), (9, 2), (10, 2), (12, 1), (18, 2), (19, 1), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [], [(0, 2), (2, 2), (3, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (12, 1), (18, 2), (19, 1), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [], [(0, 2), (2, 2), (3, 2), (4, 2), (5, 1), (6, 2), (8, 2), (9, 2), (10, 2), (17, 1), (18, 2), (19, 1), (58, 2), (64, 1), (66, 1), (72, 2), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [], [(0, 2), (2, 1), (3, 1), (5, 2), (6, 1), (9, 2), (10, 2), (12, 1), (18, 2), (19, 1), (58, 2), (66, 2), (72, 2), (115, 1), (120, 2), (233, 2), (234, 1), (293, 1)], [], [(0, 2), (2, 2), (3, 1), (5, 1), (6, 1), (9, 2), (10, 2), (12, 1), (18, 2), (19, 1), (58, 2), (60, 2), (64, 1), (66, 1), (67, 1), (72, 2), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [], [(2, 1), (3, 1), (5, 1), (6, 1), (7, 2), (9, 2), (10, 2), (12, 2), (18, 2), (19, 1), (58, 2), (66, 2), (71, 1), (72, 1), (115, 1), (117, 1), (120, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [], [], [(1, 2), (2, 1), (3, 1), (5, 1), (6, 1), (9, 2), (10, 2), (12, 2), (18, 2), (19, 1), (66, 2), (72, 1), (117, 1), (120, 1), (127, 1), (233, 2), (234, 1), (291, 2), (293, 2)], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (10, 2), (17, 2), (18, 1), (19, 2), (57, 2), (58, 1), (66, 2), (72, 1), (115, 2), (120, 1), (233, 2), (234, 1), (293, 2), (314, 1)], [(0, 1), (2, 2), (3, 2), (5, 1), (6, 1), (7, 1), (9, 1), (10, 1), (12, 1), (18, 2), (19, 1), (44, 1), (66, 1), (72, 2), (117, 2), (120, 1), (233, 1), (234, 2), (291, 1), (293, 2)], [(0, 2), (2, 2), (3, 2), (5, 1), (6, 1), (7, 1), (9, 1), (10, 1), (12, 1), (18, 2), (19, 1), (64, 2), (66, 2), (72, 1), (99, 1), (117, 2), (120, 1), (233, 1), (234, 2), (291, 1), (293, 2)], [(0, 1), (2, 2), (3, 1), (5, 1), (6, 1), (7, 1), (9, 2), (10, 1), (12, 2), (18, 2), (19, 1), (58, 1), (64, 2), (66, 2), (72, 1), (115, 2), (117, 2), (120, 1), (157, 1), (233, 1), (234, 2), (291, 1), (293, 2)], [(0, 2), (2, 2), (3, 2), (5, 1), (6, 1), (8, 2), (9, 1), (10, 2), (12, 2), (18, 2), (19, 1), (66, 2), (72, 1), (233, 2), (234, 1), (293, 2), (392, 1)], [], [(0, 2), (3, 2), (6, 2), (8, 2), (9, 1), (10, 2), (12, 1), (18, 2), (19, 1), (66, 2), (72, 1), (233, 1), (234, 1), (274, 1)], [(2, 1), (5, 1), (7, 2), (8, 1), (12, 2), (17, 2), (18, 2), (19, 1), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (115, 2), (120, 1), (293, 2), (470, 1)], [(0, 2), (5, 1), (7, 1), (8, 1), (10, 2), (12, 2), (66, 2), (72, 1), (117, 2), (120, 1), (233, 2), (234, 1), (291, 1), (293, 2)], [(0, 2), (3, 2), (5, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 2), (57, 1), (64, 2), (117, 2), (120, 1), (233, 2), (234, 1), (291, 1), (293, 2)], [(0, 2), (3, 2), (5, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 2), (58, 1), (64, 2), (114, 1), (115, 2), (117, 2), (120, 1), (233, 2), (234, 1), (291, 1), (293, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb4 : List (List (Nat × Nat)) := [[(3, 2), (6, 2), (8, 1), (9, 2), (57, 2), (58, 2), (63, 1), (64, 1), (117, 2), (120, 1), (291, 1)], [(3, 2), (6, 1), (8, 2), (9, 1), (58, 2), (64, 2), (117, 2), (120, 1), (291, 1)], [(0, 2), (2, 1), (3, 1), (6, 2), (8, 1), (9, 2), (58, 2), (64, 1), (117, 2), (120, 2), (291, 1)], [(0, 2), (3, 1), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (58, 2), (64, 1), (117, 1), (120, 2), (172, 1), (291, 2), (293, 2)], [], [], [], [], [], [], [(0, 1), (3, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (24, 1), (58, 1), (64, 2), (117, 2), (120, 1), (291, 1), (293, 1)], [], [], [(0, 1), (3, 2), (5, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (57, 2), (58, 1), (63, 1), (64, 2), (117, 2), (120, 1), (291, 1), (293, 1)], [], [], [], [(0, 1), (3, 2), (5, 2), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (58, 1), (64, 2), (117, 2), (120, 1), (291, 1), (293, 1)], [], [], [(0, 1), (3, 2), (5, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (58, 1), (64, 2), (117, 2), (120, 1), (291, 1), (293, 1)], [(0, 2), (3, 1), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (58, 2), (64, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2)], [], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (5, 1), (6, 2), (8, 2), (9, 1), (24, 2), (25, 1), (57, 2), (58, 2), (63, 1), (64, 1), (117, 2), (120, 1), (172, 1), (173, 2), (291, 1), (293, 1)], [], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (24, 1), (25, 2), (57, 2), (58, 2), (63, 1), (64, 1), (117, 2), (120, 1), (172, 1), (173, 2), (291, 1), (293, 1)], [], [(0, 1), (1, 1), (2, 2), (4, 2), (8, 2), (9, 1), (24, 1), (25, 2), (57, 2), (58, 2), (63, 1), (64, 1), (117, 2), (120, 1), (172, 1), (173, 2), (291, 1), (293, 1)], [], [(0, 2), (1, 1), (2, 1), (4, 2), (8, 2), (14, 1), (24, 1), (25, 2), (57, 2), (58, 2), (63, 1), (64, 1), (117, 2), (120, 1), (172, 1), (173, 2), (291, 1), (293, 1)], [(1, 1), (2, 1), (4, 1), (5, 2), (6, 2), (7, 2), (9, 1), (10, 1), (21, 1), (24, 1), (25, 2), (57, 2), (63, 1), (117, 1), (120, 2), (172, 2), (173, 1), (291, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 1), (9, 2), (24, 1), (25, 2), (57, 2), (58, 1), (63, 1), (64, 2), (172, 2), (173, 1), (293, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (7, 1), (8, 2), (9, 2), (10, 2), (24, 1), (25, 2), (57, 2), (58, 1), (63, 1), (64, 2), (172, 2), (173, 1), (293, 1)], [(1, 1), (2, 2), (3, 2), (4, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (24, 1), (25, 2), (57, 2), (63, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (10, 2), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (63, 2), (64, 1), (172, 2), (173, 1), (293, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (7, 2), (9, 2), (10, 1), (24, 1), (25, 2), (57, 1), (58, 1), (63, 2), (64, 2), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (8, 1), (9, 2), (24, 1), (25, 2), (57, 1), (58, 1), (63, 2), (64, 2), (117, 1), (120, 2), (172, 2), (173, 1), (293, 1)], [(1, 1), (2, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (24, 1), (25, 2), (57, 1), (63, 2), (115, 1), (117, 1), (120, 1), (172, 1), (173, 2), (291, 2), (293, 2)], [], [(0, 2), (1, 1), (2, 1), (4, 1), (6, 1), (8, 1), (9, 2), (24, 1), (25, 2), (57, 1), (58, 1), (63, 2), (64, 2), (117, 1), (120, 2), (172, 1), (173, 1), (174, 1), (291, 2), (293, 2)], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (7, 1), (8, 1), (10, 2), (24, 2), (25, 1), (57, 2), (58, 1), (63, 1), (64, 2), (172, 2), (173, 1), (293, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (7, 1), (8, 1), (10, 2), (24, 2), (25, 1), (57, 2), (58, 1), (63, 1), (64, 2), (172, 2), (173, 1), (293, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 1), (7, 2), (9, 2), (10, 1), (24, 2), (25, 1), (57, 2), (63, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [(0, 2), (1, 2), (2, 1), (4, 1), (8, 1), (9, 2), (24, 2), (25, 1), (57, 2), (63, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (5, 2), (6, 1), (7, 2), (9, 2), (10, 1), (15, 1), (24, 2), (25, 1), (57, 2), (63, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (7, 1), (8, 1), (10, 2), (24, 2), (25, 1), (57, 1), (58, 1), (63, 2), (64, 1), (66, 1), (172, 2), (173, 1), (293, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 1), (7, 2), (9, 2), (10, 1), (24, 2), (25, 1), (57, 2), (60, 2), (63, 1), (65, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [(0, 2), (1, 2), (2, 2), (4, 1), (5, 2), (6, 1), (7, 2), (10, 1), (14, 2), (24, 2), (25, 1), (57, 1), (63, 2), (64, 2), (73, 1), (117, 1), (120, 2), (172, 1), (173, 2), (291, 2), (293, 2)], [], [], [(1, 2), (2, 1), (3, 1), (4, 1), (5, 2), (7, 2), (8, 1), (9, 2), (10, 1), (14, 2), (24, 2), (25, 1), (57, 1), (63, 2), (117, 1), (120, 1), (130, 1), (172, 1), (173, 2), (291, 2), (293, 2)], [], [], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 2), (8, 2), (10, 1), (24, 1), (25, 2), (63, 2), (64, 1), (172, 2), (173, 1), (293, 2), (314, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (6, 1), (9, 1), (14, 2), (24, 2), (25, 1), (44, 1), (57, 2), (58, 2), (63, 1), (64, 1), (117, 2), (120, 1), (172, 2), (173, 1), (291, 1), (293, 2)], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (8, 2), (9, 1), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (99, 1), (117, 2), (120, 1), (172, 2), (173, 1), (291, 1), (293, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (9, 1), (14, 2), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (64, 1), (117, 2), (157, 1), (172, 2), (173, 1), (291, 1), (293, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (9, 1), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (64, 1), (172, 2), (173, 1), (293, 2), (392, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (7, 2), (8, 2), (9, 1), (10, 1), (14, 2), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (64, 1), (172, 1), (173, 1), (216, 1)], [], [(0, 2), (1, 2), (3, 2), (5, 1), (6, 1), (7, 1), (10, 2), (14, 1), (24, 2), (25, 1), (58, 1), (64, 2), (120, 1), (130, 2), (293, 2), (470, 1)], [(0, 2), (3, 2), (5, 1), (7, 1), (8, 1), (10, 2), (57, 1), (63, 2), (117, 2), (120, 1), (291, 1), (293, 2)], [(0, 2), (3, 2), (5, 1), (7, 1), (9, 1), (10, 2), (57, 1), (64, 2), (117, 2), (120, 1), (291, 1), (293, 2)], [(2, 2), (5, 1), (6, 2), (7, 1), (8, 1), (10, 2), (114, 1), (117, 2), (291, 1), (293, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb5 : List (List (Nat × Nat)) := [[(0, 1), (6, 2), (12, 2), (24, 2), (25, 1), (34, 2), (63, 1), (66, 2), (67, 1), (72, 1), (121, 2)], [], [], [], [], [], [(0, 2), (6, 1), (12, 1), (15, 1), (24, 2), (25, 1), (34, 1), (63, 2), (66, 2), (67, 1), (72, 1), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (6, 1), (7, 1), (12, 1), (15, 1), (24, 2), (25, 1), (34, 1), (63, 2), (66, 2), (67, 1), (71, 2), (72, 1), (74, 1), (121, 2)], [(0, 2), (6, 1), (12, 1), (15, 1), (24, 2), (25, 1), (34, 1), (63, 2), (65, 2), (66, 1), (67, 2), (68, 1), (72, 2), (121, 1)], [(0, 1), (1, 1), (6, 1), (7, 2), (12, 2), (19, 1), (24, 2), (25, 1), (34, 1), (63, 2), (66, 2), (67, 2), (72, 1), (121, 1)], [(0, 2), (6, 1), (12, 1), (24, 2), (25, 2), (34, 1), (63, 2), (66, 1), (67, 2), (72, 2), (121, 1)], [(0, 1), (6, 2), (12, 2), (18, 2), (24, 2), (25, 1), (34, 2), (63, 1), (66, 2), (67, 1), (72, 1), (75, 1), (121, 2)], [(0, 2), (1, 2), (6, 1), (7, 1), (12, 1), (15, 1), (19, 2), (24, 2), (25, 1), (34, 2), (63, 2), (64, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (77, 1), (121, 2)], [(0, 1), (6, 1), (12, 2), (24, 2), (25, 1), (34, 2), (63, 2), (66, 2), (67, 1), (72, 1), (121, 2)], [], [], [], [], [], [], [], [], [(0, 1), (1, 2), (6, 2), (7, 1), (12, 2), (15, 2), (34, 2), (63, 1), (64, 1), (65, 2), (66, 1), (68, 1), (71, 2), (72, 2), (74, 1), (127, 2), (131, 1)], [], [], [], [], [], [], [], [], [(0, 2), (6, 2), (7, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1), (63, 1), (65, 1), (67, 2), (68, 2), (71, 2), (74, 1), (121, 1), (127, 2), (131, 1)], [(1, 1), (6, 2), (7, 2), (24, 2), (25, 1), (34, 1), (63, 1), (65, 1), (67, 1), (68, 2), (71, 1), (74, 2), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 1), (3, 1), (6, 2), (7, 2), (9, 2), (12, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 1), (66, 1), (67, 1), (68, 2), (71, 1), (72, 2), (74, 2), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (6, 2), (7, 1), (12, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (72, 2), (74, 1), (121, 2), (127, 1), (131, 2)], [(0, 2), (1, 2), (6, 2), (7, 1), (12, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 1), (66, 1), (67, 1), (68, 2), (71, 2), (72, 2), (74, 1), (121, 2), (127, 1), (131, 2)], [(0, 2), (1, 1), (6, 2), (7, 2), (12, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 2), (66, 1), (68, 1), (71, 1), (72, 2), (74, 2), (127, 1), (131, 2)], [(0, 2), (1, 1), (6, 2), (7, 2), (9, 2), (12, 1), (14, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 2), (66, 2), (68, 1), (71, 1), (72, 1), (74, 2), (127, 1), (131, 2)], [(6, 2), (9, 2), (15, 1), (19, 2), (21, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (127, 1), (131, 2)], [(0, 1), (1, 1), (6, 1), (7, 2), (12, 2), (34, 2), (63, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 2), (72, 1), (74, 1), (121, 1), (127, 1), (131, 2)], [(0, 1), (1, 1), (6, 1), (7, 2), (12, 2), (34, 2), (63, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 1), (72, 1), (74, 2), (121, 1), (127, 2), (131, 1)], [(0, 1), (1, 2), (6, 1), (7, 1), (15, 2), (34, 2), (63, 2), (65, 2), (66, 2), (68, 1), (71, 2), (72, 1), (74, 1), (127, 2), (131, 1)], [(0, 1), (1, 2), (6, 1), (7, 1), (9, 1), (12, 2), (15, 2), (34, 2), (63, 2), (65, 2), (66, 1), (68, 1), (71, 2), (72, 2), (74, 1), (127, 2), (131, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [(0, 2), (1, 2), (7, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (74, 1), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (7, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1), (65, 2), (67, 1), (68, 2), (71, 2), (74, 1), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (7, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1), (65, 1), (67, 2), (68, 2), (71, 2), (74, 1), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (7, 1), (9, 1), (12, 1), (14, 2), (15, 2), (24, 2), (25, 1), (34, 1), (65, 2), (67, 1), (68, 1), (71, 2), (73, 1), (74, 1), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (7, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (72, 2), (74, 2), (121, 2), (127, 2), (131, 1)], [(1, 1), (7, 2), (19, 2), (24, 2), (25, 1), (34, 1), (65, 1), (67, 1), (68, 2), (71, 1), (74, 2), (80, 1), (121, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (7, 1), (9, 1), (12, 1), (14, 2), (15, 2), (24, 2), (25, 1), (34, 1), (65, 2), (67, 1), (68, 1), (71, 2), (74, 1), (121, 2), (127, 2), (130, 1), (131, 1)], [(0, 2), (1, 2), (7, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1), (65, 2), (66, 1), (67, 1), (68, 1), (71, 2), (72, 2), (74, 1), (121, 2), (127, 2), (131, 2)], [(1, 1), (7, 2), (19, 2), (24, 2), (25, 1), (34, 1), (65, 1), (67, 1), (68, 2), (71, 2), (74, 1), (121, 2), (127, 1), (131, 2), (137, 1)], [(0, 1), (1, 1), (6, 2), (7, 2), (12, 2), (15, 1), (24, 2), (25, 1), (34, 2), (51, 1), (65, 1), (67, 2), (68, 2), (71, 1), (74, 2), (121, 1), (127, 1), (131, 2)], [], [], [(0, 1), (1, 1), (7, 2), (12, 2), (15, 1), (24, 2), (25, 1), (34, 2), (64, 2), (65, 1), (67, 2), (68, 2), (71, 1), (74, 2), (99, 1), (121, 1), (127, 2), (131, 1)], [(1, 2), (7, 1), (9, 1), (14, 2), (15, 1), (24, 2), (25, 1), (34, 2), (64, 2), (65, 1), (67, 2), (68, 2), (71, 2), (74, 1), (121, 1), (127, 1), (131, 2), (157, 1)], [(1, 1), (7, 2), (24, 1), (25, 2), (64, 2), (65, 2), (66, 1), (67, 1), (68, 1), (71, 1), (72, 2), (74, 2), (121, 2), (127, 1), (131, 2), (392, 1)], [(0, 1), (7, 2), (9, 1), (12, 2), (14, 2), (15, 2), (24, 2), (25, 1), (34, 2), (64, 2), (65, 1), (67, 1), (68, 2), (71, 1), (74, 2), (121, 2), (127, 1), (131, 2), (216, 1)], [(0, 1), (7, 2), (12, 2), (15, 2), (24, 2), (25, 1), (34, 2), (64, 2), (65, 1), (66, 1), (67, 1), (68, 2), (71, 1), (72, 2), (74, 2), (121, 2), (127, 1), (131, 2), (274, 1)], [(0, 1), (1, 2), (6, 1), (7, 1), (9, 2), (12, 2), (14, 1), (15, 2), (18, 1), (34, 2), (63, 2), (66, 1), (67, 2), (71, 2), (72, 2), (74, 1), (75, 2), (127, 2), (130, 2), (131, 1), (470, 1)], [], [], [], [], [], [], [], [(1, 1), (6, 1), (7, 2), (15, 2), (24, 2), (25, 1), (66, 2), (67, 1), (71, 1), (72, 1), (74, 2), (121, 2)], [(13, 1), (15, 2), (24, 2), (25, 1), (65, 1), (68, 2)], [(0, 1), (1, 2), (7, 1), (12, 2), (18, 1), (19, 2), (24, 2), (25, 1), (66, 2), (72, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb6 : List (List (Nat × Nat)) := [[], [(8, 1), (9, 2), (18, 1), (24, 2), (25, 1), (34, 2), (60, 2), (63, 2), (65, 1), (75, 2), (117, 1)], [], [], [], [(6, 1), (9, 2), (12, 2), (14, 1), (15, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (60, 2), (63, 2), (65, 1), (75, 1), (117, 2), (127, 2), (131, 1)], [], [(8, 1), (9, 2), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 2), (65, 2), (75, 1), (117, 2)], [(8, 1), (9, 1), (11, 1), (14, 1), (15, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (60, 2), (63, 2), (65, 1), (75, 1), (117, 1)], [(6, 1), (7, 2), (8, 1), (9, 2), (18, 1), (19, 1), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (75, 2), (117, 2)], [(8, 2), (9, 1), (18, 1), (24, 2), (25, 2), (34, 1), (60, 1), (63, 1), (65, 2), (75, 2), (117, 2)], [], [], [], [(8, 1), (9, 2), (18, 2), (24, 2), (25, 1), (34, 2), (60, 2), (63, 2), (65, 1), (75, 1), (117, 1)], [(8, 1), (9, 1), (11, 1), (14, 1), (16, 2), (18, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 2), (60, 2), (63, 2), (65, 1), (75, 1), (117, 1)], [(6, 1), (8, 1), (9, 2), (18, 1), (24, 2), (25, 1), (34, 2), (60, 2), (63, 1), (65, 1), (75, 2), (117, 1)], [(8, 2), (9, 2), (18, 1), (24, 2), (25, 1), (34, 2), (60, 2), (63, 1), (65, 1), (75, 2), (117, 1)], [], [], [], [], [], [(6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (18, 1), (34, 2), (60, 2), (65, 1), (71, 1), (75, 2), (117, 1), (127, 2), (131, 1)], [], [], [], [], [], [(7, 1), (9, 1), (11, 1), (12, 2), (14, 2), (15, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (71, 2), (75, 1), (127, 2), (131, 1)], [(6, 2), (7, 1), (8, 1), (11, 2), (14, 2), (15, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (58, 1), (71, 2), (72, 2), (75, 1), (117, 2), (127, 2), (131, 1)], [], [], [], [(6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (12, 1), (18, 2), (24, 2), (25, 1), (34, 1), (71, 2), (75, 1), (127, 1), (131, 2)], [(6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (71, 2), (75, 1), (117, 2), (127, 1), (131, 2)], [(7, 1), (9, 1), (11, 1), (12, 2), (14, 2), (15, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (71, 2), (75, 1), (127, 1), (131, 2)], [(6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (12, 1), (15, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (71, 2), (75, 1), (127, 1), (131, 2)], [(7, 2), (8, 2), (11, 2), (12, 1), (19, 2), (21, 1), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 2), (117, 2), (127, 1), (131, 2)], [(7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (18, 1), (34, 2), (60, 2), (63, 2), (65, 1), (71, 2), (75, 2), (117, 1), (127, 1), (131, 2)], [], [], [], [(6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (18, 1), (34, 2), (63, 2), (65, 1), (71, 1), (75, 2), (127, 2), (131, 1)], [(7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (18, 1), (34, 2), (60, 2), (63, 2), (65, 1), (71, 1), (72, 1), (75, 2), (117, 1), (127, 2), (131, 1)], [(6, 2), (7, 2), (8, 2), (9, 1), (11, 1), (12, 2), (18, 1), (34, 2), (60, 2), (63, 2), (64, 1), (65, 1), (71, 1), (75, 2), (117, 1), (127, 2), (131, 1)], [], [], [], [], [], [], [], [], [], [], [(6, 2), (7, 2), (11, 2), (12, 2), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 1), (75, 1), (117, 2), (127, 2), (131, 1)], [(7, 1), (8, 2), (10, 1), (11, 2), (12, 2), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 1), (75, 1), (117, 2), (127, 2), (131, 1)], [(6, 2), (7, 2), (9, 1), (11, 1), (12, 2), (14, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 1), (75, 1), (117, 2), (127, 2), (131, 1)], [(7, 2), (8, 2), (9, 1), (11, 1), (12, 1), (17, 1), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 1), (75, 1), (117, 2), (127, 2), (131, 1)], [(6, 2), (7, 2), (8, 2), (11, 2), (12, 2), (19, 2), (22, 1), (24, 2), (25, 1), (34, 1), (60, 1), (63, 2), (65, 2), (71, 1), (117, 2), (127, 2), (131, 1)], [], [], [], [], [], [], [(6, 2), (7, 2), (9, 1), (11, 1), (12, 2), (14, 2), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 1), (75, 1), (117, 2), (127, 2), (130, 1), (131, 1)], [(7, 2), (8, 2), (9, 1), (11, 1), (12, 1), (18, 2), (24, 2), (25, 1), (34, 1), (60, 1), (63, 1), (65, 2), (71, 1), (75, 1), (117, 2), (127, 2), (131, 2)], [(8, 1), (9, 1), (11, 1), (14, 1), (15, 1), (16, 2), (19, 2), (24, 2), (25, 1), (34, 1), (58, 2), (60, 2), (63, 2), (65, 1), (71, 1), (72, 1), (117, 2), (127, 1), (131, 2), (137, 1)], [(7, 1), (11, 2), (12, 2), (17, 2), (18, 1), (24, 2), (25, 1), (34, 2), (51, 1), (60, 2), (63, 2), (65, 1), (71, 2), (75, 2), (117, 1), (127, 1), (131, 2)], [], [(6, 2), (7, 2), (11, 2), (12, 2), (15, 1), (16, 2), (18, 1), (24, 2), (25, 1), (34, 2), (44, 1), (71, 1), (75, 2), (127, 2), (131, 1)], [], [(7, 2), (8, 2), (11, 2), (12, 1), (14, 1), (15, 2), (16, 1), (18, 1), (24, 2), (25, 1), (34, 2), (57, 2), (60, 1), (63, 1), (65, 2), (71, 1), (75, 2), (127, 1), (131, 2), (157, 1)], [(7, 1), (8, 1), (11, 1), (12, 2), (14, 2), (15, 2), (16, 1), (24, 1), (25, 2), (60, 2), (63, 2), (65, 1), (71, 2), (72, 2), (117, 1), (127, 1), (131, 2), (392, 1)], [(7, 2), (8, 2), (11, 2), (12, 1), (14, 1), (15, 2), (16, 1), (18, 1), (24, 2), (25, 1), (34, 2), (57, 2), (60, 1), (63, 1), (65, 2), (71, 1), (75, 2), (127, 1), (131, 2), (216, 1)], [(6, 1), (7, 2), (8, 1), (11, 2), (14, 2), (15, 2), (16, 1), (18, 1), (24, 2), (25, 1), (34, 2), (57, 2), (60, 1), (63, 1), (65, 2), (71, 1), (75, 2), (127, 1), (131, 2), (274, 1)], [(6, 1), (7, 2), (16, 1), (17, 2), (19, 1), (20, 2), (34, 2), (60, 2), (63, 2), (65, 1), (71, 1), (117, 1), (127, 2), (130, 2), (131, 1), (470, 1)], [], [], [], [], [], [], [(6, 2), (8, 2), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (24, 2), (25, 1), (57, 1), (60, 2), (63, 2), (65, 1), (127, 1), (131, 2)], [(8, 1), (9, 2), (24, 2), (25, 1)], [(11, 2), (13, 1), (14, 2), (15, 2), (16, 1), (24, 2), (25, 1), (60, 2), (65, 1), (117, 1)], [(6, 2), (7, 1), (8, 1), (9, 2), (18, 1), (19, 2), (24, 2), (25, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb7 : List (List (Nat × Nat)) := [[], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (14, 2), (16, 1), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2), (57, 2), (114, 1)], [], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (12, 2), (14, 2), (15, 1), (16, 1), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (60, 1), (71, 2), (74, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (14, 2), (15, 1), (16, 1), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (14, 2), (16, 1), (19, 2), (20, 2), (24, 2), (25, 1), (34, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (14, 2), (16, 1), (19, 1), (20, 2), (24, 2), (25, 2), (34, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (14, 1), (16, 2), (18, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 2), (75, 1)], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 2)], [], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (14, 2), (16, 1), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2)], [], [], [], [], [], [(1, 2), (2, 1), (3, 2), (4, 1), (12, 2), (14, 2), (16, 1), (19, 1), (20, 2), (34, 2), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [], [], [], [(0, 1), (2, 2), (5, 2), (12, 2), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 2), (74, 1), (114, 1), (121, 1), (127, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (15, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 2), (74, 1), (114, 1), (127, 2)], [(1, 1), (5, 2), (12, 2), (15, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (58, 1), (60, 2), (71, 2), (74, 1), (114, 1), (127, 2)], [], [(0, 1), (5, 2), (12, 1), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [(0, 1), (2, 2), (3, 1), (5, 2), (12, 1), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (15, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 1), (14, 1), (15, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (12, 1), (19, 2), (21, 1), (24, 2), (25, 1), (34, 1), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (12, 1), (14, 2), (16, 1), (19, 1), (20, 2), (34, 2), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [], [], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (12, 2), (14, 2), (16, 1), (19, 1), (20, 2), (34, 2), (57, 2), (60, 2), (71, 2), (74, 1), (114, 1), (117, 1), (127, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (12, 2), (14, 2), (16, 1), (19, 1), (20, 2), (34, 2), (57, 2), (58, 2), (71, 2), (74, 1), (114, 1), (115, 1), (127, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (12, 2), (14, 2), (16, 1), (19, 1), (20, 2), (34, 2), (57, 2), (71, 2), (74, 1), (114, 1), (120, 1), (127, 1)], [], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [(0, 1), (1, 1), (2, 2), (5, 2), (12, 2), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (12, 2), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 1), (14, 1), (16, 2), (17, 1), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (19, 2), (22, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (73, 1), (74, 1), (114, 2), (127, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 1), (14, 1), (16, 2), (19, 2), (20, 1), (24, 2), (25, 1), (34, 1), (57, 1), (71, 2), (74, 2), (114, 2), (127, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (12, 1), (14, 1), (15, 1), (16, 2), (19, 2), (24, 2), (25, 1), (34, 1), (57, 1), (58, 2), (60, 1), (71, 1), (74, 2), (80, 1), (114, 2), (127, 1)], [], [], [], [(0, 2), (1, 2), (5, 2), (12, 2), (14, 2), (16, 1), (17, 2), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2), (51, 1), (57, 2), (71, 1), (74, 2), (114, 1), (127, 2)], [], [(0, 1), (5, 2), (12, 2), (14, 2), (15, 1), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2), (44, 1), (57, 1), (71, 2), (74, 1), (114, 2), (127, 1)], [(0, 2), (1, 2), (5, 2), (14, 1), (15, 2), (16, 2), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2), (60, 1), (71, 1), (74, 2), (99, 1), (114, 2), (127, 1)], [], [(2, 2), (3, 1), (5, 1), (12, 1), (14, 2), (15, 2), (16, 1), (24, 1), (25, 2), (57, 1), (71, 1), (74, 2), (114, 2), (120, 2), (127, 2), (392, 1)], [(0, 2), (1, 2), (5, 2), (12, 1), (15, 2), (16, 2), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2), (60, 1), (71, 1), (74, 2), (114, 2), (127, 1), (216, 1)], [(0, 2), (1, 2), (5, 2), (14, 1), (15, 2), (16, 2), (19, 1), (20, 2), (24, 2), (25, 1), (34, 2), (60, 1), (71, 1), (74, 2), (114, 2), (127, 1), (274, 1)], [(1, 2), (2, 1), (17, 2), (18, 1), (34, 2), (57, 1), (71, 2), (74, 1), (75, 2), (114, 2), (127, 1), (470, 1)], [], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (12, 1), (14, 2), (15, 2), (16, 1), (24, 2), (25, 1), (57, 1), (60, 2), (71, 1), (74, 2)], [], [(2, 1), (5, 2), (13, 1), (14, 2), (15, 2), (16, 1), (24, 2), (25, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (18, 1), (19, 2), (24, 2), (25, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb8 : List (List (Nat × Nat)) := [[], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (9, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (24, 2), (25, 1), (34, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (8, 1), (9, 2), (24, 2), (25, 1), (34, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 2), (9, 2), (19, 1), (24, 2), (25, 1), (34, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (9, 1), (24, 2), (25, 2), (34, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (9, 1), (19, 2), (24, 2), (25, 1), (34, 2), (65, 2), (68, 1), (77, 1)], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (19, 2), (20, 1), (24, 2), (25, 1), (34, 2)], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 2), (9, 2), (24, 2), (25, 1), (34, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (7, 1), (8, 1), (9, 2), (24, 2), (25, 1), (34, 2)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (5, 1), (7, 1), (9, 1), (11, 1), (34, 2), (60, 1), (65, 2), (68, 1), (293, 2)], [], [], [(2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 1), (11, 1), (24, 2), (25, 1), (34, 1), (60, 2), (65, 2), (67, 2), (68, 1), (121, 1), (293, 1)], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 2), (24, 2), (25, 1), (34, 1), (58, 1), (60, 1), (65, 2), (68, 1), (293, 1)], [(0, 1), (1, 1), (5, 1), (9, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 2), (65, 1), (68, 2), (293, 1)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (9, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 2), (65, 1), (68, 2), (293, 1)], [(0, 1), (4, 1), (5, 1), (9, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 2), (65, 1), (68, 2), (293, 1)], [], [(0, 1), (1, 1), (5, 1), (7, 2), (9, 2), (11, 2), (24, 2), (25, 1), (34, 1), (60, 2), (65, 1), (68, 2), (293, 1)], [], [], [(0, 2), (5, 1), (9, 1), (11, 2), (19, 2), (21, 1), (24, 2), (25, 1), (34, 1), (60, 2), (65, 1), (68, 2), (293, 1)], [], [], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 1), (11, 2), (34, 2), (60, 2), (65, 2), (68, 1), (293, 1)], [], [], [(0, 2), (1, 2), (5, 2), (7, 1), (9, 1), (11, 1), (34, 2), (60, 1), (65, 2), (68, 1), (117, 1), (293, 1)], [], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 1), (9, 1), (11, 1), (19, 1), (20, 2), (34, 2), (60, 1), (65, 2), (68, 1), (174, 1), (293, 1)], [(0, 2), (1, 2), (2, 1), (5, 1), (7, 1), (9, 1), (11, 1), (19, 1), (20, 2), (34, 2), (60, 1), (65, 2), (68, 1), (236, 1), (293, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (11, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 2), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 1), (11, 2), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 2), (19, 2), (22, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 2), (68, 2), (293, 2)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (7, 2), (9, 2), (11, 1), (24, 2), (25, 1), (34, 1), (60, 1), (65, 1), (67, 1), (68, 2), (293, 2)], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (11, 1), (19, 2), (24, 2), (25, 1), (34, 1), (58, 2), (60, 2), (65, 1), (68, 2), (80, 1), (293, 2)], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (11, 1), (19, 2), (24, 2), (25, 1), (34, 1), (58, 2), (60, 2), (65, 1), (68, 2), (137, 1), (293, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (24, 2), (25, 1), (34, 2), (51, 1), (60, 2), (65, 1), (68, 2), (293, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (9, 2), (11, 2), (24, 2), (25, 1), (34, 2), (44, 1), (60, 1), (65, 2), (68, 1), (293, 2)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (7, 1), (9, 1), (11, 1), (24, 2), (25, 1), (34, 2), (57, 2), (60, 2), (65, 1), (68, 2), (99, 1), (293, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 1), (9, 1), (11, 2), (24, 2), (25, 1), (34, 2), (57, 2), (60, 2), (65, 1), (68, 2), (157, 1), (293, 2)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (9, 1), (11, 2), (24, 2), (25, 1), (34, 2), (57, 2), (60, 2), (65, 1), (68, 2), (216, 1), (293, 2)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (9, 1), (11, 2), (24, 2), (25, 1), (34, 2), (57, 2), (60, 2), (65, 1), (68, 2), (274, 1), (293, 2)], [(1, 2), (3, 1), (4, 2), (5, 1), (7, 1), (19, 1), (20, 2), (34, 2), (60, 1), (67, 2), (293, 2), (470, 1)], [], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (24, 2), (25, 1), (57, 1), (60, 2), (65, 1), (68, 2)], [(0, 1), (5, 2), (8, 1), (9, 2), (24, 2), (25, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (7, 1), (9, 2), (18, 1), (19, 2), (24, 2), (25, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb9 : List (List (Nat × Nat)) := [[], [], [], [(0, 1), (1, 1), (5, 1), (7, 2), (9, 2), (11, 2), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 2), (57, 2), (172, 1)], [], [(0, 2), (1, 2), (5, 2), (7, 1), (11, 1), (12, 2), (15, 2), (24, 2), (25, 1), (34, 1), (58, 1), (66, 1), (72, 2)], [(0, 2), (1, 2), (2, 1), (5, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1)], [(1, 1), (3, 1), (4, 2), (5, 2), (7, 2), (11, 2), (12, 1), (15, 2), (24, 2), (25, 1), (34, 1)], [(0, 2), (1, 2), (5, 2), (7, 1), (9, 1), (11, 1), (12, 2), (15, 2), (24, 2), (25, 1), (34, 1)], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (11, 2), (12, 2), (13, 2), (15, 2), (25, 1), (34, 1)], [], [], [], [], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (11, 1), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 2)], [], [(0, 1), (1, 1), (5, 1), (7, 2), (9, 2), (11, 2), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (7, 2), (11, 1), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 2)], [], [(1, 2), (2, 2), (5, 2), (7, 1), (11, 2), (12, 2), (15, 1), (24, 2), (25, 1), (34, 2)], [], [], [], [], [(0, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 2), (12, 2), (13, 1), (24, 2), (25, 1), (34, 2), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 2), (11, 1), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 1), (57, 2), (58, 1), (67, 1), (121, 2), (172, 1), (173, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (8, 1), (9, 1), (11, 1), (12, 1), (13, 1), (24, 1), (25, 2), (34, 1), (57, 2), (60, 1), (66, 2), (67, 2), (72, 1), (121, 1), (172, 1), (173, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 2), (9, 1), (12, 2), (13, 1), (24, 1), (25, 2), (34, 1), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 1), (8, 2), (12, 1), (13, 2), (34, 1), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [(0, 1), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 1), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [(0, 1), (2, 1), (6, 2), (8, 1), (9, 1), (12, 1), (13, 2), (34, 1), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 2), (2, 1), (6, 2), (7, 1), (8, 1), (13, 2), (14, 1), (34, 1), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (11, 2), (13, 1), (15, 2), (24, 2), (25, 1), (34, 2), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (15, 2), (24, 2), (25, 1), (34, 2), (57, 2), (58, 1), (66, 2), (67, 2), (72, 1), (121, 1), (172, 1), (173, 2)], [], [], [(0, 2), (1, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (12, 2), (13, 1), (15, 2), (24, 2), (25, 1), (34, 2), (57, 2), (66, 2), (67, 2), (72, 1), (115, 1), (121, 1), (172, 1), (173, 2)], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (8, 2), (11, 2), (12, 2), (13, 1), (24, 2), (25, 1), (34, 2), (57, 2), (58, 2), (60, 2), (67, 1), (121, 2), (172, 1), (173, 1), (174, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 2), (6, 1), (7, 2), (8, 2), (34, 2), (57, 2), (58, 2), (67, 1), (121, 2), (172, 1), (173, 1), (181, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 2), (11, 1), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 1), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [(0, 2), (1, 2), (2, 2), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (11, 2), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 1), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (34, 1), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (10, 1), (11, 1), (13, 2), (15, 1), (34, 1), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (13, 2), (15, 1), (17, 1), (34, 1), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (15, 1), (24, 1), (25, 2), (34, 1), (57, 1), (58, 2), (66, 1), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (34, 1), (57, 1), (58, 2), (67, 2), (121, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1), (13, 2), (15, 1), (34, 1), (57, 1), (60, 2), (66, 1), (67, 1), (71, 1), (72, 2), (121, 2), (172, 2), (173, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1), (13, 2), (15, 1), (34, 1), (57, 1), (60, 2), (66, 1), (67, 1), (72, 2), (121, 2), (127, 1), (172, 2), (173, 1)], [], [(0, 1), (1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (9, 1), (11, 2), (13, 2), (15, 2), (17, 2), (34, 2), (51, 1), (57, 2), (58, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [], [(0, 1), (6, 1), (8, 1), (12, 2), (13, 2), (14, 2), (34, 2), (44, 1), (57, 1), (58, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [(0, 2), (2, 2), (6, 1), (8, 2), (9, 1), (12, 2), (13, 2), (34, 2), (66, 1), (67, 1), (72, 2), (99, 1), (121, 2), (172, 2), (173, 1)], [(0, 1), (1, 1), (2, 2), (6, 1), (7, 2), (8, 2), (9, 2), (13, 2), (14, 2), (34, 2), (66, 1), (67, 1), (72, 2), (121, 2), (157, 1), (172, 2), (173, 1)], [(2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 1), (12, 2), (13, 2), (15, 2), (24, 2), (25, 1), (57, 1), (58, 2), (66, 1), (67, 1), (72, 2), (121, 2), (172, 2), (173, 1), (392, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 1), (9, 1), (12, 1), (24, 2), (25, 1), (34, 2), (66, 1), (67, 1), (72, 2), (121, 2), (172, 2), (173, 1), (274, 1)], [(0, 2), (1, 1), (5, 1), (7, 2), (9, 2), (11, 2), (12, 1), (13, 2), (15, 1), (17, 2), (24, 1), (25, 2), (34, 2), (57, 1), (58, 2), (121, 2), (172, 2), (173, 1), (470, 1)], [], [], [], [], [], [], [(9, 1), (13, 2), (57, 1), (58, 2), (66, 2), (72, 1)], [(1, 1), (2, 2), (7, 2), (8, 1), (12, 1), (13, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb10 : List (List (Nat × Nat)) := [[], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (13, 1), (14, 2), (15, 1), (16, 2), (34, 2), (57, 2), (233, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 1), (9, 1), (14, 1), (15, 2), (16, 1), (34, 1), (60, 1), (63, 1), (71, 2)], [(0, 2), (1, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (15, 2), (16, 1), (34, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 2), (15, 2), (16, 1), (34, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 1), (14, 1), (15, 2), (16, 1), (34, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (13, 2), (14, 1), (15, 2), (16, 1), (18, 1), (34, 1)], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (9, 2), (13, 1), (14, 2), (15, 1), (16, 2), (34, 2), (63, 1)], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 2), (9, 2), (13, 1), (14, 2), (15, 1), (16, 2), (34, 2)], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (13, 1), (14, 2), (15, 1), (16, 2), (34, 2)], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2)], [], [], [], [], [], [(0, 2), (1, 1), (2, 2), (3, 1), (5, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 1), (57, 2), (60, 1), (63, 1), (64, 1), (71, 2), (121, 2), (233, 1), (234, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (5, 2), (7, 1), (8, 2), (9, 1), (13, 1), (14, 2), (15, 2), (16, 1), (18, 2), (19, 1), (34, 1), (57, 2), (60, 1), (63, 1), (64, 1), (121, 1), (233, 1), (234, 2)], [(0, 2), (2, 2), (3, 2), (5, 2), (6, 1), (8, 1), (9, 2), (13, 2), (14, 1), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 2), (58, 1), (63, 1), (64, 1), (121, 1), (233, 1), (234, 2)], [(0, 1), (3, 2), (4, 2), (7, 1), (8, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 1), (57, 2), (60, 1), (63, 2), (64, 1), (71, 2), (121, 1), (233, 1), (234, 2)], [(2, 1), (3, 2), (4, 2), (6, 1), (9, 2), (13, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 2), (60, 1), (63, 2), (64, 1), (71, 2), (121, 1), (233, 1), (234, 2)], [], [(0, 1), (1, 2), (3, 2), (7, 1), (8, 1), (9, 1), (13, 1), (18, 2), (19, 1), (34, 1), (57, 2), (60, 1), (63, 2), (64, 1), (71, 2), (121, 1), (233, 1), (234, 2)], [], [(4, 2), (8, 1), (9, 2), (12, 1), (13, 2), (14, 1), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 2), (60, 1), (63, 2), (64, 1), (71, 2), (121, 1), (233, 1), (234, 2)], [], [], [], [], [], [(0, 2), (1, 1), (3, 1), (4, 1), (6, 2), (7, 2), (8, 2), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2), (57, 2), (60, 1), (63, 2), (64, 1), (71, 2), (121, 1), (233, 1), (234, 2)], [], [], [(0, 2), (1, 1), (3, 1), (4, 1), (6, 2), (7, 2), (9, 2), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2), (57, 2), (60, 1), (63, 1), (64, 2), (71, 2), (121, 1), (233, 1), (234, 2)], [], [], [(0, 1), (1, 1), (2, 1), (4, 1), (7, 2), (8, 2), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2), (57, 2), (60, 1), (63, 1), (64, 1), (71, 2), (120, 1), (121, 1), (233, 1), (234, 2)], [], [(0, 2), (1, 1), (4, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2), (57, 2), (60, 1), (63, 1), (64, 2), (71, 1), (121, 2), (233, 1), (234, 1), (236, 1)], [(4, 1), (6, 2), (9, 2), (14, 1), (15, 1), (16, 2), (18, 2), (19, 1), (34, 2), (57, 2), (60, 1), (63, 1), (64, 1), (71, 2), (121, 1), (181, 1), (233, 1), (234, 2)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (6, 1), (7, 1), (8, 1), (13, 1), (14, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [(0, 1), (1, 2), (3, 2), (4, 2), (6, 1), (7, 1), (8, 1), (13, 1), (14, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [(3, 2), (4, 2), (6, 2), (9, 1), (13, 2), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [], [(0, 1), (1, 2), (2, 2), (4, 2), (6, 1), (7, 1), (8, 1), (13, 2), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [], [(4, 1), (6, 1), (8, 1), (9, 1), (13, 2), (14, 2), (15, 2), (16, 2), (18, 1), (19, 2), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (7, 1), (8, 1), (13, 1), (14, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 1), (57, 1), (60, 2), (63, 2), (64, 1), (66, 1), (71, 1), (121, 2), (233, 2), (234, 1)], [(0, 1), (2, 2), (4, 1), (6, 1), (8, 1), (13, 2), (15, 1), (16, 2), (18, 1), (19, 2), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (65, 1), (71, 1), (121, 2), (233, 2), (234, 1)], [], [(4, 1), (6, 1), (9, 2), (13, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 1), (60, 2), (63, 2), (64, 1), (71, 1), (73, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 1), (8, 1), (9, 1), (13, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (57, 1), (60, 2), (63, 2), (64, 2), (71, 1), (120, 2), (121, 2), (130, 1), (233, 2), (234, 1)], [], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 1), (8, 2), (13, 2), (14, 2), (15, 1), (16, 2), (18, 2), (19, 1), (34, 2), (51, 1), (57, 2), (60, 1), (63, 2), (64, 1), (71, 2), (121, 1), (233, 1), (234, 2)], [], [(0, 2), (3, 1), (4, 1), (6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (16, 2), (18, 2), (19, 1), (34, 2), (44, 1), (57, 1), (60, 2), (63, 1), (64, 2), (71, 1), (121, 2), (233, 2), (234, 1)], [(2, 2), (3, 1), (5, 1), (8, 1), (9, 1), (12, 2), (13, 2), (14, 2), (15, 1), (16, 2), (18, 2), (19, 1), (34, 2), (63, 2), (64, 2), (99, 1), (121, 2), (233, 2), (234, 1)], [(2, 1), (3, 2), (5, 1), (6, 2), (8, 2), (9, 1), (13, 2), (14, 1), (15, 1), (16, 2), (18, 2), (19, 1), (34, 2), (63, 2), (64, 2), (121, 2), (157, 1), (233, 2), (234, 1)], [(1, 1), (2, 2), (3, 2), (6, 1), (7, 2), (9, 2), (13, 2), (14, 2), (18, 2), (19, 1), (57, 1), (60, 2), (63, 2), (64, 2), (71, 1), (120, 2), (121, 2), (233, 2), (234, 1), (392, 1)], [(0, 2), (2, 2), (3, 2), (5, 1), (7, 2), (8, 1), (9, 2), (15, 1), (16, 2), (18, 1), (19, 2), (34, 2), (63, 2), (64, 2), (121, 2), (216, 1), (233, 2), (234, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (13, 2), (14, 1), (15, 1), (16, 2), (34, 2), (57, 1), (60, 2), (64, 2), (71, 1), (120, 1), (121, 2), (130, 2), (233, 2), (234, 1), (470, 1)], [], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (13, 2), (57, 1), (60, 2), (63, 2), (71, 1)], [(0, 1), (2, 2), (8, 1), (9, 2), (13, 2), (14, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb11 : List (List (Nat × Nat)) := [[(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (9, 1), (13, 2), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (13, 2), (57, 2), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1), (114, 1)], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (13, 1), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (13, 1), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1)], [], [], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 1), (9, 1), (12, 2), (13, 2), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (77, 1)], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (13, 2), (63, 2), (64, 2), (65, 1), (66, 1), (67, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (13, 1), (18, 1), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1)], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (13, 2), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1)], [], [], [], [], [(2, 1), (5, 2), (6, 2), (13, 1), (14, 2), (16, 1), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (13, 1), (14, 1), (16, 2), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [(2, 1), (5, 2), (6, 2), (13, 1), (14, 1), (16, 2), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [(3, 1), (4, 2), (6, 2), (13, 1), (14, 1), (16, 2), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [], [], [], [], [(0, 1), (2, 1), (5, 2), (9, 2), (14, 2), (16, 1), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [(0, 1), (3, 1), (5, 2), (9, 2), (14, 2), (16, 1), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (9, 2), (12, 1), (14, 1), (16, 2), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (9, 2), (14, 2), (16, 2), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (9, 2), (14, 1), (16, 2), (21, 1), (57, 2), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 1), (115, 2)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (9, 2), (13, 1), (14, 2), (16, 1), (57, 2), (60, 1), (65, 2), (114, 1), (115, 2)], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (13, 1), (14, 2), (16, 1), (57, 1), (60, 2), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 2), (115, 1)], [(2, 1), (5, 2), (6, 2), (13, 1), (14, 2), (16, 1), (57, 1), (58, 1), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 2), (115, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (13, 1), (14, 2), (16, 1), (57, 1), (60, 2), (63, 2), (64, 1), (65, 1), (114, 2), (115, 1)], [], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (13, 1), (14, 1), (16, 2), (57, 1), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 2), (115, 1), (174, 1)], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (13, 1), (14, 1), (16, 2), (57, 1), (60, 1), (63, 2), (64, 1), (65, 1), (66, 2), (67, 1), (114, 2), (115, 1), (236, 1)], [(0, 1), (2, 2), (3, 1), (4, 1), (6, 2), (9, 1), (13, 1), (14, 1), (16, 2), (57, 1), (60, 2), (63, 2), (65, 1), (114, 2), (115, 1), (181, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (13, 2), (14, 1), (16, 2), (57, 2), (60, 1), (65, 2), (114, 1), (115, 2)], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (9, 2), (13, 2), (14, 2), (16, 1), (57, 2), (60, 1), (65, 2), (114, 1), (115, 2)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (9, 2), (10, 1), (13, 2), (14, 2), (16, 1), (57, 2), (60, 1), (65, 2), (114, 1), (115, 2)], [], [], [], [], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (9, 1), (13, 1), (14, 1), (16, 1), (57, 1), (60, 2), (66, 2), (67, 1), (73, 1), (114, 2), (115, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (14, 2), (16, 1), (57, 1), (60, 2), (63, 2), (65, 1), (71, 1), (114, 2), (115, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (14, 2), (16, 1), (57, 1), (60, 2), (63, 2), (65, 1), (80, 1), (114, 2), (115, 1)], [], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 1), (14, 1), (16, 2), (51, 1), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (114, 1), (115, 2)], [(0, 2), (3, 2), (4, 1), (5, 1), (7, 2), (9, 1), (14, 1), (16, 2), (57, 1), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (114, 2), (115, 1), (314, 1)], [], [(2, 1), (5, 2), (9, 1), (12, 2), (14, 2), (16, 1), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1), (99, 1), (114, 2), (115, 1)], [], [(0, 1), (3, 1), (4, 2), (5, 2), (9, 1), (13, 2), (14, 1), (16, 2), (57, 1), (58, 2), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1), (114, 2), (115, 1), (392, 1)], [(2, 1), (5, 2), (9, 1), (14, 1), (16, 1), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1), (114, 2), (115, 1), (216, 1)], [(2, 1), (5, 2), (9, 1), (12, 2), (14, 2), (16, 1), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1), (114, 2), (115, 1), (274, 1)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (9, 2), (57, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (114, 2), (115, 1)], [], [], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (57, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1)], [], [], [], [], [(9, 1), (16, 2), (60, 1), (65, 2), (115, 2), (130, 1)], [], [(2, 1), (5, 2), (65, 2), (66, 2), (67, 1), (68, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (65, 2), (67, 1)], [], [], [], [], [], [], [], [], [], []] + +def comb12 : List (List (Nat × Nat)) := [[(0, 1), (2, 1), (3, 2), (4, 2), (5, 1), (6, 1), (8, 2), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (13, 1), (58, 2), (60, 2), (63, 2), (71, 1), (72, 1)], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (13, 1), (58, 1), (60, 2), (63, 2), (71, 1), (72, 2)], [], [], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (8, 2), (9, 2), (12, 1), (58, 1), (60, 2), (63, 1), (64, 1), (71, 1), (72, 2), (73, 2), (75, 1)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (58, 2), (60, 1), (63, 2), (71, 2), (72, 1)], [], [(3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 2), (11, 1), (12, 1), (15, 2), (20, 1), (58, 1), (60, 2), (63, 2), (71, 1), (72, 2)], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (58, 1), (60, 2), (63, 2), (71, 1), (72, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 1), (58, 1), (60, 2), (63, 2), (71, 1), (72, 2)], [], [], [(0, 1), (2, 1), (4, 1), (5, 1), (8, 2), (9, 2), (11, 1), (12, 2), (13, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [(0, 2), (3, 1), (5, 1), (6, 2), (9, 1), (11, 2), (12, 2), (13, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [], [(0, 1), (2, 1), (4, 1), (5, 1), (8, 2), (9, 1), (11, 2), (12, 2), (13, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [(0, 1), (3, 1), (5, 2), (6, 2), (9, 1), (11, 2), (12, 2), (13, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [], [(0, 2), (3, 2), (5, 1), (6, 1), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (58, 2), (60, 2), (71, 2), (72, 2), (120, 1), (293, 2)], [], [(0, 1), (1, 1), (2, 1), (3, 1), (5, 1), (6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [(0, 1), (2, 2), (4, 1), (5, 1), (8, 1), (9, 2), (11, 1), (12, 1), (13, 2), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [(0, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [], [(0, 1), (2, 1), (3, 1), (5, 1), (6, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [], [], [(0, 1), (2, 1), (3, 1), (5, 1), (6, 2), (8, 2), (9, 1), (11, 2), (12, 1), (13, 2), (21, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 1)], [], [], [], [], [], [(0, 1), (2, 2), (4, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (58, 1), (63, 2), (72, 1), (120, 1), (293, 2)], [(0, 2), (3, 1), (4, 1), (5, 1), (6, 2), (9, 1), (11, 1), (12, 2), (13, 1), (60, 1), (63, 2), (64, 1), (71, 2), (72, 1), (120, 1), (293, 2)], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (9, 1), (11, 2), (12, 1), (13, 1), (63, 2), (72, 1), (115, 1), (120, 1), (293, 2)], [(0, 2), (3, 1), (5, 1), (6, 2), (9, 1), (11, 2), (12, 2), (13, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 2), (293, 2)], [], [], [(0, 2), (3, 1), (5, 1), (6, 2), (9, 1), (11, 2), (12, 2), (13, 1), (60, 1), (63, 2), (71, 2), (72, 1), (120, 1), (181, 1), (293, 2)], [], [(0, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (60, 2), (71, 1), (72, 2), (120, 2), (293, 1)], [], [], [], [], [(0, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (15, 1), (60, 2), (71, 1), (72, 2), (120, 2), (293, 1)], [(0, 1), (2, 1), (3, 1), (5, 1), (6, 2), (9, 2), (11, 1), (12, 1), (13, 1), (17, 1), (60, 2), (71, 1), (72, 2), (120, 2), (293, 1)], [], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (58, 1), (63, 2), (65, 1), (120, 1), (293, 2)], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (60, 1), (63, 2), (64, 1), (66, 2), (67, 1), (71, 2), (72, 1), (120, 1), (293, 2)], [], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (60, 1), (63, 2), (71, 2), (72, 1), (80, 1), (120, 1), (293, 2)], [], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 2), (60, 1), (63, 2), (71, 2), (72, 1), (120, 1), (137, 1), (293, 2)], [(0, 1), (2, 1), (4, 1), (5, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 2), (17, 2), (51, 1), (58, 2), (63, 1), (120, 2), (293, 1)], [(0, 2), (2, 1), (4, 2), (8, 2), (9, 1), (11, 2), (12, 2), (13, 1), (17, 2), (58, 1), (60, 2), (63, 1), (71, 1), (120, 1), (293, 2), (314, 1)], [], [(0, 2), (2, 1), (4, 2), (6, 1), (9, 1), (11, 1), (12, 2), (13, 2), (57, 2), (58, 2), (63, 2), (72, 2), (99, 1), (120, 1), (293, 2)], [(0, 2), (3, 1), (4, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 2), (57, 2), (58, 2), (63, 2), (72, 2), (120, 1), (157, 1), (293, 2)], [], [(0, 2), (1, 2), (2, 1), (4, 2), (6, 1), (9, 1), (11, 2), (12, 2), (13, 2), (57, 2), (58, 2), (63, 2), (72, 2), (120, 1), (216, 1), (293, 2)], [(0, 2), (1, 2), (2, 1), (4, 2), (6, 1), (9, 1), (11, 2), (12, 2), (13, 2), (57, 2), (58, 2), (63, 2), (72, 2), (120, 1), (274, 1), (293, 2)], [], [(0, 2), (2, 1), (3, 2), (6, 1), (58, 1), (63, 2), (120, 1), (293, 2)], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (13, 2), (57, 1), (60, 2), (63, 2), (71, 1)], [], [], [], [], [(2, 1), (4, 1), (5, 2), (9, 1), (11, 2), (12, 2), (58, 1), (60, 2), (71, 1), (72, 2), (120, 2), (130, 1)], [(2, 1), (5, 2), (9, 1), (12, 2), (58, 1), (60, 2), (64, 2), (71, 1), (72, 2), (73, 1)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (58, 1), (60, 2), (64, 2), (66, 1), (71, 1), (72, 2)], [], [], [], [], [], [], [], [], [], []] + +def comb13 : List (List (Nat × Nat)) := [[(0, 1), (1, 2), (2, 2), (3, 2), (6, 2), (8, 1), (9, 1), (10, 1), (12, 2), (15, 2), (57, 2), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (233, 1), (234, 2)], [], [], [], [(3, 2), (4, 2), (6, 2), (8, 1), (9, 2), (12, 1), (15, 2), (57, 2), (58, 1), (60, 2), (65, 2), (66, 1), (67, 2), (68, 1), (72, 2), (233, 1)], [(2, 2), (3, 2), (4, 2), (5, 1), (6, 1), (8, 1), (9, 2), (12, 2), (15, 2), (24, 1), (25, 2), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1)], [], [], [], [], [(3, 2), (4, 2), (6, 1), (8, 1), (9, 2), (12, 1), (15, 2), (24, 1), (58, 1), (60, 2), (65, 2), (66, 1), (67, 2), (68, 1), (72, 2)], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 1), (8, 2), (9, 1), (12, 2), (15, 1), (58, 2), (60, 1), (66, 1), (67, 2), (72, 2), (74, 2), (75, 1)], [(3, 1), (6, 2), (8, 1), (9, 2), (12, 1), (15, 2), (58, 2), (60, 1), (66, 2), (67, 1), (72, 1), (77, 1)], [], [], [], [], [(3, 2), (4, 2), (6, 1), (8, 2), (9, 2), (12, 1), (15, 2), (58, 1), (60, 2), (65, 2), (66, 1), (67, 2), (68, 1), (72, 2)], [], [], [(3, 2), (4, 2), (6, 2), (8, 1), (9, 2), (12, 1), (15, 2), (58, 1), (60, 2), (65, 2), (66, 1), (67, 2), (68, 1), (72, 2)], [(3, 1), (4, 1), (6, 1), (8, 2), (9, 1), (12, 2), (15, 1), (58, 2), (60, 1), (66, 2), (67, 2), (72, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (8, 1), (9, 1), (10, 1), (12, 1), (24, 1), (25, 2), (57, 2), (58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (233, 1), (234, 2)], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 1), (8, 2), (10, 1), (12, 1), (24, 1), (25, 2), (57, 2), (58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (233, 1), (234, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (8, 2), (10, 1), (12, 1), (24, 1), (25, 2), (57, 2), (58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (233, 1), (234, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (5, 1), (6, 1), (8, 1), (9, 1), (10, 1), (15, 1), (24, 1), (25, 2), (57, 2), (60, 1), (65, 1), (67, 1), (68, 2), (233, 1), (234, 2)], [], [], [], [], [(0, 1), (3, 2), (5, 2), (8, 1), (9, 1), (10, 1), (12, 1), (24, 2), (25, 1), (57, 2), (58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (233, 1), (234, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 2), (5, 2), (6, 1), (9, 2), (10, 1), (15, 1), (24, 2), (25, 1), (57, 2), (60, 1), (65, 1), (67, 1), (68, 2), (233, 1), (234, 2)], [], [(0, 1), (1, 2), (3, 2), (5, 2), (8, 1), (9, 1), (10, 1), (12, 1), (15, 1), (24, 2), (25, 1), (57, 2), (58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (233, 1), (234, 2)], [], [(0, 1), (1, 2), (4, 2), (5, 2), (8, 1), (9, 1), (10, 1), (12, 1), (15, 1), (24, 2), (25, 1), (57, 2), (60, 1), (65, 1), (67, 1), (68, 2), (233, 1), (234, 2)], [], [], [], [], [], [(0, 1), (1, 2), (3, 1), (5, 2), (6, 2), (8, 2), (10, 1), (12, 2), (15, 2), (24, 2), (25, 1), (57, 2), (58, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 1), (234, 2)], [(0, 2), (1, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (10, 2), (12, 1), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (233, 2), (234, 1)], [(0, 1), (1, 1), (2, 1), (3, 2), (5, 1), (6, 2), (9, 1), (10, 2), (15, 1), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (65, 1), (67, 1), (68, 2), (233, 2), (234, 1)], [], [(0, 2), (1, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (10, 2), (12, 1), (24, 1), (25, 2), (57, 1), (58, 1), (65, 2), (66, 1), (67, 1), (68, 1), (72, 2), (117, 1), (233, 2), (234, 1)], [(0, 2), (1, 1), (5, 1), (6, 1), (8, 1), (10, 2), (15, 1), (24, 1), (25, 2), (57, 1), (60, 1), (65, 1), (67, 1), (68, 2), (115, 1), (233, 2), (234, 1)], [], [(0, 2), (1, 1), (5, 1), (6, 1), (8, 1), (10, 2), (15, 1), (24, 1), (25, 2), (57, 1), (60, 1), (65, 1), (67, 1), (68, 2), (174, 1), (233, 2), (234, 1)], [], [], [], [], [], [(0, 1), (1, 2), (3, 1), (5, 2), (6, 2), (9, 2), (10, 1), (12, 2), (15, 2), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 1), (234, 2)], [], [(0, 1), (1, 1), (2, 1), (4, 1), (5, 1), (8, 2), (9, 2), (10, 2), (12, 2), (15, 2), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 1), (234, 2)], [], [(0, 1), (1, 2), (2, 1), (5, 1), (8, 2), (10, 1), (12, 1), (15, 2), (17, 1), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 1), (234, 2)], [(0, 1), (1, 2), (4, 2), (5, 1), (6, 2), (9, 1), (10, 1), (15, 1), (22, 1), (24, 1), (25, 2), (57, 2), (60, 1), (67, 2), (233, 1), (234, 2)], [(0, 2), (1, 1), (2, 2), (3, 2), (5, 2), (6, 1), (9, 1), (10, 2), (12, 1), (15, 1), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (65, 2), (66, 2), (68, 1), (72, 2), (233, 2), (234, 1)], [(0, 2), (1, 1), (2, 2), (4, 2), (5, 2), (6, 1), (9, 1), (10, 2), (12, 1), (15, 1), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (65, 2), (66, 1), (68, 2), (72, 2), (233, 2), (234, 1)], [], [(0, 1), (1, 1), (4, 2), (5, 2), (6, 1), (9, 1), (10, 2), (12, 1), (15, 1), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (65, 1), (67, 1), (68, 2), (73, 1), (74, 2), (233, 2), (234, 1)], [], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (8, 1), (10, 2), (12, 1), (15, 1), (24, 2), (25, 1), (57, 1), (60, 1), (65, 1), (67, 1), (68, 2), (115, 1), (130, 1), (131, 2), (233, 2), (234, 1)], [], [], [(0, 1), (1, 2), (3, 1), (5, 2), (6, 1), (9, 2), (10, 1), (15, 2), (17, 2), (24, 2), (25, 1), (51, 1), (57, 2), (58, 2), (60, 2), (65, 1), (66, 2), (68, 2), (72, 1), (233, 1), (234, 2)], [(0, 2), (1, 1), (3, 1), (4, 1), (5, 1), (6, 2), (9, 1), (10, 2), (15, 2), (17, 2), (24, 1), (25, 2), (57, 1), (58, 2), (60, 2), (65, 1), (66, 2), (68, 2), (72, 1), (233, 2), (234, 1), (314, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (8, 1), (10, 2), (12, 2), (24, 2), (25, 1), (65, 1), (67, 2), (68, 2), (99, 1), (233, 2), (234, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 2), (8, 2), (9, 2), (10, 2), (24, 2), (25, 1), (65, 1), (67, 2), (68, 2), (157, 1), (233, 2), (234, 1)], [(1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 2), (9, 2), (10, 2), (24, 2), (25, 1), (57, 1), (58, 2), (65, 1), (67, 2), (68, 2), (233, 2), (234, 1), (392, 1)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (8, 1), (10, 2), (12, 2), (15, 1), (24, 2), (25, 1), (58, 2), (60, 1), (66, 2), (67, 2), (72, 1), (216, 1), (233, 2), (234, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (8, 1), (10, 2), (15, 2), (57, 1), (60, 2), (65, 1), (68, 2), (233, 2), (234, 1)], [], [], [], [], [], [(2, 1), (3, 2), (4, 2), (5, 2), (8, 1), (9, 2), (15, 2), (24, 2), (25, 1), (57, 1), (60, 2), (65, 1), (68, 2)], [], [], [], [], [(3, 2), (6, 1), (8, 2), (9, 1), (58, 1), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (115, 2), (131, 1)], [(0, 1), (2, 2), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (74, 1)], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb14 : List (List (Nat × Nat)) := [[], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (8, 1), (9, 1), (13, 1), (58, 2), (60, 2), (114, 1), (115, 1), (117, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (8, 1), (9, 1), (13, 1), (58, 2), (60, 1), (114, 1), (115, 1), (117, 2)], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (7, 1), (8, 1), (9, 1), (13, 1), (58, 1), (60, 2), (115, 2), (117, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (9, 1), (13, 1), (58, 2), (60, 1), (115, 1), (117, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (9, 1), (13, 2), (57, 2), (58, 2), (60, 1), (75, 1), (115, 1), (117, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (7, 2), (9, 1), (13, 2), (15, 2), (20, 1), (58, 2), (60, 1), (115, 1), (117, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (9, 1), (13, 2), (58, 1), (60, 2), (115, 2), (117, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (7, 1), (9, 2), (13, 2), (58, 1), (60, 2), (115, 2), (117, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (9, 1), (13, 2), (58, 2), (60, 1), (115, 1), (117, 2)], [], [], [], [(1, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 2), (14, 2), (58, 2), (60, 2), (64, 1), (73, 1), (114, 1), (115, 1), (117, 1)], [], [], [(1, 1), (3, 1), (4, 1), (6, 2), (7, 2), (8, 2), (14, 1), (58, 2), (60, 2), (73, 2), (114, 1), (115, 1), (117, 1)], [(1, 1), (4, 2), (6, 2), (7, 2), (8, 2), (14, 1), (58, 2), (60, 2), (73, 2), (114, 1), (115, 1), (117, 1)], [(1, 1), (2, 2), (3, 1), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (14, 1), (58, 2), (60, 2), (73, 2), (114, 1), (115, 1), (117, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (9, 2), (13, 2), (14, 2), (58, 2), (73, 1), (114, 1), (115, 1), (117, 1)], [(1, 1), (4, 2), (6, 2), (7, 2), (9, 2), (13, 2), (14, 2), (60, 2), (73, 1), (114, 1), (115, 1), (117, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (9, 1), (14, 2), (58, 1), (60, 1), (73, 1), (114, 2), (115, 2), (117, 2)], [], [], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (12, 1), (13, 2), (14, 1), (58, 2), (60, 2), (73, 2), (114, 1), (115, 1), (117, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (9, 2), (13, 2), (14, 2), (58, 2), (60, 2), (73, 2), (114, 1), (115, 1), (117, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (9, 2), (13, 2), (14, 1), (21, 1), (58, 2), (60, 2), (73, 2), (114, 1), (115, 1), (117, 1)], [], [], [(0, 1), (4, 2), (6, 1), (9, 2), (13, 2), (14, 2), (60, 2), (73, 1), (114, 2), (117, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (9, 2), (13, 2), (14, 2), (60, 2), (73, 1), (114, 2), (117, 1)], [], [], [], [], [], [], [(1, 1), (3, 1), (4, 1), (6, 1), (7, 2), (13, 2), (14, 1), (15, 1), (20, 2), (58, 2), (60, 2), (73, 2), (114, 2), (115, 1), (174, 1)], [(1, 1), (3, 1), (4, 1), (6, 1), (7, 2), (13, 2), (14, 1), (15, 1), (20, 2), (58, 2), (60, 2), (73, 2), (114, 2), (115, 1), (236, 1)], [(0, 1), (2, 2), (3, 1), (4, 1), (6, 1), (13, 2), (14, 1), (60, 2), (64, 2), (73, 2), (114, 2), (117, 1), (181, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (13, 1), (14, 1), (60, 1), (73, 2), (114, 1), (117, 2)], [], [], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (8, 1), (9, 2), (13, 1), (14, 2), (15, 1), (58, 2), (73, 1), (114, 2), (115, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (8, 1), (9, 1), (12, 2), (13, 2), (14, 2), (17, 1), (58, 2), (73, 1), (114, 2), (115, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (8, 1), (9, 1), (13, 1), (14, 2), (22, 1), (60, 2), (73, 1), (114, 2), (117, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (8, 2), (9, 1), (13, 1), (14, 2), (60, 1), (66, 1), (73, 1), (114, 1), (117, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 1), (13, 1), (14, 2), (60, 1), (65, 1), (73, 1), (114, 1), (117, 2)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (8, 2), (9, 1), (13, 1), (14, 2), (60, 1), (67, 1), (73, 1), (114, 1), (117, 2)], [], [], [], [], [], [], [(0, 2), (1, 2), (4, 1), (5, 1), (6, 1), (7, 1), (9, 1), (12, 1), (13, 1), (14, 1), (17, 2), (51, 1), (58, 1), (73, 2), (114, 1), (115, 2)], [(0, 2), (1, 2), (4, 1), (5, 1), (6, 1), (7, 1), (9, 1), (12, 1), (13, 1), (14, 1), (17, 2), (57, 2), (58, 2), (73, 2), (114, 2), (115, 1), (314, 1)], [(1, 1), (4, 2), (7, 2), (8, 1), (13, 1), (14, 1), (44, 1), (58, 1), (60, 1), (73, 1), (114, 2), (115, 2), (117, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (7, 2), (8, 2), (14, 1), (58, 1), (60, 1), (64, 2), (73, 2), (114, 2), (115, 2), (117, 2), (392, 1)], [(1, 1), (4, 2), (6, 1), (7, 1), (8, 1), (9, 1), (13, 1), (58, 1), (60, 1), (64, 2), (73, 2), (114, 2), (115, 2), (117, 2), (216, 1)], [(0, 1), (4, 2), (6, 1), (7, 2), (8, 1), (12, 2), (13, 1), (14, 1), (58, 1), (60, 1), (64, 2), (73, 2), (114, 2), (115, 2), (117, 2), (274, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 1), (57, 1), (58, 2), (114, 2), (115, 1)], [], [], [], [], [], [], [], [], [], [(60, 1), (73, 2), (117, 2), (130, 1)], [], [], [], [], [], [(1, 1), (4, 2), (7, 2), (11, 1), (58, 2), (60, 1), (115, 1), (117, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 1)], [], [], [], [], [], []] + +def comb15 : List (List (Nat × Nat)) := [[], [(0, 2), (3, 2), (7, 2), (11, 2), (12, 1), (16, 2), (18, 1), (19, 1), (64, 1), (120, 2), (293, 1)], [], [], [], [], [(0, 1), (2, 1), (3, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (13, 1), (14, 2), (16, 2), (18, 1), (19, 2)], [], [(0, 1), (3, 2), (7, 1), (12, 2), (13, 1), (14, 2), (16, 2), (18, 1), (19, 2)], [], [], [], [(0, 1), (3, 2), (7, 1), (8, 1), (12, 2), (14, 2), (16, 2), (18, 1), (19, 2), (60, 2), (64, 2), (68, 1), (77, 1)], [], [(0, 1), (3, 1), (4, 1), (7, 1), (12, 2), (16, 1), (18, 2), (19, 2)], [], [(0, 1), (3, 2), (7, 2), (9, 1), (11, 2), (12, 2), (14, 2), (16, 2), (18, 1), (19, 2)], [(0, 2), (3, 1), (7, 2), (12, 1), (14, 1), (16, 1), (18, 2), (19, 1)], [], [(0, 1), (3, 2), (7, 1), (8, 1), (12, 2), (14, 2), (16, 2), (18, 1), (19, 2)], [(0, 2), (2, 2), (3, 2), (7, 1), (8, 1), (9, 2), (11, 1), (12, 2), (16, 1), (18, 2), (19, 1)], [], [(0, 1), (2, 1), (4, 2), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (14, 1), (19, 2), (64, 2), (68, 1), (120, 2), (293, 1)], [], [(0, 1), (2, 1), (3, 1), (4, 1), (7, 2), (8, 2), (12, 1), (13, 1), (16, 1), (18, 2), (64, 1), (68, 2), (120, 2), (293, 1)], [], [(0, 1), (2, 1), (4, 2), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (14, 1), (19, 2), (64, 1), (68, 2), (120, 2), (293, 1)], [(2, 1), (3, 1), (4, 1), (5, 1), (7, 2), (8, 2), (12, 1), (13, 1), (16, 1), (18, 2), (64, 1), (68, 2), (120, 2), (293, 1)], [], [], [(2, 2), (4, 2), (7, 2), (8, 1), (11, 1), (12, 1), (13, 2), (19, 2), (58, 1), (64, 1), (68, 1), (120, 2), (293, 1)], [], [], [], [], [(2, 2), (3, 1), (4, 1), (7, 2), (8, 1), (9, 1), (12, 1), (13, 2), (14, 2), (16, 1), (18, 2), (64, 1), (68, 2), (120, 2), (293, 1)], [], [], [(2, 2), (3, 1), (4, 1), (7, 2), (8, 1), (12, 1), (13, 2), (14, 2), (16, 1), (18, 2), (21, 1), (64, 1), (68, 2), (120, 2), (293, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (7, 2), (8, 2), (12, 1), (13, 1), (16, 1), (18, 2), (19, 2), (64, 2), (68, 1), (120, 1), (293, 2)], [(0, 2), (2, 1), (4, 2), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (14, 1), (19, 1), (64, 2), (68, 1), (120, 1), (293, 2)], [(0, 1), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (12, 1), (13, 1), (16, 1), (18, 2), (19, 2), (64, 2), (68, 1), (120, 1), (293, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (12, 2), (13, 2), (16, 2), (18, 1), (19, 1), (60, 1), (64, 1), (68, 1), (120, 2), (293, 1)], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (16, 1), (18, 2), (19, 2), (58, 2), (64, 2), (68, 2), (115, 1), (120, 1), (293, 2)], [(0, 1), (2, 1), (3, 1), (4, 1), (7, 2), (8, 2), (12, 1), (13, 1), (16, 1), (18, 2), (19, 2), (64, 1), (68, 2), (120, 2), (293, 2)], [], [], [(0, 1), (2, 1), (3, 1), (4, 1), (7, 2), (8, 2), (12, 1), (13, 1), (16, 1), (18, 2), (19, 2), (64, 1), (68, 2), (120, 1), (181, 1), (293, 2)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (12, 2), (13, 1), (14, 1), (16, 2), (18, 1), (19, 1), (64, 1), (68, 2), (120, 2), (293, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 1), (8, 1), (13, 2), (16, 1), (18, 2), (19, 2), (64, 2), (68, 1), (120, 1), (293, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 2), (8, 1), (10, 1), (12, 1), (13, 2), (14, 2), (16, 1), (18, 2), (19, 2), (64, 2), (68, 1), (120, 1), (293, 2)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 2), (8, 1), (12, 1), (13, 2), (14, 2), (16, 1), (18, 2), (19, 2), (22, 1), (64, 2), (68, 1), (120, 1), (293, 2)], [(0, 2), (2, 2), (3, 1), (4, 2), (7, 1), (8, 1), (12, 2), (13, 1), (14, 1), (16, 2), (18, 1), (19, 1), (64, 1), (66, 1), (68, 1), (120, 2), (293, 1)], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (12, 2), (13, 1), (16, 2), (18, 1), (19, 1), (64, 1), (68, 1), (73, 1), (120, 2), (293, 1)], [(2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (8, 1), (11, 1), (12, 2), (13, 1), (14, 1), (16, 1), (18, 2), (64, 1), (68, 1), (71, 1), (120, 2), (293, 1)], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (8, 1), (11, 2), (13, 2), (16, 1), (18, 2), (19, 2), (58, 2), (64, 2), (68, 2), (120, 1), (137, 1), (293, 2)], [(0, 2), (1, 2), (2, 1), (4, 2), (6, 2), (7, 1), (8, 2), (13, 2), (14, 2), (16, 2), (18, 1), (19, 1), (51, 1), (64, 1), (68, 2), (120, 2), (293, 1)], [(4, 2), (9, 2), (13, 1), (16, 2), (18, 1), (57, 2), (64, 2), (68, 2), (120, 1), (293, 2), (314, 1)], [(0, 2), (2, 1), (4, 2), (6, 2), (7, 1), (8, 2), (13, 2), (14, 2), (16, 2), (18, 1), (44, 1), (64, 2), (68, 1), (120, 1), (293, 2)], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (13, 2), (14, 1), (19, 1), (64, 1), (68, 2), (120, 1), (157, 1), (293, 2)], [], [(0, 2), (2, 1), (4, 2), (8, 2), (13, 2), (14, 2), (16, 2), (19, 1), (64, 1), (68, 2), (120, 1), (216, 1), (293, 2)], [(0, 2), (2, 1), (4, 2), (8, 2), (13, 2), (14, 2), (16, 2), (19, 1), (64, 1), (68, 2), (120, 1), (274, 1), (293, 2)], [], [], [(0, 2), (2, 1), (3, 2), (8, 2), (9, 1), (19, 1), (57, 1), (64, 2), (120, 1), (293, 2)], [], [], [], [], [], [], [], [], [], [(2, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (64, 1), (68, 2), (120, 2), (130, 1)], [], [], [], [], [(2, 1), (4, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (16, 1)], [], [(2, 1), (3, 2), (6, 1), (8, 2), (12, 2), (14, 1)], [], [], [], [], [], []] + +def comb16 : List (List (Nat × Nat)) := [[], [(0, 1), (4, 2), (8, 2), (13, 1), (14, 2), (16, 1), (19, 2), (21, 1), (24, 1), (58, 1), (172, 1), (173, 2)], [], [(0, 2), (4, 1), (8, 2), (9, 2), (11, 1), (13, 1), (14, 2), (16, 1), (19, 1), (21, 2), (24, 1), (172, 1)], [], [], [(0, 2), (4, 2), (8, 2), (13, 1), (14, 2), (16, 1), (18, 1), (19, 1), (21, 1), (24, 1)], [], [], [(0, 2), (4, 1), (8, 2), (9, 2), (11, 1), (13, 1), (14, 2), (16, 1), (18, 1), (19, 1), (21, 2), (24, 1)], [], [], [], [], [(0, 1), (4, 2), (8, 1), (13, 2), (14, 2), (16, 1), (19, 2), (21, 1), (24, 2)], [(0, 2), (2, 2), (4, 2), (8, 2), (13, 1), (14, 2), (16, 1), (19, 1), (20, 1), (21, 1), (24, 2)], [], [(0, 1), (4, 2), (8, 2), (9, 1), (11, 2), (13, 2), (14, 1), (16, 2), (19, 2), (21, 1), (24, 1)], [(0, 2), (4, 1), (8, 1), (9, 2), (11, 1), (13, 2), (14, 2), (16, 1), (19, 1), (21, 2), (24, 2)], [(0, 2), (4, 1), (8, 2), (9, 2), (11, 1), (13, 1), (14, 2), (16, 1), (19, 1), (21, 2), (24, 2)], [], [(0, 1), (4, 2), (8, 2), (13, 2), (14, 1), (16, 2), (19, 2), (21, 1), (24, 1)], [(0, 2), (3, 2), (4, 2), (8, 2), (11, 1), (18, 1), (19, 1), (21, 1), (24, 1), (58, 1), (64, 1), (66, 1), (172, 1), (173, 2)], [], [(2, 2), (3, 2), (4, 2), (11, 1), (13, 2), (18, 1), (19, 1), (21, 1), (24, 1), (58, 1), (66, 2), (172, 1), (173, 2)], [(0, 2), (3, 2), (4, 2), (8, 2), (11, 1), (18, 1), (19, 1), (21, 1), (24, 1), (58, 1), (66, 2), (172, 1), (173, 2)], [], [(2, 2), (3, 2), (4, 1), (5, 1), (8, 2), (9, 2), (11, 2), (13, 2), (14, 1), (16, 2), (18, 1), (21, 2), (24, 2), (58, 1), (66, 2), (172, 1), (173, 2)], [], [(0, 2), (3, 2), (4, 2), (8, 2), (9, 1), (11, 1), (18, 2), (19, 1), (58, 1), (60, 1), (66, 1), (172, 1), (173, 2)], [], [], [(2, 1), (3, 1), (4, 1), (9, 1), (11, 1), (13, 1), (14, 2), (16, 1), (18, 1), (21, 2), (24, 2), (58, 2), (66, 1), (172, 2), (173, 1)], [], [(1, 2), (3, 1), (8, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (18, 2), (21, 1), (24, 1), (58, 1), (66, 2), (172, 1), (173, 2)], [(3, 1), (4, 2), (8, 2), (11, 2), (13, 2), (14, 1), (16, 2), (18, 2), (21, 1), (24, 1), (58, 1), (66, 2), (172, 1), (173, 2)], [], [(3, 1), (4, 2), (8, 2), (9, 2), (11, 2), (13, 2), (14, 2), (16, 2), (18, 2), (21, 1), (24, 1), (58, 1), (66, 2), (172, 1), (173, 2)], [], [], [(0, 1), (1, 1), (3, 2), (4, 2), (9, 1), (11, 1), (13, 2), (18, 1), (19, 2), (58, 2), (66, 1), (172, 2), (173, 1)], [], [(0, 2), (3, 2), (4, 2), (8, 2), (11, 2), (13, 2), (14, 1), (16, 2), (18, 1), (19, 1), (21, 1), (24, 1), (58, 2), (66, 1), (172, 2), (173, 1)], [], [(2, 1), (3, 1), (4, 1), (9, 1), (11, 1), (13, 1), (14, 2), (16, 1), (18, 2), (19, 2), (21, 2), (24, 2), (58, 2), (66, 1), (172, 1), (173, 2)], [], [(0, 2), (3, 1), (8, 2), (11, 1), (13, 2), (14, 1), (16, 2), (18, 1), (19, 1), (21, 1), (24, 1), (58, 2), (60, 2), (66, 2), (117, 1), (172, 2), (173, 1)], [], [(0, 2), (3, 1), (4, 2), (8, 2), (11, 2), (13, 2), (14, 1), (16, 2), (18, 1), (19, 1), (21, 1), (24, 1), (58, 2), (64, 2), (66, 2), (120, 1), (172, 2), (173, 1)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (8, 2), (9, 2), (11, 2), (13, 2), (14, 1), (16, 2), (18, 1), (19, 1), (20, 2), (21, 2), (24, 1), (58, 2), (60, 2), (66, 2), (172, 2), (173, 1), (236, 1)], [], [], [], [(0, 1), (3, 1), (4, 1), (11, 1), (13, 1), (14, 2), (16, 1), (18, 1), (19, 2), (58, 1), (66, 2), (172, 1), (173, 2)], [], [], [(0, 2), (2, 1), (3, 1), (5, 2), (8, 2), (10, 1), (11, 2), (13, 2), (14, 1), (16, 2), (18, 2), (19, 1), (58, 2), (66, 1), (172, 2), (173, 1)], [], [(0, 2), (2, 1), (3, 1), (5, 2), (8, 2), (11, 2), (13, 2), (14, 2), (16, 1), (17, 1), (18, 2), (19, 1), (58, 2), (66, 1), (172, 2), (173, 1)], [], [], [(1, 1), (3, 2), (9, 1), (11, 1), (13, 2), (14, 1), (15, 2), (16, 2), (18, 1), (21, 2), (24, 2), (58, 1), (65, 1), (66, 1), (172, 1), (173, 2)], [], [(0, 1), (3, 2), (9, 1), (11, 1), (13, 1), (14, 1), (16, 1), (18, 1), (19, 2), (58, 1), (66, 1), (73, 1), (172, 1), (173, 2)], [], [(2, 1), (3, 1), (4, 2), (5, 2), (9, 2), (13, 2), (14, 1), (16, 2), (18, 1), (21, 1), (24, 2), (58, 1), (66, 1), (80, 1), (172, 1), (173, 2)], [], [(1, 2), (2, 1), (4, 1), (5, 2), (8, 2), (9, 2), (11, 2), (13, 2), (14, 2), (16, 1), (18, 2), (21, 1), (24, 1), (58, 2), (60, 2), (66, 2), (127, 1), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (5, 1), (8, 1), (9, 2), (11, 2), (13, 1), (14, 2), (16, 1), (17, 2), (18, 2), (19, 1), (51, 1), (58, 1), (66, 2), (172, 1), (173, 2)], [(0, 1), (2, 2), (3, 2), (5, 1), (8, 1), (9, 2), (11, 2), (13, 1), (14, 2), (16, 1), (17, 2), (18, 1), (19, 2), (57, 2), (58, 2), (66, 2), (172, 2), (173, 1), (314, 1)], [(3, 2), (4, 1), (8, 1), (11, 2), (13, 1), (14, 2), (18, 2), (19, 2), (21, 2), (24, 2), (44, 1), (58, 2), (66, 1), (172, 2), (173, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (8, 2), (11, 2), (14, 2), (18, 2), (19, 2), (21, 2), (24, 2), (58, 2), (64, 2), (66, 2), (157, 1), (172, 2), (173, 1)], [(0, 2), (2, 2), (3, 2), (4, 1), (8, 2), (9, 2), (11, 2), (18, 2), (19, 2), (21, 2), (24, 2), (58, 1), (66, 2), (120, 2), (172, 2), (173, 1), (392, 1)], [], [(0, 1), (3, 1), (4, 1), (8, 1), (9, 2), (14, 1), (16, 2), (18, 2), (19, 2), (21, 2), (24, 2), (58, 2), (64, 2), (66, 2), (172, 2), (173, 1), (274, 1)], [], [], [(9, 1), (11, 2), (14, 2), (16, 1), (57, 1), (58, 2), (172, 2), (173, 1)], [], [], [], [], [], [], [], [], [], [(3, 1), (9, 1), (11, 2), (14, 2), (64, 1), (66, 2), (120, 2), (130, 1)], [], [], [], [], [(9, 1), (11, 2), (14, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb17 : List (List (Nat × Nat)) := [[], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 1), (12, 2), (17, 1), (18, 1), (19, 2), (66, 1), (233, 1), (234, 2)], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (7, 1), (11, 1), (12, 2), (17, 1), (18, 1), (19, 1), (233, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (7, 1), (12, 2), (17, 1), (18, 1), (19, 2), (24, 1), (25, 2)], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (7, 1), (11, 1), (12, 2), (17, 1), (18, 1), (19, 1), (24, 1)], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (7, 1), (11, 1), (12, 2), (17, 1), (18, 2), (19, 1), (57, 2), (63, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (7, 1), (12, 2), (17, 1), (18, 2), (19, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 2), (12, 1), (16, 2), (17, 2), (18, 2), (19, 1), (20, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (11, 2), (12, 1), (17, 2), (18, 1), (19, 2)], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (7, 1), (11, 1), (12, 2), (17, 1), (18, 2), (19, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (17, 2), (18, 1), (19, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (11, 1), (15, 1), (16, 2), (18, 2), (19, 1), (24, 1), (25, 2), (57, 1), (63, 2), (64, 1), (65, 2), (233, 1), (234, 2)], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (11, 1), (15, 1), (16, 2), (18, 2), (19, 1), (24, 1), (25, 2), (65, 2), (66, 1), (233, 1), (234, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (11, 1), (15, 1), (16, 2), (18, 2), (19, 1), (24, 1), (25, 2), (65, 2), (66, 1), (233, 1), (234, 2)], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (7, 1), (11, 2), (12, 1), (15, 1), (16, 2), (17, 2), (24, 1), (25, 2), (65, 2), (66, 1), (233, 1), (234, 2)], [], [], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1), (24, 2), (25, 1), (60, 1), (65, 1), (66, 1), (233, 1), (234, 2)], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 1), (11, 2), (12, 1), (15, 2), (16, 1), (17, 2), (24, 2), (25, 1), (58, 1), (65, 1), (66, 1), (233, 1), (234, 2)], [], [], [(1, 2), (2, 2), (3, 2), (4, 2), (5, 1), (6, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (18, 1), (19, 2), (24, 1), (25, 2), (65, 1), (66, 2), (233, 2), (234, 1)], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1), (24, 2), (25, 1), (65, 2), (66, 1), (233, 1), (234, 2)], [], [(1, 1), (3, 2), (4, 1), (5, 2), (6, 1), (11, 2), (12, 2), (15, 1), (16, 2), (17, 2), (18, 2), (19, 1), (24, 2), (25, 1), (65, 2), (66, 1), (233, 1), (234, 2)], [], [], [], [(0, 1), (2, 1), (5, 1), (6, 2), (7, 1), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1), (24, 1), (25, 2), (65, 1), (66, 2), (233, 2), (234, 1)], [(0, 2), (1, 2), (2, 1), (5, 1), (6, 1), (7, 1), (11, 2), (12, 1), (15, 2), (16, 1), (17, 2), (24, 1), (25, 2), (65, 1), (66, 2), (233, 2), (234, 1)], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (18, 1), (19, 2), (24, 2), (25, 1), (65, 1), (66, 2), (233, 1), (234, 2)], [(0, 1), (2, 1), (5, 1), (6, 2), (11, 1), (12, 1), (15, 1), (16, 2), (17, 2), (18, 2), (19, 1), (24, 1), (25, 2), (60, 2), (65, 2), (66, 2), (117, 1), (233, 2), (234, 1)], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 1), (11, 2), (12, 1), (15, 1), (16, 2), (17, 2), (18, 2), (19, 1), (24, 1), (25, 2), (58, 2), (65, 2), (66, 2), (115, 1), (233, 2), (234, 1)], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (11, 2), (12, 2), (15, 1), (17, 1), (18, 2), (19, 1), (20, 2), (24, 1), (25, 2), (60, 2), (65, 2), (66, 2), (174, 1), (233, 2), (234, 1)], [], [], [], [], [], [(0, 2), (2, 2), (5, 2), (6, 1), (11, 1), (12, 2), (15, 1), (16, 2), (17, 1), (18, 1), (19, 2), (24, 1), (25, 2), (65, 2), (66, 1), (233, 1), (234, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 1), (11, 2), (12, 1), (15, 2), (16, 1), (17, 2), (18, 2), (19, 1), (24, 2), (25, 1), (65, 1), (66, 2), (233, 2), (234, 1)], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 1), (11, 2), (12, 2), (15, 2), (16, 2), (17, 1), (18, 2), (19, 1), (24, 2), (25, 1), (65, 1), (66, 2), (233, 2), (234, 1)], [], [], [], [], [(0, 2), (3, 2), (4, 1), (5, 1), (6, 1), (11, 1), (12, 2), (15, 1), (16, 2), (17, 1), (18, 1), (19, 2), (24, 1), (25, 2), (65, 1), (66, 1), (67, 1), (233, 1), (234, 2)], [], [(0, 2), (3, 2), (4, 1), (5, 1), (6, 1), (11, 1), (12, 2), (15, 1), (16, 2), (17, 1), (18, 1), (19, 2), (24, 1), (25, 2), (57, 1), (60, 2), (63, 2), (65, 2), (66, 1), (71, 1), (233, 1), (234, 2)], [(0, 2), (3, 2), (4, 1), (5, 1), (6, 2), (12, 1), (15, 1), (16, 2), (17, 2), (24, 1), (25, 2), (57, 1), (58, 2), (63, 2), (65, 2), (66, 1), (80, 1), (233, 1), (234, 2)], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (11, 2), (12, 2), (15, 1), (16, 2), (17, 2), (18, 1), (19, 2), (24, 2), (25, 1), (58, 2), (65, 2), (66, 2), (115, 1), (130, 1), (131, 2), (233, 2), (234, 1)], [], [], [(0, 2), (2, 2), (5, 2), (6, 1), (7, 2), (11, 2), (15, 1), (16, 2), (18, 1), (19, 2), (24, 2), (25, 1), (51, 1), (65, 2), (66, 1), (233, 1), (234, 2)], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 1), (11, 2), (15, 1), (16, 2), (18, 1), (19, 2), (24, 1), (25, 2), (57, 2), (65, 2), (66, 2), (233, 2), (234, 1), (314, 1)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (11, 2), (15, 2), (16, 1), (18, 1), (19, 2), (24, 2), (25, 1), (44, 1), (65, 1), (66, 2), (233, 2), (234, 1)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (11, 2), (15, 2), (16, 1), (18, 1), (19, 2), (24, 2), (25, 1), (57, 2), (63, 1), (64, 2), (65, 1), (157, 1), (233, 2), (234, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (11, 2), (15, 2), (16, 1), (18, 1), (19, 2), (24, 2), (25, 1), (57, 2), (63, 1), (64, 2), (65, 1), (233, 2), (234, 1), (392, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (17, 2), (18, 1), (19, 2), (24, 2), (25, 1), (57, 2), (63, 1), (64, 2), (65, 1), (216, 1), (233, 2), (234, 1)], [], [], [], [(0, 2), (2, 1), (7, 1), (11, 2), (12, 2), (17, 1), (57, 1), (66, 2), (233, 2), (234, 1)], [], [], [], [], [], [], [], [], [], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 2), (11, 2), (12, 2), (15, 1), (16, 2), (18, 1), (19, 2), (58, 1), (65, 2), (115, 2), (131, 1)], [], [], [], [], [(7, 1), (11, 2), (12, 2), (17, 1)], [], [], [], [], [], [], [], []] + +def comb18 : List (List (Nat × Nat)) := [[], [], [(3, 1), (4, 2), (7, 2), (10, 2), (11, 2), (12, 1), (14, 1), (16, 2), (20, 2), (21, 1), (121, 1), (172, 1), (173, 2)], [(3, 1), (4, 2), (7, 2), (9, 2), (11, 2), (12, 1), (14, 1), (16, 2), (19, 2), (20, 2), (21, 2), (172, 1)], [], [], [], [(3, 1), (4, 2), (7, 2), (11, 2), (12, 1), (14, 1), (16, 2), (18, 1), (19, 2), (20, 2), (21, 1)], [], [(3, 1), (4, 2), (7, 2), (9, 2), (11, 2), (12, 1), (14, 1), (16, 2), (18, 1), (19, 2), (20, 2), (21, 2)], [], [(3, 1), (4, 2), (7, 1), (11, 1), (12, 2), (16, 1), (18, 2), (19, 1), (20, 1), (21, 1), (66, 1), (73, 2), (75, 1)], [], [], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (12, 1), (19, 1), (20, 1), (21, 1)], [], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 1), (12, 1), (20, 1), (21, 2)], [], [], [(2, 1), (3, 1), (4, 2), (7, 2), (11, 1), (12, 1), (20, 1), (21, 2)], [], [(3, 1), (4, 2), (7, 1), (11, 2), (12, 2), (20, 2), (21, 1)], [(2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 1), (12, 1), (14, 2), (16, 1), (18, 1), (19, 2), (20, 1), (21, 2), (60, 1), (64, 1), (66, 2), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [(2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 1), (12, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 1), (21, 2), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [], [(2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 1), (12, 1), (14, 2), (16, 1), (18, 1), (19, 2), (20, 1), (21, 2), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [], [(2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (10, 1), (12, 1), (14, 2), (16, 1), (18, 1), (19, 2), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (11, 1), (12, 1), (18, 2), (19, 1), (20, 1), (21, 2), (60, 2), (67, 1), (117, 1), (121, 2), (172, 1), (173, 2)], [(2, 1), (3, 1), (4, 2), (6, 2), (8, 1), (10, 1), (11, 1), (12, 1), (18, 2), (19, 1), (20, 1), (21, 2), (60, 2), (67, 1), (117, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [(2, 1), (3, 1), (6, 1), (7, 1), (8, 2), (12, 1), (18, 2), (19, 1), (20, 1), (21, 2), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [(2, 2), (6, 2), (7, 1), (8, 1), (14, 1), (18, 2), (19, 1), (20, 1), (21, 2), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (11, 1), (12, 1), (18, 1), (19, 2), (20, 1), (21, 2), (60, 2), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [], [], [(2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (11, 1), (18, 1), (19, 2), (60, 2), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (10, 2), (11, 1), (12, 1), (18, 1), (19, 2), (20, 1), (21, 2), (60, 2), (67, 2), (117, 1), (121, 2), (172, 2), (173, 1)], [], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (18, 1), (19, 2), (60, 2), (66, 1), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [], [(2, 1), (6, 1), (7, 2), (8, 2), (9, 2), (10, 1), (12, 2), (18, 2), (19, 1), (20, 2), (21, 1), (60, 2), (67, 1), (115, 1), (117, 1), (121, 1), (172, 1), (173, 2)], [], [], [(5, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 1), (18, 1), (19, 2), (60, 1), (67, 2), (117, 1), (121, 2), (172, 2), (173, 1), (236, 1)], [], [], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (11, 2), (12, 1), (14, 1), (16, 2), (18, 2), (19, 1), (20, 1), (21, 2), (60, 2), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [], [(2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (10, 2), (11, 1), (14, 1), (16, 2), (18, 2), (19, 1), (20, 1), (21, 2), (60, 2), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [(2, 1), (6, 1), (7, 2), (8, 2), (11, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 2), (21, 1), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [], [], [(2, 2), (6, 2), (7, 2), (8, 1), (10, 2), (11, 1), (12, 2), (14, 2), (16, 1), (17, 1), (18, 2), (19, 1), (20, 1), (21, 2), (60, 2), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [], [], [(2, 1), (6, 2), (7, 1), (8, 1), (10, 1), (11, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 2), (21, 1), (60, 1), (65, 1), (67, 1), (117, 2), (121, 1), (172, 1), (173, 2)], [], [], [(2, 2), (6, 1), (7, 2), (8, 2), (10, 1), (11, 1), (14, 1), (16, 2), (18, 2), (19, 1), (20, 1), (21, 2), (60, 1), (67, 2), (71, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [], [(2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (10, 1), (11, 2), (14, 1), (16, 1), (18, 1), (19, 2), (20, 1), (21, 2), (60, 2), (67, 1), (117, 1), (121, 1), (130, 1), (172, 1), (173, 2)], [], [(2, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 2), (60, 2), (67, 1), (117, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [(2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (10, 1), (11, 2), (14, 2), (16, 1), (17, 2), (18, 2), (19, 1), (20, 2), (21, 1), (51, 1), (60, 1), (67, 2), (117, 2), (121, 1), (172, 1), (173, 2)], [(2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (10, 1), (11, 2), (14, 2), (16, 1), (17, 2), (18, 1), (19, 2), (20, 2), (21, 1), (60, 1), (67, 2), (117, 2), (121, 1), (172, 2), (173, 1), (314, 1)], [(2, 2), (3, 2), (4, 1), (6, 1), (8, 1), (12, 2), (16, 2), (18, 2), (19, 1), (20, 2), (21, 1), (44, 1), (60, 2), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [(2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (12, 2), (14, 1), (16, 2), (18, 2), (19, 1), (20, 2), (21, 1), (60, 2), (64, 2), (66, 1), (67, 1), (99, 1), (117, 1), (121, 2), (172, 2), (173, 1)], [], [(2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (12, 2), (14, 1), (16, 2), (18, 2), (19, 1), (20, 2), (21, 1), (60, 2), (64, 2), (66, 1), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1), (392, 1)], [], [(2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (12, 1), (14, 2), (16, 1), (18, 2), (19, 1), (20, 2), (21, 1), (60, 2), (64, 2), (66, 1), (67, 1), (117, 1), (121, 2), (172, 2), (173, 1), (274, 1)], [], [], [], [(2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (10, 1), (12, 1), (14, 2), (16, 1), (114, 1), (121, 2), (172, 2), (173, 1)], [], [], [], [], [(2, 2), (3, 1), (4, 2), (7, 2), (8, 1), (12, 1), (14, 2), (16, 1), (18, 2), (19, 1)], [], [], [], [], [(3, 1), (4, 2), (9, 1), (14, 2), (66, 2), (73, 1)], [], [], [], [(2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (12, 1), (14, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb19 : List (List (Nat × Nat)) := [[], [], [], [(1, 1), (3, 1), (4, 2), (7, 2), (12, 1), (15, 2), (16, 1), (19, 1), (21, 2), (57, 1), (72, 2), (172, 1)], [], [], [], [], [(1, 1), (3, 1), (4, 2), (7, 2), (12, 1), (14, 1), (15, 2), (16, 1), (18, 1), (19, 1), (21, 1), (57, 1), (72, 2)], [(1, 1), (3, 1), (4, 2), (7, 2), (12, 1), (15, 2), (16, 1), (18, 1), (19, 1), (21, 2), (57, 1), (72, 2)], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (7, 2), (12, 1), (14, 1), (15, 2), (16, 1), (19, 1), (21, 1), (57, 1), (64, 2), (66, 1), (72, 1), (77, 1)], [], [], [(1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (14, 1), (15, 1), (16, 1), (19, 1), (20, 1), (21, 1), (57, 1), (72, 2)], [(1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (12, 1), (15, 2), (16, 1), (19, 1), (21, 2), (57, 1), (72, 2)], [], [(1, 1), (3, 1), (4, 2), (7, 2), (12, 1), (15, 2), (16, 1), (19, 1), (21, 2), (57, 2), (72, 2)], [], [(1, 2), (3, 2), (4, 1), (7, 1), (12, 2), (15, 1), (16, 2), (19, 2), (21, 1), (57, 2), (72, 1)], [(1, 2), (3, 1), (4, 2), (7, 1), (12, 2), (15, 1), (16, 2), (19, 2), (21, 1), (57, 2), (72, 1)], [(0, 2), (3, 1), (4, 2), (6, 2), (12, 1), (15, 2), (16, 1), (18, 1), (21, 2), (64, 1), (66, 2), (67, 2), (72, 2), (121, 1), (172, 1), (173, 2)], [(3, 1), (4, 2), (6, 1), (12, 2), (15, 2), (16, 1), (18, 1), (21, 2), (67, 2), (72, 1), (121, 1), (172, 1), (173, 2)], [(3, 1), (4, 2), (6, 2), (12, 1), (15, 2), (16, 1), (18, 1), (21, 2), (57, 2), (67, 2), (72, 2), (121, 1), (172, 1), (173, 2)], [], [], [(1, 2), (3, 1), (4, 2), (6, 2), (7, 1), (17, 1), (18, 1), (19, 2), (57, 2), (67, 2), (72, 2), (121, 1), (172, 1), (173, 2)], [(1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (18, 2), (19, 2), (21, 2), (67, 1), (72, 2), (121, 2), (172, 1), (173, 2)], [], [], [(3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (18, 2), (19, 2), (21, 2), (57, 2), (67, 2), (72, 2), (121, 1), (172, 1), (173, 2)], [], [(1, 2), (3, 1), (6, 1), (7, 1), (12, 1), (18, 2), (19, 2), (21, 2), (57, 2), (67, 2), (72, 2), (121, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 2), (6, 2), (7, 1), (9, 1), (18, 2), (19, 2), (21, 2), (57, 2), (67, 2), (121, 1), (172, 1), (173, 2)], [(1, 1), (6, 1), (7, 2), (14, 2), (18, 1), (19, 1), (21, 1), (57, 1), (67, 1), (72, 1), (121, 2), (172, 2), (173, 1)], [], [], [(1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (18, 1), (21, 2), (67, 1), (72, 2), (121, 2), (172, 2), (173, 1)], [(3, 1), (4, 2), (6, 2), (12, 1), (15, 2), (16, 1), (18, 1), (21, 2), (57, 2), (67, 1), (72, 2), (121, 2), (172, 2), (173, 1)], [], [(1, 2), (3, 1), (4, 2), (6, 2), (7, 1), (15, 2), (16, 1), (18, 1), (19, 2), (57, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (9, 2), (12, 1), (15, 2), (16, 1), (18, 1), (19, 2), (57, 2), (66, 1), (67, 1), (72, 2), (121, 2), (172, 2), (173, 1)], [], [], [(1, 2), (4, 2), (6, 2), (7, 1), (15, 2), (16, 1), (18, 1), (19, 2), (57, 2), (64, 2), (66, 1), (67, 1), (120, 1), (121, 2), (172, 2), (173, 1)], [(6, 1), (12, 2), (14, 2), (15, 1), (18, 2), (19, 1), (20, 2), (21, 1), (57, 1), (67, 1), (72, 1), (121, 2), (172, 1), (173, 1), (174, 1)], [], [], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (18, 2), (19, 2), (21, 2), (57, 2), (67, 1), (72, 2), (121, 2), (172, 2), (173, 1)], [], [], [(1, 2), (3, 1), (4, 2), (5, 1), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (17, 2), (18, 2), (19, 2), (21, 2), (57, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [], [(1, 2), (6, 2), (10, 1), (12, 1), (15, 2), (16, 1), (17, 2), (18, 2), (19, 2), (21, 2), (57, 2), (67, 1), (121, 2), (172, 2), (173, 1)], [(1, 1), (6, 1), (7, 2), (14, 2), (15, 1), (18, 1), (19, 1), (21, 1), (57, 1), (67, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [], [(1, 2), (6, 1), (7, 1), (12, 1), (15, 2), (16, 1), (17, 2), (18, 2), (19, 2), (21, 2), (57, 2), (67, 2), (121, 2), (172, 2), (173, 1)], [(0, 2), (1, 1), (6, 2), (7, 2), (9, 1), (12, 2), (14, 2), (15, 1), (16, 2), (18, 1), (19, 1), (21, 1), (57, 1), (66, 2), (67, 2), (72, 1), (73, 1), (121, 1), (172, 1), (173, 2)], [], [], [(1, 1), (3, 1), (6, 1), (7, 2), (14, 2), (15, 1), (16, 2), (18, 1), (19, 1), (21, 1), (57, 1), (64, 1), (66, 2), (67, 2), (120, 2), (121, 1), (130, 1), (172, 1), (173, 2)], [], [], [(3, 2), (4, 1), (6, 1), (12, 2), (15, 1), (16, 2), (18, 2), (21, 1), (51, 1), (57, 1), (67, 2), (72, 1), (121, 1), (172, 1), (173, 2)], [(1, 1), (3, 2), (4, 1), (6, 2), (7, 2), (12, 2), (15, 1), (16, 2), (18, 1), (19, 1), (21, 1), (67, 2), (72, 1), (121, 1), (172, 2), (173, 1), (314, 1)], [(3, 2), (4, 1), (6, 1), (12, 2), (15, 1), (16, 2), (18, 2), (21, 1), (44, 1), (57, 1), (67, 1), (72, 1), (121, 2), (172, 2), (173, 1)], [(0, 2), (3, 2), (4, 1), (6, 1), (9, 2), (12, 2), (14, 1), (15, 1), (16, 2), (18, 2), (21, 1), (64, 2), (66, 1), (67, 1), (99, 1), (121, 2), (172, 2), (173, 1)], [(0, 1), (3, 2), (4, 1), (6, 1), (12, 2), (15, 1), (16, 2), (18, 2), (21, 1), (64, 2), (66, 1), (67, 1), (72, 1), (121, 2), (157, 1), (172, 2), (173, 1)], [], [], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 2), (12, 1), (14, 1), (15, 2), (16, 1), (18, 2), (21, 1), (64, 2), (66, 1), (67, 1), (72, 1), (121, 2), (172, 2), (173, 1), (274, 1)], [], [], [], [], [(3, 1), (5, 2), (15, 1), (16, 2), (17, 1), (64, 1), (66, 2), (67, 1), (72, 2), (120, 2), (121, 2), (172, 2), (173, 1), (293, 1)], [], [], [], [], [(1, 1), (3, 1), (4, 2), (7, 2), (12, 1), (13, 1), (14, 2), (15, 2), (16, 1), (18, 2), (19, 1), (72, 2)], [], [], [], [], [(3, 1), (4, 2), (66, 2), (68, 1)], [], [], [], [(0, 1), (3, 1), (4, 2), (6, 2), (9, 2), (11, 1), (12, 1), (72, 2)], [], [], [], [], [], [], []] + +def comb20 : List (List (Nat × Nat)) := [[], [], [], [], [(0, 2), (1, 1), (2, 1), (4, 2), (5, 2), (7, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (233, 1)], [], [], [], [(0, 1), (1, 2), (2, 1), (4, 1), (5, 2), (7, 1), (8, 1), (9, 2), (12, 2), (15, 2), (19, 2), (24, 1), (25, 2)], [], [(0, 2), (1, 1), (2, 1), (4, 2), (5, 2), (7, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 1)], [], [(0, 2), (1, 1), (2, 1), (4, 1), (5, 2), (7, 2), (8, 1), (9, 2), (12, 1), (15, 2), (19, 1), (63, 1), (64, 2), (77, 1)], [(0, 2), (1, 1), (2, 1), (4, 2), (5, 2), (7, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (63, 1)], [], [(0, 2), (1, 2), (4, 1), (5, 2), (7, 2), (9, 1), (10, 2), (12, 2), (15, 1), (19, 1), (20, 1)], [], [(0, 2), (1, 1), (2, 1), (4, 2), (5, 2), (7, 2), (8, 2), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1)], [], [(0, 1), (1, 2), (2, 2), (4, 1), (5, 1), (7, 1), (8, 2), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (19, 2)], [], [(0, 1), (1, 2), (2, 1), (4, 1), (5, 2), (7, 1), (8, 2), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (19, 2)], [(1, 1), (4, 2), (5, 2), (7, 2), (9, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 1), (25, 2), (63, 1), (64, 1), (121, 1), (233, 1), (234, 2)], [(1, 1), (4, 2), (5, 2), (7, 2), (8, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 1), (25, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [(0, 1), (1, 1), (2, 2), (4, 2), (5, 2), (7, 2), (9, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 1), (25, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [], [(0, 1), (5, 2), (8, 2), (9, 2), (14, 2), (16, 1), (24, 1), (25, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [], [(1, 1), (4, 2), (5, 2), (7, 2), (8, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 2), (25, 1), (63, 1), (121, 2), (233, 1), (234, 2)], [], [(1, 1), (2, 2), (4, 2), (7, 2), (8, 2), (9, 2), (12, 1), (14, 2), (16, 1), (19, 1), (24, 2), (25, 1), (58, 1), (63, 2), (72, 2), (121, 1), (233, 1), (234, 2)], [(1, 2), (2, 2), (4, 1), (7, 2), (8, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 2), (25, 1), (63, 2), (121, 1), (233, 1), (234, 2)], [(1, 1), (4, 2), (7, 2), (8, 1), (14, 2), (16, 1), (19, 1), (24, 2), (25, 1), (63, 2), (121, 1), (233, 1), (234, 2)], [], [], [], [], [(1, 2), (2, 1), (4, 1), (7, 1), (8, 1), (12, 2), (14, 2), (16, 2), (19, 2), (24, 1), (25, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [], [(0, 1), (5, 1), (7, 2), (8, 2), (9, 2), (10, 1), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 1), (25, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [(0, 1), (1, 1), (2, 2), (4, 2), (5, 2), (7, 2), (9, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 1), (25, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [(0, 2), (2, 2), (5, 2), (9, 1), (12, 1), (14, 2), (15, 2), (16, 1), (24, 1), (25, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 1), (5, 2), (8, 2), (9, 2), (14, 2), (15, 2), (16, 1), (24, 1), (25, 2), (63, 1), (72, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (2, 2), (5, 2), (9, 1), (14, 2), (15, 2), (16, 1), (24, 1), (25, 2), (58, 2), (63, 1), (72, 1), (115, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (1, 2), (2, 2), (4, 1), (9, 1), (10, 1), (12, 2), (14, 1), (15, 1), (16, 2), (20, 2), (24, 2), (25, 1), (63, 1), (121, 2), (233, 1), (234, 1), (236, 1)], [], [(0, 1), (1, 1), (2, 2), (4, 2), (5, 2), (7, 2), (8, 2), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (24, 2), (25, 1), (63, 1), (121, 2), (233, 2), (234, 1)], [], [(0, 1), (1, 1), (2, 2), (5, 2), (7, 2), (8, 2), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (19, 1), (24, 2), (25, 1), (63, 1), (121, 2), (233, 2), (234, 1)], [], [(0, 1), (1, 1), (2, 1), (4, 2), (9, 2), (10, 2), (12, 1), (14, 2), (15, 2), (16, 1), (19, 1), (24, 2), (25, 1), (63, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (1, 2), (2, 2), (4, 1), (7, 1), (9, 1), (12, 1), (14, 2), (15, 1), (16, 1), (17, 1), (19, 2), (24, 1), (25, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [], [], [(0, 1), (1, 1), (2, 1), (4, 2), (7, 2), (8, 2), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (19, 1), (24, 2), (25, 1), (63, 1), (65, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (2, 1), (5, 1), (7, 1), (8, 2), (9, 1), (10, 2), (12, 2), (14, 1), (16, 2), (19, 2), (24, 1), (25, 2), (63, 1), (71, 1), (121, 1), (233, 1), (234, 2)], [], [], [(0, 2), (1, 2), (2, 2), (4, 1), (7, 1), (8, 1), (9, 1), (12, 2), (14, 1), (16, 2), (19, 2), (24, 1), (25, 2), (63, 1), (121, 1), (127, 1), (233, 1), (234, 2)], [], [(0, 2), (1, 2), (5, 2), (7, 1), (8, 1), (9, 1), (14, 1), (15, 1), (16, 2), (17, 2), (19, 2), (24, 2), (25, 1), (51, 1), (63, 2), (121, 1), (233, 1), (234, 2)], [(1, 2), (4, 1), (5, 1), (8, 1), (10, 1), (14, 1), (15, 1), (16, 2), (17, 2), (19, 2), (24, 1), (25, 2), (63, 2), (121, 1), (233, 2), (234, 1), (314, 1)], [(0, 2), (1, 2), (4, 1), (5, 1), (7, 1), (8, 1), (9, 1), (14, 1), (15, 1), (16, 1), (19, 2), (24, 2), (25, 1), (44, 1), (63, 1), (121, 2), (233, 2), (234, 1)], [(1, 2), (4, 1), (5, 1), (7, 1), (9, 1), (12, 2), (14, 2), (15, 1), (16, 1), (19, 2), (24, 2), (25, 1), (63, 2), (64, 2), (99, 1), (121, 2), (233, 2), (234, 1)], [(1, 2), (2, 2), (4, 1), (5, 1), (7, 1), (8, 1), (9, 1), (14, 1), (15, 1), (16, 1), (19, 2), (24, 2), (25, 1), (63, 2), (64, 2), (121, 2), (157, 1), (233, 2), (234, 1)], [], [(1, 1), (4, 2), (5, 1), (7, 1), (9, 1), (12, 2), (14, 2), (15, 2), (19, 2), (24, 2), (25, 1), (63, 2), (64, 2), (121, 2), (216, 1), (233, 2), (234, 1)], [], [], [], [], [], [(2, 1), (5, 2), (7, 2), (8, 2), (10, 1), (15, 1), (63, 1), (72, 2), (121, 2), (233, 2), (234, 1), (293, 1)], [], [], [], [], [(2, 1), (5, 2), (13, 1), (14, 2), (15, 2), (16, 1), (24, 2), (25, 1)], [], [], [], [], [(2, 1), (5, 2), (65, 2), (68, 1)], [], [], [], [(2, 1), (5, 2), (7, 2), (8, 2), (10, 1), (11, 1)], [], [], [], [], [], [], []] + +def comb21 : List (List (Nat × Nat)) := [[], [], [], [(2, 1), (3, 2), (7, 1), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (57, 1), (173, 1), (233, 1), (234, 2)], [(2, 1), (3, 2), (7, 1), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (57, 1), (233, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 1), (8, 1), (9, 1), (10, 1), (12, 2), (13, 2), (14, 1), (19, 1), (24, 1), (25, 2), (57, 1)], [(2, 1), (3, 2), (7, 1), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (24, 1), (57, 1)], [], [], [(2, 1), (3, 2), (7, 1), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (57, 1), (63, 1)], [], [], [(2, 1), (3, 2), (7, 2), (8, 2), (10, 1), (12, 2), (13, 2), (14, 1), (57, 1)], [(2, 1), (3, 2), (7, 1), (8, 2), (10, 2), (12, 2), (13, 2), (14, 1), (57, 1)], [(2, 2), (3, 1), (7, 1), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (57, 2)], [(2, 2), (3, 1), (7, 2), (8, 2), (10, 1), (12, 1), (13, 1), (14, 2), (57, 2)], [(2, 1), (3, 2), (7, 1), (8, 2), (10, 2), (12, 2), (13, 1), (14, 1), (57, 2)], [], [(0, 1), (7, 1), (9, 1), (10, 2), (12, 2), (13, 2), (14, 1), (24, 1), (25, 2), (63, 1), (64, 1), (121, 1), (233, 1), (234, 2)], [(0, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (13, 2), (14, 1), (24, 1), (25, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [(0, 2), (2, 2), (3, 1), (7, 1), (9, 1), (10, 2), (12, 2), (13, 2), (14, 1), (24, 1), (25, 2), (57, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [(0, 1), (3, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (24, 1), (25, 2), (57, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [], [], [(0, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (13, 2), (14, 1), (24, 2), (25, 1), (63, 1), (121, 2), (233, 1), (234, 2)], [(0, 1), (2, 2), (3, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (13, 2), (14, 1), (15, 1), (24, 2), (25, 1), (57, 2), (60, 1), (63, 2), (65, 2), (121, 1), (233, 1), (234, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (13, 2), (14, 1), (24, 2), (25, 1), (57, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [], [], [(0, 1), (2, 2), (3, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (13, 2), (14, 1), (15, 1), (24, 2), (25, 1), (57, 2), (63, 2), (121, 1), (233, 1), (234, 2)], [], [], [], [(1, 2), (2, 1), (3, 2), (8, 1), (10, 1), (19, 2), (21, 1), (24, 1), (25, 2), (57, 1), (63, 1), (121, 2), (233, 2), (234, 1)], [(0, 2), (1, 2), (7, 1), (8, 2), (9, 1), (12, 2), (13, 2), (14, 1), (24, 1), (25, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [(0, 2), (2, 2), (3, 1), (7, 1), (9, 1), (10, 2), (12, 2), (13, 2), (14, 1), (24, 1), (25, 2), (57, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (2, 2), (3, 1), (8, 2), (9, 1), (15, 2), (24, 1), (25, 2), (57, 2), (63, 1), (65, 1), (121, 2), (233, 2), (234, 1)], [], [], [(0, 2), (2, 2), (3, 1), (8, 2), (9, 1), (15, 2), (24, 1), (25, 2), (57, 2), (60, 2), (63, 1), (65, 1), (117, 1), (121, 2), (233, 2), (234, 1)], [], [], [], [], [(0, 2), (2, 1), (3, 2), (8, 1), (9, 2), (24, 2), (25, 1), (57, 1), (63, 1), (64, 2), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2)], [(0, 2), (2, 2), (3, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 2), (13, 2), (14, 1), (24, 2), (25, 1), (57, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [(0, 2), (2, 2), (3, 1), (8, 2), (9, 1), (13, 2), (14, 1), (24, 2), (25, 1), (57, 2), (63, 1), (121, 2), (233, 2), (234, 1)], [], [], [], [], [], [], [(0, 2), (2, 1), (3, 2), (8, 1), (9, 1), (19, 2), (22, 1), (24, 1), (25, 2), (57, 1), (63, 2), (121, 1), (233, 1), (234, 2)], [(0, 2), (2, 1), (3, 1), (8, 2), (9, 1), (13, 2), (14, 1), (24, 2), (25, 1), (57, 2), (63, 1), (65, 1), (66, 1), (67, 2), (121, 2), (233, 2), (234, 1)], [], [], [], [], [(0, 2), (2, 1), (3, 2), (8, 2), (9, 1), (19, 2), (24, 1), (25, 2), (57, 1), (63, 1), (80, 1), (121, 1), (233, 1), (234, 2)], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (8, 1), (9, 1), (10, 1), (19, 2), (24, 1), (25, 2), (57, 2), (63, 1), (121, 1), (137, 1), (233, 1), (234, 2)], [(0, 1), (6, 2), (7, 2), (8, 1), (9, 2), (10, 1), (12, 2), (13, 1), (14, 1), (24, 2), (25, 1), (51, 1), (57, 1), (63, 2), (121, 1), (233, 1), (234, 2)], [(0, 2), (7, 1), (8, 1), (9, 1), (10, 2), (12, 2), (13, 1), (14, 1), (24, 1), (25, 2), (63, 2), (121, 1), (233, 2), (234, 1), (314, 1)], [(0, 1), (6, 2), (7, 2), (8, 1), (9, 2), (10, 1), (12, 2), (13, 1), (14, 1), (24, 2), (25, 1), (44, 1), (57, 1), (63, 1), (121, 2), (233, 2), (234, 1)], [(0, 2), (7, 2), (9, 2), (10, 1), (12, 1), (13, 1), (14, 2), (24, 2), (25, 1), (63, 2), (64, 2), (99, 1), (121, 2), (233, 2), (234, 1)], [(0, 2), (2, 2), (3, 1), (6, 2), (7, 2), (8, 1), (9, 2), (10, 1), (12, 2), (13, 1), (14, 1), (24, 2), (25, 1), (63, 2), (64, 2), (121, 2), (157, 1), (233, 2), (234, 1)], [(0, 2), (2, 2), (3, 1), (6, 2), (7, 2), (8, 1), (9, 2), (10, 1), (12, 2), (13, 1), (14, 1), (24, 2), (25, 1), (63, 2), (64, 2), (121, 2), (233, 2), (234, 1), (392, 1)], [], [], [], [], [], [], [], [(2, 1), (3, 2), (7, 1), (10, 2), (12, 2), (14, 1), (172, 1), (173, 2), (233, 2), (234, 1)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (7, 1), (9, 2), (12, 2), (14, 1), (18, 1), (19, 2), (24, 2), (25, 1)], [], [], [], [], [(2, 1), (3, 2), (7, 1), (10, 2), (12, 2), (14, 1), (65, 2), (67, 1)], [], [], [], [(2, 1), (3, 2), (6, 1), (8, 2), (12, 2), (14, 1)], [], [], [(7, 1), (10, 2), (12, 2), (14, 1)], [], [], []] + +def comb22 : List (List (Nat × Nat)) := [[(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (18, 2), (19, 1), (24, 2), (57, 2), (65, 1), (66, 2), (68, 2), (71, 2), (72, 1), (74, 1), (75, 1), (127, 1), (131, 2), (233, 1)], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (18, 2), (19, 1), (24, 1), (57, 2), (65, 1), (66, 2), (68, 2), (71, 2), (72, 1), (74, 1), (75, 1), (127, 1), (131, 2), (233, 2)], [], [], [], [], [], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (19, 2), (24, 1), (57, 2), (63, 1), (65, 2), (66, 1), (68, 1), (72, 2), (233, 1)], [(0, 2), (2, 1), (18, 2), (19, 2), (20, 1), (24, 1), (57, 2), (66, 1), (72, 2), (75, 1), (233, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (7, 1), (18, 2), (19, 2), (24, 1), (57, 2), (65, 2), (68, 1), (75, 1), (233, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (18, 2), (19, 2), (24, 1), (57, 2), (65, 2), (66, 1), (68, 1), (72, 2), (75, 1), (233, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (18, 2), (19, 2), (24, 1), (57, 2), (65, 2), (68, 1), (71, 1), (74, 2), (75, 1), (127, 2), (131, 1), (233, 1)], [(1, 1), (6, 1), (7, 2), (18, 1), (24, 1), (57, 2), (63, 2), (71, 1), (74, 2), (75, 2), (127, 2), (131, 1), (233, 1)], [(0, 1), (1, 1), (2, 2), (6, 1), (7, 2), (18, 1), (24, 1), (57, 2), (63, 2), (66, 1), (71, 1), (72, 2), (74, 2), (75, 2), (127, 2), (131, 1), (233, 1)], [(1, 1), (6, 1), (7, 2), (18, 1), (24, 1), (57, 2), (63, 2), (65, 2), (68, 1), (71, 1), (74, 2), (75, 2), (127, 2), (131, 1), (233, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (18, 1), (19, 2), (57, 1), (60, 2), (71, 2), (74, 1), (75, 2), (127, 2), (131, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (18, 1), (19, 2), (57, 1), (60, 2), (71, 1), (74, 2), (75, 2)], [(0, 2), (2, 1), (6, 2), (7, 1), (18, 2), (19, 1), (57, 1), (60, 2), (63, 1), (65, 2), (68, 1), (71, 1), (74, 2), (75, 1)], [(3, 2), (4, 1), (6, 2), (7, 1), (18, 2), (19, 1), (57, 1), (60, 2), (63, 1), (66, 1), (71, 1), (72, 2), (74, 2), (75, 1)], [(0, 2), (5, 1), (6, 2), (7, 1), (18, 2), (19, 1), (57, 1), (60, 2), (63, 1), (71, 1), (74, 2), (75, 1)], [(3, 2), (4, 1), (18, 1), (19, 1), (24, 1), (57, 1), (60, 2), (66, 1), (67, 2), (71, 2), (72, 2), (74, 1), (75, 2), (121, 1), (127, 2), (131, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (18, 1), (19, 1), (24, 1), (57, 1), (60, 2), (65, 2), (68, 1), (71, 2), (74, 1), (75, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (18, 1), (19, 1), (24, 1), (57, 1), (58, 1), (60, 1), (66, 1), (71, 2), (72, 2), (74, 1), (75, 2)], [], [], [], [], [], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (19, 2), (57, 1), (60, 1), (63, 2), (127, 2), (131, 1), (233, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (19, 2), (57, 1), (60, 1), (63, 2), (71, 2), (74, 1), (233, 1)], [(2, 1), (3, 1), (4, 2), (18, 1), (19, 1), (57, 1), (60, 1), (66, 1), (71, 2), (72, 2), (74, 1), (75, 2), (233, 1)], [(0, 2), (2, 1), (3, 2), (4, 2), (18, 1), (19, 1), (57, 1), (60, 1), (71, 2), (74, 1), (75, 2), (233, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [(1, 2), (19, 2), (24, 2), (60, 1), (65, 1), (68, 2), (71, 1), (72, 1), (74, 2), (127, 1), (131, 2), (233, 2)], [(1, 2), (3, 1), (4, 2), (19, 2), (24, 2), (60, 1), (65, 1), (66, 2), (71, 1), (72, 1), (74, 2), (127, 1), (131, 2), (233, 2)], [(1, 2), (2, 1), (5, 2), (19, 2), (24, 2), (60, 1), (66, 2), (67, 1), (71, 1), (72, 1), (74, 2), (127, 1), (131, 2), (233, 2)], [(1, 2), (3, 1), (4, 2), (19, 2), (24, 2), (60, 1), (65, 1), (66, 2), (68, 2), (71, 1), (72, 1), (73, 1), (74, 2), (127, 1), (131, 2), (233, 2)], [(0, 1), (1, 2), (5, 2), (19, 2), (24, 2), (60, 1), (65, 1), (68, 2), (71, 1), (127, 1), (131, 2), (233, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (5, 2), (19, 2), (24, 2), (58, 2), (60, 2), (66, 2), (72, 1), (80, 1), (127, 1), (131, 2), (233, 2)], [(1, 2), (3, 1), (4, 2), (19, 2), (24, 2), (60, 1), (65, 1), (66, 2), (68, 2), (71, 1), (72, 1), (74, 2), (127, 1), (130, 1), (131, 2), (233, 2)], [(0, 1), (1, 2), (5, 2), (19, 2), (24, 2), (60, 1), (65, 1), (68, 2), (71, 1), (74, 2), (127, 1), (233, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (5, 2), (19, 2), (24, 2), (58, 2), (60, 2), (66, 2), (71, 1), (72, 1), (74, 2), (137, 1), (233, 2)], [(0, 1), (2, 2), (6, 2), (7, 1), (24, 2), (51, 1), (60, 2), (65, 2), (66, 1), (68, 1), (71, 2), (72, 2), (74, 1), (127, 2), (131, 1), (233, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (18, 2), (19, 1), (24, 1), (57, 2), (60, 1), (63, 2), (65, 2), (67, 1), (68, 1), (75, 1), (121, 2), (127, 2), (131, 1), (233, 2), (314, 1)], [(1, 1), (3, 2), (4, 1), (18, 2), (24, 2), (44, 1), (60, 1), (63, 2), (65, 2), (66, 1), (68, 1), (72, 2), (75, 1), (127, 2), (131, 1), (233, 2)], [], [], [], [], [], [], [], [(1, 2), (6, 2), (7, 1), (18, 1), (57, 1), (63, 1), (71, 2), (74, 1), (75, 2), (127, 1), (131, 2), (233, 2)], [(6, 2), (18, 1), (63, 1), (75, 2), (114, 1), (233, 2)], [(65, 1), (68, 2), (233, 2), (293, 1)], [(0, 2), (2, 1), (66, 2), (72, 1), (172, 1), (233, 2)], [], [], [(18, 1), (24, 2), (63, 1), (75, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (13, 1), (19, 1), (24, 2), (65, 1), (68, 2)], [(0, 2), (2, 1), (18, 1), (24, 2), (66, 2), (72, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb23 : List (List (Nat × Nat)) := [[], [(1, 2), (2, 1), (6, 1), (7, 1), (11, 2), (15, 2), (16, 2), (20, 2), (24, 2), (57, 2), (63, 2), (127, 1), (131, 2), (233, 1)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (6, 2), (7, 1), (11, 2), (15, 2), (16, 2), (20, 2), (24, 1), (44, 2), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [], [], [], [], [(1, 1), (2, 2), (6, 1), (7, 2), (8, 2), (11, 1), (16, 2), (18, 2), (20, 1), (24, 1), (57, 2), (75, 1), (233, 1)], [(3, 2), (4, 1), (6, 1), (8, 1), (15, 1), (16, 2), (24, 1), (57, 2), (60, 2), (63, 1), (64, 2), (66, 1), (77, 1), (233, 1)], [(1, 1), (2, 2), (6, 1), (7, 2), (8, 1), (11, 1), (16, 2), (20, 1), (24, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [], [(1, 1), (2, 2), (6, 1), (7, 2), (8, 1), (11, 1), (15, 1), (16, 1), (20, 1), (24, 1), (57, 2), (63, 1), (127, 2), (131, 1), (233, 1)], [(6, 1), (8, 1), (15, 1), (16, 2), (24, 1), (57, 2), (63, 1), (127, 2), (131, 1), (233, 1)], [(6, 2), (15, 1), (16, 2), (24, 1), (57, 2), (63, 1), (127, 2), (131, 1), (233, 1)], [(1, 1), (2, 2), (6, 1), (7, 2), (8, 1), (11, 1), (16, 2), (20, 1), (24, 1), (57, 2), (63, 1), (127, 2), (131, 1), (233, 1)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (8, 2), (15, 1), (16, 1), (20, 1), (24, 2), (34, 1), (44, 2), (64, 1), (66, 2), (127, 2), (131, 1)], [], [(0, 2), (1, 1), (3, 2), (4, 1), (6, 1), (7, 2), (16, 2), (20, 1), (24, 2), (34, 1), (44, 2)], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (11, 1), (16, 1), (20, 2), (24, 2), (34, 1), (44, 2)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (15, 1), (16, 1), (20, 1), (24, 2), (34, 1), (44, 2)], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (15, 1), (16, 1), (20, 1), (24, 2), (34, 1), (44, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 2), (16, 1), (20, 2), (24, 2), (34, 2), (44, 2), (121, 1), (127, 2), (131, 1)], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (15, 2), (16, 2), (20, 2), (24, 2), (34, 2), (44, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (16, 1), (20, 2), (24, 2), (34, 2), (44, 2)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 2), (6, 1), (7, 1), (16, 1), (20, 2), (24, 2), (34, 2), (44, 2)], [], [], [], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (7, 2), (8, 1), (15, 1), (20, 2), (24, 2), (34, 1), (44, 1), (57, 2), (63, 1), (127, 2), (131, 1), (233, 1)], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (11, 1), (15, 2), (16, 1), (24, 1), (34, 2), (44, 1), (57, 2), (60, 1), (233, 1)], [(0, 1), (1, 2), (3, 1), (4, 2), (7, 1), (8, 2), (16, 1), (20, 2), (24, 1), (34, 2), (44, 1), (57, 2), (58, 1), (233, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (16, 1), (20, 2), (24, 1), (34, 2), (44, 1), (57, 2), (66, 1), (233, 1)], [], [], [], [], [], [], [], [], [], [], [(0, 2), (1, 1), (3, 2), (4, 1), (7, 2), (15, 2), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 1), (8, 2), (10, 1), (15, 2), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [(0, 2), (1, 1), (3, 2), (4, 1), (7, 2), (11, 2), (15, 2), (16, 1), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (11, 2), (15, 2), (17, 1), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (7, 1), (15, 1), (16, 1), (20, 1), (22, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [], [], [], [], [], [], [(0, 2), (1, 1), (3, 2), (4, 1), (7, 2), (11, 2), (15, 2), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (130, 1), (131, 2), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (11, 2), (15, 2), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (127, 1), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (11, 2), (15, 2), (20, 1), (34, 2), (44, 1), (57, 1), (63, 2), (137, 1), (233, 2)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 1), (11, 1), (15, 1), (17, 2), (20, 2), (24, 1), (34, 1), (44, 2), (51, 1), (57, 2), (63, 1), (127, 2), (131, 1), (233, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (7, 1), (8, 2), (11, 1), (15, 2), (16, 2), (17, 2), (20, 2), (24, 1), (44, 2), (57, 1), (63, 2), (121, 2), (127, 2), (131, 1), (233, 2), (314, 1)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (11, 1), (15, 1), (16, 2), (34, 2), (44, 1), (63, 2), (64, 2), (66, 1), (99, 1), (127, 2), (131, 1), (233, 2)], [], [], [], [], [], [(6, 2), (8, 2), (15, 2), (16, 1), (57, 1), (63, 2), (127, 1), (131, 2), (233, 2)], [], [(6, 2), (8, 1), (114, 1), (233, 2)], [(1, 2), (2, 1), (6, 2), (7, 1), (11, 2), (15, 1), (20, 2), (24, 1), (34, 2), (44, 1), (57, 1), (58, 2), (233, 2), (293, 1)], [(6, 2), (8, 1), (172, 1), (233, 2)], [], [(6, 2), (8, 2), (15, 2), (16, 1), (24, 2), (57, 1), (63, 2), (127, 1), (131, 2)], [(8, 1), (24, 2)], [(1, 2), (2, 1), (7, 1), (11, 2), (13, 1), (16, 1), (20, 2), (24, 2)], [(6, 2), (8, 1), (18, 1), (24, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb24 : List (List (Nat × Nat)) := [[], [], [(1, 2), (4, 2), (6, 1), (7, 1), (15, 1), (16, 2), (24, 2), (57, 1), (60, 2), (63, 2), (65, 2), (71, 1), (74, 2), (114, 1), (233, 1)], [], [], [], [], [(1, 2), (4, 2), (6, 2), (7, 1), (15, 1), (16, 2), (24, 1), (57, 1), (60, 2), (63, 2), (65, 2), (71, 1), (74, 2), (233, 2)], [], [], [], [], [(1, 2), (2, 1), (3, 2), (6, 2), (7, 1), (11, 1), (15, 1), (16, 2), (24, 1), (57, 2), (63, 1), (64, 2), (65, 2), (77, 1), (233, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (15, 1), (16, 2), (24, 1), (57, 2), (63, 1), (65, 2), (233, 1)], [], [(1, 2), (2, 2), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 1), (15, 1), (16, 1), (20, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (71, 2), (74, 1), (233, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (15, 2), (16, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 1), (71, 2), (74, 1), (233, 1)], [(1, 1), (4, 1), (6, 1), (7, 2), (8, 1), (15, 2), (16, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 1), (71, 2), (74, 1), (233, 1)], [], [(1, 2), (2, 1), (3, 2), (6, 2), (7, 1), (15, 1), (16, 2), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (71, 2), (74, 1), (233, 1)], [(1, 2), (6, 2), (7, 1), (15, 1), (16, 2), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (71, 2), (74, 1), (233, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (15, 1), (16, 2), (24, 1), (57, 2), (63, 1), (65, 2), (71, 2), (74, 1), (233, 1)], [(1, 1), (2, 2), (3, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (24, 2), (34, 1), (60, 2), (64, 1), (71, 2), (74, 1)], [(1, 2), (7, 1), (8, 1), (9, 2), (11, 1), (12, 2), (15, 1), (16, 2), (24, 2), (34, 1), (60, 1), (65, 1)], [], [(1, 1), (2, 1), (4, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (15, 2), (16, 1), (24, 2), (34, 1), (60, 1)], [(1, 1), (2, 2), (3, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (15, 2), (16, 1), (24, 2), (34, 1), (60, 2)], [(1, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (15, 2), (16, 1), (24, 2), (34, 1), (60, 2)], [], [], [], [(1, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (15, 1), (16, 2), (24, 2), (34, 2), (60, 1)], [], [], [(1, 1), (4, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (15, 2), (16, 1), (24, 2), (34, 2), (60, 1)], [(1, 1), (7, 2), (8, 1), (9, 2), (11, 2), (12, 1), (15, 2), (16, 1), (24, 2), (34, 2), (60, 2), (65, 2)], [], [], [], [], [(1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (24, 2), (34, 1), (57, 2), (60, 2), (63, 1), (65, 2), (71, 2), (74, 1), (233, 1)], [], [], [], [], [], [(1, 1), (4, 1), (6, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (15, 2), (16, 1), (24, 1), (34, 2), (60, 1), (65, 2), (114, 2), (117, 1), (233, 1)], [(1, 1), (2, 2), (3, 1), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (15, 2), (16, 1), (24, 1), (34, 2), (60, 2), (65, 2), (114, 2), (115, 1), (233, 1)], [(1, 1), (6, 1), (7, 2), (8, 1), (9, 2), (11, 2), (12, 1), (15, 2), (16, 1), (24, 1), (34, 2), (60, 2), (64, 2), (65, 2), (114, 2), (120, 1), (233, 1)], [], [], [], [], [(2, 2), (3, 1), (4, 2), (6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (74, 2), (233, 2)], [(6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (74, 2), (233, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (74, 2), (233, 2)], [], [], [(4, 2), (6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (16, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (74, 2), (233, 2)], [(2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (17, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (74, 2), (233, 2)], [(1, 1), (4, 2), (6, 2), (8, 1), (9, 2), (10, 2), (11, 1), (12, 1), (15, 2), (16, 1), (22, 1), (34, 2), (57, 1), (63, 2), (65, 2), (71, 1), (74, 2), (233, 2)], [], [], [], [(4, 2), (6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (73, 1), (74, 2), (233, 2)], [(2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (71, 1), (233, 2)], [(2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (34, 2), (57, 1), (60, 1), (63, 2), (65, 1), (80, 1), (233, 2)], [], [], [], [(1, 2), (4, 1), (6, 1), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (17, 2), (24, 1), (34, 1), (51, 1), (57, 2), (60, 2), (63, 1), (65, 2), (71, 2), (74, 1), (233, 1)], [(4, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (17, 2), (34, 1), (57, 1), (60, 2), (63, 1), (65, 2), (71, 2), (74, 1), (233, 2), (314, 1)], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (12, 1), (15, 1), (16, 2), (34, 2), (57, 1), (63, 2), (64, 2), (71, 2), (74, 1), (114, 2), (157, 1), (233, 2)], [], [], [], [], [(1, 1), (2, 2), (3, 1), (6, 1), (7, 2), (15, 2), (16, 1), (57, 1), (60, 2), (63, 2), (65, 1), (71, 1), (74, 2), (233, 2)], [(2, 1), (3, 2), (57, 1), (233, 2)], [], [(5, 2), (6, 2), (7, 2), (9, 2), (10, 1), (12, 1), (24, 1), (34, 2), (64, 1), (65, 1), (114, 1), (120, 2), (233, 2), (293, 1)], [(2, 1), (3, 2), (172, 1), (233, 2)], [], [(1, 1), (2, 2), (3, 1), (6, 1), (7, 2), (15, 2), (16, 1), (24, 2), (57, 1), (60, 2), (63, 2), (65, 1), (71, 1), (74, 2)], [], [(1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (13, 1), (15, 2), (16, 1), (24, 2), (65, 1)], [(2, 1), (3, 2), (18, 1), (24, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb25 : List (List (Nat × Nat)) := [[], [], [], [], [], [], [], [], [(1, 2), (4, 2), (6, 1), (7, 1), (11, 2), (12, 1), (13, 1), (14, 2), (15, 2), (16, 1), (17, 2), (24, 1), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [], [], [(0, 1), (9, 2), (11, 1), (14, 1), (16, 2), (18, 2), (19, 2), (24, 1), (57, 2), (75, 1), (233, 1)], [], [(0, 2), (1, 2), (4, 1), (6, 2), (7, 1), (9, 1), (11, 1), (14, 2), (16, 1), (19, 1), (24, 1), (57, 2), (63, 1), (233, 1)], [(0, 1), (1, 2), (7, 1), (8, 2), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (17, 1), (19, 2), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 1)], [], [(0, 2), (1, 1), (4, 1), (7, 2), (8, 2), (9, 1), (12, 2), (15, 1), (17, 1), (19, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 1)], [(0, 2), (1, 1), (4, 1), (6, 2), (7, 2), (9, 1), (12, 2), (15, 1), (17, 1), (19, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 1)], [(0, 2), (1, 2), (7, 1), (8, 2), (9, 1), (11, 1), (12, 2), (15, 1), (17, 1), (19, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 1)], [], [], [(0, 2), (1, 1), (4, 1), (7, 1), (8, 2), (9, 1), (11, 1), (12, 2), (15, 1), (17, 1), (19, 1), (24, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 1)], [(1, 2), (6, 2), (7, 2), (8, 1), (9, 2), (12, 2), (13, 1), (14, 2), (16, 1), (17, 1), (24, 2), (34, 1), (60, 1), (64, 1), (65, 2), (68, 1), (71, 2)], [(6, 2), (7, 1), (8, 1), (11, 1), (13, 1), (14, 1), (15, 2), (16, 2), (24, 2), (34, 1)], [(0, 1), (1, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 2), (16, 2), (24, 2), (34, 1)], [], [(6, 1), (7, 2), (8, 2), (13, 1), (15, 2), (24, 2), (34, 1)], [(6, 2), (7, 2), (8, 1), (12, 2), (13, 1), (14, 1), (15, 2), (16, 2), (17, 1), (24, 2), (34, 1)], [], [(0, 1), (1, 2), (6, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 2), (16, 2), (19, 2), (24, 2), (34, 2), (60, 1), (65, 2), (68, 1)], [], [], [], [], [(0, 1), (1, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 2), (16, 2), (19, 2), (24, 2), (34, 2)], [], [(0, 1), (7, 2), (9, 2), (12, 1), (13, 1), (15, 1), (19, 2), (24, 2), (34, 2)], [(0, 1), (6, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 1), (19, 2), (24, 2), (34, 2)], [], [], [], [], [], [(0, 1), (1, 2), (6, 2), (7, 2), (9, 2), (11, 1), (12, 2), (13, 2), (14, 2), (15, 2), (16, 1), (17, 1), (19, 2), (24, 2), (34, 1), (57, 2), (60, 1), (63, 1), (71, 2), (233, 1)], [], [], [(0, 1), (1, 2), (4, 1), (6, 2), (7, 2), (9, 2), (12, 2), (13, 2), (14, 2), (15, 2), (16, 1), (17, 1), (19, 2), (24, 2), (34, 1), (57, 2), (63, 1), (71, 2), (117, 1), (233, 1)], [], [], [(0, 1), (1, 2), (6, 1), (8, 1), (9, 2), (12, 2), (13, 2), (14, 1), (15, 2), (16, 2), (17, 1), (19, 2), (24, 2), (34, 1), (57, 2), (63, 1), (71, 2), (174, 1), (233, 1)], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 2), (9, 2), (12, 1), (13, 2), (14, 2), (15, 2), (16, 1), (17, 2), (19, 2), (24, 2), (34, 1), (57, 2), (63, 1), (71, 2), (233, 1), (236, 1)], [], [(0, 1), (1, 2), (4, 2), (6, 2), (8, 2), (11, 2), (12, 1), (13, 2), (14, 2), (16, 1), (17, 2), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [], [(0, 1), (1, 2), (6, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (17, 2), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [(0, 1), (1, 2), (4, 2), (5, 1), (6, 1), (9, 2), (11, 2), (12, 2), (13, 2), (14, 2), (16, 1), (17, 1), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [(0, 1), (1, 2), (4, 2), (6, 2), (8, 2), (9, 2), (12, 1), (13, 2), (17, 2), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [(0, 1), (1, 2), (4, 2), (6, 2), (7, 2), (8, 2), (9, 2), (10, 1), (12, 2), (13, 2), (14, 2), (16, 1), (17, 1), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [], [], [(0, 1), (1, 2), (4, 2), (6, 2), (7, 2), (8, 2), (9, 2), (12, 2), (13, 2), (14, 2), (16, 1), (17, 1), (19, 2), (22, 1), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [], [(0, 1), (1, 2), (4, 2), (6, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (17, 2), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (71, 1), (233, 2)], [(0, 1), (1, 2), (4, 2), (6, 1), (9, 2), (11, 2), (12, 2), (13, 2), (14, 2), (16, 1), (17, 1), (19, 2), (34, 2), (57, 1), (60, 2), (63, 2), (67, 1), (71, 1), (233, 2)], [], [], [(0, 1), (1, 1), (4, 2), (6, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (15, 1), (17, 2), (19, 2), (34, 2), (57, 1), (63, 2), (80, 1), (233, 2)], [], [], [(0, 1), (1, 1), (4, 2), (6, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (15, 1), (17, 2), (19, 2), (34, 2), (57, 1), (63, 2), (137, 1), (233, 2)], [(4, 1), (7, 1), (8, 1), (11, 1), (12, 2), (13, 1), (14, 1), (16, 2), (17, 1), (24, 1), (34, 1), (51, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 1)], [(1, 1), (4, 1), (6, 1), (8, 1), (11, 1), (12, 2), (13, 1), (14, 1), (16, 2), (17, 1), (34, 1), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (233, 2), (314, 1)], [], [], [], [(0, 1), (1, 1), (4, 1), (7, 1), (8, 1), (11, 1), (12, 2), (13, 1), (14, 1), (15, 2), (16, 2), (17, 1), (19, 2), (34, 2), (57, 1), (60, 1), (63, 2), (64, 2), (65, 2), (68, 1), (71, 2), (233, 2), (392, 1)], [], [], [], [(0, 2), (1, 1), (7, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (17, 2), (19, 1), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (233, 2)], [(0, 2), (9, 1), (11, 2), (14, 2), (16, 1), (19, 1), (57, 1), (233, 2)], [(0, 2), (1, 1), (4, 2), (7, 2), (9, 1), (14, 2), (16, 1), (19, 1), (114, 1), (233, 2)], [], [(172, 1), (233, 2)], [], [(0, 2), (1, 1), (7, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (17, 2), (19, 1), (24, 2), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1)], [(0, 2), (1, 1), (4, 2), (6, 1), (7, 2), (9, 1), (14, 2), (16, 1), (19, 1), (24, 2)], [], [(18, 1), (24, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb26 : List (List (Nat × Nat)) := [[], [], [], [(0, 2), (2, 1), (6, 2), (8, 2), (9, 1), (13, 1), (14, 2), (24, 1), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (172, 1), (233, 1)], [], [], [], [], [], [(0, 2), (2, 1), (6, 2), (8, 2), (9, 1), (13, 1), (14, 2), (18, 1), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(6, 1), (8, 2), (13, 1), (18, 2), (57, 2), (75, 1), (233, 1)], [(0, 1), (6, 1), (8, 1), (12, 2), (13, 1), (14, 1), (19, 2), (57, 2), (63, 1), (64, 2), (77, 1), (233, 1)], [(6, 1), (8, 1), (13, 2), (24, 2), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (8, 2), (9, 2), (13, 1), (14, 1), (57, 2), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 1)], [(0, 2), (2, 1), (8, 2), (9, 1), (13, 1), (14, 2), (19, 2), (20, 1), (57, 2), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 1)], [], [(0, 1), (2, 2), (8, 2), (9, 2), (13, 2), (14, 1), (24, 2), (57, 2), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 1)], [], [], [(0, 1), (2, 2), (6, 1), (8, 1), (9, 2), (13, 2), (14, 1), (24, 2), (57, 2), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 1)], [], [(0, 2), (2, 1), (3, 1), (18, 1), (19, 2), (24, 2), (34, 1), (64, 1), (66, 1), (71, 2), (72, 2), (74, 1)], [(0, 1), (2, 2), (3, 1), (6, 1), (8, 2), (9, 2), (14, 2), (18, 1), (19, 2), (24, 2), (34, 1)], [(0, 2), (2, 1), (3, 2), (9, 1), (14, 2), (18, 1), (19, 2), (24, 2), (34, 1)], [(0, 1), (2, 2), (3, 2), (9, 2), (14, 1), (18, 1), (19, 2), (24, 2), (34, 1)], [], [(0, 2), (2, 1), (3, 2), (9, 1), (13, 2), (14, 2), (18, 1), (19, 1), (22, 1), (34, 1)], [], [], [(0, 1), (2, 1), (3, 1), (9, 1), (12, 1), (13, 1), (14, 1), (18, 1), (19, 2), (24, 1), (34, 2), (58, 1), (66, 1), (72, 2)], [], [(0, 1), (2, 2), (3, 1), (6, 1), (8, 2), (9, 2), (13, 1), (14, 1), (18, 1), (19, 2), (24, 1), (34, 2)], [], [], [], [(0, 1), (2, 1), (3, 2), (9, 2), (12, 1), (13, 1), (18, 1), (19, 2), (24, 1), (34, 2)], [], [(0, 2), (2, 1), (3, 2), (9, 1), (14, 1), (18, 1), (19, 1), (21, 1), (24, 2), (34, 2)], [], [], [(2, 1), (3, 1), (8, 2), (13, 1), (18, 2), (19, 1), (24, 1), (34, 1), (57, 2), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 1)], [], [], [(0, 2), (2, 2), (3, 1), (6, 1), (8, 1), (9, 1), (12, 2), (13, 1), (18, 2), (19, 1), (24, 1), (34, 1), (57, 2), (63, 1), (71, 2), (74, 1), (233, 1)], [], [], [(2, 1), (3, 2), (8, 2), (12, 2), (13, 1), (18, 2), (19, 1), (24, 1), (34, 1), (57, 2), (58, 2), (63, 1), (71, 2), (74, 1), (115, 1), (233, 1)], [], [(0, 1), (2, 2), (3, 2), (9, 2), (13, 1), (18, 2), (19, 2), (20, 2), (34, 2), (172, 2), (174, 1), (233, 1)], [], [(0, 2), (2, 1), (3, 2), (9, 2), (14, 1), (18, 2), (19, 1), (24, 1), (34, 2), (64, 2), (172, 2), (181, 1), (233, 1)], [(0, 1), (2, 2), (3, 2), (6, 2), (8, 2), (13, 1), (18, 2), (19, 1), (24, 2), (34, 2), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [(0, 1), (2, 2), (3, 2), (6, 2), (8, 2), (9, 2), (13, 1), (14, 1), (18, 2), (19, 1), (24, 2), (34, 2), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(2, 2), (3, 2), (5, 1), (6, 2), (8, 2), (13, 2), (18, 2), (19, 2), (22, 2), (24, 1), (34, 2), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(3, 1), (8, 1), (10, 1), (13, 2), (18, 2), (19, 2), (22, 2), (24, 1), (34, 2), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(3, 1), (8, 1), (12, 2), (13, 2), (14, 1), (17, 1), (18, 2), (19, 2), (22, 2), (24, 1), (34, 2), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 2), (9, 2), (13, 1), (14, 1), (18, 2), (19, 1), (24, 2), (34, 2), (57, 1), (63, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(3, 1), (6, 2), (8, 2), (13, 2), (18, 2), (19, 2), (22, 2), (24, 1), (34, 2), (57, 1), (63, 2), (66, 2), (67, 1), (71, 1), (72, 1), (74, 2), (233, 2)], [], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 2), (9, 2), (13, 2), (14, 1), (18, 2), (19, 2), (22, 2), (24, 1), (34, 2), (57, 1), (63, 2), (71, 1), (233, 2)], [], [], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 2), (9, 2), (13, 2), (14, 1), (18, 2), (19, 2), (22, 2), (24, 1), (34, 2), (57, 1), (63, 2), (127, 1), (233, 2)], [], [(3, 2), (8, 1), (12, 1), (13, 2), (14, 2), (17, 2), (18, 1), (19, 1), (22, 1), (24, 2), (34, 1), (51, 1), (57, 2), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 1)], [(3, 2), (6, 1), (8, 1), (12, 1), (13, 2), (14, 2), (17, 2), (18, 1), (19, 1), (22, 1), (24, 1), (34, 1), (57, 1), (63, 1), (66, 1), (71, 2), (72, 2), (74, 1), (233, 2), (314, 1)], [], [], [], [], [(3, 2), (6, 1), (9, 1), (14, 2), (18, 2), (19, 1), (34, 2), (57, 1), (63, 2), (64, 2), (66, 1), (71, 2), (72, 2), (74, 1), (172, 2), (216, 1), (233, 2)], [], [], [(0, 2), (2, 1), (8, 1), (9, 1), (13, 2), (14, 2), (24, 1), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2), (233, 2)], [(6, 2), (8, 1), (13, 2), (24, 1), (57, 1), (233, 2)], [(6, 2), (8, 1), (13, 2), (24, 1), (114, 1), (233, 2)], [(5, 2), (8, 1), (12, 1), (13, 2), (14, 2), (18, 2), (22, 1), (24, 1), (57, 1), (63, 2), (71, 1), (74, 2), (233, 2), (293, 1)], [], [], [(0, 2), (2, 1), (8, 1), (9, 1), (13, 2), (14, 2), (57, 1), (63, 2), (66, 2), (71, 1), (72, 1), (74, 2)], [(8, 1), (13, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb27 : List (List (Nat × Nat)) := [[], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (8, 1), (13, 1), (18, 1), (57, 1), (63, 2), (172, 1), (233, 1)], [], [], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (8, 1), (13, 1), (24, 1), (57, 1), (63, 2), (172, 2)], [(13, 1), (18, 2), (57, 2), (75, 1), (172, 1)], [(0, 1), (1, 2), (6, 2), (7, 1), (13, 1), (19, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (172, 1)], [], [(8, 2), (13, 1), (57, 2), (63, 1), (172, 1)], [(0, 1), (2, 2), (6, 2), (9, 2), (11, 1), (12, 1), (13, 1), (15, 2), (19, 2), (20, 1), (57, 2), (63, 1), (172, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (13, 2), (18, 2), (57, 2), (63, 1), (172, 1)], [], [(8, 2), (13, 2), (18, 2), (57, 2), (63, 1), (172, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (8, 2), (13, 2), (18, 2), (57, 2), (63, 1), (172, 1)], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (9, 1), (11, 2), (12, 2), (19, 2), (34, 1), (64, 1), (65, 1), (68, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (19, 2), (34, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (7, 1), (9, 1), (11, 2), (12, 2), (19, 2), (34, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (7, 2), (9, 2), (11, 1), (12, 1), (19, 2), (34, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (8, 1), (9, 1), (11, 2), (12, 2), (13, 2), (18, 1), (19, 1), (34, 1)], [], [], [], [], [], [], [(0, 2), (2, 2), (3, 1), (7, 2), (9, 1), (11, 1), (12, 1), (13, 1), (19, 1), (24, 2), (25, 1), (34, 2)], [], [(0, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (13, 1), (19, 1), (24, 2), (25, 1), (34, 2)], [], [(0, 2), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1), (13, 1), (14, 1), (19, 1), (24, 2), (25, 1), (34, 2)], [(2, 2), (3, 1), (4, 2), (7, 2), (11, 2), (12, 1), (18, 1), (21, 1), (24, 2), (25, 1), (34, 2)], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (11, 2), (12, 2), (13, 1), (18, 2), (19, 2), (24, 1), (25, 2), (34, 1), (57, 2), (63, 1), (172, 1)], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (9, 2), (11, 1), (12, 2), (13, 1), (18, 2), (19, 2), (24, 1), (25, 2), (34, 1), (57, 2), (63, 1), (65, 2), (68, 1), (172, 1)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (7, 1), (8, 2), (9, 2), (11, 2), (12, 2), (13, 1), (18, 2), (19, 2), (24, 1), (25, 2), (34, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (120, 1), (172, 1)], [], [(0, 1), (2, 1), (6, 2), (7, 1), (8, 1), (9, 2), (11, 1), (13, 1), (15, 1), (18, 2), (19, 2), (20, 2), (34, 2), (172, 1), (233, 2), (236, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (6, 2), (7, 2), (9, 2), (11, 2), (12, 2), (19, 1), (24, 1), (25, 2), (34, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (172, 1), (181, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (18, 1), (19, 1), (34, 2), (57, 1), (63, 2), (172, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (18, 1), (19, 1), (34, 2), (57, 1), (63, 2), (172, 2)], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (9, 2), (11, 1), (12, 1), (13, 2), (19, 2), (34, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 2), (19, 2), (34, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (9, 2), (11, 1), (12, 1), (13, 2), (15, 1), (19, 2), (34, 2), (57, 1), (63, 2), (172, 2)], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (18, 1), (19, 1), (34, 2), (57, 1), (63, 2), (65, 1), (66, 1), (68, 2), (172, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (9, 2), (11, 1), (12, 1), (13, 2), (19, 2), (34, 2), (57, 1), (63, 2), (65, 1), (172, 2)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (9, 2), (11, 2), (12, 2), (13, 2), (14, 2), (19, 2), (34, 2), (57, 1), (63, 2), (65, 1), (68, 2), (73, 1), (172, 2)], [], [], [(0, 1), (1, 2), (4, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 2), (13, 2), (14, 2), (19, 2), (34, 2), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (120, 2), (130, 1), (172, 2)], [], [], [(0, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (13, 2), (19, 1), (34, 1), (51, 1), (57, 2), (63, 1), (172, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (13, 2), (18, 2), (19, 1), (34, 1), (57, 1), (63, 1), (172, 2), (314, 1)], [], [], [], [], [], [(0, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (18, 2), (19, 1), (34, 2), (57, 1), (63, 2), (64, 2), (65, 2), (68, 1), (172, 2), (233, 2), (274, 1)], [], [(8, 1), (13, 2), (18, 1), (57, 1), (63, 2), (172, 2)], [(13, 2), (18, 1), (57, 1), (172, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (13, 2), (18, 1), (114, 1), (172, 2)], [(0, 1), (1, 2), (4, 1), (8, 1), (9, 2), (13, 2), (18, 1), (19, 2), (24, 2), (25, 1), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (120, 2), (172, 2), (293, 1)], [], [], [(8, 1), (13, 2), (57, 1), (63, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (8, 1), (13, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb28 : List (List (Nat × Nat)) := [[(0, 2), (2, 1), (6, 2), (8, 2), (9, 1), (11, 2), (12, 2), (16, 1), (57, 1), (63, 2), (233, 1)], [(0, 2), (2, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (16, 1), (57, 1), (233, 1)], [], [], [], [], [], [(0, 1), (2, 2), (6, 1), (8, 2), (9, 2), (11, 1), (12, 1), (16, 2), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (6, 1), (8, 2), (9, 2), (12, 1), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (8, 2), (9, 2), (11, 1), (12, 1), (16, 2), (18, 1), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (6, 1), (8, 1), (9, 2), (11, 1), (12, 1), (16, 2), (24, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [], [], [], [], [(0, 1), (2, 2), (9, 2), (11, 1), (12, 1), (16, 2), (233, 1)], [(233, 1)], [(6, 1), (8, 2), (233, 1)], [(8, 2), (11, 1), (233, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (8, 1), (9, 1), (57, 1), (58, 1), (60, 1), (63, 2), (64, 1), (115, 2), (127, 2), (131, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (9, 2), (57, 1), (58, 1), (60, 1), (115, 2), (127, 2), (131, 1)], [], [], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (9, 1), (11, 1), (58, 1), (60, 2), (115, 2), (127, 2), (131, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (9, 1), (58, 2), (60, 1), (115, 2), (127, 2), (131, 1)], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (12, 2), (16, 1), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (6, 2), (8, 2), (9, 1), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [(0, 2), (2, 1), (3, 2), (4, 2), (6, 1), (9, 1), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (9, 1), (12, 1), (16, 2), (58, 2), (60, 2), (63, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [], [], [], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (9, 2), (11, 2), (58, 2), (60, 1), (115, 1), (117, 1), (127, 1), (131, 2), (233, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (9, 1), (58, 1), (60, 2), (115, 2), (127, 1), (131, 2), (233, 2)], [(0, 1), (2, 2), (3, 1), (4, 1), (6, 2), (9, 2), (58, 2), (60, 2), (64, 2), (115, 1), (120, 1), (127, 1), (131, 2), (233, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (8, 1), (9, 2), (11, 2), (12, 2), (16, 1), (58, 2), (60, 1), (115, 1), (127, 1), (131, 2), (174, 1), (233, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (9, 2), (11, 2), (12, 2), (16, 1), (58, 2), (60, 1), (115, 1), (127, 1), (131, 2), (233, 2), (236, 1)], [(0, 1), (2, 2), (3, 2), (6, 1), (12, 2), (16, 1), (58, 2), (60, 2), (64, 2), (115, 1), (127, 1), (131, 2), (181, 1), (233, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 1), (11, 1), (12, 1), (16, 2), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (8, 2), (9, 1), (12, 1), (16, 2), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [(0, 2), (3, 2), (4, 1), (5, 1), (6, 2), (9, 1), (12, 1), (16, 2), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [], [], [], [], [], [], [], [], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 2), (8, 2), (9, 2), (11, 2), (12, 2), (57, 1), (58, 1), (60, 1), (63, 2), (64, 1), (115, 2), (120, 2), (127, 2), (130, 1), (131, 1), (233, 2)], [(3, 1), (4, 2), (6, 1), (8, 1), (11, 2), (12, 2), (57, 1), (58, 2), (60, 1), (63, 2), (115, 1), (127, 2), (131, 2), (233, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (8, 1), (11, 2), (12, 2), (16, 1), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (115, 1), (127, 1), (131, 2), (137, 1), (233, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (9, 1), (11, 1), (51, 1), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1), (233, 1)], [], [(0, 2), (3, 2), (4, 1), (6, 2), (8, 2), (9, 1), (11, 1), (12, 1), (16, 2), (44, 1), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 2)], [(3, 2), (4, 1), (8, 1), (9, 1), (11, 1), (12, 1), (16, 2), (57, 1), (58, 2), (60, 2), (63, 1), (64, 2), (99, 1), (115, 1), (127, 1), (131, 2), (233, 2)], [], [], [], [], [(4, 2), (16, 1), (63, 1), (64, 2), (120, 1), (130, 2), (233, 2), (470, 1)], [], [], [(6, 2), (8, 1), (114, 1), (233, 2)], [(2, 1), (4, 1), (5, 2), (6, 2), (8, 1), (11, 2), (12, 2), (16, 1), (57, 1), (58, 2), (60, 2), (64, 1), (115, 1), (120, 2), (127, 1), (131, 2), (233, 2), (293, 1)], [(6, 2), (8, 1), (172, 1), (233, 2)], [], [], [], [], [], [], [], [(8, 1), (16, 2), (63, 2), (73, 1)], [(8, 1), (11, 2), (63, 2), (68, 1)], [(6, 2), (8, 1), (63, 2), (66, 1)], [], [], [], [], [], [], [], [], [], []] + +def comb29 : List (List (Nat × Nat)) := [[(0, 2), (2, 2), (4, 2), (11, 2), (13, 2), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [], [], [(0, 1), (2, 2), (4, 1), (8, 2), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (8, 2), (11, 1), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [], [(0, 1), (2, 1), (4, 1), (8, 1), (11, 1), (14, 2), (16, 1), (18, 2), (20, 2), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 1), (4, 1), (8, 1), (11, 1), (14, 2), (16, 1), (18, 1), (20, 2), (24, 1), (57, 2), (63, 1), (233, 1)], [], [(0, 2), (2, 2), (4, 2), (6, 1), (8, 2), (11, 2), (12, 2), (13, 2), (14, 2), (15, 1), (16, 1), (18, 1), (20, 1), (57, 1), (63, 2), (64, 2), (65, 2), (68, 1), (77, 1), (233, 2)], [], [(8, 2), (13, 1), (57, 2), (63, 1), (233, 1)], [], [(2, 2), (4, 1), (6, 1), (8, 1), (13, 1), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [(2, 2), (4, 1), (8, 2), (13, 1), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (8, 1), (11, 1), (13, 1), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [], [], [(2, 2), (4, 1), (8, 1), (11, 1), (13, 1), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [(8, 2), (13, 1), (15, 1), (16, 2), (64, 1), (65, 2), (68, 1), (72, 1), (73, 1), (74, 2)], [], [], [(0, 2), (2, 1), (13, 1), (14, 2), (15, 1), (16, 2), (65, 2), (68, 1), (72, 2), (73, 2), (74, 1)], [], [], [(2, 2), (8, 2), (11, 1), (14, 1), (15, 2), (16, 1), (65, 2), (66, 1), (67, 2), (68, 1), (72, 1), (73, 1), (74, 2), (121, 1)], [], [(6, 2), (8, 1), (12, 1), (14, 2), (15, 1), (16, 2), (58, 1), (65, 2), (68, 1), (72, 1), (73, 2), (74, 1)], [], [], [], [(0, 2), (4, 1), (15, 2), (16, 1), (65, 2), (68, 1), (72, 2), (73, 2), (74, 1)], [], [(6, 2), (8, 1), (12, 1), (14, 2), (15, 1), (16, 2), (65, 2), (68, 1), (72, 2), (73, 2), (74, 1)], [(15, 1), (16, 2), (65, 2), (68, 1), (72, 2), (73, 2), (74, 1)], [], [], [], [], [], [], [(0, 2), (2, 1), (6, 1), (8, 1), (11, 2), (12, 2), (13, 2), (15, 2), (16, 2), (18, 1), (20, 2), (57, 1), (63, 2), (65, 1), (68, 2), (72, 2), (73, 1), (74, 2), (233, 2)], [(0, 2), (2, 1), (8, 2), (11, 2), (13, 2), (14, 2), (15, 2), (16, 2), (18, 1), (20, 2), (57, 1), (63, 2), (65, 1), (68, 2), (72, 2), (73, 2), (74, 1), (233, 2)], [], [(2, 1), (4, 2), (8, 1), (12, 2), (13, 2), (15, 2), (16, 2), (18, 1), (20, 2), (57, 1), (58, 2), (63, 2), (65, 1), (68, 2), (72, 2), (73, 1), (74, 2), (115, 1), (233, 2)], [(0, 2), (2, 1), (4, 2), (8, 2), (13, 2), (14, 2), (15, 2), (16, 2), (18, 1), (20, 2), (57, 1), (63, 2), (64, 2), (65, 1), (68, 2), (72, 2), (73, 2), (74, 1), (120, 1), (233, 2)], [], [], [(0, 2), (2, 1), (4, 2), (8, 2), (13, 2), (14, 2), (15, 2), (16, 2), (18, 1), (20, 2), (57, 1), (63, 2), (64, 2), (65, 1), (68, 2), (72, 2), (73, 2), (74, 1), (181, 1), (233, 2)], [], [(0, 1), (2, 2), (8, 1), (11, 1), (14, 2), (15, 2), (18, 2), (20, 1), (57, 2), (63, 1), (65, 1), (68, 2), (72, 1), (73, 1), (74, 2), (233, 1)], [], [], [], [], [(0, 1), (2, 2), (8, 2), (14, 1), (15, 2), (16, 1), (18, 2), (20, 1), (57, 2), (63, 1), (65, 1), (68, 2), (72, 1), (73, 1), (74, 2), (233, 1)], [(0, 1), (2, 2), (6, 1), (8, 1), (12, 2), (14, 2), (15, 2), (17, 1), (18, 2), (20, 1), (57, 2), (63, 1), (65, 1), (68, 2), (72, 1), (73, 1), (74, 2), (233, 1)], [], [], [(2, 1), (4, 2), (8, 1), (11, 2), (14, 2), (15, 1), (18, 1), (20, 2), (57, 1), (63, 2), (65, 2), (68, 2), (72, 1), (73, 1), (74, 2), (233, 2)], [(0, 2), (2, 2), (4, 2), (8, 2), (11, 2), (14, 1), (15, 1), (18, 1), (20, 2), (57, 1), (63, 2), (65, 1), (66, 2), (67, 1), (68, 2), (72, 2), (73, 2), (74, 1), (233, 2)], [], [], [(0, 2), (2, 2), (4, 2), (6, 1), (8, 1), (11, 2), (12, 2), (14, 2), (15, 2), (18, 1), (20, 1), (57, 1), (58, 2), (63, 2), (65, 1), (68, 2), (72, 2), (73, 1), (74, 2), (80, 1), (233, 2)], [], [], [(0, 2), (2, 2), (4, 2), (6, 1), (8, 1), (11, 2), (12, 2), (14, 2), (15, 2), (18, 1), (20, 1), (57, 1), (58, 2), (63, 2), (65, 1), (68, 2), (72, 2), (73, 1), (74, 2), (137, 1), (233, 2)], [(2, 2), (4, 1), (6, 2), (8, 2), (11, 1), (12, 1), (13, 1), (15, 1), (16, 1), (17, 2), (18, 2), (20, 1), (51, 1), (57, 2), (63, 1), (65, 2), (68, 1), (72, 2), (73, 2), (74, 1), (233, 1)], [], [(0, 1), (2, 1), (4, 1), (11, 1), (13, 1), (14, 2), (15, 2), (16, 2), (18, 1), (20, 2), (44, 1), (57, 1), (63, 2), (65, 1), (68, 2), (72, 1), (73, 1), (74, 2), (233, 2)], [], [], [(0, 2), (2, 1), (4, 1), (6, 2), (8, 1), (11, 1), (12, 1), (13, 1), (14, 1), (15, 1), (18, 1), (20, 2), (57, 1), (63, 2), (65, 2), (68, 1), (72, 1), (73, 2), (74, 1), (120, 2), (233, 2), (392, 1)], [], [], [(6, 2), (8, 2), (12, 1), (13, 2), (14, 2), (16, 1), (17, 2), (18, 1), (20, 2), (57, 1), (63, 2), (65, 1), (66, 1), (67, 2), (68, 2), (233, 2), (470, 1)], [], [(0, 2), (2, 1), (8, 1), (11, 2), (14, 2), (16, 1), (18, 1), (20, 2), (57, 1), (233, 2)], [(2, 1), (4, 2), (6, 2), (8, 1), (14, 2), (16, 1), (18, 1), (20, 2), (114, 1), (233, 2)], [], [(172, 1), (233, 2)], [], [(8, 1), (13, 2), (57, 1), (63, 2)], [], [], [], [], [(0, 1), (11, 2), (64, 1), (72, 2), (73, 2), (74, 1), (120, 2), (130, 1)], [(0, 1), (4, 2), (72, 2), (74, 1)], [], [(0, 1), (2, 2), (8, 2), (14, 1), (66, 1), (72, 2), (73, 2), (74, 1)], [], [], [], [], [], [], [], [], [], []] + +def comb30 : List (List (Nat × Nat)) := [[(6, 2), (18, 2), (57, 2), (63, 1), (233, 1)], [], [], [(0, 1), (1, 2), (6, 2), (7, 1), (8, 1), (12, 2), (13, 2), (18, 2), (19, 2), (57, 1), (60, 1), (63, 2), (65, 2), (68, 1), (71, 2), (73, 2), (74, 1), (172, 1), (233, 1)], [], [], [(0, 1), (1, 2), (3, 1), (7, 1), (8, 1), (12, 2), (13, 2), (19, 2), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (73, 2), (74, 1), (233, 1)], [(0, 1), (1, 2), (6, 1), (7, 1), (8, 1), (12, 2), (13, 2), (19, 2), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (73, 2), (74, 1), (233, 1)], [(0, 1), (1, 2), (6, 1), (7, 1), (12, 2), (19, 2), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (73, 2), (74, 1), (233, 1)], [], [(0, 2), (1, 1), (6, 1), (7, 2), (8, 2), (12, 1), (13, 1), (19, 1), (24, 1), (57, 2), (60, 2), (63, 1), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2), (233, 1)], [], [], [], [(0, 1), (1, 2), (7, 1), (8, 1), (12, 2), (13, 2), (18, 1), (19, 2), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (73, 2), (74, 1), (233, 1)], [(0, 1), (1, 2), (7, 2), (12, 2), (15, 2), (18, 1), (19, 1), (20, 1), (57, 2), (60, 1), (63, 1), (65, 2), (68, 1), (71, 2), (73, 2), (74, 1), (233, 1)], [], [(0, 2), (1, 1), (7, 2), (12, 1), (13, 1), (18, 1), (19, 1), (57, 2), (60, 2), (63, 1), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2), (233, 1)], [], [], [(0, 2), (1, 1), (6, 1), (7, 2), (8, 2), (12, 1), (13, 1), (18, 1), (19, 1), (57, 2), (60, 2), (63, 1), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2), (233, 1)], [], [(0, 1), (1, 1), (3, 1), (7, 1), (8, 2), (12, 2), (13, 1), (18, 1), (19, 2), (60, 2), (64, 1), (65, 1), (66, 1), (71, 1), (72, 2), (73, 1), (74, 2)], [], [], [], [(0, 1), (1, 1), (3, 1), (7, 1), (8, 2), (12, 2), (13, 1), (18, 1), (19, 2), (60, 2), (65, 1), (66, 1), (68, 1), (71, 1), (72, 2), (73, 1), (74, 2)], [], [(1, 1), (3, 1), (6, 1), (8, 2), (13, 1), (60, 2), (65, 2), (66, 2), (67, 2), (71, 1), (72, 1), (73, 1), (74, 2), (121, 1)], [(1, 1), (3, 2), (8, 1), (13, 2), (60, 2), (65, 1), (66, 1), (71, 2), (72, 2), (73, 2), (74, 1)], [], [], [(0, 1), (1, 1), (3, 1), (6, 1), (8, 2), (12, 2), (13, 1), (60, 2), (65, 1), (66, 1), (68, 1), (71, 1), (72, 2), (73, 1), (74, 2)], [], [], [], [(1, 1), (3, 2), (60, 2), (65, 1), (66, 1), (68, 1), (71, 1), (72, 2), (73, 1), (74, 2)], [], [(1, 1), (3, 2), (13, 2), (21, 1), (60, 1), (65, 2), (66, 1), (71, 2), (72, 2), (73, 2), (74, 1)], [], [], [(0, 2), (3, 1), (7, 2), (12, 2), (18, 1), (19, 1), (57, 2), (63, 1), (66, 2), (68, 1), (72, 1), (233, 1)], [], [(0, 1), (3, 2), (6, 2), (7, 1), (12, 2), (18, 2), (19, 2), (57, 1), (63, 2), (65, 1), (66, 2), (68, 1), (72, 1), (233, 2)], [], [(0, 1), (3, 2), (6, 2), (7, 1), (12, 2), (18, 2), (19, 2), (57, 1), (63, 2), (66, 2), (68, 2), (72, 1), (233, 2)], [(0, 1), (1, 1), (3, 1), (12, 2), (18, 2), (19, 2), (57, 1), (60, 2), (63, 2), (65, 1), (66, 2), (68, 1), (72, 1), (117, 1), (233, 2)], [], [(0, 1), (3, 1), (7, 1), (12, 2), (18, 2), (19, 2), (57, 1), (63, 2), (64, 2), (66, 2), (68, 2), (72, 1), (120, 1), (233, 2)], [], [(0, 2), (3, 1), (7, 1), (8, 2), (12, 1), (13, 1), (15, 1), (18, 2), (19, 2), (20, 2), (57, 1), (63, 2), (66, 2), (68, 2), (71, 2), (72, 1), (73, 2), (74, 1), (233, 2), (236, 1)], [], [], [], [(0, 1), (1, 1), (3, 1), (6, 1), (7, 1), (12, 2), (19, 2), (57, 2), (63, 1), (66, 2), (68, 1), (72, 1), (233, 1)], [], [(0, 1), (3, 2), (7, 2), (12, 2), (19, 2), (57, 2), (63, 1), (66, 2), (68, 1), (72, 1), (233, 1)], [], [(0, 1), (3, 2), (7, 1), (8, 1), (12, 2), (13, 2), (15, 1), (19, 2), (57, 2), (63, 1), (66, 2), (68, 1), (72, 1), (233, 1)], [], [(1, 1), (3, 2), (7, 1), (8, 1), (13, 1), (19, 2), (22, 1), (57, 2), (60, 2), (63, 1), (65, 1), (66, 2), (71, 1), (72, 1), (73, 1), (74, 2), (233, 1)], [(0, 2), (3, 1), (6, 2), (7, 2), (12, 1), (19, 1), (57, 1), (63, 2), (66, 2), (68, 1), (72, 2), (233, 2)], [], [(0, 2), (3, 1), (6, 2), (7, 2), (12, 1), (19, 1), (57, 1), (63, 2), (65, 2), (66, 1), (67, 1), (68, 2), (72, 2), (233, 2)], [], [(0, 2), (3, 1), (6, 2), (7, 2), (8, 2), (12, 1), (13, 1), (19, 1), (57, 1), (63, 2), (66, 2), (68, 2), (72, 1), (73, 2), (74, 1), (233, 2)], [], [], [(0, 2), (3, 1), (6, 2), (7, 2), (8, 2), (12, 1), (13, 1), (19, 1), (57, 1), (63, 2), (66, 2), (68, 2), (71, 2), (72, 1), (73, 2), (74, 1), (127, 1), (233, 2)], [], [(0, 2), (1, 2), (3, 2), (7, 2), (12, 1), (18, 1), (19, 1), (51, 1), (57, 2), (63, 1), (66, 1), (68, 2), (72, 2), (233, 1)], [], [(0, 2), (1, 2), (3, 2), (8, 1), (12, 1), (13, 2), (18, 1), (44, 1), (57, 1), (60, 1), (63, 2), (65, 2), (66, 2), (68, 2), (71, 2), (72, 1), (73, 2), (74, 1), (233, 2)], [], [], [], [(0, 2), (1, 2), (3, 2), (6, 1), (7, 2), (8, 1), (12, 1), (13, 2), (18, 1), (19, 1), (57, 1), (60, 1), (63, 2), (64, 2), (65, 2), (66, 2), (71, 2), (72, 1), (73, 2), (74, 1), (172, 2), (216, 1), (233, 2)], [], [(0, 2), (3, 1), (7, 1), (12, 1), (15, 1), (18, 2), (19, 2), (20, 2), (57, 1), (60, 2), (63, 2), (65, 2), (67, 2), (68, 2), (71, 1), (73, 1), (74, 2), (233, 2), (470, 1)], [], [(0, 2), (1, 1), (6, 2), (7, 2), (8, 2), (12, 1), (13, 1), (19, 1), (57, 1), (60, 2), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2), (233, 2)], [(0, 2), (1, 1), (6, 2), (7, 2), (8, 2), (12, 1), (13, 1), (19, 1), (60, 2), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2), (114, 1), (233, 2)], [(1, 1), (7, 2), (8, 2), (13, 1), (57, 1), (60, 2), (63, 2), (64, 1), (65, 1), (66, 2), (68, 2), (71, 1), (72, 1), (73, 1), (74, 2), (120, 2), (233, 2), (293, 1)], [], [], [(0, 2), (1, 1), (7, 2), (8, 2), (12, 1), (13, 1), (18, 2), (19, 1), (57, 1), (60, 2), (63, 2), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2)], [], [], [], [], [(3, 1), (6, 2), (8, 1), (13, 2), (64, 1), (68, 2), (120, 2), (130, 1)], [(8, 1), (13, 2), (68, 2), (73, 1)], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb31 : List (List (Nat × Nat)) := [[], [(3, 2), (4, 1), (8, 2), (13, 2), (14, 2), (18, 2), (21, 1), (57, 2), (73, 2), (233, 1)], [(2, 2), (5, 1), (6, 2), (13, 2), (14, 2), (18, 2), (21, 1), (57, 1), (73, 2), (114, 1), (233, 1)], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (13, 1), (14, 2), (18, 2), (21, 1), (233, 1)], [], [], [(2, 2), (3, 2), (4, 1), (5, 1), (13, 1), (14, 2), (18, 2), (21, 1), (57, 2), (73, 1), (233, 1)], [(2, 2), (3, 2), (4, 1), (5, 1), (13, 1), (14, 1), (18, 2), (21, 2), (57, 2), (73, 1), (233, 1)], [(2, 1), (5, 2), (13, 1), (14, 1), (18, 1), (21, 2), (24, 1), (57, 2), (73, 1), (233, 1)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (18, 2), (57, 2), (77, 1), (233, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (13, 1), (14, 2), (18, 2), (21, 1), (57, 2), (63, 1), (233, 1)], [(2, 2), (5, 1), (8, 2), (13, 2), (14, 2), (18, 2), (21, 1), (57, 1), (73, 2), (233, 2)], [], [], [], [], [(2, 2), (3, 2), (4, 1), (5, 1), (8, 1), (14, 2), (18, 2), (21, 1), (57, 2), (73, 1), (233, 1)], [(2, 1), (5, 2), (8, 1), (14, 2), (18, 2), (21, 1), (57, 2), (73, 1), (233, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (14, 2), (18, 2), (21, 1), (57, 2), (73, 1), (233, 1)], [], [(2, 2), (5, 2), (8, 1), (12, 2), (13, 2), (14, 1), (16, 1), (20, 2), (21, 1)], [(2, 2), (3, 1), (4, 2), (5, 2), (8, 1), (12, 2), (14, 2), (16, 2), (18, 2), (19, 1), (20, 1), (21, 2)], [], [], [], [(2, 1), (5, 1), (6, 1), (12, 1), (13, 2), (15, 1), (16, 1), (20, 1), (21, 2), (57, 1), (63, 2), (67, 2), (73, 1), (114, 2), (121, 1)], [], [], [], [(5, 2), (12, 1), (14, 1), (16, 1), (20, 2), (21, 1)], [(4, 1), (5, 1), (12, 2), (16, 1), (20, 2), (21, 1)], [(5, 2), (12, 1), (15, 1), (16, 1), (20, 1), (21, 2)], [(0, 2), (3, 1), (4, 2), (5, 2), (9, 1), (12, 2), (13, 1), (14, 1), (16, 2), (18, 2), (19, 1), (20, 1), (21, 2)], [], [], [], [], [], [(2, 2), (3, 1), (4, 2), (8, 2), (12, 2), (16, 2), (18, 1), (20, 1), (21, 1), (57, 1), (73, 2), (233, 2)], [(2, 2), (3, 1), (4, 2), (8, 2), (12, 1), (14, 1), (16, 2), (18, 1), (20, 1), (21, 1), (57, 1), (73, 2), (233, 2)], [], [], [], [], [], [], [(2, 2), (3, 2), (4, 1), (8, 2), (12, 1), (16, 2), (18, 1), (20, 1), (21, 1), (174, 1), (233, 2)], [(2, 2), (3, 2), (4, 1), (8, 2), (12, 1), (16, 2), (18, 1), (20, 1), (21, 1), (233, 2), (236, 1)], [(2, 2), (3, 1), (4, 1), (12, 1), (13, 2), (14, 1), (16, 2), (18, 1), (20, 1), (21, 1), (57, 1), (63, 2), (181, 1), (233, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (5, 2), (12, 1), (16, 1), (19, 2), (20, 2), (21, 2), (57, 2), (73, 1), (233, 1)], [], [], [], [], [], [(2, 1), (3, 1), (4, 2), (12, 2), (13, 2), (14, 1), (16, 2), (18, 1), (20, 2), (57, 1), (73, 2), (233, 2)], [(2, 1), (3, 1), (4, 2), (12, 1), (13, 2), (14, 2), (16, 1), (17, 1), (18, 1), (20, 2), (57, 1), (73, 2), (233, 2)], [(2, 1), (3, 1), (4, 2), (12, 2), (13, 2), (14, 1), (16, 2), (18, 1), (20, 1), (22, 1), (57, 1), (73, 2), (233, 2)], [(0, 1), (2, 2), (5, 2), (9, 2), (12, 1), (14, 1), (16, 1), (19, 2), (20, 2), (21, 2), (57, 2), (66, 1), (233, 1)], [(2, 1), (3, 2), (4, 1), (12, 2), (13, 1), (14, 2), (15, 2), (16, 2), (18, 2), (20, 2), (21, 2), (57, 2), (65, 1), (233, 1)], [(2, 2), (3, 1), (4, 2), (5, 2), (12, 2), (13, 1), (14, 2), (15, 2), (16, 2), (18, 2), (20, 2), (21, 2), (57, 2), (67, 1), (233, 1)], [], [], [], [], [], [], [(2, 1), (5, 1), (6, 2), (8, 1), (12, 2), (13, 1), (14, 1), (16, 2), (17, 2), (18, 2), (20, 1), (51, 1), (57, 2), (73, 1), (233, 1)], [], [], [(0, 1), (5, 1), (8, 1), (9, 2), (12, 1), (16, 1), (18, 2), (19, 2), (20, 2), (57, 1), (73, 1), (99, 1), (233, 2)], [(3, 1), (4, 2), (5, 1), (8, 1), (12, 2), (13, 1), (16, 2), (18, 1), (20, 1), (21, 1), (57, 2), (73, 1), (114, 2), (157, 1), (233, 2)], [], [], [], [(2, 2), (3, 2), (4, 1), (5, 2), (8, 2), (15, 1), (17, 2), (18, 1), (20, 2), (57, 1), (67, 2), (233, 2), (470, 1)], [(2, 1), (3, 1), (4, 2), (5, 2), (14, 1), (18, 1), (21, 2), (57, 1), (73, 2), (233, 2)], [], [], [(2, 1), (5, 2), (233, 2), (293, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (172, 1), (233, 2)], [], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (57, 1), (73, 2), (114, 2), (130, 1)], [], [], [], [], [], [(0, 1), (3, 2), (4, 1), (5, 2), (9, 2), (11, 1), (13, 2), (14, 2), (16, 2), (18, 1), (19, 2), (20, 1), (21, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2)], [], [], [], [], [], []] + +def comb32 : List (List (Nat × Nat)) := [[], [(8, 1), (18, 2), (57, 2), (66, 2), (233, 1)], [], [(11, 1), (13, 1), (16, 2), (18, 2), (57, 1), (66, 2), (172, 1), (233, 1)], [], [(8, 2), (11, 1), (13, 1), (16, 2), (233, 1)], [], [(8, 2), (11, 1), (13, 1), (16, 2), (57, 2), (66, 1), (233, 1)], [(8, 1), (11, 1), (13, 2), (16, 2), (57, 2), (66, 1), (233, 1)], [], [(11, 2), (13, 2), (16, 1), (24, 1), (57, 2), (66, 1), (233, 1)], [(8, 2), (11, 1), (13, 1), (16, 2), (57, 2), (75, 1), (233, 1)], [(1, 2), (7, 1), (9, 1), (11, 1), (12, 2), (13, 2), (15, 1), (16, 1), (18, 1), (57, 2), (77, 1), (233, 1)], [(11, 2), (13, 2), (16, 1), (18, 1), (57, 2), (63, 1), (233, 1)], [], [], [(6, 1), (8, 2), (11, 1), (13, 1), (16, 2), (18, 2), (57, 1), (66, 2), (233, 2)], [], [], [], [(11, 2), (13, 2), (16, 1), (18, 1), (57, 2), (66, 1), (233, 1)], [], [], [(1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (13, 2), (15, 2), (16, 2), (18, 1)], [], [], [(1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 1), (13, 2), (15, 2), (16, 2), (18, 1)], [], [(1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (13, 2), (15, 1), (63, 2), (66, 1), (121, 1)], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (9, 2), (11, 1), (12, 1), (13, 2), (15, 1), (57, 2), (58, 1), (66, 1), (72, 2)], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (13, 2), (15, 1)], [], [(1, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 1), (11, 2), (13, 1), (15, 2)], [], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (15, 1)], [], [(1, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 2), (13, 1), (15, 2), (21, 1)], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (11, 1), (13, 2), (15, 2), (16, 2), (18, 2), (57, 1), (66, 2), (233, 2)], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (11, 2), (15, 1), (16, 2), (18, 2), (57, 1), (66, 2), (233, 2)], [], [(1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (18, 1), (57, 2), (72, 1), (233, 1)], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (11, 1), (15, 1), (16, 2), (18, 2), (117, 1), (233, 2)], [], [(1, 2), (3, 1), (4, 1), (6, 2), (7, 1), (8, 2), (11, 2), (15, 1), (16, 2), (18, 2), (57, 1), (63, 2), (120, 1), (233, 2)], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 2), (15, 1), (16, 2), (18, 2), (233, 2), (236, 1)], [], [], [], [(1, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (11, 1), (15, 1), (16, 2), (57, 2), (66, 1), (233, 1)], [], [], [(1, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (10, 1), (11, 2), (15, 2), (16, 1), (57, 1), (66, 2), (233, 2)], [], [(1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (9, 1), (11, 2), (12, 2), (13, 1), (15, 2), (17, 1), (57, 1), (66, 2), (233, 2)], [], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (11, 1), (15, 1), (16, 2), (57, 2), (65, 1), (233, 1)], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (11, 1), (13, 2), (15, 1), (16, 2), (57, 2), (73, 1), (233, 1)], [], [(1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 1), (12, 2), (13, 2), (15, 2), (16, 2), (58, 2), (63, 2), (72, 1), (80, 1), (233, 1)], [], [(1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 2), (15, 1), (16, 1), (57, 1), (63, 2), (127, 1), (233, 2)], [], [(1, 1), (3, 2), (4, 1), (7, 2), (8, 2), (9, 2), (11, 2), (12, 1), (15, 1), (16, 2), (17, 2), (18, 1), (51, 1), (57, 2), (66, 1), (233, 1)], [], [], [(1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 1), (11, 2), (12, 2), (13, 2), (15, 2), (18, 1), (57, 1), (66, 1), (99, 1), (233, 2)], [], [], [(1, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (13, 1), (15, 2), (18, 1), (57, 2), (66, 1), (172, 2), (216, 1), (233, 2)], [], [(3, 1), (4, 2), (6, 2), (9, 2), (11, 2), (12, 1), (13, 1), (16, 2), (17, 2), (57, 1), (75, 2), (233, 2), (470, 1)], [(8, 2), (11, 2), (13, 2), (16, 1), (57, 1), (66, 2), (233, 2)], [], [(6, 2), (8, 2), (11, 2), (13, 2), (16, 1), (114, 1), (233, 2)], [(3, 1), (6, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (16, 1), (63, 1), (72, 2), (120, 2), (233, 2), (293, 1)], [], [], [], [], [], [], [], [(3, 1), (8, 1), (11, 2), (13, 2), (63, 1), (66, 2), (120, 2), (130, 1)], [], [], [], [], [(8, 1), (11, 2), (13, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb33 : List (List (Nat × Nat)) := [[], [(0, 1), (2, 2), (6, 1), (24, 2), (57, 2), (63, 2), (172, 1)], [], [], [(0, 2), (2, 1), (6, 1), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (24, 2), (57, 1), (63, 2), (172, 1), (233, 1)], [(7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (172, 1)], [], [(0, 1), (2, 2), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (57, 2), (63, 1), (172, 1)], [(7, 2), (8, 2), (9, 2), (10, 1), (11, 1), (12, 1), (13, 1), (17, 2), (57, 2), (63, 1), (172, 1)], [(0, 1), (2, 2), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 1), (57, 2), (63, 1), (172, 1)], [], [(0, 1), (2, 2), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 2), (24, 1), (57, 2), (75, 1), (172, 1)], [(0, 1), (2, 2), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 2), (24, 1), (57, 2), (77, 1), (172, 1)], [], [], [], [], [(0, 2), (2, 1), (7, 2), (8, 1), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (24, 2), (57, 1), (63, 2), (172, 2)], [(0, 2), (2, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [(0, 1), (2, 2), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (8, 1), (10, 2), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (24, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (24, 1)], [(0, 2), (1, 1), (2, 1), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (63, 1), (67, 2), (121, 1)], [], [], [(0, 1), (1, 2), (2, 2), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1)], [(0, 1), (1, 1), (6, 1), (7, 1), (9, 1), (10, 1), (11, 2), (13, 2), (14, 2), (15, 2), (16, 1), (17, 2)], [], [], [(0, 1), (1, 2), (2, 2), (7, 2), (8, 1), (10, 2), (11, 1), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1)], [], [(0, 2), (1, 2), (2, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 2), (13, 1), (14, 2), (15, 1), (16, 2), (17, 1)], [(0, 1), (1, 2), (2, 2), (6, 1), (8, 1), (10, 1), (12, 1), (13, 2), (14, 1), (15, 1), (16, 2), (17, 2), (18, 2), (21, 1)], [], [(1, 2), (6, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (24, 2), (57, 1), (63, 2), (172, 2)], [(0, 1), (1, 2), (2, 2), (7, 1), (9, 1), (11, 2), (12, 1), (13, 1), (14, 1), (15, 1), (16, 2), (24, 2), (57, 1), (63, 2), (172, 2)], [], [], [], [(1, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 1), (13, 1), (14, 2), (15, 2), (16, 1), (24, 1), (57, 2), (64, 1), (172, 1)], [(0, 1), (1, 2), (2, 2), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (24, 2), (117, 1), (172, 2)], [(0, 1), (1, 2), (2, 2), (7, 1), (8, 2), (9, 1), (11, 2), (13, 2), (14, 1), (15, 1), (16, 2), (24, 2), (115, 1), (172, 2)], [], [(0, 1), (1, 2), (2, 2), (7, 1), (8, 2), (9, 1), (11, 2), (13, 2), (14, 1), (15, 1), (16, 2), (24, 2), (172, 2), (174, 1)], [], [], [], [], [], [(0, 2), (1, 2), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (57, 2), (63, 1), (172, 1)], [(0, 1), (1, 1), (2, 2), (7, 2), (8, 2), (9, 1), (11, 2), (13, 1), (14, 2), (15, 2), (16, 1), (57, 1), (63, 2), (172, 2)], [], [(0, 1), (1, 1), (2, 2), (7, 1), (8, 2), (9, 1), (10, 1), (11, 2), (12, 1), (13, 1), (14, 1), (15, 2), (16, 2), (17, 2), (57, 1), (63, 2), (172, 2)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (6, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (57, 2), (67, 1), (172, 1)], [], [(1, 2), (6, 2), (7, 2), (9, 2), (10, 2), (11, 1), (13, 1), (14, 1), (15, 1), (16, 2), (57, 2), (71, 1), (172, 1)], [(0, 2), (1, 2), (2, 1), (8, 2), (10, 1), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (18, 2), (57, 2), (80, 1), (172, 1)], [(0, 1), (1, 1), (2, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 2), (13, 2), (14, 1), (15, 2), (16, 1), (115, 1), (130, 1), (131, 2), (172, 2)], [], [], [(1, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 2), (12, 1), (13, 2), (14, 1), (15, 1), (16, 2), (17, 2), (24, 1), (51, 1), (57, 2), (63, 1), (172, 1)], [], [], [(0, 1), (1, 1), (2, 2), (6, 2), (7, 1), (8, 2), (10, 1), (11, 2), (12, 1), (13, 1), (14, 2), (15, 2), (16, 1), (17, 2), (24, 1), (57, 1), (63, 1), (99, 1), (172, 2)], [], [], [], [(1, 1), (6, 2), (8, 2), (10, 1), (12, 1), (13, 1), (14, 2), (15, 2), (16, 1), (17, 2), (24, 1), (57, 2), (63, 1), (172, 2), (233, 2), (274, 1)], [(0, 2), (2, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (13, 2), (14, 1), (17, 1), (18, 1), (24, 2), (57, 2), (67, 2), (75, 2), (115, 2), (130, 2), (131, 1), (172, 2), (470, 1)], [(0, 2), (2, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (57, 1), (63, 2), (172, 2)], [], [(7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (114, 1), (172, 2)], [(2, 1), (5, 2), (6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (17, 1), (172, 2), (293, 1)], [], [], [], [], [], [], [], [(7, 1), (8, 1), (9, 1), (10, 2), (11, 2), (13, 2), (57, 1), (63, 2), (115, 2), (131, 1)], [], [], [], [], [(7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1)], [], [], [], [], [], [], [], []] + +def comb34 : List (List (Nat × Nat)) := [[], [], [(6, 1), (9, 1), (11, 2), (12, 1), (13, 2), (17, 2), (57, 1), (63, 2), (64, 1), (68, 2), (114, 1), (233, 1)], [], [], [(6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (17, 2), (233, 1)], [(4, 1), (6, 2), (12, 1), (14, 1), (16, 2), (17, 2), (18, 1), (21, 2), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [], [], [(6, 2), (9, 2), (11, 1), (12, 1), (14, 1), (16, 2), (17, 2), (18, 1), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [(6, 2), (9, 2), (11, 1), (12, 1), (14, 1), (16, 2), (17, 2), (24, 1), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [], [], [(6, 2), (9, 2), (11, 1), (12, 1), (13, 1), (17, 2), (57, 2), (63, 1), (233, 1)], [], [], [(8, 2), (12, 1), (13, 1), (17, 2), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [(6, 2), (12, 1), (13, 1), (17, 2), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [], [], [], [(6, 2), (9, 2), (11, 1), (12, 1), (13, 1), (17, 2), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (7, 1), (12, 2), (13, 1), (17, 1), (18, 2), (19, 2), (21, 2)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 2), (7, 1), (12, 2), (13, 1), (17, 1), (18, 2), (19, 2), (21, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (12, 2), (14, 2), (16, 1), (17, 1), (18, 1), (19, 1), (21, 1), (57, 2), (60, 1), (63, 1), (64, 2), (68, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (14, 1), (16, 2), (17, 1), (19, 1), (21, 2)], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 1), (7, 1), (8, 2), (9, 1), (12, 1), (14, 2), (16, 1), (17, 2), (19, 2), (21, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (6, 2), (7, 1), (8, 1), (14, 1), (16, 2), (17, 1), (19, 2), (21, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (7, 1), (12, 2), (14, 2), (16, 2), (17, 1), (19, 2), (21, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (9, 1), (11, 2), (13, 2), (14, 2), (16, 1), (19, 2), (21, 1), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [], [(0, 2), (1, 1), (2, 2), (3, 1), (6, 1), (7, 2), (13, 2), (14, 2), (16, 1), (19, 1), (21, 2), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (12, 1), (13, 2), (14, 1), (16, 2), (17, 2), (19, 1), (21, 2), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 2), (13, 2), (18, 1), (19, 1), (21, 1), (58, 1), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (11, 2), (12, 1), (13, 2), (14, 1), (16, 2), (17, 2), (19, 1), (21, 2), (57, 1), (63, 2), (64, 1), (233, 2)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 1), (7, 1), (8, 2), (12, 2), (13, 1), (14, 1), (16, 2), (17, 1), (18, 2), (19, 2), (21, 2), (60, 2), (114, 2), (117, 1), (233, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (7, 2), (8, 1), (12, 1), (13, 2), (14, 1), (16, 2), (17, 2), (19, 1), (21, 2), (57, 1), (63, 2), (181, 1), (233, 2)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (14, 1), (16, 2), (18, 2), (19, 2), (21, 2), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 2), (5, 1), (6, 1), (7, 1), (9, 1), (11, 2), (12, 1), (17, 2), (18, 2), (19, 2), (21, 2), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 1), (7, 1), (12, 1), (17, 2), (18, 2), (19, 1), (21, 2), (22, 1), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 2), (7, 2), (9, 2), (11, 1), (12, 2), (17, 1), (18, 1), (19, 1), (21, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 1), (7, 1), (9, 1), (11, 2), (12, 1), (17, 2), (18, 2), (19, 1), (21, 2), (57, 1), (63, 2), (80, 1), (233, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (12, 2), (14, 1), (16, 1), (17, 1), (19, 1), (21, 2), (114, 2), (130, 1), (233, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 1), (7, 1), (12, 2), (14, 1), (16, 2), (17, 1), (18, 2), (19, 2), (21, 2), (57, 1), (60, 2), (63, 2), (114, 2), (127, 1), (233, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (14, 1), (16, 2), (17, 2), (18, 1), (19, 1), (21, 1), (51, 1), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (9, 2), (11, 1), (13, 1), (14, 1), (16, 1), (19, 1), (21, 2), (57, 2), (63, 1), (64, 2), (68, 1), (114, 2), (157, 1), (233, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 2), (7, 1), (9, 2), (11, 1), (13, 1), (14, 1), (16, 2), (18, 2), (19, 2), (21, 2), (57, 2), (58, 2), (63, 1), (64, 2), (68, 1), (233, 2), (392, 1)], [], [], [(6, 2), (8, 1), (13, 2), (14, 1), (18, 1), (21, 2), (114, 1), (130, 2), (233, 2), (470, 1)], [(8, 1), (14, 2), (16, 1), (57, 1), (63, 2), (64, 1), (68, 2), (233, 2)], [(9, 1), (11, 2), (14, 2), (16, 1), (57, 1), (233, 2)], [], [], [(172, 1), (233, 2)], [], [], [(6, 1), (12, 2), (13, 2), (14, 1), (16, 2), (17, 1)], [], [], [], [], [(6, 1), (8, 2), (9, 1), (12, 2), (16, 2), (17, 1), (68, 2), (73, 1)], [], [], [], [(6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (17, 1)], [], [], [], [], [(6, 1), (8, 2), (12, 2), (14, 1), (16, 2), (17, 1)], [], [], []] + +def comb35 : List (List (Nat × Nat)) := [[], [], [(6, 2), (8, 2), (24, 2), (57, 1), (63, 2), (114, 1), (172, 1)], [], [(2, 2), (5, 1), (6, 2), (8, 2), (12, 1), (17, 2), (24, 2), (57, 1), (63, 2), (172, 1), (233, 1)], [(2, 2), (5, 1), (6, 2), (8, 1), (12, 1), (17, 2), (172, 1)], [(5, 1), (8, 2), (13, 1), (17, 2), (57, 2), (63, 1), (172, 1)], [], [(2, 2), (5, 1), (6, 2), (12, 1), (13, 1), (17, 2), (57, 2), (63, 1), (172, 1)], [(2, 1), (5, 2), (6, 1), (8, 1), (12, 2), (17, 1), (18, 1), (57, 2), (63, 1), (172, 1)], [], [], [(2, 2), (5, 1), (6, 2), (8, 1), (12, 1), (17, 2), (18, 2), (24, 1), (60, 2), (77, 1), (172, 1)], [], [], [(0, 1), (2, 1), (5, 1), (6, 2), (12, 1), (14, 1), (16, 2), (17, 2), (19, 2), (20, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [(2, 1), (5, 2), (6, 2), (12, 2), (17, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [], [], [(2, 1), (5, 2), (6, 1), (8, 1), (12, 2), (17, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 2), (12, 1), (13, 1), (17, 1), (18, 1), (19, 2), (24, 1)], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 2), (12, 1), (13, 1), (17, 1), (18, 1), (19, 2), (24, 1)], [], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (7, 2), (12, 1), (13, 1), (17, 1), (18, 2), (19, 1)], [], [(0, 2), (1, 1), (3, 2), (4, 2), (5, 2), (7, 2), (12, 1), (13, 1), (17, 1), (18, 2), (19, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (12, 2), (13, 1), (14, 1), (15, 1), (16, 2), (17, 2), (18, 2), (19, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (13, 1), (14, 1), (17, 1), (18, 2), (19, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (12, 2), (13, 2), (17, 2), (18, 1), (19, 1), (21, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (13, 2), (17, 1), (18, 1), (19, 2), (24, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (12, 2), (13, 1), (18, 2), (19, 1), (24, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (1, 1), (3, 2), (4, 1), (7, 2), (12, 1), (13, 2), (18, 2), (19, 1), (24, 2), (60, 1), (172, 2)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (12, 1), (13, 2), (18, 2), (19, 1), (24, 2), (58, 1), (172, 2)], [], [], [], [(0, 1), (1, 2), (3, 1), (4, 1), (6, 1), (7, 1), (8, 2), (12, 2), (13, 1), (18, 1), (19, 2), (24, 1), (114, 2), (120, 1), (172, 1)], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (12, 2), (13, 2), (14, 2), (16, 1), (17, 2), (18, 2), (19, 2), (20, 2), (24, 2), (172, 2), (174, 1)], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (7, 1), (8, 1), (12, 2), (13, 1), (18, 1), (19, 2), (57, 1), (63, 2), (172, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (7, 1), (8, 1), (12, 2), (13, 1), (18, 1), (19, 2), (57, 1), (63, 2), (172, 2)], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 1), (8, 1), (10, 1), (12, 1), (13, 2), (18, 2), (19, 1), (57, 2), (63, 1), (172, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 1), (8, 2), (13, 1), (14, 2), (16, 1), (17, 2), (18, 1), (19, 2), (57, 1), (63, 2), (172, 2)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (5, 2), (7, 1), (12, 2), (13, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (60, 2), (67, 1), (172, 1)], [(1, 2), (3, 2), (4, 1), (5, 1), (7, 1), (12, 2), (13, 2), (14, 2), (18, 1), (19, 2), (58, 1), (73, 1), (74, 2), (172, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (12, 1), (13, 1), (18, 2), (19, 1), (114, 2), (127, 1), (172, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (13, 2), (17, 1), (18, 1), (19, 1), (114, 2), (137, 1), (172, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (12, 2), (13, 2), (17, 2), (18, 2), (19, 1), (24, 1), (51, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (7, 1), (8, 2), (13, 2), (14, 2), (17, 2), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (114, 2), (157, 1), (172, 2)], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 1), (7, 1), (8, 2), (12, 2), (13, 2), (17, 2), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (172, 2), (233, 2), (274, 1)], [(1, 2), (2, 1), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (12, 1), (15, 1), (17, 1), (18, 1), (20, 2), (24, 2), (60, 1), (67, 2), (172, 2), (470, 1)], [(2, 1), (5, 2), (6, 1), (12, 2), (17, 1), (57, 1), (63, 2), (172, 2)], [(2, 1), (5, 2), (6, 1), (8, 2), (12, 2), (17, 1), (57, 1), (172, 2)], [], [(0, 1), (3, 1), (5, 2), (12, 2), (17, 1), (58, 2), (114, 1), (120, 2), (172, 2), (293, 1)], [], [], [], [(2, 1), (5, 2), (6, 1), (12, 2), (17, 1), (24, 2)], [], [], [], [], [(0, 1), (5, 2), (8, 1), (13, 2), (57, 1), (58, 2), (63, 2), (74, 1)], [], [], [], [(2, 1), (5, 2), (6, 1), (8, 2), (12, 2), (17, 1)], [], [], [], [], [], [], [], []] + +def comb36 : List (List (Nat × Nat)) := [[], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (14, 1), (16, 2), (18, 2), (19, 2), (20, 1), (57, 1), (63, 2), (64, 1), (66, 2), (172, 1), (233, 1)], [], [(3, 2), (4, 1), (6, 1), (8, 2), (14, 1), (16, 2), (19, 2), (20, 1), (233, 1)], [(0, 2), (2, 1), (4, 1), (9, 2), (14, 1), (16, 2), (19, 2), (20, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (8, 2), (14, 1), (16, 2), (19, 2), (20, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (8, 1), (14, 2), (16, 1), (19, 1), (20, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(3, 2), (4, 1), (6, 1), (8, 2), (14, 1), (16, 2), (19, 2), (20, 1), (57, 2), (75, 1), (233, 1)], [], [(3, 1), (4, 2), (6, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 1), (20, 2), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (8, 2), (14, 1), (16, 2), (18, 1), (19, 2), (20, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (8, 2), (14, 2), (16, 1), (18, 1), (19, 1), (20, 2), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (14, 1), (16, 2), (18, 2), (19, 2), (20, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [], [], [], [], [(0, 1), (2, 1), (3, 1), (7, 2), (8, 2), (9, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 2)], [(0, 1), (2, 1), (4, 1), (7, 2), (8, 2), (9, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 2)], [], [], [(2, 1), (3, 2), (7, 1), (9, 1), (14, 2), (16, 1), (20, 2), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1)], [(0, 2), (2, 2), (3, 1), (4, 1), (7, 1), (9, 1), (14, 2), (16, 1), (20, 2), (57, 2), (58, 1), (63, 1), (64, 2), (66, 1)], [], [(0, 1), (2, 1), (4, 1), (6, 1), (7, 1), (8, 2), (9, 2), (14, 2), (16, 1), (20, 2)], [], [(0, 2), (1, 2), (3, 2), (7, 2), (9, 1), (14, 2), (15, 1), (16, 1), (20, 1)], [], [], [(0, 2), (3, 2), (4, 2), (7, 2), (9, 1), (14, 2), (16, 2), (20, 1)], [(0, 2), (3, 2), (4, 2), (7, 2), (9, 1), (14, 1), (16, 2), (20, 1), (21, 1)], [(0, 1), (3, 1), (4, 1), (6, 2), (7, 2), (8, 2), (9, 1), (18, 2), (19, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(1, 1), (2, 1), (4, 1), (7, 1), (8, 1), (9, 2), (18, 2), (19, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [(2, 1), (4, 2), (7, 1), (8, 1), (9, 2), (18, 2), (19, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [], [(0, 1), (4, 2), (6, 2), (7, 1), (8, 2), (9, 1), (18, 2), (19, 2), (57, 1), (63, 2), (64, 1), (233, 2)], [], [], [(2, 1), (3, 2), (4, 2), (7, 1), (8, 1), (9, 2), (18, 2), (19, 2), (57, 1), (63, 2), (120, 1), (233, 2)], [(0, 1), (2, 1), (4, 1), (7, 2), (8, 2), (9, 2), (14, 2), (16, 1), (18, 1), (19, 2), (20, 2), (60, 2), (172, 2), (174, 1), (233, 1)], [], [], [(0, 1), (2, 1), (4, 1), (6, 2), (7, 2), (8, 1), (9, 2), (19, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [], [(2, 1), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (9, 2), (19, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [(2, 2), (3, 2), (4, 2), (7, 1), (9, 2), (10, 1), (19, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(2, 1), (3, 1), (4, 1), (7, 1), (9, 1), (14, 2), (16, 1), (19, 2), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [], [], [(1, 1), (2, 1), (3, 2), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (15, 2), (19, 1), (20, 1), (57, 1), (63, 2), (64, 1), (66, 2), (67, 1), (233, 2)], [(0, 2), (2, 2), (3, 1), (4, 1), (6, 1), (7, 1), (8, 2), (9, 2), (14, 2), (19, 2), (57, 2), (63, 1), (64, 2), (73, 1), (233, 1)], [], [], [(2, 1), (3, 2), (4, 1), (7, 1), (9, 1), (14, 2), (19, 2), (57, 2), (63, 1), (120, 2), (130, 1), (233, 1)], [], [], [(1, 2), (2, 2), (4, 2), (7, 2), (8, 2), (9, 1), (18, 1), (19, 1), (51, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [], [], [(0, 1), (2, 1), (4, 2), (7, 2), (8, 1), (9, 1), (14, 1), (16, 2), (18, 1), (20, 1), (57, 1), (63, 2), (64, 2), (66, 1), (120, 2), (233, 2), (392, 1)], [(0, 2), (2, 2), (3, 2), (6, 1), (7, 1), (8, 1), (9, 2), (16, 2), (18, 1), (19, 1), (20, 1), (57, 2), (63, 1), (64, 2), (66, 1), (172, 2), (216, 1), (233, 2)], [], [(1, 2), (2, 1), (4, 2), (7, 1), (15, 1), (16, 1), (19, 1), (20, 1), (57, 1), (64, 2), (66, 1), (67, 2), (75, 2), (120, 1), (130, 2), (233, 2), (470, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (8, 1), (14, 2), (16, 1), (19, 1), (20, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(3, 1), (4, 2), (6, 2), (8, 1), (14, 2), (16, 1), (19, 1), (20, 2), (57, 1), (233, 2)], [(3, 1), (4, 2), (6, 2), (8, 1), (14, 2), (16, 1), (19, 1), (20, 2), (114, 1), (233, 2)], [], [], [], [], [], [(3, 1), (4, 2), (13, 1), (14, 2), (16, 1), (18, 2), (19, 1), (20, 2)], [], [], [], [], [(3, 1), (4, 2), (66, 2), (68, 1)], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (11, 1)], [], [], [], [], [], [], []] + +def comb37 : List (List (Nat × Nat)) := [[], [], [], [], [(0, 2), (5, 1), (8, 2), (9, 1), (10, 2), (18, 2), (20, 1), (24, 2), (57, 1), (63, 2), (66, 2), (172, 1), (233, 1)], [(2, 2), (5, 1), (8, 1), (10, 2), (18, 2), (20, 1), (172, 1)], [(5, 1), (6, 1), (9, 1), (10, 2), (12, 2), (18, 2), (20, 1), (58, 2), (66, 2), (72, 1), (172, 1)], [(0, 1), (2, 1), (5, 1), (8, 1), (9, 2), (10, 2), (18, 2), (20, 1), (57, 2), (63, 1), (66, 1), (172, 1)], [], [(0, 1), (5, 2), (8, 1), (9, 2), (10, 1), (18, 2), (20, 2), (57, 2), (63, 1), (66, 1), (172, 1)], [], [(0, 1), (2, 1), (5, 1), (8, 1), (9, 2), (10, 2), (18, 1), (20, 1), (24, 1), (57, 2), (66, 1), (75, 1), (172, 1)], [], [], [(0, 1), (2, 1), (5, 1), (9, 2), (10, 2), (18, 2), (20, 1), (24, 1), (57, 2), (63, 1), (66, 1), (172, 1)], [], [(0, 1), (5, 2), (6, 1), (9, 2), (10, 1), (18, 1), (20, 2), (24, 1), (57, 2), (63, 1), (66, 1), (172, 1)], [], [(0, 2), (2, 2), (5, 2), (8, 1), (9, 1), (10, 1), (18, 1), (20, 2), (24, 1), (57, 2), (63, 1), (66, 2), (172, 1)], [], [(0, 2), (5, 1), (8, 2), (9, 1), (10, 2), (18, 2), (20, 1), (24, 2), (57, 1), (63, 2), (66, 2), (172, 2)], [], [], [], [], [(1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (9, 1), (10, 1), (12, 2), (18, 1), (20, 2), (24, 1), (25, 1), (57, 1), (58, 2), (63, 2), (66, 1), (72, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (9, 1), (10, 1), (12, 2), (18, 1), (20, 2), (24, 1), (25, 1), (57, 1), (58, 2), (63, 2), (66, 1), (72, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (9, 1), (10, 1), (12, 1), (18, 1), (20, 2), (25, 2), (57, 1), (58, 1), (60, 1), (63, 2), (72, 2)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 1), (10, 1), (12, 2), (18, 1), (20, 2), (25, 2), (57, 1), (58, 2), (63, 2), (66, 1), (72, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (10, 2), (12, 1), (15, 1), (18, 2), (20, 1), (25, 1), (57, 2), (58, 1), (63, 1), (66, 2), (72, 2)], [(1, 1), (3, 1), (4, 2), (5, 2), (6, 2), (9, 2), (10, 1), (12, 1), (18, 1), (20, 2), (25, 2), (57, 2), (58, 1), (63, 1), (72, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (10, 2), (12, 2), (18, 2), (20, 1), (25, 1), (57, 2), (58, 1), (63, 1), (66, 2), (72, 2)], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (9, 2), (10, 2), (12, 1), (18, 1), (20, 1), (21, 1), (25, 2), (57, 2), (58, 1), (63, 1), (66, 2), (72, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (8, 2), (10, 1), (12, 1), (24, 2), (25, 2), (58, 1), (66, 1), (72, 2), (172, 2)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (9, 2), (12, 2), (24, 2), (25, 2), (57, 2), (58, 2), (63, 1), (66, 2), (72, 1), (172, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (9, 1), (12, 2), (24, 2), (25, 2), (57, 2), (58, 2), (63, 1), (72, 1), (172, 2)], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 2), (8, 2), (9, 2), (12, 1), (24, 2), (25, 2), (57, 2), (58, 2), (63, 1), (66, 2), (72, 2), (172, 2)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (9, 1), (12, 1), (24, 2), (25, 2), (57, 2), (58, 1), (63, 1), (72, 2), (115, 1), (172, 2)], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (9, 1), (10, 1), (12, 2), (18, 1), (20, 2), (24, 1), (25, 1), (57, 1), (58, 2), (60, 2), (63, 2), (66, 1), (72, 1), (172, 1), (233, 2), (236, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (8, 2), (12, 2), (25, 1), (57, 2), (58, 2), (63, 1), (66, 2), (72, 1), (172, 2)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 1), (8, 2), (9, 2), (12, 2), (25, 1), (57, 2), (58, 2), (63, 1), (72, 1), (172, 2)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (7, 1), (9, 2), (10, 2), (12, 2), (25, 1), (57, 2), (58, 2), (63, 1), (72, 1), (172, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (9, 1), (17, 1), (25, 2), (57, 1), (58, 1), (63, 2), (72, 2), (172, 1)], [], [], [(1, 2), (3, 2), (4, 1), (5, 1), (6, 1), (9, 1), (10, 2), (12, 2), (15, 2), (18, 2), (20, 1), (25, 2), (57, 2), (58, 2), (63, 1), (65, 1), (72, 1), (172, 2)], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (8, 1), (9, 1), (12, 2), (18, 1), (20, 2), (25, 1), (57, 1), (58, 2), (60, 2), (63, 2), (66, 1), (71, 1), (72, 1), (172, 1)], [], [], [(1, 1), (2, 1), (5, 1), (6, 2), (9, 2), (10, 1), (12, 1), (18, 1), (20, 2), (25, 1), (57, 2), (58, 1), (60, 2), (63, 1), (72, 2), (127, 1), (172, 1)], [], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (9, 1), (12, 2), (17, 2), (24, 1), (25, 1), (51, 1), (57, 1), (58, 1), (63, 2), (66, 1), (72, 2), (172, 1)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (10, 2), (12, 2), (18, 2), (20, 1), (24, 1), (25, 1), (58, 1), (66, 2), (72, 1), (172, 2), (392, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 2), (10, 2), (12, 1), (18, 2), (20, 1), (24, 1), (25, 2), (58, 2), (66, 2), (72, 1), (172, 2), (233, 2), (274, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (9, 1), (10, 1), (12, 1), (17, 2), (18, 2), (20, 2), (24, 2), (57, 1), (66, 2), (75, 2), (172, 2), (470, 1)], [(0, 2), (2, 2), (5, 2), (9, 1), (10, 1), (18, 1), (20, 2), (57, 1), (63, 2), (66, 2), (172, 2)], [(0, 2), (2, 2), (5, 2), (8, 2), (9, 1), (10, 1), (18, 1), (20, 2), (57, 1), (66, 2), (172, 2)], [(2, 1), (5, 2), (6, 2), (10, 1), (18, 1), (20, 2), (114, 1), (172, 2)], [], [], [], [], [], [(0, 2), (2, 2), (5, 2), (8, 2), (9, 1), (10, 1), (13, 1), (18, 1), (20, 2), (24, 2), (66, 2)], [], [], [], [], [(0, 2), (2, 2), (5, 2), (8, 2), (9, 1), (10, 1), (15, 1), (18, 1), (20, 2), (25, 2), (65, 2), (66, 2), (68, 1)], [], [], [], [(2, 1), (5, 2), (6, 1), (7, 2), (8, 2), (10, 1), (11, 1), (66, 2)], [], [], [], [], [], [], []] + +def comb38 : List (List (Nat × Nat)) := [[], [], [], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (13, 1), (14, 2), (19, 2), (24, 2), (44, 1), (57, 1), (63, 2), (172, 1), (293, 1)], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (13, 1), (14, 2), (19, 2), (24, 2), (44, 1), (57, 1), (63, 2), (233, 1), (293, 1)], [(2, 1), (5, 2), (6, 2), (10, 1), (13, 1), (14, 2), (19, 2), (44, 1), (293, 1)], [(1, 1), (2, 1), (5, 2), (6, 2), (8, 2), (10, 1), (13, 2), (14, 2), (15, 2), (19, 2), (44, 1), (57, 2), (63, 1), (293, 1)], [(3, 1), (4, 2), (6, 2), (7, 1), (13, 1), (14, 2), (19, 2), (44, 1), (57, 2), (63, 1), (293, 1)], [(2, 1), (5, 2), (6, 2), (8, 2), (10, 1), (13, 2), (14, 2), (19, 2), (44, 1), (57, 2), (63, 1), (293, 1)], [], [], [(3, 1), (4, 2), (6, 2), (7, 1), (13, 1), (14, 2), (18, 2), (19, 2), (24, 1), (44, 1), (57, 2), (75, 1), (293, 1)], [(1, 2), (2, 2), (5, 2), (6, 2), (7, 1), (8, 2), (10, 1), (12, 2), (13, 1), (14, 2), (15, 1), (19, 1), (24, 1), (44, 1), (60, 2), (77, 1), (293, 1)], [], [(3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (13, 1), (14, 2), (19, 2), (24, 1), (44, 1), (57, 2), (63, 1), (293, 1)], [(3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (13, 1), (14, 2), (19, 1), (20, 1), (24, 1), (44, 1), (57, 2), (63, 1), (293, 1)], [], [], [], [], [], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (13, 1), (14, 2), (19, 2), (24, 2), (44, 1), (57, 1), (63, 2), (293, 2)], [], [], [], [], [(1, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (10, 1), (14, 1), (15, 2), (19, 2), (24, 1), (44, 2)], [(1, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 1), (10, 2), (14, 1), (15, 2), (19, 2), (24, 1), (44, 2)], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 1), (10, 1), (13, 1), (14, 1), (15, 1), (44, 2), (57, 2), (58, 1), (63, 1)], [], [(1, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (10, 1), (14, 1), (15, 2), (44, 2)], [(1, 1), (3, 2), (4, 2), (5, 1), (6, 1), (7, 1), (8, 2), (10, 2), (14, 1), (15, 2), (44, 2)], [], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 2), (13, 1), (14, 1), (15, 1), (44, 2)], [(1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (10, 1), (12, 1), (14, 1), (15, 1), (44, 2)], [(1, 2), (3, 1), (4, 2), (5, 1), (6, 1), (7, 1), (8, 2), (10, 2), (14, 2), (15, 1), (44, 2)], [], [(1, 2), (5, 1), (8, 2), (10, 2), (13, 2), (15, 1), (19, 2), (24, 2), (57, 1), (63, 2), (293, 2)], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (10, 1), (13, 1), (15, 2), (19, 2), (24, 2), (57, 1), (63, 2), (293, 2)], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (8, 2), (10, 1), (13, 2), (15, 1), (19, 2), (24, 2), (60, 1), (293, 2)], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (8, 2), (10, 1), (13, 2), (15, 1), (19, 2), (24, 2), (117, 1), (293, 2)], [], [], [], [], [(1, 1), (3, 2), (5, 2), (6, 1), (8, 1), (10, 1), (14, 1), (15, 2), (19, 2), (24, 1), (44, 2), (172, 2), (181, 1), (293, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (8, 2), (10, 1), (13, 1), (15, 2), (19, 1), (57, 1), (63, 2), (293, 2)], [(1, 1), (3, 1), (4, 2), (5, 2), (7, 1), (8, 2), (10, 1), (13, 1), (15, 2), (19, 1), (57, 1), (63, 2), (293, 2)], [], [], [], [], [], [], [(1, 2), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 1), (10, 1), (13, 1), (14, 1), (15, 1), (19, 2), (22, 1), (44, 2), (57, 2), (63, 1), (293, 1)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (10, 1), (13, 1), (15, 2), (19, 1), (60, 1), (66, 1), (67, 2), (293, 2)], [], [], [], [], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (10, 1), (14, 1), (15, 2), (19, 2), (44, 2), (58, 2), (80, 1), (293, 1)], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (10, 2), (13, 1), (14, 1), (15, 1), (19, 2), (44, 2), (58, 2), (137, 1), (293, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 1), (10, 2), (13, 2), (15, 1), (19, 1), (24, 1), (51, 1), (57, 2), (63, 1), (293, 1)], [], [], [], [], [], [(1, 1), (2, 1), (5, 1), (10, 2), (13, 2), (14, 2), (15, 2), (19, 1), (24, 1), (57, 2), (63, 1), (172, 2), (216, 1), (293, 2)], [(1, 1), (2, 2), (3, 2), (4, 1), (7, 2), (12, 2), (13, 2), (15, 2), (19, 1), (24, 1), (57, 2), (63, 1), (233, 2), (274, 1), (293, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (7, 2), (10, 1), (18, 1), (19, 1), (20, 2), (24, 2), (57, 1), (75, 2), (293, 2), (470, 1)], [(3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (13, 2), (14, 1), (19, 1), (44, 2), (57, 1), (63, 2), (293, 2)], [(3, 2), (4, 1), (6, 1), (7, 2), (13, 2), (14, 1), (19, 1), (44, 2), (57, 1), (293, 2)], [(2, 2), (5, 1), (8, 1), (10, 2), (13, 2), (14, 1), (19, 1), (44, 2), (114, 1), (293, 2)], [], [], [], [], [], [], [(18, 1), (24, 2)], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (57, 1), (60, 2), (63, 2), (67, 1)], [], [], [], [(6, 1), (8, 2)], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (7, 1), (10, 2)], [], [], []] + +def comb39 : List (List (Nat × Nat)) := [[], [], [(0, 1), (2, 2), (8, 2), (9, 2), (11, 1), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [(0, 1), (2, 2), (8, 2), (9, 2), (11, 1), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (172, 1)], [(0, 1), (2, 2), (6, 1), (8, 1), (9, 2), (11, 1), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (233, 1)], [(0, 2), (2, 1), (6, 2), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (57, 1), (63, 1)], [(0, 2), (1, 1), (2, 1), (8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (51, 2), (63, 2)], [], [], [], [], [], [], [], [], [], [], [], [(0, 1), (2, 2), (8, 2), (9, 2), (11, 1), (14, 1), (16, 2), (24, 1), (63, 1)], [(8, 2), (24, 1), (63, 1)], [(6, 1), (8, 1), (24, 1), (63, 1)], [(1, 1), (2, 2), (6, 1), (8, 1), (9, 2), (11, 1), (12, 1), (24, 1), (51, 2), (57, 2), (58, 1), (63, 2), (72, 2)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (8, 2), (12, 1), (14, 2), (15, 1), (16, 1), (24, 2), (34, 1), (51, 1), (58, 1), (60, 2), (63, 1), (64, 1), (66, 2), (67, 1), (72, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 1), (12, 2), (14, 2), (15, 2), (16, 1), (24, 2), (34, 1), (51, 2), (57, 1), (58, 2), (72, 1)], [], [], [], [], [(0, 2), (3, 1), (4, 2), (8, 1), (12, 1), (14, 2), (15, 1), (16, 1), (24, 2), (34, 2), (51, 1), (58, 1), (63, 1), (72, 2), (114, 2), (121, 1)], [], [], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (9, 1), (11, 2), (12, 1), (14, 1), (15, 2), (16, 2), (34, 2), (57, 2), (58, 1), (72, 2)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (9, 1), (12, 1), (14, 1), (15, 1), (16, 2), (34, 2), (57, 2), (58, 1), (72, 2)], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (15, 1), (34, 2), (57, 2), (58, 1), (72, 2)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (9, 1), (11, 2), (12, 1), (14, 1), (15, 1), (34, 2), (57, 2), (58, 1), (72, 2)], [(0, 1), (3, 2), (12, 2), (15, 1), (21, 1), (34, 2), (51, 2), (57, 1), (58, 2), (63, 1), (72, 1)], [], [(0, 1), (1, 2), (3, 2), (4, 1), (8, 1), (12, 2), (14, 1), (15, 2), (16, 2), (24, 2), (34, 1), (57, 1), (58, 2), (63, 2), (72, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (8, 1), (12, 1), (14, 2), (15, 2), (16, 1), (24, 2), (34, 1), (51, 1), (57, 2), (58, 1), (63, 1), (72, 2)], [(0, 2), (3, 2), (4, 2), (6, 2), (8, 2), (12, 1), (14, 2), (15, 2), (16, 1), (24, 2), (34, 1), (51, 1), (57, 2), (58, 1), (63, 1), (72, 2)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (9, 2), (11, 1), (12, 2), (14, 2), (15, 2), (16, 1), (24, 2), (34, 1), (51, 2), (58, 2), (60, 1), (72, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (12, 1), (14, 2), (15, 2), (16, 1), (24, 2), (34, 1), (57, 1), (58, 2), (63, 2), (72, 2)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (6, 1), (9, 2), (12, 2), (14, 2), (16, 1), (24, 2), (34, 1), (51, 2), (58, 2), (60, 1), (66, 1), (67, 2), (72, 1)], [], [], [], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (8, 1), (12, 2), (14, 1), (15, 1), (16, 2), (24, 2), (34, 2), (57, 1), (58, 2), (63, 2), (72, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (8, 1), (9, 2), (11, 1), (12, 2), (14, 2), (15, 1), (16, 1), (24, 2), (34, 2), (57, 1), (58, 2), (63, 2), (72, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (8, 1), (12, 1), (14, 2), (15, 1), (16, 1), (24, 2), (34, 2), (51, 1), (57, 2), (58, 1), (63, 1), (72, 2)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (8, 2), (12, 1), (14, 2), (15, 1), (16, 1), (24, 2), (34, 2), (51, 1), (57, 2), (58, 1), (63, 1), (72, 2)], [], [], [], [], [], [], [], [], [], [], [], [(0, 1), (2, 1), (3, 2), (4, 2), (6, 2), (9, 1), (11, 2), (12, 1), (14, 1), (15, 2), (16, 1), (24, 1), (34, 1), (51, 1), (58, 1), (72, 2), (114, 2), (130, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (9, 1), (11, 2), (12, 1), (14, 1), (15, 1), (16, 2), (34, 2), (58, 1), (72, 2), (114, 2), (127, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (9, 1), (11, 2), (12, 1), (14, 1), (15, 1), (16, 2), (34, 2), (58, 1), (72, 2), (114, 2), (137, 1)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (11, 1), (12, 2), (14, 2), (15, 2), (16, 1), (34, 1), (51, 2), (57, 2), (58, 2), (63, 1), (72, 1), (114, 1), (121, 2), (314, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (8, 2), (9, 2), (11, 1), (12, 2), (14, 2), (15, 2), (24, 1), (34, 1), (44, 1), (57, 1), (58, 2), (72, 1)], [(1, 1), (2, 1), (3, 2), (4, 2), (6, 2), (9, 1), (11, 1), (12, 2), (24, 1), (34, 1), (51, 2), (57, 2), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (99, 1)], [], [], [], [], [(1, 1), (4, 2), (8, 1), (16, 1), (24, 2), (51, 2), (57, 2), (114, 1), (130, 2), (470, 1)], [(8, 1), (63, 2)], [], [], [], [], [], [], [(8, 1), (24, 2)], [(0, 2), (2, 1), (9, 1), (11, 2), (13, 1), (14, 2), (16, 1), (24, 2)], [(6, 2), (8, 1), (18, 1), (24, 2)], [], [], [(1, 2), (2, 1), (6, 1), (8, 2), (9, 1), (12, 2), (15, 2), (16, 2), (51, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 2), (67, 1), (72, 1), (73, 1)], [(1, 2), (2, 1), (6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (15, 2), (51, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 2), (67, 1), (68, 1), (72, 1)], [(6, 1), (8, 2), (15, 2), (51, 1), (57, 1), (60, 2), (63, 2), (67, 1)], [], [], [], [], [], [], [], [], [], []] + +def comb40 : List (List (Nat × Nat)) := [[], [(2, 2), (5, 1), (8, 2), (14, 1), (16, 2), (24, 1), (63, 1)], [], [(2, 2), (5, 1), (8, 2), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (172, 1)], [(2, 1), (3, 1), (4, 2), (5, 2), (8, 2), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (233, 1)], [(3, 1), (4, 2), (6, 1), (8, 1), (14, 2), (16, 1), (24, 1), (57, 2), (63, 1), (114, 2)], [], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (14, 2), (16, 1), (24, 1), (57, 1), (63, 2), (114, 2)], [], [], [], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (14, 2), (16, 1), (18, 2), (24, 2), (57, 1), (63, 1), (75, 1), (114, 2)], [], [], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (9, 2), (11, 1), (14, 1), (16, 2), (19, 2), (20, 1), (24, 1), (57, 2), (63, 1), (114, 1)], [(2, 2), (5, 1), (8, 2), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [(0, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (9, 1), (11, 2), (14, 2), (16, 1), (19, 2), (24, 2), (34, 1), (57, 2), (64, 1), (114, 1)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (9, 1), (11, 2), (14, 2), (16, 1), (19, 2), (24, 2), (34, 1), (57, 2), (63, 1), (114, 1)], [], [], [], [], [], [], [], [(0, 1), (2, 2), (7, 1), (9, 2), (11, 1), (14, 1), (16, 2), (19, 2), (34, 2), (57, 1), (63, 2), (114, 2)], [(0, 2), (2, 1), (3, 1), (6, 2), (7, 2), (8, 1), (9, 1), (11, 1), (14, 1), (16, 2), (19, 1), (34, 2), (57, 1), (63, 2), (114, 2)], [], [], [(0, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 1), (12, 1), (19, 2), (34, 2), (57, 1), (63, 2), (114, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 1), (11, 1), (14, 1), (19, 1), (34, 2), (57, 1), (63, 2), (114, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 1), (11, 1), (19, 1), (21, 1), (34, 2), (57, 1), (63, 2), (114, 2)], [(0, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (9, 2), (11, 1), (14, 1), (16, 2), (19, 2), (24, 2), (34, 1)], [], [(0, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (9, 1), (11, 2), (14, 2), (16, 1), (19, 1), (24, 2), (34, 1)], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 2), (14, 2), (16, 1), (19, 2), (24, 2), (34, 1)], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 1), (14, 2), (16, 1), (19, 2), (24, 2), (34, 1), (57, 2), (63, 1), (117, 1)], [(0, 1), (2, 2), (6, 1), (7, 1), (9, 1), (11, 2), (14, 2), (16, 1), (19, 2), (24, 2), (34, 1), (57, 2), (63, 1), (115, 1)], [(0, 1), (3, 1), (4, 1), (5, 2), (6, 2), (7, 1), (8, 2), (9, 2), (11, 2), (14, 2), (16, 1), (19, 2), (24, 2), (34, 1), (63, 1), (64, 2), (120, 1)], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (9, 2), (11, 1), (14, 1), (16, 2), (19, 1), (24, 2), (34, 2)], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (9, 1), (11, 2), (14, 2), (16, 1), (19, 1), (24, 2), (34, 2)], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (8, 2), (9, 1), (10, 1), (11, 2), (14, 2), (16, 1), (19, 1), (24, 2), (34, 2)], [], [], [], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (9, 2), (11, 2), (14, 1), (16, 1), (19, 2), (24, 1), (34, 1), (63, 2), (73, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (14, 1), (16, 2), (19, 1), (34, 2), (63, 2), (71, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (14, 1), (16, 2), (19, 1), (34, 2), (63, 2), (80, 1)], [], [], [], [], [(0, 1), (2, 1), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (11, 1), (14, 2), (16, 1), (19, 2), (34, 1), (57, 1), (63, 2), (114, 1), (314, 1)], [(0, 1), (2, 1), (5, 1), (7, 2), (8, 2), (9, 2), (11, 2), (14, 2), (19, 1), (24, 1), (34, 1), (44, 1), (57, 2), (63, 1), (114, 1)], [], [(0, 2), (5, 1), (7, 2), (8, 2), (9, 2), (11, 2), (14, 2), (19, 1), (24, 1), (34, 1), (57, 2), (63, 2), (64, 2), (114, 1), (157, 1)], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 1), (11, 2), (18, 1), (19, 1), (20, 2), (24, 2), (57, 1), (75, 2), (114, 2), (470, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (57, 1), (63, 2), (114, 2)], [], [], [], [], [], [], [], [(2, 1), (5, 2), (13, 1), (14, 2), (16, 1), (24, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (18, 1), (24, 2)], [], [(2, 1), (4, 1), (5, 2), (16, 2), (63, 2), (64, 1), (120, 2), (130, 1)], [], [(2, 1), (5, 2), (63, 2), (68, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (63, 2), (66, 1)], [], [], [], [], [], [], [], [], [], []] + +def comb41 : List (List (Nat × Nat)) := [[], [(3, 1), (4, 2), (9, 2), (18, 2), (21, 1), (24, 1), (68, 1)], [(3, 1), (4, 2), (9, 2), (18, 2), (21, 1), (24, 1), (57, 2), (68, 1), (114, 1)], [], [(3, 2), (4, 1), (6, 1), (9, 1), (18, 1), (21, 2), (24, 1), (57, 2), (63, 2), (68, 2), (233, 1)], [(6, 2), (24, 1), (57, 2), (63, 1), (172, 2)], [], [], [], [(3, 1), (4, 2), (6, 2), (9, 2), (21, 1), (24, 1), (57, 1), (63, 1), (68, 1), (172, 2)], [], [], [], [], [(3, 1), (4, 2), (9, 2), (18, 2), (21, 1), (24, 1), (57, 2), (68, 1), (172, 1)], [(3, 1), (4, 2), (7, 1), (9, 2), (10, 2), (14, 1), (16, 2), (18, 2), (19, 2), (20, 1), (21, 1), (24, 1), (57, 2), (68, 1), (172, 1)], [], [(3, 2), (4, 1), (8, 1), (9, 1), (18, 1), (21, 2), (24, 1), (57, 2), (63, 2), (68, 2), (172, 1)], [], [], [(3, 2), (4, 1), (6, 1), (9, 1), (18, 1), (21, 2), (24, 1), (57, 2), (63, 2), (68, 2), (172, 1)], [], [(1, 1), (3, 2), (4, 1), (7, 1), (9, 2), (10, 1), (14, 2), (15, 2), (16, 1), (18, 1), (19, 1), (21, 1), (24, 2), (34, 1), (57, 2), (64, 1), (172, 1)], [], [], [], [(1, 1), (3, 2), (4, 1), (7, 1), (9, 2), (10, 1), (14, 2), (15, 2), (16, 1), (18, 1), (19, 1), (21, 1), (24, 2), (34, 1), (57, 2), (68, 1), (172, 1)], [], [], [], [(1, 1), (7, 1), (9, 1), (10, 1), (14, 2), (15, 2), (16, 1), (19, 1), (21, 2), (34, 1), (57, 1), (58, 1), (66, 1), (68, 1), (72, 2), (172, 1)], [(1, 2), (6, 2), (9, 2), (10, 2), (14, 1), (15, 1), (16, 2), (18, 1), (19, 1), (21, 1), (34, 2), (57, 1), (63, 1), (68, 1), (172, 2)], [], [(1, 2), (3, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 2), (14, 1), (15, 1), (16, 2), (19, 2), (21, 1), (34, 2), (57, 1), (68, 2), (172, 2)], [(1, 1), (3, 2), (4, 1), (8, 2), (9, 2), (10, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 1), (21, 1), (34, 2), (57, 1), (63, 1), (68, 1), (172, 2)], [(1, 2), (7, 2), (9, 2), (10, 2), (14, 1), (15, 1), (16, 2), (19, 2), (21, 1), (34, 2), (57, 1), (68, 2), (172, 2)], [], [(1, 2), (7, 2), (9, 1), (10, 2), (14, 2), (15, 1), (16, 2), (19, 2), (21, 1), (34, 2), (57, 1), (68, 2), (172, 2)], [], [(1, 1), (3, 1), (4, 2), (6, 1), (8, 2), (10, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (24, 2), (34, 1)], [(1, 2), (3, 2), (4, 1), (10, 1), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (24, 2), (34, 1)], [], [(1, 1), (3, 1), (4, 2), (7, 1), (8, 2), (9, 1), (10, 1), (14, 2), (15, 2), (16, 1), (18, 2), (19, 1), (24, 2), (34, 1), (63, 1), (68, 2)], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (10, 2), (14, 1), (15, 1), (16, 2), (18, 1), (19, 2), (24, 1), (34, 2), (63, 2), (66, 2), (68, 1), (72, 1)], [], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (10, 2), (14, 1), (15, 1), (16, 2), (18, 1), (19, 2), (24, 1), (34, 2), (57, 1), (58, 2), (63, 2), (66, 2), (68, 1), (72, 1), (114, 2), (115, 1)], [], [(1, 1), (9, 2), (10, 2), (14, 1), (15, 2), (16, 2), (18, 1), (19, 2), (20, 2), (21, 1), (24, 2), (34, 1), (57, 2), (68, 1), (174, 1)], [], [(1, 1), (3, 1), (4, 1), (7, 1), (8, 2), (9, 1), (10, 1), (14, 2), (15, 2), (16, 1), (18, 2), (19, 1), (24, 2), (34, 1), (63, 1), (64, 2), (181, 1)], [], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (9, 2), (10, 2), (14, 1), (15, 1), (16, 2), (19, 2), (21, 1), (24, 2), (34, 2), (63, 2), (68, 1)], [], [(1, 2), (8, 1), (9, 2), (10, 1), (14, 1), (15, 1), (16, 2), (19, 2), (21, 1), (24, 2), (34, 2), (63, 2), (68, 1)], [], [(1, 2), (7, 2), (8, 1), (9, 2), (10, 2), (15, 1), (19, 2), (21, 1), (24, 2), (34, 2), (63, 2), (68, 1)], [], [(1, 2), (3, 2), (4, 1), (10, 1), (14, 1), (15, 1), (16, 2), (18, 1), (19, 1), (22, 1), (24, 2), (34, 2)], [(1, 1), (6, 2), (7, 1), (9, 1), (10, 1), (14, 2), (15, 2), (16, 1), (19, 1), (21, 2), (24, 1), (34, 1), (63, 1), (66, 1), (68, 1)], [], [(1, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 1), (10, 1), (14, 1), (15, 1), (16, 2), (18, 2), (19, 2), (21, 2), (24, 1), (34, 1), (67, 1), (68, 2)], [], [(1, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 1), (10, 1), (14, 1), (15, 1), (16, 2), (19, 1), (21, 2), (34, 2), (68, 2), (71, 1)], [], [], [(1, 1), (9, 1), (10, 2), (14, 1), (15, 1), (16, 2), (19, 1), (21, 2), (34, 2), (57, 1), (68, 2), (114, 2), (127, 1)], [], [], [(1, 1), (6, 1), (8, 2), (9, 1), (10, 2), (14, 2), (15, 2), (16, 1), (19, 1), (21, 2), (34, 1), (57, 1), (68, 2), (172, 1), (314, 1)], [(1, 1), (3, 1), (4, 2), (7, 1), (9, 1), (10, 1), (14, 1), (15, 2), (16, 1), (18, 2), (19, 1), (24, 1), (34, 1), (44, 1), (57, 2), (63, 2), (68, 2), (172, 1)], [], [], [], [(1, 1), (3, 1), (4, 2), (6, 1), (9, 1), (10, 1), (14, 1), (15, 2), (16, 1), (18, 1), (19, 2), (24, 1), (34, 1), (57, 2), (63, 2), (64, 2), (172, 1), (216, 1)], [], [(1, 2), (3, 2), (4, 1), (8, 2), (9, 1), (10, 1), (15, 1), (18, 2), (20, 2), (21, 2), (24, 2), (57, 1), (63, 1), (67, 2), (68, 2), (172, 2), (470, 1)], [(3, 2), (4, 1), (9, 1), (18, 1), (21, 2), (57, 1), (68, 2), (172, 2)], [], [], [], [], [], [], [(3, 2), (4, 1), (9, 1), (18, 1), (21, 2), (24, 2), (63, 1), (68, 2)], [(3, 2), (4, 1), (8, 2), (9, 1), (13, 1), (18, 1), (21, 2), (24, 2), (63, 1), (68, 2)], [], [], [(9, 1), (14, 2), (57, 1), (68, 2), (114, 2), (130, 1)], [(9, 1), (14, 2), (68, 2), (73, 1)], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb42 : List (List (Nat × Nat)) := [[], [(1, 2), (2, 2), (5, 2), (7, 1), (12, 2), (18, 1), (19, 2), (24, 2), (25, 1), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1)], [(0, 1), (1, 2), (2, 1), (5, 2), (6, 2), (7, 1), (8, 1), (12, 2), (18, 1), (19, 2), (24, 2), (25, 1), (57, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (114, 1)], [(1, 1), (5, 2), (7, 2), (12, 1), (15, 1), (18, 1), (19, 1), (24, 2), (25, 1), (57, 2), (65, 1), (66, 1), (67, 1), (68, 2), (72, 2), (172, 1)], [], [(0, 2), (2, 2), (5, 2), (15, 2), (18, 1), (24, 2), (25, 1), (57, 2), (67, 1), (233, 2)], [], [], [], [], [(1, 2), (5, 1), (7, 1), (12, 2), (15, 2), (18, 1), (19, 2), (24, 2), (25, 2), (57, 1), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 2)], [], [], [(0, 2), (1, 2), (5, 2), (7, 1), (8, 2), (12, 2), (18, 2), (19, 2), (24, 2), (25, 1), (57, 1), (63, 1), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (233, 2)], [(0, 1), (1, 2), (2, 1), (5, 2), (7, 1), (12, 2), (18, 1), (19, 2), (24, 2), (25, 1), (57, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (233, 1)], [(0, 1), (1, 2), (2, 1), (5, 2), (7, 1), (12, 2), (18, 1), (19, 1), (20, 1), (24, 2), (25, 1), (57, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (233, 1)], [(1, 1), (5, 2), (6, 1), (7, 2), (8, 2), (12, 1), (15, 1), (18, 1), (19, 1), (24, 2), (25, 1), (57, 2), (65, 1), (66, 1), (67, 1), (68, 2), (72, 2), (233, 1)], [], [(0, 1), (1, 1), (2, 2), (5, 2), (7, 2), (12, 1), (15, 1), (18, 1), (19, 1), (24, 2), (25, 1), (57, 2), (65, 1), (66, 1), (67, 1), (68, 2), (72, 2), (233, 1)], [(1, 1), (5, 2), (7, 2), (12, 1), (15, 1), (18, 1), (19, 1), (24, 2), (25, 1), (57, 2), (65, 1), (66, 1), (67, 1), (68, 2), (72, 2), (233, 1)], [], [], [(0, 1), (1, 1), (2, 1), (5, 2), (6, 2), (7, 2), (8, 2), (12, 2), (15, 1), (19, 1), (24, 2), (25, 1), (34, 1), (57, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (233, 1)], [], [], [], [], [(1, 1), (2, 1), (6, 2), (7, 2), (8, 1), (12, 2), (15, 2), (19, 1), (34, 1), (57, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (233, 1)], [], [], [], [(1, 1), (5, 1), (6, 1), (8, 2), (12, 2), (18, 2), (24, 1), (25, 2), (34, 2), (57, 1), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 2)], [(0, 2), (2, 2), (5, 1), (6, 2), (8, 1), (12, 1), (15, 1), (18, 2), (24, 1), (25, 2), (34, 2), (57, 1), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (233, 2)], [], [(5, 1), (6, 1), (8, 2), (12, 2), (15, 1), (18, 2), (24, 1), (25, 2), (34, 2), (57, 1), (65, 2), (66, 2), (67, 2), (68, 1), (72, 1), (233, 2)], [], [(0, 2), (2, 1), (5, 1), (6, 1), (8, 2), (12, 2), (15, 1), (18, 2), (24, 1), (25, 2), (34, 2), (57, 1), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (233, 2)], [], [], [(1, 1), (6, 1), (7, 2), (8, 2), (15, 2), (19, 2), (34, 1)], [(0, 2), (1, 2), (2, 1), (6, 2), (7, 1), (8, 1), (15, 2), (19, 2), (34, 1)], [(0, 1), (1, 2), (2, 2), (6, 1), (7, 1), (8, 2), (12, 1), (15, 1), (19, 2), (34, 1), (65, 1), (66, 1), (68, 2), (72, 2)], [], [], [], [(1, 1), (6, 1), (7, 2), (8, 2), (15, 2), (19, 1), (34, 2), (65, 2), (68, 1)], [], [], [(0, 2), (1, 1), (2, 1), (6, 2), (7, 2), (8, 1), (15, 2), (19, 1), (34, 2), (57, 1), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1)], [], [(1, 1), (2, 2), (5, 2), (6, 2), (7, 2), (8, 1), (12, 2), (15, 2), (19, 2), (20, 2), (34, 1), (57, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (236, 1)], [(1, 2), (2, 2), (6, 1), (7, 1), (8, 2), (12, 1), (15, 1), (19, 2), (34, 2), (57, 1), (64, 2), (66, 1), (72, 2), (172, 2), (181, 1)], [], [], [], [(2, 1), (6, 1), (8, 2), (12, 2), (15, 2), (18, 1), (24, 2), (25, 1), (34, 2), (65, 2), (66, 2), (68, 1), (72, 1)], [], [(2, 2), (5, 2), (6, 2), (7, 2), (8, 1), (10, 1), (12, 2), (15, 2), (18, 1), (24, 2), (25, 1), (34, 2), (65, 2), (66, 2), (68, 1), (72, 1)], [], [(2, 2), (5, 2), (6, 2), (8, 1), (12, 1), (15, 2), (17, 1), (18, 1), (24, 2), (25, 1), (34, 2), (65, 2), (66, 2), (68, 1), (72, 1)], [(0, 1), (1, 1), (5, 2), (6, 1), (7, 2), (8, 2), (15, 1), (18, 1), (22, 1), (24, 2), (25, 1), (34, 2)], [(2, 1), (5, 1), (6, 2), (8, 1), (12, 1), (15, 1), (18, 2), (24, 1), (25, 2), (34, 1), (65, 2), (66, 2), (67, 2), (68, 1), (72, 2)], [(2, 1), (5, 1), (6, 2), (8, 1), (12, 1), (15, 1), (18, 2), (24, 1), (25, 2), (34, 1), (65, 2), (66, 1), (67, 2), (68, 2), (72, 2)], [], [(0, 2), (2, 2), (5, 1), (6, 2), (8, 1), (12, 1), (15, 1), (18, 2), (24, 1), (25, 2), (34, 1), (65, 1), (68, 2), (73, 1), (74, 2)], [], [], [(2, 1), (5, 1), (6, 1), (8, 2), (12, 1), (15, 1), (18, 2), (24, 1), (25, 2), (34, 1), (57, 2), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2), (130, 1), (131, 2)], [], [], [], [(0, 1), (2, 2), (5, 2), (6, 1), (8, 2), (12, 2), (15, 2), (17, 2), (18, 1), (24, 2), (25, 1), (34, 1), (57, 1), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (233, 1), (314, 1)], [(1, 2), (5, 2), (6, 1), (7, 1), (8, 1), (12, 1), (18, 2), (19, 2), (24, 2), (25, 1), (34, 1), (44, 1), (57, 2), (65, 1), (66, 1), (67, 1), (68, 2), (72, 2), (233, 1)], [], [], [], [], [(1, 1), (2, 1), (5, 2), (6, 2), (7, 1), (15, 1), (18, 2), (19, 2), (24, 2), (25, 1), (34, 1), (57, 2), (63, 1), (64, 2), (66, 1), (67, 1), (72, 2), (233, 1), (274, 1)], [(0, 2), (1, 1), (2, 2), (5, 1), (7, 2), (12, 2), (17, 2), (18, 2), (19, 2), (20, 2), (24, 1), (25, 2), (57, 2), (64, 2), (65, 1), (66, 2), (67, 2), (68, 2), (72, 1), (114, 2), (120, 1), (130, 2), (131, 1), (233, 2), (470, 1)], [(0, 2), (1, 1), (2, 2), (5, 1), (7, 2), (12, 1), (19, 1), (24, 1), (25, 2), (57, 1), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (233, 2)], [], [], [], [], [], [], [(0, 1), (1, 1), (2, 1), (7, 2), (8, 1), (12, 1), (15, 2), (18, 2), (19, 1), (65, 1), (66, 1), (68, 2), (72, 2)], [(1, 1), (2, 2), (7, 2), (12, 1), (13, 1), (15, 2), (18, 2), (19, 1), (65, 1), (66, 1), (68, 2), (72, 2)], [], [], [(6, 1), (8, 2), (57, 1), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (114, 2), (131, 1)], [(0, 1), (2, 2), (65, 1), (66, 1), (67, 2), (68, 2), (72, 2), (74, 1)], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb43 : List (List (Nat × Nat)) := [[(0, 2), (4, 1), (13, 1), (16, 2), (24, 1)], [], [(6, 2), (13, 1), (16, 2), (24, 1), (57, 2), (63, 1), (64, 2), (68, 1), (114, 1)], [(0, 2), (4, 1), (8, 2), (13, 2), (16, 1), (24, 1), (57, 2), (63, 1), (64, 2), (68, 1), (172, 1)], [(0, 2), (4, 1), (8, 2), (13, 2), (16, 1), (24, 1), (57, 2), (63, 1), (64, 2), (68, 1), (233, 1)], [], [(0, 2), (4, 2), (7, 1), (13, 1), (16, 2), (24, 1), (64, 1), (68, 2), (71, 2), (74, 1), (293, 2)], [], [(0, 1), (4, 2), (7, 1), (13, 2), (16, 2), (24, 1), (64, 1), (68, 2), (71, 2), (74, 1), (293, 2)], [], [], [(7, 2), (8, 1), (18, 2), (24, 1), (63, 2), (71, 1), (74, 2), (75, 1), (293, 1)], [], [(0, 2), (4, 1), (7, 2), (13, 1), (16, 2), (24, 1), (71, 1), (74, 2), (293, 1)], [], [(0, 2), (2, 2), (4, 2), (9, 2), (11, 1), (12, 1), (13, 1), (16, 1), (20, 1), (24, 2), (64, 1), (68, 2), (71, 2), (74, 1), (293, 2)], [], [], [(7, 2), (13, 1), (16, 2), (24, 1), (64, 2), (68, 1), (71, 1), (74, 2), (293, 1)], [], [], [(0, 2), (4, 1), (7, 2), (13, 1), (16, 2), (24, 1), (64, 2), (68, 1), (71, 1), (74, 2), (293, 1)], [], [(0, 2), (2, 1), (7, 1), (9, 2), (11, 1), (12, 2), (64, 1), (66, 2), (71, 2), (72, 1), (74, 1), (293, 1)], [], [(0, 1), (2, 2), (7, 1), (9, 2), (11, 1), (12, 1), (13, 1), (64, 1), (66, 2), (71, 2), (72, 1), (74, 1), (293, 1)], [], [], [], [], [(0, 2), (2, 1), (7, 2), (9, 1), (11, 2), (12, 2), (13, 2), (16, 1), (24, 2), (58, 1), (64, 2), (66, 2), (68, 2), (71, 1), (72, 1), (74, 2), (293, 2)], [], [], [], [], [(0, 2), (2, 2), (4, 2), (7, 2), (9, 2), (11, 2), (12, 1), (13, 2), (16, 1), (24, 2), (64, 2), (66, 1), (71, 1), (72, 2), (74, 2), (293, 2)], [], [], [(0, 2), (2, 2), (4, 2), (7, 2), (9, 1), (11, 2), (12, 1), (13, 2), (16, 1), (21, 1), (24, 2), (64, 2), (66, 1), (71, 1), (72, 2), (74, 2), (293, 2)], [(0, 1), (2, 2), (7, 2), (9, 2), (11, 1), (12, 1), (64, 1), (66, 1), (68, 1), (71, 2), (72, 2), (74, 1)], [], [], [], [], [(0, 1), (2, 2), (7, 2), (9, 2), (11, 1), (12, 1), (64, 2), (66, 1), (71, 1), (72, 2), (74, 2)], [(0, 2), (2, 1), (7, 2), (9, 1), (11, 1), (12, 2), (64, 2), (66, 2), (71, 1), (72, 1), (74, 2)], [(2, 2), (4, 1), (6, 1), (7, 1), (9, 2), (11, 1), (12, 1), (57, 1), (63, 2), (64, 2), (66, 1), (71, 2), (72, 2), (74, 1), (114, 2), (117, 1)], [], [], [(7, 2), (8, 1), (9, 2), (11, 1), (16, 1), (20, 2), (57, 1), (63, 2), (64, 2), (66, 1), (71, 2), (72, 2), (74, 1), (172, 2), (174, 1)], [(7, 2), (8, 1), (9, 2), (11, 1), (16, 1), (20, 2), (57, 1), (63, 2), (64, 2), (66, 1), (71, 2), (72, 2), (74, 1), (233, 2), (236, 1)], [], [], [(0, 1), (2, 2), (7, 1), (9, 1), (11, 2), (12, 2), (16, 2), (24, 1), (64, 1), (66, 1), (68, 1), (71, 2), (72, 2), (74, 1)], [], [], [(2, 1), (4, 2), (7, 2), (9, 1), (11, 2), (12, 2), (13, 2), (16, 1), (24, 2), (64, 2), (66, 2), (68, 2), (71, 1), (72, 1), (74, 2)], [(2, 1), (4, 2), (7, 1), (9, 1), (10, 1), (11, 2), (12, 2), (13, 2), (16, 1), (24, 2), (64, 2), (66, 2), (68, 2), (71, 1), (72, 1), (74, 2)], [], [], [(2, 1), (4, 2), (7, 1), (9, 1), (11, 2), (12, 2), (13, 2), (16, 1), (22, 1), (24, 2), (64, 2), (66, 2), (68, 2), (71, 1), (72, 1), (74, 2)], [(0, 1), (2, 1), (4, 1), (7, 1), (9, 1), (11, 2), (12, 2), (16, 2), (24, 1), (64, 1), (66, 2), (71, 2), (72, 2), (74, 1)], [], [], [(0, 1), (2, 2), (7, 1), (9, 2), (11, 2), (12, 1), (16, 2), (24, 1), (64, 1), (66, 1), (71, 2), (72, 2), (73, 1), (74, 1)], [(0, 2), (2, 1), (7, 1), (9, 1), (11, 2), (12, 2), (16, 2), (24, 1), (64, 1), (66, 2), (71, 2), (72, 1), (74, 2)], [], [], [], [(0, 2), (2, 2), (4, 2), (6, 1), (7, 2), (9, 2), (11, 1), (12, 1), (13, 2), (16, 1), (24, 2), (57, 1), (58, 2), (63, 2), (64, 2), (66, 1), (71, 1), (72, 2), (74, 2), (114, 2), (137, 1)], [], [(2, 2), (4, 1), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (16, 2), (24, 1), (63, 2), (64, 1), (66, 1), (68, 1), (72, 2), (293, 1), (314, 1)], [], [(0, 1), (2, 1), (4, 1), (7, 1), (8, 2), (9, 1), (11, 1), (12, 2), (13, 2), (16, 1), (24, 2), (57, 2), (63, 1), (66, 2), (68, 1), (71, 2), (72, 1), (74, 1), (99, 1), (293, 1)], [], [(0, 1), (2, 1), (4, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (16, 1), (24, 2), (66, 2), (68, 1), (72, 1), (293, 1), (392, 1)], [], [], [(0, 2), (2, 1), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (13, 1), (18, 1), (20, 2), (24, 2), (63, 1), (71, 2), (74, 1), (75, 2), (293, 2), (470, 1)], [], [(7, 1), (8, 2), (63, 1), (71, 2), (74, 1), (293, 2)], [], [], [], [], [(8, 1), (13, 2), (16, 1), (24, 2), (57, 1), (63, 2), (64, 1), (68, 2)], [(0, 1), (4, 2), (8, 1), (13, 2), (16, 1), (24, 2)], [], [(18, 1), (24, 2)], [], [(6, 1), (13, 2), (57, 1), (63, 2), (64, 1), (68, 2), (114, 2), (130, 1)], [], [], [], [], [(0, 1), (4, 2), (13, 2), (16, 1)], [], [(6, 1), (8, 2)], [], [], [], [], [], []] + +def comb44 : List (List (Nat × Nat)) := [[(9, 2), (11, 1), (14, 1), (16, 2), (24, 1)], [], [(6, 2), (9, 2), (11, 1), (14, 1), (16, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (114, 1)], [], [(8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [(3, 1), (8, 1), (24, 1), (57, 1), (63, 2), (64, 1), (66, 2), (172, 2)], [], [], [(8, 1), (9, 2), (11, 1), (14, 1), (16, 2), (18, 1), (24, 1), (57, 1), (63, 2), (64, 1), (66, 2), (172, 2)], [], [(9, 2), (11, 1), (14, 1), (16, 2), (18, 2), (24, 1), (57, 2), (75, 1), (172, 1)], [(1, 2), (3, 1), (8, 2), (9, 2), (11, 1), (14, 1), (15, 1), (16, 2), (18, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (67, 2), (77, 1), (172, 1)], [(8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [], [], [(6, 1), (9, 2), (11, 1), (14, 1), (16, 2), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (172, 2)], [], [], [], [(8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (172, 1)], [], [], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 1), (14, 1), (15, 2), (16, 2), (57, 2), (60, 2), (63, 1), (64, 1), (66, 2), (67, 1), (71, 1), (172, 1)], [], [], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 1), (9, 2), (11, 1), (14, 1), (15, 2), (16, 2), (57, 2), (60, 2), (63, 1), (64, 1), (66, 2), (67, 1), (71, 1), (172, 1)], [], [], [(1, 1), (3, 2), (6, 2), (7, 1), (8, 2), (9, 2), (11, 1), (14, 1), (15, 2), (16, 2), (24, 2), (57, 1), (60, 2), (63, 2), (64, 2), (66, 1), (67, 1), (71, 2), (172, 2)], [], [], [(0, 1), (1, 1), (3, 1), (6, 2), (7, 2), (9, 2), (11, 1), (12, 2), (14, 2), (15, 2), (16, 1), (24, 1), (57, 2), (60, 2), (63, 1), (64, 1), (66, 2), (67, 1), (71, 1), (172, 1)], [], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 1), (14, 1), (15, 2), (16, 2), (24, 2), (57, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (71, 2), (172, 2)], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 2), (14, 1), (15, 1), (16, 2), (24, 2), (57, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (71, 2), (172, 2)], [], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (14, 2), (15, 1), (16, 2), (24, 2), (57, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (71, 2), (172, 2)], [], [(1, 2), (3, 1), (6, 1), (7, 2), (8, 2), (15, 1), (60, 1), (64, 1), (66, 2), (67, 2), (71, 2)], [], [(1, 2), (3, 1), (6, 1), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (15, 1), (60, 1), (64, 1), (66, 2), (67, 2), (71, 2)], [], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 2), (15, 1), (60, 2), (64, 2), (66, 1), (67, 2), (71, 1)], [], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 2), (11, 2), (15, 2), (60, 2), (64, 2), (66, 2), (67, 1), (71, 1)], [], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 1), (15, 1), (57, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (71, 2), (114, 2), (115, 1)], [], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (15, 1), (60, 1), (64, 2), (66, 1), (67, 2), (71, 1), (174, 1)], [], [(3, 2), (6, 1), (7, 2), (8, 2), (15, 2), (60, 2), (64, 1), (66, 2), (67, 1), (71, 1), (181, 1)], [], [], [(6, 2), (7, 1), (8, 1), (9, 2), (11, 1), (14, 1), (15, 1), (16, 2), (24, 1), (60, 1), (64, 1), (66, 2), (67, 2), (71, 2)], [], [], [(1, 1), (3, 2), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 2), (14, 2), (15, 2), (16, 1), (24, 2), (60, 2), (64, 2), (66, 1), (67, 1), (71, 1)], [], [(1, 1), (3, 2), (6, 2), (7, 2), (8, 1), (9, 1), (11, 2), (12, 2), (15, 2), (17, 1), (24, 2), (60, 2), (64, 2), (66, 1), (67, 1), (71, 1)], [], [], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (11, 1), (14, 1), (15, 1), (16, 2), (24, 1), (60, 1), (64, 1), (65, 1), (66, 2), (67, 1), (71, 2)], [], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 1), (11, 1), (15, 1), (16, 2), (24, 1), (60, 1), (64, 1), (66, 1), (67, 2), (71, 2), (73, 1)], [], [(1, 1), (3, 2), (6, 2), (7, 1), (8, 1), (15, 2), (18, 2), (24, 1), (60, 2), (64, 1), (66, 2), (67, 1), (71, 1), (80, 1)], [], [(1, 2), (3, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (14, 2), (15, 1), (16, 1), (24, 2), (57, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (71, 1), (114, 2), (127, 1)], [], [], [(1, 2), (3, 1), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (14, 1), (15, 1), (16, 2), (17, 2), (24, 1), (57, 2), (60, 1), (64, 1), (66, 2), (67, 2), (71, 2), (172, 1), (314, 1)], [], [(1, 1), (3, 2), (6, 1), (7, 2), (11, 2), (15, 2), (24, 2), (57, 1), (60, 2), (63, 2), (67, 1), (71, 1), (99, 1), (172, 1)], [], [], [(1, 1), (3, 2), (6, 1), (7, 2), (15, 2), (16, 2), (24, 2), (57, 1), (60, 2), (63, 2), (67, 1), (71, 1), (172, 1), (216, 1)], [], [(1, 2), (3, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 1), (14, 1), (16, 2), (17, 2), (18, 1), (24, 2), (57, 1), (75, 2), (172, 2), (470, 1)], [], [(9, 1), (11, 2), (14, 2), (16, 1), (57, 1), (172, 2)], [], [], [], [], [(8, 1), (9, 1), (11, 2), (14, 2), (16, 1), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2)], [(8, 1), (9, 1), (11, 2), (14, 2), (16, 1), (24, 2)], [(9, 1), (11, 2), (13, 1), (14, 2), (16, 1), (24, 2)], [], [], [(6, 1), (9, 1), (11, 2), (14, 2), (57, 1), (63, 2), (64, 1), (66, 2), (114, 2), (130, 1)], [], [], [], [], [(9, 1), (11, 2), (14, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb45 : List (List (Nat × Nat)) := [[(7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 1)], [], [(0, 1), (2, 2), (6, 2), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 1), (57, 2), (63, 1), (114, 1)], [(0, 1), (2, 2), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 1), (57, 2), (63, 1), (172, 1)], [], [], [(0, 2), (2, 2), (6, 1), (18, 1), (57, 1), (63, 2), (233, 2)], [], [], [], [(0, 2), (2, 1), (6, 1), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 1), (24, 1), (57, 1), (63, 2), (233, 2)], [(0, 1), (2, 2), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (57, 2), (75, 1), (233, 1)], [(7, 2), (8, 2), (10, 1), (11, 1), (15, 1), (16, 2), (17, 2), (18, 1), (57, 2), (63, 1), (65, 2), (77, 1), (233, 1)], [], [], [], [], [(0, 2), (2, 1), (7, 2), (8, 1), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 2), (57, 1), (63, 2), (233, 2)], [(0, 2), (2, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 1), (57, 2), (63, 1), (233, 1)], [(0, 1), (2, 2), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [(0, 1), (2, 2), (8, 2), (9, 2), (10, 2), (12, 2), (15, 2), (16, 1), (17, 1), (57, 2), (60, 2), (63, 1), (65, 1), (71, 1), (72, 1), (74, 2), (233, 1)], [], [], [], [(0, 1), (2, 2), (7, 2), (8, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (57, 2), (60, 2), (63, 1), (65, 1), (71, 1), (72, 1), (74, 2), (233, 1)], [], [(0, 1), (2, 2), (6, 1), (7, 2), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (18, 2), (57, 1), (60, 2), (63, 2), (65, 1), (71, 2), (72, 2), (74, 1), (233, 2)], [(0, 2), (2, 1), (7, 1), (8, 1), (9, 2), (11, 2), (12, 1), (15, 1), (16, 2), (18, 2), (57, 1), (58, 1), (60, 1), (63, 2), (65, 2), (71, 2), (72, 1), (74, 1), (233, 2)], [], [], [(0, 1), (2, 1), (3, 1), (6, 2), (7, 2), (11, 1), (15, 2), (16, 1), (18, 1), (57, 2), (60, 2), (63, 1), (65, 1), (71, 1), (72, 1), (74, 2), (233, 1)], [(0, 1), (2, 2), (6, 1), (7, 2), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (18, 2), (57, 1), (60, 1), (63, 2), (65, 2), (71, 2), (72, 2), (74, 1), (233, 2)], [], [(0, 2), (2, 1), (7, 1), (8, 1), (9, 2), (11, 2), (12, 1), (15, 1), (16, 2), (18, 2), (57, 1), (60, 1), (63, 2), (65, 2), (71, 2), (72, 2), (74, 1), (233, 2)], [], [], [(9, 1), (10, 2), (12, 2), (15, 1), (16, 2), (17, 1), (60, 1), (65, 2), (71, 2), (72, 2), (74, 1)], [], [], [(7, 2), (9, 1), (10, 2), (11, 1), (12, 2), (15, 1), (16, 2), (17, 1), (60, 1), (65, 2), (71, 2), (72, 2), (74, 1)], [(0, 1), (2, 2), (9, 1), (10, 2), (12, 2), (15, 1), (16, 2), (17, 1), (60, 2), (65, 2), (71, 1), (72, 1), (74, 2)], [(0, 2), (2, 1), (6, 1), (7, 1), (8, 2), (10, 1), (11, 2), (15, 2), (16, 1), (17, 2), (60, 2), (65, 1), (71, 1), (72, 2), (74, 2)], [], [], [], [(0, 2), (2, 1), (3, 2), (6, 1), (7, 2), (9, 1), (10, 2), (11, 1), (12, 2), (15, 1), (16, 2), (17, 1), (57, 1), (60, 1), (63, 2), (65, 2), (71, 2), (72, 2), (74, 1), (114, 2), (120, 1)], [], [(0, 1), (5, 2), (7, 2), (11, 1), (12, 2), (15, 1), (16, 2), (17, 1), (60, 1), (65, 2), (71, 1), (72, 1), (74, 2), (236, 1)], [(0, 2), (2, 1), (3, 2), (6, 1), (9, 2), (10, 1), (12, 1), (15, 1), (16, 2), (17, 2), (57, 1), (60, 1), (63, 2), (65, 2), (71, 2), (72, 2), (74, 1), (172, 2), (181, 1)], [], [], [], [(2, 2), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (11, 1), (15, 1), (16, 2), (18, 1), (60, 1), (65, 2), (71, 2), (72, 2), (74, 1)], [(7, 2), (11, 2), (15, 2), (16, 1), (18, 2), (60, 2), (65, 1), (71, 1), (72, 1), (74, 2)], [], [(7, 1), (9, 2), (10, 1), (11, 2), (12, 1), (15, 2), (16, 2), (17, 2), (18, 2), (60, 2), (65, 1), (71, 1), (72, 1), (74, 2)], [], [], [], [], [(6, 2), (7, 2), (8, 1), (10, 2), (11, 1), (15, 1), (16, 2), (18, 1), (60, 1), (65, 1), (67, 1), (71, 2), (72, 2), (74, 1)], [], [(0, 1), (2, 2), (6, 2), (7, 2), (8, 1), (10, 2), (11, 1), (15, 1), (16, 2), (18, 1), (60, 1), (65, 2), (71, 2), (72, 1), (74, 2)], [(9, 2), (10, 1), (12, 1), (15, 2), (16, 1), (17, 1), (18, 1), (58, 2), (60, 2), (65, 1), (71, 1), (72, 2), (74, 2), (80, 1)], [(0, 1), (2, 2), (3, 1), (6, 2), (7, 1), (9, 2), (10, 1), (11, 2), (12, 1), (15, 2), (16, 1), (18, 2), (57, 2), (60, 2), (63, 1), (65, 1), (71, 1), (72, 1), (74, 2), (114, 1), (120, 2), (130, 1), (131, 2)], [], [], [], [(0, 1), (2, 2), (9, 2), (10, 1), (11, 2), (12, 1), (15, 1), (16, 2), (17, 2), (18, 1), (57, 2), (60, 1), (65, 2), (71, 2), (72, 2), (74, 1), (233, 1), (314, 1)], [], [(0, 2), (2, 1), (6, 2), (7, 1), (8, 2), (10, 1), (11, 2), (15, 2), (16, 1), (17, 2), (18, 2), (57, 1), (60, 2), (63, 2), (65, 1), (71, 1), (72, 1), (74, 2), (99, 1), (233, 1)], [], [], [], [(0, 2), (2, 1), (6, 2), (8, 2), (9, 2), (10, 2), (12, 1), (15, 2), (16, 1), (17, 1), (18, 2), (57, 1), (60, 2), (63, 2), (65, 1), (71, 1), (72, 1), (74, 2), (233, 1), (274, 1)], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (12, 1), (17, 1), (57, 2), (63, 2), (65, 1), (67, 2), (75, 2), (114, 2), (120, 1), (130, 2), (131, 1), (233, 2), (470, 1)], [], [(0, 2), (2, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (57, 1), (233, 2)], [], [], [], [], [(0, 2), (2, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 2), (57, 1), (63, 2)], [(6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 2)], [(0, 2), (2, 1), (6, 1), (7, 1), (8, 2), (9, 1), (10, 2), (11, 2), (12, 2), (13, 1), (17, 1), (18, 2)], [], [], [(0, 2), (2, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (57, 1), (63, 2), (114, 2), (131, 1)], [], [], [], [], [(7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1)], [], [], [], [], [], [], [], []] + +def comb46 : List (List (Nat × Nat)) := [[(6, 2), (11, 1), (12, 1), (16, 2), (24, 1)], [(6, 2), (12, 1), (16, 2), (24, 1), (68, 1)], [], [(6, 2), (8, 2), (11, 1), (12, 1), (13, 1), (16, 1), (24, 1), (57, 2), (68, 1), (172, 1)], [(6, 2), (8, 2), (11, 1), (12, 1), (13, 1), (16, 1), (24, 1), (57, 2), (68, 1), (233, 1)], [], [], [(0, 2), (1, 1), (4, 2), (5, 1), (11, 2), (12, 1), (16, 2), (24, 1), (58, 1), (68, 2), (115, 2), (120, 1), (127, 2), (131, 1), (293, 2)], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 2), (11, 2), (12, 2), (16, 2), (24, 1), (58, 1), (68, 2), (115, 2), (120, 1), (127, 2), (131, 1), (293, 2)], [], [], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 1), (11, 1), (12, 1), (16, 2), (24, 1), (58, 2), (63, 1), (115, 1), (120, 2), (127, 1), (131, 2), (293, 1)], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 2), (12, 1), (16, 2), (24, 1), (58, 2), (68, 1), (115, 1), (120, 2), (127, 1), (131, 2), (293, 1)], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 1), (8, 1), (12, 1), (16, 2), (24, 1), (58, 2), (68, 1), (115, 1), (120, 2), (127, 1), (131, 2), (293, 1)], [], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 1), (11, 1), (12, 1), (16, 2), (24, 1), (58, 2), (68, 1), (115, 1), (120, 2), (127, 1), (131, 2), (293, 1)], [], [], [(1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 2), (8, 2), (12, 2), (13, 1), (58, 1), (63, 2), (115, 2), (120, 2), (127, 2), (131, 1), (293, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (8, 2), (12, 2), (13, 1), (58, 1), (63, 2), (115, 2), (120, 2), (127, 2), (131, 1), (293, 1)], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (8, 1), (11, 2), (13, 2), (16, 1), (24, 2), (63, 1), (68, 2), (120, 1), (121, 1), (293, 2)], [], [(1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (6, 2), (8, 1), (13, 2), (16, 1), (24, 2), (63, 1), (68, 2), (115, 1), (120, 1), (127, 1), (131, 2), (293, 2)], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (6, 2), (8, 1), (11, 2), (13, 2), (16, 1), (24, 2), (58, 2), (63, 1), (115, 1), (120, 1), (127, 1), (131, 2), (293, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (11, 2), (12, 1), (13, 1), (16, 1), (24, 2), (58, 2), (63, 1), (115, 1), (120, 1), (127, 1), (131, 2), (293, 2)], [(0, 2), (2, 2), (3, 1), (5, 2), (8, 1), (12, 1), (13, 2), (15, 1), (16, 2), (24, 1), (58, 1), (63, 2), (115, 2), (120, 2), (127, 2), (131, 1), (293, 1)], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (5, 1), (6, 1), (8, 1), (12, 1), (13, 1), (16, 1), (21, 1), (24, 2), (58, 2), (63, 1), (115, 1), (120, 1), (127, 1), (131, 2), (293, 2)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (12, 2), (13, 1), (58, 1), (63, 1), (68, 1), (115, 2), (127, 2), (131, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (11, 1), (12, 2), (13, 1), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (12, 2), (13, 1), (58, 1), (63, 2), (115, 2), (127, 1), (131, 2)], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (6, 1), (8, 1), (12, 1), (13, 2), (58, 2), (63, 1), (115, 1), (120, 1), (127, 1), (131, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (12, 2), (16, 1), (57, 1), (58, 1), (63, 1), (115, 2), (127, 2), (131, 1), (172, 2), (174, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (12, 2), (16, 1), (57, 1), (58, 1), (63, 1), (115, 2), (127, 2), (131, 1), (233, 2), (236, 1)], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (11, 2), (13, 2), (16, 1), (24, 2), (58, 2), (63, 2), (68, 2), (115, 1), (127, 1), (131, 2)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (11, 2), (12, 1), (13, 1), (16, 1), (24, 2), (58, 2), (63, 2), (68, 2), (115, 1), (127, 1), (131, 2)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (12, 1), (13, 1), (16, 1), (22, 1), (24, 2), (58, 2), (63, 2), (68, 2), (115, 1), (127, 1), (131, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (8, 1), (11, 1), (12, 2), (13, 2), (16, 2), (24, 1), (58, 1), (63, 1), (66, 1), (115, 2), (127, 2), (131, 1)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (11, 2), (12, 1), (13, 1), (16, 1), (24, 2), (58, 1), (63, 1), (80, 1), (115, 1), (127, 1), (131, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 2), (8, 2), (12, 2), (13, 1), (16, 2), (24, 1), (58, 1), (63, 2), (115, 2), (120, 2), (127, 2), (130, 1), (131, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (8, 1), (12, 1), (13, 2), (16, 2), (24, 1), (58, 2), (63, 1), (115, 1), (127, 2), (131, 2)], [], [], [(1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 2), (11, 1), (12, 1), (16, 2), (24, 1), (63, 2), (68, 1), (120, 2), (121, 2), (293, 1), (314, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 1), (11, 1), (13, 2), (16, 1), (24, 2), (57, 2), (58, 1), (63, 2), (68, 1), (115, 2), (120, 2), (127, 2), (131, 1), (157, 1), (293, 1)], [(2, 1), (3, 2), (5, 2), (8, 2), (11, 1), (13, 1), (16, 1), (24, 2), (63, 2), (68, 1), (120, 1), (293, 1), (392, 1)], [], [], [(0, 2), (1, 1), (4, 1), (5, 1), (6, 1), (16, 1), (24, 2), (58, 1), (63, 2), (115, 2), (120, 2), (127, 2), (130, 2), (131, 1), (293, 2), (470, 1)], [], [], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 1), (8, 2), (12, 2), (13, 1), (57, 2), (58, 1), (114, 1), (115, 2), (120, 1), (127, 2), (131, 1), (293, 2)], [], [], [], [(8, 1), (13, 2), (16, 1), (24, 2), (57, 1), (68, 2)], [], [], [(18, 1), (24, 2)], [], [], [(6, 1), (12, 2), (68, 2), (73, 1)], [], [], [], [(6, 1), (11, 2), (12, 2), (16, 1)], [], [], [], [], [(6, 1), (8, 2), (12, 2), (13, 1)], [], [], []] + +def comb47 : List (List (Nat × Nat)) := [[(3, 2), (4, 1), (6, 1), (8, 2), (14, 1), (16, 2), (24, 1)], [(3, 2), (4, 1), (8, 2), (14, 1), (16, 2), (24, 1), (66, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (18, 1), (19, 2), (24, 1), (57, 2), (66, 1), (233, 1)], [], [], [(0, 2), (2, 1), (6, 2), (7, 2), (8, 1), (14, 2), (16, 1), (18, 2), (19, 1), (24, 1), (57, 1), (66, 2), (172, 2)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (19, 1), (24, 1), (57, 1), (66, 2), (172, 2)], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (14, 2), (16, 1), (19, 2), (24, 1), (57, 2), (77, 1), (172, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (172, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (14, 2), (16, 1), (19, 2), (20, 1), (24, 1), (57, 2), (66, 1), (172, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (7, 1), (8, 1), (18, 1), (19, 2), (24, 1), (57, 2), (66, 1), (172, 1)], [(3, 2), (4, 1), (6, 2), (8, 2), (14, 1), (16, 2), (24, 2), (57, 1), (66, 2), (172, 2)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (18, 1), (19, 2), (24, 1), (57, 2), (66, 1), (172, 1)], [], [], [], [(0, 2), (1, 2), (2, 1), (6, 2), (7, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 2), (57, 2), (60, 2), (63, 2), (127, 1), (172, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (18, 2), (19, 1), (57, 2), (60, 2), (63, 2), (127, 1), (172, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (60, 2), (63, 1), (66, 2), (121, 1), (127, 1), (172, 2)], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (60, 2), (63, 1), (66, 2), (127, 2), (172, 2)], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 2), (7, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (60, 1), (63, 1), (127, 2), (172, 2)], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (60, 1), (63, 1), (127, 2), (172, 2)], [], [], [(0, 1), (1, 2), (2, 2), (6, 1), (7, 1), (8, 2), (14, 1), (16, 2), (18, 1), (19, 2), (60, 1), (63, 1), (66, 1), (127, 2)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (14, 2), (16, 1), (18, 2), (19, 1), (60, 1), (63, 1), (66, 1), (127, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (6, 2), (7, 2), (8, 1), (14, 2), (16, 1), (18, 2), (19, 1), (58, 1), (60, 1), (63, 1), (127, 2)], [], [(0, 1), (1, 2), (2, 2), (6, 2), (8, 2), (14, 1), (16, 2), (18, 1), (19, 2), (60, 1), (63, 2), (117, 1), (127, 1)], [], [(0, 1), (1, 2), (2, 2), (4, 2), (6, 2), (7, 1), (8, 2), (14, 1), (16, 2), (18, 1), (19, 2), (60, 2), (63, 1), (120, 1), (127, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (14, 2), (16, 1), (18, 2), (19, 2), (20, 2), (60, 1), (63, 2), (127, 1), (174, 1)], [], [(0, 1), (1, 2), (2, 2), (4, 2), (6, 2), (7, 1), (8, 2), (14, 1), (16, 2), (18, 1), (19, 2), (60, 2), (63, 1), (127, 1), (181, 1)], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (18, 1), (19, 2), (24, 2), (60, 2), (63, 2), (66, 2), (127, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (18, 1), (19, 2), (24, 2), (60, 2), (63, 2), (66, 2), (127, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (18, 2), (19, 1), (24, 1), (60, 1), (63, 1), (66, 1), (127, 2)], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (14, 1), (16, 2), (17, 1), (18, 1), (19, 2), (24, 2), (60, 2), (63, 2), (66, 2), (127, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (18, 2), (19, 1), (24, 1), (60, 1), (63, 1), (65, 1), (127, 2)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (18, 1), (19, 2), (24, 2), (60, 1), (63, 1), (71, 1), (127, 1)], [], [(0, 2), (1, 1), (2, 1), (4, 1), (6, 1), (7, 2), (8, 1), (14, 2), (18, 2), (19, 1), (24, 1), (60, 1), (63, 2), (120, 2), (127, 2), (130, 1)], [], [(0, 2), (1, 1), (2, 1), (6, 2), (7, 2), (8, 1), (14, 2), (16, 1), (18, 1), (19, 1), (24, 1), (60, 2), (63, 1), (127, 1), (137, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (17, 2), (18, 2), (19, 1), (24, 1), (57, 2), (60, 1), (63, 2), (66, 1), (121, 2), (127, 2), (172, 1), (314, 1)], [], [], [(1, 2), (3, 1), (4, 2), (6, 2), (8, 1), (14, 2), (24, 2), (57, 1), (60, 2), (63, 2), (66, 1), (127, 1), (157, 1), (172, 1)], [], [(1, 2), (16, 2), (24, 2), (57, 1), (60, 2), (63, 2), (66, 1), (127, 1), (172, 1), (216, 1)], [], [(0, 2), (2, 2), (4, 2), (7, 2), (8, 2), (14, 1), (17, 2), (19, 1), (20, 2), (24, 2), (57, 1), (63, 2), (120, 1), (130, 2), (172, 2), (470, 1)], [], [], [(3, 1), (4, 2), (6, 2), (8, 1), (14, 2), (16, 1), (114, 1), (172, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (14, 1), (16, 2), (18, 2), (19, 1), (24, 2), (57, 1), (66, 2)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 1), (13, 1), (14, 1), (16, 2), (18, 2), (19, 1), (24, 2)], [], [], [], [(3, 1), (4, 2), (8, 1), (14, 2), (66, 2), (73, 1)], [], [], [], [(3, 1), (4, 2), (6, 2), (8, 1), (14, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb48 : List (List (Nat × Nat)) := [[(1, 2), (4, 1), (15, 1), (16, 2), (18, 1)], [(1, 2), (4, 1), (8, 2), (15, 1), (16, 2), (18, 1), (63, 1)], [], [(1, 1), (4, 2), (8, 2), (15, 2), (16, 1), (18, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [(8, 2), (18, 1), (57, 1), (63, 2), (233, 2)], [], [], [(1, 2), (4, 1), (8, 1), (15, 1), (16, 2), (18, 1), (24, 1), (57, 1), (63, 2), (233, 2)], [], [(1, 1), (3, 1), (4, 1), (6, 1), (8, 2), (12, 2), (15, 2), (16, 1), (18, 1), (57, 2), (77, 1), (233, 1)], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (8, 2), (15, 1), (16, 1), (18, 1), (20, 1), (57, 2), (63, 1), (233, 1)], [(1, 1), (4, 2), (6, 1), (8, 1), (15, 2), (16, 1), (18, 1), (57, 2), (63, 1), (233, 1)], [], [], [(1, 1), (4, 2), (8, 2), (15, 2), (16, 1), (18, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (6, 1), (8, 2), (12, 1), (15, 1), (16, 2), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (5, 1), (6, 1), (8, 2), (12, 1), (15, 1), (16, 2), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [(0, 1), (2, 2), (4, 1), (6, 1), (8, 1), (12, 1), (15, 1), (16, 2), (18, 2), (57, 1), (58, 2), (60, 2), (63, 2), (67, 2), (115, 1), (121, 1), (127, 1), (131, 2), (233, 2)], [(0, 2), (2, 1), (4, 1), (6, 2), (8, 2), (12, 2), (15, 1), (16, 2), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (115, 2), (127, 2), (131, 1), (233, 2)], [(0, 1), (2, 2), (3, 2), (4, 2), (6, 2), (8, 2), (12, 2), (15, 1), (16, 2), (18, 2), (57, 1), (58, 2), (60, 1), (63, 2), (115, 2), (127, 2), (131, 1), (233, 2)], [], [(0, 2), (2, 2), (3, 2), (4, 2), (6, 2), (8, 1), (12, 2), (15, 1), (16, 2), (18, 2), (57, 1), (58, 1), (60, 1), (115, 2), (127, 2), (131, 1), (233, 2)], [], [], [(0, 1), (2, 2), (4, 1), (6, 1), (8, 1), (9, 1), (12, 1), (15, 2), (16, 1), (18, 1), (57, 2), (58, 2), (60, 2), (115, 1), (127, 1), (131, 2), (233, 1)], [(0, 2), (2, 1), (3, 2), (4, 2), (6, 1), (8, 2), (15, 1), (16, 2), (18, 2), (57, 1), (58, 1), (60, 1), (115, 2), (127, 2), (131, 1), (233, 2)], [], [], [], [(0, 2), (1, 2), (2, 1), (6, 2), (12, 2), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [], [(0, 2), (1, 1), (2, 1), (4, 1), (6, 2), (12, 2), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [], [], [(0, 2), (1, 1), (2, 1), (4, 1), (6, 2), (8, 1), (9, 2), (12, 2), (58, 1), (60, 1), (64, 1), (115, 2), (127, 2), (131, 1)], [(0, 1), (1, 2), (2, 2), (6, 1), (8, 2), (12, 1), (58, 2), (60, 1), (115, 1), (117, 1), (127, 1), (131, 2)], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 2), (12, 1), (58, 1), (60, 2), (115, 2), (127, 1), (131, 2)], [], [], [(0, 1), (1, 1), (3, 2), (4, 1), (6, 1), (8, 2), (12, 1), (15, 1), (20, 2), (58, 2), (60, 1), (115, 1), (127, 1), (131, 2), (236, 1)], [(0, 2), (1, 2), (2, 1), (4, 2), (6, 2), (8, 1), (12, 2), (15, 2), (16, 1), (57, 1), (58, 1), (60, 1), (115, 2), (127, 2), (131, 1), (172, 2), (181, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 1), (6, 1), (12, 1), (15, 2), (16, 1), (18, 2), (58, 2), (60, 2), (63, 2), (115, 1), (127, 1), (131, 2)], [(0, 1), (2, 2), (4, 2), (6, 1), (12, 1), (15, 2), (16, 1), (18, 2), (58, 2), (60, 2), (63, 2), (115, 1), (127, 1), (131, 2)], [], [], [(0, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (8, 2), (10, 1), (12, 2), (15, 1), (16, 2), (18, 1), (58, 1), (60, 1), (63, 1), (115, 2), (127, 2), (131, 1)], [(0, 1), (1, 2), (2, 2), (4, 2), (6, 1), (12, 1), (16, 1), (18, 2), (58, 2), (60, 2), (63, 2), (115, 1), (127, 1), (131, 2)], [], [], [], [], [(0, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (12, 2), (15, 1), (16, 2), (18, 1), (58, 1), (60, 1), (67, 1), (115, 2), (127, 2), (131, 1)], [(0, 1), (2, 1), (4, 1), (5, 1), (9, 1), (12, 2), (15, 2), (16, 1), (18, 2), (58, 2), (60, 2), (64, 2), (73, 1), (74, 2), (115, 1), (127, 1), (131, 2)], [], [], [], [(0, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 2), (12, 1), (15, 1), (16, 2), (18, 1), (58, 2), (60, 1), (115, 1), (127, 2), (131, 2)], [(0, 2), (2, 2), (4, 1), (5, 2), (6, 1), (8, 2), (12, 1), (15, 1), (16, 2), (18, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [], [(0, 2), (2, 1), (4, 2), (6, 2), (8, 2), (12, 2), (15, 2), (16, 1), (18, 1), (57, 2), (58, 1), (60, 1), (63, 1), (67, 1), (115, 2), (121, 2), (127, 2), (131, 1), (233, 1), (314, 1)], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 1), (12, 1), (18, 2), (57, 1), (58, 2), (60, 2), (63, 1), (115, 1), (127, 1), (131, 2), (157, 1), (233, 1)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (6, 2), (15, 1), (16, 2), (18, 2), (57, 1), (58, 2), (60, 2), (63, 1), (115, 1), (127, 1), (131, 2), (233, 1), (274, 1)], [(1, 1), (4, 1), (5, 1), (8, 1), (15, 2), (16, 2), (18, 2), (20, 2), (57, 1), (67, 2), (233, 2), (470, 1)], [], [], [(1, 1), (4, 2), (6, 2), (8, 1), (15, 2), (16, 1), (114, 1), (233, 2)], [], [], [], [(1, 1), (4, 2), (8, 1), (15, 2), (16, 1), (18, 2), (57, 1), (63, 2)], [], [(1, 1), (4, 2), (13, 1), (15, 2), (16, 1), (18, 2)], [], [], [], [(2, 1), (5, 2), (6, 1), (12, 2), (63, 2), (74, 1)], [], [], [], [(1, 1), (4, 2), (15, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb49 : List (List (Nat × Nat)) := [[(3, 2), (4, 1), (6, 1), (8, 2), (13, 1), (15, 2), (18, 2), (20, 1), (24, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (9, 2), (13, 1), (15, 2), (18, 2), (20, 1), (24, 1), (66, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (9, 2), (13, 1), (15, 2), (18, 2), (20, 1), (24, 1), (57, 2), (66, 1), (114, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (8, 2), (9, 2), (13, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (66, 1), (233, 1)], [], [], [], [(0, 2), (2, 1), (6, 2), (8, 1), (9, 1), (13, 1), (24, 1), (57, 1), (66, 2), (172, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 1), (9, 1), (13, 1), (15, 2), (20, 1), (24, 1), (57, 1), (66, 2), (172, 2)], [], [(3, 2), (4, 1), (6, 1), (8, 2), (13, 1), (15, 2), (18, 1), (20, 1), (24, 1), (57, 2), (75, 1), (172, 1)], [], [(3, 1), (4, 2), (6, 1), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (63, 1), (172, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (9, 2), (13, 1), (15, 2), (18, 2), (20, 1), (24, 1), (57, 2), (66, 1), (172, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (9, 2), (13, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (66, 1), (172, 1)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 1), (9, 1), (13, 1), (15, 2), (18, 2), (20, 1), (24, 2), (57, 1), (66, 2), (172, 2)], [], [], [], [], [], [(6, 2), (9, 1), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (58, 2), (60, 2), (63, 1), (66, 2), (67, 1), (114, 1), (121, 2), (172, 1), (173, 1)], [(3, 2), (4, 1), (6, 2), (9, 1), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (58, 2), (60, 2), (63, 1), (66, 2), (67, 1), (114, 1), (121, 2), (172, 1), (173, 1)], [], [(3, 2), (4, 1), (6, 1), (8, 1), (9, 2), (24, 2), (58, 1), (60, 2), (63, 1), (66, 1), (67, 1), (114, 1), (121, 2), (172, 2), (173, 2)], [], [], [(1, 1), (3, 2), (4, 1), (8, 1), (9, 2), (24, 2), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 2), (121, 1), (172, 2), (173, 2)], [], [(3, 2), (4, 2), (8, 1), (9, 2), (24, 2), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 2), (121, 1), (172, 2), (173, 2)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (24, 2), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 2), (121, 1), (172, 2), (173, 2)], [(2, 2), (3, 2), (4, 1), (6, 2), (9, 1), (12, 1), (13, 2), (24, 1), (57, 1), (58, 2), (60, 2), (63, 1), (66, 2), (67, 1), (114, 1), (121, 2), (172, 1), (173, 1)], [], [], [], [], [(0, 1), (3, 2), (4, 1), (6, 1), (9, 1), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (58, 1), (60, 1), (63, 2), (66, 2), (67, 2), (114, 2), (121, 1), (173, 2)], [], [(6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (58, 1), (60, 2), (63, 2), (66, 1), (67, 2), (114, 2), (121, 1), (173, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (58, 2), (60, 1), (63, 2), (66, 1), (67, 2), (114, 2), (121, 1), (173, 2)], [], [(6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (18, 1), (20, 2), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 1), (117, 1), (121, 1), (173, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (18, 1), (20, 2), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 1), (115, 1), (121, 1), (173, 2)], [], [], [(2, 1), (5, 2), (6, 1), (9, 2), (13, 1), (15, 2), (18, 2), (20, 1), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 2), (121, 1), (173, 2), (233, 2), (236, 1)], [(4, 2), (6, 2), (8, 1), (9, 1), (13, 1), (15, 2), (18, 2), (20, 1), (57, 2), (58, 2), (60, 2), (66, 2), (67, 1), (114, 1), (121, 2), (173, 1), (181, 1)], [(3, 2), (4, 1), (6, 1), (8, 1), (9, 2), (24, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 1), (67, 1), (114, 1), (121, 2), (173, 1)], [], [], [(0, 2), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (9, 2), (24, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 1), (67, 1), (114, 1), (121, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 2), (6, 2), (9, 2), (10, 1), (24, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 1), (67, 1), (114, 1), (121, 2), (173, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (9, 1), (13, 2), (15, 1), (24, 1), (57, 1), (58, 1), (60, 1), (63, 2), (66, 2), (67, 2), (114, 2), (121, 1), (173, 2)], [], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 1), (9, 2), (24, 2), (57, 2), (58, 2), (60, 1), (63, 1), (66, 1), (67, 2), (114, 1), (121, 2), (173, 1)], [(3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (13, 2), (24, 1), (57, 1), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (73, 1), (114, 2), (121, 1), (173, 2)], [], [], [(3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (13, 2), (24, 1), (57, 2), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (114, 1), (121, 1), (130, 1), (173, 2)], [], [], [], [(3, 1), (4, 2), (6, 2), (8, 2), (9, 1), (24, 1), (58, 2), (60, 1), (63, 2), (66, 2), (67, 2), (114, 2), (121, 1), (172, 1), (173, 1), (314, 1)], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (15, 2), (18, 2), (20, 1), (24, 2), (57, 1), (58, 1), (60, 2), (63, 1), (67, 1), (114, 1), (121, 2), (172, 1), (173, 1), (392, 1)], [(0, 1), (1, 2), (2, 2), (8, 2), (13, 1), (15, 2), (18, 2), (20, 1), (24, 2), (58, 2), (60, 2), (63, 1), (67, 1), (114, 1), (121, 2), (172, 1), (173, 1), (216, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (15, 1), (18, 2), (20, 2), (24, 2), (60, 1), (66, 1), (67, 2), (75, 2), (114, 1), (130, 2), (172, 2), (470, 1)], [], [], [], [(0, 1), (5, 2), (57, 1), (58, 2), (172, 2), (293, 1)], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (9, 1), (13, 2), (15, 1), (18, 1), (20, 2), (24, 2), (57, 1), (66, 2)], [(3, 1), (4, 2), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (24, 2)], [], [], [], [], [], [(3, 1), (4, 2), (66, 2), (68, 1)], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (11, 1)], [], [], [], [], [], [], []] + +def comb50 : List (List (Nat × Nat)) := [[(0, 1), (1, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (18, 1), (19, 2)], [(0, 1), (1, 2), (4, 1), (6, 2), (7, 1), (9, 2), (18, 1), (19, 2), (63, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (6, 1), (7, 1), (8, 1), (9, 1), (18, 1), (19, 2), (57, 2), (63, 1), (114, 1)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (18, 1), (19, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [], [(0, 2), (2, 1), (3, 2), (6, 2), (8, 2), (9, 1), (12, 1), (18, 1), (57, 1), (63, 2), (233, 2)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (18, 1), (19, 2), (24, 1), (57, 1), (63, 2), (233, 2)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (8, 1), (9, 1), (19, 2), (57, 2), (75, 1), (233, 1)], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (9, 1), (18, 1), (19, 2), (57, 2), (63, 1), (233, 1)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (18, 1), (19, 1), (57, 2), (63, 1), (233, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 1), (9, 2), (18, 1), (19, 1), (57, 2), (63, 1), (233, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (18, 2), (19, 2), (57, 1), (63, 2), (233, 2)], [], [], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 1), (7, 2), (19, 1), (57, 1), (64, 2), (114, 1), (121, 2), (233, 1), (234, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 2), (19, 1), (57, 1), (64, 2), (114, 1), (121, 2), (233, 1), (234, 1)], [(2, 2), (3, 1), (5, 1), (6, 2), (8, 2), (9, 2), (18, 2), (63, 2), (64, 1), (114, 1), (121, 2), (233, 2), (234, 2)], [], [(2, 1), (3, 2), (5, 2), (6, 1), (9, 1), (18, 2), (57, 2), (58, 1), (63, 2), (64, 1), (114, 2), (121, 1), (233, 2), (234, 2)], [(1, 1), (2, 1), (3, 2), (4, 2), (5, 2), (6, 1), (8, 2), (9, 2), (18, 2), (57, 2), (64, 1), (114, 2), (121, 1), (233, 2), (234, 2)], [(0, 1), (2, 1), (3, 2), (5, 2), (6, 1), (8, 2), (9, 1), (18, 2), (57, 2), (64, 1), (114, 2), (121, 1), (233, 2), (234, 2)], [], [], [], [], [(0, 2), (5, 1), (9, 2), (12, 2), (14, 1), (18, 1), (57, 1), (64, 2), (114, 1), (121, 2), (233, 1), (234, 1)], [], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (9, 1), (19, 1), (57, 1), (63, 1), (64, 1), (114, 2), (121, 1), (234, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (5, 2), (6, 2), (7, 2), (8, 1), (9, 1), (19, 1), (57, 1), (60, 1), (64, 1), (114, 2), (121, 1), (234, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (8, 1), (19, 1), (57, 1), (64, 2), (114, 2), (121, 1), (234, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 2), (19, 1), (57, 2), (64, 1), (114, 1), (117, 1), (121, 1), (234, 2)], [], [(1, 1), (4, 2), (5, 2), (7, 2), (9, 1), (19, 1), (57, 2), (64, 1), (114, 1), (120, 1), (121, 1), (234, 2)], [(0, 2), (1, 2), (5, 2), (7, 1), (19, 2), (57, 2), (64, 1), (114, 2), (121, 1), (172, 2), (174, 1), (234, 2)], [], [(0, 2), (1, 2), (5, 2), (7, 1), (19, 2), (57, 2), (64, 1), (114, 2), (121, 1), (172, 2), (181, 1), (234, 2)], [(0, 1), (2, 1), (3, 2), (5, 1), (6, 2), (8, 2), (9, 1), (18, 2), (57, 2), (63, 2), (64, 2), (114, 1), (121, 2), (234, 1)], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 2), (18, 2), (57, 2), (63, 2), (64, 2), (114, 1), (121, 2), (234, 1)], [], [(0, 2), (1, 2), (4, 1), (5, 1), (6, 1), (7, 1), (9, 2), (18, 2), (57, 2), (63, 2), (64, 2), (114, 1), (121, 2), (234, 1)], [], [], [(0, 2), (5, 1), (6, 2), (12, 2), (17, 1), (18, 1), (57, 1), (63, 1), (64, 1), (114, 2), (121, 1), (234, 2)], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 2), (18, 2), (57, 2), (60, 2), (63, 2), (64, 2), (65, 1), (114, 1), (121, 2), (234, 1)], [], [], [(0, 2), (5, 1), (6, 2), (8, 1), (12, 2), (18, 1), (57, 1), (64, 1), (71, 1), (114, 2), (121, 1), (234, 2)], [], [], [(0, 1), (2, 1), (3, 2), (5, 1), (9, 1), (12, 2), (18, 1), (57, 2), (64, 1), (114, 1), (121, 1), (127, 1), (234, 2)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 1), (9, 2), (12, 1), (17, 2), (18, 1), (63, 1), (64, 2), (114, 2), (121, 1), (233, 1), (234, 1), (314, 1)], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (12, 2), (18, 2), (19, 2), (63, 1), (64, 2), (114, 2), (120, 2), (121, 2), (233, 1), (234, 1), (392, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (5, 1), (6, 1), (7, 1), (8, 1), (9, 2), (18, 2), (19, 2), (63, 1), (64, 2), (114, 1), (121, 2), (233, 1), (234, 1), (274, 1)], [(0, 1), (1, 1), (4, 1), (5, 1), (7, 2), (9, 2), (12, 1), (17, 2), (19, 1), (57, 1), (75, 2), (233, 2), (470, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (7, 2), (9, 2), (114, 1), (120, 2), (233, 2), (293, 1)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (9, 2), (18, 2), (19, 1), (57, 1), (63, 2)], [(0, 2), (1, 1), (4, 2), (6, 1), (7, 2), (9, 1), (18, 2), (19, 1)], [], [], [], [], [], [(4, 2), (9, 1), (60, 1), (64, 2), (65, 2), (68, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1)], [], [], [], [], [], [], []] + +def comb51 : List (List (Nat × Nat)) := [[(0, 2), (2, 1), (3, 2), (9, 1), (13, 1)], [(0, 2), (2, 1), (3, 2), (8, 2), (9, 1), (13, 1), (63, 1)], [(6, 2), (13, 1), (57, 2), (63, 1), (114, 1)], [], [], [], [], [], [], [(0, 1), (2, 2), (3, 1), (8, 1), (9, 2), (13, 1), (18, 1), (57, 1), (63, 2), (233, 2)], [(0, 1), (2, 2), (3, 1), (8, 1), (9, 2), (13, 1), (24, 1), (57, 1), (63, 2), (233, 2)], [(13, 1), (18, 2), (57, 2), (75, 1), (233, 1)], [(13, 1), (18, 2), (57, 2), (77, 1), (233, 1)], [], [(8, 2), (13, 1), (57, 2), (63, 1), (233, 1)], [(8, 2), (13, 1), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [], [], [(0, 1), (2, 2), (4, 1), (8, 1), (9, 2), (13, 2), (15, 2), (34, 1), (57, 1), (63, 2), (233, 2)], [], [], [], [], [(0, 2), (3, 2), (4, 2), (5, 1), (6, 2), (8, 1), (9, 2), (15, 2), (34, 1), (57, 1), (58, 2), (114, 1), (121, 2), (173, 1), (233, 1)], [(0, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 1), (15, 2), (34, 1), (57, 1), (58, 2), (114, 1), (121, 2), (173, 1), (233, 1)], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (13, 2), (15, 1), (34, 2), (58, 1), (63, 2), (114, 1), (121, 2), (173, 2), (233, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (13, 2), (15, 1), (34, 2), (57, 2), (58, 1), (60, 1), (63, 2), (114, 2), (121, 1), (173, 2), (233, 2)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (13, 2), (15, 1), (34, 2), (57, 2), (58, 1), (114, 2), (121, 1), (173, 2), (233, 2)], [], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (13, 2), (15, 2), (34, 2), (57, 2), (58, 1), (114, 2), (121, 1), (173, 2), (233, 2)], [], [], [], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 2), (13, 1), (15, 1), (18, 2), (21, 1), (34, 2), (57, 1), (58, 2), (114, 1), (121, 2), (173, 1), (233, 1)], [], [], [(0, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (15, 2), (34, 1), (57, 1), (58, 1), (63, 1), (114, 2), (121, 1), (173, 2)], [(0, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (9, 1), (15, 2), (34, 1), (57, 1), (58, 1), (63, 1), (114, 2), (121, 1), (173, 2)], [], [(0, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (15, 2), (34, 1), (57, 1), (58, 2), (114, 2), (121, 1), (173, 2)], [(0, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (15, 2), (34, 1), (57, 1), (58, 1), (64, 1), (114, 2), (121, 1), (173, 2)], [], [(2, 1), (3, 1), (4, 1), (5, 2), (6, 2), (8, 1), (9, 1), (15, 2), (34, 1), (57, 2), (58, 1), (114, 1), (115, 1), (121, 1), (173, 2)], [(2, 1), (3, 1), (4, 1), (5, 2), (6, 2), (8, 1), (9, 1), (15, 2), (34, 1), (57, 2), (58, 1), (114, 1), (120, 1), (121, 1), (173, 2)], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (15, 2), (18, 1), (20, 2), (34, 1), (57, 2), (58, 2), (60, 2), (114, 1), (121, 2), (173, 1), (174, 1)], [(2, 2), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (15, 2), (18, 1), (20, 2), (34, 1), (57, 2), (58, 2), (60, 2), (114, 1), (121, 2), (173, 1), (236, 1)], [], [(2, 2), (3, 2), (4, 2), (5, 1), (6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (34, 2), (57, 2), (58, 2), (63, 2), (114, 1), (121, 2), (173, 1)], [(0, 2), (3, 2), (4, 2), (5, 1), (6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (34, 2), (57, 2), (58, 2), (63, 2), (114, 1), (121, 2), (173, 1)], [], [], [], [], [], [], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 1), (13, 1), (15, 1), (18, 2), (22, 1), (34, 2), (57, 1), (58, 1), (63, 1), (114, 2), (121, 1), (173, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (8, 1), (13, 2), (15, 2), (34, 2), (57, 2), (58, 2), (64, 2), (66, 1), (67, 2), (114, 1), (121, 2), (173, 1)], [], [], [], [], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 2), (13, 1), (15, 1), (18, 2), (34, 2), (57, 1), (58, 1), (80, 1), (114, 2), (121, 1), (173, 2)], [], [], [(0, 1), (2, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (13, 1), (15, 1), (18, 2), (34, 2), (57, 2), (58, 1), (114, 1), (121, 1), (137, 1), (173, 2)], [], [(2, 1), (3, 1), (4, 1), (5, 2), (6, 1), (8, 1), (9, 1), (13, 1), (15, 2), (34, 1), (58, 2), (63, 1), (114, 2), (121, 1), (173, 1), (233, 1), (314, 1)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (13, 2), (15, 2), (34, 1), (58, 2), (63, 1), (114, 1), (121, 2), (173, 1), (216, 1), (233, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (13, 2), (15, 2), (34, 1), (58, 2), (63, 1), (114, 1), (121, 2), (173, 1), (233, 1), (274, 1)], [(0, 2), (2, 1), (4, 2), (9, 1), (13, 2), (15, 1), (18, 2), (20, 2), (34, 2), (57, 1), (75, 2), (233, 2), (470, 1)], [], [], [], [], [(172, 1), (233, 2)], [], [(8, 1), (13, 2), (57, 1), (63, 2)], [(0, 1), (2, 2), (3, 1), (8, 1), (9, 2), (13, 2)], [], [], [], [], [], [], [(0, 1), (4, 1), (5, 2), (8, 1), (9, 2), (15, 2), (63, 2), (67, 1)], [], [], [], [(6, 1), (8, 2)], [], [], [(0, 1), (2, 2), (3, 1), (9, 2)], [], [], []] + +def comb52 : List (List (Nat × Nat)) := [[], [], [], [(1, 2), (2, 2), (4, 1), (7, 1), (12, 2), (14, 2), (15, 1), (16, 1), (17, 1), (19, 2), (20, 1), (57, 2), (63, 1), (71, 2), (172, 1)], [(1, 2), (2, 1), (3, 1), (4, 1), (7, 1), (12, 2), (14, 2), (15, 1), (16, 1), (17, 1), (19, 2), (20, 1), (57, 2), (63, 1), (71, 2), (233, 1)], [], [], [], [(2, 2), (3, 1), (6, 2), (13, 1), (57, 2), (63, 1), (114, 1)], [(1, 2), (2, 2), (4, 1), (6, 2), (7, 1), (12, 2), (14, 2), (15, 1), (16, 1), (17, 1), (18, 1), (19, 2), (20, 1), (57, 2), (63, 1), (71, 2), (114, 1)], [(1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (12, 2), (14, 2), (15, 1), (16, 1), (17, 1), (19, 2), (20, 1), (24, 1), (57, 2), (63, 1), (71, 2), (114, 1)], [(1, 1), (2, 2), (3, 2), (4, 2), (6, 1), (7, 2), (12, 1), (14, 1), (15, 2), (16, 2), (17, 2), (18, 2), (19, 1), (20, 2), (57, 1), (63, 1), (71, 1), (75, 1), (114, 2)], [], [], [(1, 1), (2, 2), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (12, 1), (14, 1), (15, 2), (16, 2), (17, 2), (19, 1), (20, 2), (57, 1), (63, 2), (71, 1), (114, 2)], [], [], [], [], [(2, 2), (3, 1), (6, 2), (8, 1), (57, 2), (63, 1), (114, 1)], [(2, 1), (3, 2), (6, 2), (8, 1), (57, 2), (63, 1), (114, 1)], [(2, 2), (3, 1), (4, 1), (6, 2), (8, 1), (57, 2), (60, 2), (63, 1), (114, 1)], [], [], [], [(1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (13, 2), (14, 2), (15, 1), (16, 1), (18, 1), (19, 2), (57, 1), (60, 2), (63, 2), (114, 2)], [(1, 1), (6, 1), (7, 2), (8, 2), (13, 1), (15, 2), (18, 2), (19, 1), (57, 1), (60, 2), (63, 2), (114, 2)], [(1, 1), (6, 1), (7, 2), (8, 2), (12, 2), (13, 1), (14, 1), (15, 2), (16, 2), (17, 1), (18, 2), (19, 1), (57, 1), (60, 2), (63, 2), (114, 2)], [(1, 1), (3, 2), (6, 2), (7, 2), (12, 1), (13, 2), (15, 1), (18, 2), (19, 1), (57, 2), (60, 2), (63, 1), (66, 1), (67, 2), (72, 2), (114, 1), (121, 1)], [], [], [(1, 2), (2, 1), (3, 2), (6, 2), (7, 2), (13, 2), (15, 1), (18, 2), (19, 1), (57, 2), (60, 1), (63, 1), (114, 1)], [], [], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (13, 1), (14, 2), (15, 1), (16, 1), (18, 1), (19, 2), (57, 1), (60, 2), (63, 2), (114, 2)], [(1, 2), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (13, 1), (15, 1), (16, 1), (18, 1), (19, 2), (57, 1), (60, 2), (63, 2), (114, 2)], [(1, 2), (3, 1), (4, 2), (6, 1), (7, 1), (12, 1), (13, 1), (14, 1), (15, 1), (16, 2), (17, 2), (18, 1), (19, 2), (20, 2), (21, 1), (57, 1), (60, 1), (63, 2), (71, 1), (114, 2)], [(1, 2), (2, 1), (3, 2), (7, 1), (8, 1), (12, 1), (13, 1), (14, 2), (15, 1), (16, 1), (17, 2), (18, 1), (19, 2), (60, 1), (71, 1)], [(1, 2), (2, 1), (3, 2), (7, 1), (8, 1), (13, 1), (15, 2), (18, 1), (19, 2), (60, 1)], [], [], [], [], [], [], [], [], [(1, 2), (3, 1), (4, 2), (7, 1), (12, 1), (13, 1), (14, 1), (15, 1), (16, 2), (17, 2), (18, 2), (19, 2), (20, 2), (57, 1), (60, 1), (63, 2), (71, 1), (172, 2), (174, 1)], [(1, 2), (2, 1), (5, 2), (7, 1), (13, 1), (14, 2), (15, 1), (16, 1), (18, 2), (19, 2), (20, 2), (57, 1), (60, 1), (63, 2), (71, 1), (233, 2), (236, 1)], [(1, 2), (3, 1), (4, 2), (7, 1), (12, 1), (13, 1), (14, 1), (15, 1), (16, 2), (17, 2), (18, 2), (19, 2), (20, 2), (57, 1), (60, 1), (63, 2), (71, 1), (172, 2), (181, 1)], [], [(1, 1), (2, 2), (3, 1), (4, 1), (7, 2), (13, 1), (14, 1), (15, 2), (16, 2), (18, 2), (19, 1), (60, 1)], [(1, 2), (2, 1), (3, 2), (7, 1), (13, 2), (15, 1), (18, 1), (19, 2), (60, 2)], [(1, 2), (2, 1), (3, 2), (4, 2), (5, 1), (7, 1), (12, 1), (13, 2), (14, 2), (15, 1), (16, 1), (17, 2), (18, 1), (19, 2), (60, 2)], [(1, 1), (2, 1), (3, 2), (7, 2), (12, 2), (13, 2), (14, 1), (15, 2), (16, 2), (17, 1), (18, 1), (19, 2), (60, 2), (71, 2)], [(1, 1), (2, 1), (3, 2), (7, 1), (10, 1), (13, 2), (15, 2), (18, 1), (19, 2), (60, 2), (71, 2)], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 1), (7, 2), (12, 2), (13, 1), (14, 1), (15, 2), (16, 2), (18, 2), (19, 1), (60, 1), (72, 1)], [(1, 2), (2, 1), (3, 2), (7, 1), (13, 2), (15, 1), (18, 1), (19, 2), (60, 1), (65, 1)], [(1, 2), (2, 2), (3, 2), (7, 1), (13, 2), (14, 2), (15, 1), (16, 1), (17, 2), (18, 1), (19, 2), (60, 1), (66, 2), (67, 1), (72, 1)], [], [], [], [], [], [], [], [], [(1, 1), (4, 1), (6, 1), (7, 2), (8, 1), (13, 2), (15, 2), (16, 2), (18, 2), (19, 1), (44, 1), (57, 2), (60, 1), (63, 1), (114, 1)], [(1, 1), (4, 1), (6, 2), (7, 2), (12, 2), (13, 2), (14, 1), (15, 2), (16, 2), (18, 2), (19, 1), (57, 1), (60, 1), (63, 2), (99, 1), (114, 1)], [(1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (8, 1), (13, 2), (15, 2), (16, 2), (18, 2), (19, 1), (57, 1), (60, 1), (63, 2), (114, 1), (157, 1)], [], [], [], [], [(2, 1), (3, 2), (6, 1), (57, 1), (63, 2), (114, 2)], [(2, 1), (3, 2), (6, 1), (8, 2), (57, 1), (114, 2)], [], [], [], [], [(2, 1), (3, 2), (57, 1), (63, 2)], [], [], [], [], [], [], [(4, 2), (60, 1), (65, 2), (68, 1)], [(3, 2), (12, 1), (66, 1), (72, 2)], [], [], [(1, 1), (4, 2), (7, 2), (11, 1), (12, 1), (14, 2), (15, 2), (16, 1), (17, 2), (71, 1)], [(2, 1), (3, 2), (6, 1), (8, 2)], [], [], [], [], [], []] + +def comb53 : List (List (Nat × Nat)) := [[], [], [(6, 2), (13, 1), (57, 2), (63, 1), (114, 1)], [(1, 2), (4, 1), (8, 2), (13, 1), (15, 1), (16, 2), (57, 2), (63, 1), (172, 1)], [(1, 2), (4, 1), (8, 2), (13, 1), (15, 1), (16, 2), (57, 2), (63, 1), (233, 1)], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 2), (10, 1), (15, 1), (16, 2), (18, 1), (19, 2), (57, 2), (63, 1), (114, 1), (120, 2), (293, 1)], [], [(0, 1), (1, 1), (4, 2), (5, 2), (6, 2), (8, 2), (10, 1), (15, 2), (16, 1), (18, 2), (19, 2), (57, 2), (63, 1), (114, 1), (120, 2), (293, 1)], [(0, 1), (1, 1), (4, 2), (5, 2), (6, 2), (8, 2), (10, 1), (15, 2), (16, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (114, 1), (120, 2), (293, 1)], [], [(1, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 2), (10, 2), (11, 1), (13, 2), (15, 2), (16, 1), (18, 2), (57, 1), (63, 2), (65, 2), (77, 1), (114, 2), (120, 1), (293, 2)], [], [], [(1, 2), (4, 1), (5, 1), (6, 1), (8, 1), (9, 2), (10, 2), (11, 1), (13, 2), (15, 1), (16, 1), (18, 2), (20, 1), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 2), (8, 2), (10, 1), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2), (57, 2), (63, 1), (114, 1), (120, 2), (293, 1)], [], [], [(0, 1), (1, 1), (4, 2), (5, 2), (6, 2), (8, 2), (10, 1), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2), (57, 2), (63, 1), (114, 1), (120, 2), (293, 1)], [], [], [(0, 1), (1, 2), (4, 1), (5, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (13, 2), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [], [(0, 1), (1, 1), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (10, 2), (11, 2), (13, 2), (15, 1), (16, 2), (18, 1), (19, 2), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [(0, 1), (1, 1), (4, 2), (5, 1), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (16, 2), (18, 1), (19, 2), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [(0, 2), (1, 2), (4, 1), (5, 2), (7, 2), (8, 1), (9, 2), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1), (120, 2), (121, 1), (293, 1)], [(1, 1), (4, 1), (5, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 2), (57, 2), (60, 1), (63, 1), (65, 2), (114, 1), (120, 2), (293, 1)], [], [], [], [], [], [(1, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [], [], [(0, 1), (1, 1), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (10, 2), (11, 2), (19, 2), (21, 1), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [(0, 1), (7, 2), (8, 1), (9, 2), (11, 1), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2)], [], [], [], [(0, 1), (7, 1), (8, 1), (9, 2), (11, 1), (13, 1), (15, 1), (16, 2), (18, 1), (19, 2), (65, 1)], [], [], [], [(0, 1), (1, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (16, 2), (18, 1), (19, 2), (57, 1), (63, 2), (114, 2), (115, 1)], [(0, 1), (1, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (16, 2), (18, 1), (19, 2), (57, 1), (63, 2), (114, 2), (120, 1)], [], [], [(0, 2), (4, 2), (7, 2), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (16, 2), (18, 2), (19, 1), (57, 1), (63, 2), (172, 2), (181, 1)], [(0, 2), (1, 2), (4, 1), (7, 2), (8, 1), (9, 2), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1)], [], [(0, 1), (1, 1), (7, 1), (8, 2), (9, 2), (11, 1), (15, 1), (16, 2), (18, 1), (19, 2)], [(0, 1), (1, 1), (4, 2), (5, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (15, 1), (16, 2), (18, 1), (19, 2)], [], [], [(0, 1), (7, 1), (8, 2), (9, 2), (11, 1), (15, 2), (16, 2), (18, 1), (19, 2)], [(0, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (15, 2), (16, 1), (17, 1), (18, 1), (19, 2)], [], [(0, 2), (1, 2), (4, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1), (65, 1), (66, 1), (67, 2)], [], [], [(0, 1), (1, 1), (8, 2), (9, 2), (11, 1), (15, 1), (16, 2), (18, 1), (19, 2), (60, 2), (65, 1), (71, 1), (73, 1), (74, 2)], [(0, 1), (1, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (15, 1), (16, 2), (18, 1), (19, 2), (60, 2), (65, 1), (71, 1)], [], [], [], [(0, 1), (1, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (19, 2), (57, 1), (63, 2), (114, 2), (137, 1)], [], [], [(0, 2), (1, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 2), (10, 1), (11, 1), (13, 1), (44, 1), (57, 2), (63, 1), (114, 1), (120, 2), (293, 1)], [(1, 1), (4, 2), (5, 2), (6, 2), (7, 2), (9, 1), (10, 1), (11, 1), (13, 1), (57, 1), (63, 2), (99, 1), (114, 1), (120, 2), (293, 1)], [], [(1, 1), (4, 2), (5, 2), (7, 2), (8, 1), (9, 2), (10, 1), (11, 1), (13, 1), (57, 1), (63, 2), (114, 2), (120, 1), (293, 1), (392, 1)], [], [], [], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 1), (8, 1), (10, 2), (15, 2), (16, 1), (18, 2), (19, 1), (57, 1), (63, 2), (114, 2), (120, 1), (293, 2)], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 1), (10, 2), (15, 2), (16, 1), (18, 2), (19, 1), (57, 1), (114, 2), (120, 1), (293, 2)], [], [], [], [], [(8, 1), (13, 2), (57, 1), (63, 2)], [], [], [], [], [], [(4, 2), (7, 1), (60, 1), (65, 2), (71, 2), (74, 1)], [], [(7, 1), (10, 2), (65, 2), (67, 1)], [], [(1, 1), (4, 2), (15, 2), (16, 1)], [], [(6, 1), (8, 2)], [], [], [], [], [], []] + +def comb54 : List (List (Nat × Nat)) := [[], [], [(0, 1), (6, 2), (8, 2), (9, 2), (10, 1), (11, 1), (13, 1), (17, 2), (18, 1), (19, 2), (57, 2), (63, 1), (114, 1)], [], [(0, 2), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (18, 1), (19, 1), (57, 2), (63, 1), (233, 1)], [], [], [(0, 1), (8, 2), (9, 2), (10, 1), (11, 1), (13, 1), (17, 2), (19, 2), (57, 2), (63, 1), (172, 1)], [(0, 1), (8, 1), (9, 2), (10, 1), (11, 1), (13, 2), (17, 2), (19, 2), (57, 2), (63, 1), (172, 1)], [], [(0, 2), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (19, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [], [], [(0, 1), (6, 1), (8, 2), (9, 2), (10, 1), (11, 1), (13, 1), (17, 2), (18, 2), (19, 2), (57, 1), (63, 2), (172, 2)], [], [], [], [(0, 2), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (18, 1), (19, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [(2, 1), (3, 2), (5, 1), (6, 2), (7, 1), (8, 2), (10, 1), (11, 1), (13, 2), (17, 1), (18, 2), (19, 1), (24, 1), (25, 2), (57, 1), (63, 2), (172, 2)], [(2, 2), (3, 2), (5, 1), (6, 2), (7, 2), (8, 1), (10, 1), (11, 1), (12, 2), (17, 1), (18, 2), (24, 1), (25, 2), (57, 1), (63, 2), (172, 2)], [], [(2, 1), (3, 2), (5, 2), (6, 2), (7, 1), (10, 2), (11, 2), (18, 2), (24, 2), (25, 1), (57, 1), (63, 2), (172, 2)], [(0, 2), (2, 2), (3, 1), (5, 1), (6, 2), (7, 2), (8, 1), (9, 1), (13, 2), (17, 1), (19, 1), (24, 1), (25, 2), (114, 2), (121, 1), (172, 1)], [], [(0, 2), (2, 2), (3, 1), (5, 1), (6, 2), (7, 1), (10, 1), (11, 1), (17, 1), (19, 1), (24, 1), (25, 2), (57, 2), (58, 1), (63, 1), (72, 2), (172, 1)], [], [(0, 2), (2, 2), (3, 1), (5, 2), (6, 2), (7, 1), (8, 2), (9, 1), (10, 1), (11, 1), (19, 1), (24, 2), (25, 1), (57, 2), (63, 1), (172, 1)], [], [(2, 2), (3, 1), (5, 1), (6, 2), (7, 2), (8, 1), (10, 1), (11, 1), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (24, 1), (25, 2), (57, 1), (63, 2), (172, 2)], [(2, 2), (3, 1), (5, 1), (6, 2), (7, 1), (10, 2), (11, 2), (24, 1), (25, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 1), (2, 2), (3, 1), (5, 1), (6, 2), (7, 2), (9, 2), (10, 2), (11, 2), (12, 2), (14, 1), (19, 2), (24, 1), (25, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (2, 2), (3, 1), (5, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (13, 2), (17, 1), (18, 1), (19, 1), (24, 1), (25, 2)], [], [(2, 2), (3, 1), (5, 1), (6, 1), (7, 2), (8, 1), (10, 1), (11, 1), (13, 2), (17, 1), (18, 1), (24, 1), (25, 2)], [], [], [(0, 2), (2, 2), (3, 1), (5, 2), (6, 1), (7, 2), (9, 1), (10, 1), (11, 1), (13, 2), (18, 1), (24, 2), (25, 1), (72, 1)], [], [(2, 2), (3, 1), (5, 1), (7, 1), (10, 2), (11, 1), (18, 2), (24, 1), (25, 2), (57, 1), (63, 2), (114, 2), (117, 1)], [], [(2, 2), (3, 1), (5, 1), (7, 1), (9, 2), (10, 2), (11, 2), (18, 2), (24, 1), (25, 2), (57, 1), (63, 2), (114, 2), (120, 1)], [], [(2, 2), (3, 1), (5, 1), (6, 2), (7, 1), (10, 2), (11, 2), (18, 2), (24, 2), (25, 1), (57, 1), (63, 2), (233, 2), (236, 1)], [], [(0, 2), (2, 1), (3, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 2), (13, 2), (17, 1), (19, 1), (24, 2), (25, 1)], [(0, 1), (2, 1), (3, 2), (5, 2), (6, 1), (7, 1), (8, 2), (9, 2), (12, 1), (13, 1), (17, 1), (19, 2), (24, 2), (25, 1)], [], [(0, 1), (2, 1), (3, 2), (5, 2), (6, 1), (7, 2), (9, 2), (10, 2), (11, 2), (13, 1), (17, 2), (19, 2), (24, 1), (25, 2)], [(0, 2), (2, 1), (3, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 1), (11, 1), (13, 2), (17, 1), (19, 1), (24, 2), (25, 1)], [], [(0, 2), (2, 1), (3, 2), (5, 2), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (13, 2), (14, 2), (16, 1), (19, 1), (24, 2), (25, 1)], [], [(0, 2), (2, 1), (3, 2), (5, 1), (6, 1), (7, 2), (9, 1), (10, 2), (13, 1), (17, 2), (19, 1), (22, 1), (24, 1), (25, 2)], [], [(0, 2), (2, 1), (3, 2), (5, 2), (6, 1), (7, 1), (9, 1), (10, 1), (11, 1), (12, 1), (14, 2), (15, 2), (16, 1), (19, 1), (24, 2), (25, 1), (65, 1)], [], [(0, 1), (2, 1), (3, 2), (6, 1), (7, 1), (9, 2), (10, 1), (11, 1), (12, 1), (13, 2), (14, 2), (19, 1), (72, 1), (73, 1), (74, 2)], [], [(0, 2), (2, 1), (3, 2), (5, 2), (6, 1), (7, 2), (8, 2), (9, 2), (10, 2), (13, 1), (17, 1), (19, 1), (24, 2), (25, 1), (58, 2), (72, 1), (80, 1)], [], [(0, 1), (2, 2), (3, 1), (5, 1), (6, 2), (7, 2), (9, 2), (10, 2), (11, 2), (17, 2), (19, 2), (24, 1), (25, 2), (57, 1), (63, 2), (114, 2), (127, 1)], [], [], [], [(2, 1), (3, 2), (5, 2), (7, 2), (8, 2), (10, 2), (11, 2), (12, 1), (13, 1), (14, 2), (17, 2), (18, 1), (19, 2), (24, 2), (25, 1), (44, 1), (57, 2), (63, 1), (172, 1)], [(0, 1), (2, 1), (3, 2), (5, 2), (6, 1), (7, 2), (8, 1), (9, 2), (10, 2), (11, 2), (13, 1), (17, 2), (18, 1), (19, 2), (24, 2), (25, 1), (57, 1), (63, 2), (99, 1), (172, 1)], [], [], [(0, 1), (2, 1), (3, 2), (5, 2), (6, 1), (7, 1), (9, 2), (12, 1), (13, 2), (14, 2), (17, 1), (18, 1), (19, 2), (24, 2), (25, 1), (57, 1), (63, 2), (172, 1), (216, 1)], [], [], [(0, 2), (8, 2), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (19, 1), (57, 1), (63, 2), (172, 2)], [(0, 2), (8, 1), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (19, 1), (57, 1), (172, 2)], [], [], [], [], [(0, 2), (8, 2), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (18, 2), (19, 1), (57, 1), (63, 2)], [], [], [], [], [], [(5, 2), (8, 2), (10, 2), (11, 2), (13, 2), (17, 1), (19, 1), (24, 2), (25, 1), (72, 2), (74, 1)], [(7, 1), (8, 1), (10, 2), (11, 2), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (65, 2), (68, 1)], [], [], [(0, 2), (8, 1), (9, 1), (10, 2), (11, 2), (13, 2), (17, 1), (19, 1)], [], [], [], [], [], [], [], []] + +def comb55 : List (List (Nat × Nat)) := [[], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (11, 1), (13, 1), (14, 1), (16, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (114, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (11, 2), (13, 2), (14, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (172, 1)], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (7, 1), (8, 1), (11, 1), (13, 1), (14, 1), (16, 1), (18, 1), (19, 2), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (7, 1), (11, 1), (13, 2), (14, 1), (16, 1), (18, 1), (19, 2), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (11, 2), (13, 2), (14, 1), (18, 2), (19, 2), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [], [(0, 1), (2, 2), (6, 1), (7, 1), (8, 1), (11, 1), (13, 1), (14, 1), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (63, 2), (64, 2), (66, 1), (233, 2)], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (7, 2), (8, 1), (11, 1), (13, 1), (14, 2), (18, 2), (19, 1), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (11, 2), (13, 2), (14, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (11, 2), (13, 2), (14, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (8, 1), (9, 1), (11, 1), (13, 2), (14, 2), (16, 2), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(1, 2), (3, 2), (4, 1), (6, 1), (9, 2), (11, 1), (14, 1), (16, 2), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(0, 1), (1, 1), (3, 1), (4, 2), (7, 1), (9, 1), (11, 2), (14, 2), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [(0, 2), (1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (13, 1), (14, 1), (15, 1), (18, 2), (19, 1), (64, 2), (66, 1), (67, 2), (114, 2), (121, 1), (233, 1)], [], [], [], [], [(1, 1), (3, 2), (4, 2), (6, 2), (8, 1), (9, 1), (11, 1), (14, 1), (16, 2), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (9, 2), (11, 1), (13, 2), (14, 2), (15, 1), (16, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [(1, 2), (2, 2), (3, 2), (4, 1), (9, 2), (11, 2), (12, 1), (14, 1), (16, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [], [], [(0, 1), (7, 2), (8, 2), (9, 2), (13, 2), (16, 1), (18, 1), (19, 2), (24, 1)], [], [], [(0, 1), (7, 1), (8, 2), (9, 2), (11, 1), (13, 2), (16, 1), (18, 1), (19, 2), (24, 1)], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 1), (13, 2), (14, 1), (18, 2), (19, 1), (24, 1), (66, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (11, 1), (14, 2), (16, 1), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (114, 2), (117, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (9, 1), (11, 2), (14, 2), (16, 1), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (114, 2), (115, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (11, 2), (14, 2), (16, 1), (18, 1), (19, 2), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2), (172, 2), (174, 1)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 2), (8, 2), (9, 2), (13, 2), (16, 1), (18, 2), (19, 1)], [(0, 2), (7, 2), (9, 1), (13, 1), (14, 1), (16, 1), (18, 2), (19, 1)], [(0, 1), (1, 1), (6, 1), (7, 1), (9, 2), (11, 2), (13, 1), (16, 2), (18, 1), (19, 2)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (9, 1), (10, 1), (11, 1), (13, 2), (16, 1), (18, 2), (19, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 2), (8, 2), (9, 1), (11, 1), (12, 2), (13, 2), (14, 1), (17, 1), (18, 2), (19, 1)], [(0, 2), (6, 1), (7, 1), (9, 1), (13, 1), (16, 2), (18, 1), (19, 1), (22, 1)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 1), (15, 2), (16, 1), (18, 2), (19, 1), (67, 1)], [], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 2), (9, 1), (11, 1), (13, 1), (14, 1), (64, 2), (66, 1), (71, 1)], [(1, 2), (3, 2), (4, 1), (7, 2), (9, 1), (13, 1), (14, 1), (16, 1), (18, 2), (64, 2), (66, 1), (80, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (11, 2), (14, 2), (57, 1), (63, 2), (64, 1), (66, 2), (114, 2), (130, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (8, 2), (9, 2), (11, 2), (13, 1), (14, 1), (16, 1), (24, 1), (44, 1), (57, 2), (63, 1), (64, 2), (66, 1), (233, 1)], [(0, 1), (2, 1), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (18, 1), (19, 2), (24, 1), (57, 1), (63, 2), (64, 1), (66, 2), (99, 1), (233, 1)], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (9, 1), (12, 2), (13, 2), (16, 2), (18, 1), (19, 2), (24, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 1), (274, 1)], [], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 2), (13, 2), (14, 2), (16, 2), (18, 2), (19, 1), (57, 1), (63, 2), (64, 1), (66, 2), (233, 2)], [(8, 1), (11, 2), (13, 2), (16, 1), (57, 1), (233, 2)], [], [], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 2), (13, 2), (14, 2), (16, 2), (18, 2), (19, 1), (24, 2), (57, 1), (63, 2), (64, 1), (66, 2)], [], [], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 1), (11, 2), (13, 2), (14, 2), (16, 1), (18, 2), (19, 1), (66, 2), (73, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 1), (7, 2), (9, 1), (11, 2), (14, 2), (16, 1), (18, 2), (19, 1), (66, 2), (68, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (8, 1), (11, 2), (13, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb56 : List (List (Nat × Nat)) := [[], [(1, 2), (2, 1), (3, 2), (4, 1), (8, 2), (12, 2), (14, 1), (15, 1), (16, 2), (18, 1), (63, 1)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (18, 1), (21, 1), (57, 2), (63, 1), (233, 1)], [], [(5, 1), (8, 2), (13, 1), (17, 2), (57, 2), (63, 1), (172, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (12, 2), (13, 1), (14, 1), (15, 1), (16, 2), (57, 2), (63, 1), (172, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (21, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (9, 1), (18, 1), (21, 2), (57, 1), (63, 1), (75, 1), (172, 2)], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (8, 2), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (18, 1), (20, 1), (57, 2), (63, 1), (172, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (8, 2), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (18, 1), (21, 1), (57, 2), (63, 1), (172, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (12, 2), (14, 1), (15, 1), (16, 2), (18, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (9, 2), (12, 1), (14, 2), (15, 2), (16, 1), (18, 1), (21, 1), (57, 2), (63, 1), (172, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 2), (9, 1), (14, 2), (15, 2), (16, 1), (17, 1), (18, 2), (21, 1), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (3, 1), (4, 2), (5, 1), (8, 1), (9, 1), (12, 1), (17, 2), (18, 2), (21, 1), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (8, 1), (9, 1), (12, 1), (17, 2), (18, 2), (21, 1), (57, 1), (63, 2), (172, 2)], [], [], [(1, 1), (5, 2), (9, 2), (14, 2), (15, 2), (16, 1), (17, 1), (21, 2), (57, 2), (58, 1), (172, 1)], [], [], [(1, 2), (2, 2), (3, 1), (5, 1), (6, 2), (8, 2), (12, 1), (13, 2), (14, 1), (15, 1), (16, 2), (17, 2), (21, 1), (57, 1), (63, 2), (172, 2)], [], [], [], [(1, 2), (5, 1), (8, 1), (13, 2), (14, 2), (15, 1), (16, 2), (17, 2), (21, 1), (57, 1), (63, 2), (172, 2)], [], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (12, 2), (13, 2), (17, 2), (18, 1), (21, 1)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (9, 2), (12, 2), (13, 2), (17, 2), (18, 1), (21, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 2), (12, 2), (17, 1), (18, 2), (21, 1), (60, 1), (63, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 2), (9, 2), (12, 2), (17, 1), (18, 2), (21, 2), (63, 2), (64, 1)], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (8, 2), (9, 2), (12, 1), (17, 2), (18, 1), (21, 2), (58, 2), (63, 1), (115, 1)], [], [], [(0, 2), (1, 2), (2, 1), (5, 1), (8, 1), (9, 1), (15, 1), (17, 2), (18, 2), (20, 2), (21, 1), (57, 1), (63, 2), (233, 2), (236, 1)], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (9, 1), (12, 2), (14, 2), (15, 2), (16, 1), (17, 2), (21, 1)], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (12, 2), (14, 2), (15, 2), (16, 1), (17, 2), (21, 2)], [], [], [(1, 2), (5, 1), (10, 1), (12, 1), (14, 1), (15, 1), (16, 2), (17, 1), (21, 1)], [(1, 1), (5, 2), (14, 1), (15, 2), (16, 2), (17, 1), (21, 2)], [], [(1, 2), (5, 1), (12, 1), (14, 1), (15, 1), (16, 2), (17, 1), (21, 1), (22, 1)], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (12, 2), (14, 2), (15, 2), (16, 1), (17, 2), (21, 2), (60, 2), (65, 1)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (9, 2), (12, 1), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (21, 2), (63, 2), (71, 1)], [], [(1, 1), (5, 2), (8, 2), (12, 2), (13, 1), (14, 1), (15, 2), (16, 1), (17, 2), (21, 2), (58, 2), (63, 1), (115, 1), (130, 1), (131, 2)], [], [(0, 1), (1, 1), (5, 1), (8, 2), (13, 1), (14, 1), (15, 1), (16, 2), (17, 1), (21, 2), (58, 2), (63, 1), (137, 1)], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (12, 2), (13, 1), (14, 2), (17, 1), (18, 1), (21, 2), (44, 1), (57, 2), (63, 1), (172, 1)], [], [(0, 1), (5, 2), (8, 1), (9, 2), (12, 2), (13, 1), (14, 2), (17, 1), (18, 1), (57, 1), (63, 2), (157, 1), (172, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (9, 2), (12, 1), (13, 1), (15, 1), (16, 2), (17, 1), (18, 1), (57, 1), (63, 2), (172, 1), (216, 1)], [], [], [(0, 2), (1, 1), (8, 1), (9, 1), (12, 1), (14, 2), (15, 2), (16, 1), (21, 2), (57, 1), (63, 2), (172, 2)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (12, 1), (14, 2), (15, 2), (16, 1), (114, 1), (172, 2)], [], [], [], [(0, 2), (1, 1), (8, 1), (9, 1), (12, 1), (14, 2), (15, 2), (16, 1), (18, 2), (21, 2), (57, 1), (63, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (8, 1), (12, 1), (14, 2), (15, 2), (16, 1), (18, 2)], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 2), (12, 2), (13, 2), (14, 2), (15, 2), (16, 1), (17, 2), (58, 1), (63, 2), (115, 2), (131, 1)], [], [(9, 1), (21, 2), (60, 1), (64, 2), (65, 2), (68, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (12, 1), (14, 2), (15, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb57 : List (List (Nat × Nat)) := [[], [(0, 1), (1, 2), (2, 2), (4, 1), (9, 2), (13, 2), (14, 1), (15, 1), (16, 2), (24, 1), (66, 1)], [], [(0, 1), (1, 1), (2, 2), (4, 2), (9, 2), (13, 2), (14, 1), (15, 2), (16, 1), (24, 1), (57, 2), (66, 1), (172, 1)], [], [], [(0, 1), (2, 2), (4, 1), (9, 2), (14, 1), (16, 2), (57, 2), (66, 1), (233, 1)], [], [(0, 1), (1, 2), (2, 2), (4, 1), (9, 2), (14, 1), (15, 1), (16, 2), (57, 2), (66, 1), (233, 1)], [(0, 1), (1, 1), (2, 2), (4, 2), (9, 2), (13, 2), (14, 1), (15, 2), (16, 1), (18, 1), (57, 2), (66, 1), (233, 1)], [], [(0, 1), (2, 2), (9, 2), (13, 2), (14, 1), (18, 2), (24, 2), (57, 1), (66, 1), (75, 1), (233, 2)], [], [(0, 1), (1, 2), (2, 2), (4, 1), (8, 2), (9, 2), (13, 2), (14, 1), (15, 1), (16, 2), (24, 2), (57, 1), (63, 1), (66, 1), (233, 2)], [], [(0, 1), (2, 1), (4, 1), (9, 2), (14, 1), (16, 2), (18, 2), (20, 1), (24, 1), (57, 2), (66, 1), (233, 1)], [(0, 1), (1, 1), (2, 2), (4, 2), (6, 1), (8, 2), (9, 2), (13, 2), (14, 1), (15, 2), (16, 1), (24, 1), (57, 2), (66, 1), (233, 1)], [], [], [(0, 1), (1, 1), (2, 2), (4, 2), (9, 2), (13, 2), (14, 1), (15, 2), (16, 1), (24, 1), (57, 2), (66, 1), (233, 1)], [], [], [], [(1, 1), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (11, 1), (13, 1), (14, 1), (15, 2), (16, 2), (24, 2), (57, 1), (66, 2), (233, 2)], [], [(3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (11, 1), (13, 1), (16, 2), (24, 2), (57, 1), (66, 2), (233, 2)], [(3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 1), (13, 1), (16, 2), (24, 2), (57, 1), (66, 2), (233, 2)], [], [], [], [], [], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (14, 1), (15, 1), (16, 1), (57, 1), (66, 2), (233, 2)], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (14, 2), (15, 2), (16, 2), (57, 2), (66, 1), (233, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (11, 2), (12, 1), (15, 1), (16, 1), (57, 1), (66, 2), (233, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (13, 2), (14, 2), (16, 2), (24, 1)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (13, 2), (14, 2), (16, 2), (24, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (13, 1), (14, 1), (16, 1), (24, 2), (60, 1), (66, 2)], [(3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (13, 1), (14, 1), (16, 1), (24, 2), (58, 1), (66, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (8, 2), (11, 2), (13, 1), (16, 2), (24, 1), (63, 2), (66, 1), (120, 1)], [(0, 1), (1, 1), (3, 2), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (15, 2), (16, 1), (18, 1), (20, 2), (24, 2), (57, 1), (66, 2), (172, 2), (174, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (14, 1), (15, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (14, 1), (15, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (11, 2), (14, 2), (15, 1)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (14, 2), (15, 2), (16, 2), (17, 1)], [(0, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (13, 1), (14, 1), (16, 1), (18, 2), (22, 1)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (14, 1), (15, 2), (60, 2), (67, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (14, 1), (15, 1), (66, 2), (73, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 1), (7, 2), (9, 1), (11, 1), (13, 2), (14, 2), (15, 1), (63, 2), (66, 1), (127, 1)], [(0, 2), (1, 2), (2, 1), (3, 1), (6, 1), (7, 2), (9, 1), (11, 1), (14, 2), (16, 1), (18, 2), (63, 2), (66, 1), (137, 1)], [], [], [(0, 2), (3, 2), (4, 2), (6, 1), (7, 2), (8, 1), (9, 1), (11, 1), (14, 2), (16, 1), (24, 1), (44, 1), (57, 2), (66, 1), (233, 1)], [], [(2, 2), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (11, 1), (13, 2), (16, 1), (24, 1), (57, 1), (66, 2), (157, 1), (233, 1)], [], [], [(1, 2), (3, 1), (6, 2), (7, 2), (8, 1), (11, 1), (12, 2), (13, 2), (14, 1), (15, 1), (24, 1), (57, 1), (66, 2), (233, 1), (274, 1)], [], [(0, 2), (1, 1), (2, 1), (4, 2), (9, 1), (13, 1), (14, 2), (15, 2), (16, 1), (57, 1), (66, 2), (233, 2)], [], [(1, 1), (4, 2), (6, 2), (8, 1), (15, 2), (16, 1), (114, 1), (233, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (4, 2), (9, 1), (13, 1), (14, 2), (15, 2), (16, 1), (24, 2), (57, 1), (66, 2)], [(1, 1), (4, 2), (8, 1), (15, 2), (16, 1), (24, 2)], [], [], [], [(1, 1), (3, 1), (4, 2), (8, 2), (9, 1), (13, 1), (14, 2), (15, 2), (63, 1), (66, 2), (120, 2), (130, 1)], [], [(3, 1), (4, 2), (66, 2), (68, 1)], [], [], [(1, 1), (4, 2), (15, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb58 : List (List (Nat × Nat)) := [[], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (12, 2), (14, 1), (18, 1), (19, 2), (72, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (12, 2), (14, 1), (18, 1), (19, 2), (57, 2), (72, 1), (114, 1)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (12, 1), (14, 2), (18, 1), (19, 1), (57, 2), (63, 2), (72, 2), (233, 1)], [], [(5, 1), (7, 1), (10, 2), (12, 2), (14, 1), (19, 2), (57, 2), (72, 1), (172, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (8, 2), (12, 2), (14, 1), (19, 2), (57, 2), (72, 1), (172, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (12, 1), (14, 2), (19, 1), (24, 1), (57, 2), (63, 2), (72, 2), (172, 1)], [], [(0, 1), (1, 2), (6, 2), (7, 1), (8, 2), (12, 2), (14, 1), (18, 2), (19, 2), (57, 1), (63, 1), (77, 1), (172, 2)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (12, 2), (14, 1), (18, 1), (19, 2), (57, 2), (72, 1), (172, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 2), (12, 1), (14, 2), (18, 1), (19, 1), (57, 2), (63, 2), (72, 2), (172, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (12, 2), (14, 1), (18, 2), (19, 2), (57, 1), (63, 1), (72, 1), (172, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 2), (10, 1), (12, 1), (18, 2), (19, 2), (57, 1), (72, 2), (172, 2)], [(0, 2), (5, 1), (7, 1), (8, 1), (10, 2), (18, 2), (19, 2), (57, 1), (63, 2), (172, 2)], [], [], [(0, 1), (5, 2), (7, 1), (8, 1), (10, 2), (18, 2), (19, 2), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (7, 1), (10, 1), (12, 1), (14, 2), (19, 2), (57, 2), (60, 1), (63, 1), (72, 2), (172, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (10, 1), (12, 1), (14, 2), (19, 2), (57, 2), (58, 1), (63, 1), (72, 2), (172, 1)], [(0, 2), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (19, 1), (57, 1), (63, 2), (172, 2)], [], [(0, 2), (1, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (19, 1), (57, 1), (63, 2), (172, 2)], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (7, 2), (9, 1), (10, 2), (12, 2), (19, 1), (57, 1), (63, 1), (72, 1), (172, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (10, 1), (12, 1), (14, 2), (19, 2), (57, 2), (63, 1), (172, 1)], [], [], [], [], [(0, 2), (5, 1), (7, 1), (8, 2), (10, 2), (12, 1), (14, 2), (18, 1), (19, 2), (63, 1), (72, 2)], [], [], [], [(0, 2), (2, 2), (5, 2), (6, 2), (7, 2), (8, 2), (9, 2), (10, 1), (14, 1), (18, 2), (19, 1), (63, 2), (64, 1)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (6, 1), (7, 2), (10, 2), (12, 2), (14, 1), (18, 2), (19, 1), (57, 1), (63, 1), (72, 1), (114, 2), (120, 1)], [(0, 1), (2, 1), (5, 1), (7, 1), (8, 2), (10, 2), (14, 2), (18, 1), (19, 2), (60, 2), (63, 1), (174, 1)], [], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 1), (6, 1), (8, 2), (10, 2), (12, 1), (14, 2), (63, 1), (72, 2)], [(0, 1), (1, 1), (5, 1), (6, 1), (8, 2), (10, 2), (12, 1), (14, 2), (63, 1), (72, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (10, 1), (12, 1), (14, 2), (63, 1), (72, 2)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (10, 1), (12, 1), (14, 2), (17, 1), (63, 2), (72, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (10, 1), (12, 2), (14, 1), (22, 1), (63, 2), (72, 1)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 1), (10, 1), (12, 2), (14, 1), (63, 1), (67, 1), (72, 1)], [(1, 1), (3, 1), (4, 2), (5, 2), (6, 1), (8, 2), (9, 1), (10, 2), (12, 1), (14, 1), (63, 1), (64, 2), (73, 1), (74, 2)], [], [], [(0, 1), (1, 2), (4, 1), (6, 2), (8, 1), (10, 1), (12, 2), (14, 1), (57, 2), (63, 2), (72, 2), (114, 1), (120, 2), (130, 1), (131, 2)], [], [], [], [], [(0, 1), (5, 2), (7, 2), (8, 2), (10, 1), (18, 1), (19, 1), (44, 1), (57, 2), (63, 1), (172, 1)], [], [], [(0, 2), (2, 2), (3, 1), (5, 2), (6, 2), (7, 2), (8, 2), (10, 1), (18, 1), (19, 1), (57, 1), (63, 2), (114, 1), (120, 2), (172, 1), (392, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 1), (10, 1), (12, 2), (14, 1), (18, 1), (19, 1), (57, 1), (63, 1), (72, 1), (172, 1), (216, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 1), (12, 1), (14, 2), (19, 1), (57, 1), (72, 2), (172, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 2), (6, 2), (7, 2), (8, 1), (12, 1), (14, 2), (63, 1), (72, 2), (114, 1), (120, 2), (172, 2), (293, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 1), (12, 1), (14, 2), (18, 2), (19, 1), (57, 1), (72, 2)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (12, 1), (13, 1), (14, 2), (18, 2), (19, 1), (63, 1), (72, 2)], [], [], [(0, 1), (5, 2), (57, 1), (72, 2), (114, 2), (131, 1)], [(0, 1), (5, 2), (72, 2), (74, 1)], [], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (63, 1), (72, 2)], [], [], [], [], [], [], []] + +def comb59 : List (List (Nat × Nat)) := [[], [(2, 2), (4, 1), (9, 2), (14, 1), (16, 2), (18, 2), (20, 1), (24, 1), (66, 1)], [(2, 2), (4, 1), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (18, 2), (20, 1), (24, 1), (57, 2), (66, 1), (114, 1)], [(2, 1), (4, 2), (6, 1), (9, 1), (12, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (66, 1), (172, 1)], [], [], [(1, 1), (2, 2), (4, 1), (6, 1), (7, 2), (9, 2), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (66, 1), (233, 1)], [(2, 2), (4, 1), (6, 1), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (18, 2), (20, 1), (57, 2), (66, 1), (233, 1)], [], [(2, 1), (4, 2), (6, 1), (9, 1), (12, 2), (15, 1), (18, 2), (20, 2), (57, 2), (66, 1), (233, 1)], [], [], [(6, 2), (12, 1), (14, 2), (15, 2), (16, 1), (18, 2), (24, 2), (57, 1), (66, 1), (77, 1), (233, 2)], [(2, 2), (4, 1), (6, 2), (9, 2), (12, 1), (15, 2), (18, 2), (20, 1), (24, 2), (57, 1), (63, 1), (66, 1), (233, 2)], [(2, 2), (4, 1), (6, 1), (8, 2), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (18, 2), (20, 1), (24, 1), (57, 2), (66, 1), (233, 1)], [], [(2, 1), (4, 2), (6, 2), (8, 2), (9, 1), (12, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (66, 1), (233, 1)], [], [(2, 1), (4, 2), (6, 2), (8, 2), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (18, 1), (20, 2), (24, 1), (57, 2), (66, 1), (233, 1)], [], [(2, 2), (4, 1), (6, 2), (9, 2), (12, 1), (15, 2), (18, 2), (20, 1), (24, 2), (57, 1), (66, 2), (233, 2)], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (7, 1), (8, 2), (9, 1), (12, 2), (14, 1), (16, 2), (18, 2), (20, 1), (24, 2), (57, 1), (66, 2), (233, 2)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (12, 2), (14, 1), (16, 2), (18, 2), (20, 1), (24, 2), (57, 1), (66, 2), (233, 2)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 2), (12, 1), (14, 2), (15, 1), (16, 1), (18, 2), (20, 1), (24, 2), (57, 1), (66, 2), (233, 2)], [], [], [(1, 2), (2, 2), (3, 2), (7, 1), (8, 1), (9, 1), (12, 2), (15, 2), (18, 2), (20, 1), (57, 2), (60, 1), (233, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 2), (8, 2), (12, 1), (14, 2), (16, 1), (18, 1), (20, 2), (57, 1), (66, 2), (233, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (15, 1), (18, 1), (20, 2), (57, 1), (66, 2), (233, 2)], [], [], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (7, 1), (8, 1), (12, 2), (14, 1), (15, 2), (18, 2), (20, 1), (57, 2), (66, 1), (233, 1)], [], [], [], [], [(1, 1), (2, 2), (3, 2), (4, 1), (6, 2), (7, 2), (8, 1), (9, 1), (12, 2), (15, 2), (18, 2), (20, 1), (24, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (15, 1), (18, 1), (20, 2), (24, 2), (58, 1), (66, 2)], [], [], [(1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 2), (15, 1), (18, 1), (20, 2), (24, 2), (57, 1), (66, 2), (114, 2), (115, 1)], [], [], [(1, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (8, 1), (12, 2), (15, 2), (18, 2), (20, 1), (24, 1), (60, 2), (66, 1), (236, 1)], [], [], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 1), (14, 2), (15, 2), (16, 1)], [], [(1, 1), (2, 2), (3, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (14, 2), (15, 2), (16, 1)], [], [(1, 1), (3, 1), (4, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (14, 2), (15, 2), (16, 1)], [(1, 2), (3, 2), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (12, 1), (15, 1)], [], [(1, 2), (3, 2), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (12, 1), (15, 1), (20, 2), (22, 1)], [], [(1, 2), (3, 2), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (14, 1), (15, 1), (16, 2), (65, 1), (66, 2)], [], [], [(1, 1), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (14, 2), (15, 2), (16, 1), (60, 2), (63, 2), (66, 1), (71, 1)], [], [], [(1, 1), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (12, 1), (14, 1), (15, 1), (16, 2), (57, 1), (60, 2), (63, 2), (66, 1), (114, 2), (127, 1)], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (7, 1), (8, 1), (12, 2), (14, 1), (16, 1), (18, 1), (20, 2), (24, 1), (44, 1), (57, 2), (66, 1), (233, 1)], [], [], [(0, 1), (1, 1), (3, 2), (4, 2), (6, 2), (7, 2), (8, 1), (9, 2), (12, 2), (14, 2), (16, 1), (18, 1), (20, 2), (24, 1), (57, 2), (58, 2), (66, 2), (233, 1), (392, 1)], [], [(1, 1), (2, 1), (3, 1), (6, 1), (7, 1), (9, 2), (12, 1), (15, 1), (18, 1), (20, 2), (24, 1), (57, 1), (66, 2), (233, 1), (274, 1)], [], [(2, 1), (4, 2), (6, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (18, 1), (20, 2), (57, 1), (66, 2), (233, 2)], [], [], [(0, 1), (5, 2), (6, 2), (8, 1), (12, 1), (14, 2), (15, 2), (16, 1), (57, 1), (58, 2), (233, 2), (293, 1)], [], [], [(2, 1), (4, 2), (6, 2), (8, 1), (9, 1), (12, 1), (14, 1), (15, 2), (16, 2), (18, 1), (20, 2), (24, 2), (57, 1), (66, 2)], [], [(2, 1), (4, 2), (6, 2), (9, 1), (12, 1), (13, 1), (14, 1), (15, 2), (16, 2), (18, 1), (20, 2), (24, 2)], [], [], [(3, 1), (4, 2), (9, 1), (12, 1), (14, 1), (15, 2), (16, 1), (57, 1), (66, 2), (114, 2), (130, 1)], [(3, 1), (4, 2), (9, 1), (14, 2), (66, 2), (73, 1)], [], [], [], [], [(1, 1), (4, 2), (7, 2), (11, 1), (12, 1), (14, 2), (15, 2), (16, 1)], [], [], [], [], [], [], []] + +def comb60 : List (List (Nat × Nat)) := [[], [(1, 2), (2, 1), (6, 2), (7, 1), (17, 2), (19, 2), (24, 1), (51, 1), (66, 2), (68, 1), (72, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 1), (7, 1), (8, 1), (9, 2), (12, 1), (17, 2), (19, 2), (24, 1), (51, 1), (57, 2), (68, 1), (114, 1)], [], [], [], [(1, 2), (2, 2), (7, 1), (12, 2), (17, 2), (19, 2), (51, 1), (58, 2), (66, 1), (68, 1), (72, 2), (114, 2), (115, 1), (233, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (12, 1), (17, 2), (19, 2), (51, 1), (57, 2), (68, 1), (233, 1)], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (12, 1), (17, 2), (19, 2), (51, 1), (57, 2), (66, 2), (68, 1), (72, 1), (233, 1)], [], [], [], [], [(0, 2), (1, 2), (3, 2), (6, 2), (7, 1), (8, 2), (9, 1), (12, 2), (17, 2), (19, 2), (24, 2), (51, 1), (57, 1), (63, 1), (66, 1), (68, 1), (72, 2), (233, 2)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 2), (7, 1), (9, 2), (12, 1), (17, 2), (19, 2), (24, 1), (51, 1), (57, 2), (68, 1), (233, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (9, 2), (12, 1), (16, 2), (17, 2), (19, 1), (20, 1), (24, 1), (51, 1), (57, 2), (66, 2), (68, 1), (72, 1), (233, 1)], [], [], [], [], [], [(0, 2), (1, 2), (3, 2), (6, 2), (7, 1), (8, 2), (9, 1), (12, 2), (17, 2), (19, 2), (24, 2), (51, 1), (57, 1), (66, 1), (68, 2), (72, 2), (233, 2)], [], [(1, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 2), (19, 2), (24, 2), (58, 1), (68, 2), (114, 1), (115, 2), (233, 2)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (6, 1), (7, 1), (9, 1), (12, 1), (19, 2), (24, 2), (57, 2), (58, 2), (66, 1), (68, 2), (72, 2), (114, 2), (115, 1), (233, 2)], [(1, 2), (2, 2), (3, 1), (4, 1), (6, 1), (7, 1), (9, 1), (12, 1), (19, 2), (24, 2), (57, 2), (58, 2), (66, 1), (68, 2), (72, 2), (114, 2), (115, 1), (233, 2)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (7, 1), (9, 2), (12, 2), (17, 1), (19, 2), (51, 2), (57, 1), (58, 2), (114, 1), (115, 2), (233, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (12, 1), (19, 1), (57, 2), (58, 2), (66, 1), (68, 2), (72, 2), (114, 2), (115, 1), (233, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (12, 1), (15, 1), (16, 2), (19, 1), (57, 2), (58, 2), (66, 1), (68, 2), (72, 2), (114, 2), (115, 1), (233, 2)], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 2), (12, 1), (17, 1), (19, 2), (21, 1), (51, 2), (57, 1), (58, 1), (66, 2), (68, 1), (72, 1), (114, 1), (115, 2), (233, 1)], [], [], [(1, 2), (3, 2), (4, 2), (6, 2), (7, 1), (9, 2), (17, 1), (19, 2), (24, 1), (51, 2), (57, 1), (58, 2), (66, 1), (72, 2), (114, 2), (115, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 2), (7, 1), (12, 2), (17, 1), (19, 2), (24, 1), (51, 2), (57, 1), (58, 2), (114, 2), (115, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (8, 2), (9, 1), (19, 1), (24, 2), (57, 2), (58, 1), (60, 1), (68, 2), (114, 1), (115, 2)], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 1), (6, 2), (7, 1), (8, 2), (9, 1), (12, 1), (19, 1), (24, 2), (57, 2), (58, 2), (66, 1), (68, 2), (72, 2), (114, 1), (115, 1), (117, 1)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (12, 2), (17, 1), (19, 2), (24, 1), (51, 2), (57, 1), (58, 2), (63, 2), (68, 1), (114, 2), (115, 1), (181, 1)], [], [], [(0, 2), (3, 2), (4, 2), (6, 2), (8, 1), (9, 2), (17, 1), (51, 2), (57, 1), (58, 2), (66, 1), (72, 2), (114, 2), (115, 1)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 1), (12, 2), (17, 1), (51, 2), (57, 1), (58, 2), (114, 2), (115, 1)], [(0, 1), (1, 2), (3, 1), (4, 2), (7, 1), (12, 1), (17, 1), (51, 2), (57, 2), (58, 1), (66, 2), (72, 1), (114, 1), (115, 2)], [(0, 1), (1, 2), (3, 1), (4, 2), (10, 1), (12, 1), (17, 1), (51, 2), (57, 2), (58, 1), (66, 2), (72, 1), (114, 1), (115, 2)], [(0, 2), (2, 2), (3, 1), (4, 1), (12, 1), (16, 1), (17, 1), (51, 2), (57, 2), (58, 1), (114, 1), (115, 2)], [(0, 1), (3, 1), (4, 1), (9, 1), (17, 2), (51, 2), (57, 2), (58, 1), (66, 2), (72, 1), (114, 1), (115, 2)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (12, 1), (17, 2), (51, 1), (57, 2), (58, 1), (66, 1), (68, 2), (114, 1), (115, 2)], [], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 1), (12, 2), (17, 1), (51, 2), (57, 1), (58, 1), (63, 2), (68, 1), (80, 1), (114, 2), (115, 1)], [], [], [(0, 1), (3, 1), (4, 1), (9, 1), (12, 1), (17, 1), (51, 2), (57, 2), (58, 1), (63, 2), (66, 2), (68, 1), (72, 1), (114, 1), (115, 1), (137, 1)], [], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (6, 1), (7, 2), (8, 1), (9, 2), (12, 2), (19, 1), (24, 1), (44, 1), (57, 1), (58, 1), (66, 2), (68, 1), (72, 1), (114, 1), (115, 2), (233, 1)], [], [], [], [(2, 1), (4, 2), (6, 1), (7, 2), (8, 1), (9, 1), (17, 2), (19, 1), (24, 1), (51, 1), (58, 1), (66, 2), (68, 2), (72, 1), (114, 1), (115, 2), (216, 1), (233, 1)], [(2, 1), (4, 2), (6, 1), (7, 2), (8, 1), (9, 1), (17, 2), (19, 1), (24, 1), (51, 1), (58, 1), (66, 2), (68, 2), (72, 1), (114, 1), (115, 2), (233, 1), (274, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (9, 1), (12, 2), (17, 1), (19, 1), (51, 2), (57, 1), (68, 2), (233, 2)], [], [], [], [(172, 1), (233, 2)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (9, 1), (12, 2), (17, 1), (19, 1), (24, 2), (51, 2), (57, 1), (68, 2)], [], [], [(18, 1), (24, 2)], [], [(2, 1), (3, 2), (6, 1), (8, 2), (9, 1), (12, 2), (57, 1), (68, 2), (114, 2), (130, 1)], [(0, 1), (2, 2), (66, 1), (68, 2), (72, 2), (73, 1)], [], [], [], [], [], [(6, 1), (8, 2)], [], [], [(0, 1), (2, 1), (3, 1), (9, 2), (12, 1), (66, 1), (72, 2)], [], [], []] + +def comb61 : List (List (Nat × Nat)) := [[(0, 2), (2, 1), (3, 2), (9, 1), (13, 1)], [], [], [(4, 2), (8, 2), (9, 1), (13, 1), (15, 1), (18, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (172, 1)], [(4, 2), (8, 2), (9, 1), (13, 1), (15, 1), (18, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (233, 1)], [(0, 2), (2, 1), (4, 2), (9, 1), (15, 1), (34, 2), (293, 1)], [], [], [], [(3, 1), (4, 1), (8, 2), (9, 1), (15, 2), (34, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (293, 1)], [(3, 1), (4, 1), (8, 2), (9, 1), (15, 2), (18, 2), (24, 1), (34, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (293, 1)], [], [], [(0, 2), (2, 1), (4, 2), (8, 2), (9, 1), (13, 1), (15, 1), (34, 2), (57, 2), (63, 1), (293, 1)], [(0, 1), (2, 2), (4, 2), (8, 1), (9, 1), (13, 2), (15, 1), (18, 1), (34, 1), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (77, 2), (293, 2)], [(0, 1), (2, 2), (4, 2), (8, 1), (9, 1), (13, 2), (15, 1), (20, 1), (34, 1), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (77, 2), (293, 2)], [], [], [], [], [], [(4, 2), (8, 2), (9, 1), (13, 1), (15, 1), (18, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (293, 1)], [(3, 1), (4, 2), (13, 2), (18, 2), (34, 2), (60, 1), (65, 1), (68, 2), (77, 1), (293, 2)], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (8, 2), (13, 2), (15, 1), (18, 2), (34, 2), (57, 2), (60, 2), (63, 1), (64, 2), (77, 1), (293, 2)], [(2, 2), (3, 2), (5, 1), (8, 2), (9, 1), (13, 2), (15, 1), (18, 2), (34, 2), (57, 2), (60, 2), (63, 1), (64, 2), (77, 1), (293, 2)], [], [], [(3, 1), (4, 2), (8, 2), (18, 2), (34, 2), (57, 2), (58, 1), (60, 1), (63, 1), (64, 2), (65, 1), (68, 2), (77, 1), (293, 2)], [(1, 1), (3, 2), (4, 2), (8, 1), (9, 2), (15, 2), (18, 1), (34, 1), (57, 1), (60, 1), (63, 2), (64, 1), (77, 2), (293, 1)], [], [], [(3, 2), (4, 2), (8, 1), (9, 2), (18, 1), (34, 1), (57, 1), (60, 1), (63, 2), (64, 1), (77, 2), (293, 1)], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 1), (8, 2), (18, 1), (21, 1), (57, 2), (60, 2), (63, 1), (64, 2), (77, 1), (293, 2)], [], [], [(0, 1), (3, 2), (4, 1), (8, 2), (13, 2), (15, 1), (18, 2), (34, 1), (57, 2), (60, 1), (63, 1), (64, 2), (65, 1), (68, 2), (77, 1)], [(3, 2), (4, 1), (8, 2), (9, 1), (13, 2), (15, 1), (18, 2), (34, 1), (57, 2), (60, 1), (63, 1), (64, 2), (65, 1), (68, 2), (77, 1)], [(3, 1), (8, 1), (9, 2), (13, 1), (15, 1), (18, 1), (34, 2), (57, 1), (60, 2), (63, 2), (64, 1), (77, 2)], [], [], [(3, 1), (8, 1), (9, 2), (13, 1), (15, 1), (18, 1), (34, 2), (57, 1), (60, 1), (63, 2), (64, 1), (77, 2), (117, 1)], [], [], [], [], [(0, 1), (2, 2), (3, 2), (8, 2), (9, 1), (13, 2), (15, 1), (18, 2), (34, 2), (57, 2), (60, 2), (63, 1), (64, 1), (77, 1), (172, 2), (181, 1)], [(0, 1), (2, 2), (3, 2), (4, 2), (8, 1), (9, 2), (15, 2), (18, 1), (34, 2), (57, 1), (60, 2), (63, 2), (64, 1), (65, 2), (68, 1), (77, 2)], [(3, 2), (4, 2), (8, 1), (9, 2), (15, 2), (18, 1), (34, 2), (57, 1), (60, 2), (63, 2), (64, 1), (65, 2), (68, 1), (77, 2)], [], [], [], [], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (8, 2), (18, 1), (22, 1), (34, 2), (57, 2), (60, 1), (63, 1), (64, 2), (65, 1), (68, 2), (77, 1)], [], [(0, 2), (2, 1), (3, 1), (8, 2), (9, 2), (15, 1), (18, 2), (34, 1), (57, 2), (60, 1), (63, 1), (64, 2), (65, 1), (77, 1)], [(2, 1), (3, 1), (4, 1), (5, 2), (8, 2), (9, 1), (15, 1), (18, 2), (34, 1), (57, 2), (60, 1), (63, 1), (64, 2), (67, 1), (77, 1)], [(0, 2), (2, 1), (8, 2), (15, 1), (18, 1), (34, 2), (57, 2), (60, 1), (63, 1), (64, 1), (71, 1), (73, 1), (74, 2), (77, 2)], [(2, 1), (4, 1), (5, 2), (8, 2), (9, 2), (15, 1), (18, 1), (34, 2), (57, 2), (60, 1), (63, 1), (64, 1), (71, 1), (77, 2)], [], [(3, 1), (6, 2), (9, 2), (15, 1), (18, 1), (34, 2), (57, 2), (60, 1), (63, 1), (64, 1), (77, 2), (127, 1), (130, 1), (131, 2)], [(0, 1), (3, 1), (4, 1), (5, 2), (6, 2), (9, 1), (15, 1), (18, 1), (34, 2), (57, 2), (60, 1), (63, 1), (64, 1), (77, 2), (127, 1)], [], [], [], [], [(3, 2), (4, 1), (13, 1), (18, 1), (34, 1), (60, 2), (65, 2), (68, 1), (77, 2), (99, 1), (293, 1)], [(3, 2), (4, 1), (6, 2), (8, 1), (13, 1), (18, 1), (34, 1), (60, 2), (65, 2), (68, 1), (77, 2), (157, 1), (293, 1)], [(3, 2), (4, 1), (6, 2), (8, 1), (13, 1), (18, 1), (34, 1), (60, 2), (65, 2), (68, 1), (77, 2), (293, 1), (392, 1)], [], [], [], [], [(3, 2), (4, 1), (15, 2), (34, 1), (57, 1), (293, 2)], [(0, 1), (2, 2), (4, 1), (6, 2), (8, 1), (9, 2), (15, 2), (34, 1), (114, 1), (293, 2)], [], [], [], [], [(0, 1), (2, 2), (3, 1), (8, 1), (9, 2), (13, 2)], [], [], [], [(0, 2), (2, 1), (6, 1), (8, 2), (18, 1), (34, 2), (64, 1), (65, 1), (68, 2), (77, 2), (127, 2), (131, 1)], [(3, 1), (9, 2), (18, 1), (34, 2), (64, 1), (65, 1), (68, 2), (71, 2), (74, 1), (77, 2)], [], [], [], [], [], [(6, 1), (8, 2)], [], [], [(0, 1), (2, 2), (3, 1), (9, 2)], [], [], []] + +def comb62 : List (List (Nat × Nat)) := [[(0, 1), (1, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (18, 1), (19, 2)], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (18, 1), (19, 1), (57, 2), (63, 1), (67, 1), (121, 2), (233, 1)], [(0, 1), (1, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (19, 2), (172, 1)], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (6, 1), (7, 1), (8, 1), (9, 1), (12, 1), (19, 2), (57, 2), (63, 1), (67, 1), (121, 2), (172, 1)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (19, 1), (24, 1), (57, 2), (63, 1), (67, 1), (121, 2), (172, 1)], [], [(1, 1), (2, 2), (3, 1), (4, 1), (6, 1), (7, 2), (8, 1), (9, 1), (18, 1), (19, 1), (57, 2), (63, 1), (64, 2), (77, 1), (172, 1)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (18, 1), (19, 1), (57, 2), (63, 1), (172, 1)], [(0, 2), (2, 1), (3, 2), (8, 1), (9, 1), (18, 2), (57, 1), (63, 2), (67, 2), (121, 1), (172, 2)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (18, 2), (19, 2), (57, 1), (63, 2), (67, 2), (121, 1), (172, 2)], [], [(0, 1), (1, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 2), (18, 2), (19, 2), (57, 1), (63, 2), (67, 2), (121, 1), (172, 2)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (18, 1), (19, 1), (57, 2), (63, 1), (67, 1), (121, 2), (172, 1)], [], [(0, 1), (1, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 2), (12, 1), (18, 2), (19, 2), (58, 1), (64, 1), (66, 1), (67, 1), (72, 2), (121, 2), (172, 2)], [], [], [(0, 2), (1, 2), (2, 2), (4, 1), (7, 1), (8, 2), (9, 2), (12, 2), (18, 2), (19, 2), (57, 2), (58, 2), (63, 1), (66, 2), (67, 1), (72, 1), (121, 2), (172, 2)], [], [(0, 2), (1, 2), (2, 1), (4, 1), (5, 1), (7, 1), (8, 2), (9, 2), (12, 2), (18, 2), (19, 2), (57, 2), (58, 2), (63, 1), (66, 2), (67, 1), (72, 1), (121, 2), (172, 2)], [], [(1, 1), (2, 2), (4, 1), (7, 2), (8, 2), (9, 2), (12, 1), (19, 1), (57, 2), (58, 1), (60, 1), (63, 1), (66, 1), (67, 1), (72, 2), (121, 2), (172, 2)], [], [(0, 2), (2, 2), (6, 1), (7, 1), (12, 1), (19, 2), (57, 1), (58, 1), (63, 2), (66, 1), (67, 2), (72, 2), (121, 1), (172, 1)], [(1, 2), (2, 2), (4, 1), (6, 1), (7, 1), (9, 2), (12, 1), (19, 2), (57, 1), (58, 1), (63, 2), (66, 1), (67, 2), (72, 2), (121, 1), (172, 1)], [], [], [], [], [(1, 1), (2, 2), (3, 2), (4, 2), (7, 2), (8, 2), (9, 1), (12, 1), (14, 1), (19, 1), (57, 2), (58, 2), (63, 1), (66, 2), (67, 1), (72, 1), (121, 2), (172, 2)], [], [], [], [], [(1, 1), (2, 2), (4, 2), (7, 2), (8, 2), (9, 2), (12, 1), (18, 2), (19, 1), (57, 2), (58, 1), (63, 1), (66, 1), (67, 1), (72, 2), (121, 2)], [], [(0, 2), (1, 2), (2, 2), (4, 1), (6, 1), (7, 1), (9, 2), (12, 1), (18, 1), (19, 2), (57, 1), (58, 2), (63, 2), (66, 1), (67, 2), (72, 2), (121, 1)], [], [], [(1, 2), (2, 1), (3, 1), (4, 1), (7, 1), (8, 1), (9, 1), (12, 1), (18, 1), (19, 2), (57, 1), (58, 1), (63, 2), (66, 1), (67, 2), (72, 2), (115, 1), (121, 1)], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (7, 1), (8, 2), (9, 2), (12, 2), (18, 2), (19, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 2), (67, 1), (72, 1), (121, 2), (233, 2), (236, 1)], [], [(0, 2), (2, 1), (6, 1), (12, 2), (57, 1), (58, 2), (63, 2), (66, 2), (67, 2), (72, 1), (121, 1)], [], [(0, 2), (2, 1), (4, 1), (6, 1), (9, 2), (12, 2), (57, 1), (58, 2), (63, 2), (66, 2), (67, 2), (72, 1), (121, 1)], [], [(1, 2), (3, 1), (4, 1), (7, 1), (8, 1), (9, 1), (12, 2), (57, 1), (58, 2), (63, 2), (66, 2), (67, 2), (72, 1), (121, 1)], [], [], [(0, 1), (3, 2), (5, 2), (8, 2), (9, 1), (17, 1), (57, 2), (58, 1), (63, 1), (66, 1), (67, 1), (72, 2), (121, 2)], [], [(0, 1), (2, 2), (3, 2), (6, 2), (9, 1), (12, 1), (57, 2), (58, 1), (63, 1), (66, 2), (67, 1), (72, 2), (121, 2)], [], [(0, 1), (3, 2), (5, 2), (6, 2), (9, 1), (12, 1), (57, 2), (58, 1), (63, 1), (66, 1), (67, 2), (72, 2), (121, 2)], [(0, 1), (2, 1), (3, 1), (5, 1), (6, 1), (12, 2), (14, 2), (57, 1), (58, 2), (63, 2), (66, 1), (67, 2), (72, 2), (73, 1), (74, 2), (121, 1)], [], [(0, 1), (3, 2), (5, 2), (6, 2), (9, 1), (12, 1), (57, 2), (58, 1), (63, 1), (66, 1), (67, 2), (72, 2), (80, 1), (121, 1)], [(0, 2), (3, 2), (5, 1), (8, 1), (9, 2), (12, 2), (14, 2), (57, 1), (58, 1), (63, 2), (66, 1), (67, 2), (72, 2), (115, 1), (121, 1), (130, 1), (131, 2)], [], [(0, 2), (1, 2), (2, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 1), (11, 2), (12, 1), (57, 2), (58, 1), (63, 1), (66, 1), (67, 2), (72, 2), (121, 1), (137, 1)], [], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (12, 2), (18, 1), (19, 1), (58, 2), (64, 2), (66, 2), (67, 2), (72, 1), (99, 1), (121, 1), (172, 1)], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (14, 2), (18, 1), (19, 1), (58, 2), (64, 2), (66, 2), (67, 2), (72, 1), (121, 1), (157, 1), (172, 1)], [], [(2, 2), (3, 2), (6, 1), (7, 2), (8, 2), (9, 2), (14, 2), (18, 1), (19, 1), (58, 2), (64, 2), (66, 2), (67, 2), (72, 1), (121, 1), (172, 1), (216, 1)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 2), (19, 1), (57, 1), (172, 2)], [(0, 2), (1, 1), (4, 2), (7, 2), (9, 1), (19, 1), (114, 1), (172, 2)], [], [], [], [], [(0, 2), (1, 1), (4, 2), (6, 1), (7, 2), (9, 1), (18, 2), (19, 1)], [], [], [], [(0, 2), (2, 2), (3, 1), (5, 2), (6, 2), (8, 2), (9, 2), (12, 2), (57, 1), (63, 2), (67, 2), (115, 2), (121, 1), (131, 1)], [(2, 1), (3, 2), (5, 2), (6, 1), (9, 1), (12, 2), (57, 1), (58, 2), (63, 2), (67, 2), (74, 1), (121, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1)], [], [], [], [], [], [], []] + +def comb63 : List (List (Nat × Nat)) := [[(3, 2), (4, 1), (6, 1), (8, 2), (13, 1), (15, 2), (18, 2), (20, 1), (24, 1)], [], [], [(3, 1), (4, 2), (6, 1), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (63, 1), (172, 1)], [], [(3, 2), (4, 1), (6, 1), (8, 2), (13, 1), (15, 2), (18, 2), (20, 1), (233, 1)], [], [], [(3, 2), (4, 1), (6, 1), (8, 1), (13, 2), (15, 2), (18, 2), (20, 1), (57, 2), (63, 1), (233, 1)], [(3, 1), (4, 2), (6, 1), (8, 1), (13, 2), (15, 1), (18, 2), (20, 2), (57, 2), (63, 1), (233, 1)], [], [], [(0, 1), (3, 2), (4, 1), (6, 1), (8, 1), (12, 2), (13, 2), (15, 2), (18, 1), (20, 1), (24, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (233, 1)], [], [(6, 1), (24, 2), (57, 1), (63, 2), (233, 2)], [], [], [(3, 2), (4, 1), (6, 1), (13, 1), (15, 2), (18, 2), (20, 1), (24, 2), (57, 1), (63, 2), (233, 2)], [], [(3, 1), (4, 2), (6, 1), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (24, 1), (57, 2), (63, 1), (233, 1)], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 2), (8, 1), (9, 1), (13, 1), (15, 1), (18, 2), (20, 2), (24, 2), (57, 1), (64, 1), (65, 2), (68, 1), (73, 1), (75, 2), (233, 2)], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 2), (9, 2), (13, 1), (18, 2), (24, 2), (57, 1), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (233, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (9, 2), (13, 1), (18, 2), (24, 2), (57, 1), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (233, 2)], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (9, 1), (13, 2), (18, 1), (60, 1), (63, 1), (65, 1), (68, 2), (73, 1), (75, 2), (233, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (9, 1), (13, 2), (18, 1), (58, 1), (63, 1), (65, 1), (68, 2), (73, 1), (75, 2), (233, 2)], [(0, 2), (1, 1), (2, 1), (8, 1), (9, 1), (13, 1), (15, 1), (18, 2), (20, 2), (57, 2), (63, 2), (65, 1), (68, 2), (73, 1), (75, 2), (233, 1)], [], [(0, 2), (2, 1), (4, 1), (8, 1), (9, 1), (13, 1), (15, 1), (18, 2), (20, 2), (57, 2), (63, 2), (65, 1), (68, 2), (73, 1), (75, 2), (233, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (9, 2), (13, 1), (15, 1), (18, 2), (20, 2), (57, 2), (63, 2), (65, 1), (68, 2), (73, 1), (75, 2), (233, 1)], [(0, 1), (2, 1), (3, 1), (4, 2), (6, 2), (9, 2), (12, 1), (13, 1), (15, 2), (18, 1), (20, 1), (57, 1), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (233, 2)], [], [], [], [], [(0, 2), (2, 2), (3, 1), (4, 2), (6, 2), (9, 1), (13, 2), (18, 1), (24, 2), (63, 1), (65, 1), (68, 2), (73, 1), (75, 2)], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (8, 1), (9, 1), (13, 1), (18, 2), (24, 1), (63, 2), (65, 1), (68, 2), (73, 2), (75, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 1), (6, 1), (9, 2), (13, 1), (18, 2), (24, 1), (63, 2), (64, 2), (65, 1), (68, 2), (73, 2), (75, 1), (120, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (9, 2), (13, 1), (18, 2), (24, 2), (57, 1), (60, 2), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (172, 2), (174, 1)], [], [], [(0, 2), (2, 1), (8, 1), (9, 2), (15, 1), (20, 2), (63, 2), (65, 2), (68, 1), (73, 2), (75, 1)], [], [], [(0, 1), (2, 1), (5, 1), (8, 1), (9, 2), (15, 1), (20, 2), (63, 2), (65, 2), (68, 1), (73, 2), (75, 1)], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (9, 2), (10, 1), (15, 1), (20, 2), (63, 2), (65, 2), (68, 1), (73, 2), (75, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (9, 1), (13, 2), (20, 1), (63, 1), (65, 1), (68, 2), (73, 1), (75, 2)], [], [], [(0, 2), (2, 1), (8, 2), (9, 1), (15, 2), (20, 1), (63, 1), (65, 2), (66, 1), (68, 1), (73, 1), (75, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (8, 2), (9, 1), (15, 2), (20, 1), (63, 1), (65, 2), (68, 2), (73, 1), (75, 2)], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (8, 2), (9, 2), (13, 2), (15, 1), (20, 2), (57, 1), (60, 2), (63, 1), (65, 2), (68, 1), (71, 1), (73, 2), (75, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (8, 2), (9, 2), (13, 2), (15, 2), (20, 1), (57, 1), (58, 2), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (80, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (8, 2), (9, 2), (13, 2), (15, 1), (20, 2), (57, 1), (60, 2), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (127, 1)], [(0, 1), (2, 2), (6, 1), (8, 1), (11, 2), (13, 2), (15, 2), (20, 1), (57, 1), (58, 2), (63, 1), (65, 2), (68, 1), (73, 2), (75, 1), (137, 1)], [], [], [], [(2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 1), (12, 2), (15, 2), (18, 1), (20, 1), (24, 1), (57, 2), (64, 2), (65, 1), (68, 2), (73, 2), (75, 1), (99, 1), (233, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 2), (13, 2), (15, 2), (18, 1), (20, 1), (24, 1), (57, 2), (64, 2), (65, 1), (68, 2), (73, 2), (75, 1), (157, 1), (233, 1)], [], [], [(0, 2), (1, 2), (2, 2), (6, 2), (8, 1), (9, 2), (12, 2), (15, 2), (18, 1), (20, 1), (24, 1), (57, 2), (64, 2), (65, 1), (68, 2), (73, 2), (75, 1), (233, 1), (274, 1)], [], [], [(3, 1), (4, 2), (6, 2), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (233, 2)], [(3, 1), (4, 2), (6, 2), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (114, 1), (233, 2)], [], [], [], [], [(3, 1), (4, 2), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (24, 2)], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 2), (6, 2), (8, 2), (9, 2), (13, 2), (15, 1), (20, 2), (63, 2), (64, 1), (73, 2), (75, 1), (120, 2), (130, 1)], [(3, 1), (4, 2), (8, 1), (13, 2), (15, 1), (20, 2), (63, 2), (75, 1)], [], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (11, 1)], [], [], [], [], [], [], []] + +def comb64 : List (List (Nat × Nat)) := [[(1, 2), (4, 1), (15, 1), (16, 2), (18, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 2), (5, 2), (6, 2), (15, 1), (16, 2), (18, 1), (60, 2), (67, 1), (114, 1)], [], [(1, 1), (2, 1), (3, 2), (5, 2), (8, 2), (15, 2), (16, 1), (18, 1), (60, 2), (67, 1), (233, 1)], [(1, 2), (4, 1), (15, 1), (16, 2), (172, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 2), (5, 2), (15, 1), (16, 2), (60, 2), (67, 1), (172, 1)], [], [], [(1, 1), (2, 1), (3, 2), (5, 2), (8, 2), (15, 2), (16, 1), (24, 1), (60, 2), (67, 1), (172, 1)], [(1, 2), (4, 1), (15, 1), (16, 2), (57, 2), (75, 1), (172, 1)], [], [(1, 1), (4, 2), (8, 2), (15, 2), (16, 1), (18, 1), (57, 2), (63, 1), (172, 1)], [], [(2, 1), (3, 2), (4, 2), (5, 1), (8, 1), (16, 2), (18, 2), (20, 1), (60, 1), (67, 2), (172, 2)], [(1, 2), (2, 2), (3, 1), (5, 1), (6, 1), (15, 1), (16, 2), (18, 2), (60, 1), (67, 2), (172, 2)], [], [], [(1, 2), (2, 2), (3, 1), (5, 1), (8, 1), (15, 1), (16, 2), (18, 2), (60, 1), (67, 2), (172, 2)], [], [], [(1, 2), (2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (8, 1), (9, 1), (12, 1), (15, 1), (16, 2), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (66, 1), (67, 1), (72, 2), (172, 2)], [], [(0, 1), (1, 2), (3, 1), (4, 2), (5, 2), (6, 1), (8, 1), (9, 1), (12, 2), (15, 1), (16, 2), (18, 2), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (172, 2)], [], [], [(1, 2), (3, 1), (4, 2), (6, 1), (8, 1), (9, 1), (12, 2), (15, 1), (16, 2), (18, 2), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (172, 2)], [], [], [], [], [(1, 2), (3, 2), (5, 1), (6, 2), (8, 2), (9, 2), (12, 1), (15, 1), (16, 2), (58, 1), (60, 1), (66, 1), (67, 2), (72, 2), (172, 1)], [], [], [(1, 1), (2, 1), (5, 2), (6, 1), (9, 2), (12, 2), (15, 2), (16, 1), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (172, 2)], [(1, 2), (2, 2), (3, 2), (5, 1), (6, 1), (9, 2), (12, 2), (15, 1), (16, 2), (58, 1), (60, 1), (66, 1), (67, 2), (72, 2), (172, 1)], [], [], [], [(1, 2), (2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (9, 2), (12, 1), (15, 2), (16, 1), (18, 2), (58, 1), (60, 2), (66, 1), (67, 1), (72, 2)], [], [(1, 1), (2, 1), (3, 1), (5, 2), (6, 2), (9, 2), (12, 1), (15, 2), (16, 1), (18, 2), (58, 1), (60, 2), (66, 1), (67, 1), (72, 2)], [(1, 2), (2, 2), (4, 2), (5, 1), (6, 2), (8, 2), (9, 2), (12, 1), (15, 1), (16, 2), (18, 1), (58, 1), (60, 2), (66, 1), (67, 2), (72, 2)], [(0, 2), (1, 2), (3, 2), (5, 1), (6, 2), (8, 2), (9, 2), (12, 1), (15, 1), (16, 2), (18, 1), (58, 2), (60, 1), (66, 1), (67, 2), (72, 2)], [], [], [], [(1, 1), (2, 1), (5, 2), (6, 2), (9, 2), (12, 2), (15, 2), (16, 1), (18, 2), (58, 2), (60, 2), (64, 2), (66, 2), (67, 1), (72, 1), (114, 2), (120, 1)], [(1, 1), (3, 2), (5, 1), (6, 2), (8, 2), (9, 2), (12, 1), (15, 2), (16, 2), (18, 1), (20, 2), (58, 1), (60, 1), (66, 1), (67, 2), (72, 2), (174, 1)], [], [], [], [(2, 2), (4, 2), (5, 1), (6, 1), (9, 1), (12, 2), (58, 2), (60, 1), (66, 2), (67, 2), (72, 1)], [(2, 2), (3, 2), (5, 1), (6, 1), (9, 1), (12, 2), (58, 2), (60, 1), (66, 2), (67, 2), (72, 1)], [], [], [(2, 2), (4, 1), (5, 1), (6, 2), (8, 2), (9, 2), (10, 1), (12, 1), (58, 1), (60, 2), (66, 1), (67, 1), (72, 2)], [(1, 2), (2, 2), (3, 2), (5, 1), (6, 1), (9, 1), (12, 2), (15, 1), (58, 2), (60, 1), (66, 2), (67, 2), (72, 1)], [], [], [(2, 1), (3, 1), (4, 1), (5, 2), (6, 2), (9, 1), (12, 1), (58, 1), (60, 2), (66, 2), (67, 1), (72, 2)], [(2, 1), (4, 2), (5, 2), (6, 1), (9, 1), (12, 2), (58, 2), (60, 1), (65, 1), (66, 2), (67, 1), (72, 1)], [], [], [(3, 2), (4, 2), (6, 2), (9, 2), (12, 1), (57, 1), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (71, 1), (72, 2)], [(3, 2), (4, 2), (6, 2), (9, 2), (12, 1), (57, 1), (58, 1), (60, 1), (63, 2), (66, 1), (67, 2), (72, 2), (80, 1)], [(2, 1), (4, 2), (5, 2), (8, 1), (9, 1), (12, 2), (58, 1), (60, 1), (64, 1), (66, 1), (67, 2), (72, 2), (114, 1), (120, 2), (130, 1), (131, 2)], [], [], [], [], [], [(1, 1), (2, 2), (4, 1), (5, 1), (6, 2), (8, 2), (9, 1), (12, 1), (15, 2), (16, 1), (18, 1), (57, 2), (58, 2), (60, 1), (63, 1), (64, 2), (66, 2), (67, 2), (72, 1), (99, 1), (172, 1)], [], [(0, 1), (1, 1), (2, 1), (4, 1), (5, 1), (9, 1), (12, 2), (15, 2), (16, 1), (18, 1), (57, 2), (58, 1), (60, 1), (63, 1), (66, 2), (67, 2), (72, 1), (114, 1), (120, 2), (172, 1), (392, 1)], [(2, 2), (3, 2), (4, 2), (5, 1), (6, 1), (8, 2), (9, 2), (12, 2), (18, 1), (57, 2), (58, 2), (60, 1), (63, 1), (64, 2), (66, 2), (67, 2), (72, 1), (172, 1), (216, 1)], [], [], [], [(1, 1), (4, 2), (15, 2), (16, 1), (57, 1), (172, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (15, 2), (16, 1), (58, 2), (64, 1), (114, 1), (120, 2), (172, 2), (293, 1)], [], [], [], [], [(1, 1), (4, 2), (13, 1), (15, 2), (16, 1), (18, 2)], [], [], [(3, 1), (4, 2), (6, 2), (8, 2), (12, 2), (60, 1), (67, 2), (114, 2), (131, 1)], [], [(3, 1), (4, 2), (6, 1), (12, 2), (58, 2), (60, 1), (65, 2), (66, 2), (68, 1), (72, 1)], [], [], [(1, 1), (4, 2), (15, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb65 : List (List (Nat × Nat)) := [[(3, 2), (4, 1), (6, 1), (8, 2), (14, 1), (16, 2), (24, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (18, 1), (19, 2), (24, 1), (57, 2), (63, 1), (172, 1)], [], [(3, 2), (4, 1), (6, 1), (8, 2), (14, 1), (16, 2), (233, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (14, 2), (16, 1), (18, 1), (19, 2), (57, 2), (63, 1), (233, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (18, 2), (19, 2), (57, 2), (63, 1), (233, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (14, 2), (16, 1), (19, 2), (24, 1), (57, 2), (75, 1), (233, 1)], [], [], [], [(0, 2), (2, 1), (6, 1), (7, 2), (8, 1), (14, 2), (16, 1), (18, 1), (19, 1), (20, 1), (24, 2), (57, 1), (63, 2), (233, 2)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (18, 2), (19, 1), (24, 2), (57, 1), (63, 2), (233, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (14, 1), (16, 2), (18, 2), (19, 1), (24, 1), (57, 2), (63, 1), (233, 1)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (18, 2), (19, 1), (24, 2), (57, 1), (63, 2), (233, 2)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 2), (8, 1), (14, 2), (16, 1), (18, 1), (24, 2), (60, 1), (64, 2), (66, 1), (72, 2), (77, 2), (233, 2)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (18, 2), (24, 2), (57, 2), (60, 2), (63, 1), (64, 2), (66, 1), (72, 2), (77, 1), (233, 2)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (14, 1), (16, 2), (19, 2), (24, 2), (57, 2), (60, 2), (63, 1), (64, 2), (66, 1), (72, 2), (77, 1), (233, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (14, 1), (16, 2), (18, 2), (19, 2), (57, 2), (58, 1), (60, 1), (63, 1), (64, 1), (66, 2), (72, 1), (77, 2), (233, 2)], [], [], [(0, 1), (2, 2), (4, 1), (7, 2), (8, 2), (14, 1), (16, 2), (19, 1), (57, 1), (60, 1), (63, 2), (64, 1), (66, 2), (72, 1), (77, 2), (233, 1)], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (14, 2), (16, 2), (19, 1), (57, 1), (60, 1), (63, 2), (64, 1), (66, 2), (72, 1), (77, 2), (233, 1)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (18, 1), (24, 2), (57, 2), (60, 1), (63, 1), (64, 1), (66, 2), (72, 1), (77, 2)], [(2, 1), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (14, 1), (16, 2), (18, 2), (19, 2), (24, 2), (57, 2), (60, 1), (63, 1), (64, 1), (66, 2), (72, 1), (77, 2)], [], [(0, 1), (2, 2), (7, 2), (8, 2), (14, 1), (16, 2), (19, 1), (24, 1), (57, 1), (60, 2), (63, 2), (64, 1), (66, 2), (72, 1), (77, 2)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 2), (8, 1), (14, 2), (16, 1), (18, 1), (19, 1), (24, 1), (57, 1), (60, 2), (63, 2), (64, 2), (66, 2), (72, 1), (77, 1)], [], [(3, 1), (4, 2), (7, 1), (8, 1), (14, 2), (16, 1), (19, 2), (24, 2), (57, 2), (58, 2), (60, 2), (63, 1), (64, 2), (66, 1), (72, 2), (77, 1), (114, 2), (115, 1)], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 1), (14, 2), (16, 1), (18, 1), (19, 1), (20, 2), (24, 1), (57, 1), (60, 1), (63, 2), (64, 1), (66, 2), (72, 1), (77, 2), (236, 1)], [], [], [(7, 2), (8, 2), (14, 1), (16, 2), (18, 1), (19, 1), (57, 1), (60, 2), (63, 2), (64, 2), (66, 1), (72, 2), (77, 1)], [], [(2, 2), (5, 1), (7, 2), (8, 2), (14, 1), (16, 2), (18, 1), (19, 1), (57, 1), (60, 2), (63, 2), (64, 2), (66, 1), (72, 2), (77, 1)], [(3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (14, 2), (16, 1), (18, 2), (19, 2), (57, 2), (60, 1), (63, 1), (64, 1), (66, 2), (72, 1), (77, 2)], [], [], [(2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (14, 2), (16, 1), (17, 1), (18, 1), (19, 1), (57, 1), (60, 2), (63, 2), (64, 2), (66, 1), (72, 2), (77, 1)], [], [(0, 2), (2, 1), (7, 1), (8, 1), (14, 2), (16, 1), (18, 2), (19, 2), (57, 2), (60, 1), (63, 1), (64, 1), (66, 2), (72, 2), (77, 2)], [], [(0, 2), (2, 1), (3, 2), (4, 1), (7, 1), (19, 2), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 1), (72, 2), (77, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 1), (8, 2), (14, 1), (16, 1), (18, 2), (19, 2), (57, 2), (60, 1), (63, 1), (64, 1), (66, 1), (72, 2), (73, 1), (77, 2)], [], [(3, 1), (4, 2), (7, 1), (8, 1), (14, 2), (16, 1), (18, 2), (19, 2), (57, 2), (58, 2), (60, 2), (63, 1), (64, 2), (66, 1), (72, 2), (77, 1), (80, 1)], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (14, 1), (16, 2), (18, 1), (19, 1), (57, 2), (60, 2), (63, 1), (64, 2), (66, 1), (72, 2), (77, 1), (114, 2), (127, 1)], [], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (14, 1), (16, 2), (18, 2), (24, 1), (60, 2), (64, 1), (66, 2), (72, 1), (77, 1), (99, 1), (233, 1)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (14, 1), (16, 2), (18, 2), (24, 1), (60, 2), (64, 1), (66, 2), (72, 1), (77, 1), (233, 1), (392, 1)], [], [(0, 2), (2, 1), (6, 2), (8, 1), (14, 2), (16, 1), (18, 2), (24, 1), (60, 2), (64, 1), (66, 2), (72, 1), (77, 1), (233, 1), (274, 1)], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (14, 1), (16, 2), (18, 2), (19, 1), (57, 1), (233, 2)], [], [(2, 1), (5, 2), (7, 2), (8, 1), (14, 2), (16, 1), (233, 2), (293, 1)], [], [], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 1), (13, 1), (14, 1), (16, 2), (18, 2), (19, 1), (24, 2)], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (14, 1), (16, 1), (18, 2), (19, 1), (57, 1), (63, 2), (114, 2), (130, 1)], [], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (14, 1), (16, 2), (18, 1), (19, 1), (57, 1), (60, 2), (63, 2), (64, 2), (68, 1), (77, 1)], [], [], [(3, 1), (4, 2), (6, 2), (8, 1), (14, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb66 : List (List (Nat × Nat)) := [[(6, 2), (11, 1), (12, 1), (16, 2), (24, 1)], [], [(6, 2), (8, 2), (11, 1), (13, 1), (16, 2), (24, 1), (57, 2), (63, 1), (114, 1)], [], [], [(6, 2), (11, 1), (12, 1), (16, 2), (233, 1)], [], [(8, 2), (11, 1), (13, 1), (16, 2), (57, 2), (63, 1), (233, 1)], [(6, 2), (8, 2), (11, 1), (12, 1), (13, 1), (16, 2), (57, 2), (63, 1), (233, 1)], [], [], [(8, 2), (11, 1), (13, 1), (16, 2), (18, 2), (24, 1), (57, 2), (75, 1), (233, 1)], [(1, 2), (8, 2), (11, 1), (13, 1), (15, 1), (16, 1), (24, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (233, 1)], [], [], [], [(6, 2), (8, 1), (11, 1), (12, 2), (13, 2), (16, 2), (24, 2), (57, 1), (63, 2), (233, 2)], [(6, 1), (8, 2), (11, 1), (12, 2), (13, 2), (16, 2), (24, 2), (57, 1), (63, 2), (233, 2)], [], [], [], [(6, 1), (8, 1), (11, 2), (12, 2), (13, 2), (16, 2), (24, 2), (57, 1), (63, 2), (233, 2)], [(1, 2), (4, 1), (6, 2), (11, 2), (15, 1), (16, 2), (24, 2), (64, 2), (65, 2), (68, 1), (114, 1), (120, 2), (233, 2)], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (6, 1), (11, 2), (15, 1), (16, 2), (24, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1), (233, 2)], [(1, 2), (3, 1), (4, 1), (6, 1), (11, 2), (15, 1), (16, 2), (24, 2), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1), (233, 2)], [], [], [], [(1, 1), (4, 1), (8, 2), (11, 2), (12, 2), (13, 1), (15, 2), (16, 1), (57, 2), (60, 1), (63, 1), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2), (233, 2)], [], [], [(1, 1), (2, 1), (3, 2), (4, 2), (12, 2), (15, 2), (16, 2), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2), (233, 1)], [(1, 1), (4, 2), (6, 2), (8, 1), (13, 2), (15, 2), (16, 2), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2), (233, 1)], [(1, 1), (4, 2), (6, 2), (8, 2), (11, 2), (12, 2), (13, 1), (15, 2), (16, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1), (233, 2)], [], [], [], [(1, 1), (4, 1), (6, 2), (11, 1), (13, 2), (15, 2), (16, 2), (21, 1), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2), (233, 1)], [], [(1, 2), (4, 1), (8, 2), (11, 2), (12, 2), (13, 1), (15, 2), (16, 1), (24, 2), (57, 2), (63, 1), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (12, 2), (15, 2), (16, 2), (24, 1), (57, 1), (58, 1), (63, 2), (64, 1), (65, 1), (68, 2), (114, 1), (120, 2)], [(1, 1), (4, 2), (6, 1), (8, 1), (13, 2), (15, 2), (16, 2), (24, 1), (57, 1), (63, 2), (64, 2), (65, 1), (68, 2), (114, 2), (120, 1)], [(1, 2), (4, 2), (6, 2), (8, 2), (11, 2), (13, 1), (15, 1), (16, 1), (24, 2), (57, 2), (60, 2), (63, 1), (64, 2), (65, 2), (68, 1), (114, 1), (117, 1), (120, 1)], [], [], [], [], [(1, 1), (4, 1), (6, 1), (8, 1), (11, 1), (13, 2), (15, 2), (16, 2), (24, 1), (57, 1), (63, 2), (64, 1), (65, 1), (68, 2), (114, 2), (120, 1), (181, 1)], [], [], [(1, 2), (4, 2), (6, 1), (8, 1), (13, 2), (15, 1), (57, 1), (63, 2), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1)], [(1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (8, 2), (12, 1), (13, 1), (15, 1), (57, 1), (63, 2), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1)], [], [], [], [], [(1, 2), (2, 2), (3, 1), (4, 1), (8, 1), (11, 1), (12, 1), (13, 1), (15, 1), (22, 1), (57, 1), (63, 2), (64, 2), (65, 2), (68, 1), (114, 2), (120, 1)], [], [(1, 2), (4, 1), (6, 1), (8, 2), (12, 1), (13, 1), (15, 1), (57, 2), (63, 1), (64, 1), (65, 2), (68, 2), (114, 1), (120, 2)], [(1, 2), (3, 1), (4, 1), (8, 2), (12, 1), (13, 1), (15, 1), (57, 1), (63, 2), (64, 2), (65, 1), (66, 2), (67, 1), (68, 2), (114, 2), (120, 1)], [(1, 2), (4, 1), (6, 2), (8, 2), (13, 1), (15, 1), (57, 2), (63, 1), (64, 1), (65, 2), (68, 1), (73, 1), (114, 1), (120, 2)], [(1, 2), (4, 2), (12, 1), (15, 1), (57, 2), (60, 2), (63, 1), (64, 2), (65, 2), (68, 1), (71, 1), (114, 2), (120, 1)], [], [], [], [(1, 1), (4, 2), (6, 1), (8, 2), (12, 1), (13, 1), (15, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (114, 1), (120, 1), (137, 1)], [], [], [], [(1, 1), (4, 2), (6, 1), (11, 1), (15, 2), (16, 1), (24, 1), (64, 1), (65, 1), (68, 2), (99, 1), (114, 2), (120, 1), (233, 1)], [], [], [(1, 1), (4, 2), (11, 2), (12, 1), (15, 2), (24, 1), (64, 1), (65, 1), (68, 2), (114, 2), (120, 1), (216, 1), (233, 1)], [(1, 1), (4, 2), (11, 2), (12, 1), (15, 2), (24, 1), (64, 1), (65, 1), (68, 2), (114, 2), (120, 1), (233, 1), (274, 1)], [], [], [(8, 1), (11, 2), (13, 2), (16, 1), (57, 1), (233, 2)], [], [], [(172, 1), (233, 2)], [], [], [], [], [(18, 1), (24, 2)], [], [(6, 1), (8, 1), (11, 2), (13, 2), (57, 1), (63, 2), (114, 2), (130, 1)], [], [], [(3, 2), (6, 1), (57, 1), (63, 2), (64, 2), (66, 1), (114, 2), (120, 1)], [], [(6, 1), (11, 2), (12, 2), (16, 1)], [], [], [], [], [(6, 1), (8, 2), (12, 2), (13, 1)], [], [], []] + +def comb67 : List (List (Nat × Nat)) := [[(7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 1)], [(0, 1), (2, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (18, 1), (67, 1)], [], [], [(0, 2), (2, 1), (6, 2), (7, 1), (8, 1), (10, 2), (11, 2), (15, 2), (16, 1), (18, 1), (57, 2), (67, 1), (233, 1)], [(7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (17, 2), (172, 1)], [(0, 2), (2, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (57, 2), (67, 1), (172, 1)], [], [], [], [(0, 2), (2, 1), (6, 2), (7, 1), (8, 1), (10, 2), (11, 2), (15, 2), (16, 1), (24, 1), (57, 2), (67, 1), (172, 1)], [], [], [(0, 1), (2, 2), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 1), (57, 2), (63, 1), (172, 1)], [], [], [], [(0, 2), (2, 1), (6, 1), (7, 1), (8, 2), (10, 2), (11, 2), (15, 2), (16, 1), (18, 1), (57, 2), (67, 1), (172, 1)], [(0, 2), (2, 1), (6, 1), (7, 2), (8, 2), (10, 1), (11, 1), (15, 1), (16, 2), (18, 2), (57, 1), (67, 2), (172, 2)], [(0, 1), (2, 2), (6, 1), (7, 2), (8, 2), (10, 1), (11, 1), (15, 1), (16, 2), (18, 2), (57, 1), (67, 2), (172, 2)], [], [], [(0, 1), (2, 2), (3, 1), (6, 2), (7, 2), (8, 2), (10, 1), (11, 1), (15, 2), (16, 1), (17, 1), (18, 2), (57, 1), (63, 2), (64, 2), (66, 1), (67, 1), (72, 2), (120, 2), (172, 2)], [(0, 2), (2, 1), (3, 1), (6, 1), (7, 2), (8, 2), (10, 1), (11, 1), (12, 1), (15, 2), (16, 1), (17, 1), (18, 2), (57, 1), (64, 1), (66, 2), (67, 1), (72, 1), (120, 2), (172, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (12, 1), (15, 2), (16, 1), (17, 1), (18, 2), (57, 1), (64, 1), (66, 2), (67, 1), (72, 1), (120, 2), (172, 2)], [(0, 1), (2, 1), (3, 2), (6, 1), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (15, 2), (16, 1), (57, 1), (63, 2), (64, 2), (66, 1), (67, 1), (72, 2), (120, 1), (121, 1), (172, 2)], [], [], [], [], [(0, 2), (3, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (15, 2), (16, 1), (57, 1), (64, 1), (66, 2), (67, 1), (72, 1), (120, 2), (172, 2)], [(3, 2), (15, 2), (16, 1), (17, 1), (57, 2), (64, 2), (66, 1), (67, 2), (72, 2), (120, 1), (172, 1)], [], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 1), (16, 2), (57, 2), (64, 2), (66, 1), (67, 2), (72, 2), (120, 1), (172, 1)], [], [], [(0, 2), (2, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (15, 2), (16, 1), (18, 2), (64, 2), (66, 1), (67, 1), (72, 2), (120, 1)], [], [], [(0, 2), (2, 1), (3, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (12, 1), (15, 2), (16, 1), (18, 2), (64, 2), (66, 1), (67, 1), (72, 2), (120, 1)], [], [], [(3, 2), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (15, 2), (16, 1), (18, 2), (64, 2), (66, 2), (67, 1), (72, 1), (120, 1)], [(0, 1), (2, 2), (3, 2), (7, 2), (9, 2), (10, 1), (12, 1), (15, 1), (16, 2), (18, 1), (57, 2), (64, 2), (66, 1), (67, 2), (72, 2), (117, 1), (120, 1)], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (15, 1), (16, 2), (18, 1), (57, 2), (64, 2), (66, 1), (67, 2), (72, 2), (115, 1), (120, 1)], [], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (15, 1), (16, 2), (18, 1), (57, 2), (64, 2), (66, 1), (67, 2), (72, 2), (120, 1), (174, 1)], [], [], [], [], [], [(0, 2), (3, 2), (5, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (15, 2), (16, 1), (17, 2), (64, 2), (66, 1), (67, 1), (72, 2), (120, 1)], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (15, 1), (16, 2), (17, 1), (64, 1), (66, 2), (67, 2), (72, 1), (120, 2)], [], [(0, 1), (2, 2), (3, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 1), (64, 1), (66, 2), (67, 2), (72, 1), (120, 2)], [], [], [(0, 2), (2, 1), (3, 1), (6, 1), (8, 2), (9, 1), (12, 2), (15, 2), (16, 1), (17, 2), (64, 1), (66, 2), (67, 1), (72, 2), (120, 2)], [(0, 1), (2, 2), (3, 1), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (15, 1), (16, 2), (17, 1), (64, 1), (65, 1), (66, 2), (67, 1), (72, 1), (120, 2)], [], [(3, 1), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (15, 1), (16, 2), (17, 1), (64, 1), (66, 1), (67, 2), (72, 2), (73, 1), (74, 2), (120, 2)], [], [], [], [(3, 2), (7, 1), (8, 1), (10, 2), (11, 2), (15, 1), (16, 2), (17, 1), (63, 2), (64, 2), (66, 1), (67, 2), (72, 2), (120, 1), (127, 1)], [(3, 2), (7, 1), (8, 1), (10, 2), (11, 2), (15, 1), (16, 2), (17, 1), (63, 2), (64, 2), (66, 1), (67, 2), (72, 2), (120, 1), (137, 1)], [], [], [], [], [(0, 2), (2, 1), (3, 2), (6, 1), (7, 1), (8, 1), (10, 2), (11, 2), (15, 1), (16, 2), (17, 2), (18, 1), (57, 2), (63, 1), (64, 1), (66, 2), (67, 2), (72, 1), (120, 1), (157, 1), (172, 1)], [(0, 2), (2, 1), (3, 2), (6, 1), (7, 1), (8, 1), (10, 2), (11, 2), (15, 1), (16, 2), (17, 2), (18, 1), (57, 2), (63, 1), (64, 1), (66, 2), (67, 2), (72, 1), (120, 1), (172, 1), (392, 1)], [(0, 2), (2, 1), (3, 2), (6, 1), (8, 1), (9, 2), (12, 1), (15, 1), (16, 2), (17, 1), (18, 1), (57, 2), (63, 1), (64, 1), (66, 2), (67, 2), (72, 1), (120, 1), (172, 1), (216, 1)], [], [], [], [], [(7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (114, 1), (172, 2)], [(2, 1), (5, 2), (6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (17, 1), (172, 2), (293, 1)], [], [], [], [(6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (18, 2)], [(0, 2), (2, 1), (6, 1), (7, 1), (8, 2), (9, 1), (10, 2), (11, 2), (12, 2), (13, 1), (17, 1), (18, 2)], [], [], [], [(0, 2), (2, 1), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (12, 1), (15, 1), (16, 2), (17, 1), (67, 2), (74, 1)], [(0, 1), (2, 2), (6, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 2), (12, 1), (15, 1), (16, 2), (17, 1), (65, 2), (66, 2), (68, 1), (72, 1)], [], [], [(7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1)], [], [], [], [], [], [], [], []] + +def comb68 : List (List (Nat × Nat)) := [[(9, 2), (11, 1), (14, 1), (16, 2), (24, 1)], [(8, 2), (9, 2), (11, 1), (14, 1), (16, 2), (24, 1), (63, 1)], [], [(8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (57, 2), (63, 1), (172, 1)], [], [(9, 2), (11, 1), (14, 1), (16, 2), (233, 1)], [(3, 1), (8, 2), (9, 2), (11, 1), (14, 1), (16, 2), (57, 2), (63, 1), (233, 1)], [], [], [(8, 2), (9, 1), (11, 2), (14, 2), (16, 1), (18, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [], [], [], [(6, 1), (8, 1), (9, 1), (11, 2), (14, 2), (16, 1), (24, 1), (57, 2), (63, 1), (233, 1)], [], [], [], [(8, 1), (9, 2), (11, 1), (14, 1), (16, 2), (24, 2), (57, 1), (63, 2), (233, 2)], [], [(6, 1), (8, 2), (11, 1), (14, 1), (16, 2), (24, 2), (57, 1), (58, 1), (64, 1), (66, 1), (72, 2), (115, 2), (233, 2)], [(6, 1), (8, 1), (9, 1), (11, 1), (14, 1), (16, 2), (24, 2), (57, 1), (58, 1), (63, 1), (66, 1), (72, 2), (115, 2), (233, 2)], [], [], [(6, 1), (8, 1), (11, 2), (14, 1), (16, 2), (24, 2), (57, 1), (58, 1), (63, 1), (66, 1), (72, 2), (115, 2), (233, 2)], [], [(3, 2), (6, 2), (11, 1), (14, 2), (15, 1), (16, 1), (57, 1), (58, 2), (63, 1), (66, 2), (67, 2), (72, 1), (115, 1), (121, 1), (233, 2)], [], [(6, 1), (8, 1), (9, 2), (11, 2), (14, 2), (16, 1), (58, 2), (63, 1), (66, 2), (72, 1), (115, 2), (233, 2)], [], [(0, 1), (3, 2), (6, 2), (11, 2), (12, 2), (14, 2), (16, 1), (57, 1), (58, 1), (63, 1), (66, 1), (72, 2), (115, 2), (233, 2)], [], [(6, 2), (8, 2), (9, 1), (14, 1), (15, 1), (16, 2), (57, 2), (58, 2), (63, 2), (66, 2), (72, 1), (115, 1), (233, 1)], [(6, 2), (8, 2), (9, 1), (11, 1), (14, 1), (16, 2), (57, 2), (58, 2), (63, 2), (66, 2), (72, 1), (115, 1), (233, 1)], [], [(6, 2), (8, 2), (11, 1), (14, 2), (16, 2), (57, 2), (58, 2), (63, 2), (66, 2), (72, 1), (115, 1), (233, 1)], [], [(6, 1), (7, 1), (8, 1), (11, 1), (14, 2), (16, 1), (24, 2), (58, 2), (63, 1), (66, 2), (72, 1), (115, 1)], [], [(6, 1), (8, 1), (9, 2), (11, 2), (12, 1), (14, 2), (16, 1), (24, 2), (58, 2), (63, 1), (66, 2), (72, 1), (115, 1)], [], [], [(6, 2), (11, 2), (14, 2), (16, 1), (24, 2), (58, 2), (63, 1), (66, 1), (72, 2), (115, 1)], [], [(6, 2), (8, 2), (9, 1), (14, 1), (16, 2), (24, 1), (57, 2), (58, 2), (63, 2), (66, 2), (72, 1), (115, 1), (117, 1)], [], [(3, 2), (6, 2), (8, 2), (9, 1), (11, 1), (14, 1), (16, 2), (24, 1), (58, 2), (63, 2), (64, 2), (66, 2), (72, 1), (115, 1), (120, 1)], [], [(6, 2), (8, 2), (11, 1), (14, 1), (16, 2), (24, 1), (57, 2), (58, 2), (63, 2), (66, 2), (72, 1), (115, 1), (236, 1)], [], [], [], [(1, 1), (3, 2), (6, 2), (9, 2), (11, 2), (58, 2), (63, 1), (66, 2), (72, 1), (115, 1)], [], [], [(6, 2), (7, 2), (8, 2), (9, 1), (10, 1), (11, 1), (58, 1), (63, 2), (66, 1), (72, 2), (115, 2)], [], [(6, 2), (8, 2), (9, 1), (11, 1), (12, 2), (14, 1), (16, 2), (17, 1), (58, 1), (63, 2), (66, 1), (72, 2), (115, 2)], [], [(6, 1), (8, 1), (9, 1), (58, 1), (63, 1), (66, 2), (72, 2), (115, 2)], [], [(6, 1), (8, 1), (9, 1), (11, 1), (15, 2), (58, 1), (63, 1), (66, 1), (67, 1), (72, 2), (115, 2)], [], [(6, 2), (7, 2), (9, 1), (11, 1), (58, 1), (63, 1), (66, 1), (71, 1), (72, 2), (115, 2)], [], [(3, 1), (6, 1), (8, 1), (9, 2), (11, 2), (14, 2), (58, 1), (63, 1), (64, 1), (66, 1), (72, 2), (115, 2), (120, 2), (130, 1)], [], [(6, 2), (11, 2), (14, 2), (16, 1), (18, 2), (57, 1), (58, 1), (63, 1), (66, 1), (72, 2), (115, 1), (137, 1)], [], [], [], [], [(0, 2), (3, 1), (6, 1), (8, 2), (11, 2), (12, 1), (14, 1), (16, 1), (24, 1), (57, 2), (58, 2), (64, 2), (66, 2), (72, 1), (115, 1), (157, 1), (233, 1)], [(3, 1), (6, 1), (8, 2), (9, 2), (11, 2), (14, 2), (16, 1), (24, 1), (57, 2), (58, 1), (66, 2), (72, 1), (115, 2), (120, 2), (233, 1), (392, 1)], [], [(6, 2), (8, 1), (9, 2), (24, 1), (57, 2), (58, 2), (64, 2), (66, 2), (72, 1), (115, 1), (233, 1), (274, 1)], [], [], [], [(6, 2), (8, 1), (9, 1), (11, 2), (14, 2), (16, 1), (114, 1), (233, 2)], [(3, 1), (6, 2), (8, 1), (11, 2), (14, 2), (16, 1), (58, 2), (64, 1), (115, 1), (120, 2), (233, 2), (293, 1)], [], [], [], [(8, 1), (9, 1), (11, 2), (14, 2), (16, 1), (24, 2)], [(9, 1), (11, 2), (13, 1), (14, 2), (16, 1), (24, 2)], [], [], [], [(8, 1), (9, 1), (11, 2), (14, 2), (63, 2), (73, 1)], [(8, 1), (11, 2), (63, 2), (68, 1)], [], [], [(9, 1), (11, 2), (14, 2), (16, 1)], [], [], [], [], [], [], [], []] + +def comb69 : List (List (Nat × Nat)) := [[(0, 2), (4, 1), (13, 1), (16, 2), (24, 1)], [(0, 2), (4, 1), (8, 2), (13, 1), (16, 2), (24, 1), (63, 1)], [], [], [], [(0, 2), (4, 1), (13, 1), (16, 2), (233, 1)], [(4, 1), (8, 2), (13, 1), (16, 2), (57, 2), (63, 1), (233, 1)], [], [(0, 2), (4, 1), (8, 2), (13, 2), (16, 2), (57, 2), (63, 1), (233, 1)], [], [], [], [(0, 2), (4, 1), (8, 2), (13, 2), (16, 1), (24, 1), (57, 2), (63, 1), (64, 2), (65, 2), (68, 1), (77, 1), (233, 1)], [], [], [(2, 2), (4, 1), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (16, 1), (20, 1), (24, 1), (57, 2), (63, 1), (233, 1)], [], [], [(0, 2), (4, 1), (8, 1), (13, 1), (16, 2), (24, 2), (57, 1), (63, 2), (233, 2)], [], [], [(0, 1), (4, 2), (8, 1), (13, 1), (16, 2), (24, 2), (57, 1), (63, 2), (233, 2)], [(0, 1), (4, 2), (11, 1), (13, 1), (16, 2), (24, 2), (57, 1), (60, 1), (64, 1), (65, 2), (68, 1), (117, 2), (233, 2)], [(0, 1), (4, 2), (8, 2), (9, 1), (11, 1), (13, 1), (16, 2), (24, 2), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (117, 2), (233, 2)], [], [(2, 1), (4, 2), (8, 2), (9, 1), (11, 1), (12, 2), (13, 2), (16, 2), (24, 2), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (117, 2), (233, 2)], [], [], [(0, 1), (2, 2), (4, 2), (9, 2), (11, 2), (12, 1), (13, 1), (16, 1), (57, 1), (60, 2), (65, 2), (66, 1), (67, 2), (68, 1), (117, 1), (121, 1), (233, 2)], [(0, 1), (4, 2), (8, 2), (11, 1), (13, 2), (16, 1), (60, 2), (63, 1), (65, 1), (68, 2), (117, 2), (233, 2)], [], [], [], [], [], [(8, 1), (11, 2), (13, 1), (16, 2), (57, 2), (60, 2), (63, 2), (65, 1), (68, 2), (117, 1), (233, 1)], [], [], [(8, 1), (9, 2), (11, 2), (13, 1), (16, 2), (21, 1), (57, 2), (60, 2), (63, 2), (65, 1), (68, 2), (117, 1), (233, 1)], [(0, 1), (4, 2), (7, 1), (8, 2), (11, 1), (13, 2), (16, 1), (24, 2), (60, 2), (63, 1), (65, 1), (68, 2), (117, 1)], [], [], [], [(0, 1), (4, 2), (8, 2), (11, 2), (13, 2), (16, 1), (24, 2), (60, 2), (63, 1), (65, 2), (68, 1), (117, 1)], [], [], [], [(8, 1), (9, 2), (11, 2), (13, 1), (16, 2), (24, 1), (57, 2), (60, 2), (63, 2), (65, 1), (68, 2), (115, 1), (117, 1)], [(0, 2), (8, 1), (11, 2), (13, 1), (16, 2), (24, 1), (60, 2), (63, 2), (64, 2), (65, 1), (68, 2), (117, 1), (120, 1)], [], [], [(0, 2), (8, 1), (11, 2), (13, 1), (16, 2), (24, 1), (60, 2), (63, 2), (64, 2), (65, 1), (68, 2), (117, 1), (181, 1)], [], [(0, 1), (4, 2), (8, 2), (9, 2), (11, 2), (12, 1), (13, 2), (60, 2), (63, 1), (65, 1), (68, 2), (117, 1)], [], [], [(8, 1), (11, 2), (60, 1), (63, 2), (65, 2), (68, 1), (117, 2)], [(7, 2), (8, 1), (10, 1), (11, 2), (60, 1), (63, 2), (65, 2), (68, 1), (117, 2)], [], [], [(7, 2), (8, 1), (11, 2), (22, 1), (60, 1), (63, 2), (65, 2), (68, 1), (117, 2)], [], [(8, 2), (11, 1), (60, 1), (63, 1), (65, 2), (68, 2), (117, 2)], [(0, 2), (2, 1), (8, 1), (9, 1), (11, 1), (12, 2), (13, 1), (60, 1), (63, 2), (65, 1), (66, 2), (67, 1), (68, 2), (117, 2)], [], [], [(7, 2), (8, 2), (11, 2), (60, 1), (63, 1), (65, 2), (68, 1), (80, 1), (117, 2)], [(0, 1), (8, 2), (11, 1), (13, 2), (60, 1), (63, 1), (64, 1), (65, 2), (68, 1), (117, 2), (120, 2), (130, 1)], [(6, 2), (11, 2), (13, 2), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (117, 1), (127, 1)], [], [], [], [], [], [(0, 2), (4, 1), (6, 2), (8, 1), (11, 2), (13, 2), (16, 1), (24, 1), (57, 2), (60, 2), (64, 2), (65, 1), (68, 2), (117, 1), (157, 1), (233, 1)], [], [(0, 1), (4, 2), (11, 2), (24, 1), (57, 2), (60, 2), (64, 2), (65, 1), (68, 2), (117, 1), (216, 1), (233, 1)], [(0, 1), (4, 2), (11, 2), (24, 1), (57, 2), (60, 2), (64, 2), (65, 1), (68, 2), (117, 1), (233, 1), (274, 1)], [], [], [], [(0, 1), (4, 2), (6, 2), (8, 1), (13, 2), (16, 1), (114, 1), (233, 2)], [], [(172, 1), (233, 2)], [], [], [(0, 1), (4, 2), (8, 1), (13, 2), (16, 1), (24, 2)], [], [(18, 1), (24, 2)], [], [], [(0, 1), (4, 2), (8, 1), (13, 2), (63, 2), (73, 1)], [], [(0, 1), (2, 2), (8, 1), (9, 2), (12, 1), (13, 2), (63, 2), (66, 1)], [], [(0, 1), (4, 2), (13, 2), (16, 1)], [], [(6, 1), (8, 2)], [], [], [], [], [], []] + +def comb70 : List (List (Nat × Nat)) := [[], [], [], [], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (13, 2), (15, 1), (18, 2), (21, 1), (34, 2), (57, 1), (114, 1), (172, 2), (233, 2), (293, 1)], [(2, 1), (3, 2), (4, 1), (6, 2), (8, 1), (9, 2), (11, 1), (13, 2), (15, 1), (18, 2), (21, 1), (34, 2), (114, 1), (172, 2), (233, 2), (293, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 1), (9, 2), (11, 1), (13, 2), (15, 1), (18, 2), (21, 1), (34, 2), (57, 1), (172, 2), (233, 2), (293, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (7, 2), (8, 1), (9, 2), (11, 1), (15, 1), (21, 1), (22, 2), (34, 2), (57, 1), (114, 1), (172, 2), (233, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (13, 2), (15, 1), (21, 1), (34, 2), (57, 1), (114, 1), (172, 1), (233, 2), (293, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (13, 2), (15, 1), (18, 2), (21, 1), (24, 1), (34, 2), (57, 1), (114, 1), (172, 2), (233, 1), (293, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (18, 2), (21, 1), (22, 2), (34, 2), (57, 2), (75, 1), (114, 2), (172, 1), (233, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (11, 1), (12, 2), (15, 1), (21, 1), (22, 1), (34, 2), (57, 2), (63, 1), (64, 2), (77, 1), (172, 1), (233, 1), (293, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (21, 1), (22, 2), (34, 2), (57, 2), (63, 1), (172, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (21, 1), (22, 2), (34, 2), (57, 2), (114, 2), (172, 1), (233, 1)], [(1, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (9, 2), (11, 1), (13, 2), (15, 1), (20, 1), (21, 1), (22, 1), (34, 2), (57, 2), (172, 1), (233, 1), (293, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (21, 1), (22, 2), (34, 2), (57, 2), (233, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (9, 2), (11, 1), (13, 2), (15, 1), (21, 1), (22, 2), (34, 2), (57, 2), (172, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (21, 1), (22, 2), (34, 2), (114, 2), (233, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 2), (11, 1), (13, 2), (15, 1), (18, 1), (21, 1), (22, 1), (34, 2), (233, 1), (293, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 2), (11, 1), (13, 2), (15, 1), (18, 1), (21, 1), (22, 1), (34, 2), (172, 1), (293, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 2), (11, 1), (13, 2), (15, 1), (18, 1), (21, 1), (22, 1), (34, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (9, 1), (11, 1), (13, 2), (15, 1), (21, 2), (22, 1), (34, 2), (63, 2), (64, 1), (114, 2), (172, 1), (233, 1), (293, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 2), (11, 1), (13, 2), (15, 1), (21, 2), (22, 1), (34, 2), (114, 2), (172, 1), (233, 1), (293, 2)], [(0, 1), (5, 2), (9, 1), (11, 2), (13, 2), (15, 1), (21, 2), (22, 1), (34, 2), (57, 2), (172, 1), (233, 1), (293, 2)], [(1, 1), (2, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (18, 2), (21, 2), (22, 2), (34, 2), (57, 2), (114, 2), (172, 1), (233, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (18, 2), (21, 2), (22, 2), (34, 2), (57, 2), (114, 2), (172, 2), (233, 1), (293, 2)], [(1, 1), (5, 2), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (13, 2), (15, 1), (18, 2), (21, 2), (22, 2), (34, 2), (57, 2), (114, 2), (172, 1), (233, 2), (293, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 1), (11, 2), (18, 2), (21, 2), (22, 2), (57, 2), (63, 2), (121, 1), (172, 2), (233, 2)], [(9, 1), (11, 2), (18, 1), (21, 2), (60, 1), (172, 2), (233, 2), (293, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (9, 1), (11, 2), (18, 1), (21, 2), (58, 1), (233, 2)], [(1, 2), (5, 1), (7, 2), (8, 1), (9, 1), (11, 2), (18, 2), (21, 2), (22, 2), (57, 1), (114, 1), (172, 2), (233, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (9, 1), (11, 2), (18, 1), (21, 2), (57, 1), (233, 2)], [(1, 2), (4, 1), (6, 2), (7, 1), (9, 1), (11, 2), (18, 1), (21, 2), (57, 1), (172, 2)], [(6, 2), (8, 1), (9, 1), (11, 2), (13, 2), (15, 1), (18, 1), (21, 2), (114, 1), (172, 2), (233, 2), (293, 1)], [(6, 2), (9, 1), (18, 1), (21, 2), (114, 1), (172, 2)], [(1, 1), (5, 2), (7, 2), (8, 1), (12, 1), (13, 2), (21, 2), (22, 1), (233, 2), (293, 1)], [(1, 1), (5, 2), (6, 1), (7, 2), (13, 2), (14, 1), (21, 2), (22, 1), (172, 2), (293, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (6, 1), (8, 1), (13, 1), (15, 2), (18, 2), (22, 1), (34, 1), (63, 1), (114, 2), (121, 2), (172, 2), (233, 2), (293, 2), (314, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (9, 1), (11, 2), (13, 2), (14, 2), (15, 2), (18, 2), (22, 1), (34, 1), (44, 1)], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (13, 2), (15, 2), (18, 2), (22, 1), (34, 1), (63, 1), (64, 2), (99, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (9, 1), (13, 2), (14, 2), (15, 2), (18, 2), (22, 1), (34, 1), (57, 2), (63, 1), (64, 2), (114, 1), (157, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (11, 1), (13, 1), (15, 1), (34, 2), (57, 2), (63, 1), (64, 2), (293, 1), (392, 1)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (13, 2), (14, 2), (15, 2), (18, 1), (22, 2), (34, 1), (57, 2), (63, 1), (64, 2), (172, 1), (216, 1)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (9, 1), (12, 2), (13, 2), (15, 2), (18, 1), (22, 2), (34, 1), (57, 2), (63, 1), (64, 2), (233, 1), (274, 1)], [(1, 1), (2, 1), (5, 1), (7, 2), (8, 1), (20, 2), (22, 2), (57, 2), (75, 2), (114, 1), (172, 1), (233, 1), (293, 1), (470, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb71 : List (List (Nat × Nat)) := [[(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (19, 1), (20, 1), (24, 1), (57, 1), (58, 1), (64, 2), (66, 1), (75, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2), (470, 2)], [(0, 1), (2, 2), (6, 2), (7, 2), (8, 2), (13, 1), (18, 2), (19, 1), (24, 2), (58, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (19, 1), (20, 1), (24, 1), (57, 1), (58, 1), (64, 2), (66, 1), (75, 1), (117, 1), (172, 2), (181, 1), (291, 2), (470, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (18, 2), (19, 1), (20, 1), (24, 1), (57, 1), (58, 1), (64, 2), (66, 1), (75, 1), (114, 2), (117, 1), (181, 1), (291, 2), (470, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (19, 1), (20, 1), (57, 1), (58, 1), (64, 2), (66, 1), (75, 1), (114, 2), (117, 1), (172, 2), (181, 1), (233, 1), (291, 2), (470, 2)], [], [], [], [], [], [], [(0, 1), (2, 2), (6, 2), (7, 2), (19, 1), (24, 1), (57, 1), (58, 1), (64, 2), (66, 1), (75, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 2), (2, 1), (6, 1), (8, 1), (13, 2), (18, 1), (24, 1), (57, 1), (58, 1), (60, 2), (63, 1), (64, 1), (66, 2), (77, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (7, 2), (18, 1), (19, 1), (57, 1), (58, 1), (63, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (8, 2), (13, 1), (19, 1), (20, 2), (24, 2), (58, 1), (64, 2), (66, 1), (75, 2), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2), (470, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (24, 2), (58, 1), (64, 2), (66, 1), (75, 2), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2), (470, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 2), (13, 1), (18, 2), (19, 1), (20, 2), (24, 2), (58, 1), (64, 2), (66, 1), (75, 2), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2), (470, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (13, 1), (19, 1), (20, 2), (24, 1), (58, 1), (64, 2), (66, 1), (75, 2), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2), (470, 1)], [(0, 1), (2, 2), (6, 2), (7, 2), (19, 1), (24, 1), (57, 2), (58, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (7, 2), (8, 1), (13, 2), (19, 1), (24, 1), (57, 2), (58, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (7, 2), (8, 1), (13, 2), (18, 1), (19, 1), (57, 2), (58, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(3, 2), (4, 1), (7, 1), (19, 2), (57, 2), (58, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (181, 1), (291, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (19, 1), (20, 2), (24, 2), (57, 1), (58, 1), (63, 2), (64, 2), (66, 1), (75, 2), (114, 2), (117, 1), (172, 1), (181, 2), (291, 2), (470, 1)], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 2), (9, 1), (13, 2), (18, 1), (19, 1), (24, 1), (57, 2), (58, 1), (64, 1), (66, 2), (114, 2), (117, 1), (172, 1), (181, 2), (291, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (19, 1), (20, 2), (24, 2), (58, 1), (64, 1), (66, 2), (75, 2), (114, 2), (117, 1), (172, 1), (181, 2), (291, 2), (470, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (8, 2), (13, 1), (19, 1), (20, 2), (24, 2), (58, 1), (64, 1), (66, 2), (75, 2), (114, 2), (117, 1), (172, 1), (181, 2), (291, 2), (470, 1)], [(0, 2), (2, 1), (3, 1), (4, 2), (7, 1), (18, 1), (20, 2), (24, 2), (58, 1), (64, 1), (66, 2), (75, 2), (114, 2), (117, 1), (172, 1), (181, 2), (291, 2), (470, 1)], [(0, 2), (3, 2), (4, 1), (5, 1), (7, 1), (20, 2), (58, 1), (64, 1), (66, 2), (75, 2), (114, 2), (117, 1), (172, 1), (181, 2), (291, 2), (470, 1)], [], [], [], [], [], [], [], [], [], [], [], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (13, 2), (19, 1), (20, 1), (24, 1), (57, 2), (64, 1), (66, 2), (75, 1), (172, 1), (181, 2), (470, 2)], [(0, 2), (1, 1), (2, 1), (6, 1), (7, 2), (18, 2), (19, 1), (24, 2), (64, 1), (66, 2), (172, 1), (181, 2)], [(2, 1), (24, 2), (64, 1), (66, 2), (172, 1), (181, 2)], [(3, 1), (18, 2), (64, 1), (66, 2), (172, 1), (181, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (19, 1), (20, 1), (24, 1), (57, 1), (60, 1), (64, 1), (66, 2), (75, 1), (172, 1), (181, 2), (470, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (13, 2), (18, 1), (20, 1), (24, 1), (57, 1), (58, 1), (64, 1), (66, 2), (75, 1), (172, 1), (181, 2), (470, 2)], [(3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (13, 2), (20, 1), (24, 2), (57, 1), (64, 1), (75, 1), (172, 1), (181, 2), (470, 2)], [(0, 2), (2, 1), (6, 2), (7, 2), (8, 2), (13, 1), (18, 2), (19, 1), (24, 2), (64, 1), (66, 2), (114, 2), (117, 1), (172, 1), (181, 2)], [(3, 1), (8, 1), (9, 2), (24, 2), (64, 1), (66, 2), (114, 2), (115, 1), (172, 1), (181, 2)], [(6, 1), (18, 2), (114, 2), (120, 1), (172, 1), (181, 2)], [(0, 2), (2, 1), (3, 1), (9, 2), (13, 1), (19, 1), (20, 2), (24, 2), (64, 1), (66, 2), (174, 1), (181, 2)], [(0, 2), (2, 1), (3, 1), (9, 2), (13, 1), (18, 2), (19, 1), (20, 2), (64, 1), (66, 2), (172, 1), (181, 2), (233, 2), (236, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [(1, 2), (3, 1), (4, 2), (6, 2), (18, 1), (19, 1), (20, 2), (51, 1), (57, 2), (58, 2), (75, 2), (114, 1), (117, 2), (291, 1), (470, 1)], [], [(6, 2), (7, 2), (19, 1), (44, 1), (57, 2), (58, 1), (114, 2), (117, 1), (291, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (13, 2), (18, 1), (19, 1), (20, 1), (24, 2), (57, 2), (58, 1), (63, 1), (64, 2), (66, 1), (75, 1), (99, 1), (114, 2), (117, 1), (291, 2), (470, 2)], [(0, 1), (2, 2), (7, 2), (19, 1), (57, 1), (58, 1), (63, 1), (64, 2), (66, 1), (114, 1), (117, 1), (157, 1), (291, 2)], [(7, 1), (8, 2), (13, 1), (19, 2), (57, 1), (58, 1), (63, 1), (114, 2), (117, 2), (120, 2), (291, 1), (392, 1)], [(0, 1), (2, 2), (6, 2), (7, 2), (18, 1), (19, 1), (57, 1), (58, 1), (63, 1), (64, 2), (66, 1), (114, 2), (117, 1), (172, 2), (216, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (7, 2), (19, 1), (24, 1), (57, 1), (58, 1), (63, 1), (64, 2), (66, 1), (114, 2), (117, 1), (233, 2), (274, 1), (291, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb72 : List (List (Nat × Nat)) := [[], [(0, 2), (2, 2), (4, 2), (6, 2), (7, 2), (9, 1), (11, 2), (12, 2), (18, 1), (21, 1), (22, 1), (34, 2), (57, 1), (63, 2), (66, 2), (68, 1), (73, 1)], [(0, 2), (2, 2), (4, 2), (6, 2), (7, 2), (9, 1), (11, 2), (12, 2), (18, 1), (21, 1), (22, 1), (34, 2), (57, 1), (63, 2), (66, 2), (68, 1), (130, 1)], [(0, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (21, 2), (22, 1), (34, 2), (57, 1), (63, 2), (66, 1), (68, 1), (73, 1), (114, 2), (130, 1), (172, 1)], [(0, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (21, 2), (22, 1), (34, 2), (57, 1), (63, 1), (66, 2), (68, 1), (73, 1), (114, 2), (130, 1), (233, 1)], [], [(0, 2), (4, 2), (6, 2), (7, 2), (9, 1), (11, 2), (12, 1), (18, 1), (21, 1), (22, 1), (34, 2), (57, 1), (63, 1), (66, 1), (114, 1), (130, 2)], [(0, 1), (2, 1), (3, 2), (4, 2), (7, 2), (8, 2), (9, 2), (11, 2), (12, 1), (18, 1), (21, 1), (22, 1), (34, 2), (57, 2), (63, 1), (66, 1), (73, 2)], [(0, 1), (2, 1), (3, 2), (4, 2), (7, 2), (8, 2), (9, 2), (11, 2), (12, 1), (18, 1), (21, 1), (22, 1), (34, 2), (57, 2), (63, 1), (66, 1), (68, 2)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 2), (11, 2), (18, 1), (21, 2), (22, 1), (34, 2), (57, 2), (63, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 2), (11, 2), (21, 2), (22, 1), (24, 1), (34, 2), (57, 2), (66, 1)], [], [], [], [(0, 1), (3, 2), (6, 1), (7, 2), (9, 2), (11, 2), (12, 2), (18, 2), (22, 1), (34, 2), (57, 2), (63, 1), (66, 1), (73, 2), (114, 1), (130, 2)], [(0, 1), (1, 1), (3, 2), (4, 2), (6, 2), (7, 1), (9, 2), (12, 2), (15, 2), (18, 1), (20, 1), (22, 1), (34, 2), (57, 2), (63, 1), (66, 1), (68, 2), (114, 1), (130, 2)], [(0, 1), (2, 1), (3, 2), (4, 2), (7, 2), (8, 2), (9, 2), (11, 2), (12, 1), (18, 1), (21, 1), (22, 1), (34, 2), (57, 2), (63, 1), (114, 1), (130, 2)], [(0, 1), (2, 1), (3, 2), (4, 2), (6, 2), (7, 2), (9, 2), (11, 2), (12, 1), (18, 1), (21, 1), (22, 1), (34, 2), (57, 2), (66, 1), (114, 1), (130, 2)], [(0, 1), (2, 1), (3, 2), (4, 2), (7, 2), (8, 2), (9, 2), (11, 2), (12, 1), (18, 1), (21, 1), (22, 1), (34, 2), (63, 1), (73, 2)], [(3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (11, 2), (18, 1), (21, 1), (22, 1), (34, 2), (63, 1), (68, 2)], [(3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (11, 2), (18, 1), (21, 1), (22, 1), (34, 2), (66, 1), (68, 2)], [(3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (11, 2), (18, 1), (21, 1), (22, 1), (34, 2)], [(0, 1), (3, 2), (6, 2), (7, 1), (9, 1), (12, 2), (18, 1), (22, 2), (34, 2), (57, 2), (63, 1), (64, 1), (66, 1), (68, 2), (73, 2), (114, 1), (130, 2)], [], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (12, 1), (21, 1), (22, 2), (63, 1), (66, 1), (68, 2), (73, 2), (114, 2), (121, 1)], [(0, 2), (2, 2), (4, 2), (6, 2), (7, 1), (9, 1), (12, 2), (18, 1), (22, 2), (34, 2), (57, 1), (60, 1), (63, 1), (66, 1), (73, 2), (114, 1), (130, 2)], [(0, 1), (3, 2), (6, 2), (7, 1), (9, 1), (12, 2), (18, 1), (22, 2), (34, 2), (57, 1), (58, 1), (63, 1), (66, 2), (68, 2), (73, 2), (114, 1), (130, 2)], [], [], [], [], [], [], [], [], [(0, 1), (3, 2), (7, 2), (8, 2), (9, 2), (11, 2), (12, 2), (18, 1), (22, 2), (34, 2), (57, 2), (63, 2), (66, 2), (114, 2), (130, 1)], [(0, 1), (1, 1), (3, 2), (4, 2), (7, 1), (8, 2), (9, 2), (12, 2), (18, 1), (22, 2), (34, 2), (57, 1), (63, 2), (66, 2), (73, 1)], [(0, 2), (2, 2), (3, 2), (6, 2), (7, 1), (9, 1), (18, 1), (22, 2), (34, 2), (57, 1), (63, 2)], [(0, 2), (2, 1), (6, 2), (7, 1), (9, 1), (18, 1), (22, 2), (34, 2), (57, 1), (66, 2)], [], [], [], [], [], [], [], [], [], [(0, 2), (3, 2), (4, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (12, 1), (21, 1), (22, 2), (57, 1), (63, 2), (66, 2), (73, 1), (114, 2), (130, 1)], [(0, 2), (2, 2), (4, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (21, 1), (22, 2), (57, 1), (63, 2), (66, 2), (68, 1), (114, 2), (130, 1)], [(0, 2), (2, 2), (3, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (21, 1), (22, 2), (57, 1), (63, 2), (114, 2), (130, 1)], [(0, 2), (2, 1), (4, 2), (5, 1), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (21, 1), (22, 2), (57, 1), (66, 2), (114, 2), (130, 1)], [(2, 1), (4, 2), (7, 1), (12, 2), (21, 1), (22, 2), (63, 2), (73, 1)], [(2, 1), (4, 2), (6, 1), (8, 2), (10, 1), (12, 2), (21, 1), (22, 2), (66, 2), (73, 1)], [(1, 2), (2, 1), (7, 1), (11, 2), (12, 2), (15, 1), (21, 1), (22, 2), (63, 2), (68, 1)], [(3, 1), (4, 2), (7, 1), (11, 2), (12, 2), (17, 1), (21, 1), (22, 2), (66, 2), (68, 1)], [], [], [], [], [], [], [], [], [], [], [(1, 2), (2, 1), (3, 1), (4, 2), (6, 2), (8, 2), (11, 2), (17, 2), (18, 2), (21, 1), (34, 1), (51, 1), (57, 1), (63, 2), (66, 2), (68, 2), (73, 2), (114, 1), (130, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 1), (11, 2), (12, 1), (17, 2), (114, 1), (121, 2), (314, 1)], [], [(2, 1), (3, 1), (4, 1), (6, 2), (9, 1), (11, 1), (12, 2), (18, 1), (21, 2), (34, 2), (64, 2), (99, 1), (114, 2), (130, 1)], [(2, 1), (3, 1), (4, 1), (6, 2), (9, 1), (11, 1), (12, 2), (18, 1), (21, 2), (34, 2), (64, 2), (73, 1), (114, 2), (157, 1)], [(2, 1), (3, 1), (4, 1), (6, 1), (9, 1), (11, 1), (12, 2), (18, 1), (21, 2), (34, 2), (64, 2), (68, 1), (392, 1)], [(3, 1), (4, 2), (8, 1), (9, 1), (11, 1), (18, 2), (21, 1), (34, 2), (64, 2), (66, 1), (172, 2), (216, 1)], [(3, 1), (4, 2), (8, 1), (9, 1), (11, 1), (18, 2), (21, 1), (34, 2), (63, 1), (64, 2), (233, 2), (274, 1)], [], [(0, 1), (2, 1), (3, 1), (8, 1), (9, 2), (12, 1), (57, 2), (63, 1), (66, 1), (68, 1), (73, 1), (114, 2), (130, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb73 : List (List (Nat × Nat)) := [[(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (16, 1), (18, 2), (57, 1), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (114, 1), (130, 2)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (18, 2), (57, 1), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (114, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (18, 2), (57, 1), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (172, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (18, 2), (57, 1), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (233, 1)], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (16, 2), (18, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1)], [], [(1, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (16, 1), (18, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (114, 2), (130, 1)], [(1, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (12, 1), (16, 2), (18, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (114, 2), (130, 1)], [(1, 2), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 2), (11, 1), (12, 1), (16, 1), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (114, 2), (130, 1)], [(1, 2), (3, 2), (4, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 1), (16, 1), (18, 2), (24, 1), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1), (114, 2), (130, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (16, 1), (18, 1), (57, 1), (58, 1), (63, 1), (71, 1), (74, 2), (75, 1), (80, 1), (114, 1), (130, 2)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (16, 2), (18, 1), (57, 2), (58, 1), (60, 2), (63, 1), (71, 1), (74, 2), (77, 1), (80, 1), (114, 1), (130, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (16, 1), (18, 2), (57, 1), (58, 1), (63, 2), (71, 1), (74, 2), (80, 1), (114, 1), (130, 2)], [], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (18, 2), (57, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (16, 1), (18, 2), (57, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (9, 1), (11, 2), (12, 2), (16, 1), (18, 2), (57, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (12, 2), (16, 1), (18, 2), (57, 2), (58, 1), (63, 1), (71, 1), (74, 2), (80, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (16, 1), (18, 1), (57, 2), (63, 1), (80, 2), (114, 1), (130, 2)], [], [], [], [], [(1, 2), (6, 1), (7, 1), (8, 2), (16, 2), (18, 1), (57, 1), (60, 1), (67, 2), (80, 2), (114, 1), (121, 1), (130, 1)], [], [], [(6, 2), (7, 1), (8, 2), (18, 1), (63, 1), (80, 2)], [(0, 1), (1, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (12, 1), (16, 2), (18, 1), (63, 1), (80, 2)], [(0, 1), (1, 2), (2, 2), (4, 1), (6, 2), (7, 1), (9, 2), (12, 1), (16, 2), (18, 1), (63, 1), (80, 2)], [], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (16, 1), (18, 1), (57, 2), (58, 1), (71, 1), (74, 2), (80, 2)], [], [], [], [(1, 2), (7, 1), (8, 1), (16, 1), (18, 1), (57, 1), (60, 1), (63, 1), (80, 2), (114, 1), (130, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1), (11, 2), (16, 1), (18, 1), (57, 1), (58, 1), (63, 1), (80, 2), (114, 1), (130, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (11, 2), (16, 1), (18, 1), (57, 2), (64, 1), (80, 2), (114, 1), (130, 2)], [], [], [], [], [], [], [(0, 2), (2, 1), (8, 2), (9, 1), (12, 2), (18, 1), (58, 1), (71, 1), (74, 2), (80, 2), (114, 2), (130, 1)], [(0, 2), (2, 1), (8, 2), (11, 1), (16, 2), (18, 1), (58, 1), (71, 1), (74, 2), (80, 2), (114, 2), (130, 1)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (8, 2), (16, 2), (18, 1), (58, 1), (71, 1), (74, 2), (80, 2), (114, 2), (130, 1)], [(0, 2), (5, 1), (16, 2), (18, 1), (58, 1), (71, 1), (74, 2), (80, 2), (114, 2), (130, 1)], [], [], [], [], [], [(6, 2), (8, 2), (11, 1), (18, 1), (57, 2), (58, 1), (63, 1), (64, 2), (66, 1), (71, 1), (74, 2), (80, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (8, 2), (18, 1), (58, 1), (60, 2), (65, 1), (71, 1), (74, 2), (80, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 2), (18, 1), (58, 1), (60, 2), (67, 1), (71, 1), (74, 2), (80, 2)], [(8, 2), (11, 1), (16, 2), (18, 1), (57, 2), (58, 1), (63, 1), (64, 2), (71, 1), (73, 1), (74, 2), (80, 2)], [(6, 2), (11, 1), (16, 2), (18, 1), (71, 1), (80, 2)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (51, 1), (57, 2), (58, 1), (63, 2), (71, 1), (74, 2)], [(1, 2), (3, 1), (4, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (16, 2), (57, 2), (58, 2), (60, 2), (63, 2), (67, 1), (71, 2), (74, 1), (114, 2), (121, 2), (130, 2), (314, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (12, 2), (44, 1), (57, 2), (58, 2), (63, 1), (71, 2), (74, 1), (114, 2), (130, 1)], [], [(1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (12, 2), (16, 1), (57, 2), (58, 2), (63, 1), (71, 2), (74, 1), (114, 2), (157, 1)], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (6, 2), (7, 1), (9, 1), (11, 1), (12, 2), (57, 2), (58, 1), (63, 1), (71, 2), (74, 1), (392, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (57, 2), (58, 2), (63, 1), (71, 2), (74, 1), (172, 2), (216, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 1), (8, 1), (57, 2), (58, 2), (63, 1), (71, 2), (74, 1), (233, 2), (274, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb74 : List (List (Nat × Nat)) := [[(2, 2), (3, 2), (4, 1), (15, 1), (16, 2), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 2), (3, 2), (4, 1), (15, 1), (16, 1), (18, 2), (63, 1), (67, 2), (73, 1), (121, 1), (137, 1)], [], [(2, 2), (3, 2), (4, 1), (15, 1), (16, 1), (18, 2), (57, 2), (63, 1), (67, 2), (73, 1), (121, 1), (137, 1), (172, 1)], [(2, 1), (4, 1), (15, 1), (16, 1), (18, 2), (57, 2), (63, 1), (67, 2), (73, 1), (121, 1), (137, 1), (233, 1)], [(2, 2), (6, 1), (12, 2), (15, 1), (16, 1), (18, 2), (57, 1), (63, 1), (67, 2), (73, 2), (121, 1), (137, 1)], [(2, 2), (3, 1), (6, 1), (12, 2), (15, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [], [(2, 2), (3, 1), (4, 2), (6, 1), (12, 2), (15, 1), (16, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 2), (6, 1), (12, 2), (15, 1), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 1), (3, 1), (6, 1), (12, 2), (15, 1), (18, 2), (24, 1), (63, 1), (67, 2), (121, 1), (137, 1)], [], [(2, 2), (3, 1), (4, 2), (6, 2), (12, 1), (15, 1), (16, 2), (18, 1), (63, 1), (67, 2), (73, 2), (77, 1), (121, 1), (137, 1)], [(2, 1), (3, 1), (6, 1), (12, 2), (15, 1), (16, 1), (18, 2), (63, 2), (67, 2), (73, 2), (121, 1), (137, 1)], [], [(2, 2), (3, 1), (4, 2), (6, 2), (12, 1), (15, 1), (16, 1), (18, 1), (20, 1), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 2), (6, 2), (12, 2), (15, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 1), (3, 1), (6, 1), (8, 1), (12, 2), (15, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [], [(4, 2), (6, 2), (12, 1), (15, 1), (16, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 2), (3, 1), (4, 2), (6, 2), (12, 1), (15, 1), (16, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [(2, 2), (6, 2), (12, 1), (15, 1), (16, 1), (18, 2), (63, 1), (67, 2), (121, 1), (137, 1)], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 1), (9, 2), (11, 1), (16, 1), (18, 1), (63, 1), (73, 2), (137, 2)], [], [], [], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (12, 2), (16, 2), (18, 1), (63, 1), (73, 2), (137, 2)], [], [], [(2, 2), (3, 1), (6, 1), (12, 2), (15, 1), (16, 1), (18, 1), (63, 1), (73, 2), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (11, 1), (16, 1), (18, 1), (63, 1), (73, 2), (137, 2)], [], [], [], [], [(3, 2), (6, 1), (12, 2), (15, 1), (16, 2), (18, 1), (67, 2), (73, 1), (121, 1), (137, 2)], [], [], [], [], [], [(1, 1), (2, 1), (4, 1), (7, 2), (12, 1), (16, 2), (18, 1), (57, 2), (63, 1), (117, 1), (137, 2)], [(1, 1), (2, 1), (3, 1), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (16, 2), (18, 1), (57, 2), (63, 1), (115, 1), (137, 2)], [(1, 1), (2, 2), (3, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (16, 2), (18, 1), (120, 1), (137, 2)], [], [], [], [(1, 2), (2, 1), (3, 2), (6, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (15, 1), (18, 1), (67, 2), (73, 1), (121, 1), (137, 2)], [], [], [], [(1, 2), (7, 1), (12, 2), (15, 1), (16, 2), (18, 1), (67, 2), (73, 1), (121, 1), (137, 2)], [(1, 2), (2, 1), (3, 2), (6, 1), (8, 2), (10, 1), (12, 2), (15, 1), (16, 2), (18, 1), (67, 2), (73, 1), (121, 1), (137, 2)], [], [], [], [(1, 2), (3, 2), (4, 1), (7, 1), (11, 2), (12, 2), (15, 1), (18, 1), (66, 1), (67, 2), (121, 1), (137, 2)], [(2, 2), (18, 1), (65, 1), (67, 2), (121, 1), (137, 2)], [(3, 2), (18, 1), (121, 1), (137, 2)], [], [], [], [(1, 2), (4, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (15, 1), (16, 2), (18, 1), (63, 1), (67, 2), (120, 2), (121, 1), (130, 1), (137, 2)], [(3, 2), (4, 1), (16, 2), (18, 1), (127, 1), (137, 2)], [], [(2, 1), (3, 2), (4, 2), (6, 2), (12, 1), (15, 1), (16, 2), (51, 1), (63, 2), (67, 2), (73, 2), (121, 1)], [(1, 1), (2, 1), (6, 2), (7, 2), (12, 2), (15, 1), (57, 2), (63, 2), (67, 2), (121, 1), (314, 1)], [(0, 2), (1, 2), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (15, 2), (44, 1), (63, 1), (67, 1), (73, 1), (121, 2)], [(1, 2), (2, 2), (6, 2), (7, 1), (11, 2), (15, 2), (16, 1), (63, 1), (67, 1), (99, 1), (121, 2)], [], [(1, 2), (2, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (15, 2), (63, 2), (67, 1), (120, 2), (121, 2), (392, 1)], [(1, 2), (2, 2), (6, 2), (12, 1), (15, 2), (57, 1), (63, 1), (67, 1), (121, 2), (172, 2), (216, 1)], [(1, 2), (3, 2), (6, 2), (12, 1), (15, 2), (57, 1), (63, 1), (67, 1), (121, 2), (233, 2), (274, 1)], [], [], [], [(3, 2), (4, 1), (6, 1), (12, 1), (16, 1), (57, 2), (73, 1), (114, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb75 : List (List (Nat × Nat)) := [[(2, 1), (4, 2), (6, 2), (8, 2), (11, 1), (13, 1), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(2, 1), (4, 2), (6, 2), (8, 2), (13, 1), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (68, 1), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 1), (2, 1), (4, 1), (6, 1), (8, 2), (11, 1), (13, 1), (15, 1), (18, 1), (20, 2), (60, 1), (63, 2), (65, 2), (68, 1), (114, 2), (117, 1), (127, 1), (291, 2)], [(0, 1), (4, 2), (6, 2), (8, 1), (11, 1), (13, 1), (14, 1), (15, 1), (16, 2), (60, 1), (63, 2), (65, 2), (68, 1), (114, 1), (117, 1), (127, 1), (172, 1), (291, 2)], [(0, 1), (4, 2), (6, 2), (8, 1), (11, 1), (13, 1), (14, 1), (15, 1), (16, 2), (60, 1), (63, 2), (65, 2), (68, 1), (114, 1), (117, 1), (127, 1), (233, 1), (291, 2)], [(0, 1), (2, 1), (4, 1), (6, 2), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (57, 2), (60, 1), (63, 2), (65, 2), (68, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 2), (2, 1), (4, 1), (6, 2), (8, 1), (11, 2), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 2), (2, 1), (6, 2), (8, 1), (13, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [], [(0, 2), (4, 1), (6, 2), (13, 2), (14, 1), (15, 1), (16, 2), (18, 1), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 2), (4, 1), (6, 2), (13, 2), (14, 1), (15, 1), (16, 2), (24, 1), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (8, 1), (14, 2), (15, 1), (16, 1), (18, 1), (20, 1), (57, 1), (60, 1), (63, 2), (65, 2), (68, 2), (75, 1), (114, 1), (117, 1), (127, 1), (291, 2)], [], [(0, 1), (2, 1), (4, 1), (6, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (65, 2), (68, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (8, 1), (11, 2), (14, 2), (15, 1), (16, 1), (18, 2), (20, 1), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [], [(0, 1), (2, 1), (4, 1), (11, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 1), (2, 1), (4, 1), (6, 2), (8, 1), (11, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [(0, 2), (2, 1), (6, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [], [], [(0, 1), (2, 1), (4, 1), (6, 2), (15, 1), (18, 1), (20, 2), (57, 1), (60, 1), (63, 2), (65, 2), (114, 1), (117, 1), (127, 1), (291, 2)], [], [], [], [(2, 2), (4, 1), (8, 1), (11, 2), (14, 2), (16, 1), (18, 1), (20, 2), (63, 1), (68, 2), (117, 1), (127, 2), (291, 2)], [], [], [], [(0, 1), (2, 1), (4, 1), (8, 1), (11, 2), (13, 2), (15, 1), (18, 1), (20, 2), (57, 2), (60, 1), (63, 1), (65, 2), (117, 1), (127, 2), (291, 2)], [], [], [], [], [(2, 1), (4, 2), (8, 1), (11, 2), (13, 2), (15, 1), (18, 1), (20, 2), (63, 1), (68, 2), (117, 1), (127, 2), (291, 2)], [], [(0, 1), (2, 1), (4, 1), (6, 2), (8, 2), (11, 2), (12, 1), (13, 2), (14, 2), (16, 1), (18, 1), (20, 2), (63, 1), (68, 2), (117, 1), (127, 2), (291, 2)], [(0, 1), (2, 1), (4, 1), (8, 1), (11, 2), (13, 2), (16, 1), (18, 1), (20, 2), (63, 1), (68, 2), (117, 1), (127, 2), (291, 2)], [], [], [], [], [], [(0, 1), (4, 2), (6, 2), (8, 2), (11, 1), (13, 1), (57, 1), (60, 1), (63, 1), (114, 1), (127, 2)], [], [], [(8, 2), (13, 1), (57, 2), (63, 1), (117, 1), (127, 2)], [], [], [(2, 1), (4, 2), (6, 2), (13, 1), (14, 2), (16, 1), (18, 1), (20, 2), (57, 2), (63, 1), (114, 1), (127, 2), (172, 2), (174, 1)], [(2, 1), (4, 2), (6, 2), (13, 1), (14, 2), (16, 1), (18, 1), (20, 2), (57, 2), (63, 1), (114, 1), (127, 2), (233, 2), (236, 1)], [], [], [(0, 1), (4, 2), (6, 2), (8, 2), (11, 1), (14, 1), (15, 1), (16, 2), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (114, 1), (127, 2)], [], [], [], [], [(0, 1), (4, 2), (6, 2), (15, 1), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (114, 1), (127, 2)], [(0, 1), (4, 2), (8, 2), (12, 2), (14, 1), (15, 1), (16, 2), (17, 1), (57, 1), (60, 1), (63, 1), (65, 2), (68, 1), (114, 1), (127, 2)], [], [(0, 1), (2, 2), (6, 2), (8, 2), (11, 1), (14, 1), (15, 1), (16, 2), (57, 1), (60, 1), (63, 1), (65, 2), (66, 1), (114, 1), (127, 2)], [], [], [(0, 1), (4, 2), (6, 2), (11, 1), (15, 1), (16, 2), (57, 1), (60, 1), (63, 1), (65, 2), (73, 1), (114, 1), (127, 2)], [(0, 1), (4, 2), (6, 2), (11, 1), (57, 2), (71, 1), (114, 1), (127, 2)], [], [(15, 1), (16, 2), (57, 2), (60, 1), (63, 1), (65, 2), (127, 2), (130, 1)], [], [], [(0, 2), (2, 2), (4, 2), (6, 1), (8, 2), (11, 2), (12, 1), (13, 2), (14, 2), (15, 1), (16, 1), (17, 2), (18, 2), (20, 1), (51, 1), (57, 1), (60, 1), (65, 2), (68, 2), (114, 1), (117, 2), (291, 1)], [(0, 1), (2, 2), (6, 1), (12, 1), (13, 1), (14, 2), (15, 1), (16, 1), (17, 2), (18, 2), (20, 1), (60, 1), (65, 2), (114, 1), (117, 2), (291, 1), (314, 1)], [(0, 2), (2, 1), (6, 1), (15, 2), (16, 2), (18, 1), (20, 2), (44, 1), (57, 2), (60, 2), (65, 1), (68, 1), (114, 2), (117, 1), (291, 2)], [(0, 2), (2, 1), (6, 2), (8, 2), (11, 1), (12, 2), (14, 1), (15, 2), (16, 2), (18, 1), (20, 2), (57, 2), (60, 2), (65, 1), (99, 1), (114, 2), (117, 1), (291, 2)], [(0, 1), (2, 1), (4, 1), (6, 2), (15, 2), (16, 2), (18, 1), (20, 2), (60, 2), (65, 1), (114, 1), (117, 1), (157, 1), (291, 2)], [], [(0, 1), (2, 2), (6, 1), (8, 1), (14, 2), (15, 2), (18, 2), (20, 1), (60, 2), (65, 1), (114, 2), (117, 1), (172, 2), (216, 1), (291, 2)], [(0, 1), (2, 2), (6, 2), (12, 2), (15, 2), (18, 2), (20, 1), (60, 2), (65, 1), (114, 2), (117, 1), (233, 2), (274, 1), (291, 2)], [], [], [], [], [(2, 2), (4, 1), (8, 1), (11, 1), (13, 1), (14, 1), (16, 2), (18, 2), (20, 1), (57, 2), (68, 1), (293, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb76 : List (List (Nat × Nat)) := [[(0, 2), (3, 1), (12, 1), (18, 2), (19, 1), (57, 2), (58, 2), (63, 2), (66, 1), (72, 2), (114, 2), (137, 1), (172, 1), (173, 2)], [(0, 2), (3, 1), (6, 2), (12, 1), (18, 2), (19, 1), (57, 2), (58, 2), (63, 2), (66, 2), (72, 2), (114, 2), (137, 1), (172, 1), (173, 2)], [(0, 2), (3, 1), (6, 2), (12, 1), (18, 2), (19, 1), (57, 1), (58, 2), (63, 2), (66, 2), (72, 2), (137, 1), (172, 1), (173, 2)], [], [(0, 2), (3, 1), (6, 1), (12, 1), (19, 1), (58, 2), (63, 2), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2), (233, 1)], [(0, 2), (3, 1), (12, 1), (18, 1), (19, 1), (57, 2), (58, 2), (63, 2), (66, 1), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2)], [(0, 2), (3, 2), (6, 2), (12, 1), (18, 1), (19, 1), (57, 1), (58, 2), (63, 2), (66, 2), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2)], [(0, 2), (3, 1), (12, 1), (18, 1), (19, 1), (57, 1), (58, 2), (63, 2), (66, 2), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2)], [(0, 2), (3, 1), (8, 2), (12, 1), (13, 1), (18, 1), (19, 1), (57, 1), (58, 2), (63, 2), (66, 2), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2)], [], [(0, 2), (3, 1), (6, 1), (12, 1), (18, 2), (19, 1), (24, 1), (58, 2), (63, 2), (72, 2), (114, 2), (137, 1), (173, 2)], [(0, 2), (3, 1), (12, 1), (18, 1), (19, 1), (57, 1), (58, 2), (63, 2), (66, 1), (72, 2), (75, 1), (114, 2), (137, 1), (172, 2), (173, 2)], [(1, 2), (3, 1), (7, 1), (8, 2), (13, 1), (18, 2), (57, 1), (58, 2), (63, 2), (66, 1), (72, 2), (77, 1), (114, 2), (137, 1), (172, 2), (173, 2)], [(0, 2), (3, 1), (6, 1), (12, 1), (19, 1), (58, 2), (66, 2), (72, 2), (114, 2), (137, 1), (173, 2)], [(0, 2), (3, 1), (6, 2), (12, 1), (18, 2), (19, 1), (57, 1), (58, 2), (63, 2), (66, 2), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2)], [(0, 2), (3, 1), (6, 2), (7, 1), (8, 2), (12, 1), (13, 1), (15, 2), (18, 2), (20, 1), (57, 1), (58, 2), (63, 2), (66, 2), (72, 2), (114, 2), (137, 1), (172, 2), (173, 2)], [], [(0, 2), (3, 1), (8, 1), (12, 1), (19, 1), (58, 2), (63, 2), (72, 2), (114, 2), (137, 1), (173, 2)], [], [], [(0, 2), (3, 1), (6, 1), (12, 1), (19, 1), (58, 2), (63, 2), (72, 2), (114, 2), (137, 1), (173, 2)], [], [], [], [], [], [(7, 1), (18, 2), (58, 1), (63, 1), (66, 1), (114, 1), (137, 2), (172, 2), (173, 2)], [], [], [], [(0, 2), (3, 1), (12, 1), (18, 1), (19, 1), (57, 2), (58, 2), (63, 1), (66, 2), (72, 2), (114, 1), (137, 2), (172, 2), (173, 2)], [], [(6, 1), (18, 1), (19, 1), (58, 1), (63, 1), (66, 1), (114, 1), (137, 2), (172, 2), (173, 2)], [], [], [], [(0, 2), (3, 1), (8, 1), (12, 1), (13, 2), (18, 1), (19, 1), (58, 1), (63, 1), (66, 1), (114, 1), (137, 2), (172, 2), (173, 2)], [], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 2), (21, 1), (57, 1), (58, 1), (63, 1), (114, 1), (137, 2), (172, 1), (173, 2)], [], [], [(12, 1), (18, 2), (58, 1), (63, 1), (66, 2), (72, 2), (114, 1), (137, 2), (172, 1)], [], [], [(6, 1), (18, 2), (58, 1), (63, 1), (66, 1), (114, 1), (137, 2), (172, 1)], [], [], [(6, 1), (18, 2), (57, 1), (63, 1), (66, 1), (115, 1), (137, 2), (172, 1)], [], [(1, 2), (3, 1), (8, 1), (13, 2), (15, 1), (18, 2), (19, 1), (20, 2), (58, 1), (63, 1), (66, 1), (114, 1), (137, 2), (172, 1), (173, 2), (174, 1)], [], [(1, 2), (6, 2), (7, 1), (18, 1), (57, 2), (58, 1), (114, 1), (137, 2), (173, 2), (181, 1)], [], [], [(0, 2), (1, 1), (6, 1), (7, 2), (12, 1), (18, 1), (19, 1), (58, 1), (63, 1), (66, 2), (72, 2), (114, 1), (137, 2), (172, 1)], [], [(0, 2), (3, 1), (12, 1), (18, 1), (19, 1), (58, 1), (63, 1), (66, 2), (72, 2), (114, 1), (137, 2), (172, 1)], [], [(0, 2), (3, 1), (7, 2), (8, 1), (12, 1), (13, 2), (15, 1), (18, 1), (19, 1), (58, 1), (63, 1), (66, 2), (72, 2), (114, 1), (137, 2), (172, 1)], [], [(0, 2), (3, 1), (6, 2), (8, 2), (12, 1), (22, 1), (57, 1), (58, 1), (63, 1), (66, 1), (72, 2), (114, 1), (137, 2)], [], [(0, 2), (3, 1), (6, 1), (7, 2), (12, 1), (18, 1), (19, 1), (58, 1), (63, 1), (65, 1), (66, 1), (72, 2), (114, 1), (137, 2), (172, 1)], [], [(0, 2), (3, 1), (6, 1), (7, 2), (8, 1), (12, 1), (13, 2), (18, 1), (19, 1), (58, 1), (63, 1), (66, 1), (72, 2), (73, 1), (114, 1), (137, 2), (172, 1)], [], [(57, 2), (80, 1), (114, 1), (137, 2)], [(0, 2), (3, 1), (6, 1), (7, 2), (8, 1), (12, 1), (13, 2), (18, 1), (19, 1), (57, 1), (58, 1), (63, 1), (66, 1), (72, 2), (130, 1), (137, 2), (172, 1)], [], [], [(0, 2), (1, 2), (3, 2), (6, 2), (7, 1), (12, 1), (19, 1), (51, 1), (57, 1), (72, 2), (172, 1), (173, 1)], [(0, 2), (3, 1), (12, 1), (18, 1), (19, 1), (57, 1), (72, 2), (173, 1), (314, 1)], [(0, 1), (3, 2), (6, 2), (12, 2), (19, 1), (44, 1), (57, 1), (66, 1), (72, 1), (173, 2)], [(0, 2), (3, 1), (6, 1), (8, 2), (12, 1), (13, 1), (19, 1), (57, 1), (72, 1), (99, 1), (173, 2)], [(0, 1), (3, 2), (12, 2), (19, 1), (57, 2), (72, 1), (114, 2), (157, 1), (173, 2)], [(0, 1), (3, 2), (6, 2), (8, 1), (12, 2), (13, 2), (19, 2), (57, 2), (72, 1), (173, 1), (392, 1)], [], [(0, 2), (3, 1), (6, 2), (8, 2), (12, 1), (13, 1), (18, 2), (19, 1), (66, 2), (72, 1), (172, 2), (173, 2), (233, 2), (274, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb77 : List (List (Nat × Nat)) := [[(0, 2), (5, 1), (6, 1), (8, 2), (10, 1), (18, 2), (24, 2), (25, 2), (57, 1), (63, 1), (64, 1), (114, 2), (137, 1), (233, 1), (234, 2)], [(0, 2), (5, 1), (6, 1), (8, 1), (10, 1), (18, 2), (24, 2), (25, 2), (57, 1), (63, 2), (64, 1), (114, 2), (137, 1), (233, 1), (234, 2)], [(2, 2), (5, 1), (8, 2), (10, 1), (18, 2), (24, 2), (25, 2), (63, 2), (64, 1), (137, 1), (233, 1), (234, 2)], [(0, 1), (2, 1), (5, 1), (6, 1), (10, 1), (18, 2), (25, 2), (57, 2), (64, 1), (114, 2), (137, 1), (172, 1), (233, 2), (234, 2)], [], [(0, 2), (5, 1), (6, 1), (8, 2), (10, 1), (18, 2), (24, 1), (25, 2), (57, 1), (63, 1), (64, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(5, 1), (6, 1), (8, 1), (10, 1), (18, 2), (24, 1), (25, 2), (63, 2), (64, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(2, 2), (5, 1), (6, 1), (8, 2), (10, 1), (18, 2), (24, 1), (25, 2), (63, 2), (64, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(2, 2), (5, 1), (8, 2), (10, 1), (12, 1), (18, 2), (24, 1), (25, 2), (63, 2), (64, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(0, 1), (2, 1), (5, 1), (6, 1), (10, 1), (24, 2), (25, 2), (57, 2), (64, 1), (114, 2), (137, 1), (234, 2)], [], [(2, 2), (5, 1), (6, 1), (8, 2), (10, 1), (18, 1), (24, 2), (25, 2), (63, 1), (64, 1), (75, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(2, 2), (5, 1), (6, 1), (8, 2), (10, 1), (18, 1), (24, 2), (25, 2), (63, 1), (64, 1), (77, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [], [(2, 2), (5, 1), (6, 1), (8, 1), (10, 1), (18, 2), (24, 2), (25, 2), (63, 2), (64, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(2, 2), (5, 1), (6, 1), (8, 1), (10, 1), (18, 1), (20, 1), (24, 2), (25, 2), (63, 2), (64, 1), (114, 2), (137, 1), (233, 2), (234, 2)], [(0, 1), (2, 1), (5, 1), (6, 2), (8, 2), (10, 1), (18, 2), (25, 2), (57, 2), (64, 1), (114, 2), (137, 1), (234, 2)], [], [(0, 2), (5, 1), (6, 1), (10, 1), (18, 2), (25, 2), (57, 2), (64, 1), (114, 2), (137, 1), (234, 2)], [(0, 1), (2, 1), (5, 1), (6, 1), (10, 1), (18, 2), (25, 2), (57, 2), (64, 1), (114, 2), (137, 1), (234, 2)], [], [], [], [], [], [], [], [(0, 2), (5, 1), (6, 2), (8, 1), (10, 1), (18, 1), (24, 2), (25, 2), (57, 1), (63, 1), (64, 1), (114, 1), (137, 2), (233, 2), (234, 2)], [], [], [], [], [], [(0, 2), (3, 1), (6, 2), (8, 2), (9, 2), (10, 1), (18, 1), (24, 1), (57, 1), (63, 1), (64, 1), (114, 1), (137, 2), (233, 2), (234, 2)], [], [(0, 2), (2, 1), (6, 2), (8, 1), (10, 1), (18, 1), (24, 1), (57, 1), (63, 1), (64, 1), (114, 1), (137, 2), (233, 2), (234, 2)], [], [(0, 2), (2, 1), (8, 1), (9, 2), (10, 1), (12, 2), (14, 1), (18, 1), (24, 1), (57, 1), (63, 1), (64, 1), (114, 1), (137, 2), (233, 2), (234, 2)], [(0, 1), (2, 2), (6, 2), (9, 2), (10, 1), (21, 1), (57, 2), (64, 1), (114, 1), (137, 2), (233, 1), (234, 2)], [], [], [], [(0, 2), (5, 1), (6, 2), (8, 1), (9, 1), (18, 1), (24, 2), (25, 2), (57, 1), (63, 2), (114, 1), (137, 2), (233, 1)], [], [], [(0, 2), (5, 1), (6, 2), (8, 2), (18, 1), (24, 2), (25, 2), (57, 1), (63, 1), (64, 1), (114, 1), (137, 2), (233, 1)], [], [], [(0, 1), (2, 1), (3, 2), (5, 1), (8, 1), (9, 1), (18, 1), (24, 2), (25, 2), (57, 2), (63, 1), (120, 1), (137, 2), (233, 1)], [], [(0, 2), (2, 1), (6, 2), (8, 1), (10, 1), (18, 2), (20, 2), (24, 2), (25, 2), (57, 1), (63, 1), (64, 1), (114, 1), (137, 2), (233, 1), (234, 2), (236, 1)], [(2, 2), (3, 2), (5, 1), (6, 2), (9, 1), (18, 1), (24, 1), (25, 2), (114, 1), (137, 2), (172, 2), (181, 1)], [], [], [], [(0, 2), (5, 1), (6, 2), (8, 2), (18, 1), (24, 1), (57, 1), (63, 2), (114, 1), (137, 2), (233, 1)], [], [(0, 2), (2, 1), (6, 2), (8, 1), (10, 1), (18, 1), (24, 1), (57, 1), (63, 2), (114, 1), (137, 2), (233, 1)], [], [(0, 2), (2, 1), (8, 1), (12, 2), (17, 1), (18, 1), (24, 1), (57, 1), (63, 2), (114, 1), (137, 2), (233, 1)], [(0, 1), (2, 2), (6, 2), (22, 1), (57, 2), (63, 1), (114, 1), (137, 2)], [], [], [(0, 2), (2, 1), (6, 2), (8, 2), (18, 1), (24, 1), (57, 1), (63, 1), (67, 1), (114, 1), (137, 2), (233, 1)], [], [(0, 2), (2, 1), (8, 2), (12, 2), (18, 1), (24, 1), (57, 1), (63, 1), (71, 1), (114, 1), (137, 2), (233, 1)], [(0, 1), (2, 2), (6, 2), (8, 1), (57, 2), (80, 1), (114, 1), (137, 2)], [], [(0, 1), (2, 2), (6, 1), (8, 1), (12, 2), (18, 1), (24, 1), (57, 2), (63, 1), (127, 1), (137, 2), (233, 1)], [], [(0, 2), (2, 2), (5, 2), (6, 2), (10, 2), (12, 1), (17, 2), (25, 1), (51, 1), (57, 1), (64, 2), (233, 1), (234, 1)], [(0, 2), (2, 2), (5, 2), (6, 2), (10, 2), (12, 1), (17, 2), (24, 1), (25, 1), (57, 1), (64, 2), (234, 1), (314, 1)], [(0, 2), (2, 2), (5, 2), (6, 2), (9, 1), (10, 1), (12, 1), (14, 2), (25, 1), (44, 1), (57, 1), (63, 1), (64, 1), (234, 2)], [(0, 2), (2, 2), (5, 2), (8, 1), (10, 1), (25, 1), (57, 1), (64, 1), (99, 1), (234, 2)], [(0, 1), (5, 2), (9, 1), (10, 1), (12, 1), (14, 2), (25, 1), (57, 2), (64, 1), (114, 2), (157, 1), (234, 2)], [(0, 2), (3, 1), (5, 1), (9, 2), (10, 2), (12, 2), (25, 2), (57, 1), (64, 2), (114, 1), (120, 2), (234, 1), (392, 1)], [(2, 1), (5, 2), (6, 2), (8, 2), (9, 1), (10, 1), (12, 1), (14, 2), (24, 2), (25, 1), (63, 2), (64, 1), (172, 2), (216, 1), (233, 2), (234, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb78 : List (List (Nat × Nat)) := [[(0, 1), (1, 1), (3, 2), (6, 2), (7, 2), (9, 1), (12, 2), (13, 1), (18, 2), (19, 1), (24, 1), (25, 2), (34, 1), (60, 1), (63, 2), (65, 2), (72, 1), (121, 1), (127, 2), (173, 2), (181, 1)], [(0, 2), (1, 2), (3, 2), (6, 1), (7, 1), (9, 1), (12, 1), (13, 1), (15, 1), (18, 2), (19, 1), (24, 2), (25, 1), (60, 1), (64, 1), (65, 2), (71, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (1, 1), (3, 2), (6, 2), (7, 2), (9, 1), (12, 2), (13, 1), (15, 2), (18, 2), (19, 1), (24, 1), (25, 2), (34, 1), (57, 1), (63, 1), (72, 1), (121, 1), (173, 2), (181, 1)], [(3, 2), (9, 1), (13, 1), (15, 1), (18, 1), (19, 2), (24, 1), (25, 2), (34, 1), (57, 1), (60, 2), (63, 1), (65, 1), (71, 1), (181, 1)], [(0, 1), (1, 2), (3, 2), (7, 1), (9, 1), (12, 2), (13, 1), (15, 1), (18, 2), (19, 1), (34, 1), (57, 1), (60, 2), (63, 1), (64, 2), (65, 1), (71, 1), (72, 1), (173, 2), (181, 1), (234, 1)], [(0, 1), (1, 1), (3, 1), (6, 2), (7, 2), (9, 2), (12, 2), (13, 2), (15, 2), (18, 1), (19, 2), (24, 1), (25, 2), (57, 1), (60, 2), (64, 2), (65, 1), (71, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(1, 1), (3, 1), (7, 2), (9, 2), (13, 2), (18, 1), (19, 2), (34, 1), (57, 1), (60, 1), (63, 2), (64, 1), (65, 2), (71, 2), (117, 1), (127, 2), (173, 1), (181, 2), (233, 1), (234, 2), (291, 2)], [(0, 1), (1, 1), (3, 1), (6, 2), (7, 2), (9, 2), (12, 2), (13, 2), (15, 2), (18, 1), (19, 2), (24, 1), (25, 2), (60, 2), (63, 1), (64, 2), (65, 1), (71, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 1), (3, 1), (6, 1), (7, 2), (9, 2), (12, 2), (15, 2), (18, 1), (19, 2), (24, 1), (25, 2), (60, 2), (63, 1), (64, 2), (65, 1), (71, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 1), (3, 1), (6, 1), (7, 2), (9, 2), (12, 2), (13, 2), (15, 2), (18, 2), (19, 2), (24, 1), (25, 2), (60, 2), (63, 1), (64, 2), (65, 1), (71, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 1), (3, 1), (6, 1), (7, 2), (9, 2), (12, 2), (13, 2), (15, 2), (18, 1), (19, 2), (24, 2), (25, 2), (60, 2), (63, 1), (64, 2), (65, 1), (71, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [(1, 2), (3, 2), (6, 2), (7, 1), (9, 1), (18, 1), (19, 2), (34, 1), (60, 1), (63, 1), (64, 2), (65, 2), (117, 2), (121, 1), (173, 2), (181, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (3, 2), (6, 1), (7, 1), (9, 1), (12, 1), (13, 2), (15, 1), (18, 1), (19, 2), (24, 2), (25, 1), (34, 2), (57, 1), (63, 2), (64, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (3, 2), (6, 1), (9, 1), (12, 2), (24, 2), (25, 1), (34, 2), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (65, 1), (72, 1), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(3, 2), (6, 2), (7, 1), (9, 1), (15, 2), (18, 1), (19, 2), (34, 1), (57, 1), (64, 2), (117, 2), (127, 1), (173, 2), (181, 1), (233, 2), (234, 1), (291, 1)], [(3, 2), (9, 1), (15, 2), (34, 1), (57, 1), (64, 2), (117, 2), (127, 1), (173, 2), (181, 1), (233, 2), (234, 1), (291, 1)], [(1, 2), (7, 1), (15, 2), (18, 1), (19, 2), (24, 2), (25, 1), (34, 1), (57, 1), (64, 2), (117, 2), (127, 1), (173, 2), (181, 1), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (3, 2), (6, 1), (7, 1), (9, 1), (12, 1), (13, 2), (15, 1), (18, 1), (19, 2), (24, 2), (25, 1), (34, 2), (57, 2), (60, 2), (63, 1), (64, 1), (65, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 2), (1, 2), (3, 2), (6, 1), (7, 1), (9, 1), (12, 1), (18, 1), (19, 2), (24, 1), (25, 2), (34, 2), (57, 2), (60, 2), (63, 1), (64, 1), (65, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (3, 2), (6, 2), (9, 1), (12, 2), (13, 2), (24, 2), (25, 1), (34, 2), (57, 2), (60, 2), (63, 1), (64, 1), (65, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 2), (1, 2), (3, 2), (6, 2), (7, 1), (12, 1), (13, 2), (14, 1), (18, 1), (19, 2), (24, 1), (25, 2), (34, 2), (57, 2), (60, 2), (63, 1), (64, 1), (65, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 2), (1, 2), (3, 2), (6, 2), (7, 1), (12, 1), (19, 2), (21, 1), (24, 1), (25, 2), (34, 2), (57, 2), (60, 2), (63, 1), (64, 1), (65, 1), (72, 2), (117, 1), (121, 2), (173, 2), (181, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (1, 1), (3, 1), (7, 2), (9, 2), (12, 2), (15, 2), (18, 2), (19, 1), (24, 1), (25, 2), (34, 1), (57, 2), (64, 2), (71, 1), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (3, 1), (6, 2), (7, 1), (9, 2), (12, 1), (15, 1), (18, 2), (19, 1), (24, 2), (25, 1), (57, 1), (60, 1), (63, 2), (65, 2), (71, 1), (72, 2), (121, 2), (127, 1), (173, 1), (181, 2)], [(1, 1), (3, 1), (6, 1), (7, 2), (9, 2), (12, 1), (15, 1), (24, 2), (25, 1), (57, 1), (60, 1), (63, 2), (65, 2), (71, 1), (72, 2), (121, 2), (127, 1), (173, 1), (181, 2)], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 1), (12, 1), (15, 1), (18, 2), (19, 1), (57, 1), (60, 1), (63, 2), (65, 2), (71, 1), (72, 2), (121, 2), (127, 1), (173, 1), (181, 2)], [(0, 1), (1, 1), (3, 1), (6, 2), (7, 2), (9, 2), (12, 2), (13, 1), (15, 2), (18, 2), (19, 1), (24, 1), (25, 2), (34, 1), (57, 1), (60, 1), (63, 1), (64, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 2), (3, 1), (6, 2), (9, 2), (12, 1), (24, 1), (25, 2), (34, 1), (57, 1), (60, 1), (63, 1), (64, 2), (65, 2), (72, 2), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 1), (1, 1), (3, 1), (6, 2), (7, 2), (9, 2), (12, 2), (18, 2), (19, 1), (24, 2), (25, 1), (34, 1), (57, 1), (60, 1), (63, 1), (65, 2), (72, 1), (117, 2), (121, 1), (173, 1), (181, 2), (233, 2), (234, 1), (291, 1)], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 1), (9, 2), (12, 1), (13, 1), (15, 1), (18, 2), (19, 1), (24, 2), (25, 1), (60, 1), (65, 2), (71, 1), (72, 2), (117, 1), (121, 2), (173, 1), (181, 2)], [(1, 1), (3, 1), (6, 1), (7, 2), (9, 2), (15, 2), (24, 2), (25, 1), (58, 2), (60, 2), (65, 1), (71, 1), (115, 1), (121, 2), (173, 1), (181, 2)], [(0, 2), (1, 2), (6, 1), (7, 1), (12, 1), (15, 2), (18, 2), (19, 1), (60, 2), (65, 1), (71, 1), (72, 2), (120, 1), (121, 2), (173, 1), (181, 2)], [(3, 1), (9, 2), (13, 1), (15, 2), (24, 2), (25, 1), (60, 2), (65, 1), (174, 1), (181, 2)], [(0, 2), (1, 1), (3, 1), (7, 2), (9, 2), (12, 1), (13, 1), (15, 2), (18, 2), (19, 1), (60, 2), (64, 1), (65, 1), (72, 2), (173, 1), (181, 2), (234, 2), (236, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [(6, 2), (13, 2), (15, 2), (18, 2), (19, 1), (34, 2), (51, 1), (57, 2), (60, 1), (63, 2), (65, 2), (71, 2)], [(0, 2), (6, 2), (12, 1), (13, 1), (15, 1), (18, 1), (19, 2), (24, 2), (25, 1), (34, 2), (57, 2), (63, 2), (64, 2), (71, 1), (72, 2), (117, 2), (121, 1), (233, 2), (234, 1), (291, 1), (314, 1)], [], [], [], [], [], [], [], [(0, 1), (1, 1), (7, 2), (12, 2), (15, 1), (24, 1), (25, 2), (34, 2), (64, 1), (71, 1), (72, 1), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [], [(0, 1), (1, 1), (6, 2), (7, 2), (12, 2), (15, 2), (24, 1), (25, 2), (34, 2), (57, 1), (60, 1), (63, 2), (64, 1), (65, 2), (71, 1), (72, 1), (114, 1), (117, 1), (121, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (3, 1), (6, 1), (9, 2), (12, 2), (13, 1), (15, 2), (24, 1), (25, 2), (34, 2), (57, 1), (60, 1), (63, 2), (64, 2), (65, 2), (72, 1), (117, 2), (120, 2), (121, 2), (233, 2), (234, 1), (291, 1), (293, 1)], [(0, 2), (1, 2), (6, 1), (7, 1), (12, 1), (18, 1), (19, 2), (24, 1), (25, 2), (34, 2), (57, 1), (60, 2), (63, 2), (64, 1), (65, 1), (72, 2), (117, 1), (121, 2), (172, 1), (173, 2), (233, 1), (234, 2), (291, 2)], [(0, 1), (6, 1), (12, 2), (24, 2), (25, 1), (34, 2), (57, 1), (60, 2), (63, 2), (64, 2), (65, 1), (72, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb79 : List (List (Nat × Nat)) := [[], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 2), (7, 2), (9, 2), (11, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1), (66, 2), (68, 1), (73, 1)], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 2), (7, 2), (9, 2), (11, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1), (66, 2), (68, 1), (130, 1)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (9, 1), (11, 1), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1), (66, 1), (68, 1), (73, 1), (115, 2), (130, 1), (173, 1)], [(1, 1), (3, 1), (4, 2), (9, 1), (10, 2), (11, 1), (15, 2), (16, 1), (22, 1), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1), (65, 2), (66, 2), (68, 1), (73, 1), (115, 2), (130, 1), (234, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (5, 1), (7, 2), (9, 1), (14, 2), (19, 2), (22, 2), (25, 2), (34, 2), (65, 1), (66, 1), (68, 2), (73, 2), (115, 1), (130, 2)], [], [], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (5, 1), (7, 2), (9, 1), (14, 2), (19, 2), (22, 2), (25, 2), (34, 2), (57, 2), (65, 1), (66, 1), (68, 2), (73, 2), (75, 1), (115, 1), (130, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (5, 1), (9, 1), (12, 2), (15, 1), (16, 2), (19, 1), (22, 2), (25, 2), (34, 2), (57, 2), (63, 1), (64, 2), (66, 1), (73, 2), (77, 1), (115, 1), (130, 2)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (5, 1), (7, 2), (9, 1), (14, 2), (19, 2), (22, 2), (25, 2), (34, 2), (57, 2), (63, 1), (65, 1), (66, 1), (68, 2), (73, 2), (115, 1), (130, 2)], [], [], [], [], [], [], [], [], [], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (11, 2), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 2), (63, 1), (64, 2), (66, 1), (115, 1), (130, 2)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (11, 2), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2), (66, 1), (73, 2)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 2), (9, 1), (11, 2), (14, 1), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2), (66, 1), (68, 2)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 2), (9, 1), (11, 2), (14, 1), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (9, 1), (11, 2), (14, 2), (15, 2), (16, 1), (22, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2), (65, 2), (66, 1)], [], [], [], [(0, 1), (1, 2), (3, 2), (4, 1), (5, 2), (7, 2), (9, 2), (11, 2), (14, 2), (22, 1), (25, 1), (34, 2), (58, 2), (65, 1), (66, 1), (73, 2), (115, 1), (130, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (7, 1), (11, 2), (14, 1), (19, 1), (22, 1), (25, 1), (34, 2), (58, 2), (65, 1), (115, 1), (130, 2)], [(0, 1), (1, 1), (3, 2), (4, 2), (5, 2), (7, 2), (9, 2), (11, 2), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (58, 2), (66, 1), (115, 1), (130, 2)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (11, 2), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (65, 1), (66, 1), (68, 2), (73, 2)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (11, 2), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (66, 1), (73, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (7, 1), (9, 1), (11, 2), (12, 1), (19, 1), (22, 1), (25, 1), (34, 2), (65, 1), (68, 2)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (11, 2), (14, 2), (15, 1), (16, 2), (22, 1), (25, 1), (34, 2), (66, 1), (68, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (7, 2), (11, 2), (14, 1), (15, 1), (16, 2), (21, 1), (22, 1), (25, 1), (34, 2)], [(0, 1), (2, 1), (5, 1), (9, 2), (11, 2), (15, 1), (16, 2), (19, 2), (22, 2), (25, 2), (34, 2), (57, 1), (63, 2), (64, 1), (66, 2), (115, 2), (130, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 1), (7, 2), (9, 1), (15, 1), (16, 2), (19, 2), (22, 2), (25, 2), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1), (66, 2), (73, 1)], [(5, 1), (14, 1), (15, 1), (16, 2), (19, 1), (22, 2), (25, 2), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 1), (7, 2), (9, 1), (19, 2), (22, 2), (25, 2), (34, 2), (57, 1), (58, 2), (63, 2), (64, 1), (65, 1), (66, 2)], [], [], [], [], [], [], [], [], [], [(0, 1), (2, 1), (5, 1), (11, 2), (14, 2), (15, 1), (16, 2), (19, 1), (22, 2), (25, 2), (58, 1), (65, 2), (66, 2), (73, 1), (115, 2), (130, 1)], [(0, 1), (2, 1), (5, 1), (9, 2), (11, 2), (15, 1), (16, 2), (19, 1), (22, 2), (25, 2), (58, 1), (65, 2), (66, 2), (68, 1), (115, 2), (130, 1)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (9, 2), (11, 2), (15, 1), (16, 2), (19, 1), (22, 2), (25, 2), (58, 1), (65, 2), (115, 2), (130, 1)], [(0, 1), (2, 1), (5, 1), (9, 2), (11, 2), (14, 2), (19, 1), (22, 2), (58, 1), (66, 2), (115, 2), (130, 1)], [(0, 2), (5, 1), (9, 1), (15, 1), (16, 2), (19, 1), (22, 2), (25, 2), (65, 2), (73, 1)], [(0, 2), (2, 1), (7, 2), (9, 1), (10, 1), (14, 2), (19, 1), (22, 2), (66, 2), (73, 1)], [(0, 2), (5, 1), (9, 1), (11, 2), (15, 1), (19, 1), (22, 2), (25, 2), (65, 2), (68, 1)], [(0, 2), (2, 1), (9, 1), (11, 2), (12, 2), (17, 1), (19, 1), (22, 2), (66, 2), (68, 1)], [], [], [], [], [], [], [], [], [], [], [(0, 1), (1, 2), (2, 1), (5, 1), (7, 1), (9, 2), (11, 2), (12, 1), (15, 1), (16, 2), (17, 2), (19, 2), (25, 2), (34, 1), (51, 1), (57, 2), (63, 1), (64, 2), (65, 1), (66, 2), (68, 2), (73, 2), (115, 1), (130, 2)], [], [(1, 2), (3, 2), (4, 1), (7, 1), (14, 1), (15, 1), (16, 2), (19, 2), (44, 1), (57, 1), (63, 2), (64, 1), (65, 2), (66, 1), (68, 1), (73, 1), (115, 2), (130, 1)], [], [], [], [], [], [(0, 2), (1, 2), (5, 1), (7, 1), (9, 2), (11, 2), (12, 1), (14, 1), (15, 2), (16, 1), (17, 2), (19, 2), (25, 2), (34, 1), (57, 1), (58, 2), (73, 1), (75, 2), (470, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (11, 1), (14, 1), (15, 2), (16, 1), (19, 1), (34, 2), (58, 1), (63, 1), (64, 2), (65, 2), (115, 2), (130, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (11, 1), (14, 1), (15, 2), (16, 1), (19, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2), (65, 2), (73, 1), (114, 1), (115, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (9, 2), (11, 1), (14, 2), (15, 2), (16, 1), (19, 2), (25, 2), (34, 1), (58, 2), (68, 1), (293, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (9, 1), (11, 2), (14, 2), (15, 2), (16, 1), (19, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2), (65, 2), (66, 1), (172, 1), (173, 2)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (9, 1), (10, 1), (11, 2), (14, 1), (15, 1), (16, 2), (19, 1), (25, 1), (34, 2), (57, 2), (58, 1), (63, 1), (64, 2), (233, 1), (234, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb80 : List (List (Nat × Nat)) := [[(0, 2), (1, 1), (6, 2), (7, 2), (8, 2), (9, 2), (10, 1), (11, 1), (12, 2), (14, 1), (16, 2), (18, 2), (19, 1), (20, 1), (58, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (80, 1), (470, 2)], [], [(0, 2), (1, 1), (6, 2), (7, 2), (8, 2), (9, 2), (10, 1), (11, 1), (12, 2), (14, 1), (16, 1), (18, 2), (19, 1), (20, 1), (58, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (80, 1), (130, 1), (470, 2)], [(0, 2), (1, 2), (2, 2), (6, 1), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (15, 2), (16, 2), (18, 2), (20, 1), (60, 2), (67, 1), (71, 1), (74, 2), (80, 1), (115, 2), (130, 1), (173, 1), (470, 2)], [(0, 1), (1, 2), (6, 2), (7, 2), (8, 2), (10, 1), (11, 1), (15, 2), (16, 2), (18, 2), (20, 1), (60, 2), (66, 2), (67, 1), (71, 1), (72, 1), (74, 2), (80, 1), (115, 2), (130, 1), (234, 1), (470, 2)], [], [(0, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 2), (16, 1), (18, 1), (19, 2), (80, 2), (115, 1), (130, 2)], [], [], [], [], [], [], [], [(0, 1), (2, 2), (6, 1), (7, 1), (8, 2), (9, 1), (10, 2), (11, 2), (14, 1), (15, 2), (19, 1), (20, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 1), (72, 1), (74, 2), (80, 2), (115, 1), (130, 2), (470, 1)], [(0, 2), (2, 1), (6, 1), (7, 1), (8, 2), (10, 2), (14, 2), (15, 2), (16, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 1), (72, 1), (74, 2), (80, 2), (115, 1), (130, 2), (470, 1)], [(0, 1), (2, 2), (6, 2), (7, 1), (8, 2), (9, 1), (10, 2), (11, 2), (14, 1), (15, 2), (18, 2), (19, 1), (20, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 1), (72, 1), (74, 2), (80, 2), (115, 1), (130, 2), (470, 1)], [(0, 1), (2, 2), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (14, 1), (15, 2), (18, 2), (19, 1), (20, 2), (60, 2), (65, 2), (66, 2), (67, 2), (68, 1), (71, 1), (72, 1), (74, 2), (80, 2), (115, 1), (130, 2), (470, 1)], [], [], [], [], [(1, 1), (2, 2), (6, 1), (12, 1), (15, 1), (16, 1), (18, 2), (19, 1), (20, 2), (58, 1), (60, 1), (64, 1), (66, 2), (67, 2), (71, 2), (72, 1), (74, 1), (80, 1), (115, 1), (130, 2), (470, 1)], [], [(0, 1), (1, 1), (2, 1), (6, 1), (12, 2), (15, 1), (18, 2), (19, 1), (20, 2), (58, 2), (60, 1), (67, 2), (71, 2), (74, 1), (80, 1), (470, 1)], [(1, 1), (2, 2), (6, 1), (9, 1), (11, 2), (12, 2), (14, 2), (15, 1), (16, 1), (18, 2), (19, 1), (20, 2), (58, 2), (60, 1), (67, 2), (71, 2), (74, 1), (80, 1), (470, 1)], [(0, 1), (1, 1), (2, 1), (7, 1), (12, 2), (15, 1), (20, 2), (58, 2), (60, 1), (67, 2), (71, 2), (74, 1), (80, 1), (470, 1)], [(0, 1), (1, 1), (2, 1), (6, 1), (8, 2), (10, 1), (12, 2), (15, 1), (20, 2), (58, 2), (60, 1), (67, 2), (71, 2), (74, 1), (80, 1), (470, 1)], [], [(6, 1), (8, 1), (9, 1), (10, 2), (11, 2), (12, 1), (14, 2), (16, 2), (18, 1), (19, 2), (58, 1), (71, 1), (74, 2), (80, 1), (115, 1), (130, 2)], [(1, 1), (2, 2), (8, 2), (10, 2), (12, 2), (14, 2), (15, 2), (16, 2), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 1), (115, 1), (130, 2)], [], [], [], [(1, 1), (2, 2), (6, 1), (8, 1), (9, 1), (10, 2), (11, 2), (12, 2), (14, 2), (16, 1), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 1)], [(1, 1), (2, 2), (6, 1), (8, 1), (9, 1), (10, 2), (12, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 1)], [(1, 1), (2, 2), (8, 2), (9, 1), (10, 2), (11, 2), (14, 1), (15, 2), (16, 2), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 1)], [(1, 1), (2, 2), (6, 1), (8, 1), (9, 1), (10, 2), (11, 2), (12, 2), (14, 2), (15, 2), (16, 2), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 1)], [(0, 1), (2, 2), (7, 1), (8, 1), (10, 2), (12, 2), (14, 2), (15, 2), (16, 1), (18, 2), (19, 1), (21, 1), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 1)], [(0, 2), (1, 1), (6, 2), (8, 2), (12, 2), (14, 1), (16, 1), (18, 2), (19, 1), (20, 1), (58, 2), (65, 2), (66, 2), (67, 1), (68, 1), (72, 1), (80, 2), (115, 2), (130, 1), (470, 2)], [], [], [], [(6, 2), (8, 2), (9, 2), (11, 1), (12, 1), (14, 2), (16, 1), (18, 2), (19, 1), (20, 1), (58, 1), (60, 1), (65, 2), (66, 2), (67, 1), (68, 1), (71, 2), (72, 1), (74, 1), (80, 2), (470, 2)], [(0, 2), (2, 1), (8, 1), (14, 2), (15, 1), (16, 1), (18, 2), (19, 1), (20, 1), (58, 1), (60, 1), (65, 1), (66, 1), (67, 1), (68, 2), (71, 2), (72, 2), (74, 1), (80, 2), (470, 2)], [(6, 2), (8, 2), (9, 2), (12, 1), (14, 2), (15, 1), (16, 1), (18, 2), (19, 1), (20, 1), (58, 1), (60, 1), (65, 1), (66, 2), (67, 1), (68, 2), (71, 2), (72, 1), (74, 1), (80, 2), (470, 2)], [], [], [], [], [], [], [(1, 1), (2, 2), (6, 2), (10, 1), (12, 2), (14, 2), (15, 2), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 2), (115, 2), (130, 1)], [(1, 1), (2, 2), (6, 2), (9, 2), (10, 1), (11, 1), (12, 2), (15, 2), (16, 2), (18, 1), (19, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 2), (115, 2), (130, 1)], [(0, 2), (1, 2), (2, 2), (7, 2), (10, 1), (12, 2), (14, 2), (15, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 2), (115, 2), (130, 1)], [(0, 2), (1, 1), (2, 2), (5, 1), (6, 2), (8, 1), (12, 2), (14, 2), (15, 2), (58, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (80, 2), (115, 2), (130, 1)], [], [], [], [], [], [(1, 1), (2, 2), (6, 2), (9, 2), (10, 1), (11, 1), (12, 1), (15, 2), (18, 1), (19, 2), (58, 1), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (74, 2), (80, 2)], [(0, 2), (1, 1), (7, 2), (10, 1), (12, 1), (14, 2), (15, 2), (16, 1), (58, 1), (60, 2), (65, 1), (71, 1), (74, 2), (80, 2)], [(0, 2), (1, 1), (6, 2), (8, 1), (12, 1), (14, 2), (15, 2), (16, 1), (58, 1), (60, 2), (67, 1), (71, 1), (74, 2), (80, 2)], [(0, 2), (1, 1), (7, 2), (10, 1), (11, 1), (12, 1), (14, 2), (15, 2), (58, 1), (60, 2), (65, 1), (68, 2), (71, 1), (73, 1), (74, 2), (80, 2)], [(1, 1), (2, 2), (6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (15, 2), (58, 1), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (80, 2)], [], [], [], [], [(0, 2), (2, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (15, 1), (16, 1), (18, 1), (19, 2), (20, 2), (51, 1), (58, 2), (60, 1), (67, 2), (71, 2), (74, 1), (115, 1), (130, 2), (470, 1)], [], [], [(6, 1), (9, 1), (10, 2), (11, 1), (15, 1), (16, 2), (18, 2), (19, 1), (20, 1), (58, 1), (60, 1), (64, 2), (65, 1), (66, 2), (67, 1), (68, 2), (71, 2), (72, 1), (74, 1), (99, 1), (115, 2), (130, 1), (470, 2)], [], [], [], [], [], [(1, 2), (2, 1), (8, 2), (12, 1), (14, 1), (15, 1), (16, 1), (18, 2), (19, 1), (58, 1), (60, 1), (65, 2), (66, 2), (68, 1), (71, 2), (72, 1), (74, 1), (115, 2), (130, 1)], [], [(1, 2), (2, 1), (6, 2), (8, 2), (12, 1), (14, 1), (15, 1), (16, 2), (18, 2), (19, 1), (58, 1), (60, 1), (65, 2), (66, 2), (68, 1), (71, 2), (72, 1), (74, 1), (114, 1), (115, 2)], [(0, 1), (1, 2), (2, 1), (5, 2), (7, 2), (8, 2), (9, 2), (10, 1), (11, 1), (12, 1), (14, 1), (15, 1), (16, 2), (18, 1), (19, 1), (60, 1), (65, 2), (66, 2), (68, 1), (71, 2), (72, 1), (74, 1), (293, 1)], [(1, 1), (2, 2), (6, 1), (8, 1), (12, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (60, 2), (65, 1), (66, 1), (68, 2), (71, 1), (72, 2), (74, 2), (172, 1), (173, 2)], [(0, 1), (1, 1), (2, 1), (8, 2), (9, 2), (14, 2), (15, 2), (16, 1), (18, 1), (19, 2), (60, 2), (65, 1), (66, 2), (68, 2), (71, 1), (72, 1), (74, 2), (233, 1), (234, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb81 : List (List (Nat × Nat)) := [[(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (9, 2), (12, 1), (13, 2), (14, 2), (16, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (9, 2), (12, 1), (13, 2), (14, 2), (58, 1), (60, 2), (73, 1), (115, 1), (127, 1), (131, 2), (137, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (9, 2), (12, 2), (16, 2), (18, 2), (60, 1), (67, 1), (73, 1), (115, 2), (121, 2), (127, 2), (131, 1), (137, 1), (173, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (9, 2), (10, 2), (12, 2), (16, 2), (18, 2), (60, 1), (67, 1), (73, 1), (115, 2), (121, 2), (127, 2), (131, 1), (137, 1), (234, 1)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (9, 1), (14, 2), (16, 2), (58, 1), (73, 2), (137, 2)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (9, 1), (13, 1), (14, 2), (16, 2), (57, 2), (58, 1), (73, 2), (75, 1), (137, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (9, 1), (14, 2), (16, 2), (18, 1), (58, 1), (73, 2), (137, 2)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (9, 1), (13, 1), (14, 2), (16, 2), (58, 1), (73, 2), (137, 2)], [], [], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (12, 1), (13, 1), (14, 1), (58, 1), (60, 2), (64, 1), (73, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (9, 1), (12, 1), (13, 1), (14, 1), (16, 2), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [], [(1, 1), (2, 1), (5, 2), (6, 2), (9, 1), (12, 1), (13, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (9, 1), (12, 1), (13, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(1, 1), (6, 2), (9, 1), (12, 1), (13, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (9, 1), (14, 2), (16, 2), (58, 2), (67, 2), (73, 2), (121, 1), (137, 1)], [(0, 1), (1, 1), (5, 2), (12, 1), (14, 1), (58, 1), (73, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (12, 1), (14, 1), (58, 2), (60, 2), (73, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (12, 1), (14, 1), (16, 2), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(0, 1), (1, 1), (4, 1), (5, 2), (12, 1), (14, 1), (16, 2), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [], [], [(0, 1), (1, 1), (5, 2), (12, 2), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(0, 1), (1, 1), (5, 2), (12, 1), (14, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [(0, 1), (1, 1), (5, 2), (12, 1), (21, 1), (58, 1), (60, 2), (115, 1), (127, 1), (131, 2), (137, 1)], [], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (9, 2), (12, 1), (13, 2), (14, 2), (60, 2), (73, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [], [], [], [], [], [(0, 2), (1, 1), (5, 1), (6, 1), (7, 2), (13, 2), (58, 1), (60, 2), (117, 1), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (9, 2), (13, 2), (115, 1), (137, 2)], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 1), (13, 2), (58, 1), (64, 2), (120, 1), (137, 2)], [], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (12, 1), (14, 1), (16, 1), (60, 2), (73, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (7, 1), (9, 2), (12, 1), (14, 2), (60, 2), (73, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [(9, 2), (10, 1), (12, 1), (14, 2), (60, 2), (73, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [], [], [], [(2, 2), (5, 1), (9, 2), (12, 1), (14, 2), (16, 1), (60, 2), (66, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (9, 2), (12, 1), (14, 2), (16, 1), (60, 2), (65, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [(9, 2), (12, 1), (14, 2), (16, 1), (60, 2), (67, 1), (115, 1), (127, 1), (131, 2), (137, 2)], [], [], [], [(2, 2), (3, 1), (5, 1), (9, 2), (12, 1), (14, 2), (60, 2), (64, 1), (115, 1), (120, 2), (127, 1), (130, 1), (131, 2), (137, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (58, 1), (60, 2), (127, 1), (137, 2)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (9, 2), (12, 1), (13, 2), (14, 2), (16, 2), (51, 1), (58, 2), (60, 2), (73, 2), (115, 1), (127, 1), (131, 2)], [], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (6, 1), (13, 2), (16, 1), (64, 2), (73, 1), (157, 1)], [], [], [], [(0, 2), (1, 2), (4, 2), (5, 1), (6, 1), (9, 1), (12, 1), (13, 2), (57, 1), (58, 2), (60, 2), (64, 2), (67, 2), (73, 1), (75, 2), (115, 1), (120, 1), (127, 1), (130, 2), (131, 2), (470, 1)], [(1, 1), (12, 2), (13, 1), (14, 2), (58, 1), (60, 1), (73, 1), (115, 2), (127, 2), (131, 1)], [(1, 1), (12, 2), (14, 2), (16, 1), (57, 1), (58, 1), (60, 1), (115, 2), (127, 2), (131, 1)], [], [(1, 1), (4, 1), (7, 2), (12, 2), (13, 1), (14, 2), (16, 1), (18, 2), (58, 1), (60, 1), (64, 1), (115, 2), (120, 2), (127, 2), (131, 1), (293, 1)], [(1, 1), (7, 1), (12, 1), (14, 1), (16, 2), (58, 2), (60, 2), (67, 2), (115, 1), (121, 1), (127, 1), (131, 2), (172, 1), (173, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (10, 1), (12, 1), (14, 1), (16, 2), (58, 2), (60, 2), (67, 2), (115, 1), (121, 1), (127, 1), (131, 2), (233, 1), (234, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb82 : List (List (Nat × Nat)) := [[(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (9, 2), (12, 1), (13, 1), (68, 1), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 2), (5, 1), (8, 2), (9, 1), (11, 1), (12, 1), (13, 1), (58, 2), (68, 1), (115, 1), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (5, 2), (8, 2), (9, 1), (11, 1), (12, 1), (13, 1), (58, 2), (68, 1), (115, 1), (117, 1), (127, 1), (173, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (5, 2), (8, 2), (9, 1), (11, 1), (12, 1), (13, 1), (58, 2), (68, 1), (115, 1), (117, 1), (127, 1), (233, 1), (291, 2)], [], [], [], [(3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (11, 2), (12, 2), (58, 1), (68, 2), (115, 2), (117, 1), (121, 1), (127, 2), (233, 1), (234, 2), (291, 2)], [], [], [], [(3, 2), (4, 1), (6, 1), (9, 2), (11, 2), (12, 2), (13, 2), (58, 1), (60, 2), (64, 2), (77, 1), (115, 2), (117, 1), (121, 1), (127, 2), (233, 1), (234, 2), (291, 2)], [], [], [(2, 2), (3, 2), (4, 1), (6, 1), (9, 1), (13, 2), (15, 2), (20, 1), (58, 1), (68, 2), (115, 2), (117, 1), (121, 1), (127, 2), (233, 1), (234, 2), (291, 2)], [], [], [], [(3, 2), (4, 1), (6, 1), (9, 2), (11, 2), (12, 2), (13, 2), (58, 1), (68, 2), (115, 2), (117, 1), (121, 1), (127, 2), (233, 1), (234, 2), (291, 2)], [(3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (11, 2), (12, 2), (13, 2), (58, 1), (68, 2), (115, 2), (117, 1), (121, 1), (127, 2), (233, 1), (234, 2), (291, 2)], [], [(0, 1), (2, 1), (5, 1), (8, 1), (13, 2), (64, 1), (68, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (2, 1), (5, 1), (8, 1), (9, 1), (11, 2), (13, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (13, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [], [(0, 1), (2, 1), (5, 1), (8, 1), (13, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (8, 2), (13, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(3, 2), (4, 1), (6, 1), (8, 2), (9, 2), (11, 2), (12, 2), (58, 1), (68, 2), (115, 2), (117, 1), (121, 2), (127, 1), (233, 1), (234, 2), (291, 2)], [], [(2, 2), (5, 1), (9, 1), (12, 2), (58, 1), (68, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (2, 2), (5, 1), (9, 1), (11, 2), (12, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (2, 1), (3, 1), (5, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (12, 2), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (12, 2), (21, 1), (117, 1), (121, 1), (127, 1), (233, 1), (234, 2), (291, 2)], [], [], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 1), (9, 2), (11, 1), (13, 1), (58, 2), (60, 1), (115, 1), (127, 2)], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (13, 1), (117, 1), (127, 2)], [], [], [(0, 1), (3, 1), (4, 2), (6, 2), (12, 2), (13, 1), (15, 1), (20, 2), (121, 1), (127, 2), (173, 2), (174, 1)], [(0, 1), (3, 1), (4, 2), (6, 2), (12, 2), (13, 1), (15, 1), (20, 2), (121, 1), (127, 2), (234, 2), (236, 1)], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (9, 1), (11, 1), (12, 1), (58, 2), (68, 1), (115, 1), (127, 2)], [], [], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (9, 2), (15, 1), (58, 2), (68, 1), (115, 1), (127, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (17, 1), (58, 2), (68, 1), (115, 1), (127, 2)], [], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (8, 2), (9, 1), (11, 1), (12, 1), (58, 2), (66, 1), (115, 1), (127, 2)], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (9, 2), (11, 1), (58, 2), (73, 1), (115, 1), (127, 2)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (8, 1), (9, 2), (11, 1), (58, 2), (71, 1), (115, 1), (127, 2)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (127, 2), (130, 1)], [], [], [(0, 1), (5, 2), (8, 1), (9, 2), (11, 2), (12, 2), (13, 2), (17, 2), (51, 1), (58, 1), (68, 2), (115, 2), (117, 2), (121, 2), (233, 2), (234, 1), (291, 1)], [], [], [], [], [(3, 2), (4, 1), (6, 1), (9, 2), (11, 1), (12, 1), (13, 1), (64, 2), (68, 1), (392, 1)], [], [], [(0, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (13, 1), (15, 1), (17, 2), (20, 2), (117, 2), (121, 2), (130, 2), (233, 2), (234, 1), (291, 1), (470, 1)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (9, 2), (58, 2), (68, 1), (115, 1), (117, 1), (121, 1), (233, 1), (234, 2), (291, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (9, 2), (11, 1), (57, 1), (58, 2), (115, 1), (117, 1), (121, 1), (233, 1), (234, 2), (291, 2)], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 1), (8, 2), (114, 1), (117, 1), (121, 1), (233, 1), (234, 2), (291, 2)], [], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 2), (117, 1), (121, 2), (172, 1), (173, 2), (233, 1), (234, 2), (291, 2)], [(0, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (117, 1), (121, 2), (233, 2), (234, 1), (291, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb83 : List (List (Nat × Nat)) := [[(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 1), (18, 1), (19, 1), (58, 2), (60, 1), (117, 2), (137, 1), (173, 1), (233, 1), (234, 2)], [(1, 1), (3, 2), (4, 1), (8, 2), (10, 2), (11, 2), (18, 1), (19, 1), (58, 2), (60, 1), (66, 1), (117, 2), (137, 1), (173, 1), (233, 1), (234, 2)], [(1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 1), (11, 2), (18, 1), (19, 1), (58, 2), (66, 1), (137, 1), (173, 1), (233, 1), (234, 2)], [], [(3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (10, 1), (11, 2), (18, 1), (19, 1), (60, 2), (66, 1), (117, 1), (121, 1), (137, 1), (233, 2), (234, 2)], [], [], [], [], [(3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (10, 2), (11, 1), (19, 2), (60, 1), (66, 2), (117, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [], [], [], [], [], [], [(3, 1), (4, 2), (7, 1), (8, 1), (10, 2), (11, 1), (18, 2), (19, 2), (60, 1), (66, 2), (117, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [], [(1, 1), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 1), (8, 2), (10, 1), (11, 1), (18, 2), (19, 2), (60, 1), (66, 2), (117, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [(3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (10, 2), (11, 1), (18, 2), (19, 2), (60, 1), (66, 2), (117, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (8, 2), (11, 1), (18, 2), (19, 2), (58, 2), (60, 2), (66, 2), (117, 1), (137, 2), (173, 1), (233, 1), (234, 2)], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 1), (8, 1), (10, 2), (18, 2), (64, 1), (66, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 2), (9, 1), (10, 1), (11, 2), (18, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [(8, 1), (18, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 1), (8, 1), (10, 2), (18, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 1), (8, 1), (10, 1), (18, 2), (58, 1), (60, 2), (117, 1), (121, 1), (137, 1), (173, 2)], [(3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (10, 2), (11, 1), (19, 2), (60, 1), (66, 2), (117, 2), (137, 1), (233, 2), (234, 1)], [(3, 1), (4, 2), (11, 1), (19, 2), (60, 1), (66, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [], [(6, 2), (7, 1), (8, 1), (19, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (6, 2), (7, 1), (8, 1), (10, 1), (19, 2), (58, 1), (60, 2), (117, 1), (121, 1), (137, 1), (173, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (9, 2), (10, 1), (11, 1), (14, 1), (15, 1), (16, 2), (19, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [(0, 1), (1, 1), (5, 2), (10, 2), (11, 1), (19, 2), (58, 1), (60, 2), (117, 1), (121, 1), (137, 1), (173, 2)], [], [(0, 1), (1, 1), (5, 2), (9, 2), (10, 2), (11, 1), (14, 1), (19, 2), (58, 1), (60, 2), (117, 1), (121, 1), (137, 1), (173, 2)], [], [], [], [(0, 1), (1, 1), (3, 2), (4, 1), (8, 2), (10, 2), (11, 2), (18, 1), (58, 1), (60, 1), (66, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 1), (18, 1), (58, 2), (60, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [], [(0, 1), (1, 1), (5, 2), (7, 2), (8, 2), (9, 2), (11, 1), (18, 1), (58, 1), (60, 2), (115, 1), (117, 1), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (8, 2), (9, 2), (11, 1), (18, 1), (58, 2), (60, 1), (117, 1), (137, 2), (173, 1), (174, 1), (233, 1), (234, 2)], [], [(1, 2), (2, 1), (3, 2), (5, 2), (8, 2), (10, 1), (11, 1), (18, 1), (58, 1), (64, 2), (121, 1), (137, 2), (173, 2), (181, 1)], [], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (10, 2), (11, 2), (19, 1), (58, 1), (60, 1), (66, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [(1, 2), (2, 2), (5, 1), (10, 1), (11, 2), (19, 1), (58, 1), (60, 1), (66, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [(1, 2), (2, 2), (5, 1), (9, 1), (10, 1), (11, 1), (14, 2), (16, 1), (19, 1), (58, 1), (60, 1), (66, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [(3, 2), (4, 1), (11, 2), (22, 1), (60, 2), (66, 1), (117, 1), (137, 2)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (11, 2), (14, 2), (15, 2), (16, 1), (19, 1), (58, 1), (60, 1), (65, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [(1, 2), (6, 1), (7, 2), (8, 2), (9, 1), (10, 2), (11, 2), (14, 2), (19, 1), (58, 1), (60, 1), (73, 1), (117, 2), (121, 2), (137, 2), (173, 2), (233, 1), (234, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (10, 1), (60, 2), (80, 1), (117, 1), (137, 2)], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 1), (9, 1), (10, 1), (11, 2), (14, 2), (19, 1), (58, 1), (60, 2), (117, 1), (121, 2), (130, 1), (137, 2), (173, 2), (233, 1), (234, 2)], [], [], [(2, 2), (3, 2), (4, 1), (5, 1), (6, 1), (7, 2), (10, 1), (11, 1), (18, 2), (19, 1), (51, 1), (60, 1), (66, 2), (117, 2), (121, 1), (233, 1), (234, 2)], [], [], [], [], [], [(1, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 2), (11, 2), (14, 2), (18, 1), (19, 2), (58, 2), (60, 1), (64, 2), (66, 1), (117, 2), (121, 1), (173, 1), (216, 1), (233, 2), (234, 1)], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (8, 2), (9, 2), (11, 1), (14, 1), (18, 1), (19, 2), (58, 2), (60, 1), (117, 2), (121, 2), (130, 2), (173, 1), (470, 1)], [(1, 2), (2, 2), (5, 1), (8, 1), (10, 1), (11, 2), (58, 1), (60, 1), (66, 1), (117, 2), (121, 1), (173, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (57, 1), (58, 1), (60, 1), (117, 2), (121, 1), (173, 2)], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (10, 1), (58, 1), (60, 2), (114, 1), (117, 1), (121, 1), (173, 2)], [(0, 1), (1, 1), (5, 2), (10, 2), (58, 1), (60, 2), (117, 1), (121, 2), (173, 1), (293, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb84 : List (List (Nat × Nat)) := [[(1, 1), (2, 2), (3, 2), (4, 2), (5, 1), (8, 2), (9, 2), (10, 2), (15, 2), (24, 1), (25, 2), (57, 1), (63, 2), (65, 1), (66, 2), (115, 2), (137, 1), (172, 1), (173, 2), (234, 1)], [(1, 1), (2, 2), (3, 2), (4, 2), (5, 1), (8, 2), (9, 2), (10, 2), (15, 1), (24, 1), (25, 2), (57, 1), (63, 2), (65, 2), (66, 2), (115, 2), (137, 1), (172, 1), (173, 2), (234, 1)], [(0, 1), (1, 1), (2, 1), (4, 2), (5, 1), (6, 2), (9, 1), (10, 2), (15, 1), (24, 1), (25, 2), (57, 1), (58, 2), (63, 2), (65, 2), (66, 2), (137, 1), (172, 1), (173, 2), (234, 1)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (15, 1), (24, 1), (25, 2), (57, 2), (58, 1), (63, 1), (67, 2), (115, 1), (121, 1), (137, 1), (172, 2), (173, 2)], [], [], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (15, 2), (25, 1), (57, 1), (58, 2), (63, 2), (67, 1), (115, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (15, 2), (24, 2), (25, 1), (58, 2), (67, 1), (115, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (15, 2), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (67, 1), (115, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (15, 2), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (67, 1), (115, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [(1, 1), (2, 1), (4, 2), (5, 2), (6, 1), (9, 1), (10, 2), (15, 2), (24, 2), (25, 1), (57, 2), (63, 1), (65, 1), (66, 2), (115, 1), (137, 2), (172, 1), (173, 2), (234, 1)], [(2, 1), (4, 1), (5, 2), (8, 1), (9, 2), (15, 2), (24, 2), (25, 1), (57, 1), (58, 2), (63, 2), (64, 1), (66, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (15, 2), (24, 2), (25, 1), (58, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [(0, 1), (4, 1), (5, 2), (8, 1), (9, 2), (15, 2), (24, 2), (25, 1), (58, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [(2, 1), (4, 1), (5, 2), (8, 1), (9, 2), (15, 2), (24, 2), (25, 1), (58, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [(1, 2), (2, 1), (3, 1), (4, 1), (5, 2), (8, 1), (9, 1), (10, 1), (15, 2), (24, 2), (25, 1), (57, 2), (58, 1), (63, 1), (65, 2), (66, 1), (67, 2), (115, 1), (121, 1), (137, 1), (234, 2)], [], [(0, 2), (2, 1), (3, 2), (6, 1), (8, 2), (9, 1), (57, 1), (63, 2), (115, 2), (137, 1), (172, 2), (173, 1)], [(58, 2), (60, 1), (65, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [(0, 2), (1, 2), (2, 1), (3, 1), (9, 2), (10, 1), (57, 2), (58, 2), (63, 1), (65, 1), (66, 1), (67, 2), (115, 1), (121, 1), (137, 1), (234, 2)], [(1, 1), (15, 2), (58, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [(1, 2), (2, 1), (3, 1), (9, 2), (10, 1), (15, 2), (57, 2), (58, 1), (63, 1), (65, 2), (66, 1), (67, 2), (115, 1), (121, 1), (137, 1), (234, 2)], [], [(58, 2), (67, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [], [(1, 2), (3, 2), (6, 2), (8, 1), (9, 1), (10, 1), (12, 1), (15, 2), (57, 2), (58, 1), (63, 1), (65, 2), (66, 1), (67, 2), (115, 1), (121, 1), (137, 1), (234, 2)], [], [], [], [], [], [(1, 2), (2, 2), (4, 2), (5, 1), (6, 2), (9, 2), (10, 1), (24, 1), (25, 2), (57, 1), (58, 2), (63, 2), (65, 2), (66, 1), (67, 1), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [], [], [(1, 2), (2, 2), (3, 2), (4, 2), (5, 1), (6, 2), (9, 2), (10, 1), (15, 1), (24, 1), (25, 2), (57, 1), (58, 2), (63, 2), (65, 1), (66, 2), (67, 1), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 1), (8, 2), (10, 1), (15, 1), (24, 1), (25, 2), (57, 1), (63, 2), (64, 2), (65, 1), (66, 2), (67, 1), (115, 1), (120, 1), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [], [(1, 1), (3, 1), (8, 2), (9, 2), (10, 2), (15, 1), (24, 1), (25, 2), (57, 2), (60, 2), (63, 1), (65, 2), (66, 2), (115, 1), (137, 2), (172, 1), (173, 2), (234, 1), (236, 1)], [(2, 2), (4, 2), (5, 1), (8, 2), (9, 1), (15, 1), (24, 1), (25, 2), (58, 1), (64, 2), (66, 1), (67, 2), (121, 1), (137, 2), (173, 2), (181, 1)], [], [], [], [(1, 2), (2, 2), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (10, 1), (57, 1), (58, 2), (63, 2), (65, 2), (66, 1), (67, 1), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [], [(1, 1), (3, 2), (9, 1), (10, 2), (57, 1), (58, 2), (63, 2), (65, 2), (66, 1), (67, 1), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [], [(1, 2), (3, 2), (4, 2), (9, 2), (10, 1), (12, 2), (17, 1), (57, 1), (58, 2), (63, 2), (65, 2), (66, 1), (67, 1), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [(2, 2), (3, 1), (9, 2), (22, 1), (57, 2), (63, 1), (115, 1), (137, 2)], [], [], [(1, 2), (3, 2), (6, 2), (8, 1), (9, 1), (10, 1), (57, 1), (58, 2), (63, 2), (65, 1), (66, 1), (67, 2), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [], [(1, 2), (3, 2), (6, 2), (8, 1), (9, 1), (10, 1), (57, 2), (58, 2), (60, 2), (63, 1), (65, 2), (66, 1), (67, 1), (71, 1), (115, 2), (121, 2), (137, 2), (172, 1), (173, 2), (234, 2)], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 1), (9, 2), (58, 2), (80, 1), (115, 1), (137, 2)], [], [(0, 2), (1, 2), (2, 1), (3, 1), (9, 2), (10, 1), (57, 2), (60, 2), (63, 1), (65, 2), (66, 1), (67, 1), (115, 1), (121, 2), (127, 1), (137, 2), (172, 1), (173, 2), (234, 2)], [], [(2, 1), (3, 2), (4, 2), (5, 2), (8, 1), (9, 2), (12, 1), (15, 1), (17, 2), (24, 2), (25, 1), (51, 1), (57, 1), (58, 1), (63, 2), (67, 2), (115, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 1), (10, 2), (12, 2), (24, 1), (25, 2), (58, 1), (64, 2), (65, 1), (67, 2), (115, 2), (121, 1), (172, 2), (173, 1), (234, 1), (274, 1)], [(1, 1), (2, 2), (3, 2), (4, 2), (5, 1), (8, 2), (9, 2), (10, 2), (12, 1), (15, 1), (17, 2), (24, 1), (25, 2), (57, 2), (58, 2), (63, 1), (65, 2), (66, 2), (115, 1), (121, 2), (234, 1), (470, 1)], [(1, 2), (3, 2), (8, 1), (9, 1), (10, 1), (15, 2), (57, 1), (58, 1), (63, 2), (65, 2), (66, 1), (67, 2), (115, 2), (121, 1), (234, 2)], [(1, 2), (3, 2), (6, 2), (8, 1), (9, 1), (10, 1), (57, 2), (58, 1), (63, 2), (65, 1), (66, 1), (67, 2), (115, 2), (121, 1), (234, 2)], [(0, 2), (1, 2), (2, 1), (3, 1), (9, 2), (10, 1), (57, 1), (58, 2), (63, 2), (65, 1), (66, 1), (67, 2), (114, 1), (115, 1), (121, 1), (234, 2)], [(0, 1), (1, 1), (3, 2), (5, 2), (9, 1), (10, 2), (57, 2), (58, 1), (63, 1), (64, 1), (65, 2), (66, 1), (67, 1), (115, 2), (120, 2), (121, 2), (234, 1), (293, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb85 : List (List (Nat × Nat)) := [[(0, 2), (2, 2), (5, 1), (6, 2), (9, 2), (12, 2), (19, 1), (22, 2), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (66, 1), (68, 2), (73, 2), (120, 1), (130, 2)], [], [], [], [], [], [(0, 1), (2, 2), (5, 1), (7, 2), (9, 2), (12, 2), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (65, 2), (66, 1), (67, 1), (68, 1), (73, 1)], [(0, 1), (2, 2), (5, 1), (7, 2), (9, 2), (12, 2), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (64, 1), (65, 2), (66, 1), (67, 1), (68, 1), (120, 2), (130, 1)], [(0, 1), (2, 2), (5, 1), (7, 2), (9, 2), (12, 2), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (64, 1), (65, 2), (66, 1), (67, 1), (73, 1), (120, 2), (130, 1)], [(5, 1), (7, 1), (12, 1), (22, 1), (24, 1), (25, 2), (34, 2), (64, 1), (65, 2), (67, 1), (68, 1), (73, 1), (120, 2), (130, 1)], [(0, 1), (7, 2), (9, 2), (12, 1), (19, 2), (22, 1), (24, 1), (34, 2), (64, 1), (65, 1), (67, 2), (68, 1), (73, 1), (120, 2), (130, 1)], [(0, 2), (2, 2), (5, 1), (6, 2), (9, 2), (12, 2), (18, 2), (19, 1), (22, 2), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (66, 1), (68, 2), (73, 2), (75, 1), (120, 1), (130, 2)], [(1, 2), (2, 2), (5, 1), (6, 1), (7, 1), (9, 2), (12, 2), (22, 2), (24, 1), (25, 2), (34, 2), (63, 2), (65, 2), (66, 1), (73, 2), (77, 1), (120, 1), (130, 2)], [(0, 2), (2, 2), (5, 1), (6, 1), (9, 2), (12, 2), (19, 1), (22, 2), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (66, 1), (68, 2), (73, 2), (120, 1), (130, 2)], [], [], [], [], [], [], [], [], [], [(0, 1), (5, 1), (6, 1), (7, 2), (9, 1), (12, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 2), (65, 2), (67, 1), (120, 1), (130, 2)], [(0, 2), (5, 1), (6, 1), (7, 2), (12, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 2), (67, 1), (73, 2)], [(0, 1), (2, 1), (5, 1), (6, 1), (7, 2), (9, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 2), (67, 1), (68, 2)], [(0, 1), (2, 1), (5, 1), (6, 1), (7, 2), (9, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1)], [(0, 1), (2, 1), (5, 1), (6, 1), (7, 2), (9, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 1), (66, 2), (67, 2)], [(0, 2), (2, 1), (6, 1), (7, 2), (9, 1), (12, 2), (19, 1), (22, 2), (63, 2), (64, 1), (66, 2), (120, 2), (121, 1), (130, 1)], [(0, 2), (1, 2), (2, 1), (5, 1), (9, 1), (19, 1), (22, 2), (24, 1), (25, 2), (34, 2), (60, 1), (65, 2), (66, 2), (68, 1)], [(0, 2), (5, 1), (12, 1), (19, 1), (22, 2), (24, 1), (25, 2), (34, 2), (58, 1), (72, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [(0, 1), (5, 1), (6, 2), (7, 2), (12, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (67, 1), (68, 2), (120, 1), (130, 2)], [(2, 1), (5, 1), (6, 2), (7, 2), (9, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (65, 2), (66, 2), (67, 1), (72, 1), (120, 1), (130, 2)], [(0, 1), (5, 1), (6, 2), (7, 2), (12, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (65, 2), (67, 1), (120, 1), (130, 2)], [(0, 1), (1, 1), (5, 1), (6, 2), (7, 1), (12, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (60, 2), (63, 1), (64, 2), (67, 1), (68, 2), (73, 2), (117, 1)], [(0, 1), (2, 1), (5, 1), (6, 2), (7, 2), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (58, 2), (63, 1), (64, 2), (65, 2), (66, 2), (67, 1), (72, 1), (73, 2), (115, 1)], [(0, 1), (5, 1), (6, 2), (7, 2), (12, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (65, 2), (67, 1), (73, 2), (120, 1)], [(0, 1), (2, 1), (5, 1), (6, 2), (7, 2), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (60, 2), (63, 1), (64, 2), (66, 2), (67, 1), (68, 2), (174, 1)], [(0, 1), (1, 1), (2, 1), (6, 2), (7, 2), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (60, 2), (63, 1), (64, 2), (65, 2), (66, 2), (67, 2), (68, 2), (236, 1)], [(0, 1), (1, 2), (2, 1), (5, 1), (6, 2), (7, 2), (9, 1), (19, 2), (22, 1), (24, 1), (25, 2), (34, 2), (63, 1), (64, 1), (65, 2), (66, 2), (67, 1), (181, 1)], [(0, 2), (2, 2), (7, 2), (9, 2), (12, 1), (19, 1), (22, 2), (64, 1), (65, 2), (66, 1), (67, 1), (73, 1), (120, 2), (130, 1)], [(0, 2), (2, 2), (7, 2), (9, 1), (12, 2), (19, 1), (22, 2), (64, 1), (65, 2), (66, 1), (67, 1), (68, 1), (120, 2), (130, 1)], [(0, 2), (1, 1), (2, 1), (7, 2), (9, 1), (12, 2), (19, 1), (22, 2), (64, 1), (65, 2), (66, 2), (67, 1), (120, 2), (130, 1)], [(0, 2), (2, 1), (5, 1), (7, 2), (9, 1), (12, 2), (19, 1), (22, 2), (64, 1), (66, 2), (120, 2), (130, 1)], [(0, 2), (2, 1), (9, 1), (12, 2), (19, 1), (22, 2), (65, 2), (66, 2), (67, 1), (73, 1)], [(0, 2), (2, 1), (7, 2), (9, 1), (10, 1), (12, 2), (19, 1), (22, 2), (66, 2), (73, 1)], [(0, 2), (2, 1), (7, 2), (9, 1), (12, 2), (15, 1), (19, 1), (22, 2), (65, 2), (66, 2), (67, 1), (68, 1)], [(0, 2), (2, 1), (7, 2), (9, 1), (12, 2), (17, 1), (19, 1), (22, 2), (66, 2), (68, 1)], [], [], [], [], [], [], [], [], [], [], [], [(6, 2), (7, 2), (17, 2), (63, 1), (64, 2), (65, 1), (67, 2), (68, 2), (73, 2), (120, 1), (121, 2), (130, 2), (314, 1)], [(0, 2), (2, 2), (6, 1), (9, 2), (12, 1), (44, 1), (63, 1), (66, 1), (68, 1), (73, 1), (120, 2), (130, 1)], [], [], [], [], [], [(1, 2), (2, 2), (5, 2), (6, 1), (7, 2), (9, 2), (17, 2), (18, 1), (24, 2), (25, 1), (34, 1), (63, 2), (64, 1), (65, 1), (66, 1), (67, 2), (73, 1), (75, 2), (470, 1)], [], [], [], [], [], [], [], [(2, 2), (5, 1), (6, 2), (7, 1), (9, 2), (12, 2), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 1), (66, 1), (67, 2), (73, 1)], [(2, 2), (5, 1), (6, 1), (7, 1), (9, 2), (12, 2), (13, 1), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 1), (66, 1), (67, 2), (68, 1)], [(0, 1), (2, 1), (5, 1), (6, 1), (7, 2), (9, 1), (18, 1), (19, 2), (24, 1), (25, 2), (34, 2), (63, 2), (64, 1), (65, 1), (66, 2), (67, 2)], [(2, 1), (5, 2), (6, 1), (7, 1), (9, 2), (24, 2), (25, 1), (34, 2), (63, 2), (64, 1), (65, 2), (66, 2), (67, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb86 : List (List (Nat × Nat)) := [[], [], [(0, 2), (2, 2), (3, 1), (5, 1), (9, 2), (12, 1), (15, 1), (16, 2), (21, 1), (60, 1), (65, 2), (68, 1), (73, 2), (115, 2), (137, 2)], [], [], [(1, 1), (2, 2), (4, 1), (5, 2), (7, 2), (9, 2), (11, 1), (12, 2), (16, 1), (20, 1), (21, 1), (57, 2), (114, 1), (115, 1), (137, 1)], [(1, 2), (2, 1), (4, 2), (5, 2), (7, 1), (9, 2), (11, 2), (15, 2), (20, 2), (57, 2), (60, 2), (65, 1), (68, 2), (73, 1), (114, 1), (115, 1), (137, 1)], [], [(1, 2), (2, 1), (4, 1), (5, 2), (7, 1), (9, 2), (11, 2), (15, 2), (16, 1), (20, 2), (57, 2), (60, 2), (65, 1), (68, 2), (73, 1), (114, 1), (115, 1), (137, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (7, 1), (9, 2), (11, 2), (12, 2), (15, 2), (16, 1), (20, 2), (21, 1), (57, 2), (60, 2), (65, 1), (68, 2), (73, 1), (114, 1), (115, 1), (137, 1)], [(0, 1), (1, 1), (2, 1), (4, 1), (5, 2), (7, 2), (9, 1), (11, 2), (12, 2), (15, 2), (16, 1), (19, 2), (20, 2), (21, 1), (25, 1), (57, 2), (60, 2), (65, 1), (68, 2), (73, 1), (114, 1), (115, 1), (137, 1)], [(0, 1), (2, 1), (5, 1), (11, 2), (15, 1), (18, 2), (19, 1), (20, 2), (21, 1), (57, 1), (60, 1), (65, 2), (68, 1), (73, 2), (75, 1), (114, 2), (115, 2), (137, 2)], [], [], [(0, 1), (2, 1), (5, 1), (11, 2), (15, 1), (19, 1), (20, 2), (21, 1), (57, 1), (60, 1), (65, 2), (68, 1), (73, 2), (114, 2), (115, 2), (137, 2)], [], [], [], [(0, 2), (2, 2), (3, 1), (5, 1), (9, 2), (12, 1), (15, 1), (16, 2), (21, 1), (57, 1), (60, 1), (65, 2), (68, 1), (73, 2), (114, 2), (115, 2), (137, 2)], [], [], [], [(0, 1), (1, 1), (2, 2), (5, 2), (7, 2), (9, 1), (11, 1), (12, 1), (20, 1), (21, 1), (57, 1), (64, 1), (73, 2), (114, 2), (137, 1)], [(0, 1), (1, 1), (2, 2), (5, 2), (7, 2), (9, 2), (11, 1), (12, 1), (16, 2), (20, 1), (21, 1), (57, 1), (114, 2), (137, 1)], [], [(0, 1), (1, 1), (4, 2), (5, 2), (7, 2), (9, 2), (11, 1), (20, 1), (21, 1), (57, 1), (114, 2), (137, 1)], [(0, 1), (1, 1), (3, 2), (5, 2), (7, 2), (9, 2), (11, 1), (20, 1), (21, 1), (57, 1), (114, 2), (137, 1)], [(0, 1), (1, 1), (2, 2), (4, 2), (7, 2), (9, 2), (11, 1), (20, 1), (21, 1), (57, 1), (114, 2), (137, 1)], [], [], [], [(1, 1), (4, 1), (5, 1), (12, 2), (16, 1), (21, 1), (57, 2), (114, 1), (137, 2)], [], [], [(4, 2), (5, 1), (12, 2), (15, 1), (21, 1), (57, 2), (114, 1), (137, 2)], [(1, 1), (2, 2), (4, 2), (5, 1), (7, 2), (11, 1), (20, 1), (57, 2), (114, 1), (137, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (5, 2), (9, 2), (12, 1), (15, 1), (16, 2), (20, 1), (21, 1), (60, 1), (65, 2), (68, 1), (73, 2), (115, 2), (137, 1)], [], [(0, 2), (4, 2), (5, 2), (9, 2), (15, 1), (21, 2), (60, 1), (65, 2), (68, 1), (73, 2), (115, 2), (137, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (9, 2), (15, 1), (21, 2), (60, 1), (65, 2), (68, 1), (73, 2), (115, 2), (137, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (9, 2), (11, 1), (12, 1), (16, 2), (20, 1), (21, 1), (60, 1), (115, 2), (137, 1)], [(0, 1), (1, 1), (2, 2), (5, 2), (7, 2), (9, 2), (11, 1), (12, 1), (16, 2), (20, 1), (21, 1), (58, 1), (115, 2), (137, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (9, 2), (15, 1), (16, 2), (21, 2), (60, 1), (65, 2), (68, 1), (115, 2), (137, 1)], [], [], [], [(0, 2), (1, 1), (2, 2), (4, 2), (5, 2), (7, 2), (9, 2), (11, 1), (20, 1), (21, 1), (115, 2), (137, 1), (174, 1)], [(0, 2), (1, 1), (2, 2), (4, 2), (5, 2), (7, 2), (9, 2), (11, 1), (20, 1), (21, 1), (115, 2), (137, 1), (236, 1)], [(0, 2), (4, 1), (5, 2), (12, 2), (15, 1), (21, 2), (60, 1), (64, 2), (65, 2), (68, 1), (115, 2), (137, 1), (181, 1)], [(1, 1), (3, 2), (4, 2), (5, 1), (7, 2), (11, 1), (12, 2), (15, 2), (16, 1), (20, 1), (60, 2), (65, 1), (68, 2), (73, 1), (115, 1), (137, 2)], [], [], [], [(1, 1), (2, 2), (4, 2), (5, 1), (7, 2), (9, 2), (11, 2), (15, 2), (20, 1), (60, 2), (65, 1), (68, 2), (73, 1), (115, 1), (137, 2)], [(1, 1), (3, 2), (7, 1), (9, 2), (10, 1), (11, 2), (15, 2), (20, 1), (60, 2), (65, 1), (68, 2), (73, 1), (115, 1), (137, 2)], [], [], [], [(1, 1), (2, 2), (3, 2), (5, 1), (7, 2), (9, 2), (11, 1), (15, 2), (16, 1), (20, 1), (60, 2), (65, 1), (66, 1), (68, 2), (115, 1), (137, 2)], [(1, 1), (2, 2), (4, 2), (5, 1), (7, 2), (9, 2), (11, 1), (15, 2), (16, 1), (20, 1), (60, 2), (65, 1), (115, 1), (137, 2)], [(1, 1), (3, 2), (7, 2), (9, 2), (11, 1), (15, 2), (16, 1), (20, 1), (60, 2), (67, 1), (115, 1), (137, 2)], [], [], [], [(4, 2), (5, 1), (12, 2), (21, 1), (130, 1), (137, 2)], [(2, 1), (3, 2), (12, 2), (21, 1), (127, 1), (137, 2)], [], [], [(1, 1), (2, 2), (7, 2), (9, 2), (12, 1), (15, 1), (16, 2), (20, 1), (21, 2), (57, 1), (60, 1), (65, 2), (68, 1), (73, 2), (114, 2), (115, 1), (314, 1)], [], [], [(0, 2), (4, 1), (9, 1), (12, 1), (16, 1), (57, 1), (64, 2), (73, 1), (114, 1), (115, 1), (157, 1)], [], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (5, 1), (7, 1), (9, 1), (12, 1), (16, 2), (18, 1), (19, 2), (21, 1), (57, 2), (65, 1), (67, 2), (68, 2), (73, 1), (75, 2), (114, 1), (130, 2), (470, 1)], [], [], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 2), (7, 1), (9, 2), (11, 2), (15, 2), (20, 2), (21, 1), (57, 1), (60, 2), (65, 1), (68, 2), (73, 1)], [], [(0, 1), (1, 1), (3, 2), (4, 2), (7, 2), (9, 2), (11, 1), (12, 2), (13, 1), (20, 1), (21, 2)], [(0, 2), (1, 1), (3, 1), (4, 2), (7, 2), (9, 1), (11, 2), (12, 1), (16, 2), (18, 1), (19, 2), (20, 2), (21, 1)], [(0, 1), (1, 2), (2, 1), (4, 2), (7, 1), (9, 2), (11, 2), (12, 1), (16, 2), (20, 2), (21, 1), (24, 1), (25, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb87 : List (List (Nat × Nat)) := [[], [], [], [], [], [(0, 1), (1, 1), (4, 2), (6, 1), (8, 1), (11, 1), (17, 2), (51, 1), (58, 1), (60, 2), (64, 1), (66, 2), (72, 1), (120, 2), (127, 1), (293, 1)], [(0, 1), (1, 1), (2, 1), (4, 2), (6, 2), (9, 1), (12, 2), (17, 2), (51, 1), (60, 2), (64, 1), (66, 1), (68, 1), (72, 2), (120, 2), (127, 1), (293, 1)], [(0, 1), (1, 1), (2, 1), (4, 1), (6, 2), (9, 1), (11, 1), (12, 2), (17, 2), (51, 1), (60, 2), (64, 1), (66, 1), (68, 1), (72, 2), (120, 2), (127, 1), (293, 1)], [], [(1, 1), (2, 2), (3, 2), (4, 2), (7, 2), (8, 2), (9, 1), (11, 1), (12, 2), (17, 2), (19, 1), (51, 1), (60, 2), (64, 1), (66, 1), (68, 1), (72, 2), (120, 2), (127, 1), (293, 1)], [(0, 1), (2, 1), (4, 2), (6, 2), (11, 1), (12, 2), (17, 2), (25, 1), (51, 1), (60, 2), (64, 1), (66, 1), (68, 1), (72, 2), (120, 2), (127, 1), (293, 1)], [], [(3, 1), (4, 2), (5, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (17, 2), (19, 2), (51, 1), (60, 1), (64, 1), (66, 2), (72, 1), (77, 1), (120, 1), (127, 2), (293, 2)], [], [], [(1, 1), (5, 1), (6, 1), (8, 2), (12, 2), (14, 1), (16, 2), (19, 2), (20, 1), (60, 1), (64, 2), (66, 2), (68, 2), (72, 1), (120, 1), (127, 2), (293, 2)], [], [], [], [(0, 2), (1, 1), (2, 1), (5, 1), (6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (60, 1), (64, 2), (66, 2), (68, 2), (72, 1), (120, 1), (127, 2), (293, 2)], [(0, 2), (1, 1), (2, 1), (5, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (60, 1), (64, 2), (66, 2), (68, 2), (72, 1), (120, 1), (127, 2), (293, 2)], [], [(0, 2), (1, 1), (3, 1), (4, 1), (6, 1), (8, 1), (9, 1), (12, 2), (17, 2), (51, 1), (58, 2), (60, 2), (66, 1), (68, 2), (72, 2), (120, 1), (127, 1), (293, 2)], [(0, 2), (1, 1), (3, 1), (4, 1), (6, 1), (8, 1), (9, 2), (11, 2), (12, 2), (17, 2), (51, 1), (58, 2), (60, 2), (64, 2), (66, 1), (72, 2), (120, 1), (127, 1), (293, 2)], [(1, 1), (2, 2), (3, 2), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (58, 2), (60, 2), (64, 2), (66, 1), (72, 2), (120, 1), (127, 1), (293, 2)], [], [(0, 2), (1, 1), (3, 1), (4, 1), (6, 1), (8, 1), (9, 1), (12, 2), (17, 2), (51, 1), (58, 2), (60, 2), (64, 2), (66, 1), (72, 2), (120, 1), (127, 1), (293, 2)], [(0, 2), (1, 1), (2, 2), (3, 2), (5, 1), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (58, 2), (60, 2), (64, 2), (66, 1), (72, 2), (120, 1), (127, 1), (293, 2)], [], [(0, 1), (2, 2), (3, 2), (5, 2), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (60, 2), (64, 1), (66, 1), (68, 1), (72, 2), (120, 2), (127, 2), (293, 1)], [], [], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (5, 1), (12, 2), (14, 1), (15, 1), (16, 2), (58, 1), (60, 1), (64, 1), (66, 2), (72, 1), (120, 2), (127, 2), (293, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 2), (8, 1), (58, 1), (60, 1), (64, 1), (66, 2), (72, 1), (120, 2), (127, 2), (293, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (5, 1), (12, 2), (14, 1), (58, 1), (60, 1), (64, 1), (66, 2), (72, 1), (120, 2), (127, 2), (293, 1)], [], [(1, 1), (2, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (66, 1), (68, 2), (72, 2), (127, 1)], [(1, 2), (2, 2), (3, 2), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (66, 1), (68, 2), (72, 2), (127, 1)], [(1, 1), (3, 1), (4, 1), (6, 1), (8, 1), (9, 1), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (66, 1), (68, 2), (72, 2), (127, 1)], [(1, 1), (2, 2), (3, 2), (4, 1), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (66, 1), (68, 2), (72, 2), (127, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 1), (6, 2), (9, 2), (11, 2), (12, 1), (17, 2), (51, 1), (58, 1), (60, 2), (127, 1)], [(1, 1), (2, 2), (3, 2), (4, 1), (8, 2), (9, 1), (11, 2), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (66, 1), (72, 2), (127, 1)], [], [(1, 1), (3, 2), (6, 1), (8, 1), (9, 1), (12, 1), (17, 2), (51, 1), (60, 2), (115, 1), (127, 1)], [(1, 1), (2, 2), (3, 2), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (64, 2), (66, 1), (72, 2), (120, 1), (127, 1)], [], [], [(1, 1), (2, 2), (3, 2), (8, 2), (9, 1), (12, 2), (17, 2), (51, 1), (58, 1), (60, 2), (64, 2), (66, 1), (72, 2), (127, 1), (181, 1)], [], [(2, 2), (3, 2), (5, 2), (6, 2), (11, 1), (17, 2), (51, 1), (58, 2), (60, 1), (66, 2), (68, 1), (72, 1), (127, 2)], [], [], [], [], [(2, 2), (3, 2), (5, 2), (6, 2), (9, 1), (14, 2), (16, 1), (17, 2), (51, 1), (58, 2), (60, 1), (66, 2), (68, 1), (72, 1), (127, 2)], [(3, 1), (4, 1), (5, 1), (8, 2), (9, 1), (12, 2), (51, 1), (58, 2), (60, 1), (66, 2), (68, 1), (72, 1), (127, 2)], [], [(2, 2), (3, 1), (4, 1), (5, 2), (6, 2), (11, 1), (17, 2), (51, 1), (58, 2), (60, 1), (72, 1), (127, 2)], [], [], [(2, 2), (3, 2), (5, 2), (6, 2), (9, 1), (11, 1), (14, 2), (17, 2), (51, 1), (58, 2), (60, 1), (66, 2), (72, 1), (73, 1), (127, 2)], [(1, 1), (4, 2), (7, 2), (11, 1), (71, 1), (127, 2)], [], [(2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (9, 1), (14, 2), (17, 2), (51, 1), (58, 2), (60, 1), (64, 1), (66, 2), (72, 1), (120, 2), (127, 2), (130, 1)], [], [], [], [(0, 2), (1, 2), (3, 2), (5, 2), (6, 2), (9, 2), (11, 2), (12, 1), (17, 1), (51, 1), (64, 2), (66, 2), (68, 2), (72, 1), (120, 1), (293, 2), (314, 1)], [], [], [], [(0, 2), (3, 2), (4, 1), (9, 2), (11, 1), (12, 1), (58, 2), (64, 1), (66, 1), (68, 1), (72, 2), (120, 1), (293, 1), (392, 1)], [], [], [(1, 2), (2, 1), (4, 1), (5, 2), (8, 2), (9, 1), (12, 2), (16, 1), (17, 1), (19, 1), (20, 2), (51, 1), (58, 2), (130, 2), (293, 1), (470, 1)], [], [], [], [], [], [], [(1, 1), (2, 2), (4, 1), (5, 2), (8, 1), (9, 2), (12, 1), (17, 1), (51, 2), (57, 1), (58, 2), (66, 2), (68, 1), (72, 1)], [(1, 1), (2, 1), (4, 2), (5, 2), (8, 2), (9, 1), (12, 2), (17, 1), (51, 2)], [], [(0, 1), (1, 1), (3, 1), (4, 1), (5, 2), (6, 1), (7, 1), (9, 1), (12, 2), (17, 1), (18, 1), (19, 2), (51, 2)], [(1, 2), (2, 1), (4, 1), (5, 2), (8, 1), (9, 2), (12, 2), (17, 1), (24, 1), (25, 2), (51, 2)], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb88 : List (List (Nat × Nat)) := [[], [], [], [(0, 2), (1, 2), (2, 2), (3, 2), (5, 1), (6, 2), (7, 1), (8, 1), (10, 1), (11, 2), (14, 2), (15, 1), (19, 2), (20, 2), (24, 2), (25, 1), (58, 1), (60, 1), (67, 2), (137, 2), (173, 1)], [], [(0, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (11, 2), (24, 1), (25, 2), (57, 2), (58, 2), (137, 1), (172, 1), (173, 2)], [(0, 2), (4, 1), (5, 1), (9, 1), (11, 1), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (67, 1), (137, 1), (172, 1), (173, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (11, 2), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (67, 1), (137, 1), (172, 1), (173, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (10, 1), (11, 2), (14, 1), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (67, 1), (137, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 2), (14, 2), (15, 1), (20, 2), (24, 2), (25, 2), (57, 2), (58, 2), (60, 2), (67, 1), (137, 1), (172, 1), (173, 2)], [], [], [], [], [], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 1), (7, 1), (9, 1), (10, 1), (11, 1), (14, 1), (15, 2), (20, 1), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (67, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (5, 1), (6, 2), (7, 1), (8, 1), (10, 1), (11, 2), (14, 2), (15, 1), (19, 2), (20, 2), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (67, 2), (137, 2), (172, 2), (173, 1)], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (14, 1), (15, 2), (20, 1), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (67, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (5, 2), (6, 2), (7, 1), (8, 1), (9, 1), (11, 2), (19, 2), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (67, 2), (137, 2), (172, 2), (173, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (9, 1), (10, 1), (11, 1), (14, 1), (15, 2), (19, 1), (20, 1), (24, 2), (25, 1), (57, 1), (58, 2), (64, 1), (66, 2), (137, 1), (172, 2), (173, 1)], [(0, 2), (1, 2), (3, 2), (4, 1), (5, 2), (6, 2), (7, 1), (8, 1), (9, 2), (14, 1), (15, 2), (19, 1), (20, 1), (24, 2), (25, 1), (57, 1), (58, 2), (137, 1), (172, 2), (173, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (5, 1), (9, 2), (10, 1), (19, 2), (24, 2), (25, 1), (57, 1), (58, 2), (137, 1), (172, 2), (173, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 1), (5, 1), (9, 1), (10, 1), (11, 1), (14, 1), (15, 2), (19, 1), (20, 1), (24, 2), (25, 1), (57, 1), (58, 2), (137, 1), (172, 2), (173, 1)], [], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 1), (9, 1), (10, 2), (14, 2), (15, 1), (19, 2), (20, 2), (57, 1), (58, 2), (137, 1), (172, 2), (173, 1)], [], [], [(3, 2), (4, 1), (11, 2), (14, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (57, 2), (58, 2), (60, 2), (67, 1), (137, 2), (172, 1), (173, 2)], [], [(0, 1), (3, 2), (6, 1), (7, 2), (8, 2), (10, 1), (14, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (57, 2), (58, 1), (137, 2), (172, 1), (173, 2)], [], [], [], [(0, 1), (2, 2), (7, 2), (10, 1), (12, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (57, 2), (58, 1), (137, 2), (172, 1), (173, 2)], [], [(0, 2), (3, 1), (4, 2), (5, 1), (14, 2), (15, 1), (19, 1), (20, 2), (21, 1), (57, 2), (58, 1), (137, 2), (172, 1), (173, 2)], [(1, 2), (2, 2), (5, 2), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (14, 1), (15, 2), (19, 1), (20, 1), (24, 2), (25, 1), (58, 2), (60, 1), (67, 2), (137, 1)], [(0, 2), (1, 2), (5, 2), (9, 2), (10, 1), (11, 1), (19, 2), (24, 2), (25, 1), (58, 2), (60, 1), (67, 2), (137, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 1), (9, 1), (10, 2), (11, 1), (14, 2), (15, 1), (19, 2), (20, 2), (58, 2), (60, 1), (67, 2), (137, 1)], [(1, 2), (2, 2), (5, 2), (6, 2), (7, 1), (8, 1), (9, 1), (11, 1), (14, 1), (15, 2), (19, 1), (20, 1), (24, 2), (25, 1), (58, 2), (60, 1), (137, 1)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (14, 2), (15, 1), (19, 2), (20, 2), (58, 2), (60, 1), (66, 1), (67, 2), (137, 1)], [(1, 2), (3, 2), (4, 1), (5, 1), (9, 1), (10, 1), (11, 1), (14, 1), (15, 2), (19, 1), (20, 1), (24, 2), (25, 1), (58, 2), (117, 1), (137, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 1), (5, 1), (9, 1), (10, 2), (11, 1), (14, 2), (15, 1), (19, 2), (20, 2), (58, 2), (60, 1), (64, 2), (66, 1), (67, 2), (120, 1), (137, 1)], [], [(0, 2), (1, 1), (3, 1), (4, 2), (10, 2), (11, 1), (14, 2), (15, 1), (19, 2), (20, 2), (58, 2), (137, 1), (236, 1)], [], [], [], [(2, 1), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (8, 2), (10, 1), (11, 2), (14, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (58, 1), (60, 2), (67, 1), (137, 2)], [], [(3, 2), (4, 1), (11, 2), (14, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (58, 1), (60, 2), (67, 1), (137, 2)], [], [(1, 2), (3, 2), (4, 2), (9, 1), (11, 1), (19, 2), (20, 1), (24, 1), (25, 2), (58, 1), (60, 2), (67, 1), (137, 2)], [], [(0, 1), (2, 1), (4, 1), (9, 1), (10, 2), (11, 2), (14, 2), (15, 1), (19, 1), (20, 2), (22, 1), (58, 1), (60, 2), (67, 1), (137, 2)], [], [(3, 2), (4, 1), (6, 1), (7, 2), (8, 2), (10, 1), (11, 2), (14, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (58, 1), (60, 2), (65, 1), (137, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (11, 2), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (58, 1), (60, 2), (66, 2), (67, 1), (73, 1), (137, 2)], [], [(0, 2), (2, 1), (6, 1), (7, 2), (8, 2), (9, 1), (14, 2), (15, 1), (19, 1), (20, 2), (80, 1), (137, 2)], [(4, 1), (9, 1), (11, 1), (15, 2), (19, 2), (20, 1), (24, 1), (25, 2), (58, 1), (60, 2), (64, 1), (66, 2), (67, 1), (120, 2), (130, 1), (137, 2)], [], [], [], [(0, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 1), (9, 2), (10, 2), (11, 2), (14, 2), (15, 1), (19, 1), (20, 2), (24, 1), (25, 2), (57, 1), (60, 1), (67, 2), (172, 2), (173, 1), (314, 1)], [], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (11, 1), (14, 2), (15, 1), (19, 2), (20, 2), (24, 2), (25, 1), (57, 1), (64, 2), (66, 1), (172, 1), (173, 1), (216, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 2), (5, 2), (9, 1), (10, 2), (11, 1), (14, 2), (15, 2), (20, 1), (57, 2), (60, 1), (64, 2), (66, 1), (67, 2), (120, 1), (130, 2), (172, 1), (173, 2), (470, 1)], [], [], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (5, 1), (9, 2), (10, 1), (11, 2), (14, 1), (15, 2), (19, 1), (20, 1), (57, 1), (60, 2), (67, 1)], [(1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (8, 1), (9, 1), (10, 1), (14, 2), (15, 1), (20, 2)], [(0, 2), (1, 1), (3, 2), (4, 2), (5, 2), (10, 1), (11, 2), (13, 1), (15, 2), (19, 1), (20, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb89 : List (List (Nat × Nat)) := [[], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (18, 2), (19, 2), (58, 1), (60, 1), (63, 1), (65, 2), (72, 2), (137, 2), (234, 1)], [(1, 1), (5, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (18, 1), (19, 1), (25, 1), (57, 2), (58, 1), (60, 1), (63, 2), (65, 2), (72, 2), (137, 1), (233, 1), (234, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (9, 2), (10, 1), (18, 1), (19, 1), (25, 1), (57, 2), (60, 1), (63, 2), (65, 2), (137, 1), (233, 1), (234, 2)], [(1, 1), (5, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (18, 1), (19, 1), (25, 1), (57, 2), (58, 1), (63, 2), (72, 2), (137, 1), (233, 1), (234, 2)], [(1, 1), (5, 2), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (18, 1), (19, 1), (25, 1), (57, 2), (60, 1), (63, 2), (65, 2), (137, 1), (233, 1), (234, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (18, 2), (19, 1), (57, 2), (58, 2), (60, 2), (63, 2), (65, 1), (72, 1), (137, 1), (233, 1), (234, 2)], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (18, 2), (19, 2), (57, 1), (58, 1), (60, 1), (63, 2), (65, 2), (72, 2), (137, 2), (233, 2), (234, 1)], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (9, 2), (10, 2), (11, 1), (12, 1), (18, 2), (19, 2), (57, 1), (58, 1), (60, 1), (63, 1), (65, 2), (72, 2), (137, 2), (233, 2), (234, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (18, 2), (19, 2), (57, 1), (58, 1), (60, 1), (63, 1), (65, 2), (72, 2), (137, 2), (233, 2), (234, 1)], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (7, 1), (8, 2), (9, 2), (10, 2), (18, 1), (25, 1), (57, 1), (60, 2), (63, 1), (65, 1), (137, 2), (233, 2), (234, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (9, 1), (10, 2), (11, 1), (12, 2), (18, 2), (57, 1), (58, 2), (63, 1), (64, 1), (72, 1), (137, 1), (233, 2), (234, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 2), (18, 2), (57, 1), (58, 2), (63, 2), (72, 1), (137, 1), (233, 2), (234, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (18, 2), (57, 1), (58, 2), (63, 2), (72, 1), (137, 1), (233, 2), (234, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (9, 1), (10, 2), (11, 2), (12, 2), (18, 2), (57, 1), (58, 2), (63, 2), (72, 1), (137, 1), (233, 2), (234, 1)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (7, 2), (9, 1), (10, 2), (19, 2), (25, 2), (57, 1), (60, 2), (63, 2), (65, 1), (137, 1), (233, 2), (234, 1)], [], [], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 2), (5, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (18, 1), (25, 2), (57, 2), (60, 1), (63, 1), (65, 2), (137, 2), (233, 1), (234, 2)], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (9, 2), (10, 1), (12, 2), (18, 1), (25, 2), (57, 2), (58, 2), (60, 2), (63, 1), (65, 1), (72, 1), (137, 2), (233, 1), (234, 2)], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (9, 1), (10, 1), (12, 2), (14, 1), (18, 1), (25, 2), (57, 2), (60, 1), (63, 1), (65, 2), (137, 2), (233, 1), (234, 2)], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 2), (7, 2), (9, 1), (10, 1), (11, 2), (12, 1), (21, 1), (57, 2), (58, 1), (63, 1), (72, 2), (137, 2), (233, 1), (234, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (18, 2), (58, 2), (60, 1), (63, 2), (65, 2), (72, 1), (137, 1)], [(6, 1), (18, 2), (63, 2), (137, 1)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (11, 1), (12, 1), (19, 2), (25, 2), (58, 1), (60, 2), (63, 2), (65, 1), (72, 2), (137, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 1), (11, 2), (12, 2), (18, 2), (58, 2), (60, 1), (63, 2), (72, 1), (137, 1)], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (8, 2), (9, 1), (19, 2), (25, 2), (58, 1), (60, 2), (63, 2), (65, 1), (137, 1)], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 1), (11, 2), (12, 2), (18, 2), (58, 2), (63, 2), (72, 1), (117, 1), (137, 1)], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (11, 1), (19, 2), (25, 2), (60, 2), (63, 2), (65, 1), (115, 1), (137, 1)], [], [(0, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (7, 1), (11, 1), (19, 2), (25, 2), (60, 2), (63, 2), (65, 1), (137, 1), (174, 1)], [], [], [], [], [], [(1, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 1), (8, 1), (9, 2), (11, 2), (12, 2), (18, 1), (25, 2), (58, 2), (60, 1), (63, 1), (65, 2), (72, 1), (137, 2)], [], [(1, 2), (5, 1), (6, 2), (7, 2), (9, 2), (10, 1), (11, 2), (12, 2), (18, 1), (25, 2), (58, 2), (60, 1), (63, 1), (65, 2), (72, 1), (137, 2)], [], [(1, 2), (5, 1), (6, 2), (11, 1), (12, 1), (17, 1), (18, 1), (25, 2), (58, 2), (60, 1), (63, 1), (65, 2), (72, 1), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (9, 2), (11, 1), (12, 1), (22, 1), (58, 1), (60, 2), (63, 1), (65, 1), (72, 2), (137, 2)], [], [], [(1, 2), (5, 1), (6, 1), (8, 1), (9, 2), (11, 2), (12, 2), (18, 1), (25, 2), (58, 2), (60, 1), (63, 1), (65, 1), (67, 1), (72, 1), (137, 2)], [], [(1, 2), (5, 1), (6, 2), (7, 2), (8, 1), (9, 2), (11, 2), (12, 2), (18, 1), (25, 2), (71, 1), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (58, 1), (60, 2), (65, 1), (72, 2), (80, 1), (137, 2)], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (11, 1), (12, 1), (18, 1), (25, 2), (58, 2), (60, 1), (65, 2), (72, 1), (127, 1), (137, 2)], [], [], [(6, 1), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (17, 2), (18, 1), (19, 2), (57, 1), (60, 1), (65, 2), (233, 2), (234, 1), (314, 1)], [], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 1), (10, 2), (12, 2), (18, 2), (19, 1), (25, 1), (57, 1), (58, 2), (60, 1), (63, 1), (64, 2), (65, 2), (72, 1), (233, 1), (234, 1), (274, 1)], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (7, 2), (9, 2), (10, 1), (17, 2), (25, 1), (57, 2), (58, 2), (60, 2), (65, 2), (67, 2), (72, 1), (233, 1), (234, 2), (470, 1)], [], [], [], [], [], [], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (11, 1), (12, 1), (25, 2), (57, 1), (58, 1), (60, 1), (65, 2), (72, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (11, 1), (12, 1), (25, 2), (58, 1), (60, 2), (65, 1), (72, 2)], [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1), (8, 2), (11, 1), (12, 1), (13, 1), (25, 2), (58, 2), (60, 1), (65, 2), (72, 1)], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []] + +def comb90 : List (List (Nat × Nat)) := [[(6, 1), (11, 1), (15, 1), (16, 2), (18, 2), (58, 2), (80, 1), (114, 2), (117, 1), (127, 2), (173, 1)], [(1, 1), (3, 1), (6, 1), (7, 2), (11, 2), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (117, 1), (120, 2), (121, 2), (173, 1)], [], [], [], [(1, 2), (3, 2), (6, 2), (7, 1), (11, 1), (18, 1), (58, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (117, 2), (120, 1), (121, 1), (173, 2)], [(3, 2), (8, 1), (9, 2), (11, 2), (18, 2), (57, 1), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 2), (114, 2), (115, 1), (120, 1), (121, 1), (127, 2), (173, 1)], [], [], [], [], [(1, 1), (3, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1), (57, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (71, 1), (72, 1), (74, 2), (75, 1), (80, 1), (114, 1), (115, 2), (120, 2), (121, 2)], [(3, 1), (6, 1), (8, 1), (9, 2), (18, 1), (57, 1), (58, 1), (60, 2), (77, 1), (80, 1), (114, 1), (115, 1), (117, 1), (120, 2), (173, 2)], [(6, 1), (8, 1), (9, 2), (11, 1), (18, 1), (57, 1), (58, 1), (80, 1), (114, 1), (115, 1), (173, 2)], [(1, 1), (3, 1), (7, 2), (11, 2), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (117, 1), (120, 2), (121, 2), (173, 1)], [(0, 2), (1, 2), (3, 1), (7, 1), (8, 1), (9, 2), (12, 1), (15, 2), (18, 2), (20, 1), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (117, 1), (120, 2), (121, 2), (173, 1)], [(1, 1), (3, 1), (6, 1), (7, 2), (11, 2), (18, 2), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (117, 1), (120, 2), (121, 2), (173, 1)], [(1, 1), (3, 1), (7, 2), (8, 1), (11, 2), (18, 2), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (117, 1), (120, 2), (121, 2), (173, 1)], [], [], [], [], [(1, 1), (7, 2), (58, 2), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 1), (114, 1), (117, 1), (121, 2)], [(1, 1), (3, 1), (6, 2), (7, 2), (8, 1), (9, 2), (57, 2), (58, 2), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (115, 2), (117, 1), (120, 2), (121, 2)], [], [], [], [], [], [(1, 2), (3, 2), (6, 2), (7, 1), (8, 1), (9, 2), (11, 2), (57, 1), (58, 1), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 2), (115, 1), (120, 1), (121, 1)], [(1, 2), (3, 2), (6, 1), (7, 1), (8, 2), (9, 1), (57, 1), (58, 1), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 2), (115, 2), (117, 2), (120, 1), (121, 1)], [(6, 2), (7, 1), (8, 1), (9, 2), (15, 2), (16, 1), (57, 1), (80, 2), (114, 2), (115, 1), (117, 2), (127, 1)], [(0, 1), (1, 2), (7, 1), (12, 2), (57, 1), (80, 2), (114, 2), (115, 1), (117, 2), (127, 1)], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (57, 1), (80, 2), (114, 2), (115, 1), (117, 2), (127, 1)], [], [], [], [], [], [], [(1, 1), (3, 1), (7, 2), (8, 1), (9, 2), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 1), (115, 1), (120, 2), (121, 2), (127, 1), (173, 1)], [(1, 1), (3, 1), (6, 2), (7, 2), (8, 2), (9, 1), (12, 1), (15, 2), (16, 1), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 1), (115, 1), (120, 2), (121, 2), (127, 1), (173, 1)], [(1, 1), (3, 1), (7, 2), (8, 1), (9, 2), (15, 2), (16, 1), (18, 2), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 1), (115, 1), (120, 2), (121, 2), (127, 1), (173, 1)], [(1, 1), (3, 1), (6, 1), (7, 2), (8, 2), (9, 1), (11, 1), (57, 1), (58, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (115, 2), (120, 2), (121, 2)], [(1, 1), (3, 1), (6, 2), (7, 2), (8, 1), (9, 2), (57, 1), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (115, 1), (117, 1), (120, 2), (121, 2)], [(1, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 1), (57, 1), (58, 2), (60, 2), (63, 2), (64, 2), (66, 2), (67, 1), (72, 1), (80, 2), (114, 1), (115, 2), (117, 1), (120, 1), (121, 2)], [], [], [], [], [], [], [], [], [], [], [(1, 2), (3, 2), (6, 2), (7, 1), (8, 2), (9, 1), (18, 2), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 1), (115, 2), (117, 2), (120, 1), (121, 1), (173, 1)], [(1, 2), (3, 2), (8, 1), (9, 1), (10, 1), (18, 2), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 1), (115, 2), (117, 2), (120, 1), (121, 1), (173, 1)], [(1, 2), (3, 2), (6, 2), (7, 1), (8, 2), (9, 1), (11, 2), (16, 1), (18, 2), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 1), (115, 2), (117, 2), (120, 1), (121, 1), (173, 1)], [(1, 2), (3, 2), (7, 1), (8, 1), (9, 2), (11, 2), (12, 2), (17, 1), (18, 2), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 1), (115, 2), (117, 2), (120, 1), (121, 1), (173, 1)], [(0, 2), (3, 2), (6, 2), (8, 2), (12, 1), (15, 2), (16, 1), (18, 2), (22, 1), (57, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (80, 1), (114, 1), (115, 2), (117, 2), (120, 1), (121, 1), (173, 1)], [(1, 2), (3, 2), (6, 2), (7, 1), (11, 1), (18, 1), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (80, 2), (117, 2), (120, 1), (121, 1), (173, 2)], [(1, 2), (3, 2), (7, 1), (8, 2), (9, 1), (18, 1), (58, 2), (64, 2), (65, 1), (66, 1), (67, 2), (72, 2), (80, 2), (115, 2), (120, 1), (121, 1), (173, 2)], [(1, 2), (6, 2), (7, 1), (18, 1), (58, 1), (80, 2), (121, 1), (173, 2)], [(3, 2), (11, 1), (58, 1), (64, 2), (71, 1), (73, 1), (74, 2), (80, 2), (117, 2), (120, 1)], [(6, 2), (8, 1), (9, 2), (11, 1), (71, 1), (80, 2), (115, 1), (117, 2)], [], [], [], [], [], [], [(0, 2), (1, 1), (6, 2), (7, 2), (11, 2), (12, 1), (15, 2), (16, 1), (18, 1), (44, 1), (57, 2), (58, 1), (114, 2), (115, 2), (173, 2)], [(1, 1), (3, 2), (6, 2), (7, 2), (11, 1), (18, 1), (57, 2), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (72, 1), (99, 1), (114, 2), (117, 1), (120, 1), (121, 2), (173, 2)], [], [], [], [], [], [(1, 2), (3, 2), (6, 2), (7, 1), (15, 2), (16, 1), (18, 2), (60, 1), (63, 1), (64, 2), (66, 1), (67, 2), (72, 2), (117, 1), (120, 1), (121, 1), (127, 1), (173, 1)], [], [], [], [], [], [], [], [], [], [], [], [(1, 1), (3, 1), (6, 1), (7, 2), (8, 1), (9, 2), (18, 1), (57, 1), (58, 2), (60, 2), (63, 2), (64, 1), (66, 2), (67, 1), (71, 2), (72, 1), (74, 1), (114, 2), (115, 1), (117, 2), (120, 2), (121, 2), (173, 2)], [(1, 2), (3, 1), (6, 1), (7, 1), (8, 2), (9, 1), (11, 1), (57, 1), (58, 1), (60, 2), (63, 2), (64, 1), (65, 2), (66, 1), (67, 2), (68, 1), (72, 2), (114, 2), (115, 2), (117, 1), (120, 2), (121, 1)], [(1, 2), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (57, 1), (58, 2), (60, 1), (63, 2), (64, 1), (66, 2), (67, 2), (72, 1), (114, 2), (115, 1), (117, 2), (120, 2), (121, 1)], [(1, 2), (3, 2), (6, 1), (7, 1), (8, 2), (9, 1), (57, 1), (58, 1), (60, 1), (63, 2), (64, 2), (66, 1), (67, 2), (72, 2), (114, 2), (115, 2), (117, 2), (120, 1), (121, 1)], [], [], [], [], [], [], [], [], []] + +def comb91 : List (List (Nat × Nat)) := [[(1, 1), (4, 1), (6, 2), (7, 2), (9, 1), (13, 1), (15, 2), (16, 1), (19, 2), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (7, 1), (9, 1), (13, 2), (15, 2), (16, 1), (18, 1), (19, 1), (57, 2), (58, 1), (60, 2), (63, 2), (64, 2), (66, 2), (67, 1), (71, 1), (72, 1), (99, 1), (121, 2), (137, 2), (173, 1)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (9, 2), (13, 2), (15, 1), (16, 2), (18, 2), (19, 2), (57, 2), (58, 2), (63, 1), (66, 1), (67, 2), (72, 2), (114, 1), (121, 1), (137, 1), (173, 2)], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (6, 1), (7, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 1), (19, 1), (58, 1), (60, 2), (63, 2), (64, 2), (66, 2), (67, 1), (71, 1), (72, 1), (99, 1), (114, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [], [(0, 1), (2, 2), (3, 1), (13, 1), (15, 1), (16, 2), (18, 2), (19, 2), (57, 2), (58, 2), (60, 2), (63, 1), (64, 2), (66, 1), (67, 2), (71, 1), (72, 2), (77, 1), (114, 1), (121, 1), (137, 1), (173, 2)], [(0, 1), (2, 2), (3, 1), (4, 1), (9, 2), (13, 1), (15, 1), (16, 2), (18, 2), (19, 2), (57, 2), (58, 2), (60, 2), (63, 1), (66, 1), (67, 2), (71, 1), (72, 2), (114, 1), (121, 1), (137, 1), (173, 2)], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (7, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 2), (19, 1), (58, 1), (60, 2), (63, 2), (64, 2), (66, 2), (67, 1), (71, 1), (72, 1), (99, 1), (114, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (4, 2), (7, 1), (9, 1), (13, 2), (15, 2), (16, 1), (18, 1), (19, 1), (58, 1), (60, 2), (63, 2), (64, 2), (66, 2), (67, 1), (71, 1), (72, 1), (99, 1), (114, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [(0, 1), (2, 2), (3, 1), (6, 2), (9, 2), (13, 1), (57, 2), (58, 2), (64, 2), (99, 2), (114, 2), (137, 1)], [], [(1, 1), (6, 1), (7, 2), (13, 2), (57, 2), (58, 1), (60, 2), (71, 1), (114, 1), (137, 2)], [], [], [], [(1, 1), (7, 2), (13, 1), (18, 2), (57, 2), (58, 2), (60, 2), (64, 1), (71, 1), (99, 2), (114, 2), (137, 1), (173, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (57, 2), (58, 2), (64, 1), (71, 1), (99, 2), (114, 2), (137, 1)], [(1, 1), (7, 2), (57, 2), (60, 2), (64, 1), (71, 1), (99, 2), (114, 2), (137, 1)], [(1, 1), (13, 2), (18, 1), (19, 2), (57, 2), (58, 1), (60, 2), (71, 1), (114, 1), (137, 2)], [], [], [(4, 1), (13, 2), (15, 1), (16, 2), (18, 1), (19, 2), (57, 2), (58, 1), (60, 2), (71, 1), (114, 1), (137, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (7, 2), (9, 1), (57, 2), (58, 1), (60, 2), (71, 1), (114, 1), (137, 2)], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (7, 1), (9, 1), (13, 2), (15, 2), (16, 1), (18, 1), (19, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (7, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 2), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [(0, 2), (1, 2), (2, 1), (3, 2), (7, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 2), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (13, 2), (58, 1), (60, 1), (71, 1), (117, 1), (137, 2)], [(1, 1), (6, 1), (7, 2), (13, 2), (60, 2), (71, 1), (115, 1), (137, 2)], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (9, 1), (13, 2), (58, 1), (60, 2), (64, 2), (71, 1), (120, 1), (137, 2)], [], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 2), (6, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 1), (19, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (2, 2), (3, 1), (6, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 1), (19, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (2, 1), (3, 2), (4, 2), (5, 1), (6, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 1), (19, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (9, 1), (13, 1), (15, 2), (16, 2), (18, 1), (19, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (2, 1), (3, 2), (4, 2), (6, 1), (9, 1), (13, 1), (15, 2), (16, 1), (17, 1), (18, 1), (19, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [(0, 2), (2, 1), (3, 2), (4, 2), (6, 1), (9, 1), (15, 2), (16, 1), (18, 2), (22, 1), (57, 2), (58, 2), (60, 1), (63, 2), (64, 2), (66, 2), (67, 1), (71, 2), (72, 1), (99, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (7, 1), (9, 2), (13, 1), (15, 1), (16, 2), (18, 2), (19, 2), (58, 1), (66, 1), (67, 2), (121, 1), (137, 2), (173, 2)], [(0, 1), (2, 2), (3, 1), (9, 2), (13, 2), (18, 1), (58, 1), (65, 1), (66, 1), (67, 2), (72, 2), (121, 1), (137, 2), (173, 2)], [(13, 2), (18, 1), (58, 1), (121, 1), (137, 2), (173, 2)], [], [], [], [(4, 1), (9, 2), (60, 2), (64, 1), (115, 1), (120, 2), (127, 1), (130, 1), (131, 2), (137, 2)], [(0, 2), (2, 1), (3, 2), (4, 1), (58, 1), (60, 2), (127, 1), (137, 2)], [], [], [], [(1, 1), (4, 2), (7, 2), (9, 2), (15, 1), (16, 2), (19, 1), (44, 1), (57, 2), (63, 1), (64, 1), (66, 1), (67, 2), (72, 2), (99, 2), (114, 2), (121, 1), (173, 2)], [], [(1, 2), (4, 1), (7, 1), (13, 1), (15, 1), (16, 2), (18, 2), (19, 2), (63, 1), (64, 1), (66, 1), (67, 2), (72, 2), (99, 1), (114, 1), (121, 1), (157, 1), (173, 2)], [], [], [], [], [(0, 1), (2, 2), (3, 1), (6, 1), (9, 1), (13, 1), (15, 2), (16, 1), (18, 2), (57, 1), (63, 2), (64, 2), (66, 2), (67, 1), (72, 1), (99, 1), (114, 1), (121, 2), (173, 1)], [], [], [], [], [], [(1, 2), (6, 1), (7, 1), (13, 2), (57, 2), (60, 1), (64, 1), (71, 2), (99, 2)], [], [], [], [], [(0, 2), (2, 1), (3, 2), (6, 2), (9, 2), (13, 2), (15, 1), (16, 2), (18, 2), (19, 2), (57, 1), (58, 1), (63, 1), (64, 1), (66, 1), (67, 2), (71, 1), (72, 2), (99, 2), (115, 2), (121, 1), (127, 2), (131, 1), (173, 2)], [], [(0, 1), (2, 2), (3, 1), (4, 1), (6, 2), (9, 2), (15, 1), (16, 2), (18, 1), (19, 2), (57, 1), (60, 2), (63, 1), (64, 1), (65, 2), (68, 1), (71, 1), (99, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (6, 2), (7, 2), (9, 2), (13, 1), (57, 1), (60, 2), (63, 1), (64, 1), (66, 1), (71, 1), (72, 2), (99, 2)], [(1, 1), (6, 2), (7, 2), (13, 1), (57, 1), (60, 2), (63, 1), (64, 1), (71, 1), (99, 2)], [], [], [], [], [], [], [], [], []] + +def comb92 : List (List (Nat × Nat)) := [[(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (11, 1), (13, 1), (15, 1), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [], [], [], [], [(0, 1), (4, 2), (5, 2), (7, 2), (11, 1), (15, 2), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1), (293, 1)], [], [], [(1, 2), (2, 2), (3, 1), (5, 1), (6, 2), (8, 1), (11, 2), (15, 2), (34, 2), (60, 1), (63, 1), (65, 2), (127, 2), (293, 2)], [], [], [(0, 1), (1, 2), (2, 2), (3, 1), (4, 1), (5, 2), (6, 1), (7, 1), (8, 1), (11, 1), (12, 1), (13, 1), (58, 2), (71, 1), (74, 2), (75, 1), (80, 1), (127, 1), (293, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 1), (4, 1), (5, 2), (6, 2), (7, 1), (11, 1), (13, 1), (15, 1), (58, 1), (60, 1), (63, 1), (65, 2), (80, 2), (127, 1), (293, 1)], [], [(1, 2), (2, 2), (5, 1), (7, 2), (8, 1), (13, 2), (15, 2), (20, 1), (34, 2), (60, 1), (63, 1), (65, 2), (127, 2), (293, 2)], [], [], [], [(1, 2), (2, 2), (3, 1), (5, 1), (6, 2), (8, 2), (11, 2), (13, 2), (15, 2), (34, 2), (60, 1), (63, 1), (65, 2), (127, 2), (293, 2)], [(1, 2), (2, 2), (3, 1), (5, 1), (8, 1), (11, 2), (13, 2), (15, 2), (34, 2), (60, 1), (63, 1), (65, 2), (127, 2), (293, 2)], [], [(0, 2), (1, 2), (5, 1), (8, 1), (13, 2), (34, 1), (60, 1), (63, 1), (64, 1), (65, 2), (127, 1), (293, 2)], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (13, 1), (58, 2), (80, 1), (127, 2), (293, 1)], [], [], [(1, 2), (2, 2), (3, 1), (5, 1), (6, 2), (8, 1), (11, 2), (15, 2), (34, 2), (60, 1), (63, 1), (65, 2), (121, 1), (127, 1), (293, 2)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (15, 2), (34, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1), (293, 2)], [], [], [], [(0, 1), (5, 2), (7, 2), (15, 1), (58, 2), (80, 1), (127, 2), (293, 1)], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 2), (8, 1), (12, 1), (58, 2), (80, 1), (127, 2), (293, 1)], [(0, 1), (1, 1), (4, 2), (5, 2), (7, 2), (14, 1), (58, 2), (80, 1), (127, 2), (293, 1)], [], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 2), (8, 2), (11, 2), (13, 2), (34, 1), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (13, 2), (34, 1), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (1, 2), (7, 2), (8, 1), (13, 2), (34, 1), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 2), (7, 2), (8, 2), (13, 2), (34, 1), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (6, 2), (7, 2), (11, 1), (13, 1), (58, 2), (60, 1), (80, 1), (127, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (13, 1), (58, 2), (80, 1), (117, 1), (127, 2)], [], [], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (6, 1), (8, 1), (13, 1), (20, 2), (58, 2), (80, 1), (127, 2), (174, 1)], [(0, 1), (1, 1), (3, 1), (4, 2), (5, 2), (6, 2), (13, 1), (20, 2), (58, 2), (80, 1), (127, 2), (236, 1)], [], [(0, 2), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (11, 2), (15, 2), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [], [(0, 1), (2, 2), (3, 1), (6, 2), (7, 2), (8, 1), (11, 2), (15, 2), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (2, 1), (3, 2), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (11, 2), (15, 2), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (15, 2), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (10, 1), (15, 2), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 1), (8, 1), (15, 2), (22, 1), (34, 2), (58, 2), (60, 1), (63, 1), (65, 2), (80, 1), (127, 1)], [(0, 1), (2, 2), (4, 2), (7, 2), (11, 1), (15, 1), (58, 2), (60, 1), (66, 1), (67, 2), (80, 1), (127, 2)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (11, 1), (12, 1), (14, 2), (71, 1), (73, 1), (74, 2), (127, 2)], [(1, 1), (4, 2), (7, 2), (11, 1), (71, 1), (127, 2)], [], [(2, 2), (3, 1), (6, 2), (8, 1), (12, 1), (14, 2), (130, 1), (131, 2)], [], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (5, 1), (6, 1), (7, 2), (11, 2), (13, 2), (14, 2), (15, 2), (44, 1), (58, 2), (60, 2), (63, 2), (65, 1), (80, 1), (293, 2)], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 1), (5, 2), (6, 2), (7, 2), (8, 2), (11, 1), (13, 1), (15, 1), (34, 2), (58, 2), (64, 2), (80, 1), (293, 1), (392, 1)], [], [], [], [(0, 2), (2, 2), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 2), (34, 1), (58, 1), (60, 1), (63, 1), (65, 2), (80, 2), (293, 1)], [], [], [], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (13, 1), (15, 2), (34, 2), (57, 1), (58, 1), (60, 1), (63, 1), (65, 2), (80, 2)], [], [], [], [], [(0, 2), (2, 2), (3, 1), (4, 1), (6, 2), (7, 1), (8, 1), (11, 1), (12, 2), (15, 1), (34, 1), (58, 1), (60, 2), (63, 2), (65, 1), (80, 2), (127, 2), (131, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (12, 2), (15, 1), (34, 1), (58, 1), (60, 2), (63, 2), (65, 1), (71, 2), (74, 1), (80, 2)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (34, 1), (58, 2), (60, 1), (63, 2), (65, 1), (67, 1), (80, 1)], [(0, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (34, 1), (58, 2), (60, 1), (63, 2), (65, 2), (80, 1)], [], [], [], [], [], [], [], [], []] + +def comb93 : List (List (Nat × Nat)) := [[(0, 1), (1, 2), (2, 1), (6, 1), (8, 1), (12, 2), (18, 1), (19, 1), (58, 2), (60, 1), (71, 2), (72, 1), (137, 1)], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 2), (18, 2), (19, 2), (58, 2), (63, 2), (121, 2), (137, 2), (173, 1)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (6, 1), (8, 2), (9, 1), (12, 2), (19, 2), (57, 2), (60, 2), (71, 1), (72, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [], [], [], [(0, 1), (1, 2), (6, 2), (7, 1), (8, 1), (19, 2), (57, 1), (58, 2), (63, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 1), (1, 1), (2, 1), (4, 1), (6, 1), (8, 2), (9, 2), (12, 2), (19, 1), (57, 2), (60, 1), (63, 2), (71, 2), (72, 2), (74, 2), (75, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (6, 1), (7, 1), (8, 1), (9, 2), (12, 1), (18, 1), (57, 2), (60, 1), (64, 2), (71, 2), (72, 1), (77, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [(0, 2), (1, 1), (6, 1), (7, 2), (8, 1), (18, 1), (19, 1), (57, 2), (58, 1), (63, 2), (121, 1), (137, 1), (172, 1), (173, 2)], [], [], [(0, 1), (1, 2), (7, 1), (8, 1), (18, 2), (19, 2), (57, 1), (58, 2), (63, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 2), (18, 2), (19, 2), (57, 1), (58, 2), (63, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [(0, 1), (1, 2), (6, 2), (7, 1), (8, 2), (18, 2), (19, 2), (57, 1), (58, 2), (63, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 1), (1, 2), (3, 1), (4, 1), (6, 2), (7, 2), (8, 2), (9, 1), (12, 2), (18, 2), (19, 2), (57, 1), (58, 1), (60, 1), (71, 2), (72, 1), (121, 2), (137, 2), (172, 2), (173, 1)], [(8, 1), (18, 2), (57, 1), (58, 2), (63, 2), (64, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [], [], [], [(3, 2), (7, 2), (8, 2), (9, 1), (12, 1), (18, 1), (57, 2), (58, 2), (60, 2), (63, 2), (71, 1), (72, 2), (121, 1), (137, 2), (172, 1), (173, 2)], [], [(0, 1), (1, 2), (6, 2), (7, 1), (8, 1), (19, 2), (57, 1), (58, 2), (63, 2), (137, 1), (172, 2), (173, 1)], [(2, 1), (3, 2), (9, 1), (19, 2), (57, 1), (58, 2), (63, 2), (71, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [], [], [(3, 2), (6, 1), (7, 1), (8, 2), (9, 1), (12, 1), (19, 1), (57, 2), (58, 2), (60, 2), (63, 2), (71, 1), (72, 2), (121, 1), (137, 2), (172, 1), (173, 2)], [], [], [], [(2, 2), (3, 2), (7, 1), (9, 1), (12, 2), (19, 1), (57, 2), (58, 2), (60, 2), (63, 2), (71, 1), (72, 2), (121, 1), (137, 2), (172, 1), (173, 2)], [], [(9, 2), (21, 1), (57, 2), (58, 1), (121, 1), (137, 2), (172, 1), (173, 2)], [(0, 1), (1, 2), (2, 2), (3, 1), (6, 2), (7, 1), (8, 2), (9, 2), (18, 2), (63, 2), (137, 1)], [(8, 1), (18, 2), (63, 2), (137, 1)], [], [(0, 1), (1, 2), (2, 2), (7, 2), (8, 1), (9, 1), (12, 1), (18, 2), (58, 1), (60, 2), (63, 1), (71, 1), (72, 2), (137, 1)], [], [(0, 1), (1, 1), (2, 2), (6, 1), (7, 1), (8, 1), (12, 1), (18, 1), (58, 2), (60, 1), (63, 2), (71, 2), (72, 2), (137, 2)], [], [], [(0, 2), (1, 1), (2, 1), (3, 1), (7, 1), (8, 2), (9, 2), (12, 1), (18, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 2), (115, 1), (137, 2)], [], [(0, 2), (2, 1), (3, 1), (7, 2), (8, 2), (9, 2), (12, 1), (18, 1), (58, 2), (60, 1), (63, 2), (71, 1), (72, 2), (121, 1), (137, 2), (173, 2), (174, 1)], [], [(0, 2), (2, 1), (3, 2), (8, 2), (9, 1), (18, 1), (58, 1), (64, 2), (121, 1), (137, 2), (173, 2), (181, 1)], [(0, 1), (1, 2), (6, 2), (7, 1), (8, 1), (19, 2), (63, 2), (137, 1)], [(0, 1), (1, 2), (3, 1), (6, 2), (7, 1), (8, 1), (9, 2), (19, 2), (63, 2), (137, 1)], [], [(0, 1), (1, 2), (2, 2), (4, 2), (5, 1), (6, 2), (8, 1), (9, 1), (12, 1), (19, 2), (58, 1), (60, 2), (63, 1), (71, 1), (72, 2), (137, 1)], [], [(0, 1), (1, 2), (3, 2), (7, 2), (9, 1), (10, 1), (12, 1), (19, 2), (58, 1), (60, 2), (63, 1), (71, 1), (72, 2), (137, 1)], [], [(0, 1), (1, 2), (4, 2), (9, 1), (17, 1), (19, 2), (58, 1), (60, 2), (63, 1), (71, 1), (72, 2), (137, 1)], [], [], [(0, 2), (1, 1), (3, 1), (6, 1), (8, 2), (9, 2), (12, 2), (19, 1), (58, 2), (60, 1), (63, 2), (65, 1), (71, 2), (72, 1), (137, 2)], [], [(0, 1), (1, 1), (2, 1), (6, 1), (8, 2), (12, 2), (19, 1), (58, 2), (60, 1), (63, 2), (71, 2), (72, 2), (73, 1), (74, 2), (137, 2)], [], [(0, 2), (1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 1), (80, 1), (137, 2)], [(0, 2), (1, 1), (3, 1), (9, 2), (12, 2), (19, 1), (58, 1), (60, 1), (63, 2), (71, 2), (72, 2), (115, 1), (130, 1), (131, 2), (137, 2)], [], [], [], [], [(0, 2), (1, 1), (2, 2), (3, 1), (6, 1), (7, 2), (9, 2), (18, 2), (19, 1), (44, 1), (57, 1), (58, 2), (63, 1), (121, 2), (172, 2), (173, 1)], [], [], [], [(0, 2), (1, 1), (2, 2), (3, 2), (6, 1), (8, 1), (9, 1), (12, 2), (18, 1), (19, 2), (57, 1), (58, 1), (60, 2), (63, 1), (64, 2), (71, 1), (72, 1), (121, 2), (172, 1), (173, 1), (216, 1)], [], [], [(0, 1), (1, 2), (2, 2), (7, 2), (8, 1), (12, 1), (57, 2), (58, 2), (60, 2), (63, 1), (71, 1), (72, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [], [], [(0, 2), (2, 2), (7, 2), (8, 2), (12, 1), (18, 1), (19, 2), (57, 1), (58, 1), (60, 1), (63, 1), (71, 2), (72, 2)], [], [], [], [], [(3, 2), (4, 2), (6, 1), (7, 2), (8, 2), (9, 2), (12, 1), (58, 2), (60, 2), (63, 2), (71, 1), (72, 1), (115, 2), (131, 1)], [(0, 1), (2, 2), (4, 2), (7, 2), (9, 1), (12, 1), (58, 1), (60, 2), (63, 2), (71, 1), (72, 1), (74, 1)], [(3, 2), (4, 2), (7, 2), (9, 2), (12, 1), (58, 1), (60, 2), (63, 2), (65, 2), (68, 1), (71, 1), (72, 2)], [], [], [], [], [], [], [], [], [], [], []] + +def comb94 : List (List (Nat × Nat)) := [[(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (8, 1), (10, 1), (14, 1), (24, 1), (25, 2), (58, 2), (60, 1), (66, 1), (71, 2), (73, 2), (74, 1), (137, 1)], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (9, 1), (24, 2), (25, 1), (57, 1), (58, 1), (64, 1), (66, 1), (67, 1), (99, 2), (121, 2), (137, 2), (234, 1)], [(0, 2), (1, 1), (2, 1), (6, 2), (8, 1), (9, 1), (10, 2), (14, 2), (58, 2), (60, 2), (64, 1), (66, 2), (67, 2), (71, 1), (73, 1), (74, 2), (99, 2), (121, 1), (137, 1), (233, 1), (234, 2)], [], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 2), (9, 1), (25, 1), (57, 2), (58, 1), (64, 1), (66, 1), (67, 1), (99, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [(0, 1), (1, 2), (2, 1), (5, 1), (6, 1), (8, 1), (9, 2), (10, 1), (14, 2), (24, 1), (25, 2), (58, 2), (60, 1), (64, 1), (66, 2), (67, 2), (71, 2), (73, 1), (74, 1), (75, 1), (99, 2), (121, 1), (137, 1), (233, 1), (234, 2)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (8, 1), (10, 1), (14, 1), (24, 1), (25, 2), (58, 2), (60, 1), (66, 2), (67, 2), (71, 2), (73, 2), (74, 1), (77, 1), (99, 2), (121, 1), (137, 1), (233, 1), (234, 2)], [], [], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 1), (9, 1), (24, 2), (25, 1), (57, 2), (58, 1), (64, 1), (66, 1), (67, 1), (99, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [], [], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (9, 1), (24, 2), (25, 1), (57, 2), (58, 1), (64, 1), (66, 1), (67, 1), (99, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [(1, 1), (3, 2), (4, 1), (6, 2), (8, 2), (9, 2), (10, 1), (14, 1), (24, 2), (25, 1), (57, 1), (58, 1), (60, 1), (67, 1), (71, 2), (73, 2), (74, 1), (121, 2), (137, 2), (233, 2), (234, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (24, 2), (25, 1), (57, 1), (58, 2), (64, 1), (66, 1), (67, 1), (121, 2), (137, 1), (233, 2), (234, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 1), (6, 2), (9, 2), (10, 2), (14, 2), (24, 1), (25, 2), (58, 1), (60, 2), (64, 1), (66, 2), (67, 2), (71, 1), (73, 1), (74, 2), (99, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 1), (57, 1), (58, 2), (66, 2), (137, 1), (233, 2), (234, 1)], [(0, 2), (2, 1), (9, 2), (10, 2), (14, 2), (57, 1), (58, 2), (66, 1), (67, 1), (71, 1), (73, 1), (74, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [(0, 1), (2, 1), (3, 1), (4, 2), (5, 1), (9, 1), (10, 1), (14, 1), (57, 2), (60, 1), (64, 1), (66, 2), (67, 1), (71, 2), (73, 2), (74, 1), (99, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [], [], [(2, 1), (4, 1), (5, 2), (6, 2), (8, 1), (9, 1), (10, 2), (14, 2), (58, 1), (60, 2), (64, 1), (66, 2), (67, 2), (71, 1), (73, 1), (74, 2), (99, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [], [(0, 2), (2, 2), (3, 2), (4, 1), (5, 2), (9, 2), (10, 2), (14, 2), (58, 1), (60, 2), (64, 1), (66, 2), (67, 2), (71, 1), (73, 1), (74, 2), (99, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 1), (10, 2), (58, 1), (60, 2), (64, 1), (66, 2), (67, 2), (71, 1), (73, 1), (74, 2), (99, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (9, 2), (21, 1), (57, 2), (58, 1), (66, 1), (67, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 2), (10, 1), (24, 2), (25, 1), (57, 1), (58, 2), (64, 1), (66, 2), (99, 2), (137, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (24, 2), (25, 1), (57, 1), (58, 2), (64, 1), (66, 2), (99, 2), (137, 1)], [(1, 1), (2, 1), (6, 1), (9, 2), (10, 2), (14, 2), (24, 2), (25, 1), (57, 2), (58, 2), (60, 2), (64, 2), (71, 1), (73, 1), (74, 2), (99, 1), (137, 1)], [], [], [], [(0, 1), (1, 2), (2, 2), (6, 1), (8, 1), (10, 1), (14, 1), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (64, 1), (66, 1), (71, 2), (73, 2), (74, 1), (99, 2), (137, 2)], [], [], [(1, 2), (3, 2), (6, 2), (9, 1), (10, 1), (14, 1), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (66, 1), (71, 2), (73, 2), (74, 1), (99, 2), (120, 1), (137, 2)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (9, 2), (10, 2), (14, 2), (24, 1), (25, 2), (57, 1), (58, 1), (60, 1), (64, 1), (66, 2), (67, 2), (71, 1), (73, 1), (74, 2), (99, 2), (121, 1), (137, 2), (234, 2), (236, 1)], [(0, 1), (1, 2), (3, 1), (4, 1), (5, 2), (6, 2), (9, 2), (10, 2), (14, 2), (24, 1), (25, 2), (58, 1), (60, 2), (64, 2), (71, 1), (73, 1), (74, 2), (137, 2), (181, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 1), (57, 1), (58, 2), (64, 1), (66, 2), (99, 2), (137, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 1), (57, 1), (58, 2), (64, 1), (66, 2), (99, 2), (137, 1)], [(0, 2), (1, 2), (2, 1), (6, 1), (8, 2), (10, 2), (14, 2), (57, 2), (58, 2), (60, 2), (64, 2), (71, 1), (73, 1), (74, 2), (99, 1), (137, 1)], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 1), (7, 1), (10, 1), (14, 2), (57, 2), (58, 2), (60, 2), (64, 2), (71, 1), (73, 1), (74, 2), (99, 1), (137, 1)], [], [(0, 2), (1, 1), (2, 1), (6, 1), (8, 2), (10, 2), (14, 2), (15, 1), (57, 2), (58, 2), (60, 2), (64, 2), (71, 1), (73, 1), (74, 2), (99, 1), (137, 1)], [], [], [], [], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 2), (6, 2), (8, 1), (10, 1), (14, 1), (57, 1), (58, 1), (60, 1), (64, 1), (67, 1), (71, 2), (73, 2), (74, 1), (99, 2), (137, 2)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (6, 2), (8, 1), (9, 2), (10, 1), (14, 2), (57, 1), (58, 1), (60, 1), (64, 1), (66, 1), (71, 2), (73, 1), (74, 2), (99, 2), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (5, 1), (6, 2), (8, 1), (10, 2), (80, 1), (137, 2)], [], [(0, 2), (3, 1), (4, 2), (5, 1), (9, 2), (10, 2), (14, 2), (57, 1), (58, 1), (60, 1), (64, 1), (66, 1), (71, 1), (73, 1), (74, 2), (99, 2), (127, 1), (137, 2)], [], [], [], [(0, 2), (2, 1), (6, 2), (8, 2), (9, 2), (14, 2), (24, 2), (25, 1), (44, 1), (64, 2), (67, 1), (99, 1), (121, 2), (233, 2), (234, 1)], [], [], [], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 1), (6, 1), (8, 1), (9, 1), (10, 2), (14, 2), (24, 1), (25, 2), (57, 2), (60, 2), (66, 1), (67, 1), (71, 1), (73, 1), (74, 2), (99, 2), (121, 2), (233, 1), (234, 1), (274, 1)], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 1), (6, 1), (9, 2), (10, 2), (14, 2), (57, 1), (60, 2), (64, 2), (66, 1), (67, 2), (71, 1), (73, 1), (74, 2), (99, 1), (121, 1), (233, 1), (234, 2)], [], [], [], [], [], [(0, 1), (1, 1), (3, 2), (4, 1), (5, 2), (6, 2), (9, 1), (10, 1), (14, 1), (24, 1), (25, 2), (57, 2), (60, 1), (64, 1), (71, 2), (73, 2), (74, 1), (99, 2)], [], [], [], [], [(2, 2), (4, 1), (5, 1), (6, 2), (8, 1), (9, 2), (10, 2), (14, 1), (57, 1), (60, 2), (64, 2), (71, 1), (73, 1), (74, 2), (99, 2), (120, 2), (130, 1)], [(0, 2), (3, 2), (4, 1), (5, 1), (10, 2), (14, 1), (57, 1), (60, 2), (64, 1), (71, 1), (73, 2), (74, 2), (99, 2)], [(2, 2), (3, 2), (4, 1), (5, 1), (9, 2), (10, 2), (14, 2), (57, 1), (60, 2), (64, 1), (68, 1), (71, 1), (73, 1), (74, 2), (99, 2)], [], [], [], [], [], [], [], [], [], [], []] + +def comb95 : List (List (Nat × Nat)) := [[], [(2, 1), (7, 2), (8, 1), (9, 1), (11, 2), (12, 1), (13, 2), (14, 1), (19, 1), (22, 1), (58, 1), (71, 2), (74, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 1), (8, 2), (9, 2), (11, 1), (12, 2), (14, 2), (15, 1), (19, 1), (34, 2), (71, 1), (74, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [(0, 1), (2, 2), (6, 2), (8, 1), (9, 1), (11, 2), (13, 1), (14, 2), (15, 1), (22, 1), (34, 2), (71, 2), (74, 1), (114, 1), (121, 1), (137, 1), (173, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 2), (9, 2), (11, 1), (12, 2), (14, 2), (15, 1), (19, 1), (34, 2), (71, 1), (74, 2), (114, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 2), (13, 1), (14, 2), (15, 1), (19, 1), (34, 2), (57, 2), (71, 1), (74, 2), (75, 1), (114, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (13, 1), (14, 1), (20, 1), (22, 1), (71, 2), (74, 1), (114, 1), (121, 1), (137, 1), (173, 2)], [(0, 1), (1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (13, 1), (22, 2), (71, 2), (74, 1), (114, 1), (121, 1), (137, 1), (173, 2)], [(0, 1), (1, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (13, 1), (14, 1), (22, 2), (71, 2), (74, 1), (114, 1), (121, 1), (137, 1), (173, 2)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 2), (13, 1), (14, 2), (15, 1), (19, 1), (34, 2), (71, 1), (74, 2), (114, 2), (121, 2), (137, 2), (173, 1)], [], [], [], [], [(0, 1), (2, 2), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (14, 1), (15, 2), (19, 2), (34, 1), (114, 2), (137, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 2), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (22, 1), (114, 1), (137, 2)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 1), (11, 2), (14, 2), (15, 1), (19, 1), (22, 1), (34, 2), (71, 1), (74, 2), (114, 2), (137, 1), (173, 1)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 1), (11, 2), (14, 2), (15, 1), (19, 2), (22, 1), (34, 2), (114, 2), (137, 1)], [(0, 1), (1, 1), (3, 2), (4, 2), (6, 1), (8, 2), (9, 1), (11, 2), (14, 2), (15, 1), (19, 2), (22, 1), (34, 2), (114, 2), (137, 1)], [(0, 1), (2, 2), (6, 2), (8, 1), (9, 2), (11, 1), (13, 1), (14, 1), (15, 1), (19, 2), (22, 1), (114, 1), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (6, 2), (7, 2), (8, 1), (11, 1), (12, 1), (13, 2), (14, 2), (22, 1), (114, 1), (137, 2)], [], [], [], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (13, 2), (15, 2), (19, 1), (22, 1), (34, 1), (71, 1), (74, 2), (121, 2), (137, 1), (173, 1)], [(1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 2), (19, 1), (22, 1), (71, 2), (74, 1), (121, 1), (137, 2), (173, 2)], [], [], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (13, 2), (15, 2), (19, 1), (22, 1), (34, 1), (58, 2), (60, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (1, 1), (2, 2), (3, 1), (4, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (13, 2), (15, 2), (19, 1), (22, 1), (34, 1), (121, 2), (137, 1), (173, 1)], [(0, 2), (1, 1), (2, 1), (3, 1), (4, 2), (7, 1), (8, 2), (11, 2), (12, 2), (13, 2), (14, 1), (15, 2), (19, 1), (22, 1), (34, 1), (58, 2), (64, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 1), (19, 2), (22, 2), (117, 1), (137, 2)], [(1, 1), (2, 2), (3, 1), (4, 2), (7, 2), (8, 1), (9, 2), (11, 1), (13, 2), (22, 1), (115, 1), (137, 2)], [(1, 1), (2, 2), (4, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 2), (22, 1), (120, 1), (137, 2)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (9, 1), (11, 2), (13, 2), (14, 2), (15, 1), (19, 1), (22, 1), (34, 2), (71, 1), (74, 2), (121, 2), (137, 1), (173, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (9, 1), (11, 2), (13, 2), (14, 2), (15, 1), (19, 1), (22, 1), (34, 2), (71, 1), (74, 2), (121, 2), (137, 1), (173, 1)], [(0, 1), (1, 2), (3, 2), (4, 1), (5, 1), (9, 1), (11, 2), (13, 2), (14, 2), (15, 1), (19, 1), (22, 1), (34, 2), (71, 1), (74, 2), (121, 2), (137, 1), (173, 1)], [(2, 2), (9, 2), (11, 1), (14, 1), (19, 1), (71, 2), (74, 1), (121, 1), (137, 2), (173, 2)], [(2, 2), (7, 2), (9, 2), (10, 1), (11, 1), (12, 1), (19, 1), (71, 2), (74, 1), (121, 1), (137, 2), (173, 2)], [], [], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (9, 2), (11, 2), (13, 2), (14, 1), (15, 1), (19, 1), (22, 1), (34, 2), (64, 2), (71, 1), (73, 1), (74, 2), (121, 2), (137, 1), (173, 1)], [(0, 2), (1, 2), (3, 2), (4, 1), (9, 1), (11, 2), (13, 2), (14, 2), (15, 1), (19, 1), (22, 1), (34, 2), (58, 2), (71, 1), (121, 2), (137, 1), (173, 1)], [(0, 2), (1, 2), (3, 2), (4, 1), (9, 1), (11, 2), (13, 2), (14, 2), (15, 1), (19, 1), (22, 1), (34, 2), (58, 2), (80, 1), (121, 2), (137, 1), (173, 1)], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 1), (9, 2), (11, 1), (13, 2), (19, 2), (22, 1), (115, 1), (120, 2), (127, 1), (130, 1), (131, 2), (137, 2)], [(0, 1), (2, 2), (6, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 2), (19, 2), (22, 1), (127, 1), (137, 2)], [], [], [], [], [(1, 2), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (9, 2), (12, 1), (13, 2), (19, 2), (22, 1), (58, 2), (71, 1), (74, 2), (99, 1), (114, 2), (121, 1), (173, 2)], [(2, 2), (6, 1), (7, 2), (12, 2), (13, 1), (14, 1), (15, 2), (19, 1), (22, 1), (34, 1), (71, 2), (74, 1), (114, 1), (121, 1), (157, 1), (173, 2)], [], [], [], [], [], [(0, 2), (1, 2), (3, 2), (4, 1), (6, 2), (8, 1), (15, 2), (19, 1), (22, 2), (34, 1), (57, 1), (58, 2), (114, 1), (121, 2), (173, 1)], [], [], [], [], [], [], [], [], [], [(0, 1), (1, 1), (3, 1), (4, 2), (6, 1), (8, 2), (13, 2), (14, 1), (15, 2), (22, 1), (34, 1), (71, 2), (74, 1), (115, 2), (121, 1), (127, 2), (131, 1), (173, 2)], [], [], [], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (9, 2), (11, 1), (13, 1), (14, 1), (15, 2), (19, 1), (22, 2), (34, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (12, 2), (13, 2), (14, 1), (15, 2), (19, 2), (22, 1), (34, 1)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (13, 2), (15, 2), (19, 2), (22, 1), (34, 1)], [], [], [], [], []] + +def comb96 : List (List (Nat × Nat)) := [[], [(0, 1), (1, 2), (3, 1), (4, 2), (6, 1), (7, 2), (10, 2), (13, 1), (15, 2), (16, 2), (18, 1), (20, 2), (34, 2), (44, 1), (60, 2), (64, 2), (65, 2), (68, 1), (127, 1)], [], [], [], [], [(1, 1), (2, 1), (5, 2), (6, 1), (7, 2), (9, 2), (14, 1), (16, 1), (18, 2), (19, 2), (20, 2), (34, 1), (44, 1), (58, 2), (60, 2), (64, 2), (65, 2), (68, 1), (127, 1), (293, 1)], [], [(1, 2), (5, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 2), (14, 2), (15, 2), (16, 1), (18, 2), (19, 2), (58, 1), (60, 1), (64, 1), (65, 1), (68, 2), (127, 2), (293, 2)], [], [], [], [(1, 1), (2, 1), (5, 1), (6, 1), (8, 1), (9, 2), (10, 2), (12, 2), (13, 2), (14, 2), (16, 1), (18, 2), (19, 2), (20, 2), (58, 1), (60, 1), (77, 1), (127, 2), (293, 2)], [], [(0, 2), (1, 2), (3, 1), (4, 2), (5, 2), (6, 1), (7, 2), (10, 2), (13, 1), (15, 2), (16, 2), (18, 1), (20, 2), (34, 2), (44, 1), (58, 2), (60, 2), (64, 2), (65, 2), (68, 1), (127, 1), (293, 1)], [], [(1, 1), (5, 2), (6, 1), (9, 2), (10, 2), (13, 1), (14, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 2), (44, 1), (58, 2), (60, 2), (64, 2), (65, 2), (68, 1), (127, 1), (293, 1)], [(1, 1), (5, 2), (6, 1), (7, 2), (9, 2), (13, 1), (14, 1), (15, 2), (16, 1), (18, 2), (19, 1), (34, 2), (44, 1), (58, 2), (60, 2), (64, 2), (65, 2), (68, 1), (127, 1), (293, 1)], [], [(1, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 1), (10, 2), (13, 2), (14, 2), (15, 2), (16, 1), (18, 2), (19, 2), (58, 1), (60, 1), (64, 1), (65, 1), (68, 2), (127, 2), (293, 2)], [(0, 1), (1, 2), (2, 2), (5, 1), (6, 1), (7, 2), (8, 2), (10, 2), (13, 2), (15, 2), (19, 1), (20, 1), (58, 1), (60, 1), (64, 1), (65, 1), (68, 2), (127, 2), (293, 2)], [], [], [(0, 2), (1, 1), (2, 2), (5, 1), (6, 1), (7, 2), (13, 2), (14, 1), (15, 1), (16, 1), (18, 2), (20, 1), (34, 2), (44, 1), (58, 1), (60, 2), (127, 1), (293, 2)], [], [(1, 2), (2, 2), (5, 2), (8, 1), (9, 1), (10, 1), (13, 1), (14, 2), (15, 1), (20, 2), (34, 2), (44, 1), (58, 2), (60, 1), (127, 2), (293, 1)], [], [], [(1, 1), (5, 1), (6, 1), (7, 2), (9, 1), (14, 2), (19, 1), (44, 1), (58, 1), (60, 2), (64, 1), (65, 1), (67, 2), (68, 2), (121, 1), (127, 1), (293, 2)], [(0, 1), (1, 1), (2, 2), (5, 2), (8, 1), (9, 1), (10, 2), (14, 2), (15, 2), (20, 1), (34, 2), (44, 1), (58, 2), (60, 2), (64, 2), (65, 2), (68, 1), (127, 2), (293, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 2), (5, 1), (6, 1), (7, 2), (16, 2), (18, 1), (20, 1), (44, 1), (58, 1), (60, 2), (127, 1), (293, 2)], [(1, 1), (2, 1), (5, 1), (6, 1), (7, 2), (9, 2), (14, 1), (16, 1), (18, 2), (19, 2), (20, 2), (44, 1), (58, 1), (60, 2), (127, 1), (293, 2)], [(0, 2), (1, 1), (2, 1), (3, 1), (5, 1), (6, 1), (7, 2), (16, 2), (18, 1), (20, 1), (44, 1), (58, 1), (60, 2), (127, 1), (293, 2)], [(0, 1), (1, 1), (2, 2), (3, 2), (4, 1), (5, 2), (8, 1), (10, 2), (15, 2), (16, 2), (18, 1), (19, 2), (20, 2), (34, 2), (44, 1), (58, 2), (60, 1), (127, 2), (293, 1)], [], [(0, 1), (1, 2), (2, 1), (5, 2), (7, 2), (8, 2), (10, 2), (12, 1), (14, 2), (15, 1), (20, 2), (34, 2), (44, 1), (58, 2), (60, 1), (127, 2), (293, 1)], [(0, 1), (1, 2), (2, 1), (5, 2), (8, 2), (10, 1), (15, 1), (20, 2), (34, 2), (44, 1), (58, 2), (60, 1), (127, 2), (293, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (9, 1), (10, 1), (13, 2), (14, 2), (15, 1), (19, 2), (20, 2), (34, 1), (44, 1), (60, 2), (64, 1), (65, 1), (68, 2), (127, 1)], [], [], [], [], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (9, 1), (10, 1), (13, 2), (14, 2), (15, 1), (19, 1), (20, 2), (34, 2), (44, 1), (58, 1), (60, 2), (127, 1)], [(0, 1), (2, 2), (3, 2), (4, 1), (6, 1), (7, 2), (9, 1), (10, 1), (13, 2), (14, 2), (15, 1), (19, 1), (20, 2), (34, 2), (44, 1), (60, 2), (64, 1), (127, 1)], [(0, 2), (2, 1), (6, 1), (7, 2), (8, 1), (9, 1), (10, 1), (13, 1), (14, 2), (16, 1), (18, 2), (19, 1), (20, 2), (117, 1), (127, 2)], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (13, 1), (14, 1), (16, 2), (18, 1), (19, 2), (20, 1), (127, 2), (174, 1)], [(2, 1), (5, 2), (6, 1), (7, 2), (8, 2), (10, 1), (13, 1), (14, 2), (16, 1), (18, 2), (19, 1), (20, 2), (127, 2), (236, 1)], [], [(0, 1), (1, 1), (2, 1), (6, 1), (7, 2), (9, 2), (14, 1), (16, 1), (18, 2), (19, 2), (20, 2), (34, 2), (44, 1), (60, 2), (64, 1), (65, 1), (68, 2), (127, 1)], [], [(0, 1), (1, 1), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (9, 1), (14, 2), (19, 1), (34, 2), (44, 1), (60, 2), (64, 1), (65, 1), (68, 2), (127, 1)], [(1, 1), (2, 1), (5, 1), (6, 1), (7, 2), (9, 2), (14, 1), (16, 1), (18, 2), (19, 2), (20, 2), (34, 2), (44, 1), (60, 2), (64, 1), (65, 1), (68, 2), (127, 1)], [], [], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (7, 2), (8, 2), (9, 2), (10, 1), (14, 1), (15, 1), (16, 2), (18, 1), (19, 2), (20, 1), (60, 1), (64, 2), (65, 2), (68, 1), (127, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (6, 1), (8, 2), (9, 2), (12, 2), (14, 2), (15, 1), (16, 1), (17, 1), (18, 1), (19, 2), (20, 1), (60, 1), (64, 2), (65, 2), (68, 1), (127, 2)], [], [], [(0, 1), (1, 1), (2, 1), (6, 1), (7, 2), (9, 2), (14, 1), (16, 1), (18, 2), (19, 2), (20, 2), (34, 2), (44, 1), (60, 2), (65, 1), (127, 1)], [(1, 1), (2, 2), (6, 1), (7, 2), (16, 2), (18, 1), (20, 1), (34, 2), (44, 1), (60, 2), (67, 1), (127, 1)], [], [], [(0, 1), (1, 1), (2, 1), (6, 1), (7, 2), (9, 2), (14, 1), (16, 1), (18, 2), (19, 1), (20, 2), (44, 1), (60, 2), (80, 1), (127, 1)], [(7, 2), (10, 1), (12, 1), (14, 2), (130, 1), (131, 2)], [], [], [], [], [], [(0, 1), (1, 2), (2, 2), (3, 2), (4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (10, 2), (12, 2), (13, 2), (14, 1), (16, 1), (18, 2), (20, 2), (34, 2), (44, 1), (58, 1), (64, 1), (65, 1), (68, 2), (99, 1), (293, 2)], [], [(1, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1), (8, 1), (10, 1), (13, 1), (15, 1), (19, 2), (20, 2), (58, 1), (64, 2), (65, 2), (68, 1), (293, 1), (392, 1)], [], [], [], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 2), (8, 1), (10, 2), (15, 2), (16, 1), (18, 2), (19, 2), (34, 1), (44, 2), (57, 1), (58, 2), (293, 1)], [], [], [], [], [], [], [], [], [], [(0, 2), (1, 2), (2, 2), (6, 2), (7, 2), (9, 2), (10, 2), (12, 2), (14, 2), (16, 2), (18, 1), (19, 1), (20, 1), (34, 1), (44, 2), (60, 1), (64, 2), (65, 2), (68, 1), (127, 2), (131, 1)], [], [], [], [], [(1, 2), (2, 1), (3, 2), (4, 1), (6, 1), (7, 2), (8, 1), (10, 2), (15, 2), (16, 1), (19, 2), (34, 1), (44, 2)], [], [(0, 2), (2, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 2), (14, 2), (15, 2), (16, 2), (18, 1), (19, 1), (20, 2), (34, 1), (44, 2)], [(6, 1), (7, 2), (8, 2), (10, 1), (15, 2), (16, 1), (18, 2), (34, 1), (44, 2)], [], [], [], [], []] + +def comb97 : List (List (Nat × Nat)) := [[], [(1, 1), (2, 2), (9, 2), (10, 2), (11, 2), (12, 1), (13, 2), (15, 2), (16, 1), (18, 1), (19, 1), (24, 1), (58, 2), (64, 2), (66, 1), (72, 2), (137, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (18, 2), (19, 2), (24, 1), (58, 1), (60, 2), (64, 2), (66, 1), (67, 1), (72, 2), (121, 2), (137, 2), (173, 1)], [], [], [(0, 2), (1, 2), (2, 2), (3, 1), (4, 2), (7, 2), (8, 2), (9, 1), (10, 2), (11, 2), (12, 2), (13, 1), (15, 1), (16, 2), (19, 2), (34, 1), (58, 2), (60, 1), (64, 1), (66, 2), (67, 2), (72, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [], [], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (19, 2), (24, 1), (58, 1), (60, 2), (64, 2), (66, 1), (67, 1), (72, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [], [], [], [(0, 2), (1, 1), (2, 2), (7, 2), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (15, 2), (16, 1), (18, 1), (19, 1), (34, 2), (58, 2), (60, 1), (64, 1), (66, 2), (67, 2), (72, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [(0, 2), (1, 1), (2, 2), (8, 1), (9, 1), (10, 2), (11, 2), (12, 2), (13, 2), (15, 1), (16, 1), (18, 1), (20, 1), (34, 2), (58, 2), (60, 1), (64, 1), (66, 2), (67, 2), (72, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 1), (2, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 1), (10, 1), (11, 2), (12, 2), (18, 1), (19, 1), (24, 1), (58, 2), (60, 1), (64, 1), (66, 2), (67, 2), (72, 1), (121, 1), (137, 1), (172, 1), (173, 2)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 1), (9, 2), (10, 2), (11, 1), (12, 1), (13, 1), (18, 2), (19, 2), (24, 2), (58, 1), (60, 2), (64, 2), (66, 1), (67, 1), (72, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [(0, 1), (1, 2), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (18, 2), (19, 2), (24, 2), (58, 1), (60, 2), (64, 2), (66, 1), (67, 1), (72, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (8, 1), (9, 2), (10, 1), (11, 1), (12, 1), (13, 2), (15, 1), (16, 2), (18, 2), (19, 2), (34, 2), (58, 1), (60, 2), (64, 2), (66, 1), (67, 1), (72, 2), (121, 2), (137, 2), (172, 2), (173, 1)], [], [(0, 1), (3, 2), (4, 1), (7, 1), (9, 2), (10, 2), (11, 2), (12, 2), (13, 2), (18, 2), (24, 2), (34, 2), (58, 2), (60, 2), (64, 1), (66, 2), (67, 1), (72, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [], [], [(0, 1), (2, 1), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (15, 2), (16, 1), (18, 1), (34, 2), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (121, 1), (137, 2), (172, 1), (173, 2)], [], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (11, 2), (12, 2), (13, 2), (19, 2), (24, 1), (58, 2), (64, 1), (66, 2), (72, 1), (137, 1), (172, 2), (173, 1)], [], [(0, 2), (1, 1), (2, 2), (8, 1), (9, 1), (10, 2), (11, 1), (12, 2), (13, 2), (15, 1), (16, 2), (19, 1), (34, 2), (58, 2), (60, 1), (64, 1), (66, 2), (67, 2), (72, 1), (121, 1), (137, 2), (172, 1), (173, 2)], [(0, 2), (2, 2), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (19, 2), (24, 1), (58, 2), (60, 2), (64, 1), (66, 2), (67, 1), (72, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 2), (3, 1), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (15, 2), (16, 1), (19, 2), (34, 1), (58, 2), (60, 2), (64, 1), (66, 2), (67, 1), (72, 1), (121, 2), (137, 1), (172, 2), (173, 1)], [], [], [(0, 2), (1, 1), (2, 2), (8, 1), (9, 1), (10, 2), (11, 1), (12, 2), (13, 2), (15, 1), (16, 2), (19, 1), (34, 2), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (121, 1), (137, 2), (172, 1), (173, 2)], [], [(0, 2), (3, 1), (4, 2), (7, 2), (8, 2), (9, 1), (10, 1), (11, 1), (12, 1), (13, 1), (21, 1), (24, 2), (34, 1), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (121, 1), (137, 2), (172, 1), (173, 2)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (11, 2), (12, 2), (13, 2), (18, 2), (24, 1), (58, 2), (64, 1), (66, 2), (72, 1), (137, 1)], [], [(0, 1), (2, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (10, 2), (11, 1), (12, 1), (15, 2), (16, 1), (18, 1), (24, 1), (34, 1), (58, 1), (64, 2), (66, 1), (72, 2), (137, 2)], [], [(0, 1), (2, 2), (8, 2), (11, 2), (13, 1), (15, 2), (16, 1), (18, 2), (34, 1), (58, 2), (60, 1), (137, 1)], [], [(3, 1), (4, 2), (7, 2), (8, 2), (10, 1), (11, 2), (15, 1), (16, 2), (18, 2), (24, 2), (34, 2), (58, 2), (64, 1), (137, 1)], [], [(3, 2), (4, 1), (7, 1), (8, 1), (9, 2), (10, 2), (11, 1), (13, 1), (15, 2), (16, 1), (18, 1), (24, 1), (34, 1), (115, 1), (137, 2)], [], [(0, 2), (9, 1), (11, 1), (12, 1), (13, 2), (15, 2), (16, 2), (18, 1), (19, 1), (20, 2), (34, 2), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (121, 1), (137, 2), (173, 2), (174, 1)], [], [(0, 1), (2, 1), (4, 2), (7, 2), (8, 1), (9, 2), (10, 1), (11, 1), (12, 1), (13, 2), (18, 1), (24, 2), (34, 1), (58, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (121, 1), (137, 2), (173, 2), (181, 1)], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (19, 2), (34, 1), (58, 2), (64, 1), (66, 2), (72, 1), (137, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 1), (7, 1), (9, 1), (11, 2), (12, 2), (13, 2), (19, 2), (34, 1), (58, 2), (64, 1), (66, 2), (72, 1), (137, 1)], [], [(0, 2), (1, 2), (2, 1), (3, 1), (4, 2), (5, 1), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (15, 2), (16, 1), (19, 2), (24, 2), (34, 2), (58, 2), (64, 1), (66, 2), (72, 1), (137, 1)], [(0, 1), (1, 1), (2, 1), (7, 1), (9, 2), (10, 1), (11, 1), (12, 1), (15, 1), (16, 2), (19, 1), (24, 1), (34, 1), (58, 1), (64, 2), (66, 1), (72, 2), (137, 2)], [], [(0, 1), (1, 1), (2, 1), (9, 2), (10, 2), (11, 1), (12, 1), (13, 2), (15, 2), (16, 2), (19, 1), (24, 1), (34, 1), (58, 1), (64, 2), (66, 1), (72, 2), (137, 2)], [], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (13, 1), (22, 1), (58, 1), (64, 2), (66, 1), (72, 2), (137, 2)], [(1, 2), (2, 1), (3, 2), (4, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (13, 1), (19, 2), (34, 1), (58, 2), (72, 1), (137, 1)], [], [(0, 2), (1, 2), (2, 2), (8, 1), (9, 1), (10, 1), (11, 2), (12, 2), (15, 2), (16, 1), (19, 2), (24, 2), (34, 2), (58, 2), (60, 2), (64, 1), (66, 2), (67, 1), (72, 1), (137, 1)], [], [(0, 1), (2, 2), (3, 1), (4, 2), (7, 2), (10, 1), (11, 2), (13, 2), (15, 1), (16, 2), (19, 2), (24, 1), (58, 2), (71, 1), (137, 1)], [], [(0, 1), (1, 1), (2, 1), (9, 1), (10, 2), (11, 1), (12, 1), (15, 1), (16, 2), (19, 1), (24, 1), (34, 1), (115, 1), (130, 1), (131, 2), (137, 2)], [], [], [], [], [], [(0, 1), (1, 1), (2, 2), (8, 2), (10, 2), (13, 2), (18, 2), (19, 1), (24, 2), (34, 1), (60, 2), (64, 2), (66, 1), (67, 1), (72, 2), (99, 1), (121, 2), (172, 2), (173, 1)], [], [], [(1, 1), (3, 1), (4, 2), (7, 1), (15, 2), (16, 1), (18, 1), (19, 2), (24, 2), (34, 2), (60, 2), (67, 1), (121, 2), (172, 1), (173, 1), (216, 1)], [], [], [], [(0, 2), (3, 2), (4, 1), (7, 1), (8, 2), (9, 2), (10, 2), (12, 1), (15, 1), (16, 2), (57, 1), (60, 1), (64, 2), (66, 1), (67, 2), (72, 2), (121, 1), (172, 1), (173, 2)], [], [], [], [], [], [], [], [], [], [(3, 2), (4, 1), (7, 2), (9, 1), (10, 1), (13, 1), (15, 2), (16, 1), (24, 2), (34, 1), (58, 1), (64, 2), (66, 1), (72, 2), (115, 2), (131, 1)], [], [], [], [], [(3, 2), (4, 1), (7, 2), (10, 1), (13, 2), (15, 1), (16, 2), (24, 2), (34, 1)], [(3, 2), (4, 1), (7, 1), (10, 2), (11, 1), (13, 1), (15, 2), (16, 1), (24, 2), (34, 1)], [], [], [], [], [], [], []] + +def comb98 : List (List (Nat × Nat)) := [[], [(0, 1), (5, 2), (6, 1), (9, 1), (11, 2), (12, 2), (14, 1), (16, 2), (24, 1), (25, 2), (57, 2), (63, 1), (64, 1), (137, 1)], [], [], [(0, 2), (2, 1), (3, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (57, 1), (63, 2), (121, 2), (137, 2), (234, 1)], [], [(2, 2), (3, 1), (6, 1), (7, 2), (10, 1), (11, 2), (14, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (57, 2), (63, 1), (121, 1), (137, 1), (233, 1), (234, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 1), (14, 1), (16, 2), (18, 2), (25, 1), (57, 1), (63, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [], [], [(0, 2), (2, 1), (3, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 1), (14, 1), (16, 2), (24, 2), (25, 1), (121, 2), (137, 2), (233, 2), (234, 1)], [(2, 1), (3, 1), (6, 1), (7, 2), (10, 1), (11, 2), (14, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 2), (57, 2), (63, 1), (121, 1), (137, 1), (233, 1), (234, 2)], [(1, 1), (3, 2), (4, 2), (6, 1), (7, 1), (10, 1), (11, 2), (12, 1), (14, 1), (16, 2), (18, 1), (20, 1), (24, 2), (25, 1), (34, 2), (57, 2), (63, 1), (121, 1), (137, 1), (233, 1), (234, 2)], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 2), (9, 2), (10, 1), (11, 2), (14, 2), (16, 1), (24, 1), (25, 2), (57, 2), (63, 1), (121, 1), (137, 1), (233, 1), (234, 2)], [], [], [], [(0, 2), (2, 1), (3, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 1), (14, 1), (16, 2), (24, 2), (25, 1), (57, 1), (63, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [(0, 1), (6, 1), (7, 1), (9, 2), (10, 2), (11, 1), (12, 1), (18, 1), (34, 2), (57, 1), (63, 2), (121, 2), (137, 2), (233, 2), (234, 1)], [], [(0, 2), (2, 1), (5, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (18, 1), (34, 2), (121, 2), (137, 1), (233, 2), (234, 1)], [], [], [], [(0, 2), (2, 2), (3, 1), (6, 1), (7, 2), (9, 1), (10, 1), (11, 1), (14, 1), (16, 2), (18, 1), (24, 2), (25, 1), (34, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [(0, 2), (2, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (14, 2), (16, 1), (57, 1), (63, 2), (137, 1), (233, 2), (234, 1)], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (14, 2), (16, 1), (121, 2), (137, 1), (233, 2), (234, 1)], [(2, 2), (3, 1), (5, 1), (7, 1), (10, 2), (11, 2), (12, 2), (18, 2), (24, 2), (25, 1), (34, 1), (121, 2), (137, 1), (233, 2), (234, 1)], [], [], [(0, 2), (3, 1), (5, 2), (6, 1), (7, 2), (9, 1), (10, 1), (11, 1), (18, 1), (24, 1), (25, 2), (34, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [], [(2, 2), (3, 1), (5, 2), (6, 1), (7, 2), (10, 1), (11, 1), (14, 1), (18, 1), (24, 1), (25, 2), (34, 2), (121, 1), (137, 2), (233, 1), (234, 2)], [(0, 2), (2, 1), (3, 1), (4, 2), (5, 2), (7, 2), (9, 1), (10, 1), (11, 1), (12, 1), (14, 2), (16, 1), (18, 2), (21, 1), (24, 2), (25, 1), (34, 1), (121, 1), (137, 2), (233, 1), (234, 2)], [(1, 2), (2, 1), (4, 1), (5, 2), (6, 2), (7, 1), (11, 2), (14, 2), (16, 1), (24, 2), (25, 1), (57, 1), (63, 2), (137, 1)], [], [], [(0, 1), (3, 1), (5, 1), (6, 1), (9, 2), (11, 1), (12, 2), (14, 2), (16, 1), (18, 2), (34, 1), (57, 2), (63, 1), (137, 2)], [(0, 1), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (11, 2), (12, 1), (18, 2), (24, 1), (25, 2), (34, 1), (60, 1), (64, 2), (137, 1)], [(0, 1), (2, 1), (3, 2), (5, 2), (9, 2), (11, 2), (14, 1), (16, 2), (18, 1), (34, 2), (58, 1), (64, 2), (137, 1)], [], [], [], [(2, 1), (5, 1), (6, 1), (9, 2), (11, 1), (12, 2), (14, 2), (16, 1), (18, 2), (34, 1), (120, 1), (137, 2)], [], [(0, 2), (1, 2), (2, 1), (4, 1), (5, 2), (6, 1), (9, 1), (10, 1), (11, 1), (12, 2), (14, 1), (16, 2), (18, 2), (20, 2), (24, 2), (25, 1), (34, 2), (121, 1), (137, 2), (234, 2), (236, 1)], [(2, 2), (4, 2), (5, 1), (11, 1), (14, 1), (16, 2), (24, 1), (25, 2), (137, 2), (181, 1)], [(0, 1), (2, 2), (3, 1), (5, 2), (6, 2), (11, 2), (12, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (57, 1), (63, 2), (137, 1)], [(3, 1), (5, 2), (6, 2), (11, 2), (12, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (57, 1), (63, 2), (137, 1)], [(0, 1), (2, 1), (3, 1), (4, 1), (5, 2), (9, 2), (11, 2), (14, 2), (16, 1), (18, 1), (24, 1), (25, 2), (34, 2), (57, 1), (63, 2), (137, 1)], [], [], [(0, 2), (3, 1), (6, 1), (7, 2), (9, 1), (10, 1), (11, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (57, 2), (63, 1), (137, 2)], [], [(0, 2), (3, 1), (6, 1), (9, 1), (11, 1), (12, 2), (14, 2), (16, 1), (17, 1), (18, 2), (24, 2), (25, 1), (34, 1), (57, 2), (63, 1), (137, 2)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 2), (7, 2), (9, 2), (11, 1), (12, 1), (22, 1), (57, 2), (63, 1), (137, 2)], [(0, 1), (2, 2), (3, 1), (5, 2), (6, 2), (11, 2), (12, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (64, 2), (66, 1), (137, 1)], [(0, 1), (2, 1), (3, 1), (4, 1), (5, 2), (9, 2), (11, 2), (14, 2), (16, 1), (18, 1), (24, 1), (25, 2), (34, 2), (57, 1), (60, 2), (63, 2), (65, 1), (137, 1)], [], [(0, 1), (2, 1), (3, 2), (5, 2), (11, 2), (14, 1), (16, 1), (18, 1), (24, 1), (25, 2), (34, 2), (64, 2), (73, 1), (137, 1)], [], [], [], [(0, 2), (3, 1), (9, 1), (11, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (127, 1), (137, 2)], [], [], [], [], [(3, 2), (5, 2), (6, 1), (7, 1), (9, 1), (10, 2), (12, 1), (14, 2), (16, 1), (18, 2), (24, 1), (25, 2), (34, 1), (57, 1), (63, 2), (64, 2), (99, 1), (121, 2), (233, 2), (234, 1)], [], [], [], [(0, 1), (1, 2), (2, 1), (4, 1), (5, 2), (6, 2), (7, 1), (9, 2), (10, 2), (18, 2), (24, 2), (25, 1), (34, 2), (57, 2), (63, 1), (121, 2), (233, 1), (234, 1), (274, 1)], [], [], [(2, 2), (3, 2), (5, 1), (7, 2), (9, 1), (10, 1), (12, 1), (14, 1), (16, 2), (57, 1), (64, 2), (121, 1), (233, 1), (234, 2)], [], [], [], [], [], [], [], [], [], [(0, 2), (3, 2), (9, 2), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (57, 2), (63, 1), (120, 2), (130, 1)], [], [], [], [], [(0, 1), (2, 1), (3, 1), (9, 2), (18, 2), (24, 2), (25, 1), (34, 1)], [(0, 2), (3, 1), (9, 1), (11, 1), (14, 1), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1)], [], [], [], [], [], [], []] + +def comb99 : List (List (Nat × Nat)) := [[], [], [(6, 2), (8, 2), (11, 2), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (18, 1), (34, 2), (51, 2), (60, 1), (65, 2), (68, 1), (117, 2), (137, 2)], [], [], [], [], [(0, 1), (1, 2), (6, 1), (7, 1), (11, 2), (12, 2), (17, 1), (18, 2), (19, 2), (34, 1), (51, 2), (60, 1), (65, 2), (68, 1), (117, 2), (120, 2), (137, 2), (293, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (6, 1), (7, 1), (11, 1), (12, 2), (14, 1), (15, 1), (16, 2), (17, 1), (19, 1), (51, 2), (57, 1), (60, 2), (65, 1), (68, 2), (117, 1), (120, 1), (137, 1), (293, 2)], [], [], [(1, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (13, 1), (14, 1), (15, 1), (16, 2), (17, 1), (34, 2), (51, 2), (71, 1), (74, 2), (75, 1), (117, 2), (120, 2), (137, 2), (293, 1)], [(1, 1), (2, 2), (3, 1), (7, 2), (8, 1), (9, 2), (11, 1), (12, 1), (13, 2), (14, 2), (15, 2), (16, 1), (17, 1), (18, 1), (51, 2), (57, 1), (60, 2), (77, 1), (117, 1), (120, 1), (137, 1), (293, 2)], [], [(6, 2), (8, 2), (9, 1), (11, 1), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (18, 1), (34, 2), (51, 2), (60, 1), (65, 2), (68, 1), (117, 2), (120, 2), (137, 2), (293, 1)], [(1, 2), (2, 1), (3, 1), (7, 1), (8, 1), (9, 2), (11, 2), (12, 2), (13, 2), (14, 2), (15, 1), (16, 1), (17, 1), (18, 1), (20, 1), (51, 2), (57, 1), (60, 2), (65, 1), (68, 2), (117, 1), (120, 1), (137, 1), (293, 2)], [], [], [(0, 1), (6, 2), (8, 2), (11, 2), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (18, 1), (19, 2), (34, 2), (51, 2), (60, 1), (65, 2), (68, 1), (117, 2), (120, 2), (137, 2), (293, 1)], [(0, 2), (1, 2), (2, 2), (3, 1), (7, 1), (8, 1), (11, 1), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (19, 1), (51, 2), (57, 2), (60, 2), (65, 1), (68, 2), (117, 1), (120, 1), (137, 1), (293, 2)], [(0, 2), (1, 2), (2, 2), (3, 1), (6, 1), (7, 1), (11, 1), (12, 2), (13, 2), (14, 1), (15, 1), (16, 2), (17, 1), (19, 1), (51, 2), (57, 2), (60, 2), (65, 1), (68, 2), (117, 1), (120, 1), (137, 1), (293, 2)], [], [], [], [(6, 2), (8, 1), (9, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (18, 1), (19, 1), (34, 2), (120, 1), (137, 2), (293, 2)], [(1, 2), (2, 2), (3, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (13, 1), (14, 2), (15, 2), (16, 1), (17, 2), (34, 2), (51, 1), (57, 1), (120, 2), (137, 1), (293, 1)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (11, 2), (12, 1), (17, 2), (18, 1), (19, 2), (34, 2), (51, 1), (57, 1), (60, 1), (65, 2), (68, 1), (120, 2), (137, 1), (293, 1)], [], [(0, 2), (1, 1), (19, 1), (120, 1), (137, 2), (293, 2)], [], [], [], [(0, 2), (1, 1), (7, 2), (11, 1), (19, 1), (120, 1), (137, 2), (293, 2)], [(1, 2), (2, 1), (3, 2), (6, 2), (7, 1), (9, 1), (11, 2), (12, 2), (14, 2), (15, 2), (16, 1), (17, 2), (34, 2), (51, 1), (57, 2), (120, 2), (137, 1), (293, 1)], [(1, 2), (2, 2), (3, 1), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (15, 2), (16, 1), (17, 2), (34, 2), (51, 1), (57, 2), (120, 2), (137, 1), (293, 1)], [], [], [(6, 1), (8, 1), (11, 1), (12, 1), (13, 2), (14, 1), (15, 1), (16, 2), (17, 2), (18, 2), (34, 1), (51, 1), (60, 2), (65, 1), (68, 2), (117, 1), (137, 2)], [], [], [(1, 2), (2, 1), (3, 2), (7, 1), (8, 2), (12, 1), (13, 1), (14, 2), (15, 2), (16, 1), (17, 2), (51, 1), (57, 1), (60, 1), (117, 2), (137, 1)], [], [], [], [(6, 2), (8, 1), (9, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (18, 1), (34, 2), (115, 1), (137, 2)], [(6, 2), (8, 1), (9, 2), (11, 1), (13, 2), (14, 1), (15, 1), (16, 2), (18, 1), (34, 2), (120, 1), (137, 2)], [(0, 2), (1, 2), (2, 2), (3, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 1), (13, 1), (14, 1), (15, 2), (16, 2), (17, 2), (18, 2), (19, 1), (20, 2), (51, 1), (57, 2), (117, 2), (137, 1), (174, 1)], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 1), (13, 1), (14, 1), (15, 2), (16, 2), (17, 2), (18, 2), (19, 1), (20, 2), (51, 1), (57, 2), (117, 2), (137, 1), (236, 1)], [], [(6, 2), (9, 1), (12, 1), (17, 2), (18, 1), (34, 2), (51, 1), (60, 2), (65, 1), (68, 2), (117, 1), (137, 2)], [(0, 1), (1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (9, 2), (12, 1), (17, 2), (18, 1), (19, 2), (51, 1), (57, 1), (60, 1), (65, 2), (68, 1), (117, 2), (137, 1)], [], [], [(6, 2), (11, 1), (12, 1), (17, 2), (18, 1), (34, 2), (51, 1), (60, 2), (65, 1), (68, 2), (117, 1), (137, 2)], [(6, 2), (7, 2), (10, 1), (11, 1), (12, 1), (17, 2), (18, 1), (34, 2), (51, 1), (60, 2), (65, 1), (68, 2), (117, 1), (137, 2)], [(1, 1), (2, 1), (3, 2), (6, 2), (7, 2), (11, 2), (12, 1), (14, 2), (16, 1), (17, 2), (51, 1), (57, 2), (60, 1), (65, 2), (68, 1), (117, 2), (137, 1)], [(1, 1), (2, 2), (3, 1), (7, 2), (8, 2), (11, 2), (51, 1), (57, 2), (60, 1), (65, 2), (68, 1), (117, 2), (137, 1)], [], [], [(6, 2), (12, 1), (17, 2), (18, 1), (34, 2), (51, 1), (60, 2), (65, 1), (117, 1), (137, 2)], [(6, 1), (8, 1), (12, 1), (17, 2), (18, 1), (34, 2), (51, 1), (60, 2), (67, 1), (117, 1), (137, 2)], [(1, 2), (2, 1), (3, 2), (6, 2), (7, 1), (12, 2), (14, 1), (15, 2), (16, 1), (17, 2), (51, 1), (57, 2), (71, 1), (73, 1), (74, 2), (117, 2), (137, 1)], [(1, 2), (2, 2), (3, 1), (7, 1), (8, 2), (12, 1), (14, 2), (15, 2), (16, 1), (17, 2), (51, 1), (57, 2), (71, 1), (117, 2), (137, 1)], [], [], [], [], [], [], [], [], [(1, 1), (2, 1), (3, 2), (6, 1), (7, 2), (8, 2), (9, 2), (11, 2), (13, 2), (14, 1), (15, 2), (16, 1), (18, 2), (34, 2), (57, 1), (60, 2), (65, 1), (68, 2), (117, 1), (120, 1), (157, 1), (293, 2)], [(0, 1), (2, 2), (3, 1), (6, 2), (8, 2), (9, 1), (11, 1), (12, 2), (13, 1), (14, 1), (15, 1), (16, 2), (17, 1), (19, 2), (51, 2), (60, 1), (65, 2), (68, 1), (117, 2), (120, 1), (293, 1), (392, 1)], [], [], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (12, 2), (17, 1), (18, 2), (19, 2), (34, 1), (51, 2), (57, 1), (114, 1), (120, 2), (293, 1)], [], [], [], [], [(1, 2), (2, 1), (3, 2), (6, 2), (7, 1), (12, 2), (13, 1), (14, 2), (15, 2), (16, 1), (17, 1), (18, 1), (34, 2), (51, 2), (57, 1)], [], [], [], [], [(0, 1), (2, 1), (3, 2), (8, 1), (9, 2), (12, 1), (14, 1), (15, 1), (16, 2), (17, 1), (19, 2), (34, 1), (51, 2), (57, 1), (60, 1), (65, 2), (68, 1), (71, 2), (74, 1)], [], [], [], [(0, 1), (1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (9, 2), (11, 1), (12, 2), (17, 1), (19, 2), (34, 1), (51, 2), (57, 1)], [], [], [], [], [(1, 1), (2, 1), (3, 2), (7, 2), (8, 1), (12, 2), (17, 1), (18, 2), (34, 1), (51, 2), (57, 2)], [(1, 1), (2, 2), (3, 1), (6, 1), (7, 2), (12, 2), (17, 1), (18, 2), (34, 1), (51, 2), (57, 2)], [], []] + +def comb100 : List (List (Nat × Nat)) := [[], [], [(0, 2), (1, 1), (2, 2), (4, 2), (5, 1), (7, 2), (8, 1), (9, 1), (11, 1), (12, 2), (17, 2), (18, 1), (19, 2), (44, 2), (58, 1), (66, 1), (72, 2), (115, 2), (127, 2)], [(0, 1), (6, 1), (8, 2), (9, 2), (11, 2), (15, 2), (16, 2), (17, 2), (18, 2), (19, 2), (20, 2), (34, 1), (58, 1), (66, 2), (72, 1), (115, 2), (127, 1), (173, 1)], [], [], [], [(0, 2), (1, 1), (2, 2), (4, 2), (5, 1), (6, 1), (7, 2), (8, 1), (9, 1), (11, 1), (12, 2), (17, 2), (44, 1), (58, 2), (66, 1), (72, 2), (115, 1), (127, 2), (172, 1), (173, 2)], [], [(0, 1), (6, 1), (8, 2), (9, 2), (11, 2), (15, 2), (16, 2), (17, 2), (19, 2), (20, 2), (34, 1), (58, 1), (66, 2), (72, 1), (115, 2), (127, 1), (172, 2), (173, 1)], [], [(0, 2), (1, 2), (2, 1), (4, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (15, 2), (16, 1), (17, 1), (19, 2), (34, 1), (44, 1), (58, 2), (74, 2), (75, 1), (115, 1), (127, 2), (172, 1), (173, 2)], [], [], [(1, 2), (4, 1), (5, 2), (7, 1), (8, 2), (11, 2), (12, 1), (15, 2), (16, 1), (18, 1), (19, 2), (34, 1), (44, 1), (58, 2), (66, 1), (72, 2), (115, 1), (127, 2), (172, 1), (173, 2)], [], [(2, 1), (6, 2), (8, 1), (11, 1), (15, 2), (17, 2), (18, 2), (20, 1), (34, 1), (58, 1), (66, 2), (72, 1), (115, 2), (127, 1), (172, 2), (173, 1)], [], [], [(2, 1), (6, 1), (8, 2), (11, 1), (15, 2), (17, 2), (18, 2), (20, 1), (34, 1), (58, 1), (66, 2), (72, 1), (115, 2), (127, 1), (172, 2), (173, 1)], [], [(0, 1), (1, 2), (2, 1), (4, 1), (5, 2), (7, 1), (8, 2), (9, 2), (11, 2), (17, 2), (18, 2), (19, 1), (44, 1), (58, 1), (66, 2), (72, 1), (115, 2), (127, 1), (172, 2), (173, 1)], [], [], [(0, 1), (1, 1), (2, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 2), (9, 2), (11, 1), (12, 1), (17, 2), (18, 2), (19, 1), (44, 2), (58, 2), (115, 1), (127, 2), (172, 2), (173, 1)], [], [(0, 2), (2, 1), (6, 2), (8, 1), (9, 1), (11, 2), (12, 2), (15, 2), (17, 1), (18, 1), (19, 1), (20, 1), (34, 1), (58, 1), (115, 2), (127, 1), (172, 1), (173, 2)], [], [], [], [(0, 1), (2, 1), (6, 2), (8, 1), (9, 1), (11, 1), (12, 2), (15, 2), (17, 2), (19, 2), (20, 1), (34, 1), (58, 2), (66, 1), (72, 2), (115, 2), (127, 1), (172, 1), (173, 2)], [(0, 2), (1, 2), (2, 2), (4, 1), (5, 2), (6, 1), (7, 2), (9, 1), (11, 2), (12, 2), (15, 2), (17, 1), (19, 2), (20, 1), (34, 1), (44, 2), (58, 2), (115, 1), (127, 2), (172, 2), (173, 1)], [(0, 1), (2, 2), (9, 2), (11, 1), (12, 1), (15, 2), (17, 2), (19, 2), (20, 1), (34, 1), (58, 1), (115, 2), (127, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 1), (16, 2), (17, 2), (19, 2), (20, 1), (34, 1), (44, 2), (58, 2), (115, 1), (127, 2), (172, 2), (173, 1)], [(0, 1), (2, 2), (8, 2), (9, 2), (11, 2), (12, 2), (15, 1), (17, 1), (19, 1), (20, 2), (34, 2), (44, 1), (58, 2), (115, 1), (127, 2), (172, 2), (173, 1)], [(0, 1), (2, 1), (6, 2), (8, 1), (9, 2), (11, 1), (12, 2), (15, 2), (17, 2), (19, 2), (20, 1), (34, 1), (58, 1), (115, 2), (127, 1), (172, 1), (173, 2)], [], [(0, 2), (1, 2), (2, 2), (5, 2), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (16, 1), (17, 1), (20, 2), (21, 1), (44, 1), (58, 1), (115, 2), (127, 1), (172, 1), (173, 2)], [], [(0, 1), (1, 2), (2, 1), (4, 1), (5, 2), (7, 1), (8, 2), (9, 2), (11, 2), (12, 1), (17, 1), (18, 2), (19, 1), (44, 1), (58, 2), (66, 2), (72, 1), (115, 1), (127, 2)], [(0, 2), (2, 1), (6, 2), (8, 1), (9, 1), (11, 1), (12, 2), (15, 2), (17, 2), (18, 1), (19, 1), (20, 1), (34, 1), (58, 1), (66, 1), (72, 2), (115, 2), (127, 1)], [], [], [(0, 1), (2, 2), (9, 2), (11, 1), (12, 1), (15, 2), (17, 2), (18, 1), (19, 1), (20, 1), (34, 1), (58, 1), (115, 2), (127, 1)], [], [(0, 2), (1, 2), (2, 2), (4, 1), (5, 2), (7, 1), (8, 2), (9, 1), (11, 2), (12, 2), (15, 2), (17, 1), (18, 2), (20, 1), (34, 1), (44, 1), (117, 1), (127, 2)], [], [(0, 1), (2, 2), (6, 1), (8, 2), (9, 1), (11, 2), (12, 2), (15, 1), (17, 1), (18, 2), (19, 2), (20, 2), (34, 2), (120, 1), (127, 2)], [(0, 1), (2, 1), (4, 2), (5, 1), (6, 2), (8, 1), (9, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (18, 1), (19, 2), (34, 1), (58, 1), (115, 2), (127, 1), (173, 2), (174, 1)], [], [(0, 2), (1, 2), (2, 2), (5, 2), (6, 1), (7, 1), (8, 1), (9, 1), (11, 2), (12, 2), (16, 1), (17, 1), (18, 1), (20, 2), (44, 1), (58, 1), (115, 2), (127, 1), (173, 2), (181, 1)], [(1, 2), (2, 2), (4, 1), (5, 2), (6, 2), (7, 1), (9, 1), (12, 2), (15, 2), (19, 2), (20, 1), (34, 1), (44, 1), (58, 2), (66, 2), (72, 1), (115, 1), (127, 2)], [], [(0, 1), (2, 2), (4, 1), (5, 2), (9, 2), (12, 1), (15, 2), (19, 2), (20, 1), (34, 1), (58, 1), (66, 1), (72, 2), (115, 2), (127, 1)], [], [], [(0, 2), (2, 2), (6, 1), (7, 2), (8, 2), (9, 1), (10, 1), (12, 2), (15, 1), (19, 1), (20, 2), (34, 2), (58, 2), (66, 2), (72, 1), (115, 1), (127, 2)], [(0, 1), (2, 1), (6, 2), (8, 1), (9, 2), (12, 2), (15, 2), (16, 1), (17, 2), (19, 2), (20, 1), (34, 1), (58, 1), (66, 1), (72, 2), (115, 2), (127, 1)], [], [(0, 2), (1, 2), (2, 2), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (11, 1), (12, 2), (16, 1), (17, 2), (20, 2), (22, 1), (44, 1), (58, 1), (66, 1), (72, 2), (115, 2), (127, 1)], [(1, 2), (2, 2), (4, 1), (5, 2), (6, 2), (7, 1), (12, 2), (15, 2), (19, 2), (20, 1), (34, 1), (44, 1), (58, 2), (72, 1), (115, 1), (127, 2)], [], [(0, 2), (1, 1), (2, 1), (4, 2), (5, 1), (7, 2), (9, 1), (16, 1), (17, 2), (19, 1), (20, 2), (34, 2), (58, 2), (66, 2), (67, 1), (72, 1), (115, 1), (127, 2)], [(2, 2), (12, 1), (15, 2), (19, 2), (20, 1), (34, 1), (58, 1), (73, 1), (74, 2), (115, 2), (127, 1)], [], [(0, 2), (1, 2), (4, 1), (5, 1), (6, 2), (7, 1), (9, 2), (11, 1), (12, 1), (16, 1), (17, 2), (20, 2), (44, 1), (80, 1), (115, 2), (127, 1)], [], [], [], [], [], [], [], [(1, 2), (2, 2), (4, 1), (5, 2), (7, 1), (8, 2), (11, 1), (15, 1), (17, 2), (18, 2), (19, 2), (20, 2), (34, 2), (44, 1), (58, 1), (66, 2), (72, 1), (115, 2), (157, 1), (172, 2), (173, 1)], [], [(0, 1), (2, 1), (6, 2), (7, 2), (8, 2), (9, 2), (12, 2), (16, 1), (17, 2), (18, 1), (20, 2), (44, 2), (66, 1), (72, 2), (172, 1), (173, 1), (216, 1)], [], [], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 1), (15, 1), (17, 2), (19, 1), (20, 2), (34, 2), (44, 1), (58, 1), (114, 1), (115, 2), (172, 1), (173, 2)], [], [], [], [], [(0, 1), (1, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 2), (11, 1), (12, 1), (15, 1), (17, 2), (18, 1), (20, 2), (34, 2), (44, 2)], [], [], [], [], [(1, 1), (2, 2), (4, 2), (5, 1), (6, 1), (7, 2), (11, 2), (15, 2), (19, 2), (20, 1), (34, 1), (44, 2), (66, 1), (72, 2), (74, 1)], [], [], [], [(0, 2), (1, 1), (4, 2), (5, 1), (6, 2), (7, 2), (8, 2), (9, 1), (11, 2), (12, 2), (15, 2), (17, 1), (19, 2), (20, 1), (34, 1), (44, 2)], [], [], [], [(0, 2), (1, 1), (2, 2), (4, 2), (5, 2), (6, 1), (7, 2), (9, 1), (11, 2), (15, 2), (19, 2), (20, 1), (34, 1), (44, 2)], [], [], [], []] + +def comb101 : List (List (Nat × Nat)) := [[], [], [(1, 1), (3, 1), (7, 2), (8, 2), (9, 1), (15, 2), (16, 1), (18, 2), (34, 1), (63, 1), (120, 2), (130, 2)], [], [(0, 2), (1, 2), (4, 1), (5, 2), (6, 1), (10, 1), (13, 2), (16, 2), (18, 2), (24, 2), (25, 1), (63, 2), (64, 2), (120, 2), (130, 1), (234, 1)], [], [], [(0, 1), (3, 1), (4, 1), (5, 2), (7, 2), (8, 2), (10, 1), (15, 2), (16, 1), (18, 2), (24, 2), (25, 1), (34, 1), (63, 1), (64, 1), (120, 1), (130, 2), (233, 1), (234, 2)], [], [], [(0, 2), (1, 2), (4, 1), (5, 2), (6, 1), (10, 1), (13, 2), (16, 2), (18, 2), (25, 1), (63, 2), (64, 2), (120, 2), (130, 1), (233, 2), (234, 1)], [(0, 1), (1, 1), (3, 1), (4, 1), (5, 2), (7, 1), (9, 2), (10, 1), (15, 1), (16, 2), (18, 1), (24, 2), (25, 1), (34, 2), (64, 2), (73, 2), (75, 1), (120, 1), (130, 2), (233, 1), (234, 2)], [], [(0, 2), (1, 2), (4, 1), (5, 2), (10, 1), (13, 2), (16, 2), (24, 2), (25, 1), (64, 2), (120, 2), (130, 1), (233, 2), (234, 1)], [(0, 1), (1, 1), (3, 1), (4, 1), (5, 2), (7, 1), (8, 2), (10, 1), (15, 1), (16, 1), (18, 2), (24, 2), (25, 1), (34, 2), (63, 1), (64, 1), (120, 1), (130, 2), (233, 1), (234, 2)], [], [], [(0, 2), (1, 2), (4, 1), (5, 2), (8, 1), (10, 1), (13, 2), (16, 2), (24, 2), (25, 1), (63, 2), (64, 2), (120, 2), (130, 1), (233, 2), (234, 1)], [(0, 1), (1, 1), (4, 2), (5, 1), (8, 2), (10, 2), (13, 2), (16, 1), (24, 1), (25, 2), (63, 1), (64, 1), (120, 1), (130, 2), (233, 1), (234, 2)], [], [(0, 2), (1, 2), (4, 1), (5, 2), (6, 1), (10, 1), (13, 2), (16, 2), (24, 2), (25, 1), (63, 2), (64, 2), (120, 2), (130, 1), (233, 2), (234, 1)], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 1), (13, 1), (14, 2), (15, 1), (18, 1), (34, 2), (63, 2), (64, 2), (120, 2), (130, 1), (233, 2), (234, 1)], [], [], [(1, 2), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (10, 2), (13, 2), (15, 2), (16, 1), (18, 2), (24, 1), (25, 2), (34, 1), (64, 2), (120, 1), (130, 2), (233, 2), (234, 1)], [], [], [(0, 1), (1, 1), (3, 2), (4, 2), (5, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (13, 1), (14, 1), (16, 1), (24, 1), (25, 2), (64, 1), (120, 2), (130, 1), (233, 1), (234, 2)], [], [], [], [(0, 2), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 2), (11, 2), (14, 2), (15, 1), (16, 2), (18, 1), (24, 1), (25, 2), (34, 2), (64, 2), (120, 1), (130, 2), (233, 2), (234, 1)], [], [(0, 1), (3, 2), (6, 1), (8, 2), (9, 2), (13, 2), (16, 2), (64, 1), (120, 2), (130, 1), (233, 1), (234, 2)], [(0, 2), (1, 2), (4, 2), (5, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 2), (11, 2), (14, 2), (15, 2), (16, 2), (18, 1), (24, 1), (25, 2), (34, 2), (64, 2), (120, 1), (130, 2), (233, 2), (234, 1)], [], [], [(0, 1), (3, 1), (6, 2), (8, 1), (9, 2), (13, 2), (14, 1), (16, 2), (64, 1), (120, 2), (130, 1), (233, 1), (234, 2)], [(0, 1), (4, 1), (5, 1), (6, 2), (7, 1), (8, 1), (9, 2), (10, 2), (13, 1), (14, 2), (15, 1), (18, 1), (21, 1), (24, 1), (25, 2), (34, 2), (64, 1), (120, 2), (130, 1), (233, 1), (234, 2)], [], [(4, 2), (5, 1), (6, 1), (7, 1), (9, 2), (10, 2), (11, 1), (13, 1), (14, 1), (15, 2), (18, 2), (24, 1), (25, 2), (34, 1), (63, 2), (120, 1), (130, 2)], [], [(1, 1), (3, 2), (4, 2), (5, 1), (6, 1), (8, 1), (9, 1), (10, 2), (13, 2), (16, 2), (24, 1), (25, 2), (63, 1), (120, 2), (130, 1)], [], [], [(1, 1), (3, 2), (4, 2), (5, 1), (6, 1), (8, 2), (10, 2), (13, 2), (16, 2), (24, 1), (25, 2), (64, 1), (120, 2), (130, 1)], [(1, 2), (6, 2), (7, 1), (8, 1), (11, 2), (14, 2), (15, 1), (16, 2), (18, 1), (34, 2), (117, 1), (130, 2)], [(1, 2), (3, 2), (4, 1), (5, 2), (6, 1), (8, 2), (9, 2), (10, 1), (13, 1), (16, 1), (24, 2), (25, 1), (115, 1), (130, 2)], [], [], [(0, 1), (1, 1), (3, 1), (6, 1), (7, 2), (8, 2), (9, 2), (11, 1), (13, 1), (14, 1), (16, 1), (18, 1), (24, 1), (25, 2), (64, 1), (120, 2), (130, 1), (234, 2), (236, 1)], [(1, 1), (5, 2), (6, 2), (7, 1), (8, 1), (9, 1), (10, 1), (13, 1), (14, 2), (15, 1), (18, 1), (24, 2), (25, 1), (34, 2), (120, 2), (130, 1), (181, 1)], [(4, 2), (5, 1), (6, 2), (7, 1), (8, 2), (10, 2), (13, 2), (15, 1), (16, 1), (18, 1), (24, 1), (25, 2), (34, 2), (63, 2), (120, 1), (130, 2)], [], [], [(3, 2), (4, 2), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 2), (11, 2), (14, 2), (63, 1), (120, 2), (130, 1)], [(3, 2), (6, 1), (9, 2), (11, 1), (14, 1), (63, 2), (120, 1), (130, 2)], [], [], [(3, 1), (6, 2), (7, 1), (9, 1), (10, 2), (11, 2), (16, 2), (17, 1), (63, 1), (120, 2), (130, 1)], [(4, 1), (5, 1), (6, 2), (7, 2), (9, 1), (10, 1), (11, 2), (13, 2), (14, 1), (15, 1), (16, 1), (18, 1), (22, 1), (24, 1), (25, 2), (34, 2), (63, 1), (120, 2), (130, 1)], [(4, 2), (5, 1), (6, 1), (7, 1), (8, 2), (10, 2), (13, 2), (15, 1), (16, 1), (18, 1), (24, 1), (25, 2), (34, 2), (64, 2), (66, 1), (120, 1), (130, 2)], [(1, 1), (3, 2), (6, 1), (7, 2), (9, 2), (11, 1), (14, 1), (15, 2), (63, 2), (65, 1), (120, 1), (130, 2)], [], [], [(3, 1), (6, 2), (7, 1), (8, 1), (9, 1), (10, 2), (11, 2), (14, 2), (71, 1), (120, 2), (130, 1)], [(4, 1), (5, 1), (6, 2), (7, 2), (8, 1), (9, 1), (10, 1), (11, 2), (13, 2), (14, 1), (15, 1), (16, 1), (18, 1), (24, 1), (25, 2), (34, 2), (80, 1), (120, 2), (130, 1)], [], [], [], [], [], [], [], [(0, 2), (1, 2), (3, 1), (6, 1), (7, 1), (13, 1), (14, 2), (15, 1), (18, 1), (34, 2), (63, 2), (64, 2), (120, 2), (157, 1), (233, 2), (234, 1)], [], [], [(0, 2), (1, 1), (3, 1), (4, 2), (5, 1), (6, 1), (7, 2), (8, 1), (9, 2), (10, 2), (11, 1), (14, 1), (16, 2), (18, 1), (24, 1), (25, 2), (63, 1), (64, 2), (233, 1), (234, 1), (274, 1)], [], [], [], [(0, 1), (3, 2), (4, 2), (5, 1), (6, 2), (7, 1), (8, 1), (9, 2), (10, 2), (13, 1), (15, 1), (18, 1), (24, 1), (25, 2), (34, 2), (64, 1), (114, 1), (120, 2), (233, 1), (234, 2)], [], [], [], [], [(1, 1), (3, 2), (4, 1), (5, 2), (7, 1), (8, 1), (10, 1), (13, 1), (15, 1), (18, 1), (24, 2), (25, 1), (34, 2)], [], [], [], [], [(3, 2), (4, 1), (5, 2), (6, 2), (7, 2), (9, 1), (10, 1), (13, 1), (15, 2), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1), (63, 1), (64, 2), (73, 1)], [], [], [], [(3, 2), (4, 1), (5, 2), (6, 2), (7, 2), (8, 1), (10, 1), (13, 1), (15, 2), (18, 2), (24, 2), (25, 1), (34, 1)], [], [], [], [(3, 1), (4, 2), (5, 2), (7, 2), (10, 1), (13, 1), (14, 1), (15, 2), (16, 2), (18, 2), (24, 2), (25, 1), (34, 1)], [], [], [], []] + +def comb102 : List (List (Nat × Nat)) := [[], [], [], [(0, 2), (2, 1), (6, 2), (7, 1), (11, 1), (14, 1), (15, 2), (16, 2), (18, 2), (19, 2), (34, 1), (58, 1), (66, 2), (72, 1), (137, 2), (173, 1)], [], [], [], [], [(0, 2), (2, 2), (6, 1), (11, 2), (12, 2), (14, 2), (16, 1), (19, 2), (58, 2), (66, 1), (72, 2), (137, 1), (172, 1), (173, 2)], [(0, 2), (2, 1), (6, 2), (7, 1), (11, 1), (14, 1), (15, 2), (16, 2), (19, 2), (34, 1), (58, 1), (66, 2), (72, 1), (137, 2), (172, 2), (173, 1)], [], [], [(1, 2), (2, 2), (6, 1), (7, 1), (11, 2), (12, 1), (14, 2), (16, 1), (18, 1), (34, 1), (58, 2), (66, 1), (67, 2), (72, 2), (77, 1), (137, 1), (172, 1), (173, 2)], [], [], [(2, 1), (7, 1), (11, 2), (12, 2), (14, 2), (15, 2), (16, 1), (18, 1), (20, 1), (34, 1), (58, 2), (66, 1), (72, 2), (137, 1), (172, 1), (173, 2)], [(0, 2), (2, 1), (7, 1), (11, 1), (14, 1), (15, 2), (16, 2), (18, 2), (19, 2), (34, 1), (58, 1), (66, 2), (72, 1), (137, 2), (172, 2), (173, 1)], [], [(3, 1), (6, 2), (7, 1), (11, 1), (14, 1), (15, 2), (16, 2), (18, 2), (19, 2), (34, 1), (58, 1), (66, 2), (72, 1), (137, 2), (172, 2), (173, 1)], [], [(0, 1), (2, 2), (6, 1), (7, 2), (11, 2), (14, 2), (15, 1), (16, 1), (18, 1), (19, 1), (34, 2), (58, 2), (66, 1), (72, 2), (137, 1), (172, 1), (173, 2)], [(0, 1), (3, 1), (6, 2), (7, 2), (11, 1), (12, 2), (18, 2), (19, 2), (58, 1), (66, 2), (72, 1), (137, 2), (172, 2), (173, 1)], [], [], [], [(0, 1), (2, 2), (3, 2), (11, 2), (14, 2), (16, 1), (18, 2), (58, 2), (137, 1), (172, 2), (173, 1)], [(2, 2), (3, 1), (7, 2), (11, 1), (12, 1), (14, 1), (15, 2), (16, 2), (18, 1), (34, 1), (58, 1), (137, 2), (172, 1), (173, 2)], [], [], [(0, 2), (1, 2), (2, 1), (3, 2), (11, 2), (14, 2), (16, 1), (19, 2), (34, 1), (58, 2), (60, 1), (67, 2), (137, 1), (172, 2), (173, 1)], [(2, 1), (3, 1), (7, 1), (11, 1), (12, 2), (14, 1), (15, 2), (16, 2), (19, 1), (34, 1), (58, 2), (66, 1), (72, 2), (137, 2), (172, 1), (173, 2)], [], [(2, 2), (3, 1), (6, 1), (7, 1), (11, 1), (12, 1), (14, 1), (15, 2), (16, 2), (19, 1), (34, 1), (58, 1), (137, 2), (172, 1), (173, 2)], [], [(0, 1), (2, 2), (3, 1), (11, 2), (14, 2), (16, 1), (19, 2), (34, 1), (58, 2), (137, 1), (172, 2), (173, 1)], [], [], [(2, 2), (3, 1), (7, 2), (11, 2), (12, 1), (15, 1), (16, 1), (19, 2), (34, 2), (58, 2), (137, 1), (172, 2), (173, 1)], [(0, 2), (2, 1), (3, 2), (4, 2), (11, 1), (21, 1), (58, 1), (137, 2), (172, 1), (173, 2)], [], [], [(0, 1), (2, 1), (3, 1), (7, 1), (11, 1), (12, 2), (14, 1), (15, 2), (16, 2), (18, 1), (34, 1), (58, 1), (66, 1), (72, 2), (137, 2)], [], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 1), (11, 2), (14, 2), (15, 2), (16, 1), (18, 2), (58, 2), (66, 2), (67, 1), (72, 1), (137, 1)], [(2, 2), (3, 1), (6, 1), (7, 1), (11, 1), (12, 1), (14, 1), (15, 2), (16, 2), (18, 1), (34, 1), (58, 1), (137, 2)], [], [(1, 1), (3, 1), (11, 2), (14, 2), (15, 2), (16, 1), (18, 2), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (117, 1), (137, 1)], [(0, 1), (2, 1), (3, 2), (7, 1), (11, 1), (12, 1), (14, 1), (15, 2), (16, 2), (18, 1), (34, 1), (115, 1), (137, 2)], [], [], [(0, 1), (1, 1), (2, 1), (3, 1), (7, 2), (11, 2), (12, 1), (14, 2), (15, 1), (16, 1), (18, 2), (19, 1), (20, 2), (34, 1), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (137, 1), (236, 1)], [(0, 2), (2, 1), (3, 2), (4, 2), (11, 1), (18, 1), (58, 1), (137, 2), (173, 2), (181, 1)], [], [(0, 1), (2, 2), (3, 2), (6, 2), (7, 1), (11, 2), (14, 2), (15, 2), (16, 1), (19, 2), (34, 1), (58, 2), (66, 2), (72, 1), (137, 1)], [(1, 1), (2, 1), (3, 1), (6, 1), (11, 1), (12, 2), (14, 1), (15, 2), (16, 2), (19, 1), (34, 1), (58, 1), (66, 1), (72, 2), (137, 2)], [], [(0, 1), (3, 2), (7, 1), (11, 1), (12, 2), (14, 1), (15, 2), (16, 2), (19, 1), (34, 1), (58, 1), (66, 1), (72, 2), (137, 2)], [], [], [(0, 2), (3, 1), (11, 2), (15, 1), (17, 1), (19, 2), (34, 2), (58, 2), (66, 2), (72, 1), (137, 1)], [(0, 2), (1, 1), (3, 2), (4, 2), (7, 2), (11, 1), (12, 1), (22, 1), (58, 1), (66, 1), (72, 2), (137, 2)], [(0, 1), (2, 2), (3, 1), (6, 2), (7, 1), (11, 2), (14, 2), (15, 2), (16, 1), (19, 2), (34, 1), (58, 2), (72, 1), (137, 1)], [(0, 1), (3, 2), (6, 1), (11, 1), (12, 2), (14, 1), (15, 2), (16, 2), (19, 1), (34, 1), (58, 1), (65, 1), (66, 1), (67, 2), (72, 2), (137, 2)], [], [], [(0, 2), (1, 1), (3, 1), (6, 2), (11, 2), (12, 1), (14, 2), (16, 1), (19, 2), (34, 2), (58, 2), (60, 2), (66, 2), (67, 1), (71, 1), (72, 1), (137, 1)], [(0, 2), (1, 1), (2, 1), (3, 2), (4, 2), (6, 1), (7, 2), (11, 1), (80, 1), (137, 2)], [], [(0, 2), (1, 1), (3, 1), (6, 2), (11, 2), (12, 1), (14, 2), (16, 1), (19, 2), (34, 2), (58, 2), (60, 2), (66, 2), (67, 1), (72, 1), (127, 1), (137, 1)], [], [], [], [], [], [], [(0, 1), (2, 2), (3, 2), (6, 1), (7, 2), (15, 1), (18, 2), (19, 1), (34, 2), (66, 2), (72, 1), (172, 2), (173, 1), (392, 1)], [(0, 1), (3, 2), (6, 1), (12, 2), (14, 2), (18, 1), (19, 2), (66, 1), (72, 2), (172, 1), (173, 1), (216, 1)], [], [], [], [], [], [(0, 1), (2, 1), (3, 2), (7, 2), (12, 1), (14, 1), (15, 2), (16, 2), (34, 1), (172, 1), (173, 2), (293, 1)], [], [], [], [], [(0, 1), (2, 1), (3, 2), (7, 2), (12, 1), (13, 1), (15, 1), (18, 1), (19, 2), (34, 2)], [], [], [], [], [(0, 1), (2, 1), (3, 2), (7, 2), (12, 1), (14, 1), (15, 2), (16, 2), (34, 1), (65, 2), (67, 1), (68, 1)], [], [], [], [(0, 1), (2, 1), (3, 2), (6, 1), (7, 1), (11, 1), (12, 1), (14, 1), (15, 2), (16, 2), (34, 1)], [], [], [(0, 2), (1, 2), (4, 1), (7, 2), (12, 1), (14, 1), (15, 2), (16, 2), (34, 1)], [], [], [], []] + +def comb103 : List (List (Nat × Nat)) := [[], [], [], [], [(2, 2), (3, 1), (4, 2), (5, 1), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 1), (25, 2), (34, 1), (63, 2), (64, 2), (137, 2), (234, 1)], [], [], [], [(8, 1), (10, 1), (11, 2), (12, 2), (14, 1), (17, 1), (63, 1), (64, 1), (137, 1), (233, 1), (234, 2)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 2), (34, 1), (63, 2), (64, 2), (137, 2), (233, 2), (234, 1)], [], [(8, 1), (10, 1), (11, 2), (12, 1), (14, 1), (17, 1), (34, 1), (63, 1), (64, 1), (65, 2), (77, 1), (137, 1), (233, 1), (234, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 1), (25, 2), (34, 1), (64, 2), (137, 2), (233, 2), (234, 1)], [], [(2, 2), (8, 1), (10, 1), (11, 2), (12, 2), (14, 1), (15, 2), (17, 1), (20, 1), (34, 1), (63, 1), (64, 1), (137, 1), (233, 1), (234, 2)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (8, 1), (9, 1), (10, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 1), (25, 2), (34, 1), (63, 2), (64, 2), (137, 2), (233, 2), (234, 1)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 2), (10, 1), (11, 2), (12, 1), (15, 1), (16, 2), (17, 2), (24, 2), (25, 1), (34, 2), (63, 1), (64, 1), (137, 1), (233, 1), (234, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 2), (9, 2), (10, 2), (11, 1), (24, 2), (25, 1), (63, 2), (64, 2), (137, 2), (233, 2), (234, 1)], [], [], [], [(2, 2), (3, 2), (4, 1), (5, 2), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (24, 2), (25, 1), (64, 2), (137, 1), (233, 2), (234, 1)], [], [(8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (34, 1), (64, 1), (137, 2), (233, 1), (234, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (24, 2), (25, 1), (34, 1), (60, 1), (64, 2), (65, 2), (137, 1), (233, 2), (234, 1)], [], [], [], [(4, 1), (5, 2), (8, 2), (10, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (64, 1), (137, 2), (233, 1), (234, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (9, 1), (10, 2), (11, 2), (12, 2), (17, 1), (24, 2), (25, 1), (34, 1), (64, 2), (137, 1), (233, 2), (234, 1)], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (64, 1), (137, 2), (233, 1), (234, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (8, 2), (10, 2), (11, 2), (12, 2), (14, 2), (15, 1), (16, 2), (17, 2), (24, 1), (25, 2), (34, 2), (64, 2), (137, 1), (233, 2), (234, 1)], [], [(2, 2), (3, 1), (4, 2), (9, 1), (10, 1), (11, 1), (21, 1), (64, 1), (137, 2), (233, 1), (234, 2)], [], [], [], [(8, 1), (9, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (34, 1), (63, 1), (137, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (11, 2), (15, 2), (16, 1), (24, 2), (25, 1), (63, 2), (65, 1), (137, 1)], [], [(8, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (34, 1), (64, 1), (137, 2)], [(2, 1), (3, 2), (4, 1), (5, 2), (11, 2), (15, 2), (16, 1), (24, 2), (25, 1), (60, 2), (63, 2), (65, 1), (117, 1), (137, 1)], [], [(2, 1), (3, 2), (8, 1), (9, 2), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (34, 1), (120, 1), (137, 2)], [(3, 1), (4, 2), (5, 1), (8, 2), (9, 2), (11, 2), (12, 2), (14, 2), (15, 1), (17, 1), (20, 2), (24, 1), (25, 2), (34, 1), (60, 2), (63, 2), (65, 1), (137, 1), (174, 1)], [], [(2, 2), (3, 1), (4, 1), (5, 1), (11, 1), (24, 1), (25, 2), (137, 2), (181, 1)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (11, 2), (15, 2), (16, 1), (24, 2), (25, 1), (34, 1), (63, 2), (137, 1)], [], [(8, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (63, 1), (137, 2)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (63, 1), (137, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (8, 2), (9, 2), (11, 2), (12, 2), (14, 2), (15, 1), (17, 1), (24, 1), (25, 2), (34, 2), (63, 2), (137, 1)], [], [(2, 2), (3, 1), (4, 2), (9, 2), (11, 1), (22, 1), (63, 1), (137, 2)], [(3, 2), (4, 1), (5, 2), (11, 2), (15, 2), (16, 1), (24, 2), (25, 1), (34, 1), (64, 2), (66, 1), (137, 1)], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (63, 1), (65, 2), (67, 1), (137, 2)], [(2, 2), (3, 1), (4, 2), (5, 1), (8, 1), (11, 2), (12, 2), (14, 2), (15, 1), (16, 2), (17, 1), (24, 1), (25, 2), (34, 2), (64, 2), (73, 1), (137, 1)], [], [(2, 2), (3, 1), (4, 2), (8, 1), (9, 2), (11, 1), (80, 1), (137, 2)], [(2, 1), (3, 2), (4, 2), (5, 1), (8, 2), (9, 2), (11, 2), (12, 2), (14, 2), (15, 1), (16, 2), (17, 1), (24, 1), (25, 2), (34, 2), (120, 2), (130, 1), (137, 1)], [], [], [], [], [], [], [], [(2, 2), (3, 1), (8, 1), (9, 1), (10, 2), (12, 2), (14, 2), (15, 1), (16, 2), (17, 1), (34, 2), (63, 2), (64, 2), (120, 2), (233, 2), (234, 1), (392, 1)], [], [(2, 2), (3, 1), (4, 2), (5, 1), (8, 1), (9, 2), (10, 2), (12, 2), (14, 1), (24, 1), (25, 2), (63, 1), (64, 2), (233, 1), (234, 1), (274, 1)], [], [], [], [], [(2, 1), (3, 2), (4, 2), (5, 1), (8, 1), (9, 1), (10, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (64, 1), (120, 2), (233, 1), (234, 2), (293, 1)], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (9, 2), (12, 2), (13, 1), (14, 2), (15, 1), (16, 2), (17, 1), (24, 2), (25, 1), (34, 2)], [], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 1), (9, 2), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1), (63, 1), (64, 2), (68, 1)], [], [], [], [(2, 1), (3, 2), (4, 1), (5, 2), (8, 2), (9, 1), (11, 1), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1)], [], [], [(2, 2), (3, 1), (4, 2), (5, 2), (8, 1), (9, 2), (12, 2), (15, 2), (16, 1), (17, 1), (24, 2), (25, 1), (34, 1)], [], [], [], []] + +def combData : List (List (List (Nat × Nat))) := [comb0, comb1, comb2, comb3, comb4, comb5, comb6, comb7, comb8, comb9, comb10, comb11, comb12, comb13, comb14, comb15, comb16, comb17, comb18, comb19, comb20, comb21, comb22, comb23, comb24, comb25, comb26, comb27, comb28, comb29, comb30, comb31, comb32, comb33, comb34, comb35, comb36, comb37, comb38, comb39, comb40, comb41, comb42, comb43, comb44, comb45, comb46, comb47, comb48, comb49, comb50, comb51, comb52, comb53, comb54, comb55, comb56, comb57, comb58, comb59, comb60, comb61, comb62, comb63, comb64, comb65, comb66, comb67, comb68, comb69, comb70, comb71, comb72, comb73, comb74, comb75, comb76, comb77, comb78, comb79, comb80, comb81, comb82, comb83, comb84, comb85, comb86, comb87, comb88, comb89, comb90, comb91, comb92, comb93, comb94, comb95, comb96, comb97, comb98, comb99, comb100, comb101, comb102, comb103] + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8CheckFrames.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8CheckFrames.lean new file mode 100644 index 0000000000..11923fcc13 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8CheckFrames.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the 759 frames. -/ + +namespace CarrierCode.E8 + +theorem framesOK_true : framesOK := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data.lean new file mode 100644 index 0000000000..4a650daddb --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data.lean @@ -0,0 +1,873 @@ +/-! Generated by Matarener/Internal local-topology-2026-10-27/e8hand/gen_lean_data.py. Roots of the 104 ports +mod 3 in D8 coordinates (order of ports.json) and the 759 frames of pairwise orthogonal ports. -/ + +namespace CarrierCode.E8 + +def rootData : List (List Nat) := [ + [1, 1, 0, 0, 0, 0, 0, 0], + [1, 0, 0, 1, 0, 0, 0, 0], + [2, 2, 1, 2, 2, 1, 1, 2], + [1, 0, 0, 0, 1, 0, 0, 0], + [2, 2, 1, 2, 2, 2, 1, 1], + [0, 1, 1, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 0, 0, 0, 0], + [1, 2, 2, 2, 2, 1, 1, 2], + [1, 2, 2, 2, 2, 1, 2, 1], + [0, 0, 1, 0, 1, 0, 0, 0], + [1, 2, 2, 2, 2, 2, 1, 1], + [0, 1, 0, 0, 0, 0, 0, 1], + [0, 1, 0, 0, 0, 0, 1, 0], + [0, 1, 0, 0, 0, 1, 0, 0], + [0, 0, 0, 1, 0, 0, 0, 1], + [0, 0, 0, 1, 0, 0, 1, 0], + [2, 1, 2, 2, 2, 2, 2, 2], + [0, 0, 0, 1, 0, 1, 0, 0], + [0, 0, 0, 0, 1, 0, 0, 1], + [0, 0, 0, 0, 1, 0, 1, 0], + [1, 2, 1, 2, 2, 2, 2, 1], + [0, 0, 0, 0, 1, 1, 0, 0], + [2, 2, 2, 1, 1, 1, 1, 1], + [2, 1, 2, 2, 1, 1, 1, 1], + [0, 0, 0, 0, 0, 2, 2, 0], + [0, 0, 0, 0, 0, 2, 0, 2], + [2, 1, 2, 1, 2, 1, 1, 1], + [0, 0, 0, 0, 0, 0, 2, 2], + [1, 0, 0, 0, 2, 0, 0, 0], + [2, 2, 1, 1, 1, 1, 2, 1], + [1, 0, 0, 2, 0, 0, 0, 0], + [2, 1, 1, 2, 1, 1, 1, 2], + [1, 2, 0, 0, 0, 0, 0, 0], + [2, 1, 1, 2, 1, 2, 1, 1], + [0, 0, 2, 0, 0, 2, 0, 0], + [0, 0, 2, 0, 0, 0, 2, 0], + [2, 1, 1, 1, 2, 1, 2, 1], + [0, 0, 2, 0, 0, 0, 0, 2], + [2, 1, 1, 1, 2, 2, 1, 1], + [0, 0, 1, 0, 2, 0, 0, 0], + [1, 2, 2, 1, 1, 1, 1, 2], + [0, 0, 1, 2, 0, 0, 0, 0], + [1, 2, 2, 1, 1, 2, 1, 1], + [1, 1, 2, 2, 1, 1, 2, 1], + [0, 2, 1, 0, 0, 0, 0, 0], + [1, 1, 2, 2, 1, 2, 1, 1], + [2, 0, 0, 0, 0, 2, 0, 0], + [1, 1, 2, 1, 2, 1, 1, 2], + [2, 0, 0, 0, 0, 0, 2, 0], + [1, 1, 2, 1, 2, 1, 2, 1], + [2, 0, 0, 0, 0, 0, 0, 2], + [1, 1, 2, 1, 2, 2, 1, 1], + [0, 0, 0, 0, 2, 0, 0, 1], + [0, 0, 0, 0, 2, 0, 1, 0], + [2, 1, 2, 1, 1, 2, 2, 2], + [0, 0, 0, 0, 2, 1, 0, 0], + [0, 0, 0, 2, 0, 0, 0, 1], + [1, 2, 1, 1, 1, 2, 1, 2], + [0, 0, 0, 2, 0, 0, 1, 0], + [1, 2, 1, 1, 1, 2, 2, 1], + [0, 0, 0, 2, 0, 1, 0, 0], + [1, 1, 1, 2, 1, 1, 2, 2], + [0, 2, 0, 0, 0, 0, 0, 1], + [1, 1, 1, 2, 1, 2, 1, 2], + [0, 2, 0, 0, 0, 0, 1, 0], + [1, 1, 1, 2, 1, 2, 2, 1], + [0, 2, 0, 0, 0, 1, 0, 0], + [1, 1, 1, 1, 2, 1, 2, 2], + [2, 0, 2, 0, 0, 0, 0, 0], + [1, 1, 1, 1, 2, 2, 1, 2], + [1, 2, 2, 2, 2, 2, 2, 2], + [2, 2, 1, 2, 2, 2, 2, 2], + [0, 0, 0, 1, 1, 0, 0, 0], + [0, 1, 0, 0, 1, 0, 0, 0], + [2, 2, 2, 2, 2, 2, 2, 1], + [2, 2, 2, 2, 2, 2, 1, 2], + [0, 1, 0, 1, 0, 0, 0, 0], + [2, 2, 2, 2, 2, 1, 2, 2], + [1, 0, 2, 0, 0, 0, 0, 0], + [2, 1, 1, 2, 2, 1, 1, 1], + [2, 2, 1, 1, 2, 1, 1, 1], + [1, 0, 0, 0, 0, 0, 0, 2], + [1, 0, 0, 0, 0, 0, 2, 0], + [2, 2, 1, 2, 1, 1, 1, 1], + [1, 0, 0, 0, 0, 2, 0, 0], + [1, 1, 2, 2, 2, 1, 1, 1], + [0, 0, 1, 0, 0, 0, 0, 2], + [0, 0, 1, 0, 0, 0, 2, 0], + [1, 2, 2, 2, 1, 1, 1, 1], + [0, 0, 1, 0, 0, 2, 0, 0], + [0, 1, 0, 2, 0, 0, 0, 0], + [2, 2, 2, 1, 1, 2, 2, 1], + [2, 2, 2, 1, 1, 2, 1, 2], + [0, 1, 0, 0, 2, 0, 0, 0], + [2, 2, 2, 1, 1, 1, 2, 2], + [2, 1, 2, 2, 1, 2, 2, 1], + [2, 1, 2, 2, 1, 2, 1, 2], + [0, 0, 0, 1, 2, 0, 0, 0], + [2, 1, 2, 2, 1, 1, 2, 2], + [0, 0, 0, 0, 0, 0, 2, 1], + [1, 2, 1, 2, 1, 1, 1, 2], + [0, 0, 0, 0, 0, 2, 0, 1], + [1, 2, 1, 2, 1, 1, 2, 1], + [0, 0, 0, 0, 0, 2, 1, 0]] + +def frameData : List (List Nat) := [ + [0, 6, 18, 24, 32, 41, 52, 103], + [0, 6, 18, 26, 31, 40, 54, 103], + [0, 6, 19, 25, 32, 41, 53, 101], + [0, 6, 20, 25, 33, 42, 53, 100], + [0, 6, 21, 26, 33, 42, 54, 99], + [0, 6, 21, 27, 32, 41, 55, 99], + [0, 7, 16, 20, 79, 86, 97, 103], + [0, 7, 16, 26, 31, 39, 56, 103], + [0, 7, 17, 19, 79, 86, 98, 102], + [0, 7, 17, 23, 35, 42, 52, 102], + [0, 7, 17, 27, 31, 39, 57, 102], + [0, 7, 21, 26, 35, 42, 56, 96], + [0, 8, 16, 23, 36, 41, 53, 101], + [0, 8, 17, 18, 79, 87, 98, 100], + [0, 8, 17, 23, 37, 42, 53, 100], + [0, 8, 18, 26, 34, 40, 58, 98], + [0, 8, 21, 26, 37, 42, 58, 95], + [0, 8, 21, 27, 36, 41, 59, 95], + [0, 9, 14, 20, 79, 88, 95, 103], + [0, 9, 14, 24, 32, 39, 56, 103], + [0, 9, 15, 25, 32, 39, 58, 101], + [0, 9, 17, 23, 38, 42, 54, 99], + [0, 9, 17, 27, 32, 39, 60, 99], + [0, 9, 20, 25, 38, 42, 58, 95], + [0, 10, 14, 19, 79, 89, 95, 102], + [0, 10, 14, 23, 35, 40, 55, 102], + [0, 10, 14, 24, 33, 39, 57, 102], + [0, 10, 15, 18, 79, 89, 96, 100], + [0, 10, 15, 25, 33, 39, 59, 100], + [0, 10, 16, 23, 38, 41, 55, 99], + [0, 10, 16, 26, 33, 39, 60, 99], + [0, 10, 18, 24, 38, 41, 57, 96], + [0, 10, 18, 26, 35, 40, 60, 96], + [0, 10, 19, 25, 38, 41, 59, 95], + [0, 14, 19, 32, 34, 53, 56, 89], + [0, 14, 20, 33, 34, 53, 57, 88], + [0, 14, 21, 32, 35, 55, 56, 87], + [0, 15, 18, 32, 34, 52, 58, 89], + [0, 15, 21, 32, 37, 55, 58, 86], + [0, 15, 21, 33, 36, 54, 59, 86], + [0, 16, 20, 33, 36, 53, 60, 86], + [0, 17, 18, 31, 38, 54, 57, 87], + [0, 17, 18, 32, 35, 52, 60, 87], + [0, 17, 19, 32, 37, 53, 60, 86], + [0, 24, 32, 37, 72, 86, 97, 103], + [0, 24, 33, 36, 72, 86, 98, 102], + [0, 25, 32, 35, 72, 87, 97, 101], + [0, 26, 31, 37, 72, 88, 95, 103], + [0, 26, 33, 34, 72, 88, 98, 99], + [0, 27, 31, 36, 72, 89, 95, 102], + [0, 27, 32, 34, 72, 89, 97, 99], + [0, 40, 54, 59, 70, 86, 97, 103], + [0, 40, 55, 58, 70, 86, 98, 102], + [0, 41, 52, 59, 70, 88, 95, 103], + [0, 41, 53, 57, 70, 88, 96, 101], + [0, 42, 52, 58, 70, 89, 95, 102], + [0, 42, 53, 56, 70, 89, 96, 100], + [1, 5, 18, 20, 80, 85, 100, 103], + [1, 5, 18, 24, 30, 44, 52, 103], + [1, 5, 19, 25, 30, 44, 53, 101], + [1, 5, 19, 26, 29, 43, 54, 101], + [1, 5, 20, 27, 29, 43, 55, 100], + [1, 5, 21, 27, 30, 44, 55, 99], + [1, 7, 13, 19, 80, 86, 94, 102], + [1, 7, 13, 22, 35, 45, 52, 102], + [1, 7, 19, 26, 34, 43, 62, 94], + [1, 7, 20, 25, 35, 45, 61, 93], + [1, 7, 20, 27, 34, 43, 63, 93], + [1, 7, 21, 26, 35, 45, 62, 92], + [1, 8, 13, 18, 80, 87, 94, 100], + [1, 8, 13, 22, 37, 45, 53, 100], + [1, 8, 13, 27, 29, 39, 65, 100], + [1, 8, 18, 24, 36, 44, 61, 94], + [1, 8, 21, 26, 37, 45, 64, 91], + [1, 8, 21, 27, 36, 44, 65, 91], + [1, 9, 11, 20, 80, 88, 91, 103], + [1, 9, 11, 24, 30, 39, 62, 103], + [1, 9, 12, 22, 36, 43, 54, 101], + [1, 9, 12, 25, 30, 39, 64, 101], + [1, 9, 13, 22, 38, 45, 54, 99], + [1, 9, 13, 27, 30, 39, 66, 99], + [1, 9, 20, 25, 38, 45, 64, 91], + [1, 9, 20, 27, 36, 43, 66, 91], + [1, 10, 11, 19, 80, 89, 91, 102], + [1, 10, 12, 18, 80, 89, 92, 100], + [1, 10, 12, 22, 37, 43, 55, 100], + [1, 10, 18, 24, 38, 44, 63, 92], + [1, 10, 19, 25, 38, 44, 65, 91], + [1, 10, 19, 26, 37, 43, 66, 91], + [1, 11, 19, 30, 34, 53, 62, 89], + [1, 11, 20, 29, 35, 55, 61, 88], + [1, 11, 21, 30, 35, 55, 62, 87], + [1, 12, 18, 30, 34, 52, 64, 89], + [1, 12, 21, 30, 37, 55, 64, 86], + [1, 13, 18, 30, 35, 52, 66, 87], + [1, 13, 19, 29, 38, 54, 65, 86], + [1, 13, 19, 30, 37, 53, 66, 86], + [1, 18, 20, 34, 38, 63, 64, 85], + [1, 18, 20, 35, 36, 61, 66, 85], + [1, 22, 35, 36, 73, 85, 101, 102], + [1, 24, 30, 37, 73, 86, 93, 103], + [1, 25, 30, 35, 73, 87, 93, 101], + [1, 26, 29, 35, 73, 88, 92, 101], + [1, 27, 30, 34, 73, 89, 93, 99], + [1, 39, 62, 65, 70, 85, 100, 103], + [1, 39, 63, 64, 70, 85, 101, 102], + [1, 43, 54, 63, 70, 87, 93, 101], + [1, 43, 55, 62, 70, 87, 94, 100], + [1, 44, 52, 65, 70, 88, 91, 103], + [1, 44, 53, 63, 70, 88, 92, 101], + [1, 44, 55, 61, 70, 88, 94, 99], + [1, 45, 52, 64, 70, 89, 91, 102], + [1, 45, 53, 62, 70, 89, 92, 100], + [1, 45, 54, 61, 70, 89, 93, 99], + [2, 5, 16, 20, 81, 85, 97, 103], + [2, 5, 16, 23, 30, 47, 52, 103], + [2, 5, 17, 19, 81, 85, 98, 102], + [2, 5, 19, 26, 29, 46, 56, 98], + [2, 5, 20, 27, 29, 46, 57, 97], + [2, 5, 21, 27, 30, 47, 57, 96], + [2, 6, 13, 22, 33, 48, 52, 102], + [2, 6, 13, 27, 28, 40, 63, 102], + [2, 6, 19, 25, 32, 47, 61, 94], + [2, 6, 20, 25, 33, 48, 61, 93], + [2, 6, 21, 26, 33, 48, 62, 92], + [2, 6, 21, 27, 32, 47, 63, 92], + [2, 8, 13, 16, 81, 87, 94, 97], + [2, 8, 13, 27, 29, 40, 68, 97], + [2, 8, 16, 23, 36, 47, 61, 94], + [2, 8, 17, 23, 37, 48, 61, 93], + [2, 8, 21, 26, 37, 48, 67, 90], + [2, 8, 21, 27, 36, 47, 68, 90], + [2, 9, 12, 17, 81, 88, 92, 98], + [2, 9, 12, 22, 36, 46, 56, 98], + [2, 9, 12, 25, 30, 40, 67, 98], + [2, 9, 13, 15, 81, 88, 94, 96], + [2, 9, 13, 22, 38, 48, 56, 96], + [2, 9, 13, 27, 30, 40, 69, 96], + [2, 9, 15, 23, 36, 46, 62, 94], + [2, 9, 17, 23, 38, 48, 62, 92], + [2, 9, 20, 25, 38, 48, 67, 90], + [2, 9, 20, 27, 36, 46, 69, 90], + [2, 10, 12, 16, 81, 89, 92, 97], + [2, 10, 12, 22, 37, 46, 57, 97], + [2, 10, 15, 23, 37, 46, 63, 93], + [2, 10, 16, 23, 38, 47, 63, 92], + [2, 10, 19, 25, 38, 47, 68, 90], + [2, 10, 19, 26, 37, 46, 69, 90], + [2, 12, 16, 28, 36, 56, 61, 89], + [2, 12, 17, 28, 37, 57, 61, 88], + [2, 13, 15, 29, 33, 52, 68, 88], + [2, 13, 16, 28, 38, 56, 63, 87], + [2, 13, 16, 30, 33, 52, 69, 87], + [2, 15, 21, 32, 37, 63, 67, 85], + [2, 15, 21, 33, 36, 62, 68, 85], + [2, 16, 20, 33, 36, 61, 69, 85], + [2, 17, 19, 32, 37, 61, 69, 85], + [2, 22, 32, 37, 74, 85, 97, 103], + [2, 22, 33, 36, 74, 85, 98, 102], + [2, 25, 30, 33, 74, 87, 93, 98], + [2, 26, 28, 37, 74, 88, 90, 103], + [2, 26, 29, 33, 74, 88, 92, 98], + [2, 27, 28, 36, 74, 89, 90, 102], + [2, 27, 29, 32, 74, 89, 92, 97], + [2, 40, 62, 68, 70, 85, 97, 103], + [2, 40, 63, 67, 70, 85, 98, 102], + [2, 46, 56, 63, 70, 87, 93, 98], + [2, 46, 57, 62, 70, 87, 94, 97], + [2, 47, 52, 68, 70, 88, 90, 103], + [2, 47, 57, 61, 70, 88, 94, 96], + [2, 48, 52, 67, 70, 89, 90, 102], + [2, 48, 56, 61, 70, 89, 93, 96], + [3, 5, 14, 20, 83, 85, 95, 103], + [3, 5, 14, 24, 28, 44, 56, 103], + [3, 5, 15, 23, 29, 49, 54, 101], + [3, 5, 15, 25, 28, 44, 58, 101], + [3, 5, 17, 27, 28, 44, 60, 99], + [3, 5, 20, 27, 29, 49, 60, 95], + [3, 6, 11, 22, 31, 47, 54, 103], + [3, 6, 11, 24, 28, 41, 62, 103], + [3, 6, 12, 25, 28, 41, 64, 101], + [3, 6, 13, 22, 33, 51, 54, 99], + [3, 6, 13, 27, 28, 41, 66, 99], + [3, 6, 20, 25, 33, 51, 64, 91], + [3, 7, 12, 17, 83, 86, 92, 98], + [3, 7, 12, 22, 34, 49, 56, 98], + [3, 7, 13, 15, 83, 86, 94, 96], + [3, 7, 13, 22, 35, 51, 56, 96], + [3, 7, 15, 23, 34, 49, 62, 94], + [3, 7, 15, 25, 31, 44, 67, 94], + [3, 7, 17, 23, 35, 51, 62, 92], + [3, 7, 17, 27, 31, 44, 69, 92], + [3, 7, 20, 25, 35, 51, 67, 90], + [3, 7, 20, 27, 34, 49, 69, 90], + [3, 8, 11, 17, 83, 87, 91, 98], + [3, 8, 11, 22, 34, 47, 58, 98], + [3, 8, 11, 24, 29, 41, 67, 98], + [3, 8, 13, 14, 83, 87, 94, 95], + [3, 8, 13, 22, 37, 51, 58, 95], + [3, 8, 14, 23, 34, 47, 64, 94], + [3, 8, 17, 23, 37, 51, 64, 91], + [3, 10, 11, 15, 83, 89, 91, 96], + [3, 10, 11, 22, 35, 47, 60, 96], + [3, 10, 12, 14, 83, 89, 92, 95], + [3, 10, 12, 22, 37, 49, 60, 95], + [3, 10, 14, 23, 35, 47, 66, 92], + [3, 10, 14, 24, 33, 44, 69, 92], + [3, 10, 15, 23, 37, 49, 66, 91], + [3, 11, 15, 28, 34, 58, 62, 89], + [3, 11, 15, 29, 31, 54, 67, 89], + [3, 11, 17, 28, 35, 60, 62, 87], + [3, 12, 14, 28, 34, 56, 64, 89], + [3, 12, 17, 28, 37, 60, 64, 86], + [3, 13, 14, 28, 35, 56, 66, 87], + [3, 13, 15, 28, 37, 58, 66, 86], + [3, 14, 20, 33, 34, 64, 69, 85], + [3, 22, 31, 37, 76, 85, 95, 103], + [3, 22, 33, 34, 76, 85, 98, 99], + [3, 24, 28, 37, 76, 86, 90, 103], + [3, 24, 29, 33, 76, 86, 92, 98], + [3, 25, 28, 35, 76, 87, 90, 101], + [3, 27, 28, 34, 76, 89, 90, 99], + [3, 27, 29, 31, 76, 89, 92, 95], + [3, 41, 64, 69, 70, 85, 96, 101], + [3, 41, 66, 67, 70, 85, 98, 99], + [3, 47, 58, 66, 70, 86, 92, 98], + [3, 47, 60, 64, 70, 86, 94, 96], + [3, 49, 54, 69, 70, 87, 90, 101], + [3, 49, 56, 66, 70, 87, 91, 98], + [3, 49, 60, 62, 70, 87, 94, 95], + [3, 51, 54, 67, 70, 89, 90, 99], + [3, 51, 56, 64, 70, 89, 91, 96], + [3, 51, 58, 62, 70, 89, 92, 95], + [4, 5, 14, 19, 84, 85, 95, 102], + [4, 5, 14, 24, 28, 45, 57, 102], + [4, 5, 15, 18, 84, 85, 96, 100], + [4, 5, 15, 23, 29, 50, 55, 100], + [4, 5, 15, 25, 28, 45, 59, 100], + [4, 5, 16, 23, 30, 51, 55, 99], + [4, 5, 16, 26, 28, 45, 60, 99], + [4, 5, 18, 24, 30, 51, 57, 96], + [4, 5, 19, 25, 30, 51, 59, 95], + [4, 5, 19, 26, 29, 50, 60, 95], + [4, 6, 11, 22, 31, 48, 55, 102], + [4, 6, 11, 24, 28, 42, 63, 102], + [4, 6, 12, 25, 28, 42, 65, 100], + [4, 6, 18, 24, 32, 51, 63, 92], + [4, 6, 18, 26, 31, 48, 66, 92], + [4, 6, 19, 25, 32, 51, 65, 91], + [4, 7, 12, 16, 84, 86, 92, 97], + [4, 7, 12, 22, 34, 50, 57, 97], + [4, 7, 15, 23, 34, 50, 63, 93], + [4, 7, 15, 25, 31, 45, 68, 93], + [4, 7, 16, 26, 31, 45, 69, 92], + [4, 7, 19, 26, 34, 50, 69, 90], + [4, 8, 11, 16, 84, 87, 91, 97], + [4, 8, 11, 22, 34, 48, 59, 97], + [4, 8, 11, 24, 29, 42, 68, 97], + [4, 8, 14, 23, 34, 48, 65, 93], + [4, 8, 16, 23, 36, 51, 65, 91], + [4, 8, 18, 24, 36, 51, 68, 90], + [4, 9, 11, 15, 84, 88, 91, 96], + [4, 9, 11, 24, 30, 42, 69, 96], + [4, 9, 12, 14, 84, 88, 92, 95], + [4, 9, 12, 22, 36, 50, 60, 95], + [4, 9, 14, 24, 32, 45, 69, 92], + [4, 9, 15, 23, 36, 50, 66, 91], + [4, 11, 15, 28, 34, 59, 63, 88], + [4, 11, 15, 29, 31, 55, 68, 88], + [4, 11, 16, 30, 31, 55, 69, 87], + [4, 12, 14, 28, 34, 57, 65, 88], + [4, 12, 16, 28, 36, 60, 65, 86], + [4, 14, 19, 32, 34, 65, 69, 85], + [4, 15, 18, 31, 36, 66, 68, 85], + [4, 22, 31, 36, 77, 85, 95, 102], + [4, 22, 32, 34, 77, 85, 97, 99], + [4, 24, 28, 36, 77, 86, 90, 102], + [4, 24, 29, 32, 77, 86, 92, 97], + [4, 25, 30, 31, 77, 87, 93, 95], + [4, 26, 28, 34, 77, 88, 90, 99], + [4, 26, 29, 31, 77, 88, 92, 95], + [4, 42, 65, 69, 70, 85, 96, 100], + [4, 42, 66, 68, 70, 85, 97, 99], + [4, 48, 59, 66, 70, 86, 92, 97], + [4, 48, 60, 65, 70, 86, 93, 96], + [4, 50, 55, 69, 70, 87, 90, 100], + [4, 50, 57, 66, 70, 87, 91, 97], + [4, 50, 60, 63, 70, 87, 93, 95], + [4, 51, 55, 68, 70, 88, 90, 99], + [4, 51, 57, 65, 70, 88, 91, 96], + [4, 51, 59, 63, 70, 88, 92, 95], + [5, 14, 19, 44, 46, 53, 56, 84], + [5, 14, 20, 45, 46, 53, 57, 83], + [5, 14, 21, 44, 48, 55, 56, 82], + [5, 14, 21, 45, 47, 54, 57, 82], + [5, 15, 18, 44, 46, 52, 58, 84], + [5, 15, 21, 44, 50, 55, 58, 81], + [5, 15, 21, 45, 49, 54, 59, 81], + [5, 16, 20, 43, 51, 55, 58, 81], + [5, 16, 20, 45, 49, 53, 60, 81], + [5, 17, 18, 44, 48, 52, 60, 82], + [5, 17, 19, 43, 51, 54, 59, 81], + [5, 17, 19, 44, 50, 53, 60, 81], + [5, 18, 20, 46, 51, 57, 58, 80], + [5, 23, 47, 50, 72, 80, 100, 103], + [5, 23, 48, 49, 72, 80, 101, 102], + [5, 24, 44, 50, 72, 81, 97, 103], + [5, 24, 45, 49, 72, 81, 98, 102], + [5, 25, 44, 48, 72, 82, 97, 101], + [5, 25, 45, 47, 72, 82, 98, 100], + [5, 26, 43, 48, 72, 83, 96, 101], + [5, 26, 45, 46, 72, 83, 98, 99], + [5, 27, 43, 47, 72, 84, 96, 100], + [5, 27, 44, 46, 72, 84, 97, 99], + [5, 28, 56, 59, 71, 80, 100, 103], + [5, 28, 57, 58, 71, 80, 101, 102], + [5, 29, 54, 57, 71, 82, 97, 101], + [5, 29, 55, 56, 71, 82, 98, 100], + [5, 30, 52, 59, 71, 83, 95, 103], + [5, 30, 53, 57, 71, 83, 96, 101], + [6, 11, 19, 41, 46, 53, 62, 84], + [6, 11, 20, 42, 46, 53, 63, 83], + [6, 11, 21, 41, 48, 55, 62, 82], + [6, 11, 21, 42, 47, 54, 63, 82], + [6, 12, 18, 40, 49, 54, 61, 84], + [6, 12, 18, 41, 46, 52, 64, 84], + [6, 12, 21, 41, 50, 55, 64, 81], + [6, 12, 21, 42, 49, 54, 65, 81], + [6, 13, 18, 40, 51, 54, 63, 82], + [6, 13, 18, 41, 48, 52, 66, 82], + [6, 13, 19, 41, 50, 53, 66, 81], + [6, 18, 20, 46, 51, 63, 64, 79], + [6, 18, 20, 48, 49, 61, 66, 79], + [6, 22, 47, 50, 73, 79, 100, 103], + [6, 22, 48, 49, 73, 79, 101, 102], + [6, 24, 41, 50, 73, 81, 93, 103], + [6, 24, 42, 49, 73, 81, 94, 102], + [6, 25, 41, 48, 73, 82, 93, 101], + [6, 25, 42, 47, 73, 82, 94, 100], + [6, 26, 40, 50, 73, 83, 91, 103], + [6, 26, 42, 46, 73, 83, 94, 99], + [6, 27, 40, 49, 73, 84, 91, 102], + [6, 27, 41, 46, 73, 84, 93, 99], + [6, 28, 62, 65, 71, 79, 100, 103], + [6, 28, 63, 64, 71, 79, 101, 102], + [6, 31, 54, 65, 71, 81, 93, 103], + [6, 31, 55, 64, 71, 81, 94, 102], + [6, 32, 52, 65, 71, 83, 91, 103], + [6, 32, 53, 63, 71, 83, 92, 101], + [6, 32, 55, 61, 71, 83, 94, 99], + [6, 33, 52, 64, 71, 84, 91, 102], + [6, 33, 53, 62, 71, 84, 92, 100], + [6, 33, 54, 61, 71, 84, 93, 99], + [7, 12, 16, 39, 49, 56, 61, 84], + [7, 12, 16, 41, 43, 52, 67, 84], + [7, 12, 17, 39, 50, 57, 61, 83], + [7, 12, 17, 42, 43, 52, 68, 83], + [7, 12, 21, 41, 50, 57, 67, 80], + [7, 12, 21, 42, 49, 56, 68, 80], + [7, 13, 16, 39, 51, 56, 63, 82], + [7, 13, 16, 41, 45, 52, 69, 82], + [7, 15, 21, 44, 50, 63, 67, 79], + [7, 15, 21, 45, 49, 62, 68, 79], + [7, 16, 20, 43, 51, 63, 67, 79], + [7, 16, 20, 45, 49, 61, 69, 79], + [7, 17, 19, 43, 51, 62, 68, 79], + [7, 17, 19, 44, 50, 61, 69, 79], + [7, 22, 44, 50, 74, 79, 97, 103], + [7, 22, 45, 49, 74, 79, 98, 102], + [7, 23, 41, 50, 74, 80, 93, 103], + [7, 23, 42, 49, 74, 80, 94, 102], + [7, 25, 41, 45, 74, 82, 93, 98], + [7, 25, 42, 44, 74, 82, 94, 97], + [7, 26, 39, 50, 74, 83, 90, 103], + [7, 26, 42, 43, 74, 83, 94, 96], + [7, 27, 39, 49, 74, 84, 90, 102], + [7, 27, 41, 43, 74, 84, 93, 96], + [7, 31, 56, 68, 71, 80, 93, 103], + [7, 31, 57, 67, 71, 80, 94, 102], + [7, 34, 56, 63, 71, 82, 93, 98], + [7, 34, 57, 62, 71, 82, 94, 97], + [7, 35, 52, 67, 71, 84, 90, 102], + [7, 35, 56, 61, 71, 84, 93, 96], + [8, 11, 16, 39, 47, 58, 61, 84], + [8, 11, 17, 39, 48, 59, 61, 83], + [8, 11, 21, 41, 48, 59, 67, 80], + [8, 11, 21, 42, 47, 58, 68, 80], + [8, 13, 14, 40, 45, 53, 68, 83], + [8, 13, 16, 39, 51, 58, 65, 81], + [8, 13, 18, 40, 51, 58, 68, 80], + [8, 14, 21, 44, 48, 65, 67, 79], + [8, 14, 21, 45, 47, 64, 68, 79], + [8, 22, 44, 48, 75, 79, 97, 101], + [8, 22, 45, 47, 75, 79, 98, 100], + [8, 23, 41, 48, 75, 80, 93, 101], + [8, 23, 42, 47, 75, 80, 94, 100], + [8, 24, 41, 45, 75, 81, 93, 98], + [8, 24, 42, 44, 75, 81, 94, 97], + [8, 26, 39, 48, 75, 83, 90, 101], + [8, 26, 40, 45, 75, 83, 91, 98], + [8, 27, 39, 47, 75, 84, 90, 100], + [8, 27, 40, 44, 75, 84, 91, 97], + [8, 29, 64, 68, 71, 79, 97, 101], + [8, 29, 65, 67, 71, 79, 98, 100], + [8, 34, 58, 65, 71, 81, 93, 98], + [8, 34, 59, 64, 71, 81, 94, 97], + [8, 36, 53, 68, 71, 83, 90, 101], + [8, 36, 59, 61, 71, 83, 94, 95], + [8, 37, 53, 67, 71, 84, 90, 100], + [8, 37, 58, 61, 71, 84, 93, 95], + [9, 11, 15, 39, 46, 58, 62, 84], + [9, 11, 17, 39, 48, 60, 62, 82], + [9, 11, 20, 42, 46, 58, 69, 80], + [9, 12, 14, 39, 46, 56, 64, 84], + [9, 12, 14, 40, 43, 54, 67, 84], + [9, 12, 17, 39, 50, 60, 64, 81], + [9, 13, 14, 39, 48, 56, 66, 82], + [9, 13, 14, 40, 45, 54, 69, 82], + [9, 13, 15, 39, 50, 58, 66, 81], + [9, 14, 20, 43, 48, 66, 67, 79], + [9, 14, 20, 45, 46, 64, 69, 79], + [9, 22, 43, 48, 76, 79, 96, 101], + [9, 22, 45, 46, 76, 79, 98, 99], + [9, 23, 40, 50, 76, 80, 91, 103], + [9, 23, 42, 46, 76, 80, 94, 99], + [9, 24, 39, 50, 76, 81, 90, 103], + [9, 24, 42, 43, 76, 81, 94, 96], + [9, 25, 39, 48, 76, 82, 90, 101], + [9, 25, 40, 45, 76, 82, 91, 98], + [9, 27, 39, 46, 76, 84, 90, 99], + [9, 27, 40, 43, 76, 84, 91, 96], + [9, 30, 64, 69, 71, 79, 96, 101], + [9, 30, 66, 67, 71, 79, 98, 99], + [9, 32, 58, 69, 71, 80, 92, 101], + [9, 32, 60, 67, 71, 80, 94, 99], + [9, 36, 54, 69, 71, 82, 90, 101], + [9, 36, 56, 66, 71, 82, 91, 98], + [9, 36, 60, 62, 71, 82, 94, 95], + [9, 38, 54, 67, 71, 84, 90, 99], + [9, 38, 56, 64, 71, 84, 91, 96], + [9, 38, 58, 62, 71, 84, 92, 95], + [10, 11, 15, 39, 46, 59, 63, 83], + [10, 11, 16, 39, 47, 60, 63, 82], + [10, 11, 19, 41, 46, 59, 69, 80], + [10, 12, 14, 39, 46, 57, 65, 83], + [10, 12, 14, 40, 43, 55, 68, 83], + [10, 12, 16, 39, 49, 60, 65, 81], + [10, 12, 18, 40, 49, 60, 68, 80], + [10, 14, 19, 43, 47, 66, 68, 79], + [10, 14, 19, 44, 46, 65, 69, 79], + [10, 22, 43, 47, 77, 79, 96, 100], + [10, 22, 44, 46, 77, 79, 97, 99], + [10, 23, 40, 49, 77, 80, 91, 102], + [10, 23, 41, 46, 77, 80, 93, 99], + [10, 24, 39, 49, 77, 81, 90, 102], + [10, 24, 41, 43, 77, 81, 93, 96], + [10, 25, 39, 47, 77, 82, 90, 100], + [10, 25, 40, 44, 77, 82, 91, 97], + [10, 26, 39, 46, 77, 83, 90, 99], + [10, 26, 40, 43, 77, 83, 91, 96], + [10, 33, 59, 69, 71, 80, 92, 100], + [10, 33, 60, 68, 71, 80, 93, 99], + [10, 35, 59, 66, 71, 81, 92, 97], + [10, 35, 60, 65, 71, 81, 93, 96], + [10, 37, 55, 69, 71, 82, 90, 100], + [10, 37, 57, 66, 71, 82, 91, 97], + [10, 37, 60, 63, 71, 82, 93, 95], + [10, 38, 55, 68, 71, 83, 90, 99], + [10, 38, 57, 65, 71, 83, 91, 96], + [10, 38, 59, 63, 71, 83, 92, 95], + [11, 15, 21, 54, 59, 63, 67, 78], + [11, 15, 21, 55, 58, 62, 68, 78], + [11, 16, 20, 53, 60, 63, 67, 78], + [11, 16, 20, 55, 58, 61, 69, 78], + [11, 17, 19, 53, 60, 62, 68, 78], + [11, 17, 19, 54, 59, 61, 69, 78], + [11, 22, 54, 59, 74, 78, 97, 103], + [11, 22, 55, 58, 74, 78, 98, 102], + [11, 24, 62, 68, 72, 78, 97, 103], + [11, 24, 63, 67, 72, 78, 98, 102], + [11, 28, 41, 59, 74, 80, 88, 103], + [11, 28, 42, 58, 74, 80, 89, 102], + [11, 29, 41, 55, 74, 82, 88, 98], + [11, 29, 42, 54, 74, 82, 89, 97], + [11, 30, 42, 53, 74, 83, 89, 96], + [11, 31, 47, 68, 72, 80, 88, 103], + [11, 31, 48, 67, 72, 80, 89, 102], + [11, 34, 47, 63, 72, 82, 88, 98], + [11, 34, 48, 62, 72, 82, 89, 97], + [11, 35, 46, 62, 72, 84, 87, 97], + [11, 35, 47, 61, 72, 84, 88, 96], + [12, 14, 21, 54, 57, 65, 67, 78], + [12, 14, 21, 55, 56, 64, 68, 78], + [12, 17, 18, 52, 60, 64, 68, 78], + [12, 22, 54, 57, 75, 78, 97, 101], + [12, 22, 55, 56, 75, 78, 98, 100], + [12, 25, 64, 68, 72, 78, 97, 101], + [12, 25, 65, 67, 72, 78, 98, 100], + [12, 28, 41, 57, 75, 80, 88, 101], + [12, 28, 42, 56, 75, 80, 89, 100], + [12, 30, 40, 55, 75, 83, 86, 98], + [12, 30, 42, 52, 75, 83, 89, 95], + [12, 34, 49, 65, 72, 81, 88, 98], + [12, 34, 50, 64, 72, 81, 89, 97], + [12, 36, 46, 65, 72, 83, 86, 98], + [12, 36, 50, 61, 72, 83, 89, 95], + [12, 37, 46, 64, 72, 84, 86, 97], + [12, 37, 49, 61, 72, 84, 88, 95], + [13, 14, 19, 53, 56, 66, 68, 78], + [13, 15, 18, 52, 58, 66, 68, 78], + [13, 22, 52, 58, 77, 78, 95, 102], + [13, 22, 53, 56, 77, 78, 96, 100], + [13, 27, 65, 69, 72, 78, 96, 100], + [13, 27, 66, 68, 72, 78, 97, 99], + [13, 28, 40, 58, 77, 80, 86, 102], + [13, 29, 40, 54, 77, 82, 86, 97], + [13, 29, 41, 52, 77, 82, 88, 95], + [13, 30, 40, 53, 77, 83, 86, 96], + [13, 33, 50, 69, 72, 80, 87, 100], + [13, 33, 51, 68, 72, 80, 88, 99], + [13, 35, 50, 66, 72, 81, 87, 97], + [13, 35, 51, 65, 72, 81, 88, 96], + [13, 37, 48, 66, 72, 82, 86, 97], + [13, 37, 51, 63, 72, 82, 88, 95], + [13, 38, 48, 65, 72, 83, 86, 96], + [13, 38, 50, 63, 72, 83, 87, 95], + [14, 23, 54, 65, 74, 78, 93, 103], + [14, 23, 55, 64, 74, 78, 94, 102], + [14, 24, 56, 68, 73, 78, 93, 103], + [14, 24, 57, 67, 73, 78, 94, 102], + [14, 28, 44, 65, 74, 79, 88, 103], + [14, 28, 45, 64, 74, 79, 89, 102], + [14, 32, 39, 65, 74, 83, 85, 103], + [14, 32, 43, 55, 74, 83, 87, 94], + [14, 32, 45, 53, 74, 83, 89, 92], + [14, 33, 39, 64, 74, 84, 85, 102], + [14, 33, 43, 54, 74, 84, 87, 93], + [14, 33, 44, 53, 74, 84, 88, 92], + [14, 34, 47, 57, 73, 82, 88, 94], + [14, 34, 48, 56, 73, 82, 89, 93], + [14, 35, 40, 67, 73, 84, 85, 102], + [14, 35, 46, 56, 73, 84, 87, 93], + [15, 23, 54, 63, 75, 78, 93, 101], + [15, 23, 55, 62, 75, 78, 94, 100], + [15, 25, 58, 68, 73, 78, 93, 101], + [15, 25, 59, 67, 73, 78, 94, 100], + [15, 28, 44, 63, 75, 79, 88, 101], + [15, 28, 45, 62, 75, 79, 89, 100], + [15, 29, 49, 68, 73, 79, 88, 101], + [15, 29, 50, 67, 73, 79, 89, 100], + [15, 31, 44, 55, 75, 81, 88, 94], + [15, 31, 45, 54, 75, 81, 89, 93], + [15, 32, 39, 63, 75, 83, 85, 101], + [15, 32, 45, 52, 75, 83, 89, 91], + [15, 33, 39, 62, 75, 84, 85, 100], + [15, 33, 44, 52, 75, 84, 88, 91], + [15, 34, 49, 59, 73, 81, 88, 94], + [15, 34, 50, 58, 73, 81, 89, 93], + [15, 36, 46, 59, 73, 83, 86, 94], + [15, 37, 46, 58, 73, 84, 86, 93], + [16, 23, 52, 65, 76, 78, 91, 103], + [16, 23, 53, 63, 76, 78, 92, 101], + [16, 23, 55, 61, 76, 78, 94, 99], + [16, 26, 58, 69, 73, 78, 92, 101], + [16, 26, 60, 67, 73, 78, 94, 99], + [16, 28, 43, 63, 76, 79, 87, 101], + [16, 28, 45, 61, 76, 79, 89, 99], + [16, 30, 49, 69, 73, 79, 87, 101], + [16, 30, 51, 67, 73, 79, 89, 99], + [16, 31, 39, 65, 76, 81, 85, 103], + [16, 31, 43, 55, 76, 81, 87, 94], + [16, 31, 45, 53, 76, 81, 89, 92], + [16, 33, 39, 61, 76, 84, 85, 99], + [16, 33, 43, 52, 76, 84, 87, 91], + [16, 36, 41, 69, 73, 82, 85, 101], + [16, 36, 47, 60, 73, 82, 86, 94], + [16, 36, 51, 56, 73, 82, 89, 91], + [16, 38, 41, 67, 73, 84, 85, 99], + [16, 38, 47, 58, 73, 84, 86, 92], + [16, 38, 49, 56, 73, 84, 87, 91], + [17, 23, 52, 64, 77, 78, 91, 102], + [17, 23, 53, 62, 77, 78, 92, 100], + [17, 23, 54, 61, 77, 78, 93, 99], + [17, 27, 59, 69, 73, 78, 92, 100], + [17, 27, 60, 68, 73, 78, 93, 99], + [17, 28, 43, 62, 77, 79, 87, 100], + [17, 28, 44, 61, 77, 79, 88, 99], + [17, 31, 39, 64, 77, 81, 85, 102], + [17, 31, 43, 54, 77, 81, 87, 93], + [17, 31, 44, 53, 77, 81, 88, 92], + [17, 32, 39, 61, 77, 83, 85, 99], + [17, 32, 43, 52, 77, 83, 87, 91], + [17, 35, 50, 60, 73, 81, 87, 93], + [17, 35, 51, 59, 73, 81, 88, 92], + [17, 37, 42, 69, 73, 82, 85, 100], + [17, 37, 48, 60, 73, 82, 86, 93], + [17, 37, 51, 57, 73, 82, 88, 91], + [17, 38, 42, 68, 73, 83, 85, 99], + [17, 38, 48, 59, 73, 83, 86, 92], + [17, 38, 50, 57, 73, 83, 87, 91], + [18, 24, 52, 68, 76, 78, 90, 103], + [18, 24, 57, 61, 76, 78, 94, 96], + [18, 26, 58, 66, 74, 78, 92, 98], + [18, 26, 60, 64, 74, 78, 94, 96], + [18, 30, 49, 66, 74, 79, 87, 98], + [18, 30, 51, 64, 74, 79, 89, 96], + [18, 31, 40, 68, 76, 80, 85, 103], + [18, 31, 46, 57, 76, 80, 87, 94], + [18, 32, 49, 60, 74, 80, 87, 94], + [18, 32, 51, 58, 74, 80, 89, 92], + [18, 34, 40, 63, 76, 82, 85, 98], + [18, 34, 48, 52, 76, 82, 89, 90], + [18, 35, 40, 61, 76, 84, 85, 96], + [18, 35, 46, 52, 76, 84, 87, 90], + [18, 36, 41, 66, 74, 82, 85, 98], + [18, 36, 51, 54, 74, 82, 89, 90], + [18, 38, 41, 64, 74, 84, 85, 96], + [18, 38, 49, 54, 74, 84, 87, 90], + [19, 25, 53, 68, 76, 78, 90, 101], + [19, 25, 59, 61, 76, 78, 94, 95], + [19, 26, 54, 69, 75, 78, 90, 101], + [19, 26, 56, 66, 75, 78, 91, 98], + [19, 26, 60, 62, 75, 78, 94, 95], + [19, 29, 46, 65, 76, 79, 86, 98], + [19, 29, 50, 61, 76, 79, 89, 95], + [19, 30, 47, 66, 75, 79, 86, 98], + [19, 30, 51, 62, 75, 79, 89, 95], + [19, 32, 41, 69, 75, 80, 85, 101], + [19, 32, 47, 60, 75, 80, 86, 94], + [19, 32, 51, 56, 75, 80, 89, 91], + [19, 34, 50, 53, 76, 81, 89, 90], + [19, 37, 46, 53, 76, 84, 86, 90], + [19, 38, 41, 62, 75, 84, 85, 95], + [19, 38, 47, 54, 75, 84, 86, 90], + [20, 25, 53, 67, 77, 78, 90, 100], + [20, 25, 58, 61, 77, 78, 93, 95], + [20, 27, 55, 69, 75, 78, 90, 100], + [20, 27, 57, 66, 75, 78, 91, 97], + [20, 27, 60, 63, 75, 78, 93, 95], + [20, 29, 46, 64, 77, 79, 86, 97], + [20, 29, 49, 61, 77, 79, 88, 95], + [20, 33, 42, 69, 75, 80, 85, 100], + [20, 33, 48, 60, 75, 80, 86, 93], + [20, 33, 51, 57, 75, 80, 88, 91], + [20, 34, 49, 53, 77, 81, 88, 90], + [20, 35, 42, 66, 75, 81, 85, 97], + [20, 35, 51, 55, 75, 81, 88, 90], + [20, 36, 46, 53, 77, 83, 86, 90], + [20, 38, 42, 63, 75, 83, 85, 95], + [20, 38, 48, 55, 75, 83, 86, 90], + [21, 26, 54, 67, 77, 78, 90, 99], + [21, 26, 56, 64, 77, 78, 91, 96], + [21, 26, 58, 62, 77, 78, 92, 95], + [21, 27, 55, 68, 76, 78, 90, 99], + [21, 27, 57, 65, 76, 78, 91, 96], + [21, 27, 59, 63, 76, 78, 92, 95], + [21, 30, 47, 64, 77, 79, 86, 96], + [21, 30, 49, 62, 77, 79, 87, 95], + [21, 32, 41, 67, 77, 80, 85, 99], + [21, 32, 47, 58, 77, 80, 86, 92], + [21, 32, 49, 56, 77, 80, 87, 91], + [21, 33, 42, 68, 76, 80, 85, 99], + [21, 33, 48, 59, 76, 80, 86, 92], + [21, 33, 50, 57, 76, 80, 87, 91], + [21, 35, 42, 65, 76, 81, 85, 96], + [21, 35, 50, 55, 76, 81, 87, 90], + [21, 36, 41, 62, 77, 82, 85, 95], + [21, 36, 47, 54, 77, 82, 86, 90], + [21, 37, 42, 63, 76, 82, 85, 95], + [21, 37, 48, 55, 76, 82, 86, 90], + [22, 31, 36, 44, 46, 53, 56, 77], + [22, 31, 37, 45, 46, 53, 57, 76], + [22, 31, 38, 44, 48, 55, 56, 75], + [22, 31, 38, 45, 47, 54, 57, 75], + [22, 32, 34, 43, 47, 52, 58, 77], + [22, 32, 35, 45, 47, 52, 60, 75], + [22, 32, 37, 43, 51, 55, 58, 74], + [22, 32, 37, 45, 49, 53, 60, 74], + [22, 33, 34, 43, 48, 52, 59, 76], + [22, 33, 36, 43, 51, 54, 59, 74], + [22, 33, 36, 44, 50, 53, 60, 74], + [22, 34, 38, 47, 50, 57, 58, 73], + [22, 34, 38, 48, 49, 56, 59, 73], + [22, 35, 36, 46, 51, 56, 59, 73], + [23, 29, 35, 40, 50, 55, 61, 76], + [23, 29, 35, 42, 46, 52, 65, 76], + [23, 29, 38, 41, 50, 55, 64, 74], + [23, 29, 38, 42, 49, 54, 65, 74], + [23, 30, 34, 40, 49, 53, 62, 77], + [23, 30, 35, 40, 51, 55, 62, 75], + [23, 30, 35, 42, 47, 52, 66, 75], + [23, 30, 37, 42, 49, 53, 66, 74], + [23, 34, 38, 47, 50, 63, 64, 72], + [23, 34, 38, 48, 49, 62, 65, 72], + [23, 35, 36, 46, 51, 62, 65, 72], + [23, 35, 36, 47, 50, 61, 66, 72], + [24, 28, 38, 41, 45, 57, 62, 75], + [24, 28, 38, 42, 44, 56, 63, 75], + [24, 29, 32, 39, 49, 56, 61, 77], + [24, 29, 32, 41, 43, 52, 67, 77], + [24, 29, 33, 39, 50, 57, 61, 76], + [24, 29, 33, 42, 43, 52, 68, 76], + [24, 29, 38, 41, 50, 57, 67, 73], + [24, 29, 38, 42, 49, 56, 68, 73], + [24, 30, 33, 39, 51, 57, 62, 75], + [24, 30, 33, 42, 44, 52, 69, 75], + [24, 32, 37, 43, 51, 63, 67, 72], + [24, 32, 37, 45, 49, 61, 69, 72], + [24, 33, 36, 43, 51, 62, 68, 72], + [24, 33, 36, 44, 50, 61, 69, 72], + [25, 28, 35, 40, 45, 59, 61, 76], + [25, 28, 38, 41, 45, 59, 64, 74], + [25, 28, 38, 42, 44, 58, 65, 74], + [25, 30, 31, 40, 44, 53, 67, 77], + [25, 30, 33, 39, 51, 59, 64, 74], + [25, 30, 35, 40, 51, 59, 67, 73], + [25, 31, 38, 44, 48, 65, 67, 72], + [25, 31, 38, 45, 47, 64, 68, 72], + [26, 28, 34, 40, 43, 58, 62, 77], + [26, 28, 35, 40, 45, 60, 62, 75], + [26, 28, 37, 42, 43, 58, 66, 74], + [26, 29, 31, 39, 46, 56, 64, 77], + [26, 29, 31, 40, 43, 54, 67, 77], + [26, 29, 33, 39, 50, 60, 64, 74], + [26, 29, 35, 40, 50, 60, 67, 73], + [26, 31, 37, 43, 48, 66, 67, 72], + [26, 31, 37, 45, 46, 64, 69, 72], + [27, 28, 34, 40, 43, 59, 63, 76], + [27, 28, 36, 41, 43, 59, 66, 74], + [27, 29, 31, 39, 46, 57, 65, 76], + [27, 29, 31, 40, 43, 55, 68, 76], + [27, 29, 32, 39, 49, 60, 65, 74], + [27, 30, 31, 39, 47, 57, 66, 75], + [27, 30, 31, 40, 44, 55, 69, 75], + [27, 30, 34, 40, 49, 59, 69, 73], + [27, 31, 36, 43, 47, 66, 68, 72], + [27, 31, 36, 44, 46, 65, 69, 72], + [28, 34, 38, 56, 59, 63, 64, 71], + [28, 34, 38, 57, 58, 62, 65, 71], + [28, 35, 36, 56, 59, 61, 66, 71], + [29, 31, 38, 54, 57, 65, 67, 71], + [29, 31, 38, 55, 56, 64, 68, 71], + [29, 32, 35, 52, 60, 65, 67, 71], + [30, 31, 37, 53, 57, 66, 67, 71], + [30, 33, 34, 52, 59, 64, 69, 71], + [39, 46, 51, 56, 59, 63, 64, 70], + [39, 46, 51, 57, 58, 62, 65, 70], + [39, 47, 50, 57, 58, 61, 66, 70], + [39, 48, 49, 56, 59, 61, 66, 70], + [40, 43, 51, 54, 59, 63, 67, 70], + [40, 43, 51, 55, 58, 62, 68, 70], + [40, 44, 50, 53, 60, 63, 67, 70], + [40, 44, 50, 55, 58, 61, 69, 70], + [40, 45, 49, 53, 60, 62, 68, 70], + [40, 45, 49, 54, 59, 61, 69, 70], + [41, 43, 48, 52, 59, 66, 67, 70], + [41, 45, 46, 52, 59, 64, 69, 70], + [42, 43, 47, 52, 58, 66, 68, 70], + [42, 44, 46, 52, 58, 65, 69, 70]] + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs.lean new file mode 100644 index 0000000000..a411c0a766 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs.lean @@ -0,0 +1,117 @@ +import Mathlib +import CarrierCode.E8Data +import CarrierCode.E8Cert + +/-! +# Concrete data layer for the E8 proof + +Roots of the ports mod 3 (D8 coordinates), frames, and step-3 certificates are stored as lists of naturals so that +the kernel checks them quickly (`decide +kernel`, no `native_decide`). This file defines the list functions and +their `ZMod 3` / `Fin` counterparts, and proves the bridge lemmas. +-/ + +namespace CarrierCode.E8 + +open Matrix + +abbrev ι := Fin 104 + +def rL (i : ℕ) : List ℕ := rootData.getD i [] +def rv (i : ℕ) (k : ℕ) : ℕ := (rL i).getD k 0 +def dotW (i : ℕ) (w : List ℕ) : ℕ := + rv i 0 * w.getD 0 0 + rv i 1 * w.getD 1 0 + rv i 2 * w.getD 2 0 + rv i 3 * w.getD 3 0 + + rv i 4 * w.getD 4 0 + rv i 5 * w.getD 5 0 + rv i 6 * w.getD 6 0 + rv i 7 * w.getD 7 0 +def dotN (i j : ℕ) : ℕ := dotW i (rL j) +def frL (f : ℕ) : List ℕ := frameData.getD f [] +def frN (f k : ℕ) : ℕ := (frL f).getD k 0 + +/-- a list of naturals as a vector of `F₃⁸` -/ +def vec (w : List ℕ) : Fin 8 → ZMod 3 := fun k => ((w.getD k 0 : ℕ) : ZMod 3) +/-- the root of port `i` mod 3 -/ +def r (i : ℕ) : Fin 8 → ZMod 3 := vec (rL i) + +theorem dotW_cast (i : ℕ) (w : List ℕ) : ((dotW i w : ℕ) : ZMod 3) = r i ⬝ᵥ vec w := by + simp [dotW, r, vec, rv, dotProduct, Fin.sum_univ_eight] + +theorem dotN_cast (i j : ℕ) : ((dotN i j : ℕ) : ZMod 3) = r i ⬝ᵥ r j := dotW_cast i (rL j) + +theorem cast_eq_zero_iff (n : ℕ) : ((n : ℕ) : ZMod 3) = 0 ↔ n % 3 = 0 := by + rw [ZMod.natCast_eq_zero_iff]; exact Nat.dvd_iff_mod_eq_zero + +theorem cast_mod (n : ℕ) : ((n % 3 : ℕ) : ZMod 3) = (n : ZMod 3) := ZMod.natCast_mod n 3 + +/-- ports as elements of `ι` -/ +def toι (a : ℕ) : ι := ⟨a % 104, Nat.mod_lt _ (by norm_num)⟩ + +theorem toι_val {a : ℕ} (h : a < 104) : (toι a).val = a := Nat.mod_eq_of_lt h + +/-- frames as maps `Fin 8 → ι` -/ +def fr (f : ℕ) (k : Fin 8) : ι := toι (frN f k) + +/-- The Gram form mod 3. -/ +def Gm (i j : ι) : ZMod 3 := r i ⬝ᵥ r j + +theorem Gm_comm (i j : ι) : Gm i j = Gm j i := dotProduct_comm _ _ + +/-- Sum over a list of length 8 as a sum over `Fin 8`. -/ +theorem sum_fin8 (ℓ : List ℕ) (h : ℓ.length = 8) (g : ℕ → ZMod 3) : + ∑ k : Fin 8, g (ℓ.getD k 0) = (ℓ.map g).sum := by + match ℓ, h with + | [a0, a1, a2, a3, a4, a5, a6, a7], _ => simp [Fin.sum_univ_eight]; ring + +/-- Counting form of a list sum. -/ +theorem sum_count (ℓ : List ℕ) (hl : ∀ a ∈ ℓ, a < 104) (h : ι → ZMod 3) : + ∑ i : ι, ((ℓ.count i.val : ℕ) : ZMod 3) * h i = (ℓ.map fun a => h (toι a)).sum := by + induction ℓ with + | nil => simp + | cons a ℓ ih => + have ha : a < 104 := hl a (by simp) + have ih' := ih (fun b hb => hl b (by simp [hb])) + simp only [List.count_cons, List.map_cons, List.sum_cons] + rw [← ih'] + have : ∑ i : ι, (((if (a == i.val) = true then 1 else 0 : ℕ)) : ZMod 3) * h i = h (toι a) := by + rw [Finset.sum_eq_single (toι a)] + · simp [toι_val ha] + · intro b _ hb + have : a ≠ b.val := fun e => hb (Fin.ext (by rw [toι_val ha]; exact e.symm)) + simp [this] + · simp + rw [← this, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun i _ => ?_ + push_cast; ring + +/-! ## Checks (decided by the kernel in `E8Check*.lean`) -/ + +def framesOK : Prop := ∀ f : Fin 759, (frL f).length = 8 ∧ ∀ a b : Fin 8, frN f a < 104 ∧ + (a ≠ b → dotN (frN f a) (frN f b) % 3 = 0 ∧ frN f a ≠ frN f b) + +instance : Decidable framesOK := by unfold framesOK; infer_instance + +def seedL (t : ℕ) : List ℕ := seedData.getD t [] +def seedN (t j : ℕ) : ℕ := (seedL t).getD j 0 +def wL (t j : ℕ) : List ℕ := (wData.getD t []).getD j [] +def combL (t x : ℕ) : List (ℕ × ℕ) := (combData.getD t []).getD x [] +def accL (L : List (ℕ × ℕ)) (i : ℕ) : ℕ := (L.map fun p => p.2 * (frL p.1).count i).sum +def eN (t x j : ℕ) : ℕ := dotN t x * dotW x (wL t j) +def tgt (t x i : ℕ) : ℕ := (if i = x then 1 else 0) + + ((List.range 7).map fun j => if i = seedN t j then 2 * eN t x j else 0).sum + +def seedOK (t : ℕ) : Prop := (seedL t).length = 7 ∧ ∀ i j : Fin 7, seedN t i < 104 ∧ seedN t i ≠ t ∧ + (dotN t (seedN t i) * dotW (seedN t i) (wL t j)) % 3 = (if i = j then 1 else 0) ∧ dotW t (wL t j) % 3 = 0 + +def check3 (t x : ℕ) : Prop := + x = t ∨ dotN t x % 3 = 0 ∨ x ∈ seedL t ∨ + ((∀ p ∈ combL t x, p.1 < 759) ∧ + (∀ i : Fin 104, i.val = t ∨ dotN t i % 3 = 0 ∨ accL (combL t x) i % 3 = tgt t x i % 3) ∧ + (((combL t x).map Prod.snd).sum + 2 * accL (combL t x) t) % 3 = + (1 + ((List.range 7).map fun j => 2 * eN t x j).sum) % 3) + +instance (t : ℕ) : Decidable (seedOK t) := by unfold seedOK; infer_instance +instance (t x : ℕ) : Decidable (check3 t x) := by unfold check3; infer_instance + +/-- All step-3 checks for the ports `t` with `t / 13 = k`. -/ +def step3OK (k : ℕ) : Prop := ∀ t : Fin 104, t.val / 13 = k → seedOK t ∧ ∀ x : Fin 104, check3 t x + +instance (k : ℕ) : Decidable (step3OK k) := by unfold step3OK; infer_instance + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step3.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step3.lean new file mode 100644 index 0000000000..21cc80e9e4 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step3.lean @@ -0,0 +1,214 @@ +import CarrierCode.E8 +import CarrierCode.E8Defs + +/-! +# Steps 1–3 for the concrete ports + +For a matrix `M = A * B` (inner dimension 8) with unit diagonal and zeros on orthogonal pairs, every frame gives +`∑_{x ∈ F} N t x = 1` with `N t x = M t x * M x t`; with the checked certificates this yields +`N t x = 1 + Gm t x * (r x ⬝ᵥ v t)` for an explicit `v t ⟂ r t` (step 3 of E8-PROOF.md). +-/ + +namespace CarrierCode.E8 + +open Matrix + +variable (M : Matrix ι ι (ZMod 3)) (A : Matrix ι (Fin 8) (ZMod 3)) (B : Matrix (Fin 8) ι (ZMod 3)) + +/-- The hypotheses on a decoding matrix. -/ +structure Hyp : Prop where + fac : M = A * B + diag : ∀ i, M i i = 1 + conf : ∀ i j, i ≠ j → Gm i j = 0 → M i j = 0 + +/-- `N t x = M t x * M x t`. -/ +def Nm (t x : ι) : ZMod 3 := M t x * M x t + +variable {M A B} + +theorem frame_mat (h : Hyp M A B) (hF : framesOK) (f : Fin 759) : M.submatrix (fr f) (fr f) = 1 := by + ext k l + obtain ⟨_, hf⟩ := hF f + simp only [submatrix_apply, one_apply] + by_cases hkl : k = l + · subst hkl; simp [h.diag] + · obtain ⟨hk, hd⟩ := hf k l + obtain ⟨hdot, hne⟩ := hd hkl + have hl := (hf l k).1 + rw [if_neg hkl] + apply h.conf + · intro e; apply hne + have := congrArg Fin.val e + simpa [fr, toι_val hk, toι_val hl] using this + · show r (fr f k).val ⬝ᵥ r (fr f l).val = 0 + rw [← dotN_cast] + simp only [fr, toι_val hk, toι_val hl] + exact (cast_eq_zero_iff _).mpr hdot + +theorem frame_sum_N (h : Hyp M A B) (hF : framesOK) (f : Fin 759) (t : ι) : + ∑ k : Fin 8, Nm M t (fr f k) = 1 := by + have hm := frame_mat h hF f + rw [h.fac] at hm + have := CarrierCode.E8.frame_sum A B (fr f) hm t + rw [← h.fac] at this + rw [← h.diag t, ← this]; rfl + +theorem frame_sum_count (h : Hyp M A B) (hF : framesOK) (f : Fin 759) (t : ι) : + ∑ i : ι, (((frL f).count i.val : ℕ) : ZMod 3) * Nm M t i = 1 := by + obtain ⟨hlen, hf⟩ := hF f + have hl : ∀ a ∈ frL f, a < 104 := by + intro a ha + obtain ⟨k, hk, rfl⟩ := List.getElem_of_mem ha + have := (hf ⟨k, hlen ▸ hk⟩ ⟨k, hlen ▸ hk⟩).1 + simpa [frN, List.getD_eq_getElem?_getD, List.getElem?_eq_getElem hk] using this + rw [sum_count _ hl, ← sum_fin8 _ hlen] + exact frame_sum_N h hF f t + +theorem comb_sum (h : Hyp M A B) (hF : framesOK) (t : ι) (L : List (ℕ × ℕ)) (hL : ∀ p ∈ L, p.1 < 759) : + ∑ i : ι, ((accL L i.val : ℕ) : ZMod 3) * Nm M t i = (((L.map Prod.snd).sum : ℕ) : ZMod 3) := by + induction L with + | nil => simp [accL] + | cons p L ih => + have ih' := ih (fun q hq => hL q (by simp [hq])) + have hp := frame_sum_count h hF ⟨p.1, hL p (by simp)⟩ t + simp only [accL, List.map_cons, List.sum_cons] at ih' ⊢ + push_cast at ih' ⊢ + have e : ∀ i : ι, ((p.2 : ZMod 3) * ((frL p.1).count i.val : ℕ) + + (L.map fun q => (((q.2 * (frL q.1).count i.val : ℕ)) : ZMod 3)).sum) * Nm M t i = + (p.2 : ZMod 3) * ((((frL p.1).count i.val : ℕ) : ZMod 3) * Nm M t i) + + (L.map fun q => (((q.2 * (frL q.1).count i.val : ℕ)) : ZMod 3)).sum * Nm M t i := fun i => by ring + simp only [List.map_map, Function.comp_def] at ih' ⊢ + rw [Finset.sum_congr rfl fun i _ => e i, Finset.sum_add_distrib, ← Finset.mul_sum, hp, mul_one] + push_cast at ih' ⊢ + rw [ih'] + +/-- The vector `v_t` of step 3. -/ +def vv (M : Matrix ι ι (ZMod 3)) (t : ι) : Fin 8 → ZMod 3 := + ∑ j : Fin 7, (Nm M t (toι (seedN t j)) - 1) • vec (wL t j) + +theorem sum_range7 (g : ℕ → ℕ) : (((List.range 7).map g).sum : ℕ) = ∑ j : Fin 7, g j := by + simp [List.sum_range_succ, Fin.sum_univ_seven] + +theorem conf_N (h : Hyp M A B) (t i : ι) (hit : i ≠ t) (hG : dotN t i % 3 = 0) : Nm M t i = 0 := by + have : M t i = 0 := h.conf t i (Ne.symm hit) (by rw [Gm, ← dotN_cast]; exact (cast_eq_zero_iff _).mpr hG) + simp [Nm, this] + +theorem rx_dot_vv (t x : ι) : + Gm t x * (r x ⬝ᵥ vv M t) = ∑ j : Fin 7, (Nm M t (toι (seedN t j)) - 1) * ((eN t x j : ℕ) : ZMod 3) := by + simp only [vv, dotProduct_sum, dotProduct_smul, smul_eq_mul, Finset.mul_sum, eN] + refine Finset.sum_congr rfl fun j _ => ?_ + push_cast; rw [dotN_cast, dotW_cast]; simp only [Gm]; ring + +theorem seed_mem {t x : ℕ} (hlen : (seedL t).length = 7) (hx : x ∈ seedL t) : ∃ i : Fin 7, seedN t i = x := by + obtain ⟨k, hk, rfl⟩ := List.getElem_of_mem hx + exact ⟨⟨k, hlen ▸ hk⟩, by simp [seedN, List.getD_eq_getElem?_getD, List.getElem?_eq_getElem hk]⟩ + +/-- Step 3 at a seed. -/ +theorem step3_seed {t x : ι} (hS : seedOK t.val) (i : Fin 7) (hx : seedN t i = x.val) : + Nm M t x = 1 + Gm t x * (r x ⬝ᵥ vv M t) := by + rw [rx_dot_vv] + have hδ : ∀ j : Fin 7, ((eN t x j : ℕ) : ZMod 3) = if i = j then 1 else 0 := by + intro j + have := (hS.2 i j).2.2.1 + rw [hx] at this + rw [← cast_mod, eN, this]; split_ifs <;> simp + simp_rw [hδ, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq, Finset.mem_univ, if_true] + have : toι (seedN t i) = x := Fin.ext (by rw [hx, toι_val x.isLt]) + rw [this]; ring + +/-- Step 3 away from the seeds, from the certificate. -/ +theorem step3_cert {t x : ι} (h : Hyp M A B) (hF : framesOK) (hS : seedOK t.val) (hxt : x ≠ t) + (hpos : ∀ p ∈ combL t x, p.1 < 759) + (hacc : ∀ i : Fin 104, i.val = t.val ∨ dotN t i % 3 = 0 ∨ accL (combL t x) i % 3 = tgt t x i % 3) + (hsc : (((combL t x).map Prod.snd).sum + 2 * accL (combL t x) t) % 3 = + (1 + ((List.range 7).map fun j => 2 * eN t x j).sum) % 3) : + Nm M t x = 1 + Gm t x * (r x ⬝ᵥ vv M t) := by + have hc := comb_sum h hF t (combL t x) hpos + -- tgt vanishes at t + have htgt_t : tgt t x t = 0 := by + have hxt' : t.val ≠ x.val := fun e => hxt (Fin.ext e.symm) + simp only [tgt, if_neg hxt', zero_add] + apply List.sum_eq_zero + intro a ha + obtain ⟨j, hj, rfl⟩ := List.mem_map.mp ha + have := (hS.2 ⟨j, List.mem_range.mp hj⟩ ⟨0, by norm_num⟩).2.1 + simp [Ne.symm this] + -- split the sum + have hsplit : ∀ i : ι, ((accL (combL t x) i.val : ℕ) : ZMod 3) * Nm M t i = + (if i = t then ((accL (combL t x) t.val : ℕ) : ZMod 3) else 0) + ((tgt t x i.val : ℕ) : ZMod 3) * Nm M t i := by + intro i + by_cases hit : i = t + · subst hit; simp [htgt_t, Nm, h.diag] + · rw [if_neg hit, zero_add] + rcases hacc i with e | e | e + · exact absurd (Fin.ext e) hit + · rw [conf_N h t i hit e]; simp + · rw [← cast_mod (accL _ _), e, cast_mod] + rw [Finset.sum_congr rfl fun i _ => hsplit i, Finset.sum_add_distrib, Finset.sum_ite_eq'] at hc + simp only [Finset.mem_univ, if_true] at hc + -- evaluate the tgt sum + have hterm : ∀ i : ι, ((tgt t x i.val : ℕ) : ZMod 3) * Nm M t i = + (if i = x then Nm M t i else 0) + + ∑ j : Fin 7, if i = toι (seedN t j) then 2 * ((eN t x j : ℕ) : ZMod 3) * Nm M t i else 0 := by + intro i + simp only [tgt] + rw [sum_range7] + push_cast [Nat.cast_ite] + rw [add_mul, Finset.sum_mul] + have hx : (i.val = x.val) ↔ i = x := ⟨Fin.ext, fun e => e ▸ rfl⟩ + have h1 : ((if i.val = x.val then (1 : ZMod 3) else 0)) * Nm M t i = if i = x then Nm M t i else 0 := by + by_cases e : i = x + · rw [if_pos (hx.mpr e), if_pos e, one_mul] + · rw [if_neg (fun h => e (hx.mp h)), if_neg e, zero_mul] + have h2 : ∀ j : Fin 7, ((if i.val = seedN t j then 2 * ((eN t x j : ℕ) : ZMod 3) else 0)) * Nm M t i = + if i = toι (seedN t j) then 2 * ((eN t x j : ℕ) : ZMod 3) * Nm M t i else 0 := by + intro j + have hj := (hS.2 j j).1 + have hs : (i.val = seedN t ↑j) ↔ i = toι (seedN t j) := + ⟨fun e => Fin.ext (by rw [toι_val hj]; exact e), fun e => by rw [e, toι_val hj]⟩ + by_cases e : i = toι (seedN t j) + · rw [if_pos (hs.mpr e), if_pos e] + · rw [if_neg (fun h => e (hs.mp h)), if_neg e, zero_mul] + exact congrArg₂ (· + ·) h1 (Finset.sum_congr rfl fun j _ => h2 j) + have htsum : ∑ i : ι, ((tgt t x i.val : ℕ) : ZMod 3) * Nm M t i = + Nm M t x + ∑ j : Fin 7, 2 * ((eN t x j : ℕ) : ZMod 3) * Nm M t (toι (seedN t j)) := by + rw [Finset.sum_congr rfl fun i _ => hterm i, Finset.sum_add_distrib, Finset.sum_ite_eq', + Finset.sum_comm] + simp only [Finset.sum_ite_eq', Finset.mem_univ, if_true] + rw [htsum] at hc + rw [sum_range7] at hsc + have hsc' := congrArg (fun n : ℕ => (n : ZMod 3)) hsc + simp only [cast_mod] at hsc' + push_cast at hsc' hc + rw [rx_dot_vv] + have h3 : (3 : ZMod 3) = 0 := by decide + -- hc : acc_t + (N x + Σ 2 e_j N s_j) = Σ c ; hsc' : Σ c + 2 acc_t = 1 + Σ 2 e_j + have key : Nm M t x = 1 + ∑ j : Fin 7, 2 * ((eN t x j : ℕ) : ZMod 3) - + ∑ j : Fin 7, 2 * ((eN t x j : ℕ) : ZMod 3) * Nm M t (toι (seedN t j)) := by + linear_combination hc + hsc' - (accL (combL t x) t.val : ZMod 3) * h3 + rw [key, add_sub_assoc, ← Finset.sum_sub_distrib] + refine congrArg (1 + ·) (Finset.sum_congr rfl fun j _ => ?_) + linear_combination (((eN t x j : ℕ) : ZMod 3) * (1 - Nm M t (toι (seedN t j)))) * h3 + +theorem rt_dot_vv {t : ι} (hS : seedOK t.val) : r t ⬝ᵥ vv M t = 0 := by + simp only [vv, dotProduct_sum, dotProduct_smul, smul_eq_mul] + refine Finset.sum_eq_zero fun j _ => ?_ + rw [← dotW_cast, ← cast_mod, (hS.2 j j).2.2.2]; simp + +/-- Step 3 (equation (3) of E8-PROOF.md) for every non-orthogonal pair, given the checks. -/ +theorem step3 (h : Hyp M A B) (hF : framesOK) (hC : ∀ t : ι, seedOK t.val ∧ ∀ x : ι, check3 t.val x.val) + (t x : ι) (hnz : dotN t x % 3 ≠ 0) : + Nm M t x = 1 + Gm t x * (r x ⬝ᵥ vv M t) := by + obtain ⟨hS, hc⟩ := hC t + rcases hc x with e | e | e | ⟨hpos, hacc, hsc⟩ + · have : x = t := Fin.ext e + subst this + rw [rt_dot_vv hS, mul_zero, add_zero]; simp [Nm, h.diag] + · exact absurd e hnz + · obtain ⟨i, hi⟩ := seed_mem hS.1 e + exact step3_seed hS i hi + · by_cases hxt : x = t + · subst hxt; rw [rt_dot_vv hS, mul_zero, add_zero]; simp [Nm, h.diag] + · exact step3_cert h hF hS hxt hpos hacc hsc + +end CarrierCode.E8 From bdf217939170c874bd83ba9436f69f2f8c6e053e Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 23:34:59 +0000 Subject: [PATCH 08/11] E8 Lean: step-3 kernel checks in 8 chunks and combined step3_all Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYm9RueiYCeCpQh8oBuC --- .../lean/CarrierCode/E8Check3_0.lean | 9 +++++ .../lean/CarrierCode/E8Check3_1.lean | 9 +++++ .../lean/CarrierCode/E8Check3_2.lean | 9 +++++ .../lean/CarrierCode/E8Check3_3.lean | 9 +++++ .../lean/CarrierCode/E8Check3_4.lean | 9 +++++ .../lean/CarrierCode/E8Check3_5.lean | 9 +++++ .../lean/CarrierCode/E8Check3_6.lean | 9 +++++ .../lean/CarrierCode/E8Check3_7.lean | 9 +++++ .../lean/CarrierCode/E8Checks.lean | 38 +++++++++++++++++++ 9 files changed, 110 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_0.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_1.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_2.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_3.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_4.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_5.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_6.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_7.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Checks.lean diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_0.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_0.lean new file mode 100644 index 0000000000..5d798eb0bf --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_0.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 0 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_0 : step3OK 0 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_1.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_1.lean new file mode 100644 index 0000000000..e9fe3e324e --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_1.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 1 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_1 : step3OK 1 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_2.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_2.lean new file mode 100644 index 0000000000..fe5c7d81db --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_2.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 2 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_2 : step3OK 2 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_3.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_3.lean new file mode 100644 index 0000000000..e203211923 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_3.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 3 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_3 : step3OK 3 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_4.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_4.lean new file mode 100644 index 0000000000..0aa8dc46f0 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_4.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 4 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_4 : step3OK 4 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_5.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_5.lean new file mode 100644 index 0000000000..6fadb1ffb0 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_5.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 5 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_5 : step3OK 5 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_6.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_6.lean new file mode 100644 index 0000000000..8e0cc36494 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_6.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 6 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_6 : step3OK 6 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_7.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_7.lean new file mode 100644 index 0000000000..710454fff0 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check3_7.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs + +/-! Kernel check of the step-3 certificates for the ports t with t / 13 = 7 (generated). -/ + +namespace CarrierCode.E8 + +theorem step3OK_7 : step3OK 7 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Checks.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Checks.lean new file mode 100644 index 0000000000..4bc823c92a --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Checks.lean @@ -0,0 +1,38 @@ +import CarrierCode.E8CheckFrames +import CarrierCode.E8Check3_0 +import CarrierCode.E8Check3_1 +import CarrierCode.E8Check3_2 +import CarrierCode.E8Check3_3 +import CarrierCode.E8Check3_4 +import CarrierCode.E8Check3_5 +import CarrierCode.E8Check3_6 +import CarrierCode.E8Check3_7 +import CarrierCode.E8Step3 + +/-! All kernel checks of steps 1–3 combined, and step 3 for every decoding matrix. -/ + +namespace CarrierCode.E8 + +open Matrix + +theorem step3_checks : ∀ t : ι, seedOK t.val ∧ ∀ x : ι, check3 t.val x.val := by + intro t + have ht := t.isLt + rcases (show t.val / 13 = 0 ∨ t.val / 13 = 1 ∨ t.val / 13 = 2 ∨ t.val / 13 = 3 ∨ t.val / 13 = 4 ∨ + t.val / 13 = 5 ∨ t.val / 13 = 6 ∨ t.val / 13 = 7 by omega) with h | h | h | h | h | h | h | h + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_0 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_1 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_2 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_3 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_4 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_5 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_6 t h) + · exact (fun ⟨a, b⟩ => ⟨a, fun x => b x⟩) (step3OK_7 t h) + +/-- Step 3 for every matrix satisfying the decoding hypotheses: `N t x = 1 + (r_t·r_x)(r_x·v_t)`. -/ +theorem step3_all {M : Matrix ι ι (ZMod 3)} {A : Matrix ι (Fin 8) (ZMod 3)} {B : Matrix (Fin 8) ι (ZMod 3)} + (h : Hyp M A B) (t x : ι) (hnz : dotN t x % 3 ≠ 0) : + Nm M t x = 1 + Gm t x * (r x ⬝ᵥ vv M t) := + step3 h framesOK_true step3_checks t x hnz + +end CarrierCode.E8 From 6827da050bb5ec2056fc65b2030ac32f82b3462d Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 28 Oct 2026 23:41:48 +0000 Subject: [PATCH 09/11] E8 Lean: step 4 (general A2 trick, v_t = 0, M symmetric and +-1 off the conflict pattern) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYm9RueiYCeCpQh8oBuC --- .../lean/CarrierCode/E8Check4.lean | 9 + .../lean/CarrierCode/E8Data4.lean | 218 ++++++++++++++++++ .../lean/CarrierCode/E8Defs4.lean | 38 +++ .../lean/CarrierCode/E8Step4.lean | 134 +++++++++++ 4 files changed, 399 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check4.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data4.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs4.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step4.lean diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check4.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check4.lean new file mode 100644 index 0000000000..651ff11a83 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check4.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs4 + +/-! Kernel check of the step-4 data (A2 triangles and inverse matrices). -/ + +namespace CarrierCode.E8 + +theorem step4OK_true : step4OK := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data4.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data4.lean new file mode 100644 index 0000000000..62881ef007 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data4.lean @@ -0,0 +1,218 @@ +/-! Generated by Matarener/Internal local-topology-2026-10-27/e8hand/gen_lean_step4.py. Step 4 data: for each +port t, seven A2 triangles (x, y, a, b) with r_y = a r_t + b r_x mod 3, and the inverse C of [r_t; r_x...]. -/ + +namespace CarrierCode.E8 + +def a2Data : List (List Nat) := [ + [1, 90, 1, 2, 2, 91, 1, 2, 3, 93, 1, 2, 4, 94, 1, 2, 5, 78, 1, 2, 11, 81, 1, 2, 12, 82, 1, 2], + [0, 90, 2, 1, 2, 95, 1, 2, 3, 97, 1, 2, 4, 98, 1, 2, 6, 78, 1, 2, 14, 81, 1, 2, 15, 82, 1, 2], + [0, 91, 2, 1, 1, 95, 2, 1, 3, 100, 1, 2, 4, 101, 1, 2, 7, 78, 1, 2, 11, 79, 1, 2, 24, 71, 1, 2], + [0, 93, 2, 1, 1, 97, 2, 1, 2, 100, 2, 1, 9, 78, 1, 2, 16, 80, 1, 2, 19, 82, 1, 2, 21, 84, 1, 2], + [0, 94, 2, 1, 1, 98, 2, 1, 2, 101, 2, 1, 10, 78, 1, 2, 13, 79, 1, 2, 20, 82, 1, 2, 21, 83, 1, 2], + [0, 78, 2, 1, 6, 90, 1, 2, 7, 91, 1, 2, 8, 92, 1, 2, 9, 93, 1, 2, 10, 94, 1, 2, 11, 86, 1, 2], + [1, 78, 2, 1, 5, 90, 2, 1, 7, 95, 1, 2, 8, 96, 1, 2, 9, 97, 1, 2, 10, 98, 1, 2, 14, 86, 1, 2], + [2, 78, 2, 1, 5, 91, 2, 1, 6, 95, 2, 1, 8, 99, 1, 2, 9, 100, 1, 2, 10, 101, 1, 2, 11, 85, 1, 2], + [5, 92, 2, 1, 6, 96, 2, 1, 7, 99, 2, 1, 9, 102, 1, 2, 10, 103, 1, 2, 12, 85, 1, 2, 25, 70, 1, 2], + [3, 78, 2, 1, 5, 93, 2, 1, 6, 97, 2, 1, 7, 100, 2, 1, 8, 102, 2, 1, 18, 86, 1, 2, 21, 89, 1, 2], + [4, 78, 2, 1, 5, 94, 2, 1, 6, 98, 2, 1, 7, 101, 2, 1, 8, 103, 2, 1, 13, 85, 1, 2, 21, 88, 1, 2], + [0, 81, 2, 1, 2, 79, 2, 1, 5, 86, 2, 1, 12, 99, 1, 2, 13, 101, 1, 2, 14, 90, 1, 2, 18, 93, 1, 2], + [0, 82, 2, 1, 5, 87, 2, 1, 8, 85, 2, 1, 11, 99, 2, 1, 13, 103, 1, 2, 15, 90, 1, 2, 19, 93, 1, 2], + [0, 84, 2, 1, 4, 79, 2, 1, 5, 89, 2, 1, 11, 101, 2, 1, 12, 103, 2, 1, 17, 90, 1, 2, 21, 93, 1, 2], + [1, 81, 2, 1, 2, 80, 2, 1, 6, 86, 2, 1, 11, 90, 2, 1, 15, 99, 1, 2, 16, 100, 1, 2, 17, 101, 1, 2], + [1, 82, 2, 1, 6, 87, 2, 1, 12, 90, 2, 1, 14, 99, 2, 1, 16, 102, 1, 2, 17, 103, 1, 2, 19, 97, 1, 2], + [1, 83, 2, 1, 3, 80, 2, 1, 6, 88, 2, 1, 14, 100, 2, 1, 15, 102, 2, 1, 21, 98, 1, 2, 22, 68, 2, 2], + [1, 84, 2, 1, 4, 80, 2, 1, 6, 89, 2, 1, 13, 90, 2, 1, 14, 101, 2, 1, 15, 103, 2, 1, 21, 97, 1, 2], + [2, 83, 2, 1, 3, 81, 2, 1, 7, 88, 2, 1, 11, 93, 2, 1, 14, 97, 2, 1, 19, 99, 1, 2, 21, 101, 1, 2], + [3, 82, 2, 1, 8, 88, 2, 1, 9, 87, 2, 1, 12, 93, 2, 1, 15, 97, 2, 1, 18, 99, 2, 1, 21, 103, 1, 2], + [4, 82, 2, 1, 8, 89, 2, 1, 10, 87, 2, 1, 12, 94, 2, 1, 15, 98, 2, 1, 21, 102, 1, 2, 22, 62, 2, 2], + [3, 84, 2, 1, 4, 83, 2, 1, 9, 89, 2, 1, 13, 93, 2, 1, 16, 98, 2, 1, 18, 101, 2, 1, 19, 103, 2, 1], + [0, 71, 2, 1, 5, 70, 2, 1, 15, 69, 2, 2, 16, 68, 2, 2, 17, 67, 2, 2, 18, 65, 2, 2, 19, 63, 2, 2], + [1, 71, 2, 1, 6, 70, 2, 1, 12, 69, 2, 2, 13, 67, 2, 2, 18, 59, 2, 2, 19, 57, 2, 2, 20, 56, 2, 2], + [2, 71, 2, 1, 7, 70, 2, 1, 12, 66, 2, 2, 13, 64, 2, 2, 15, 60, 2, 2, 16, 59, 2, 2, 19, 55, 2, 2], + [8, 70, 2, 1, 11, 66, 2, 2, 13, 62, 2, 2, 14, 60, 2, 2, 16, 57, 2, 2, 18, 55, 2, 2, 22, 92, 2, 1], + [3, 71, 2, 1, 9, 70, 2, 1, 11, 65, 2, 2, 12, 63, 2, 2, 13, 61, 2, 2, 14, 59, 2, 2, 20, 52, 2, 2], + [4, 71, 2, 1, 10, 70, 2, 1, 11, 64, 2, 2, 12, 62, 2, 2, 14, 58, 2, 2, 18, 53, 2, 2, 22, 94, 2, 1], + [0, 73, 2, 1, 1, 72, 2, 1, 8, 69, 2, 2, 9, 68, 2, 2, 10, 67, 2, 2, 18, 50, 2, 2, 19, 48, 2, 2], + [0, 75, 2, 1, 6, 69, 2, 2, 7, 66, 2, 2, 9, 63, 2, 2, 10, 62, 2, 2, 12, 70, 2, 1, 14, 51, 2, 2], + [0, 76, 2, 1, 3, 72, 2, 1, 6, 68, 2, 2, 7, 65, 2, 2, 8, 63, 2, 2, 10, 61, 2, 2, 14, 50, 2, 2], + [1, 74, 2, 1, 2, 73, 2, 1, 8, 60, 2, 2, 9, 59, 2, 2, 10, 58, 2, 2, 12, 51, 2, 2, 14, 70, 2, 1], + [1, 76, 2, 1, 3, 73, 2, 1, 5, 68, 2, 2, 7, 59, 2, 2, 8, 57, 2, 2, 11, 50, 2, 2, 13, 46, 2, 2], + [1, 77, 2, 1, 4, 73, 2, 1, 5, 67, 2, 2, 7, 58, 2, 2, 8, 56, 2, 2, 11, 49, 2, 2, 17, 70, 2, 1], + [2, 75, 2, 1, 5, 66, 2, 2, 6, 60, 2, 2, 9, 55, 2, 2, 10, 54, 2, 2, 13, 44, 2, 2, 25, 86, 2, 1], + [2, 77, 2, 1, 4, 74, 2, 1, 5, 64, 2, 2, 6, 58, 2, 2, 8, 54, 2, 2, 9, 53, 2, 2, 12, 44, 2, 2], + [3, 75, 2, 1, 5, 63, 2, 2, 6, 57, 2, 2, 7, 55, 2, 2, 10, 52, 2, 2, 11, 45, 2, 2, 19, 70, 2, 1], + [4, 75, 2, 1, 5, 62, 2, 2, 6, 56, 2, 2, 7, 54, 2, 2, 9, 52, 2, 2, 11, 44, 2, 2, 20, 70, 2, 1], + [3, 77, 2, 1, 4, 76, 2, 1, 5, 61, 2, 2, 7, 53, 2, 2, 8, 52, 2, 2, 11, 43, 2, 2, 15, 40, 2, 2], + [3, 68, 2, 2, 4, 67, 2, 2, 5, 73, 2, 1, 6, 72, 2, 1, 18, 37, 2, 2, 19, 35, 2, 2, 21, 34, 2, 2], + [3, 65, 2, 2, 4, 64, 2, 2, 5, 74, 2, 1, 7, 72, 2, 1, 11, 71, 2, 1, 15, 38, 2, 2, 16, 37, 2, 2], + [1, 68, 2, 2, 2, 65, 2, 2, 4, 61, 2, 2, 5, 76, 2, 1, 9, 72, 2, 1, 14, 37, 2, 2, 15, 35, 2, 2], + [1, 67, 2, 2, 2, 64, 2, 2, 3, 61, 2, 2, 5, 77, 2, 1, 10, 72, 2, 1, 13, 71, 2, 1, 14, 36, 2, 2], + [0, 69, 2, 2, 2, 60, 2, 2, 3, 57, 2, 2, 4, 56, 2, 2, 6, 75, 2, 1, 8, 73, 2, 1, 11, 38, 2, 2], + [0, 68, 2, 2, 2, 59, 2, 2, 6, 76, 2, 1, 9, 73, 2, 1, 11, 37, 2, 2, 12, 35, 2, 2, 13, 34, 2, 2], + [0, 67, 2, 2, 2, 58, 2, 2, 6, 77, 2, 1, 10, 73, 2, 1, 11, 36, 2, 2, 17, 71, 2, 1, 18, 29, 2, 2], + [0, 66, 2, 2, 1, 60, 2, 2, 3, 55, 2, 2, 4, 54, 2, 2, 7, 75, 2, 1, 8, 74, 2, 1, 13, 32, 2, 2], + [0, 65, 2, 2, 1, 59, 2, 2, 4, 53, 2, 2, 7, 76, 2, 1, 9, 74, 2, 1, 12, 33, 2, 2, 17, 29, 2, 2], + [0, 64, 2, 2, 1, 58, 2, 2, 3, 53, 2, 2, 7, 77, 2, 1, 10, 74, 2, 1, 12, 32, 2, 2, 16, 29, 2, 2], + [0, 63, 2, 2, 1, 57, 2, 2, 2, 55, 2, 2, 4, 52, 2, 2, 8, 76, 2, 1, 9, 75, 2, 1, 11, 33, 2, 2], + [0, 62, 2, 2, 1, 56, 2, 2, 2, 54, 2, 2, 3, 52, 2, 2, 8, 77, 2, 1, 10, 75, 2, 1, 11, 32, 2, 2], + [0, 61, 2, 2, 2, 53, 2, 2, 9, 77, 2, 1, 10, 76, 2, 1, 12, 31, 2, 2, 14, 29, 2, 2, 21, 71, 2, 1], + [3, 50, 2, 2, 4, 49, 2, 2, 8, 38, 2, 2, 9, 37, 2, 2, 11, 73, 2, 1, 14, 72, 2, 1, 19, 27, 2, 2], + [2, 51, 2, 2, 3, 48, 2, 2, 4, 47, 2, 2, 7, 38, 2, 2, 12, 73, 2, 1, 15, 72, 2, 1, 18, 27, 2, 2], + [2, 50, 2, 2, 4, 46, 2, 2, 7, 37, 2, 2, 8, 35, 2, 2, 16, 72, 2, 1, 20, 24, 2, 2, 28, 83, 2, 1], + [2, 49, 2, 2, 3, 46, 2, 2, 7, 36, 2, 2, 13, 73, 2, 1, 17, 72, 2, 1, 18, 25, 2, 2, 19, 24, 2, 2], + [1, 50, 2, 2, 4, 43, 2, 2, 6, 37, 2, 2, 8, 33, 2, 2, 11, 76, 2, 1, 15, 27, 2, 2, 18, 72, 2, 1], + [1, 49, 2, 2, 3, 43, 2, 2, 6, 36, 2, 2, 8, 32, 2, 2, 11, 77, 2, 1, 13, 74, 2, 1, 15, 26, 2, 2], + [1, 48, 2, 2, 2, 45, 2, 2, 6, 35, 2, 2, 10, 31, 2, 2, 12, 76, 2, 1, 14, 27, 2, 2, 19, 72, 2, 1], + [1, 47, 2, 2, 2, 44, 2, 2, 7, 32, 2, 2, 9, 31, 2, 2, 12, 77, 2, 1, 13, 75, 2, 1, 14, 26, 2, 2], + [1, 46, 2, 2, 2, 43, 2, 2, 6, 34, 2, 2, 8, 31, 2, 2, 13, 76, 2, 1, 14, 25, 2, 2, 21, 72, 2, 1], + [0, 51, 2, 2, 3, 42, 2, 2, 4, 41, 2, 2, 5, 38, 2, 2, 13, 26, 2, 2, 14, 75, 2, 1, 15, 74, 2, 1], + [0, 50, 2, 2, 5, 37, 2, 2, 10, 29, 2, 2, 12, 27, 2, 2, 13, 25, 2, 2, 14, 76, 2, 1, 16, 74, 2, 1], + [0, 49, 2, 2, 5, 36, 2, 2, 8, 30, 2, 2, 9, 29, 2, 2, 12, 26, 2, 2, 14, 77, 2, 1, 17, 74, 2, 1], + [0, 48, 2, 2, 2, 42, 2, 2, 4, 40, 2, 2, 5, 35, 2, 2, 11, 27, 2, 2, 15, 76, 2, 1, 16, 75, 2, 1], + [0, 47, 2, 2, 2, 41, 2, 2, 3, 40, 2, 2, 7, 30, 2, 2, 11, 26, 2, 2, 15, 77, 2, 1, 17, 75, 2, 1], + [0, 46, 2, 2, 5, 34, 2, 2, 7, 29, 2, 2, 11, 25, 2, 2, 12, 24, 2, 2, 16, 77, 2, 1, 17, 76, 2, 1], + [0, 45, 2, 2, 1, 42, 2, 2, 4, 39, 2, 2, 5, 33, 2, 2, 13, 23, 2, 2, 18, 75, 2, 1, 19, 74, 2, 1], + [0, 44, 2, 2, 1, 41, 2, 2, 3, 39, 2, 2, 5, 32, 2, 2, 16, 22, 2, 2, 20, 74, 2, 1, 34, 84, 2, 1], + [0, 43, 2, 2, 6, 29, 2, 2, 8, 28, 2, 2, 12, 23, 2, 2, 15, 22, 2, 2, 18, 77, 2, 1, 21, 74, 2, 1], + [5, 22, 2, 1, 6, 23, 2, 1, 7, 24, 2, 1, 8, 25, 2, 1, 9, 26, 2, 1, 10, 27, 2, 1, 12, 29, 2, 1], + [0, 22, 2, 1, 1, 23, 2, 1, 2, 24, 2, 1, 3, 26, 2, 1, 4, 27, 2, 1, 11, 40, 2, 1, 15, 43, 2, 1], + [1, 28, 2, 1, 3, 30, 2, 1, 6, 39, 2, 1, 7, 40, 2, 1, 10, 42, 2, 1, 14, 52, 2, 1, 15, 53, 2, 1], + [0, 28, 2, 1, 2, 31, 2, 1, 3, 32, 2, 1, 4, 33, 2, 1, 5, 39, 2, 1, 8, 43, 2, 1, 11, 52, 2, 1], + [1, 31, 2, 1, 4, 35, 2, 1, 5, 40, 2, 1, 8, 46, 2, 1, 9, 47, 2, 1, 10, 48, 2, 1, 13, 57, 2, 1], + [0, 29, 2, 1, 2, 34, 2, 1, 3, 36, 2, 1, 4, 37, 2, 1, 6, 43, 2, 1, 7, 46, 2, 1, 13, 59, 2, 1], + [0, 30, 2, 1, 1, 32, 2, 1, 4, 38, 2, 1, 5, 41, 2, 1, 7, 47, 2, 1, 8, 49, 2, 1, 11, 56, 2, 1], + [1, 33, 2, 1, 2, 35, 2, 1, 3, 38, 2, 1, 5, 42, 2, 1, 6, 45, 2, 1, 8, 50, 2, 1, 11, 57, 2, 1], + [0, 5, 2, 1, 1, 6, 2, 1, 2, 7, 2, 1, 3, 9, 2, 1, 4, 10, 2, 1, 28, 39, 2, 1, 34, 46, 2, 1], + [2, 11, 2, 1, 4, 13, 2, 1, 23, 39, 2, 1, 24, 40, 2, 1, 26, 41, 2, 1, 31, 52, 2, 1, 36, 58, 2, 1], + [2, 14, 2, 1, 3, 16, 2, 1, 4, 17, 2, 1, 22, 39, 2, 1, 25, 43, 2, 1, 26, 44, 2, 1, 29, 53, 2, 1], + [0, 11, 2, 1, 1, 14, 2, 1, 3, 18, 2, 1, 22, 40, 2, 1, 25, 46, 2, 1, 27, 48, 2, 1, 28, 52, 2, 1], + [0, 12, 2, 1, 1, 15, 2, 1, 3, 19, 2, 1, 4, 20, 2, 1, 23, 43, 2, 1, 24, 46, 2, 1, 28, 53, 2, 1], + [1, 16, 2, 1, 2, 18, 2, 1, 4, 21, 2, 1, 22, 41, 2, 1, 23, 44, 2, 1, 25, 49, 2, 1, 28, 54, 2, 1], + [0, 13, 2, 1, 1, 17, 2, 1, 3, 21, 2, 1, 22, 42, 2, 1, 24, 48, 2, 1, 25, 50, 2, 1, 28, 55, 2, 1], + [7, 11, 2, 1, 8, 12, 2, 1, 10, 13, 2, 1, 23, 28, 2, 1, 25, 29, 2, 1, 26, 30, 2, 1, 43, 53, 2, 1], + [5, 11, 2, 1, 6, 14, 2, 1, 9, 18, 2, 1, 23, 31, 2, 1, 25, 34, 2, 1, 27, 35, 2, 1, 39, 52, 2, 1], + [5, 12, 2, 1, 6, 15, 2, 1, 9, 19, 2, 1, 10, 20, 2, 1, 22, 29, 2, 1, 24, 34, 2, 1, 39, 53, 2, 1], + [6, 16, 2, 1, 7, 18, 2, 1, 8, 19, 2, 1, 10, 21, 2, 1, 22, 30, 2, 1, 23, 32, 2, 1, 39, 54, 2, 1], + [5, 13, 2, 1, 6, 17, 2, 1, 8, 20, 2, 1, 9, 21, 2, 1, 23, 33, 2, 1, 24, 35, 2, 1, 39, 55, 2, 1], + [0, 1, 2, 1, 5, 6, 2, 1, 11, 14, 2, 1, 12, 15, 2, 1, 13, 17, 2, 1, 22, 23, 2, 1, 30, 32, 2, 1], + [0, 2, 2, 1, 5, 7, 2, 1, 22, 24, 2, 1, 28, 31, 2, 1, 29, 34, 2, 1, 41, 47, 2, 1, 42, 48, 2, 1], + [5, 8, 2, 1, 13, 20, 2, 1, 22, 25, 2, 1, 30, 36, 2, 1, 39, 43, 2, 1, 40, 46, 2, 1, 41, 49, 2, 1], + [0, 3, 2, 1, 5, 9, 2, 1, 11, 18, 2, 1, 12, 19, 2, 1, 13, 21, 2, 1, 22, 26, 2, 1, 28, 32, 2, 1], + [0, 4, 2, 1, 5, 10, 2, 1, 12, 20, 2, 1, 22, 27, 2, 1, 28, 33, 2, 1, 30, 38, 2, 1, 40, 48, 2, 1], + [1, 2, 2, 1, 6, 7, 2, 1, 16, 18, 2, 1, 23, 24, 2, 1, 33, 35, 2, 1, 39, 40, 2, 1, 43, 46, 2, 1], + [6, 8, 2, 1, 16, 19, 2, 1, 17, 20, 2, 1, 23, 25, 2, 1, 28, 29, 2, 1, 31, 34, 2, 1, 44, 49, 2, 1], + [1, 3, 2, 1, 6, 9, 2, 1, 14, 18, 2, 1, 15, 19, 2, 1, 17, 21, 2, 1, 23, 26, 2, 1, 28, 30, 2, 1], + [1, 4, 2, 1, 6, 10, 2, 1, 15, 20, 2, 1, 16, 21, 2, 1, 23, 27, 2, 1, 31, 35, 2, 1, 39, 42, 2, 1], + [7, 8, 2, 1, 11, 12, 2, 1, 14, 15, 2, 1, 18, 19, 2, 1, 24, 25, 2, 1, 35, 37, 2, 1, 47, 49, 2, 1], + [2, 3, 2, 1, 7, 9, 2, 1, 14, 16, 2, 1, 24, 26, 2, 1, 34, 36, 2, 1, 35, 38, 2, 1, 40, 41, 2, 1], + [2, 4, 2, 1, 7, 10, 2, 1, 11, 13, 2, 1, 14, 17, 2, 1, 18, 21, 2, 1, 24, 27, 2, 1, 34, 37, 2, 1], + [8, 9, 2, 1, 15, 16, 2, 1, 20, 21, 2, 1, 25, 26, 2, 1, 29, 30, 2, 1, 43, 44, 2, 1, 46, 47, 2, 1], + [8, 10, 2, 1, 12, 13, 2, 1, 15, 17, 2, 1, 19, 21, 2, 1, 25, 27, 2, 1, 34, 35, 2, 1, 43, 45, 2, 1]] + +def invData : List (List (List Nat)) := [ + [[0, 1, 2, 1, 2, 2, 0, 2], [1, 2, 1, 2, 1, 1, 0, 1], [2, 1, 2, 1, 2, 0, 0, 2], [0, 0, 1, 2, 1, 1, 0, 1], [0, 2, 1, 0, 1, 1, 0, 1], [2, 1, 1, 1, 0, 2, 1, 2], [2, 1, 2, 1, 2, 2, 0, 0], [2, 1, 2, 1, 2, 2, 1, 2]], + [[0, 1, 2, 1, 2, 2, 0, 2], [0, 0, 1, 2, 1, 1, 0, 1], [2, 1, 2, 1, 2, 0, 0, 2], [1, 2, 1, 2, 1, 1, 0, 1], [0, 2, 1, 0, 1, 1, 0, 1], [2, 1, 1, 1, 0, 2, 1, 2], [2, 1, 2, 1, 2, 2, 0, 0], [2, 1, 2, 1, 2, 2, 1, 2]], + [[1, 0, 2, 2, 0, 1, 2, 2], [2, 1, 1, 1, 0, 2, 1, 1], [0, 0, 2, 2, 0, 2, 2, 2], [2, 0, 2, 1, 0, 2, 1, 1], [2, 0, 1, 2, 0, 2, 1, 1], [0, 2, 2, 2, 1, 1, 0, 2], [0, 1, 1, 1, 2, 2, 0, 0], [1, 2, 2, 2, 0, 1, 0, 2]], + [[0, 1, 0, 2, 2, 1, 2, 2], [0, 0, 0, 1, 1, 2, 1, 1], [2, 1, 0, 2, 0, 1, 2, 2], [0, 2, 1, 1, 1, 2, 1, 1], [1, 2, 0, 1, 1, 2, 1, 1], [2, 1, 0, 2, 2, 1, 2, 0], [2, 1, 0, 2, 2, 1, 0, 2], [2, 1, 2, 0, 2, 2, 2, 2]], + [[1, 2, 1, 2, 2, 2, 2, 1], [2, 2, 2, 1, 1, 1, 1, 2], [0, 2, 1, 2, 0, 2, 2, 1], [2, 1, 0, 1, 1, 1, 1, 2], [2, 2, 2, 1, 1, 0, 1, 0], [1, 1, 1, 2, 2, 0, 2, 1], [0, 2, 1, 2, 2, 2, 0, 1], [0, 1, 1, 0, 2, 0, 2, 1]], + [[2, 0, 1, 0, 2, 1, 2, 2], [1, 1, 2, 0, 1, 2, 1, 1], [0, 2, 1, 0, 2, 1, 2, 2], [0, 1, 0, 0, 1, 2, 1, 1], [0, 1, 2, 0, 1, 0, 1, 1], [2, 2, 1, 2, 2, 1, 0, 0], [2, 2, 1, 2, 0, 1, 2, 0], [2, 2, 1, 0, 2, 1, 2, 0]], + [[2, 0, 1, 0, 2, 1, 2, 2], [0, 1, 0, 0, 1, 2, 1, 1], [0, 2, 1, 0, 2, 1, 2, 2], [1, 1, 2, 0, 1, 2, 1, 1], [0, 1, 2, 0, 1, 0, 1, 1], [2, 2, 1, 2, 2, 1, 0, 0], [2, 2, 1, 2, 0, 1, 2, 0], [2, 2, 1, 0, 2, 1, 2, 0]], + [[0, 0, 2, 1, 2, 1, 2, 2], [2, 1, 2, 2, 1, 2, 1, 1], [1, 2, 2, 1, 2, 1, 2, 2], [2, 1, 1, 0, 1, 2, 1, 1], [2, 1, 1, 2, 1, 0, 1, 1], [0, 2, 1, 1, 2, 1, 0, 0], [0, 2, 1, 1, 0, 1, 2, 0], [1, 2, 1, 1, 2, 1, 2, 0]], + [[0, 2, 1, 2, 1, 2, 2, 0], [2, 0, 0, 2, 0, 2, 1, 2], [1, 1, 0, 1, 0, 1, 2, 1], [2, 2, 1, 2, 0, 2, 1, 2], [2, 2, 0, 2, 1, 2, 1, 2], [0, 0, 0, 1, 0, 2, 0, 1], [1, 0, 0, 1, 0, 1, 0, 1], [0, 0, 0, 2, 0, 1, 0, 1]], + [[2, 0, 1, 1, 2, 2, 0, 2], [0, 1, 0, 2, 1, 1, 0, 1], [0, 2, 1, 1, 2, 2, 0, 2], [0, 1, 2, 0, 1, 1, 0, 1], [1, 1, 2, 2, 1, 1, 0, 1], [2, 2, 1, 1, 2, 2, 0, 0], [2, 2, 1, 1, 1, 0, 1, 2], [2, 2, 1, 1, 2, 2, 1, 2]], + [[0, 0, 0, 1, 2, 2, 1, 1], [2, 1, 1, 2, 1, 1, 2, 2], [1, 2, 0, 1, 2, 2, 1, 1], [2, 1, 0, 0, 1, 1, 2, 2], [2, 1, 1, 2, 1, 1, 1, 0], [1, 2, 2, 1, 2, 2, 2, 1], [0, 2, 2, 1, 2, 0, 2, 1], [0, 2, 2, 1, 0, 2, 2, 1]], + [[2, 2, 1, 2, 2, 2, 1, 1], [1, 2, 2, 1, 1, 1, 2, 2], [2, 1, 1, 0, 2, 2, 1, 1], [0, 2, 2, 1, 1, 1, 0, 2], [0, 2, 2, 1, 1, 1, 2, 0], [2, 1, 1, 2, 2, 0, 1, 1], [2, 1, 1, 2, 0, 2, 1, 1], [0, 1, 1, 2, 2, 2, 1, 1]], + [[2, 0, 1, 1, 2, 2, 1, 1], [1, 1, 2, 2, 1, 1, 2, 2], [2, 2, 2, 1, 2, 2, 1, 1], [0, 1, 2, 2, 1, 1, 0, 2], [0, 1, 2, 2, 1, 1, 2, 0], [2, 2, 1, 1, 2, 0, 1, 1], [0, 2, 1, 1, 2, 2, 1, 1], [2, 2, 1, 1, 0, 2, 1, 1]], + [[2, 2, 1, 2, 2, 2, 1, 1], [1, 2, 2, 1, 1, 1, 2, 2], [2, 1, 1, 0, 2, 2, 1, 1], [0, 2, 2, 1, 1, 1, 0, 2], [0, 2, 2, 1, 1, 1, 2, 0], [0, 1, 1, 2, 2, 2, 1, 1], [2, 1, 1, 2, 2, 0, 1, 1], [2, 1, 1, 2, 0, 2, 1, 1]], + [[2, 1, 2, 2, 1, 2, 1, 2], [0, 0, 1, 1, 0, 1, 2, 1], [2, 0, 2, 0, 1, 2, 1, 2], [1, 0, 1, 1, 2, 1, 2, 1], [0, 2, 2, 1, 2, 1, 0, 1], [2, 0, 2, 2, 1, 2, 1, 0], [2, 0, 2, 2, 1, 0, 1, 2], [0, 0, 2, 2, 1, 2, 1, 2]], + [[2, 0, 2, 1, 2, 2, 2, 2], [0, 1, 1, 0, 1, 1, 1, 1], [2, 2, 0, 1, 2, 2, 2, 2], [1, 1, 1, 2, 1, 1, 1, 1], [0, 1, 1, 2, 1, 1, 1, 2], [2, 2, 2, 1, 2, 2, 0, 2], [0, 2, 2, 1, 2, 2, 2, 2], [2, 2, 2, 1, 0, 2, 2, 2]], + [[2, 2, 0, 1, 0, 0, 0, 2], [1, 1, 0, 1, 1, 1, 1, 0], [2, 1, 0, 2, 0, 0, 0, 2], [1, 2, 0, 2, 0, 0, 0, 1], [1, 1, 1, 2, 0, 0, 0, 1], [2, 2, 2, 1, 0, 0, 1, 2], [2, 1, 0, 1, 0, 1, 0, 2], [2, 1, 0, 1, 1, 0, 0, 2]], + [[2, 2, 1, 2, 1, 2, 2, 1], [0, 2, 2, 1, 0, 1, 1, 2], [2, 1, 1, 0, 1, 2, 2, 1], [1, 2, 2, 1, 2, 1, 1, 2], [0, 2, 2, 1, 2, 1, 1, 0], [0, 1, 1, 2, 1, 2, 2, 1], [2, 1, 1, 2, 1, 2, 0, 1], [2, 1, 1, 2, 1, 0, 2, 1]], + [[2, 2, 1, 2, 1, 1, 2, 2], [0, 1, 0, 1, 0, 2, 1, 1], [2, 1, 1, 0, 1, 1, 2, 2], [0, 1, 0, 1, 2, 0, 1, 1], [1, 1, 0, 1, 2, 2, 1, 1], [2, 2, 0, 2, 1, 1, 2, 0], [2, 2, 0, 2, 1, 1, 0, 2], [0, 2, 0, 2, 1, 1, 2, 2]], + [[2, 0, 1, 1, 1, 1, 2, 2], [0, 1, 2, 2, 0, 2, 1, 1], [2, 2, 1, 2, 1, 1, 2, 2], [0, 1, 2, 2, 2, 0, 1, 1], [1, 1, 2, 2, 2, 2, 1, 1], [2, 2, 1, 1, 1, 1, 2, 0], [0, 2, 1, 1, 1, 1, 2, 2], [2, 2, 1, 1, 1, 1, 0, 2]], + [[1, 2, 0, 1, 0, 2, 2, 2], [1, 2, 0, 2, 1, 1, 1, 1], [1, 1, 0, 2, 0, 2, 2, 2], [1, 2, 0, 2, 0, 2, 1, 1], [1, 2, 1, 1, 0, 1, 2, 1], [2, 1, 2, 2, 0, 2, 2, 2], [2, 1, 0, 1, 0, 2, 2, 2], [0, 2, 0, 2, 1, 1, 1, 0]], + [[2, 1, 2, 2, 1, 1, 2, 2], [0, 0, 1, 1, 0, 2, 1, 1], [2, 0, 2, 0, 1, 1, 2, 2], [0, 2, 2, 1, 2, 0, 1, 1], [1, 0, 1, 1, 2, 2, 1, 1], [0, 0, 2, 2, 1, 1, 2, 2], [2, 0, 2, 2, 1, 1, 2, 0], [2, 0, 2, 2, 1, 1, 0, 2]], + [[2, 2, 1, 0, 2, 0, 0, 0], [1, 2, 2, 0, 1, 0, 0, 0], [2, 1, 2, 0, 2, 0, 0, 0], [0, 1, 1, 1, 1, 1, 1, 0], [0, 1, 1, 0, 1, 1, 1, 1], [0, 2, 2, 2, 2, 0, 2, 0], [0, 2, 2, 0, 2, 2, 2, 0], [0, 2, 2, 0, 2, 2, 0, 2]], + [[2, 2, 1, 0, 2, 0, 2, 1], [0, 1, 1, 1, 2, 1, 1, 2], [2, 1, 2, 0, 2, 0, 2, 1], [1, 2, 2, 0, 1, 0, 1, 2], [0, 1, 1, 0, 2, 1, 2, 2], [0, 2, 2, 2, 2, 2, 2, 1], [0, 2, 2, 0, 1, 2, 2, 1], [0, 2, 2, 0, 1, 0, 1, 1]], + [[0, 0, 2, 2, 2, 0, 1, 0], [2, 0, 0, 2, 2, 0, 0, 0], [0, 2, 0, 2, 2, 0, 1, 0], [2, 0, 0, 1, 2, 1, 0, 0], [2, 0, 0, 1, 2, 0, 0, 1], [1, 0, 0, 1, 2, 0, 0, 0], [1, 0, 0, 2, 1, 0, 0, 0], [2, 1, 1, 2, 0, 2, 0, 2]], + [[0, 2, 2, 2, 0, 1, 0, 0], [2, 0, 2, 2, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 1], [2, 0, 1, 2, 1, 0, 0, 0], [2, 0, 1, 2, 0, 0, 1, 0], [1, 0, 1, 2, 0, 0, 0, 0], [2, 0, 0, 1, 2, 1, 2, 2], [1, 0, 2, 1, 0, 0, 0, 0]], + [[2, 2, 1, 1, 2, 2, 2, 1], [0, 1, 1, 2, 2, 2, 2, 2], [2, 1, 2, 1, 2, 2, 2, 1], [0, 1, 1, 1, 2, 2, 0, 2], [1, 2, 2, 2, 1, 1, 1, 2], [0, 2, 2, 1, 1, 2, 1, 1], [0, 2, 2, 1, 2, 1, 1, 1], [0, 2, 2, 2, 1, 1, 1, 1]], + [[0, 1, 0, 1, 1, 0, 0, 1], [2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 1], [2, 0, 0, 1, 2, 1, 0, 0], [2, 0, 0, 1, 2, 0, 1, 0], [2, 1, 1, 2, 0, 2, 2, 0], [1, 0, 0, 1, 2, 0, 0, 0], [1, 0, 0, 2, 1, 0, 0, 0]], + [[1, 2, 2, 1, 2, 1, 1, 0], [2, 2, 1, 2, 1, 2, 2, 0], [0, 1, 1, 2, 2, 2, 2, 0], [2, 1, 2, 2, 1, 2, 2, 0], [0, 2, 2, 1, 2, 1, 1, 0], [0, 1, 1, 1, 1, 0, 2, 1], [0, 1, 1, 2, 1, 2, 2, 1], [0, 1, 1, 2, 1, 2, 0, 0]], + [[2, 2, 0, 1, 2, 0, 1, 2], [1, 2, 0, 2, 1, 0, 2, 1], [0, 2, 1, 2, 1, 2, 2, 0], [0, 1, 0, 1, 2, 1, 1, 0], [0, 1, 2, 1, 0, 1, 1, 0], [0, 2, 0, 1, 1, 0, 2, 1], [2, 1, 0, 1, 2, 0, 2, 2], [0, 2, 0, 2, 1, 2, 2, 1]], + [[1, 2, 2, 2, 0, 1, 1, 1], [2, 2, 1, 1, 0, 2, 2, 2], [0, 1, 1, 2, 0, 2, 2, 2], [0, 2, 2, 2, 0, 1, 1, 1], [2, 1, 2, 1, 0, 2, 2, 2], [0, 1, 1, 1, 2, 2, 0, 0], [0, 1, 1, 1, 2, 0, 2, 0], [0, 1, 1, 1, 0, 2, 2, 0]], + [[2, 2, 0, 1, 2, 0, 2, 1], [0, 1, 0, 1, 2, 1, 0, 1], [1, 1, 2, 1, 0, 1, 0, 1], [1, 2, 0, 2, 1, 0, 1, 2], [2, 2, 1, 2, 1, 2, 0, 2], [0, 2, 0, 1, 1, 0, 1, 2], [0, 2, 0, 2, 1, 2, 1, 2], [2, 1, 0, 1, 2, 0, 2, 2]], + [[1, 2, 2, 2, 1, 1, 0, 1], [0, 2, 2, 2, 1, 1, 0, 1], [0, 1, 1, 2, 2, 2, 0, 2], [2, 2, 1, 1, 2, 2, 0, 2], [2, 1, 2, 1, 2, 2, 0, 2], [0, 1, 1, 1, 2, 2, 0, 0], [0, 1, 1, 1, 1, 0, 1, 2], [0, 1, 1, 1, 2, 2, 1, 2]], + [[1, 0, 1, 1, 2, 1, 2, 2], [2, 2, 1, 1, 2, 2, 0, 2], [1, 1, 2, 0, 1, 1, 0, 1], [2, 1, 2, 2, 1, 2, 1, 1], [0, 1, 0, 2, 1, 1, 0, 1], [1, 2, 1, 1, 2, 1, 2, 0], [1, 1, 2, 2, 0, 2, 1, 1], [1, 1, 2, 2, 1, 1, 1, 1]], + [[0, 1, 1, 0, 0, 2, 2, 1], [2, 0, 2, 0, 0, 0, 2, 0], [1, 0, 2, 0, 0, 0, 1, 0], [2, 0, 1, 1, 0, 0, 2, 0], [2, 0, 1, 0, 1, 0, 2, 0], [1, 0, 1, 0, 0, 0, 2, 0], [0, 2, 1, 1, 1, 2, 0, 0], [2, 0, 2, 0, 0, 0, 1, 2]], + [[2, 1, 1, 2, 2, 0, 2, 0], [2, 0, 0, 2, 0, 0, 0, 2], [1, 0, 0, 2, 0, 0, 0, 1], [2, 0, 0, 1, 1, 0, 0, 2], [2, 0, 0, 1, 0, 0, 1, 2], [0, 2, 0, 1, 1, 2, 1, 0], [1, 0, 0, 1, 0, 0, 0, 2], [0, 0, 2, 1, 1, 2, 1, 0]], + [[2, 2, 0, 2, 1, 0, 2, 1], [0, 1, 0, 2, 1, 1, 0, 1], [0, 2, 1, 1, 2, 2, 0, 2], [0, 1, 2, 0, 1, 1, 0, 1], [1, 2, 0, 1, 2, 0, 1, 2], [0, 2, 0, 1, 1, 0, 1, 2], [2, 1, 0, 2, 1, 0, 2, 2], [0, 2, 0, 1, 2, 2, 1, 2]], + [[0, 0, 1, 1, 2, 1, 0, 2], [2, 0, 2, 0, 0, 0, 2, 0], [1, 0, 2, 0, 0, 0, 1, 0], [2, 0, 1, 1, 0, 0, 2, 0], [2, 0, 1, 0, 0, 1, 2, 0], [2, 1, 2, 2, 0, 2, 0, 1], [0, 2, 1, 1, 2, 1, 0, 0], [1, 0, 1, 0, 0, 0, 2, 0]], + [[0, 1, 2, 0, 1, 1, 1, 1], [1, 0, 2, 0, 1, 2, 2, 1], [2, 0, 1, 1, 2, 1, 1, 2], [1, 0, 2, 0, 2, 1, 1, 2], [0, 0, 1, 0, 2, 2, 2, 2], [1, 2, 1, 1, 2, 1, 2, 0], [2, 0, 1, 0, 1, 2, 2, 2], [2, 0, 1, 0, 2, 1, 2, 2]], + [[0, 2, 1, 1, 1, 2, 2, 1], [2, 1, 1, 2, 1, 2, 2, 1], [1, 2, 2, 2, 2, 1, 1, 2], [2, 1, 1, 1, 2, 2, 2, 1], [0, 2, 2, 2, 2, 1, 1, 2], [0, 1, 1, 1, 1, 2, 2, 2], [0, 1, 1, 1, 1, 2, 0, 1], [0, 1, 1, 1, 1, 0, 2, 1]], + [[1, 1, 1, 1, 2, 1, 1, 2], [1, 0, 0, 2, 0, 2, 0, 1], [2, 0, 0, 2, 0, 1, 0, 2], [0, 0, 1, 1, 0, 1, 1, 2], [2, 0, 2, 2, 1, 2, 2, 1], [0, 2, 0, 2, 0, 2, 2, 2], [0, 0, 2, 2, 0, 2, 0, 1], [2, 0, 0, 1, 0, 2, 0, 2]], + [[0, 2, 2, 2, 1, 1, 0, 2], [2, 1, 2, 2, 2, 1, 0, 2], [1, 2, 1, 1, 2, 2, 0, 1], [0, 2, 1, 1, 2, 2, 0, 1], [2, 1, 2, 2, 1, 2, 0, 2], [0, 1, 1, 0, 1, 1, 1, 2], [0, 1, 2, 2, 1, 1, 0, 0], [0, 1, 2, 2, 1, 1, 1, 2]], + [[2, 2, 0, 2, 0, 1, 0, 0], [1, 0, 2, 1, 2, 0, 2, 1], [2, 0, 1, 2, 2, 0, 1, 2], [1, 2, 0, 1, 0, 2, 0, 0], [1, 1, 0, 2, 0, 2, 0, 0], [2, 0, 1, 2, 1, 0, 2, 2], [0, 0, 1, 1, 2, 0, 2, 1], [2, 1, 0, 2, 0, 1, 0, 1]], + [[2, 2, 0, 2, 0, 0, 1, 0], [1, 2, 0, 1, 0, 0, 2, 0], [0, 2, 0, 1, 2, 1, 2, 2], [0, 1, 0, 2, 1, 0, 1, 1], [1, 1, 0, 2, 0, 0, 2, 0], [2, 1, 2, 2, 1, 0, 1, 1], [1, 1, 2, 0, 1, 2, 1, 2], [2, 1, 0, 2, 0, 0, 1, 1]], + [[0, 2, 1, 1, 1, 1, 2, 2], [0, 2, 2, 2, 2, 2, 1, 1], [1, 2, 2, 2, 2, 2, 1, 1], [2, 1, 1, 2, 1, 1, 2, 2], [2, 1, 1, 1, 2, 1, 2, 2], [0, 1, 1, 1, 1, 1, 2, 0], [0, 1, 1, 1, 1, 1, 0, 2], [0, 1, 1, 1, 1, 2, 2, 2]], + [[2, 1, 0, 0, 1, 1, 0, 2], [1, 0, 0, 0, 2, 2, 0, 1], [2, 2, 1, 2, 0, 0, 1, 2], [1, 1, 2, 2, 0, 0, 2, 1], [1, 0, 0, 0, 2, 1, 0, 2], [2, 2, 1, 1, 0, 0, 2, 2], [0, 1, 1, 2, 0, 0, 2, 1], [2, 0, 0, 0, 1, 2, 0, 2]], + [[1, 2, 0, 0, 0, 0, 0, 1], [2, 2, 0, 0, 0, 0, 0, 2], [2, 2, 2, 2, 0, 1, 1, 0], [2, 1, 1, 0, 0, 0, 0, 2], [2, 1, 0, 1, 0, 0, 0, 2], [1, 1, 0, 0, 0, 0, 0, 2], [0, 1, 1, 1, 2, 2, 0, 0], [0, 1, 1, 1, 2, 0, 2, 0]], + [[2, 2, 2, 0, 1, 0, 0, 0], [1, 2, 1, 0, 2, 0, 0, 0], [0, 2, 1, 2, 2, 1, 2, 0], [1, 1, 2, 0, 2, 0, 0, 0], [0, 1, 2, 1, 1, 0, 1, 0], [2, 2, 1, 0, 1, 0, 0, 1], [2, 1, 2, 0, 1, 0, 1, 0], [1, 2, 2, 0, 1, 2, 1, 1]], + [[1, 2, 0, 0, 0, 0, 1, 0], [2, 2, 0, 0, 0, 0, 2, 0], [2, 2, 2, 2, 1, 1, 0, 0], [2, 1, 1, 0, 0, 0, 2, 0], [2, 1, 0, 1, 0, 0, 2, 0], [0, 2, 0, 0, 2, 0, 2, 1], [1, 1, 0, 0, 0, 0, 2, 0], [0, 2, 0, 0, 0, 2, 2, 1]], + [[2, 2, 2, 0, 0, 1, 0, 0], [1, 2, 1, 0, 0, 2, 0, 0], [0, 2, 1, 0, 2, 2, 1, 2], [1, 1, 2, 0, 0, 2, 0, 0], [0, 1, 2, 0, 1, 1, 0, 1], [2, 1, 2, 2, 1, 1, 0, 1], [1, 1, 0, 2, 1, 1, 2, 2], [2, 1, 2, 0, 0, 1, 0, 1]], + [[1, 2, 0, 0, 0, 0, 0, 1], [2, 2, 0, 0, 0, 0, 0, 2], [2, 2, 2, 0, 2, 1, 1, 0], [2, 1, 1, 0, 0, 0, 0, 2], [2, 1, 0, 0, 1, 0, 0, 2], [0, 1, 1, 2, 1, 2, 0, 0], [0, 1, 1, 2, 1, 0, 2, 0], [1, 1, 0, 0, 0, 0, 0, 2]], + [[0, 2, 1, 2, 0, 2, 1, 2], [0, 2, 2, 1, 0, 1, 2, 1], [2, 2, 1, 2, 0, 0, 2, 1], [2, 1, 1, 2, 1, 2, 1, 2], [1, 1, 2, 2, 0, 0, 1, 2], [2, 2, 1, 1, 0, 0, 2, 2], [0, 1, 1, 2, 0, 0, 1, 2], [1, 2, 2, 1, 2, 1, 0, 1]], + [[0, 1, 2, 2, 0, 1, 1, 0], [2, 0, 2, 2, 0, 2, 1, 0], [0, 0, 2, 2, 1, 1, 1, 0], [2, 0, 2, 2, 0, 1, 2, 0], [0, 0, 1, 1, 0, 2, 2, 0], [0, 2, 0, 1, 1, 1, 1, 1], [0, 0, 2, 2, 0, 1, 1, 1], [1, 0, 1, 1, 0, 2, 2, 0]], + [[0, 0, 1, 2, 2, 1, 1, 0], [2, 0, 0, 2, 2, 2, 1, 0], [0, 2, 1, 2, 0, 1, 1, 0], [2, 0, 0, 2, 2, 1, 2, 0], [0, 0, 0, 1, 1, 2, 2, 0], [0, 2, 0, 0, 2, 1, 1, 1], [1, 0, 0, 1, 1, 2, 2, 0], [0, 0, 0, 2, 2, 1, 1, 1]], + [[2, 2, 2, 1, 2, 0, 1, 0], [0, 2, 2, 2, 2, 2, 2, 0], [2, 1, 2, 2, 2, 0, 1, 0], [0, 1, 1, 2, 1, 1, 2, 1], [2, 2, 2, 1, 2, 0, 1, 2], [2, 1, 2, 2, 1, 0, 2, 0], [2, 2, 1, 1, 2, 0, 2, 0], [2, 2, 1, 2, 1, 0, 2, 0]], + [[0, 2, 1, 2, 1, 1, 1, 2], [2, 2, 0, 2, 2, 1, 1, 2], [0, 1, 1, 0, 1, 1, 1, 2], [2, 2, 0, 2, 1, 2, 1, 2], [0, 1, 0, 1, 2, 2, 2, 1], [1, 1, 0, 1, 2, 2, 2, 1], [0, 2, 0, 2, 1, 1, 1, 0], [0, 2, 0, 2, 1, 1, 2, 2]], + [[0, 1, 2, 0, 2, 1, 0, 1], [2, 0, 2, 0, 2, 2, 0, 1], [0, 0, 2, 1, 2, 1, 0, 1], [0, 0, 1, 0, 1, 2, 0, 2], [2, 0, 2, 0, 2, 1, 0, 2], [0, 2, 0, 1, 1, 1, 1, 1], [0, 0, 2, 0, 2, 1, 1, 1], [1, 0, 1, 0, 1, 2, 0, 2]], + [[0, 2, 1, 1, 1, 2, 2, 1], [1, 2, 1, 1, 2, 2, 2, 1], [0, 1, 1, 2, 1, 2, 2, 1], [0, 2, 2, 2, 2, 1, 1, 2], [0, 1, 0, 2, 2, 1, 1, 2], [2, 1, 2, 2, 1, 1, 2, 2], [0, 1, 1, 1, 1, 2, 2, 2], [2, 1, 2, 2, 1, 2, 1, 2]], + [[0, 1, 2, 0, 2, 1, 0, 1], [2, 0, 2, 0, 2, 2, 0, 1], [0, 0, 2, 1, 2, 1, 0, 1], [0, 0, 1, 0, 1, 2, 0, 2], [2, 0, 2, 0, 2, 1, 0, 2], [0, 1, 1, 2, 0, 1, 1, 1], [1, 0, 1, 0, 1, 2, 0, 2], [0, 0, 2, 0, 2, 1, 1, 1]], + [[0, 0, 0, 1, 1, 2, 2, 1], [1, 0, 0, 2, 1, 2, 2, 1], [0, 0, 2, 2, 1, 2, 2, 1], [0, 1, 0, 2, 2, 1, 1, 2], [0, 0, 1, 1, 0, 1, 1, 2], [2, 0, 0, 1, 2, 1, 2, 2], [2, 0, 0, 1, 2, 2, 1, 2], [0, 2, 0, 1, 1, 2, 2, 2]], + [[0, 1, 2, 0, 2, 1, 0, 1], [2, 0, 2, 0, 2, 2, 0, 1], [0, 0, 2, 1, 2, 1, 0, 1], [0, 0, 1, 0, 1, 2, 0, 2], [2, 0, 2, 0, 2, 1, 0, 2], [1, 0, 1, 0, 1, 2, 0, 2], [0, 1, 1, 2, 0, 1, 1, 1], [0, 0, 2, 0, 2, 1, 1, 1]], + [[0, 1, 1, 1, 2, 1, 2, 2], [0, 0, 2, 2, 1, 2, 1, 1], [0, 0, 1, 1, 0, 1, 2, 2], [1, 0, 1, 2, 0, 1, 2, 2], [0, 2, 0, 2, 1, 2, 1, 1], [0, 0, 1, 1, 2, 2, 2, 2], [2, 0, 2, 1, 0, 2, 1, 2], [2, 0, 2, 1, 0, 2, 2, 1]], + [[1, 2, 0, 1, 1, 0, 0, 2], [2, 2, 0, 2, 2, 0, 0, 1], [1, 1, 1, 1, 1, 0, 0, 2], [0, 1, 0, 1, 1, 0, 1, 2], [1, 0, 2, 1, 0, 2, 2, 1], [1, 1, 0, 1, 1, 1, 0, 2], [1, 1, 0, 1, 2, 0, 0, 2], [0, 2, 0, 2, 2, 0, 0, 1]], + [[0, 0, 0, 1, 1, 1, 2, 2], [0, 1, 0, 2, 2, 2, 1, 1], [0, 2, 1, 1, 1, 1, 2, 2], [1, 0, 0, 2, 1, 1, 2, 2], [0, 1, 2, 2, 0, 2, 1, 1], [2, 0, 0, 1, 2, 2, 1, 2], [0, 2, 0, 1, 1, 2, 2, 2], [2, 0, 0, 1, 2, 2, 2, 1]], + [[1, 1, 0, 1, 1, 1, 0, 2], [2, 0, 0, 2, 2, 2, 0, 1], [1, 0, 0, 1, 2, 1, 0, 2], [0, 0, 0, 1, 1, 1, 1, 2], [1, 2, 1, 0, 0, 2, 2, 1], [1, 0, 2, 2, 1, 2, 0, 2], [0, 0, 0, 2, 2, 2, 0, 1], [1, 0, 0, 1, 1, 2, 0, 2]], + [[0, 0, 2, 1, 2, 1, 2, 2], [0, 1, 1, 2, 1, 2, 1, 1], [0, 0, 1, 1, 0, 1, 2, 2], [1, 0, 2, 1, 0, 1, 2, 2], [0, 0, 1, 0, 1, 2, 1, 1], [2, 0, 1, 2, 0, 2, 1, 2], [2, 0, 1, 2, 0, 2, 2, 1], [0, 2, 2, 1, 2, 2, 2, 2]], + [[1, 2, 0, 1, 0, 1, 2, 0], [2, 2, 0, 2, 0, 2, 1, 0], [1, 1, 1, 1, 0, 1, 2, 0], [0, 1, 0, 1, 0, 1, 2, 1], [1, 0, 2, 1, 2, 0, 1, 2], [0, 2, 0, 2, 0, 2, 1, 0], [1, 1, 0, 1, 0, 2, 2, 0], [1, 1, 0, 1, 1, 1, 2, 0]], + [[0, 1, 1, 1, 2, 1, 2, 2], [0, 0, 2, 2, 1, 2, 1, 1], [0, 0, 1, 1, 0, 1, 2, 2], [0, 2, 0, 2, 1, 2, 1, 1], [1, 0, 1, 2, 0, 1, 2, 2], [0, 0, 1, 1, 2, 2, 2, 2], [2, 0, 2, 1, 0, 2, 1, 2], [2, 0, 2, 1, 0, 2, 2, 1]], + [[1, 2, 0, 0, 1, 0, 0, 0], [2, 2, 0, 0, 2, 0, 0, 0], [1, 1, 0, 0, 2, 0, 0, 0], [2, 1, 1, 0, 2, 0, 0, 0], [2, 1, 0, 1, 2, 0, 0, 0], [2, 2, 0, 0, 1, 0, 0, 2], [0, 2, 2, 2, 1, 1, 1, 1], [0, 2, 0, 0, 2, 1, 2, 0]], + [[0, 0, 1, 1, 1, 0, 2, 2], [0, 1, 2, 2, 2, 0, 1, 1], [0, 2, 2, 1, 2, 2, 2, 2], [0, 1, 2, 2, 1, 1, 1, 1], [1, 0, 1, 2, 1, 0, 2, 2], [2, 0, 2, 1, 2, 0, 1, 2], [0, 2, 1, 1, 2, 0, 2, 2], [2, 0, 2, 1, 2, 0, 2, 1]], + [[0, 2, 1, 2, 0, 1, 2, 2], [1, 0, 0, 2, 1, 0, 2, 1], [2, 1, 0, 1, 2, 0, 1, 2], [1, 2, 1, 2, 1, 0, 2, 1], [1, 2, 0, 2, 1, 1, 2, 1], [2, 0, 0, 1, 1, 0, 2, 0], [2, 0, 0, 1, 2, 0, 1, 0], [2, 0, 0, 2, 1, 0, 1, 0]], + [[2, 2, 2, 0, 0, 1, 1, 1], [1, 2, 1, 0, 0, 2, 2, 2], [0, 1, 2, 2, 1, 2, 0, 2], [1, 1, 2, 0, 0, 2, 2, 2], [1, 1, 1, 0, 1, 2, 2, 2], [2, 1, 2, 2, 0, 2, 2, 1], [2, 2, 1, 0, 0, 1, 1, 2], [2, 1, 2, 0, 0, 1, 2, 1]], + [[1, 2, 2, 0, 0, 0, 0, 0], [0, 2, 2, 2, 1, 1, 0, 1], [1, 1, 2, 1, 0, 0, 0, 0], [2, 2, 1, 0, 0, 0, 0, 0], [2, 1, 2, 0, 0, 0, 0, 0], [1, 1, 2, 0, 2, 1, 1, 0], [1, 1, 2, 0, 0, 0, 0, 1], [1, 1, 2, 0, 0, 0, 1, 0]], + [[1, 2, 0, 2, 0, 0, 0, 0], [2, 2, 0, 1, 0, 0, 0, 0], [1, 1, 0, 2, 0, 1, 0, 0], [0, 1, 0, 2, 1, 0, 1, 1], [2, 1, 0, 2, 0, 0, 0, 0], [1, 1, 2, 2, 1, 0, 0, 1], [1, 2, 2, 2, 0, 2, 1, 1], [1, 1, 0, 2, 0, 0, 0, 1]], + [[2, 0, 2, 2, 1, 0, 1, 1], [1, 0, 2, 2, 2, 0, 1, 2], [2, 0, 1, 2, 1, 0, 2, 1], [1, 1, 1, 1, 2, 0, 2, 2], [1, 0, 2, 1, 2, 1, 1, 2], [2, 0, 1, 1, 1, 0, 2, 2], [2, 0, 1, 1, 2, 0, 1, 2], [0, 1, 1, 1, 2, 1, 1, 0]], + [[2, 2, 0, 0, 0, 0, 1, 1], [1, 2, 0, 0, 0, 0, 2, 2], [2, 2, 2, 0, 0, 0, 2, 1], [1, 1, 1, 0, 0, 1, 1, 2], [1, 1, 0, 1, 0, 0, 2, 2], [2, 1, 0, 0, 0, 0, 1, 2], [0, 1, 1, 1, 2, 1, 1, 0], [2, 1, 1, 0, 2, 0, 1, 2]], + [[1, 2, 2, 0, 0, 0, 0, 0], [2, 2, 1, 0, 0, 0, 0, 0], [1, 1, 2, 0, 1, 0, 0, 0], [2, 1, 2, 0, 0, 0, 0, 0], [0, 1, 2, 1, 0, 0, 1, 1], [1, 0, 2, 1, 1, 2, 0, 1], [1, 1, 2, 0, 0, 2, 1, 1], [1, 1, 2, 0, 0, 0, 0, 1]], + [[2, 2, 0, 0, 2, 1, 1, 1], [1, 2, 0, 0, 2, 1, 2, 2], [2, 1, 0, 0, 2, 2, 1, 1], [1, 2, 0, 0, 1, 2, 2, 2], [1, 1, 0, 1, 1, 2, 2, 2], [0, 2, 2, 1, 1, 2, 2, 0], [2, 2, 2, 0, 1, 1, 2, 2], [2, 1, 0, 0, 1, 2, 1, 2]], + [[0, 0, 0, 0, 2, 0, 2, 0], [0, 1, 0, 0, 1, 0, 1, 0], [2, 0, 0, 0, 2, 0, 2, 0], [0, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 0, 2, 0, 1, 0], [1, 0, 0, 0, 1, 0, 1, 2], [1, 1, 1, 2, 1, 2, 0, 0], [1, 0, 0, 1, 1, 2, 1, 2]], + [[2, 2, 2, 2, 1, 2, 2, 2], [2, 2, 2, 2, 2, 1, 1, 2], [0, 2, 1, 2, 1, 2, 1, 1], [1, 2, 1, 2, 1, 1, 1, 1], [1, 2, 1, 1, 1, 2, 1, 1], [0, 1, 2, 1, 1, 2, 2, 1], [0, 2, 1, 2, 1, 1, 1, 2], [0, 2, 1, 1, 1, 2, 2, 1]], + [[2, 2, 0, 2, 0, 1, 1, 1], [1, 1, 1, 1, 1, 2, 1, 2], [0, 1, 1, 1, 1, 2, 2, 2], [2, 2, 0, 2, 0, 2, 0, 0], [1, 1, 1, 1, 0, 2, 2, 2], [0, 1, 0, 2, 0, 1, 0, 0], [0, 1, 1, 1, 0, 2, 2, 0], [0, 2, 0, 1, 0, 1, 0, 0]], + [[0, 0, 0, 2, 0, 0, 0, 2], [0, 1, 0, 1, 0, 0, 0, 1], [1, 2, 1, 1, 2, 2, 2, 0], [0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 1], [1, 0, 0, 1, 0, 2, 0, 1], [1, 0, 0, 1, 0, 0, 2, 1], [2, 0, 0, 2, 0, 0, 0, 2]], + [[0, 0, 0, 2, 0, 0, 0, 2], [0, 1, 0, 1, 0, 0, 0, 1], [1, 1, 0, 1, 2, 1, 2, 0], [0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 1], [1, 0, 0, 1, 0, 0, 2, 1], [2, 0, 0, 2, 0, 0, 0, 2], [1, 0, 1, 1, 2, 2, 0, 1]], + [[2, 0, 2, 2, 0, 0, 2, 1], [1, 1, 1, 1, 1, 2, 1, 2], [0, 1, 1, 1, 1, 0, 1, 2], [1, 1, 1, 1, 0, 0, 1, 2], [2, 0, 2, 2, 0, 0, 2, 0], [0, 0, 1, 2, 0, 0, 1, 0], [0, 1, 1, 1, 0, 2, 2, 0], [0, 0, 2, 1, 0, 0, 1, 0]], + [[0, 0, 0, 2, 0, 0, 0, 2], [0, 1, 0, 1, 0, 0, 0, 1], [1, 2, 1, 1, 2, 2, 2, 0], [0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 1], [2, 0, 0, 2, 0, 0, 0, 2], [1, 0, 0, 1, 0, 2, 0, 1], [1, 0, 0, 1, 0, 0, 2, 1]], + [[0, 1, 1, 1, 1, 1, 0, 2], [2, 2, 0, 2, 0, 2, 0, 0], [2, 2, 0, 2, 0, 1, 1, 1], [1, 1, 1, 1, 1, 1, 2, 2], [1, 1, 1, 1, 0, 1, 0, 2], [0, 1, 0, 2, 0, 1, 0, 0], [0, 1, 1, 1, 0, 1, 0, 0], [0, 2, 0, 1, 0, 1, 0, 0]], + [[1, 1, 2, 1, 2, 2, 2, 0], [0, 1, 0, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 2], [0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 1], [1, 0, 0, 1, 0, 2, 0, 1], [1, 0, 0, 1, 0, 0, 2, 1], [2, 0, 0, 2, 0, 0, 0, 2]], + [[1, 0, 1, 1, 2, 1, 2, 0], [0, 1, 0, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 2], [0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 1], [1, 0, 0, 1, 0, 0, 2, 1], [2, 0, 0, 2, 0, 0, 0, 2], [1, 1, 0, 1, 2, 2, 0, 1]], + [[0, 0, 1, 1, 1, 1, 1, 2], [1, 0, 1, 1, 1, 1, 0, 2], [2, 1, 2, 2, 2, 0, 2, 1], [1, 0, 1, 1, 1, 0, 1, 2], [2, 1, 2, 2, 2, 0, 2, 0], [0, 2, 1, 1, 2, 0, 1, 0], [0, 2, 1, 2, 1, 0, 1, 0], [0, 2, 2, 1, 1, 0, 1, 0]], + [[1, 1, 0, 2, 1, 1, 2, 0], [0, 1, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 2, 0, 0, 2], [0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 2, 0, 0, 1], [2, 0, 0, 0, 2, 0, 0, 2], [1, 0, 0, 0, 1, 0, 2, 1], [1, 0, 1, 2, 1, 2, 0, 1]], + [[1, 2, 0, 0, 0, 0, 0, 2], [2, 2, 0, 0, 0, 0, 0, 1], [1, 1, 1, 0, 0, 0, 0, 2], [1, 2, 0, 0, 0, 0, 0, 1], [0, 0, 1, 2, 2, 2, 1, 1], [1, 1, 0, 0, 0, 1, 0, 2], [1, 1, 0, 0, 1, 0, 0, 2], [1, 1, 0, 1, 0, 0, 0, 2]], + [[2, 2, 1, 2, 0, 1, 0, 1], [1, 2, 2, 1, 0, 2, 0, 2], [2, 1, 2, 2, 0, 1, 0, 1], [2, 1, 2, 2, 0, 1, 2, 1], [2, 2, 1, 2, 2, 1, 0, 1], [2, 2, 1, 1, 0, 1, 0, 2], [2, 1, 2, 1, 0, 2, 0, 1], [0, 2, 2, 0, 1, 2, 1, 2]], + [[2, 2, 1, 0, 2, 0, 1, 1], [1, 2, 2, 0, 2, 0, 2, 1], [2, 2, 1, 0, 1, 0, 1, 2], [2, 2, 1, 0, 1, 0, 1, 1], [2, 2, 1, 0, 1, 2, 1, 2], [2, 1, 2, 0, 1, 0, 1, 2], [0, 2, 2, 2, 0, 1, 2, 1], [2, 2, 1, 2, 2, 0, 2, 1]], + [[1, 2, 0, 0, 0, 0, 0, 2], [2, 2, 0, 0, 0, 0, 0, 1], [1, 1, 1, 0, 0, 0, 0, 2], [0, 0, 1, 2, 2, 2, 1, 1], [1, 2, 0, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 1, 0, 2], [1, 1, 0, 0, 1, 0, 0, 2], [1, 1, 0, 1, 0, 0, 0, 2]], + [[2, 2, 0, 1, 0, 0, 0, 1], [1, 2, 0, 2, 0, 0, 0, 2], [2, 1, 1, 1, 0, 0, 0, 1], [2, 2, 0, 1, 0, 0, 2, 1], [2, 2, 0, 1, 0, 2, 0, 1], [0, 1, 1, 2, 2, 1, 1, 2], [2, 1, 0, 2, 0, 0, 0, 1], [2, 2, 0, 1, 2, 0, 0, 2]], + [[2, 2, 1, 0, 2, 1, 0, 1], [2, 2, 2, 2, 1, 1, 0, 1], [2, 1, 2, 0, 2, 1, 0, 1], [1, 2, 2, 0, 1, 2, 0, 2], [2, 1, 2, 0, 2, 1, 2, 1], [2, 1, 2, 0, 1, 2, 0, 1], [2, 2, 1, 0, 1, 1, 0, 2], [0, 2, 1, 1, 1, 2, 1, 2]], + [[2, 1, 1, 1, 1, 0, 1, 2], [2, 2, 0, 1, 0, 0, 1, 2], [2, 2, 0, 1, 0, 0, 1, 0], [1, 2, 0, 2, 0, 0, 2, 0], [2, 1, 1, 1, 1, 2, 1, 2], [2, 1, 0, 2, 0, 0, 1, 0], [0, 2, 0, 2, 2, 1, 2, 1], [2, 2, 0, 1, 2, 0, 2, 0]], + [[1, 2, 0, 0, 0, 0, 0, 2], [0, 0, 1, 2, 2, 2, 1, 1], [1, 1, 1, 0, 0, 0, 0, 2], [2, 2, 0, 0, 0, 0, 0, 1], [1, 2, 0, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 1, 0, 2], [1, 1, 0, 0, 1, 0, 0, 2], [1, 1, 0, 1, 0, 0, 0, 2]], + [[2, 1, 1, 1, 0, 0, 1, 0], [2, 1, 2, 1, 2, 2, 1, 0], [2, 0, 2, 1, 0, 0, 1, 0], [1, 0, 2, 2, 0, 0, 2, 0], [2, 0, 2, 1, 0, 0, 1, 2], [0, 0, 1, 2, 1, 0, 2, 1], [2, 0, 1, 2, 0, 0, 1, 0], [2, 0, 2, 1, 0, 2, 2, 0]], + [[1, 1, 1, 1, 1, 1, 2, 0], [0, 2, 2, 1, 0, 0, 0, 1], [1, 2, 1, 1, 0, 0, 2, 1], [0, 2, 1, 2, 0, 0, 0, 1], [0, 2, 1, 1, 1, 0, 0, 1], [1, 2, 1, 1, 0, 2, 0, 1], [2, 1, 2, 2, 0, 0, 0, 2], [0, 1, 2, 2, 0, 0, 0, 2]], + [[0, 1, 2, 0, 2, 1, 1, 0], [1, 1, 0, 2, 1, 1, 1, 0], [0, 0, 0, 0, 2, 1, 1, 0], [1, 0, 0, 0, 2, 1, 1, 2], [2, 0, 1, 0, 1, 2, 2, 0], [0, 0, 0, 0, 1, 1, 2, 0], [0, 0, 0, 0, 1, 2, 1, 0], [2, 0, 0, 1, 1, 2, 2, 1]], + [[1, 0, 1, 1, 1, 1, 1, 2], [0, 2, 2, 2, 1, 1, 1, 0], [1, 2, 2, 1, 1, 1, 1, 2], [0, 2, 2, 1, 2, 1, 1, 0], [0, 2, 2, 1, 1, 2, 1, 0], [2, 1, 1, 2, 2, 2, 2, 0], [1, 2, 2, 1, 1, 1, 0, 0], [0, 1, 1, 2, 2, 2, 2, 0]], + [[0, 0, 2, 1, 2, 0, 1, 1], [1, 1, 1, 1, 1, 0, 1, 1], [0, 1, 1, 1, 1, 0, 2, 1], [1, 0, 2, 1, 2, 2, 1, 1], [2, 0, 2, 2, 2, 0, 1, 2], [0, 0, 1, 2, 1, 0, 2, 1], [2, 0, 2, 2, 1, 1, 2, 2], [0, 0, 2, 1, 1, 0, 1, 2]], + [[1, 1, 1, 1, 1, 1, 2, 0], [0, 2, 2, 0, 1, 0, 0, 1], [1, 2, 1, 0, 1, 0, 2, 1], [0, 2, 1, 1, 1, 0, 0, 1], [0, 2, 1, 0, 2, 0, 0, 1], [2, 1, 2, 0, 2, 0, 0, 2], [0, 1, 2, 0, 2, 0, 0, 2], [1, 2, 1, 0, 1, 2, 0, 1]]] + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs4.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs4.lean new file mode 100644 index 0000000000..9bbd9ba1ea --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs4.lean @@ -0,0 +1,38 @@ +import CarrierCode.E8Defs +import CarrierCode.E8Data4 + +/-! +# Data layer for step 4 + +For each port `t`, seven A2 triangles `(x, y, a, b)` with `r_y = a r_t + b r_x` (mod 3) and the inverse `C` of the +matrix with rows `r_t, r_x₁, …, r_x₇`. +-/ + +namespace CarrierCode.E8 + +def a2L (t : ℕ) : List ℕ := a2Data.getD t [] +def ax (t i : ℕ) : ℕ := (a2L t).getD (4 * i) 0 +def ay (t i : ℕ) : ℕ := (a2L t).getD (4 * i + 1) 0 +def aa (t i : ℕ) : ℕ := (a2L t).getD (4 * i + 2) 0 +def ab (t i : ℕ) : ℕ := (a2L t).getD (4 * i + 3) 0 +def cL (t k i : ℕ) : ℕ := ((invData.getD t []).getD k []).getD i 0 +/-- rows `r_t, r_x₁, …, r_x₇` -/ +def rowL (t i : ℕ) : List ℕ := if i = 0 then rL t else rL (ax t (i - 1)) + +def tri4 (t i : ℕ) : Prop := + ax t i < 104 ∧ ay t i < 104 ∧ dotN t (ax t i) % 3 ≠ 0 ∧ dotN t (ay t i) % 3 ≠ 0 ∧ + dotN (ax t i) (ay t i) % 3 ≠ 0 ∧ (aa t i = 1 ∨ aa t i = 2) ∧ (ab t i = 1 ∨ ab t i = 2) ∧ + ∀ k : Fin 8, (rv (ay t i) k + 2 * aa t i * rv t k + 2 * ab t i * rv (ax t i) k) % 3 = 0 + +def check4 (t : ℕ) : Prop := + (∀ i : Fin 7, tri4 t i) ∧ + ∀ k l : Fin 8, ((List.range 8).map fun i => cL t k i * (rowL t i).getD l 0).sum % 3 = if k = l then 1 else 0 + +instance (t i : ℕ) : Decidable (tri4 t i) := by unfold tri4; infer_instance +instance (t : ℕ) : Decidable (check4 t) := by unfold check4; infer_instance + +def step4OK : Prop := ∀ t : Fin 104, check4 t + +instance : Decidable step4OK := by unfold step4OK; infer_instance + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step4.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step4.lean new file mode 100644 index 0000000000..2bfcc6c58b --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step4.lean @@ -0,0 +1,134 @@ +import CarrierCode.E8Step3 +import CarrierCode.E8Defs4 + +/-! +# Step 4: symmetry and A2 triangles kill `v_t` + +From step 3 and the symmetry of `N`, `r_x ⬝ v_t = r_t ⬝ v_x` for non-orthogonal ports. Along an A2 triangle this +forces `r_x ⬝ v_t = 0` (`a2_gen`), and the checked spanning triangles give `v_t = 0`. Hence `N t x = 1`, so `M` is +symmetric and `M t x = ±1` for every non-orthogonal pair. +-/ + +namespace CarrierCode.E8 + +open Matrix + +variable {M : Matrix ι ι (ZMod 3)} {A : Matrix ι (Fin 8) (ZMod 3)} {B : Matrix (Fin 8) ι (ZMod 3)} + +/-- The checks of steps 1–3 (proved by the kernel in `E8Checks.lean`). -/ +def Checks3 : Prop := framesOK ∧ ∀ t : ι, seedOK t.val ∧ ∀ x : ι, check3 t.val x.val + +theorem step3' (h : Hyp M A B) (hC : Checks3) (t x : ι) (hnz : dotN t x % 3 ≠ 0) : + Nm M t x = 1 + Gm t x * (r x ⬝ᵥ vv M t) := step3 h hC.1 hC.2 t x hnz + +theorem two_mul_ne (a b : ZMod 3) (ha : a ≠ 0) (hb : b ≠ 0) : 2 * a * b ≠ 0 := by + revert a b; decide + +/-- The A2 trick for a general triangle `r_y = a r_t + b r_x` in characteristic 3. -/ +theorem a2_gen {n : Type*} [Fintype n] (rt rx ry vt vx vy : n → ZMod 3) (a b : ZMod 3) (ha : a ≠ 0) (hb : b ≠ 0) + (hy : ry = a • rt + b • rx) (ht : rt ⬝ᵥ vt = 0) (hx : rx ⬝ᵥ vx = 0) (hyy : ry ⬝ᵥ vy = 0) + (stx : rx ⬝ᵥ vt = rt ⬝ᵥ vx) (sty : ry ⬝ᵥ vt = rt ⬝ᵥ vy) (sxy : rx ⬝ᵥ vy = ry ⬝ᵥ vx) : + rx ⬝ᵥ vt = 0 := by + have e1 : ry ⬝ᵥ vt = b * (rx ⬝ᵥ vt) := by + rw [hy, add_dotProduct, smul_dotProduct, smul_dotProduct, ht, smul_eq_mul, smul_eq_mul, mul_zero, zero_add] + have e2 : ry ⬝ᵥ vx = a * (rx ⬝ᵥ vt) := by + rw [hy, add_dotProduct, smul_dotProduct, smul_dotProduct, hx, smul_eq_mul, smul_eq_mul, mul_zero, add_zero, stx] + have e3 : ry ⬝ᵥ vy = a * (rt ⬝ᵥ vy) + b * (rx ⬝ᵥ vy) := by + rw [hy, add_dotProduct, smul_dotProduct, smul_dotProduct, smul_eq_mul, smul_eq_mul] + rw [← sty, sxy, e1, e2, hyy] at e3 + have key : (2 * a * b) * (rx ⬝ᵥ vt) = 0 := by linear_combination -e3 + exact (mul_eq_zero.mp key).resolve_left (two_mul_ne a b ha hb) + +theorem dotN_comm (i j : ℕ) : dotN i j = dotN j i := by + simp only [dotN, dotW, rv, rL]; ring + +theorem Gm_ne {t x : ι} (hnz : dotN t x % 3 ≠ 0) : Gm t x ≠ 0 := by + rw [Gm, ← dotN_cast]; exact fun e => hnz ((cast_eq_zero_iff _).mp e) + +/-- (4) of E8-PROOF.md. -/ +theorem symm_rel (h : Hyp M A B) (hC : Checks3) {t x : ι} (hnz : dotN t x % 3 ≠ 0) : + r x ⬝ᵥ vv M t = r t ⬝ᵥ vv M x := by + have e1 := step3' h hC t x hnz + have e2 := step3' h hC x t (by rwa [dotN_comm]) + have hN : Nm M t x = Nm M x t := mul_comm _ _ + rw [e1, e2, Gm_comm x t] at hN + exact mul_left_cancel₀ (Gm_ne hnz) (add_left_cancel hN) + +theorem rv_vec (i : ℕ) (k : Fin 8) : ((rv i k : ℕ) : ZMod 3) = r i k := rfl + +theorem tri_vec {t i : ℕ} (hT : tri4 t i) : + r (ay t i) = ((aa t i : ℕ) : ZMod 3) • r t + ((ab t i : ℕ) : ZMod 3) • r (ax t i) := by + funext k + have e := hT.2.2.2.2.2.2.2 k + have e' := congrArg (fun n : ℕ => (n : ZMod 3)) e + simp only [cast_mod] at e' + push_cast at e' + simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul] + rw [rv_vec, rv_vec, rv_vec] at e' + have h3 : (3 : ZMod 3) = 0 := by decide + linear_combination e' - (r t k * (aa t i : ZMod 3) + r (ax t i) k * (ab t i : ZMod 3)) * h3 + +theorem unit3 {n : ℕ} (h : n = 1 ∨ n = 2) : ((n : ℕ) : ZMod 3) ≠ 0 := by + rcases h with rfl | rfl <;> decide + +theorem vv_self (hC : Checks3) (u : ι) : r u ⬝ᵥ vv M u = 0 := rt_dot_vv (hC.2 u).1 + +/-- Every row `r_x` of the spanning set is orthogonal to `v_t`. -/ +theorem row_dot_vv (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) (t : ι) (i : Fin 7) : + r (ax t i) ⬝ᵥ vv M t = 0 := by + have hT := (h4 t).1 i + obtain ⟨hx, hy, htx, hty, hxy, ha, hb, -⟩ := (h4 t).1 i + have ex : ((toι (ax t i) : ι) : ℕ) = ax t i := toι_val hx + have ey : ((toι (ay t i) : ι) : ℕ) = ay t i := toι_val hy + have stx := symm_rel h hC (t := t) (x := toι (ax t i)) (by rwa [ex]) + have sty := symm_rel h hC (t := t) (x := toι (ay t i)) (by rwa [ey]) + have sxy := symm_rel h hC (t := toι (ay t i)) (x := toι (ax t i)) (by rw [ex, ey, dotN_comm]; exact hxy) + have vx := vv_self (M := M) hC (toι (ax t i)) + have vy := vv_self (M := M) hC (toι (ay t i)) + rw [ex] at stx sxy vx + rw [ey] at sty sxy vy + exact a2_gen (r t) (r (ax t i)) (r (ay t i)) (vv M t) (vv M (toι (ax t i))) (vv M (toι (ay t i))) + _ _ (unit3 ha) (unit3 hb) (tri_vec hT) (vv_self hC t) vx vy stx sty sxy + +theorem sum_range8 (g : ℕ → ℕ) : (((List.range 8).map g).sum : ℕ) = ∑ j : Fin 8, g j := by + simp [List.sum_range_succ, Fin.sum_univ_eight] + +/-- Step 4: `v_t = 0`. -/ +theorem vv_zero (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) (t : ι) : vv M t = 0 := by + have hrow : ∀ i : Fin 8, vec (rowL t i) ⬝ᵥ vv M t = 0 := by + intro i + by_cases hi : (i : ℕ) = 0 + · simp only [rowL, if_pos hi]; exact vv_self hC t + · simp only [rowL, if_neg hi] + have := row_dot_vv h hC h4 t ⟨i - 1, by omega⟩ + exact this + funext k + have hinv : ∀ l : Fin 8, ∑ i : Fin 8, ((cL t k i : ℕ) : ZMod 3) * vec (rowL t i) l = if k = l then 1 else 0 := by + intro l + have e := (h4 t).2 k l + rw [sum_range8] at e + have e' := congrArg (fun n : ℕ => (n : ZMod 3)) e + simp only [cast_mod] at e' + push_cast at e' + exact e' + calc vv M t k = ∑ l : Fin 8, (if k = l then (1 : ZMod 3) else 0) * vv M t l := by simp + _ = ∑ l : Fin 8, ∑ i : Fin 8, ((cL t k i : ℕ) : ZMod 3) * vec (rowL t i) l * vv M t l := by + simp_rw [← hinv, Finset.sum_mul] + _ = ∑ i : Fin 8, ((cL t k i : ℕ) : ZMod 3) * (vec (rowL t i) ⬝ᵥ vv M t) := by + rw [Finset.sum_comm]; simp only [dotProduct, Finset.mul_sum, mul_assoc] + _ = 0 := by simp [hrow] + +/-- After step 4: `N t x = 1` for non-orthogonal pairs. -/ +theorem N_one (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) {t x : ι} (hnz : dotN t x % 3 ≠ 0) : Nm M t x = 1 := by + rw [step3' h hC t x hnz, vv_zero h hC h4, dotProduct_zero, mul_zero, add_zero] + +/-- (5) of E8-PROOF.md: `M` is symmetric and `M t x = ±1` off the conflict pattern. -/ +theorem M_symm_pm (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) {t x : ι} (hnz : dotN t x % 3 ≠ 0) : + M x t = M t x ∧ M t x * M t x = 1 := by + have e := N_one h hC h4 hnz + simp only [Nm] at e + generalize M t x = a at e ⊢ + generalize M x t = b at e ⊢ + revert a b; decide + +end CarrierCode.E8 From 5a47e4df579f3142a5f01c530d3657950854510d Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 29 Oct 2026 00:04:21 +0000 Subject: [PATCH 10/11] E8 Lean: step 5 (signs, M = D (2 Gm) D) and final theorem decoding_unique Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYm9RueiYCeCpQh8oBuC --- .../lean/CarrierCode/E8Check5.lean | 9 + .../lean/CarrierCode/E8Data5.lean | 80 ++++++ .../lean/CarrierCode/E8Defs5.lean | 48 ++++ .../lean/CarrierCode/E8Main.lean | 26 ++ .../lean/CarrierCode/E8Step5.lean | 270 ++++++++++++++++++ 5 files changed, 433 insertions(+) create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check5.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data5.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs5.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Main.lean create mode 100644 research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step5.lean diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check5.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check5.lean new file mode 100644 index 0000000000..8f7c589cdd --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Check5.lean @@ -0,0 +1,9 @@ +import CarrierCode.E8Defs5 + +/-! Kernel check of the step-5 (signs) data. -/ + +namespace CarrierCode.E8 + +theorem check5_true : check5 := by decide +kernel + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data5.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data5.lean new file mode 100644 index 0000000000..8512e17be9 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Data5.lean @@ -0,0 +1,80 @@ +/-! Generated by Matarener/Internal local-topology-2026-10-27/e8hand/gen_lean_step5.py. Step 5 (signs) data for +the frame number 0: trees (index 8 * s + s'; per port [parent, depth]), triangle witnesses, first support. -/ + +namespace CarrierCode.E8 + +def fT : Nat := 0 + +def treeData : List (List (List Nat)) := [ + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [29, 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], [1, 1], [74, 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], [1, 1], [74, 3], [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], [80, 2], [29, 2], [80, 2], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [80, 2], [29, 2], [80, 2], [74, 3], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [74, 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], [2, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [28, 2], [0, 0], [28, 2], [0, 0], [43, 3], [0, 0], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [28, 2], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [28, 2], [0, 0], [29, 2], [0, 0], [28, 2], [0, 0], [28, 2], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 3], [0, 0], [2, 1], [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, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 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], [2, 1], [80, 3], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 2], [12, 2], [74, 2], [0, 0], [0, 0], [0, 0], [0, 0], [80, 3], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [74, 2], [12, 2], [74, 2], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [80, 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], [1, 0], [0, 0], [12, 2], [0, 0], [46, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [11, 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], [46, 3], [0, 0], [11, 2], [0, 0], [11, 2], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [11, 2], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [46, 3], [0, 0], [11, 2], [0, 0], [0, 0], [12, 2], [11, 2], [0, 0], [11, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [46, 3], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [61, 2], [0, 0], [22, 2], [4, 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], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 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], [22, 2], [0, 0], [0, 0], [61, 2], [0, 0], [22, 2], [0, 0], [22, 2], [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], [0, 0], [0, 0], [4, 3], [0, 0], [0, 0], [61, 2], [0, 0], [0, 0], [0, 0], [0, 0], [22, 2], [0, 0], [22, 2], [0, 0], [0, 0], [0, 0], [0, 0], [61, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 3], [1, 1], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [85, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 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], [74, 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], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [74, 3], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [85, 2], [49, 2], [85, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [49, 2], [49, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [49, 2], [49, 2], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [74, 3], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [29, 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], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [4, 1], [29, 2], [0, 0], [4, 1], [12, 2], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [43, 3], [29, 2], [0, 0], [4, 1], [12, 2], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [29, 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], [1, 1], [74, 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], [1, 1], [74, 3], [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], [80, 2], [29, 2], [80, 2], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [80, 2], [29, 2], [80, 2], [74, 3], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [74, 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], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 0], [0, 0], [43, 2], [0, 0], [0, 0], [0, 0], [0, 0], [43, 2], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 2], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [7, 1], [39, 2], [0, 0], [43, 2], [0, 0], [0, 0], [39, 2], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [29, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 3], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [85, 3], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 2], [15, 2], [74, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [85, 3], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [74, 2], [15, 2], [74, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [85, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [57, 3], [0, 0], [1, 1], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [57, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 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], [7, 2], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [57, 3], [0, 0], [57, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [7, 2], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [34, 2], [9, 2], [0, 0], [9, 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], [9, 2], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [34, 2], [0, 0], [9, 2], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [34, 2], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [0, 0], [1, 1], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [34, 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], [8, 0], [80, 2], [14, 2], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 3], [8, 1], [74, 3], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [80, 2], [14, 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], [80, 2], [0, 0], [14, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [14, 2], [80, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 3], [8, 1], [74, 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], [8, 0], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [29, 2], [43, 3], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [8, 1], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 3], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [2, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [28, 2], [0, 0], [28, 2], [0, 0], [43, 3], [0, 0], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [28, 2], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [28, 2], [0, 0], [29, 2], [0, 0], [28, 2], [0, 0], [28, 2], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 3], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 0], [0, 0], [43, 2], [0, 0], [0, 0], [0, 0], [0, 0], [43, 2], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 2], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [7, 1], [39, 2], [0, 0], [43, 2], [0, 0], [0, 0], [39, 2], [0, 0], [39, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [29, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 3], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [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, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [2, 1], [0, 0], [2, 1], [53, 3], [2, 1], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [53, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [53, 3], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [16, 2], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0]], + [[0, 0], [0, 0], [2, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [33, 2], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [25, 2], [0, 0], [19, 3], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [14, 2], [0, 0], [14, 2], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [3, 1], [14, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [25, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [0, 0], [14, 2], [0, 0], [14, 2], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [25, 2], [14, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [14, 2], [0, 0], [0, 0], [0, 0], [25, 2], [0, 0], [3, 1], [0, 0], [3, 1], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 0], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [29, 2], [0, 0], [19, 1], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [19, 1], [0, 0], [102, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [102, 2], [0, 0], [19, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 1], [0, 0], [102, 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], [33, 3], [0, 0], [29, 2], [19, 1], [0, 0]], + [[0, 0], [0, 0], [2, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 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], [2, 1], [80, 3], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 2], [12, 2], [74, 2], [0, 0], [0, 0], [0, 0], [0, 0], [80, 3], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [74, 2], [12, 2], [74, 2], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [80, 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], [0, 0], [0, 0], [0, 0], [7, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [85, 3], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 2], [15, 2], [74, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [85, 3], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [74, 2], [15, 2], [74, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [85, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [2, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [2, 1], [0, 0], [2, 1], [53, 3], [2, 1], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [53, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [53, 3], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [16, 2], [0, 0], [0, 0], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [16, 2], [0, 0], [16, 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], [7, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [7, 1], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [40, 3], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [40, 3], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [40, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [7, 1], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [2, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [0, 0], [2, 1], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [20, 2], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 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], [19, 0], [80, 2], [26, 2], [0, 0], [0, 0], [0, 0], [74, 3], [19, 1], [74, 3], [0, 0], [0, 0], [0, 0], [80, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [80, 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], [74, 3], [19, 1], [74, 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], [0, 0], [0, 0], [26, 2], [0, 0], [0, 0], [0, 0], [0, 0], [19, 1], [19, 1], [0, 0], [0, 0], [0, 0], [0, 0], [19, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 2], [80, 2], [26, 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], [12, 0], [19, 3], [0, 0], [21, 2], [0, 0], [12, 1], [0, 0], [17, 2], [0, 0], [12, 1], [0, 0], [0, 0], [0, 0], [12, 1], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 1], [21, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [12, 1], [0, 0], [0, 0], [21, 2], [0, 0], [12, 1], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [19, 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], [17, 2], [0, 0], [19, 3], [0, 0], [0, 0], [21, 2], [0, 0], [12, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [12, 1], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [12, 2], [0, 0], [46, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [11, 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], [46, 3], [0, 0], [11, 2], [0, 0], [11, 2], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [11, 2], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [46, 3], [0, 0], [11, 2], [0, 0], [0, 0], [12, 2], [11, 2], [0, 0], [11, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [46, 3], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [57, 3], [0, 0], [1, 1], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [57, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 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], [7, 2], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [57, 3], [0, 0], [57, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [7, 2], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [7, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 2], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [7, 1], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [40, 3], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [40, 3], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [40, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [7, 1], [0, 0], [0, 0], [7, 1], [0, 0], [7, 1], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [0, 0], [0, 0], [0, 0], [12, 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], [1, 0], [0, 0], [0, 0], [0, 0], [20, 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], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [33, 3], [102, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [102, 2], [0, 0], [20, 2], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [20, 2], [102, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [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]], + [[0, 0], [0, 0], [0, 0], [3, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [3, 1], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [26, 3], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 3], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [26, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [0, 0], [3, 1], [0, 0], [3, 1], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 0], [0, 0], [33, 3], [0, 0], [42, 2], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [13, 2], [0, 0], [0, 0], [33, 3], [0, 0], [13, 2], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [42, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [42, 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], [42, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [13, 2], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [13, 2], [0, 0]], + [[0, 0], [1, 0], [61, 2], [0, 0], [22, 2], [4, 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], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 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], [22, 2], [0, 0], [0, 0], [61, 2], [0, 0], [22, 2], [0, 0], [22, 2], [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], [0, 0], [0, 0], [4, 3], [0, 0], [0, 0], [61, 2], [0, 0], [0, 0], [0, 0], [0, 0], [22, 2], [0, 0], [22, 2], [0, 0], [0, 0], [0, 0], [0, 0], [61, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 3], [1, 1], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [34, 2], [9, 2], [0, 0], [9, 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], [9, 2], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [34, 2], [0, 0], [9, 2], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [34, 2], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [15, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [0, 0], [1, 1], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [34, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [2, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [33, 2], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 3], [0, 0], [0, 0], [33, 2], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0]], + [[0, 0], [0, 0], [2, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [0, 0], [2, 1], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [20, 2], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [31, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [2, 1], [0, 0], [2, 1], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0]], + [[0, 0], [1, 0], [0, 0], [0, 0], [0, 0], [20, 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], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [33, 3], [102, 2], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [102, 2], [0, 0], [20, 2], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [20, 2], [102, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [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]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 2], [0, 0], [26, 2], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [20, 3], [0, 0], [20, 3], [0, 0], [0, 0], [9, 2], [0, 0], [26, 2], [0, 0], [0, 0], [0, 0], [0, 0], [20, 3], [0, 0], [20, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [9, 2], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [42, 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], [15, 2], [4, 1], [42, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 2], [0, 0], [4, 1], [33, 3], [0, 0], [15, 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], [4, 1], [0, 0], [42, 2], [0, 0], [0, 0], [33, 3], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [85, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 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], [74, 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], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [74, 3], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [85, 2], [49, 2], [85, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [49, 2], [49, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [49, 2], [49, 2], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [74, 3], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 0], [80, 2], [14, 2], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 3], [8, 1], [74, 3], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [80, 2], [14, 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], [80, 2], [0, 0], [14, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [14, 2], [80, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [74, 3], [8, 1], [74, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [25, 2], [0, 0], [19, 3], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [14, 2], [0, 0], [14, 2], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [3, 1], [14, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [25, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [0, 0], [14, 2], [0, 0], [14, 2], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [25, 2], [14, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [14, 2], [0, 0], [0, 0], [0, 0], [25, 2], [0, 0], [3, 1], [0, 0], [3, 1], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 0], [80, 2], [26, 2], [0, 0], [0, 0], [0, 0], [74, 3], [19, 1], [74, 3], [0, 0], [0, 0], [0, 0], [80, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [80, 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], [74, 3], [19, 1], [74, 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], [0, 0], [0, 0], [26, 2], [0, 0], [0, 0], [0, 0], [0, 0], [19, 1], [19, 1], [0, 0], [0, 0], [0, 0], [0, 0], [19, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 2], [80, 2], [26, 2], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [3, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [3, 1], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [26, 3], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [0, 0], [0, 0], [20, 2], [0, 0], [20, 2], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 3], [0, 0], [0, 0], [0, 0], [3, 1], [0, 0], [0, 0], [20, 2], [0, 0], [0, 0], [0, 0], [0, 0], [26, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [0, 0], [3, 1], [0, 0], [3, 1], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 2], [0, 0], [26, 2], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [20, 3], [0, 0], [20, 3], [0, 0], [0, 0], [9, 2], [0, 0], [26, 2], [0, 0], [0, 0], [0, 0], [0, 0], [20, 3], [0, 0], [20, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [26, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [9, 2], [0, 0], [9, 2], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [21, 3], [0, 0], [8, 2], [0, 0], [8, 2], [0, 0], [4, 1], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [21, 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], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [21, 3], [0, 0], [8, 2], [0, 0], [4, 1], [0, 0], [19, 2], [4, 1], [0, 0], [8, 2], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [29, 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], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [4, 1], [29, 2], [0, 0], [4, 1], [12, 2], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [43, 3], [29, 2], [0, 0], [4, 1], [12, 2], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 2], [0, 0], [43, 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], [0, 0], [8, 0], [0, 0], [43, 3], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [29, 2], [43, 3], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [8, 1], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [43, 3], [0, 0], [17, 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], [19, 0], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [29, 2], [0, 0], [19, 1], [0, 0], [0, 0], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [29, 2], [19, 1], [0, 0], [102, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [29, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [102, 2], [0, 0], [19, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 1], [0, 0], [102, 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], [33, 3], [0, 0], [29, 2], [19, 1], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 0], [19, 3], [0, 0], [21, 2], [0, 0], [12, 1], [0, 0], [17, 2], [0, 0], [12, 1], [0, 0], [0, 0], [0, 0], [12, 1], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [12, 1], [21, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [19, 3], [0, 0], [17, 2], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [12, 1], [0, 0], [0, 0], [21, 2], [0, 0], [12, 1], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [19, 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], [17, 2], [0, 0], [19, 3], [0, 0], [0, 0], [21, 2], [0, 0], [12, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [17, 2], [0, 0], [12, 1], [0, 0], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 0], [0, 0], [33, 3], [0, 0], [42, 2], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [13, 2], [0, 0], [0, 0], [33, 3], [0, 0], [13, 2], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [42, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [8, 1], [0, 0], [42, 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], [42, 2], [0, 0], [8, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [13, 2], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [13, 2], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [42, 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], [15, 2], [4, 1], [42, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [15, 2], [0, 0], [33, 3], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [42, 2], [0, 0], [4, 1], [33, 3], [0, 0], [15, 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], [4, 1], [0, 0], [42, 2], [0, 0], [0, 0], [33, 3], [0, 0], [15, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0]], + [[0, 0], [0, 0], [0, 0], [0, 0], [4, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [8, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [4, 1], [0, 0], [19, 2], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [21, 3], [0, 0], [8, 2], [0, 0], [8, 2], [0, 0], [4, 1], [0, 0], [4, 1], [0, 0], [0, 0], [0, 0], [8, 2], [0, 0], [21, 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], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [21, 3], [0, 0], [8, 2], [0, 0], [4, 1], [0, 0], [19, 2], [4, 1], [0, 0], [8, 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]]] + +def rootData5 : List Nat := [0, 1, 2, 2, 1, 1, 3, 4, 1, 0, 7, 7, 1, 1, 8, 8, 2, 7, 0, 2, 3, 2, 3, 19, 2, 7, 2, 0, 7, 2, 19, 12, 1, 1, 3, 7, 0, 1, 3, 8, 1, 1, 2, 2, 1, 0, 4, 4, 3, 8, 3, 19, 3, 4, 0, 4, 4, 8, 19, 12, 8, 4, 4, 0] + +def triData : List Nat := [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 74, 1, 1, 74, 29, 0, 29, 0, 2, 3, 2, 3, 29, 0, 74, 2, 0, 12, 2, 74, 12, 0, 1, 3, 12, 0, 1, 3, 12, 0, 1, 2, 2, 1, 0, 4, 4, 0, 74, 3, 74, 3, 4, 0, 4, 0, 29, 29, 12, 12, 4, 4, 0] + +def sup0Data : List Nat := [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 2, 0, 1, 3, 2, 3, 2, 0, 0, 0, 3, 4, 2, 1, 1, 1, 1, 1, 1, 3, 5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 3, 2, 2, 7] + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs5.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs5.lean new file mode 100644 index 0000000000..3dc4dc4d10 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Defs5.lean @@ -0,0 +1,48 @@ +import CarrierCode.E8Defs +import CarrierCode.E8Data5 + +/-! +# Data layer for step 5 (signs) + +`T s` are the ports of the frame `fT`; `En j s = 2 (r_j ⬝ r_{T s}) mod 3` is the frame coordinate of port `j`. +For every ordered pair `(s, s')` a tree (parent, depth) connects the ports meeting both `T s` and `T s'` by edges +`j - k` that are orthogonal, share only `s, s'` and have opposite sign products. +-/ + +namespace CarrierCode.E8 + +def Tn (s : ℕ) : ℕ := frN fT s +def En (j s : ℕ) : ℕ := (2 * dotN j (Tn s)) % 3 +def trP (s s' j : ℕ) : ℕ := ((treeData.getD (8 * s + s') []).getD j []).getD 0 0 +def trD (s s' j : ℕ) : ℕ := ((treeData.getD (8 * s + s') []).getD j []).getD 1 0 +def rt5 (s s' : ℕ) : ℕ := rootData5.getD (8 * s + s') 0 +def triW (s s' : ℕ) : ℕ := triData.getD (8 * s + s') 0 +def sup0 (j : ℕ) : ℕ := sup0Data.getD j 0 + +def treeOK (s s' j : ℕ) : Prop := + (trD s s' j = 0 → j = rt5 s s') ∧ + (trD s s' j ≠ 0 → trP s s' j < 104 ∧ trD s s' (trP s s' j) + 1 = trD s s' j ∧ + En (trP s s' j) s ≠ 0 ∧ En (trP s s' j) s' ≠ 0 ∧ trP s s' j ≠ j ∧ dotN j (trP s s' j) % 3 = 0 ∧ + (∀ u : Fin 8, u.val ≠ s → u.val ≠ s' → (En j u * En (trP s s' j) u) % 3 = 0) ∧ + (En j s * En j s' + En (trP s s' j) s * En (trP s s' j) s') % 3 = 0) + +def c5diag : Prop := ∀ t : Fin 104, dotN t t % 3 = 2 +def c5root : Prop := ∀ s s' : Fin 8, s ≠ s' → rt5 s s' < 104 ∧ En (rt5 s s') s ≠ 0 ∧ En (rt5 s s') s' ≠ 0 +def c5tree : Prop := ∀ s s' : Fin 8, s ≠ s' → ∀ j : Fin 104, En j s ≠ 0 → En j s' ≠ 0 → treeOK s s' j +def c5tri : Prop := ∀ s s' : Fin 8, s.val ≠ 0 → s'.val ≠ 0 → s ≠ s' → + triW s s' < 104 ∧ En (triW s s') 0 ≠ 0 ∧ En (triW s s') s ≠ 0 ∧ En (triW s s') s' ≠ 0 +def c5sup : Prop := ∀ j : Fin 104, sup0 j < 8 ∧ En j (sup0 j) ≠ 0 +def c5gram : Prop := ∀ j k : Fin 104, ((List.range 8).map fun s => En j s * En k s).sum % 3 = (2 * dotN j k) % 3 + +def check5 : Prop := c5diag ∧ c5root ∧ c5tree ∧ c5tri ∧ c5sup ∧ c5gram + +instance (s s' j : ℕ) : Decidable (treeOK s s' j) := by unfold treeOK; infer_instance +instance : Decidable c5diag := by unfold c5diag; infer_instance +instance : Decidable c5root := by unfold c5root; infer_instance +instance : Decidable c5tree := by unfold c5tree; infer_instance +instance : Decidable c5tri := by unfold c5tri; infer_instance +instance : Decidable c5sup := by unfold c5sup; infer_instance +instance : Decidable c5gram := by unfold c5gram; infer_instance +instance : Decidable check5 := by unfold check5; infer_instance + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Main.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Main.lean new file mode 100644 index 0000000000..2f9413a0d3 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Main.lean @@ -0,0 +1,26 @@ +import CarrierCode.E8Checks +import CarrierCode.E8Check4 +import CarrierCode.E8Check5 +import CarrierCode.E8Step5 + +/-! +# Search-free uniqueness of the length-8 decoding code (E8-PROOF.md) + +Let `M` be the 104 × 104 matrix of decoding vectors over `F₃`: `M = A * B` with inner dimension 8 (the code has +dimension at most 8), unit diagonal, and `M i j = 0` whenever ports `i ≠ j` conflict (their E8 roots are +orthogonal). Then `M = D (2 Gm) D` for a diagonal `±1` matrix `D`, where `Gm` is the Gram form of the roots mod 3. +So the decoding vectors, and the code they span, are unique up to signs. + +All finite inputs are checked by the kernel (`decide +kernel`), with no `native_decide`. +-/ + +namespace CarrierCode.E8 + +theorem checks3_true : Checks3 := ⟨framesOK_true, step3_checks⟩ + +theorem decoding_unique (M : Matrix ι ι (ZMod 3)) (A : Matrix ι (Fin 8) (ZMod 3)) (B : Matrix (Fin 8) ι (ZMod 3)) + (h : Hyp M A B) : + ∃ D : ι → ZMod 3, (∀ j, D j * D j = 1) ∧ ∀ j k, M j k = D j * D k * (2 * Gm j k) := + signs h checks3_true step4OK_true check5_true + +end CarrierCode.E8 diff --git a/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step5.lean b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step5.lean new file mode 100644 index 0000000000..cf7cd1beef --- /dev/null +++ b/research/p104-carrier-code-uniqueness/lean/CarrierCode/E8Step5.lean @@ -0,0 +1,270 @@ +import CarrierCode.E8Step4 +import CarrierCode.E8Defs5 + +/-! +# Step 5: signs + +With `M` symmetric, `±1` off the conflict pattern, and `M = M[:, T] M[T, :]` for the frame `T`, the frame +coordinates `X j s = M j (T s)` satisfy `X j s = c_j d_s E j s` where `E j s = 2 r_j ⬝ r_{T s}`. The pair products +`P j s s'` are constant along the checked trees (orthogonality and opposite signs), their triangle products are `1`, +so they form a coboundary `d_s d_s'`. Hence `M = D (2 Gm) D` with `D = ±1`. +-/ + +namespace CarrierCode.E8 + +open Matrix + +variable {M : Matrix ι ι (ZMod 3)} {A : Matrix ι (Fin 8) (ZMod 3)} {B : Matrix (Fin 8) ι (ZMod 3)} + +def fT' : Fin 759 := ⟨fT, by decide⟩ +def T (s : Fin 8) : ι := fr fT s +def E (j : ι) (s : Fin 8) : ZMod 3 := 2 * Gm j (T s) +def X (M : Matrix ι ι (ZMod 3)) (j : ι) (s : Fin 8) : ZMod 3 := M j (T s) +def P (M : Matrix ι ι (ZMod 3)) (j : ι) (s s' : Fin 8) : ZMod 3 := X M j s * X M j s' * E j s * E j s' + +theorem sq_one_of_ne (a : ZMod 3) (h : a ≠ 0) : a * a = 1 := by revert a; decide + +theorem T_val (hF : framesOK) (s : Fin 8) : (T s).val = Tn s := toι_val ((hF fT').2 s s).1 + +theorem En_cast (hF : framesOK) (j : ι) (s : Fin 8) : ((En j s : ℕ) : ZMod 3) = E j s := by + rw [En, cast_mod]; push_cast; rw [dotN_cast, E, Gm, T_val hF] + +theorem E_ne (hF : framesOK) {j : ι} {s : Fin 8} (h : En j s ≠ 0) : E j s ≠ 0 := by + rw [← En_cast hF]; intro e; apply h + have := (cast_eq_zero_iff _).mp e + unfold En at this ⊢; omega + +theorem E_eq (hF : framesOK) {j : ι} {s : Fin 8} (h : En j s = 0) : E j s = 0 := by + rw [← En_cast hF, h, Nat.cast_zero] + +theorem M_symm (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) (j k : ι) : M j k = M k j := by + by_cases hjk : j = k + · subst hjk; rfl + by_cases hz : dotN j k % 3 = 0 + · have g : Gm j k = 0 := by rw [Gm, ← dotN_cast]; exact (cast_eq_zero_iff _).mpr hz + rw [h.conf j k hjk g, h.conf k j (Ne.symm hjk) (by rw [Gm_comm]; exact g)] + · exact (M_symm_pm h hC h4 hz).1.symm + +theorem M_fac (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) (j k : ι) : + M j k = ∑ s, X M j s * X M k s := by + have hm := frame_mat h hC.1 fT' + rw [h.fac] at hm + have e := frame_factor A B (fr fT') hm + rw [← h.fac] at e + rw [congrFun (congrFun e j) k, mul_apply] + refine Finset.sum_congr rfl fun s _ => ?_ + simp only [submatrix_apply, id, X, T] + rw [M_symm h hC h4 (fr fT' s) k]; rfl + +theorem X_sq (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) (h5 : check5) (j : ι) (s : Fin 8) : + X M j s * X M j s = E j s * E j s := by + simp only [X, E] + by_cases hjt : j = T s + · rw [hjt, h.diag] + have hd := h5.1 (T s) + have : Gm (T s) (T s) = 2 := by + rw [Gm, ← dotN_cast, ← cast_mod, hd]; rfl + rw [this]; decide + by_cases hz : dotN j (T s) % 3 = 0 + · have g : Gm j (T s) = 0 := by rw [Gm, ← dotN_cast]; exact (cast_eq_zero_iff _).mpr hz + rw [h.conf j (T s) hjt g, g]; ring + · rw [(M_symm_pm h hC h4 hz).2] + have := sq_one_of_ne _ (Gm_ne hz) + have h3 : (3 : ZMod 3) = 0 := by decide + linear_combination (-4 : ZMod 3) * this - h3 + +section +variable (h : Hyp M A B) (hC : Checks3) (h4 : step4OK) (h5 : check5) +include h hC h4 h5 + +theorem X_zero {j : ι} {s : Fin 8} (hE : E j s = 0) : X M j s = 0 := by + have := X_sq h hC h4 h5 j s + rw [hE, mul_zero] at this + exact mul_self_eq_zero.mp this + +theorem X_one {j : ι} {s : Fin 8} (hE : E j s ≠ 0) : X M j s * X M j s = 1 := by + rw [X_sq h hC h4 h5, sq_one_of_ne _ hE] + +omit h hC h4 h5 in +theorem edge_alg' (a b c d e1 e2 e3 e4 : ZMod 3) (H : a * c + b * d = 0) (Hs : e1 * e2 + e3 * e4 = 0) + (hb : b * b = 1) (hc : c * c = 1) : a * b * e1 * e2 = c * d * e3 * e4 := by + linear_combination e1 * e2 * (b * c * H - a * b * hc - c * d * hb) - c * d * Hs + +/-- One tree edge: orthogonal ports sharing exactly `s, s'` with opposite signs have equal pair products. -/ +theorem edge {j k : ι} {s s' : Fin 8} (hss : s ≠ s') (hjk : k ≠ j) (hort : dotN j k % 3 = 0) + (hks : En k s ≠ 0) (_hks' : En k s' ≠ 0) (_hjs : En j s ≠ 0) (hjs' : En j s' ≠ 0) + (hu : ∀ u : Fin 8, u.val ≠ s.val → u.val ≠ s'.val → (En j u * En k u) % 3 = 0) + (hsg : (En j s * En j s' + En k s * En k s') % 3 = 0) : + P M j s s' = P M k s s' := by + have hF := hC.1 + have hM : M j k = 0 := h.conf j k (Ne.symm hjk) (by rw [Gm, ← dotN_cast]; exact (cast_eq_zero_iff _).mpr hort) + rw [M_fac h hC h4] at hM + rw [Fintype.sum_eq_add s s' hss] at hM + · have hs := congrArg (fun n : ℕ => (n : ZMod 3)) hsg + simp only [cast_mod] at hs + push_cast at hs + simp only [En_cast hF] at hs + exact edge_alg' _ _ _ _ _ _ _ _ hM hs (X_one h hC h4 h5 (E_ne hF hjs')) (X_one h hC h4 h5 (E_ne hF hks)) + · intro u ⟨hu1, hu2⟩ + have e := hu u (fun e => hu1 (Fin.ext e)) (fun e => hu2 (Fin.ext e)) + have e' := congrArg (fun n : ℕ => (n : ZMod 3)) e + simp only [cast_mod] at e' + push_cast at e' + simp only [En_cast hF] at e' + rcases mul_eq_zero.mp e' with z | z + · rw [X_zero h hC h4 h5 z, zero_mul] + · rw [X_zero h hC h4 h5 z, mul_zero] + +/-- Pair products are constant along the trees. -/ +theorem P_const (s s' : Fin 8) (hss : s ≠ s') : + ∀ n, ∀ j : ι, trD s s' j = n → En j s ≠ 0 → En j s' ≠ 0 → P M j s s' = P M (toι (rt5 s s')) s s' := by + intro n + induction n with + | zero => + intro j hd hjs hjs' + have e := (h5.2.2.1 s s' hss j hjs hjs').1 hd + have : toι (rt5 s s') = j := by rw [← e]; exact Fin.ext (toι_val j.isLt) + rw [this] + | succ n ih => + intro j hd hjs hjs' + obtain ⟨hk, hdk, hks, hks', hkj, hort, hu, hsg⟩ := (h5.2.2.1 s s' hss j hjs hjs').2 (by omega) + have ek : ((toι (trP s s' j) : ι) : ℕ) = trP s s' j := toι_val hk + rw [← ek] at hks hks' hkj hort hu hsg hdk + rw [edge h hC h4 h5 hss (fun e => hkj (by rw [e])) hort hks hks' hjs hjs' hu hsg] + exact ih _ (by omega) hks hks' + +def ρ (M : Matrix ι ι (ZMod 3)) (s s' : Fin 8) : ZMod 3 := P M (toι (rt5 s s')) s s' + +theorem P_rho {s s' : Fin 8} (hss : s ≠ s') {j : ι} (hjs : En j s ≠ 0) (hjs' : En j s' ≠ 0) : + P M j s s' = ρ M s s' := P_const h hC h4 h5 s s' hss _ j rfl hjs hjs' + +theorem P_sq {j : ι} {s s' : Fin 8} (hjs : En j s ≠ 0) (hjs' : En j s' ≠ 0) : P M j s s' * P M j s' s = 1 := by + have hF := hC.1 + have a := X_one h hC h4 h5 (E_ne hF hjs); have b := X_one h hC h4 h5 (E_ne hF hjs') + have c := sq_one_of_ne _ (E_ne hF hjs); have d := sq_one_of_ne _ (E_ne hF hjs') + simp only [P] + have : X M j s * X M j s' * E j s * E j s' * (X M j s' * X M j s * E j s' * E j s) = + (X M j s * X M j s) * (X M j s' * X M j s') * (E j s * E j s) * (E j s' * E j s') := by ring + rw [this, a, b, c, d]; ring + +theorem P_tri {j : ι} {s s' s'' : Fin 8} (h1 : En j s ≠ 0) (h2 : En j s' ≠ 0) (h3 : En j s'' ≠ 0) : + P M j s s' * P M j s' s'' * P M j s'' s = 1 := by + have hF := hC.1 + have a := X_one h hC h4 h5 (E_ne hF h1); have b := X_one h hC h4 h5 (E_ne hF h2) + have c := X_one h hC h4 h5 (E_ne hF h3) + have a' := sq_one_of_ne _ (E_ne hF h1); have b' := sq_one_of_ne _ (E_ne hF h2) + have c' := sq_one_of_ne _ (E_ne hF h3) + simp only [P] + have : X M j s * X M j s' * E j s * E j s' * (X M j s' * X M j s'' * E j s' * E j s'') * + (X M j s'' * X M j s * E j s'' * E j s) = + (X M j s * X M j s) * (X M j s' * X M j s') * (X M j s'' * X M j s'') * + (E j s * E j s) * (E j s' * E j s') * (E j s'' * E j s'') := by ring + rw [this, a, b, c, a', b', c']; ring + +theorem rho_symm {s s' : Fin 8} (hss : s ≠ s') : ρ M s s' = ρ M s' s := by + obtain ⟨hr, h1, h2⟩ := h5.2.1 s s' hss + have e : ((toι (rt5 s s') : ι) : ℕ) = rt5 s s' := toι_val hr + rw [← e] at h1 h2 + rw [ρ, ← P_rho h hC h4 h5 (Ne.symm hss) h2 h1] + simp only [P]; ring + +theorem rho_sq {s s' : Fin 8} (hss : s ≠ s') : ρ M s s' * ρ M s s' = 1 := by + obtain ⟨hr, h1, h2⟩ := h5.2.1 s s' hss + have e : ((toι (rt5 s s') : ι) : ℕ) = rt5 s s' := toι_val hr + rw [← e] at h1 h2 + have := P_sq h hC h4 h5 h1 h2 + have hc : P M (toι (rt5 s s')) s' s = P M (toι (rt5 s s')) s s' := by simp only [P]; ring + rw [hc] at this; exact this + +def dd (M : Matrix ι ι (ZMod 3)) (s : Fin 8) : ZMod 3 := if s = 0 then 1 else ρ M 0 s + +theorem dd_sq (s : Fin 8) : dd M s * dd M s = 1 := by + unfold dd; split_ifs with hs + · ring + · exact rho_sq h hC h4 h5 (Ne.symm hs) + +theorem rho_cob {s s' : Fin 8} (hss : s ≠ s') : ρ M s s' = dd M s * dd M s' := by + have hF := hC.1 + by_cases h0 : s = 0 + · subst h0; simp [dd, Ne.symm hss] + by_cases h0' : s' = 0 + · subst h0' + rw [rho_symm h hC h4 h5 hss] + show ρ M 0 s = (if s = 0 then 1 else ρ M 0 s) * (if (0 : Fin 8) = 0 then 1 else ρ M 0 0) + rw [if_neg h0, if_pos rfl, mul_one] + obtain ⟨hw, w0, ws, ws'⟩ := h5.2.2.2.1 s s' (fun e => h0 (Fin.ext e)) (fun e => h0' (Fin.ext e)) hss + have e : ((toι (triW s s') : ι) : ℕ) = triW s s' := toι_val hw + rw [← e] at w0 ws ws' + have p1 := P_rho h hC h4 h5 (Ne.symm h0) w0 ws + have p2 := P_rho h hC h4 h5 hss ws ws' + have p3 := P_rho h hC h4 h5 (Ne.symm h0') w0 ws' + have t := P_tri h hC h4 h5 (s := 0) (s' := s) (s'' := s') w0 ws ws' + have c3 : P M (toι (triW s s')) s' 0 = P M (toι (triW s s')) 0 s' := by simp only [P]; ring + rw [c3, p1, p2, p3] at t + have hp := rho_sq h hC h4 h5 (Ne.symm h0) + have hu := rho_sq h hC h4 h5 (Ne.symm h0') + show ρ M s s' = (if s = 0 then 1 else ρ M 0 s) * (if s' = 0 then 1 else ρ M 0 s') + rw [if_neg h0, if_neg h0'] + generalize ρ M 0 s = a at t hp ⊢ + generalize ρ M 0 s' = b at t hu ⊢ + generalize ρ M s s' = q at t ⊢ + linear_combination a * b * t - q * b * b * hp - q * hu + +def s0 (j : ι) : Fin 8 := ⟨sup0 j % 8, Nat.mod_lt _ (by norm_num)⟩ +def cc (M : Matrix ι ι (ZMod 3)) (j : ι) : ZMod 3 := X M j (s0 j) * E j (s0 j) * dd M (s0 j) + +omit h hC h4 in +theorem s0_ne (j : ι) : En j (s0 j) ≠ 0 := by + obtain ⟨hl, hne⟩ := h5.2.2.2.2.1 j + simp only [s0, Nat.mod_eq_of_lt hl]; exact hne + +theorem X_form (j : ι) (s : Fin 8) : X M j s = cc M j * dd M s * E j s := by + have hF := hC.1 + by_cases hE : En j s = 0 + · rw [X_zero h hC h4 h5 (E_eq hF hE), E_eq hF hE, mul_zero] + have he := sq_one_of_ne _ (E_ne hF hE) + have hd := dd_sq h hC h4 h5 s + by_cases hs : s0 j = s + · rw [cc, hs] + linear_combination (-(X M j s * dd M s * dd M s)) * he - X M j s * hd + · have H := P_rho h hC h4 h5 hs (s0_ne h5 j) hE + rw [rho_cob h hC h4 h5 hs] at H + simp only [P] at H + have hx0 := X_one h hC h4 h5 (E_ne hF (s0_ne h5 j)) + have he0 := sq_one_of_ne _ (E_ne hF (s0_ne h5 j)) + rw [cc] + linear_combination (-(X M j s * E j (s0 j) * E j (s0 j) * E j s * E j s)) * hx0 - + X M j s * E j s * E j s * he0 - X M j s * he + X M j (s0 j) * E j (s0 j) * E j s * H + +theorem cc_sq (j : ι) : cc M j * cc M j = 1 := by + have hF := hC.1 + have a := X_one h hC h4 h5 (E_ne hF (s0_ne h5 j)) + have b := sq_one_of_ne _ (E_ne hF (s0_ne h5 j)) + have c := dd_sq h hC h4 h5 (s0 j) + simp only [cc] + linear_combination (E j (s0 j) * E j (s0 j) * dd M (s0 j) * dd M (s0 j)) * a + + dd M (s0 j) * dd M (s0 j) * b + c + +omit h h4 in +theorem gram (j k : ι) : ∑ s, E j s * E k s = 2 * Gm j k := by + have hF := hC.1 + have e := h5.2.2.2.2.2 j k + rw [sum_range8] at e + have e' := congrArg (fun n : ℕ => (n : ZMod 3)) e + simp only [cast_mod] at e' + push_cast at e' + simp only [En_cast hF] at e' + rw [e', dotN_cast]; rfl + +/-- **Step 5.** Every decoding matrix is `D (2 Gm) D` with `D = ±1`. -/ +theorem signs : ∃ D : ι → ZMod 3, (∀ j, D j * D j = 1) ∧ ∀ j k, M j k = D j * D k * (2 * Gm j k) := by + refine ⟨cc M, cc_sq h hC h4 h5, fun j k => ?_⟩ + rw [M_fac h hC h4, ← gram hC h5, Finset.mul_sum] + refine Finset.sum_congr rfl fun s _ => ?_ + rw [X_form h hC h4 h5 j s, X_form h hC h4 h5 k s] + have hd := dd_sq h hC h4 h5 s + linear_combination cc M j * cc M k * E j s * E k s * hd + +end + +end CarrierCode.E8 From 096938513138868f0ed27639061f1a5054900f96 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 29 Oct 2026 09:37:58 +0000 Subject: [PATCH 11/11] p104 carrier code uniqueness: add search-free E8 proof (e8/) and link the Lean formalization Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011VhYm9RueiYCeCpQh8oBuC --- .../p104-carrier-code-uniqueness/PROOF.md | 10 +- .../p104-carrier-code-uniqueness/README.md | 21 +- .../e8/E8-PROOF.md | 165 +++++++++++++ .../e8/handcert.md | 230 ++++++++++++++++++ .../e8/ports-d8.md | 120 +++++++++ .../e8/ports.json | 1 + .../e8/verify_e8hand.py | 160 ++++++++++++ 7 files changed, 699 insertions(+), 8 deletions(-) create mode 100644 research/p104-carrier-code-uniqueness/e8/E8-PROOF.md create mode 100644 research/p104-carrier-code-uniqueness/e8/handcert.md create mode 100644 research/p104-carrier-code-uniqueness/e8/ports-d8.md create mode 100644 research/p104-carrier-code-uniqueness/e8/ports.json create mode 100644 research/p104-carrier-code-uniqueness/e8/verify_e8hand.py diff --git a/research/p104-carrier-code-uniqueness/PROOF.md b/research/p104-carrier-code-uniqueness/PROOF.md index d8d51f3a2b..37766de9ea 100644 --- a/research/p104-carrier-code-uniqueness/PROOF.md +++ b/research/p104-carrier-code-uniqueness/PROOF.md @@ -191,10 +191,12 @@ block, with `<α_j, β_j> = 1` and `<α_j, β_k> = 0` for orthogonal pairs. The `E8` solution is `α_j = β_j = ε_j`, the sign pattern of the root. This works because `4 ≡ 1` mod 3. -A hand proof of uniqueness is open. Subsystems of three blocks through a pair -of clique points do not force full supports: every probed degenerate support -is locally consistent. So the uniqueness depends on how all 14 blocks fit -together. +Subsystems of three blocks through a pair of clique points do not force full +supports: every probed degenerate support is locally consistent. A proof +without the search must therefore use all of E8 at once. Such a proof is in +[`e8/E8-PROOF.md`](e8/E8-PROOF.md): frame factorisation over all 759 frames, +an A2 triangle argument, and a sign step in one frame. It is formalized in +Lean (`lean/CarrierCode/E8*.lean`). ## 6. Scoped cost corollary diff --git a/research/p104-carrier-code-uniqueness/README.md b/research/p104-carrier-code-uniqueness/README.md index d8bbe25f53..5a5e8af925 100644 --- a/research/p104-carrier-code-uniqueness/README.md +++ b/research/p104-carrier-code-uniqueness/README.md @@ -173,12 +173,25 @@ python3 scripts/check_lean_axioms.py --project research/p104-carrier-code-unique The audit reports `propext`, `Classical.choice` and `Quot.sound` only, for all 14 declarations. -## Open next questions +## Search-free proof via E8 + +[`e8/E8-PROOF.md`](e8/E8-PROOF.md) proves Theorem 3 a second time, without the search. The 104 ports are 104 of +the 120 root lines of E8, and two ports conflict exactly when their roots are orthogonal. The argument has five +steps: frame factorisation `M = M[:,F] M[F,:]`; frame sums of `N = M ∘ Mᵀ`; a linear lemma on each row of `N` +(proved by hand with the tables in [`e8/handcert.md`](e8/handcert.md)); the A2 triangle trick, which makes `M` +symmetric with `±1` entries; and signs, which give `M = D (Gram/2) D`. +[`e8/verify_e8hand.py`](e8/verify_e8hand.py) re-checks the finite inputs in about a minute. -- **A hand proof of uniqueness.** We have no proof that does not rely on the - certificate. PROOF.md §5a reduces the question to 14 blocks of - `S(3,4,8)`, but local subsystems do not force the answer. +The whole argument is also formalized in Lean (`lean/CarrierCode/E8*.lean`, final theorem +`CarrierCode.E8.decoding_unique`). All finite inputs are checked by the kernel, with no `native_decide`, and the +axioms are the standard three. These files are outside the default build target because they are heavy (about +8 GB per step-3 chunk, 35 minutes in total); `e8/E8-PROOF.md` gives the build commands and the exact scope. + +## Open next questions +- **The link from `decoding_unique` to `CodeFact`.** The E8 theorem is stated + for the matrix of decoding vectors. Deriving the word-level `CodeFact` + hypothesis from it (row space and minimum weights) is not formalized. - **Partner codes of dimension 9 or more are not classified.** PR6030 is one, because of a bookkeeping direction. A cheaper design would need carriers that are each cheap but together decode. The clique and cover bounds alone diff --git a/research/p104-carrier-code-uniqueness/e8/E8-PROOF.md b/research/p104-carrier-code-uniqueness/e8/E8-PROOF.md new file mode 100644 index 0000000000..91ef08f375 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/e8/E8-PROOF.md @@ -0,0 +1,165 @@ +# Uniqueness of the length-8 P104 decoding code via E8 (search-free proof) + +Prepared by Matarener with Claude (Anthropic), via Claude Code. 2026-10-29. + +This gives a second proof of Theorem 3 of [`../PROOF.md`](../PROOF.md), without the depth-first search certificate: +a structural argument. The argument has no branching, and every step is elementary. The finite inputs (the port +coordinates, the symmetries and the tables for Lemma V2) are listed in `ports-d8.md` and `handcert.md`, and a reader +can check them line by line. `verify_e8hand.py` re-checks everything with exact arithmetic in about a minute. + +## 0. Setting + +- Ports: 104 odd-weight vectors q in F_2^9. They are 104 of the 120 root lines of E8 (A8 coordinates). A weight-7 q + maps to e_i − e_j, where i, j are its zeros. A weight-3 q maps to 2/3 on its support and −1/3 elsewhere. +- Ports i, j *conflict* ( = 1) exactly when their roots are orthogonal. Below, "x ⊥ y" means conflict. +- Problem: W ≤ F_3^104 has dim 8, and for every port l a vector w_l ∈ W has w_l[l] = 1 and w_l[m] = 0 for all + m ⊥ l. Let M be the 104×104 matrix with rows w_l. We show that M = D·G'·D, where G' = Gram/2 mod 3 of the + roots and D is a diagonal ±1 matrix. So W is unique up to signs, and the decoding vectors are unique. + +**Coordinates mod 3.** E8 = D8 ∪ (D8 + ½·1) in orthonormal coordinates u_1..u_8. Every index involved is a power +of 2, so E8 ⊗ Z_(3) = Z_(3)^8. Roots therefore reduce to vectors of F_3^8 with the standard dot product +(½ ≡ 2). A D8 root ±u_i ± u_j reduces to itself. A half-spin root ½·s, s ∈ {±1}^8, reduces to −s. +Orthogonality is preserved, every root has square 2, and G'[x][y] = (r_x·r_y)/2 ≡ −r_x·r_y. + +**Structure of the ports (V1).** The ports contain exactly one D8 subsystem, and contain all 56 of its lines. The +other 48 ports are half-spin lines; 16 of the 64 half-spin lines are missing (listed by `verify_e8hand.py`). There +are 759 frames, that is, sets of 8 pairwise orthogonal ports. + +E8 facts used: (a) a root not in a frame F is non-orthogonal to exactly 4 members of F. (b) In frame coordinates, +every other root is ½(±r_a ± r_b ± r_c ± r_d) over a block {a,b,c,d} of the Steiner system S(3,4,8) on F. +(c) For every frame, Σ_{f∈F} (a·r_f)(r_f·b) = 2·(a·b) for all a, b, since r_f/√2 is an orthonormal basis. + +## 1. Frame factorisation (hand) + +For every frame F, M[F,F] = I, because of the diagonal and the conflict zeros. Since rank M ≤ 8, + + M = M[:,F] · M[F,:] for every frame F. (1) + +## 2. The symmetric matrix N (hand) + +Let N[t][x] = M[t][x]·M[x][t]. Then N is symmetric, N[t][t] = 1, and N[t][x] = 0 for x ⊥ t. The diagonal entry of +(1) gives + + Σ_{x∈F} N[t][x] = 1 for every port t and every frame F. (2) + +If t ∉ F, only the 4 members of F that are non-orthogonal to t contribute, by fact (a). + +## 3. Linear lemma (elementary, with tables) + +Fix t and let N(t) be the 48 ports that are non-orthogonal to t. Put h_t(x) = N[t][x] − 1 for x ∈ N(t). By (2), +the four values on F ∩ N(t) sum to 1 − 4 ≡ 0 for every frame F ∌ t. Call such a set of four a *quadruple*. + +For v ∈ r_t^⊥ (mod 3), the functions g_v(x) = (r_x·r_t)(r_x·v) satisfy every quadruple relation, by fact (c). They +form a 7-dimensional family. **Lemma V2**: every h with all quadruple relations is some g_v. Hence + + N[t][x] = 1 + (r_t·r_x)(r_x·v_t) for a unique v_t ∈ r_t^⊥ (mod 3). (3) + +*Proof.* By symmetry it suffices to treat one port per orbit. The three signed permutations of the D8 axes in +`ports-d8.md` map the missing lines to themselves, so they map ports to ports and frames to frames. They have three +orbits on ports, represented by p0, p22 and p28. For each representative the proof uses only the tables in +`handcert.md`. + +For x ∈ N(t), let x̄ be the third line of the A2 through t and x, so r_x̄ = ±(r_t − r_x). The reflection s_t in +r_t is an isometry of E8. It fixes every root orthogonal to t and swaps the lines x and x̄. So for a frame F ∌ t, +s_t(F) is again a frame, and its quadruple is the set of antipodes of the quadruple of F. + +1. *Even part.* For each antipodal pair p = {x, x̄} of ports, put σ(p) = h(x) + h(x̄). Suppose F and s_t(F) are + both port frames; the tables list them. Adding their two quadruple relations gives σ(p1) + … + σ(p4) = 0 over + the four pairs. Call this a *tetrad*. + Now take tetrads A = {p, q, a, b}, B = {p, q, c, d} and C = {a, b, c, d}. Then A + B − C gives + 2(σ(p) + σ(q)) = 0, so σ(p) = −σ(q). + The tables give such edges forming a spanning tree of all 20–21 pairs, plus one triangle. Around the triangle, + σ(p) = −σ(q) = σ(s) = −σ(p), so 2σ(p) = 0 and σ(p) = 0. Along the tree, σ = 0 on every pair. So h(x̄) = −h(x) + whenever both are ports. +2. *Odd closure.* Take 7 seeds whose roots, together with r_t, are independent mod 3. Each table step fixes one more + value of h, either by the antipode rule or by a quadruple with three known values. After 41 steps every value on + N(t) is a fixed linear combination of the 7 seed values. So the solution space has dimension at most 7. It + contains the 7-dimensional family g_v, so the two are equal. ∎ + +`verify_e8hand.py` (V2) re-checks the rank, 41 for every port, as an independent cross-check. + +## 4. Symmetry and A2 triangles kill v_t (hand + V3) + +Fix a root representative r_a for every port a. Because N is symmetric and r_a·r_b = ±1 for non-orthogonal a, b, +(3) gives + + r_b·v_a = r_a·v_b for all non-orthogonal ports a, b. (4) + +Let {t, x, y} be an A2 triangle of ports. Choose signs so that r_t·r_x = 1 and r_y = r_t − r_x. Then +r_y·r_t = 1 and r_y·r_x = −1. Using (4) together with v_a ⊥ r_a: + + r_y·v_t = (r_t − r_x)·v_t = −r_x·v_t, + r_y·v_t = r_t·v_y = (r_x + r_y)·v_y = r_x·v_y = r_y·v_x = (r_t − r_x)·v_x = r_t·v_x = r_x·v_t. + +So 2·(r_x·v_t) = 0, which gives r_x·v_t = 0 in characteristic 3. + +**V3**: for every port t, r_t and the r_x with x ∈ N(t) whose A2 third line is a port span F_3^8. (There are 40 +or 42 such x.) Hence v_t = 0 and N[t][x] = 1 for every non-orthogonal pair. Equivalently, + + M[t][x] = M[x][t] ∈ {±1} for x non-orthogonal to t. (5) + +So M is symmetric with exactly the E8 zero pattern. (V4 cross-checks steps 3–4 as one linear system.) + +## 5. Signs (hand + V5) + +Take the D8 matching frame T. By (b), every non-T port j is ½Σ_{t∈B_j} ε_j(t) r_t over a block B_j. Put +α_j(t) = M[j][t] for t ∈ B_j. These are ±1 by (5), and M[t][j] = α_j(t). + +For a pair {a, b} ⊂ T, three blocks contain it. A line j in one of them has σ_ab(j) = ε_j(a)ε_j(b). Take two lines +j, k in different blocks through {a, b} with σ_ab(j) ≠ σ_ab(k). They are orthogonal, and the only common frame +coordinates are a and b. So (1) gives α_j(a)α_k(a) + α_j(b)α_k(b) = 0, that is, +α_j(a)α_j(b) = −α_k(a)α_k(b). + +By V5, every block through {a, b} has ports of both signs. Hence ρ_s(ab) := α_j(a)α_j(b) depends only on +s = σ_ab(j), and ρ_−(ab) = −ρ_+(ab). So α_j(a)α_j(b) = σ_ab(j)·ρ_+(ab). + +Around a triangle a, b, c, take a port of the block through a, b, c. The product of its three pair products is 1, +and so is the product of its σ's. Hence ρ_+(ab)ρ_+(bc)ρ_+(ca) = 1. A function on the pairs of 8 points whose +product around every triangle is 1 is a coboundary: ρ_+(ab) = d_a d_b with d_t = ±1. Therefore +α_j(t) = c_j d_t ε_j(t) for some sign c_j. + +Now (1) gives M[j][k] = Σ_t α_j(t)α_k(t) = c_j c_k Σ_{t∈B_j∩B_k} ε_j(t)ε_k(t). This equals c_j c_k G'[j][k], +because G' = r·r/2 = ¼Σεε ≡ Σεε mod 3. Also M[j][t] = c_j d_t ε_j(t) = −c_j d_t G'[j][t]. With D_j = c_j off T and +D_t = −d_t on T, we get M = D G' D. ∎ + +## What is checked by a script + +None of the hand steps depends on a computer. The finite inputs are tables a reader can check line by line: + +- the port coordinates and symmetry generators in `ports-d8.md`; +- the tetrads, edges and closure steps in `handcert.md`; +- the A2 span (V3) and the availability fact (V5). + +`verify_e8hand.py` re-checks all of these (V1–V5) with exact arithmetic and no search, in about a minute +(`python3 -B verify_e8hand.py`, final line `RESULT PASS`). + +## Lean formalization + +The whole argument is formalized in [`../lean/CarrierCode/E8*.lean`](../lean/CarrierCode). The final theorem +`CarrierCode.E8.decoding_unique` in `E8Main.lean` states: if a 104 × 104 matrix `M` over `ZMod 3` factors as +`A * B` with inner dimension 8, has unit diagonal, and vanishes on conflicting pairs (orthogonal roots), then +`M = D (2 Gm) D` for a diagonal `±1` matrix `D`, where `Gm` is the Gram form of the roots mod 3. + +- `E8.lean`: the general steps (frame factorisation, frame sums, coboundary). +- `E8Step3.lean`, `E8Step4.lean`, `E8Step5.lean`: steps 3–5, including the general A2 trick. +- `E8Data*.lean`, `E8Cert.lean`: the finite inputs as lists of naturals (roots mod 3, the 759 frames, the step-3 + certificates, the A2 triangles with inverse matrices, the sign trees). Every property used is re-checked by the + kernel (`decide +kernel` in `E8Check*.lean`), so the provenance of these lists does not matter. +- No `native_decide`. `#print axioms CarrierCode.E8.decoding_unique` gives `propext`, `Classical.choice` and + `Quot.sound` only. + +The E8 files are not imported by the default target, because the step-3 checks are heavy: each `E8Check3_k` needs +about 8 GB of memory and 3 minutes. Build them one at a time: + +```sh +cd research/p104-carrier-code-uniqueness/lean && lake exe cache get +for t in E8CheckFrames E8Check3_0 E8Check3_1 E8Check3_2 E8Check3_3 E8Check3_4 E8Check3_5 E8Check3_6 E8Check3_7 \ + E8Check4 E8Check5 E8Main; do lake build CarrierCode.$t || break; done +``` + +A full sequential build took about 35 minutes on a 4-core, 31 GB machine. + +Scope: the theorem is stated for the port order of `E8Data.lean`, which is the order of [`ports.json`](ports.json) +(odd-weight vectors of F_2^9 as integers), and for a +matrix `M` of decoding vectors. The link to the word-level `CodeFact` hypothesis of `../lean` (where the code is +the row space of `M`) is not formalized, and the weight part of `CodeFact` is still checked by `verify.py`. diff --git a/research/p104-carrier-code-uniqueness/e8/handcert.md b/research/p104-carrier-code-uniqueness/e8/handcert.md new file mode 100644 index 0000000000..a98809ea84 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/e8/handcert.md @@ -0,0 +1,230 @@ +# Tables for Lemma V2 (generated by handcert.py) + +Ports are named p0..p103 by their position in ports.json. For each orbit representative t: N(t), antipodal pairs, tetrads, the sigma-graph certificate and the odd closure. + +## t = p0 (orbit of size 32) + +N(t): p1, p2, p3, p4, p5, p11, p12, p13, p22, p28, p29, p30, p43, p44, p45, p46, p47, p48, p49, p50, p51, p61, p62, p63, p64, p65, p66, p67, p68, p69, p71, p73, p74, p75, p76, p77, p78, p80, p81, p82, p83, p84, p85, p90, p91, p92, p93, p94 + +Antipodal pairs (both ports): P0={p1,p90}, P1={p2,p91}, P2={p3,p93}, P3={p4,p94}, P4={p5,p78}, P5={p11,p81}, P6={p12,p82}, P7={p13,p84}, P8={p22,p71}, P9={p28,p73}, P10={p29,p75}, P11={p30,p76}, P12={p43,p69}, P13={p44,p68}, P14={p45,p67}, P15={p46,p66}, P16={p47,p65}, P17={p48,p64}, P18={p49,p63}, P19={p50,p62}, P20={p51,p61} + +Odd triangle: P0, P4, P13. + +Edges (sigma_p = -sigma_q), each from tetrads A, B sharing {p,q} and C = A xor B: + +- P0 ~ P1: A={P0,P1,P14,P17} [F=p1 p8 p21 p26 p37 p45 p64 p91; s_t F=p2 p8 p21 p26 p37 p48 p67 p90]; B={P0,P1,P13,P16} [F=p1 p8 p21 p27 p36 p44 p65 p91; s_t F=p2 p8 p21 p27 p36 p47 p68 p90]; C={P13,P14,P16,P17} [F=p8 p14 p21 p44 p48 p65 p67 p79; s_t F=p8 p14 p21 p45 p47 p64 p68 p79] +- P0 ~ P2: A={P0,P2,P14,P20} [F=p1 p7 p20 p25 p35 p45 p61 p93; s_t F=p3 p7 p20 p25 p35 p51 p67 p90]; B={P0,P2,P12,P18} [F=p1 p7 p20 p27 p34 p43 p63 p93; s_t F=p3 p7 p20 p27 p34 p49 p69 p90]; C={P12,P14,P18,P20} [F=p7 p16 p20 p43 p51 p63 p67 p79; s_t F=p7 p16 p20 p45 p49 p61 p69 p79] +- P0 ~ P3: A={P0,P3,P12,P19} [F=p1 p7 p19 p26 p34 p43 p62 p94; s_t F=p4 p7 p19 p26 p34 p50 p69 p90]; B={P0,P3,P13,P20} [F=p1 p8 p18 p24 p36 p44 p61 p94; s_t F=p4 p8 p18 p24 p36 p51 p68 p90]; C={P12,P13,P19,P20} [F=p7 p17 p19 p43 p51 p62 p68 p79; s_t F=p7 p17 p19 p44 p50 p61 p69 p79] +- P0 ~ P4: A={P0,P4,P11,P13} [F=p1 p5 p18 p24 p30 p44 p52 p103; s_t F=p18 p24 p52 p68 p76 p78 p90 p103]; B={P0,P4,P10,P12} [F=p1 p5 p19 p26 p29 p43 p54 p101; s_t F=p19 p26 p54 p69 p75 p78 p90 p101]; C={P10,P11,P12,P13} [F=p24 p29 p33 p42 p43 p52 p68 p76; s_t F=p24 p30 p33 p42 p44 p52 p69 p75] +- P0 ~ P5: A={P0,P5,P11,P19} [F=p1 p9 p11 p24 p30 p39 p62 p103; s_t F=p9 p24 p39 p50 p76 p81 p90 p103]; B={P0,P5,P10,P20} [F=p1 p11 p20 p29 p35 p55 p61 p88; s_t F=p20 p35 p51 p55 p75 p81 p88 p90]; C={P10,P11,P19,P20} [F=p19 p29 p50 p61 p76 p79 p89 p95; s_t F=p19 p30 p51 p62 p75 p79 p89 p95] +- P0 ~ P6: A={P0,P6,P8,P12} [F=p1 p9 p12 p22 p36 p43 p54 p101; s_t F=p9 p36 p54 p69 p71 p82 p90 p101]; B={P0,P6,P11,P17} [F=p1 p9 p12 p25 p30 p39 p64 p101; s_t F=p9 p25 p39 p48 p76 p82 p90 p101]; C={P8,P11,P12,P17} [F=p9 p22 p43 p48 p76 p79 p96 p101; s_t F=p9 p30 p64 p69 p71 p79 p96 p101] +- P0 ~ P7: A={P0,P7,P8,P14} [F=p1 p7 p13 p22 p35 p45 p52 p102; s_t F=p7 p35 p52 p67 p71 p84 p90 p102]; B={P0,P7,P10,P16} [F=p1 p8 p13 p27 p29 p39 p65 p100; s_t F=p8 p27 p39 p47 p75 p84 p90 p100]; C={P8,P10,P14,P16} [F=p8 p22 p45 p47 p75 p79 p98 p100; s_t F=p8 p29 p65 p67 p71 p79 p98 p100] +- P0 ~ P8: A={P0,P7,P8,P14} [F=p1 p7 p13 p22 p35 p45 p52 p102; s_t F=p7 p35 p52 p67 p71 p84 p90 p102]; B={P0,P6,P8,P12} [F=p1 p9 p12 p22 p36 p43 p54 p101; s_t F=p9 p36 p54 p69 p71 p82 p90 p101]; C={P6,P7,P12,P14} [F=p7 p12 p16 p41 p43 p52 p67 p84; s_t F=p7 p13 p16 p41 p45 p52 p69 p82] +- P0 ~ P10: A={P0,P4,P10,P12} [F=p1 p5 p19 p26 p29 p43 p54 p101; s_t F=p19 p26 p54 p69 p75 p78 p90 p101]; B={P0,P7,P10,P16} [F=p1 p8 p13 p27 p29 p39 p65 p100; s_t F=p8 p27 p39 p47 p75 p84 p90 p100]; C={P4,P7,P12,P16} [F=p5 p27 p43 p47 p72 p84 p96 p100; s_t F=p13 p27 p65 p69 p72 p78 p96 p100] +- P0 ~ P11: A={P0,P4,P11,P13} [F=p1 p5 p18 p24 p30 p44 p52 p103; s_t F=p18 p24 p52 p68 p76 p78 p90 p103]; B={P0,P5,P11,P19} [F=p1 p9 p11 p24 p30 p39 p62 p103; s_t F=p9 p24 p39 p50 p76 p81 p90 p103]; C={P4,P5,P13,P19} [F=p5 p15 p21 p44 p50 p55 p58 p81; s_t F=p11 p15 p21 p55 p58 p62 p68 p78] +- P0 ~ P12: A={P0,P4,P10,P12} [F=p1 p5 p19 p26 p29 p43 p54 p101; s_t F=p19 p26 p54 p69 p75 p78 p90 p101]; B={P0,P3,P12,P19} [F=p1 p7 p19 p26 p34 p43 p62 p94; s_t F=p4 p7 p19 p26 p34 p50 p69 p90]; C={P3,P4,P10,P19} [F=p4 p5 p15 p23 p29 p50 p55 p100; s_t F=p15 p23 p55 p62 p75 p78 p94 p100] +- P0 ~ P13: A={P0,P4,P11,P13} [F=p1 p5 p18 p24 p30 p44 p52 p103; s_t F=p18 p24 p52 p68 p76 p78 p90 p103]; B={P0,P3,P13,P20} [F=p1 p8 p18 p24 p36 p44 p61 p94; s_t F=p4 p8 p18 p24 p36 p51 p68 p90]; C={P3,P4,P11,P20} [F=p4 p5 p16 p23 p30 p51 p55 p99; s_t F=p16 p23 p55 p61 p76 p78 p94 p99] +- P0 ~ P14: A={P0,P7,P8,P14} [F=p1 p7 p13 p22 p35 p45 p52 p102; s_t F=p7 p35 p52 p67 p71 p84 p90 p102]; B={P0,P2,P14,P20} [F=p1 p7 p20 p25 p35 p45 p61 p93; s_t F=p3 p7 p20 p25 p35 p51 p67 p90]; C={P2,P7,P8,P20} [F=p3 p6 p13 p22 p33 p51 p54 p99; s_t F=p6 p33 p54 p61 p71 p84 p93 p99] +- P0 ~ P15: A={P0,P7,P11,P15} [F=p1 p9 p13 p27 p30 p39 p66 p99; s_t F=p9 p27 p39 p46 p76 p84 p90 p99]; B={P0,P1,P12,P15} [F=p1 p9 p20 p27 p36 p43 p66 p91; s_t F=p2 p9 p20 p27 p36 p46 p69 p90]; C={P1,P7,P11,P12} [F=p2 p9 p13 p27 p30 p40 p69 p96; s_t F=p9 p27 p40 p43 p76 p84 p91 p96] +- P0 ~ P16: A={P0,P7,P10,P16} [F=p1 p8 p13 p27 p29 p39 p65 p100; s_t F=p8 p27 p39 p47 p75 p84 p90 p100]; B={P0,P1,P13,P16} [F=p1 p8 p21 p27 p36 p44 p65 p91; s_t F=p2 p8 p21 p27 p36 p47 p68 p90]; C={P1,P7,P10,P13} [F=p2 p8 p13 p27 p29 p40 p68 p97; s_t F=p8 p27 p40 p44 p75 p84 p91 p97] +- P0 ~ P17: A={P0,P1,P14,P17} [F=p1 p8 p21 p26 p37 p45 p64 p91; s_t F=p2 p8 p21 p26 p37 p48 p67 p90]; B={P0,P6,P11,P17} [F=p1 p9 p12 p25 p30 p39 p64 p101; s_t F=p9 p25 p39 p48 p76 p82 p90 p101]; C={P1,P6,P11,P14} [F=p2 p9 p12 p25 p30 p40 p67 p98; s_t F=p9 p25 p40 p45 p76 p82 p91 p98] +- P0 ~ P19: A={P0,P3,P12,P19} [F=p1 p7 p19 p26 p34 p43 p62 p94; s_t F=p4 p7 p19 p26 p34 p50 p69 p90]; B={P0,P5,P11,P19} [F=p1 p9 p11 p24 p30 p39 p62 p103; s_t F=p9 p24 p39 p50 p76 p81 p90 p103]; C={P3,P5,P11,P12} [F=p4 p9 p11 p24 p30 p42 p69 p96; s_t F=p9 p24 p42 p43 p76 p81 p94 p96] +- P0 ~ P20: A={P0,P2,P14,P20} [F=p1 p7 p20 p25 p35 p45 p61 p93; s_t F=p3 p7 p20 p25 p35 p51 p67 p90]; B={P0,P3,P13,P20} [F=p1 p8 p18 p24 p36 p44 p61 p94; s_t F=p4 p8 p18 p24 p36 p51 p68 p90]; C={P2,P3,P13,P14} [F=p3 p7 p15 p25 p31 p44 p67 p94; s_t F=p4 p7 p15 p25 p31 p45 p68 p93] +- P4 ~ P13: A={P0,P4,P11,P13} [F=p1 p5 p18 p24 p30 p44 p52 p103; s_t F=p18 p24 p52 p68 p76 p78 p90 p103]; B={P2,P4,P9,P13} [F=p3 p5 p14 p24 p28 p44 p56 p103; s_t F=p14 p24 p56 p68 p73 p78 p93 p103]; C={P0,P2,P9,P11} [F=p1 p24 p30 p37 p73 p86 p93 p103; s_t F=p3 p24 p28 p37 p76 p86 p90 p103] +- P9 ~ P15: A={P2,P7,P9,P15} [F=p3 p6 p13 p27 p28 p41 p66 p99; s_t F=p6 p27 p41 p46 p73 p84 p93 p99]; B={P8,P9,P15,P20} [F=p22 p35 p36 p46 p51 p56 p59 p73; s_t F=p28 p35 p36 p56 p59 p61 p66 p71]; C={P2,P7,P8,P20} [F=p3 p6 p13 p22 p33 p51 p54 p99; s_t F=p6 p33 p54 p61 p71 p84 p93 p99] +- P15 ~ P18: A={P1,P2,P15,P18} [F=p2 p10 p15 p23 p37 p46 p63 p93; s_t F=p3 p10 p15 p23 p37 p49 p66 p91]; B={P15,P17,P18,P20} [F=p6 p18 p20 p46 p51 p63 p64 p79; s_t F=p6 p18 p20 p48 p49 p61 p66 p79]; C={P1,P2,P17,P20} [F=p2 p6 p20 p25 p33 p48 p61 p93; s_t F=p3 p6 p20 p25 p33 p51 p64 p91] + +Odd closure. Seeds: p30, p28, p83, p66, p74, p90, p61 (their roots and r_t are independent mod 3). + +- p1 = -p90 (antipode) +- p76 = -p30 (antipode) +- p46 = -p66 (antipode) +- p51 = -p61 (antipode) +- p73 = -p28 (antipode) +- p13 from quadruple {p1, p13, p30, p66} +- p85 from quadruple {p1, p61, p66, p85} +- p22 from quadruple {p1, p22, p73, p85} +- p93 from quadruple {p1, p30, p73, p93} +- p45 from quadruple {p1, p45, p61, p93} +- p2 from quadruple {p2, p22, p74, p85} +- p63 from quadruple {p2, p46, p63, p93} +- p48 from quadruple {p2, p48, p61, p93} +- p3 from quadruple {p3, p13, p22, p51} +- p94 from quadruple {p3, p13, p83, p94} +- p67 from quadruple {p3, p51, p67, p90} +- p5 from quadruple {p5, p45, p46, p83} +- p80 from quadruple {p5, p46, p51, p80} +- p49 from quadruple {p5, p48, p49, p80} +- p81 from quadruple {p5, p45, p49, p81} +- p43 from quadruple {p5, p43, p48, p83} +- p71 from quadruple {p5, p28, p71, p80} +- p11 from quadruple {p11, p46, p63, p83} +- p82 from quadruple {p13, p51, p63, p82} +- p50 from quadruple {p13, p50, p66, p81} +- p64 from quadruple {p46, p51, p63, p64} +- p47 from quadruple {p22, p47, p50, p73} +- p91 from quadruple {p50, p73, p83, p91} +- p84 from quadruple {p49, p73, p84, p91} +- p65 from quadruple {p65, p71, p81, p93} +- p92 from quadruple {p63, p71, p83, p92} +- p62 from quadruple {p62, p71, p84, p92} +- p12 from quadruple {p12, p49, p61, p84} +- p68 from quadruple {p12, p43, p68, p83} +- p69 from quadruple {p13, p45, p69, p82} +- p44 from quadruple {p44, p50, p63, p67} +- p75 from quadruple {p22, p44, p48, p75} +- p29 from quadruple {p29, p64, p68, p71} +- p77 from quadruple {p22, p43, p47, p77} +- p78 from quadruple {p11, p63, p67, p78} +- p4 = -p94 (antipode) + +## t = p22 (orbit of size 48) + +N(t): p0, p5, p14, p15, p16, p17, p18, p19, p20, p21, p23, p24, p25, p26, p27, p28, p29, p30, p39, p40, p41, p42, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p80, p81, p82, p83, p84, p86, p87, p88, p89, p90, p91, p92, p93, p94 + +Antipodal pairs (both ports): P0={p0,p71}, P1={p5,p70}, P2={p15,p69}, P3={p16,p68}, P4={p17,p67}, P5={p18,p65}, P6={p19,p63}, P7={p20,p62}, P8={p21,p61}, P9={p23,p90}, P10={p24,p91}, P11={p25,p92}, P12={p26,p93}, P13={p27,p94}, P14={p29,p87}, P15={p30,p88}, P16={p39,p80}, P17={p40,p81}, P18={p41,p83}, P19={p42,p84} + +Odd triangle: P0, P5, P19. + +Edges (sigma_p = -sigma_q), each from tetrads A, B sharing {p,q} and C = A xor B: + +- P0 ~ P3: A={P0,P3,P12,P16} [F=p0 p7 p16 p26 p31 p39 p56 p103; s_t F=p7 p31 p56 p68 p71 p80 p93 p103]; B={P0,P3,P9,P18} [F=p0 p8 p16 p23 p36 p41 p53 p101; s_t F=p8 p36 p53 p68 p71 p83 p90 p101]; C={P9,P12,P16,P18} [F=p7 p23 p41 p50 p74 p80 p93 p103; s_t F=p7 p26 p39 p50 p74 p83 p90 p103] +- P0 ~ P4: A={P0,P4,P9,P19} [F=p0 p7 p17 p23 p35 p42 p52 p102; s_t F=p7 p35 p52 p67 p71 p84 p90 p102]; B={P0,P4,P13,P16} [F=p0 p7 p17 p27 p31 p39 p57 p102; s_t F=p7 p31 p57 p67 p71 p80 p94 p102]; C={P9,P13,P16,P19} [F=p7 p23 p42 p49 p74 p80 p94 p102; s_t F=p7 p27 p39 p49 p74 p84 p90 p102] +- P0 ~ P5: A={P0,P5,P10,P18} [F=p0 p6 p18 p24 p32 p41 p52 p103; s_t F=p6 p32 p52 p65 p71 p83 p91 p103]; B={P0,P5,P12,P17} [F=p0 p6 p18 p26 p31 p40 p54 p103; s_t F=p6 p31 p54 p65 p71 p81 p93 p103]; C={P10,P12,P17,P18} [F=p6 p24 p41 p50 p73 p81 p93 p103; s_t F=p6 p26 p40 p50 p73 p83 p91 p103] +- P0 ~ P8: A={P0,P8,P12,P19} [F=p0 p6 p21 p26 p33 p42 p54 p99; s_t F=p6 p33 p54 p61 p71 p84 p93 p99]; B={P0,P8,P13,P18} [F=p0 p6 p21 p27 p32 p41 p55 p99; s_t F=p6 p32 p55 p61 p71 p83 p94 p99]; C={P12,P13,P18,P19} [F=p6 p26 p42 p46 p73 p83 p94 p99; s_t F=p6 p27 p41 p46 p73 p84 p93 p99] +- P0 ~ P9: A={P0,P4,P9,P19} [F=p0 p7 p17 p23 p35 p42 p52 p102; s_t F=p7 p35 p52 p67 p71 p84 p90 p102]; B={P0,P3,P9,P18} [F=p0 p8 p16 p23 p36 p41 p53 p101; s_t F=p8 p36 p53 p68 p71 p83 p90 p101]; C={P3,P4,P18,P19} [F=p7 p12 p16 p41 p43 p52 p67 p84; s_t F=p7 p12 p17 p42 p43 p52 p68 p83] +- P0 ~ P11: A={P0,P6,P11,P18} [F=p0 p6 p19 p25 p32 p41 p53 p101; s_t F=p6 p32 p53 p63 p71 p83 p92 p101]; B={P0,P7,P11,P19} [F=p0 p6 p20 p25 p33 p42 p53 p100; s_t F=p6 p33 p53 p62 p71 p84 p92 p100]; C={P6,P7,P18,P19} [F=p6 p11 p19 p41 p46 p53 p62 p84; s_t F=p6 p11 p20 p42 p46 p53 p63 p83] +- P0 ~ P12: A={P0,P5,P12,P17} [F=p0 p6 p18 p26 p31 p40 p54 p103; s_t F=p6 p31 p54 p65 p71 p81 p93 p103]; B={P0,P8,P12,P19} [F=p0 p6 p21 p26 p33 p42 p54 p99; s_t F=p6 p33 p54 p61 p71 p84 p93 p99]; C={P5,P8,P17,P19} [F=p6 p12 p18 p40 p49 p54 p61 p84; s_t F=p6 p12 p21 p42 p49 p54 p65 p81] +- P0 ~ P13: A={P0,P8,P13,P18} [F=p0 p6 p21 p27 p32 p41 p55 p99; s_t F=p6 p32 p55 p61 p71 p83 p94 p99]; B={P0,P4,P13,P16} [F=p0 p7 p17 p27 p31 p39 p57 p102; s_t F=p7 p31 p57 p67 p71 p80 p94 p102]; C={P4,P8,P16,P18} [F=p7 p12 p17 p39 p50 p57 p61 p83; s_t F=p7 p12 p21 p41 p50 p57 p67 p80] +- P0 ~ P16: A={P0,P3,P12,P16} [F=p0 p7 p16 p26 p31 p39 p56 p103; s_t F=p7 p31 p56 p68 p71 p80 p93 p103]; B={P0,P4,P13,P16} [F=p0 p7 p17 p27 p31 p39 p57 p102; s_t F=p7 p31 p57 p67 p71 p80 p94 p102]; C={P3,P4,P12,P13} [F=p16 p26 p60 p67 p73 p78 p94 p99; s_t F=p17 p27 p60 p68 p73 p78 p93 p99] +- P0 ~ P18: A={P0,P5,P10,P18} [F=p0 p6 p18 p24 p32 p41 p52 p103; s_t F=p6 p32 p52 p65 p71 p83 p91 p103]; B={P0,P6,P11,P18} [F=p0 p6 p19 p25 p32 p41 p53 p101; s_t F=p6 p32 p53 p63 p71 p83 p92 p101]; C={P5,P6,P10,P11} [F=p1 p10 p18 p24 p38 p44 p63 p92; s_t F=p1 p10 p19 p25 p38 p44 p65 p91] +- P0 ~ P19: A={P0,P7,P11,P19} [F=p0 p6 p20 p25 p33 p42 p53 p100; s_t F=p6 p33 p53 p62 p71 p84 p92 p100]; B={P0,P8,P12,P19} [F=p0 p6 p21 p26 p33 p42 p54 p99; s_t F=p6 p33 p54 p61 p71 p84 p93 p99]; C={P7,P8,P11,P12} [F=p1 p7 p20 p25 p35 p45 p61 p93; s_t F=p1 p7 p21 p26 p35 p45 p62 p92] +- P1 ~ P9: A={P1,P3,P9,P15} [F=p2 p5 p16 p23 p30 p47 p52 p103; s_t F=p2 p47 p52 p68 p70 p88 p90 p103]; B={P1,P2,P9,P14} [F=p3 p5 p15 p23 p29 p49 p54 p101; s_t F=p3 p49 p54 p69 p70 p87 p90 p101]; C={P2,P3,P14,P15} [F=p2 p13 p15 p29 p33 p52 p68 p88; s_t F=p2 p13 p16 p30 p33 p52 p69 p87] +- P2 ~ P9: A={P2,P7,P9,P13} [F=p2 p9 p15 p23 p36 p46 p62 p94; s_t F=p2 p9 p20 p27 p36 p46 p69 p90]; B={P2,P6,P9,P12} [F=p2 p10 p15 p23 p37 p46 p63 p93; s_t F=p2 p10 p19 p26 p37 p46 p69 p90]; C={P6,P7,P12,P13} [F=p1 p7 p19 p26 p34 p43 p62 p94; s_t F=p1 p7 p20 p27 p34 p43 p63 p93] +- P5 ~ P19: A={P1,P2,P5,P19} [F=p4 p5 p15 p18 p84 p85 p96 p100; s_t F=p4 p42 p65 p69 p70 p85 p96 p100]; B={P5,P8,P17,P19} [F=p6 p12 p18 p40 p49 p54 p61 p84; s_t F=p6 p12 p21 p42 p49 p54 p65 p81]; C={P1,P2,P8,P17} [F=p5 p15 p21 p44 p50 p55 p58 p81; s_t F=p40 p44 p50 p55 p58 p61 p69 p70] +- P6 ~ P9: A={P2,P6,P9,P12} [F=p2 p10 p15 p23 p37 p46 p63 p93; s_t F=p2 p10 p19 p26 p37 p46 p69 p90]; B={P3,P6,P9,P11} [F=p2 p10 p16 p23 p38 p47 p63 p92; s_t F=p2 p10 p19 p25 p38 p47 p68 p90]; C={P2,P3,P11,P12} [F=p4 p7 p15 p25 p31 p45 p68 p93; s_t F=p4 p7 p16 p26 p31 p45 p69 p92] +- P7 ~ P9: A={P2,P7,P9,P13} [F=p2 p9 p15 p23 p36 p46 p62 p94; s_t F=p2 p9 p20 p27 p36 p46 p69 p90]; B={P4,P7,P9,P11} [F=p2 p9 p17 p23 p38 p48 p62 p92; s_t F=p2 p9 p20 p25 p38 p48 p67 p90]; C={P2,P4,P11,P13} [F=p3 p7 p15 p25 p31 p44 p67 p94; s_t F=p3 p7 p17 p27 p31 p44 p69 p92] +- P9 ~ P10: A={P3,P5,P9,P10} [F=p4 p8 p16 p23 p36 p51 p65 p91; s_t F=p4 p8 p18 p24 p36 p51 p68 p90]; B={P9,P10,P16,P17} [F=p9 p23 p40 p50 p76 p80 p91 p103; s_t F=p9 p24 p39 p50 p76 p81 p90 p103]; C={P3,P5,P16,P17} [F=p8 p13 p16 p39 p51 p58 p65 p81; s_t F=p8 p13 p18 p40 p51 p58 p68 p80] +- P9 ~ P14: A={P1,P2,P9,P14} [F=p3 p5 p15 p23 p29 p49 p54 p101; s_t F=p3 p49 p54 p69 p70 p87 p90 p101]; B={P5,P9,P14,P19} [F=p18 p35 p46 p52 p76 p84 p87 p90; s_t F=p23 p29 p35 p42 p46 p52 p65 p76]; C={P1,P2,P5,P19} [F=p4 p5 p15 p18 p84 p85 p96 p100; s_t F=p4 p42 p65 p69 p70 p85 p96 p100] +- P9 ~ P15: A={P1,P3,P9,P15} [F=p2 p5 p16 p23 p30 p47 p52 p103; s_t F=p2 p47 p52 p68 p70 p88 p90 p103]; B={P7,P9,P15,P17} [F=p20 p34 p49 p53 p77 p81 p88 p90; s_t F=p23 p30 p34 p40 p49 p53 p62 p77]; C={P1,P3,P7,P17} [F=p2 p5 p16 p20 p81 p85 p97 p103; s_t F=p2 p40 p62 p68 p70 p85 p97 p103] +- P9 ~ P17: A={P9,P10,P16,P17} [F=p9 p23 p40 p50 p76 p80 p91 p103; s_t F=p9 p24 p39 p50 p76 p81 p90 p103]; B={P7,P9,P15,P17} [F=p20 p34 p49 p53 p77 p81 p88 p90; s_t F=p23 p30 p34 p40 p49 p53 p62 p77]; C={P7,P10,P15,P16} [F=p1 p9 p11 p20 p80 p88 p91 p103; s_t F=p1 p9 p11 p24 p30 p39 p62 p103] + +Odd closure. Seeds: p24, p80, p21, p65, p71, p90, p92 (their roots and r_t are independent mod 3). + +- p61 = -p21 (antipode) +- p91 = -p24 (antipode) +- p23 = -p90 (antipode) +- p39 = -p80 (antipode) +- p18 = -p65 (antipode) +- p25 = -p92 (antipode) +- p0 = -p71 (antipode) +- p41 from quadruple {p0, p18, p24, p41} +- p19 from quadruple {p0, p19, p25, p41} +- p27 from quadruple {p0, p21, p27, p41} +- p17 from quadruple {p0, p17, p27, p39} +- p16 from quadruple {p0, p16, p23, p41} +- p87 from quadruple {p0, p17, p18, p87} +- p42 from quadruple {p0, p17, p23, p42} +- p26 from quadruple {p0, p21, p26, p42} +- p14 from quadruple {p0, p14, p24, p39} +- p15 from quadruple {p0, p15, p25, p39} +- p20 from quadruple {p0, p20, p25, p42} +- p89 from quadruple {p0, p14, p19, p89} +- p40 from quadruple {p0, p14, p23, p40} +- p88 from quadruple {p0, p14, p20, p88} +- p86 from quadruple {p0, p15, p21, p86} +- p72 from quadruple {p0, p24, p72, p86} +- p70 from quadruple {p0, p40, p70, p86} +- p5 from quadruple {p5, p18, p20, p80} +- p30 from quadruple {p5, p18, p24, p30} +- p29 from quadruple {p5, p19, p26, p29} +- p94 from quadruple {p19, p80, p86, p94} +- p62 from quadruple {p19, p26, p62, p94} +- p93 from quadruple {p20, p25, p61, p93} +- p63 from quadruple {p20, p27, p63, p93} +- p64 from quadruple {p21, p26, p64, p91} +- p66 from quadruple {p27, p30, p39, p66} +- p81 from quadruple {p5, p16, p20, p81} +- p28 from quadruple {p27, p28, p40, p63} +- p68 from quadruple {p27, p29, p40, p68} +- p67 from quadruple {p21, p26, p67, p90} +- p69 from quadruple {p27, p30, p40, p69} +- p83 from quadruple {p5, p14, p20, p83} +- p84 from quadruple {p5, p14, p19, p84} +- p82 from quadruple {p5, p14, p21, p82} + +## t = p28 (orbit of size 24) + +N(t): p0, p1, p7, p8, p9, p10, p18, p19, p20, p21, p22, p23, p29, p30, p31, p32, p33, p39, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p67, p68, p69, p70, p72, p73, p78, p81, p82, p83, p84, p85, p91, p92, p93, p94, p95, p96, p97, p98 + +Antipodal pairs (both ports): P0={p0,p73}, P1={p1,p72}, P2={p8,p69}, P3={p9,p68}, P4={p10,p67}, P5={p18,p50}, P6={p19,p48}, P7={p20,p47}, P8={p21,p46}, P9={p23,p85}, P10={p29,p96}, P11={p30,p97}, P12={p31,p91}, P13={p32,p93}, P14={p33,p94}, P15={p39,p78}, P16={p52,p81}, P17={p53,p82}, P18={p54,p83}, P19={p55,p84} + +Odd triangle: P0, P5, P14. + +Edges (sigma_p = -sigma_q), each from tetrads A, B sharing {p,q} and C = A xor B: + +- P0 ~ P3: A={P0,P3,P13,P15} [F=p0 p9 p14 p24 p32 p39 p56 p103; s_t F=p14 p24 p56 p68 p73 p78 p93 p103]; B={P0,P3,P9,P18} [F=p0 p9 p17 p23 p38 p42 p54 p99; s_t F=p17 p38 p42 p68 p73 p83 p85 p99]; C={P9,P13,P15,P18} [F=p14 p23 p54 p65 p74 p78 p93 p103; s_t F=p14 p32 p39 p65 p74 p83 p85 p103] +- P0 ~ P4: A={P0,P4,P9,P19} [F=p0 p10 p14 p23 p35 p40 p55 p102; s_t F=p14 p35 p40 p67 p73 p84 p85 p102]; B={P0,P4,P14,P15} [F=p0 p10 p14 p24 p33 p39 p57 p102; s_t F=p14 p24 p57 p67 p73 p78 p94 p102]; C={P9,P14,P15,P19} [F=p14 p23 p55 p64 p74 p78 p94 p102; s_t F=p14 p33 p39 p64 p74 p84 p85 p102] +- P0 ~ P5: A={P0,P5,P13,P16} [F=p0 p6 p18 p24 p32 p41 p52 p103; s_t F=p6 p24 p41 p50 p73 p81 p93 p103]; B={P0,P5,P12,P18} [F=p0 p6 p18 p26 p31 p40 p54 p103; s_t F=p6 p26 p40 p50 p73 p83 p91 p103]; C={P12,P13,P16,P18} [F=p6 p31 p54 p65 p71 p81 p93 p103; s_t F=p6 p32 p52 p65 p71 p83 p91 p103] +- P0 ~ P8: A={P0,P8,P14,P18} [F=p0 p6 p21 p26 p33 p42 p54 p99; s_t F=p6 p26 p42 p46 p73 p83 p94 p99]; B={P0,P8,P13,P19} [F=p0 p6 p21 p27 p32 p41 p55 p99; s_t F=p6 p27 p41 p46 p73 p84 p93 p99]; C={P13,P14,P18,P19} [F=p6 p32 p55 p61 p71 p83 p94 p99; s_t F=p6 p33 p54 p61 p71 p84 p93 p99] +- P0 ~ P9: A={P0,P2,P9,P17} [F=p0 p8 p16 p23 p36 p41 p53 p101; s_t F=p16 p36 p41 p69 p73 p82 p85 p101]; B={P0,P3,P9,P18} [F=p0 p9 p17 p23 p38 p42 p54 p99; s_t F=p17 p38 p42 p68 p73 p83 p85 p99]; C={P2,P3,P17,P18} [F=p8 p13 p14 p40 p45 p53 p68 p83; s_t F=p9 p13 p14 p40 p45 p54 p69 p82] +- P0 ~ P13: A={P0,P5,P13,P16} [F=p0 p6 p18 p24 p32 p41 p52 p103; s_t F=p6 p24 p41 p50 p73 p81 p93 p103]; B={P0,P6,P13,P17} [F=p0 p6 p19 p25 p32 p41 p53 p101; s_t F=p6 p25 p41 p48 p73 p82 p93 p101]; C={P5,P6,P16,P17} [F=p5 p17 p18 p44 p48 p52 p60 p82; s_t F=p5 p17 p19 p44 p50 p53 p60 p81] +- P0 ~ P14: A={P0,P7,P14,P17} [F=p0 p6 p20 p25 p33 p42 p53 p100; s_t F=p6 p25 p42 p47 p73 p82 p94 p100]; B={P0,P8,P14,P18} [F=p0 p6 p21 p26 p33 p42 p54 p99; s_t F=p6 p26 p42 p46 p73 p83 p94 p99]; C={P7,P8,P17,P18} [F=p5 p14 p20 p45 p46 p53 p57 p83; s_t F=p5 p14 p21 p45 p47 p54 p57 p82] +- P0 ~ P15: A={P0,P3,P13,P15} [F=p0 p9 p14 p24 p32 p39 p56 p103; s_t F=p14 p24 p56 p68 p73 p78 p93 p103]; B={P0,P4,P14,P15} [F=p0 p10 p14 p24 p33 p39 p57 p102; s_t F=p14 p24 p57 p67 p73 p78 p94 p102]; C={P3,P4,P13,P14} [F=p9 p32 p60 p67 p71 p80 p94 p99; s_t F=p10 p33 p60 p68 p71 p80 p93 p99] +- P0 ~ P17: A={P0,P6,P13,P17} [F=p0 p6 p19 p25 p32 p41 p53 p101; s_t F=p6 p25 p41 p48 p73 p82 p93 p101]; B={P0,P7,P14,P17} [F=p0 p6 p20 p25 p33 p42 p53 p100; s_t F=p6 p25 p42 p47 p73 p82 p94 p100]; C={P6,P7,P13,P14} [F=p2 p6 p19 p25 p32 p47 p61 p94; s_t F=p2 p6 p20 p25 p33 p48 p61 p93] +- P0 ~ P18: A={P0,P5,P12,P18} [F=p0 p6 p18 p26 p31 p40 p54 p103; s_t F=p6 p26 p40 p50 p73 p83 p91 p103]; B={P0,P8,P14,P18} [F=p0 p6 p21 p26 p33 p42 p54 p99; s_t F=p6 p26 p42 p46 p73 p83 p94 p99]; C={P5,P8,P12,P14} [F=p18 p31 p46 p57 p76 p80 p87 p94; s_t F=p21 p33 p50 p57 p76 p80 p87 p91] +- P0 ~ P19: A={P0,P8,P13,P19} [F=p0 p6 p21 p27 p32 p41 p55 p99; s_t F=p6 p27 p41 p46 p73 p84 p93 p99]; B={P0,P4,P9,P19} [F=p0 p10 p14 p23 p35 p40 p55 p102; s_t F=p14 p35 p40 p67 p73 p84 p85 p102]; C={P4,P8,P9,P13} [F=p2 p10 p15 p23 p37 p46 p63 p93; s_t F=p2 p15 p21 p32 p37 p63 p67 p85] +- P1 ~ P7: A={P1,P5,P7,P9} [F=p1 p5 p18 p20 p80 p85 p100 p103; s_t F=p5 p23 p47 p50 p72 p80 p100 p103]; B={P1,P7,P10,P19} [F=p1 p5 p20 p27 p29 p43 p55 p100; s_t F=p5 p27 p43 p47 p72 p84 p96 p100]; C={P5,P9,P10,P19} [F=p4 p5 p15 p18 p84 p85 p96 p100; s_t F=p4 p5 p15 p23 p29 p50 p55 p100] +- P2 ~ P4: A={P2,P4,P6,P8} [F=p2 p8 p21 p26 p37 p48 p67 p90; s_t F=p2 p10 p19 p26 p37 p46 p69 p90]; B={P2,P4,P17,P19} [F=p8 p37 p53 p67 p71 p84 p90 p100; s_t F=p10 p37 p55 p69 p71 p82 p90 p100]; C={P6,P8,P17,P19} [F=p5 p14 p19 p44 p46 p53 p56 p84; s_t F=p5 p14 p21 p44 p48 p55 p56 p82] +- P4 ~ P6: A={P1,P4,P6,P12} [F=p1 p10 p11 p19 p80 p89 p91 p102; s_t F=p11 p31 p48 p67 p72 p80 p89 p102]; B={P2,P4,P6,P8} [F=p2 p8 p21 p26 p37 p48 p67 p90; s_t F=p2 p10 p19 p26 p37 p46 p69 p90]; C={P1,P2,P8,P12} [F=p1 p8 p21 p26 p37 p45 p64 p91; s_t F=p26 p31 p37 p45 p46 p64 p69 p72] +- P4 ~ P7: A={P3,P4,P6,P7} [F=p2 p9 p20 p25 p38 p48 p67 p90; s_t F=p2 p10 p19 p25 p38 p47 p68 p90]; B={P4,P7,P15,P17} [F=p10 p11 p16 p39 p47 p60 p63 p82; s_t F=p11 p16 p20 p53 p60 p63 p67 p78]; C={P3,P6,P15,P17} [F=p9 p11 p17 p39 p48 p60 p62 p82; s_t F=p11 p17 p19 p53 p60 p62 p68 p78] +- P4 ~ P10: A={P0,P4,P5,P10} [F=p0 p10 p15 p18 p79 p89 p96 p100; s_t F=p15 p29 p50 p67 p73 p79 p89 p100]; B={P4,P10,P12,P18} [F=p3 p10 p11 p15 p83 p89 p91 p96; s_t F=p3 p11 p15 p29 p31 p54 p67 p89]; C={P0,P5,P12,P18} [F=p0 p6 p18 p26 p31 p40 p54 p103; s_t F=p6 p26 p40 p50 p73 p83 p91 p103] +- P4 ~ P12: A={P1,P4,P6,P12} [F=p1 p10 p11 p19 p80 p89 p91 p102; s_t F=p11 p31 p48 p67 p72 p80 p89 p102]; B={P4,P10,P12,P18} [F=p3 p10 p11 p15 p83 p89 p91 p96; s_t F=p3 p11 p15 p29 p31 p54 p67 p89]; C={P1,P6,P10,P18} [F=p1 p5 p19 p26 p29 p43 p54 p101; s_t F=p5 p26 p43 p48 p72 p83 p96 p101] +- P5 ~ P14: A={P1,P2,P5,P14} [F=p1 p8 p13 p18 p80 p87 p94 p100; s_t F=p13 p33 p50 p69 p72 p80 p87 p100]; B={P5,P10,P14,P15} [F=p18 p24 p57 p61 p76 p78 p94 p96; s_t F=p24 p29 p33 p39 p50 p57 p61 p76]; C={P1,P2,P10,P15} [F=p1 p8 p13 p27 p29 p39 p65 p100; s_t F=p13 p27 p65 p69 p72 p78 p96 p100] +- P7 ~ P11: A={P7,P9,P11,P16} [F=p2 p5 p16 p20 p81 p85 p97 p103; s_t F=p2 p5 p16 p23 p30 p47 p52 p103]; B={P7,P8,P10,P11} [F=p2 p5 p20 p27 p29 p46 p57 p97; s_t F=p2 p5 p21 p27 p30 p47 p57 p96]; C={P8,P9,P10,P16} [F=p21 p35 p42 p65 p76 p81 p85 p96; s_t F=p23 p29 p35 p42 p46 p52 p65 p76] +- P11 ~ P16: A={P1,P5,P11,P16} [F=p1 p5 p18 p24 p30 p44 p52 p103; s_t F=p5 p24 p44 p50 p72 p81 p97 p103]; B={P7,P9,P11,P16} [F=p2 p5 p16 p20 p81 p85 p97 p103; s_t F=p2 p5 p16 p23 p30 p47 p52 p103]; C={P1,P5,P7,P9} [F=p1 p5 p18 p20 p80 p85 p100 p103; s_t F=p5 p23 p47 p50 p72 p80 p100 p103] + +Odd closure. Seeds: p23, p78, p21, p91, p54, p72, p94 (their roots and r_t are independent mod 3). + +- p46 = -p21 (antipode) +- p85 = -p23 (antipode) +- p31 = -p91 (antipode) +- p83 = -p54 (antipode) +- p39 = -p78 (antipode) +- p1 = -p72 (antipode) +- p33 = -p94 (antipode) +- p0 from quadruple {p0, p21, p33, p54} +- p7 from quadruple {p0, p7, p31, p39} +- p52 from quadruple {p0, p7, p23, p52} +- p96 from quadruple {p0, p7, p21, p96} +- p9 from quadruple {p0, p9, p23, p54} +- p32 from quadruple {p0, p9, p32, p39} +- p10 from quadruple {p0, p10, p33, p39} +- p18 from quadruple {p0, p10, p18, p96} +- p55 from quadruple {p0, p10, p23, p55} +- p97 from quadruple {p0, p32, p72, p97} +- p98 from quadruple {p0, p33, p72, p98} +- p95 from quadruple {p0, p31, p72, p95} +- p70 from quadruple {p0, p54, p70, p97} +- p53 from quadruple {p0, p53, p70, p96} +- p20 from quadruple {p1, p18, p20, p85} +- p30 from quadruple {p1, p18, p30, p52} +- p19 from quadruple {p1, p19, p30, p53} +- p29 from quadruple {p1, p19, p29, p54} +- p22 from quadruple {p1, p7, p22, p52} +- p93 from quadruple {p1, p7, p20, p93} +- p92 from quadruple {p1, p7, p21, p92} +- p8 from quadruple {p1, p8, p18, p94} +- p73 from quadruple {p1, p22, p73, p85} +- p81 from quadruple {p20, p81, p85, p97} +- p47 from quadruple {p23, p30, p47, p52} +- p48 from quadruple {p22, p33, p48, p52} +- p68 from quadruple {p8, p29, p68, p97} +- p67 from quadruple {p8, p21, p48, p67} +- p69 from quadruple {p9, p30, p69, p96} +- p49 from quadruple {p23, p29, p49, p54} +- p51 from quadruple {p22, p33, p51, p54} +- p84 from quadruple {p19, p84, p85, p95} +- p50 from quadruple {p23, p29, p50, p55} +- p82 from quadruple {p21, p48, p55, p82} + diff --git a/research/p104-carrier-code-uniqueness/e8/ports-d8.md b/research/p104-carrier-code-uniqueness/e8/ports-d8.md new file mode 100644 index 0000000000..21805cd9ad --- /dev/null +++ b/research/p104-carrier-code-uniqueness/e8/ports-d8.md @@ -0,0 +1,120 @@ +# Ports in D8 coordinates (generated by porttable.py) + +Orthonormal D8 axes u_1..u_8 (fixed by d8.py). Mod 3 a root reduces to its coordinate vector with 1/2 = 2. + +| port | q (bits 0..8) | root | +|---|---|---| +| p0 | 110100000 | (1,1,0,0,0,0,0,0) | +| p1 | 110010000 | (1,0,0,1,0,0,0,0) | +| p2 | 110001000 | 1/2(++-++--+) | +| p3 | 110000010 | (1,0,0,0,1,0,0,0) | +| p4 | 110000001 | 1/2(++-+++--) | +| p5 | 101100000 | (0,1,1,0,0,0,0,0) | +| p6 | 101010000 | (0,0,1,1,0,0,0,0) | +| p7 | 101001000 | 1/2(-++++--+) | +| p8 | 101000100 | 1/2(-++++-+-) | +| p9 | 101000010 | (0,0,1,0,1,0,0,0) | +| p10 | 101000001 | 1/2(-+++++--) | +| p11 | 100101000 | (0,1,0,0,0,0,0,1) | +| p12 | 100100100 | (0,1,0,0,0,0,1,0) | +| p13 | 100100001 | (0,1,0,0,0,1,0,0) | +| p14 | 100011000 | (0,0,0,1,0,0,0,1) | +| p15 | 100010100 | (0,0,0,1,0,0,1,0) | +| p16 | 100010010 | 1/2(+-++++++) | +| p17 | 100010001 | (0,0,0,1,0,1,0,0) | +| p18 | 100001010 | (0,0,0,0,1,0,0,1) | +| p19 | 100000110 | (0,0,0,0,1,0,1,0) | +| p20 | 100000101 | 1/2(-+-++++-) | +| p21 | 100000011 | (0,0,0,0,1,1,0,0) | +| p22 | 011100000 | 1/2(+++-----) | +| p23 | 011010000 | 1/2(+-++----) | +| p24 | 011001000 | (0,0,0,0,0,-1,-1,0) | +| p25 | 011000100 | (0,0,0,0,0,-1,0,-1) | +| p26 | 011000010 | 1/2(+-+-+---) | +| p27 | 011000001 | (0,0,0,0,0,0,-1,-1) | +| p28 | 010110000 | (1,0,0,0,-1,0,0,0) | +| p29 | 010100100 | 1/2(++----+-) | +| p30 | 010100010 | (1,0,0,-1,0,0,0,0) | +| p31 | 010011000 | 1/2(+--+---+) | +| p32 | 010010010 | (1,-1,0,0,0,0,0,0) | +| p33 | 010010001 | 1/2(+--+-+--) | +| p34 | 010001100 | (0,0,-1,0,0,-1,0,0) | +| p35 | 010001001 | (0,0,-1,0,0,0,-1,0) | +| p36 | 010000110 | 1/2(+---+-+-) | +| p37 | 010000101 | (0,0,-1,0,0,0,0,-1) | +| p38 | 010000011 | 1/2(+---++--) | +| p39 | 001110000 | (0,0,1,0,-1,0,0,0) | +| p40 | 001101000 | 1/2(-++----+) | +| p41 | 001100010 | (0,0,1,-1,0,0,0,0) | +| p42 | 001100001 | 1/2(-++--+--) | +| p43 | 001010100 | 1/2(--++--+-) | +| p44 | 001010010 | (0,-1,1,0,0,0,0,0) | +| p45 | 001010001 | 1/2(--++-+--) | +| p46 | 001001100 | (-1,0,0,0,0,-1,0,0) | +| p47 | 001001010 | 1/2(--+-+--+) | +| p48 | 001001001 | (-1,0,0,0,0,0,-1,0) | +| p49 | 001000110 | 1/2(--+-+-+-) | +| p50 | 001000101 | (-1,0,0,0,0,0,0,-1) | +| p51 | 001000011 | 1/2(--+-++--) | +| p52 | 000111000 | (0,0,0,0,-1,0,0,1) | +| p53 | 000110100 | (0,0,0,0,-1,0,1,0) | +| p54 | 000110010 | 1/2(+-+--+++) | +| p55 | 000110001 | (0,0,0,0,-1,1,0,0) | +| p56 | 000101010 | (0,0,0,-1,0,0,0,1) | +| p57 | 000101001 | 1/2(-+---+-+) | +| p58 | 000100110 | (0,0,0,-1,0,0,1,0) | +| p59 | 000100101 | 1/2(-+---++-) | +| p60 | 000100011 | (0,0,0,-1,0,1,0,0) | +| p61 | 000011100 | 1/2(---+--++) | +| p62 | 000011010 | (0,-1,0,0,0,0,0,1) | +| p63 | 000011001 | 1/2(---+-+-+) | +| p64 | 000010110 | (0,-1,0,0,0,0,1,0) | +| p65 | 000010101 | 1/2(---+-++-) | +| p66 | 000010011 | (0,-1,0,0,0,1,0,0) | +| p67 | 000001110 | 1/2(----+-++) | +| p68 | 000001101 | (-1,0,-1,0,0,0,0,0) | +| p69 | 000001011 | 1/2(----++-+) | +| p70 | 001111111 | 1/2(-+++++++) | +| p71 | 010111111 | 1/2(++-+++++) | +| p72 | 011011111 | (0,0,0,1,1,0,0,0) | +| p73 | 011101111 | (0,1,0,0,1,0,0,0) | +| p74 | 011110111 | 1/2(+++++++-) | +| p75 | 011111011 | 1/2(++++++-+) | +| p76 | 011111101 | (0,1,0,1,0,0,0,0) | +| p77 | 011111110 | 1/2(+++++-++) | +| p78 | 100111111 | (1,0,-1,0,0,0,0,0) | +| p79 | 101011111 | 1/2(+--++---) | +| p80 | 101101111 | 1/2(++--+---) | +| p81 | 101110111 | (1,0,0,0,0,0,0,-1) | +| p82 | 101111011 | (1,0,0,0,0,0,-1,0) | +| p83 | 101111101 | 1/2(++-+----) | +| p84 | 101111110 | (1,0,0,0,0,-1,0,0) | +| p85 | 110011111 | 1/2(--+++---) | +| p86 | 110110111 | (0,0,1,0,0,0,0,-1) | +| p87 | 110111011 | (0,0,1,0,0,0,-1,0) | +| p88 | 110111101 | 1/2(-+++----) | +| p89 | 110111110 | (0,0,1,0,0,-1,0,0) | +| p90 | 111001111 | (0,1,0,-1,0,0,0,0) | +| p91 | 111010111 | 1/2(+++--++-) | +| p92 | 111011011 | 1/2(+++--+-+) | +| p93 | 111011101 | (0,1,0,0,-1,0,0,0) | +| p94 | 111011110 | 1/2(+++---++) | +| p95 | 111100111 | 1/2(+-++-++-) | +| p96 | 111101011 | 1/2(+-++-+-+) | +| p97 | 111101101 | (0,0,0,1,-1,0,0,0) | +| p98 | 111101110 | 1/2(+-++--++) | +| p99 | 111110011 | (0,0,0,0,0,0,-1,1) | +| p100 | 111110101 | 1/2(-+-+---+) | +| p101 | 111110110 | (0,0,0,0,0,-1,0,1) | +| p102 | 111111001 | 1/2(-+-+--+-) | +| p103 | 111111010 | (0,0,0,0,0,-1,1,0) | + +Missing lines (16, all half-spin): 1/2(+++++---), 1/2(++++-+++), 1/2(++-----+), 1/2(--++---+), 1/2(++-++-+-), 1/2(-++---+-), 1/2(+--+--+-), 1/2(-+-++-++), 1/2(-+----++), 1/2(+-+-+-++), 1/2(+++-++++), 1/2(+---+--+), 1/2(++---+--), 1/2(-+-+++-+), 1/2(----+++-), 1/2(-++-+---) + +Symmetry generators (signed permutations of the axes; each maps the 16 missing lines to themselves up to sign, hence ports to ports and frames to frames). Coordinate i moves to position p[i], then the listed axes change sign: + +- p = [7, 5, 1, 2, 6, 3, 0, 4], sign flips on axes [0, 1, 2, 3, 4, 6] +- p = [4, 7, 2, 3, 5, 0, 1, 6], sign flips on axes [2, 3, 5, 7] +- p = [2, 3, 0, 6, 4, 5, 7, 1], sign flips on axes [1, 2] + +They generate a group of order 384 on lines with three orbits on ports, of sizes 32, 48, 24, represented by p0, p22, p28. diff --git a/research/p104-carrier-code-uniqueness/e8/ports.json b/research/p104-carrier-code-uniqueness/e8/ports.json new file mode 100644 index 0000000000..b964c3ae2e --- /dev/null +++ b/research/p104-carrier-code-uniqueness/e8/ports.json @@ -0,0 +1 @@ +[11, 19, 35, 131, 259, 13, 21, 37, 69, 133, 261, 41, 73, 265, 49, 81, 145, 273, 161, 193, 321, 385, 14, 22, 38, 70, 134, 262, 26, 74, 138, 50, 146, 274, 98, 290, 194, 322, 386, 28, 44, 140, 268, 84, 148, 276, 100, 164, 292, 196, 324, 388, 56, 88, 152, 280, 168, 296, 200, 328, 392, 112, 176, 304, 208, 336, 400, 224, 352, 416, 508, 506, 502, 494, 478, 446, 382, 254, 505, 501, 493, 477, 445, 381, 253, 499, 475, 443, 379, 251, 487, 471, 439, 375, 247, 463, 431, 367, 239, 415, 351, 223, 319, 191] \ No newline at end of file diff --git a/research/p104-carrier-code-uniqueness/e8/verify_e8hand.py b/research/p104-carrier-code-uniqueness/e8/verify_e8hand.py new file mode 100644 index 0000000000..39367f2638 --- /dev/null +++ b/research/p104-carrier-code-uniqueness/e8/verify_e8hand.py @@ -0,0 +1,160 @@ +"""Self-contained verification of the finite facts used in the E8 hand proof of uniqueness of the length-8 +P104 decoding code (see E8-PROOF.md). Standard library only; exact arithmetic. Apache-2.0. +V1 the 104 ports contain exactly one D8 subsystem; there are 759 frames (8 pairwise orthogonal ports). +V2 for every port t, the frame equations sum_{x in F, x non-orth t} g(x) = c (F a frame not containing t) have + rank 41 on the 48 unknowns, and the 7-dim family g(x) = (r_x.r_t)(r_x.v), v in r_t^perp (mod 3), solves the + homogeneous system: so the homogeneous solutions are exactly that family. +V3 for every port t, r_t and the roots r_x of the ports x for which the third line of the A2 through t, x is a port + span F_3^8. +V4 (independent cross-check of steps 3-4) the symmetric system has only the solution N = 1 on non-orth pairs. +V5 sign-step availability in the D8 matching frame T.""" +import itertools, sys, time +from fractions import Fraction as Q +T0 = time.time() +def log(*a): print('[%6.1fs]' % (time.time() - T0), *a, flush=True) +log('START verify_e8hand') +P = [11, 19, 35, 131, 259, 13, 21, 37, 69, 133, 261, 41, 73, 265, 49, 81, 145, 273, 161, 193, 321, 385, 14, 22, 38, 70, 134, 262, 26, 74, 138, 50, 146, 274, 98, 290, 194, 322, 386, 28, 44, 140, 268, 84, 148, 276, 100, 164, 292, 196, 324, 388, 56, 88, 152, 280, 168, 296, 200, 328, 392, 112, 176, 304, 208, 336, 400, 224, 352, 416, 508, 506, 502, 494, 478, 446, 382, 254, 505, 501, 493, 477, 445, 381, 253, 499, 475, 443, 379, 251, 487, 471, 439, 375, 247, 463, 431, 367, 239, 415, 351, 223, 319, 191] +LINES = [q for q in range(512) if bin(q).count('1') in (3, 7)] +def root(q): + c = [(q >> k) & 1 for k in range(9)] + if sum(c) == 7: + i, j = [k for k in range(9) if not c[k]]; r = [Q(0)] * 9; r[i] = Q(1); r[j] = Q(-1); return tuple(r) + return tuple(Q(2, 3) if c[k] else Q(-1, 3) for k in range(9)) +R = {q: root(q) for q in LINES} +def ip(a, b): return sum(x * y for x, y in zip(R[a], R[b])) +PS = set(P) +assert len(P) == 104 and PS <= set(LINES) +assert all((ip(a, b) == 0) == (bin(a & b).count('1') % 2 == 1) for a in P for b in P if a != b), 'conflict = orthogonality' +def frames(pool): + out = [] + def rec(cur, cand): + if len(cur) == 8: out.append(tuple(cur)); return + for i, q in enumerate(cand): rec(cur + [q], [x for x in cand[i + 1:] if ip(q, x) == 0]) + rec([], list(pool)); return out +FR = frames(P); log('V1 frames', len(FR)); assert len(FR) == 759 +# ---- D8: find it via a frame and a partition of its 8 lines into 4 pairs whose unions are blocks +def frame_view(T): + v = {} + for q in LINES: + if q in T: continue + c = [ip(q, t) for t in T]; B = tuple(i for i in range(8) if c[i] != 0); assert len(B) == 4 + v[q] = B + return v +def parts(rest): + if not rest: yield []; return + a = rest[0] + for b in rest[1:]: + for p in parts([x for x in rest if x not in (a, b)]): yield [(a, b)] + p +D8s = set(); D8T = None +for T in FR: + v = frame_view(T); blocks = {} + for q, B in v.items(): blocks.setdefault(B, []).append(q) + for pt in parts(list(range(8))): + if all(tuple(sorted(p + q)) in blocks for p, q in itertools.combinations(pt, 2)): + L = set(T) + for p, q in itertools.combinations(pt, 2): L |= set(blocks[tuple(sorted(p + q))]) + if L <= PS: D8s.add(frozenset(L)); D8T = D8T or (T, pt) +log('V1 D8 subsystems inside the ports', len(D8s)); assert len(D8s) == 1 +D8 = next(iter(D8s)) +# orthonormal D8 axes u_1..u_8: vectors (r_x +- r_y)/2 of orthogonal D8 pairs occurring 7 times +cnt = {} +for x, y in itertools.combinations(sorted(D8), 2): + if ip(x, y) == 0: + for sg in (1, -1): + w = tuple((a + sg * b) / 2 for a, b in zip(R[x], R[y])) + if w[next(i for i in range(9) if w[i] != 0)] < 0: w = tuple(-c for c in w) + cnt[w] = cnt.get(w, 0) + 1 +U = [w for w, c in cnt.items() if c == 7]; assert len(U) == 8 +def dotv(a, b): return sum(x * y for x, y in zip(a, b)) +assert all(dotv(U[i], U[j]) == (1 if i == j else 0) for i in range(8) for j in range(8)) +def coords(q): return [dotv(R[q], u) for u in U] +def red(q): # E8 (x) Z_(3) = Z_(3)^8 in D8 coordinates; 1/2 = 2 mod 3 + return tuple(int(c * 2) * 2 % 3 if c.denominator == 2 else int(c) % 3 for c in coords(q)) +RD = {q: red(q) for q in LINES} +def d3(a, b): return sum(x * y for x, y in zip(a, b)) % 3 +assert all((d3(RD[a], RD[b]) == 0) == (ip(a, b) == 0) for a in LINES for b in LINES if a != b) +assert all(d3(RD[q], RD[q]) == 2 for q in LINES) +miss = sorted(q for q in LINES if q not in PS) +def sv(q): + s = ['+' if c > 0 else '-' for c in coords(q)] + return ''.join(s) if s[0] == '+' else ''.join('-' if c == '+' else '+' for c in s) +log('V1 missing lines (all half-spin, sign vectors in D8 axes):', sorted(sv(q) for q in miss)) +assert not (set(miss) & D8) +def rref(rows, n): + rows = [list(r) for r in rows]; k = 0; piv = [] + for c in range(n): + p = next((i for i in range(k, len(rows)) if rows[i][c] % 3), None) + if p is None: continue + rows[k], rows[p] = rows[p], rows[k]; inv = rows[k][c] % 3 + rows[k] = [(x * inv) % 3 for x in rows[k]] + for i in range(len(rows)): + if i != k and rows[i][c] % 3: + f = rows[i][c]; rows[i] = [(x - f * y) % 3 for x, y in zip(rows[i], rows[k])] + piv.append(c); k += 1 + return rows[:k], piv +def third(t, x): + s = 1 if ip(t, x) > 0 else -1 + v = tuple(a - s * b for a, b in zip(R[t], R[x])) + return next(q for q in LINES if R[q] == v or R[q] == tuple(-c for c in v)) +KER = {}; NB = {}; ok2 = ok3 = True +for t in P: + N = [x for x in P if x != t and ip(t, x) != 0]; idx = {x: i for i, x in enumerate(N)}; NB[t] = idx + rows = [] + for F in FR: + if t in F: continue + r = [0] * 48 + for x in F: + if x in idx: r[idx[x]] = 1 + assert sum(r) == 4; rows.append(r) + red_, piv = rref(rows, 48) + # family: basis of r_t^perp mod 3, g_v(x) = (r_x.r_t)(r_x.v) + perp = [v for v in itertools.product(range(3), repeat=8) if d3(v, RD[t]) == 0] + fam = [] + for v in perp: + g = [d3(RD[x], RD[t]) * d3(RD[x], v) % 3 for x in N] + if rref(fam + [g], 48)[1].__len__() > len(fam): fam.append(g) + if len(fam) == 7: break + sol = all(sum(a * b for a, b in zip(r, g)) % 3 == 0 for r in rows for g in fam) + good = len(piv) == 41 and len(fam) == 7 and sol + ok2 &= good + A2 = [x for x in N if third(t, x) in PS] + rk3 = len(rref([RD[t]] + [RD[x] for x in A2], 8)[1]); ok3 &= rk3 == 8 + # store kernel basis for V4 + free = [c for c in range(48) if c not in piv]; K = [] + for f in free: + v = [0] * 48; v[f] = 1 + for r, c in zip(red_, piv): v[c] = (-r[f]) % 3 + K.append(v) + KER[t] = K + log('t=%d frames-not-containing-t %d rank %d family-dim %d family-solves %s | A2-completable %d span %d' + % (t, len(rows), len(piv), len(fam), sol, len(A2), rk3)) +log('V2 per-port linear lemma holds for all 104 ports:', ok2); log('V3 A2 span holds for all 104 ports:', ok3) +var = {} +for t in P: + for k in range(7): var[t, k] = len(var) +eqs = [] +for t in P: + for x in NB[t]: + if x < t: continue + r = [0] * len(var) + for k, v in enumerate(KER[t]): r[var[t, k]] = (r[var[t, k]] + v[NB[t][x]]) % 3 + for k, v in enumerate(KER[x]): r[var[x, k]] = (r[var[x, k]] - v[NB[x][t]]) % 3 + eqs.append(r) +rk4 = len(rref(eqs, len(var))[1]); log('V4 symmetric system unknowns', len(var), 'rank', rk4, 'only N=1:', rk4 == len(var)) +# V5: in the D8 matching frame T every block has >= 1 ports, and for every pair {a,b} of T, every block through it +# and every sign sigma there is a port with sigma_ab = sigma +T, pt = D8T; v = frame_view(T); ok5 = True +for B in set(v.values()): + ok5 &= sum(1 for q, b in v.items() if b == B and q in PS) >= 1 +for a, b in itertools.combinations(range(8), 2): + for B in set(v.values()): + if a in B and b in B: + sig = set() + for q, bb in v.items(): + if bb == B and q in PS: + sig.add((ip(q, T[a]) * ip(q, T[b])) > 0) + ok5 &= sig == {True, False} +log('V5 sign-step availability in the D8 frame:', ok5) +ALL = ok2 and ok3 and rk4 == len(var) and ok5 +log('RESULT', 'PASS' if ALL else 'FAIL') +sys.exit(0 if ALL else 1)