From 76fad3fe9276796949f769e54eeefdd185f28f4f Mon Sep 17 00:00:00 2001 From: commdata2338 <199849969+commdata2338@users.noreply.github.com> Date: Sat, 17 Oct 2026 13:27:38 -0500 Subject: [PATCH] Research: independently certify the helper-13 cut for PR #3124's P104 matching Independently corroborates PR #3182's helper-13 exclusion for the exact PR #3124 cycle-A matching [13,203,191,63] in the fixed X-only monotone common-frame model. With helper 13 alone on a nested flag and the other 207 helpers favorably relaxed, all 9,765 flags fail: the missing-pair histogram {1002:225, 1020:477, 1023:477, 1025:117, 1026:8469} and the 22 contact profiles match PR #3182, and 995 required pairs are missing for every flag. A source-bound cut shows that an outside source can reach Y40 only through u -> 13 -> 91 (u = 63, 118 or 185), which nestedness forbids (separators 31, 178 and 253 lie outside B_8; PR #3182's pair proof lists the same three), so Y40's correction depends only on X6, X8, X41 and X45 and misses 44 required coefficients, including C[40,1] = 1/2. New literal-subspace geometry, two support engines, an algebraic contact checker and forward and reverse replays of the original 4,058-event word agree; no predecessor code or result is imported. Native realization, dirty restoration, chronology and the consumer bill remain open; no supplier or kappa change. Adds research/p104-moved-helper-cut/ only. Submitted by @commdata2338 with substantial AI assistance (OpenAI Codex research and implementation; packaged with Claude Code). Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01X86sCSXdoDd61SDFfC1PKG --- research/p104-moved-helper-cut/README.md | 250 + research/p104-moved-helper-cut/RESULT.json | 7980 +++++++++++++++++ research/p104-moved-helper-cut/SOURCES.json | 86 + research/p104-moved-helper-cut/TASK.json | 133 + research/p104-moved-helper-cut/VERIFY.json | 58 + research/p104-moved-helper-cut/check_cut.py | 175 + research/p104-moved-helper-cut/test_verify.py | 181 + research/p104-moved-helper-cut/verify.py | 500 ++ 8 files changed, 9363 insertions(+) create mode 100644 research/p104-moved-helper-cut/README.md create mode 100644 research/p104-moved-helper-cut/RESULT.json create mode 100644 research/p104-moved-helper-cut/SOURCES.json create mode 100644 research/p104-moved-helper-cut/TASK.json create mode 100644 research/p104-moved-helper-cut/VERIFY.json create mode 100644 research/p104-moved-helper-cut/check_cut.py create mode 100644 research/p104-moved-helper-cut/test_verify.py create mode 100644 research/p104-moved-helper-cut/verify.py diff --git a/research/p104-moved-helper-cut/README.md b/research/p104-moved-helper-cut/README.md new file mode 100644 index 0000000000..e907cf03ab --- /dev/null +++ b/research/p104-moved-helper-cut/README.md @@ -0,0 +1,250 @@ +# An independent moved-helper cut for PR3124's P104 matching + +**Scoped proof and independently implemented finite audit.** The exact matching +published in [PR3124](https://github.com/CrocSwap/integer-mult-bounds/pull/3124), +with alternating cycle `[13,203,191,63]`, cannot deliver the required P104 +correction in the fixed X-only monotone common-frame model. Requiring only +helper **13** to follow one nested flag already forces the added coefficient +`X1 -> Y40` to be zero, although `C[40,1] = (I-G/2)[40,1] = 1/2`. + +This independently corroborates **dcharb78's prior helper-13 exclusion in +PR3182, Pillar 2**. Discovery priority for that exclusion is not claimed. +The contribution is a separately implemented source-bound check, a small +three-vector separating proof, and a full support receipt. It does not import +any predecessor Python, propagation routine, flag enumerator or result file. +Ross Richardson's PR3032 supplies the earlier one-helper cut method for a +different matching. PR3124's positive helper-91 result remains within its +stated scope; it leaves the other 207 helpers relaxed. + +The small proof bounds Y40's correction support by `{6,8,41,45}`, excluding +**44 of its 48 required coefficients**. Separately, a complete census gives: + +| Missing required pairs over all 104 targets | Helper-13 flags | +|---:|---:| +| 1,002 | 225 | +| 1,020 | 477 | +| 1,023 | 477 | +| 1,025 | 117 | +| 1,026 | 8,469 | +| **Total** | **9,765** | + +The flags have 22 distinct complete contact/read/write profiles. Across all +flags, **995 specific required pairs are always missing**. The census and +histogram agree with the reported PR3182 helper-13 values; the 995-pair +intersection and the small Y40 proof are recorded here explicitly. No other +PR3182 pillar, helper census or consumer-price claim is admitted by this audit. + +## Contract and proof + +Work in `F2^9` with the frozen PR1972/1991 X and Y frame paths. X is immutable; +Y is unread. The added correction must preserve each arbitrary initial Y +value. Helpers begin with independent arbitrary dirty inputs and follow +monotone flags from dimension zero to nine. Scalar transfers require a common +frame. No original-channel helper reads, extra lifetimes, descending frame +transports, target feedback or source-dependent frame program are granted. + +For helper `h`, its dimension-two departure space is `A_h`, and its +dimension-seven space is `B_M[h]`, where M is the pinned matching. Dimensions +one and eight are the prescribed source line and target hyperplane. Every +intermediate frame F obeys `A_h <= F <= B_M[h]`. + +We grant all frozen source snapshots without their actual event deadlines, +free mixing, and no restoration or physical cost. Every helper except 13 may +choose each contact independently, even when those contacts cannot coexist +in one flag. Same-layer contacts receive full transitive closure, including +fresh source reads, and all writers accumulate into each target. This is a +favorable necessary support test, not an executable correction program. + +A nonzero coefficient in any allowed linear program requires a source-to-write +path of nondecreasing frame dimension. Copies, cancellation, rescaling and +independent dirty inputs cannot create a source coefficient without such a +path. Dimension zero supplies no source; at dimension nine no Y write remains. + +### Complete local boundary + +Literal enumeration of all admissible subspaces gives the following **complete** +other-helper contact lists. Dimensions two and seven have no other contact. + +| Helper | Dimension 1 | Dimension 3 | Dimensions 4 and 5 | Dimension 6 | Dimension 8 | +|---:|---|---|---|---|---| +| 13 | 12 | 63,185 | 63,91,118,185 | 91 | 124 | +| 17 | 16 | none | none | none | 83 | +| 83 | 82 | none | 91 | 91 | 17 | +| 91 | 90 | none | 13,83 | 13,83 | 183 | + +These helpers read only X6, X8, X41 and X45 respectively, at dimension one. +Each dimension-one partner has that same source and no other source there. +Y40 has no direct equal-frame X read. Its only writers are helpers 17 and 83, +both at dimension eight. The late contact from 183 into 91 cannot reach the +earlier exits from 91 into 83 at dimensions four through six. + +Any new source outside `{6,8,41,45}` reaching Y40 must therefore pass through +`u -> 13 -> 91`, where `u` is 63, 118 or 185. Entry from helper 124 occurs +only at dimension eight and is too late. Entry from 91 itself cannot be the +first acquisition of an outside source into this local subsystem. + +At the contact with u, helper 13's frame contains `A_u`. At its later contact +with 91, its frame lies in `B_8`, because `M[91]=8`. Nestedness would force +`A_u <= B_8`. Each possible u has an explicit contradiction: + +| u | A_u basis | Vector in A_u but outside B_8 | +|---:|---|---:| +| 63 | 31,288 | 31 | +| 118 | 178,365 | 178 | +| 185 | 253,288 | 253 | + +Here `B_8 = span(2,13,20,37,64,133,261)`. The integers encode binary vectors; +span and membership are over F2. Equal-dimension contacts give the same +contradiction, since a flag has just one frame at that dimension. Repeated +contacts do not evade the first-acquisition argument. These three separations +also appear among the twelve pairwise incompatibilities in PR3182's algebraic +proof for helper 13; the addition here is the complete local boundary above, +which makes `u -> 13 -> 91` the only route for an outside source into Y40. + +It follows that Y40's added support lies in `{6,8,41,45}`. The checker +reconstructs the 120 doubled E8 root representatives, removes the two fixture +frames, and uses the retained lexicographic 104-port order. The doubled roots +at indices 1 and 40 are `(0,0,0,0,0,2,0,2)` and +`(1,-1,-1,1,-1,-1,-1,-1)`. Their dot product is -4, so +`C[40,1] = -(-4)/8 = 1/2`. All four allowed support positions are required, +leaving 44 other nonzero coefficients unavailable. + +A separate exact rational replay of all 104 original X columns checks the +4,058-event logical channel, every common-frame ADD and all 10,816 target +coefficients against the reconstructed Gram matrix. It also checks source +preservation and zero final source response in the dirty helpers. The native +transport realization and arbitrary dirty/target entrance columns remain +inherited. The existing G/2 response in Y is not an available correction +source because Y is unread. Preserving arbitrary +initial Y forces the added increment to supply I-G/2; its missing X1 +coefficient cannot be repaired by counting the existing response again. + +### Finite completeness and checks + +Each interval `B_M[h]/A_h` is five-dimensional. The verifier generates every +literal quotient subspace by all one-vector extensions, obtaining layer counts +`1,31,155,155,31,1`, then lifts its cosets to actual F2^9 point sets. It tests +contact by equality of literal admissible frames, not an imported interval +formula. Complete quotient flags number +`31*15*7*3*1 = 9765`; all are traversed once. + +Flags are grouped only when **every** incident contact, read and write agrees +at every dimension. Literal quotient enumeration follows PR3032's credited +method, reimplemented here with integer point masks and full incidence tables. +One source-bitset connected-component engine and a +separate per-source layered BFS agree on all 104 output supports for every +class and for the unconstrained positive control. They share the new parser, +geometry and mathematical model; they are not independent human reviews. +[RESULT.json](RESULT.json) retains every class's multiplicity, representative +flag, complete output supports as 104-bit hexadecimal masks, and the 995-pair +intersection. Default replay compares every field, including JSON types. + +[check_cut.py](check_cut.py) independently reconstructs the small boundary by +binary Gaussian elimination and the interval-contact lemma +`dim(A+C) <= d <= dim(B intersect D)`, with the required inclusions. It imports +neither the main checker nor predecessor code and enumerates no quotient +flags. It derives Y40's entire correction row by reverse scalar sensitivity +through the original word, including private copy/erase boundaries. This +also checks that row's initial Y coefficient is one and its other dirty +entrance coefficients vanish. The two geometry methods and forward/reverse +coefficient calculations agree exactly. The source JSON and mathematical +contract remain shared; no independent human review is claimed. + +A deliberately nonnested choice, differing at one intermediate frame from a +nested flag, restores X1's path to Y40 in the favorable graph. The cut receipt +retains its literal bases. The normal flag validator rejects it. The completely +unconstrained matching reaches all 4,992 required pairs. These controls show +that the nestedness restriction is substantive, rather than a missing-edge +artifact of this implementation. + +Eleven behavioral groups cover same-layer fresh-read relay, accumulation from +all writers and a direct read, prohibition on backward time travel, independent +dirty state, the nonnested control, changed contacts/coefficient, equivalent +basis order and an invalid matching, logical port-order/common-frame binding, all 17,424 interval/contact cases in F2^3, +independent algebraic cut agreement, and optimized Git-free export with source +and receipt corruption. No predecessor checker is imported or executed. + +## Reproduce + +Python 3.12 and standard library, from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/p104-moved-helper-cut +``` + +The main marker is: + +```text +PASS_P104_MOVED_HELPER_CUT flags=9765 helper=13 profiles=22 always_missing=995 no_new_kappa +``` + +To check the small proof boundary without enumerating the 9,765 flags: + +```sh +python3 -I -O -B research/p104-moved-helper-cut/verify.py --cut-only +python3 -I -O -B research/p104-moved-helper-cut/check_cut.py +``` + +This prints `PASS_P104_MOVED_HELPER_SMALL_CUT target=40 source=1 +missing_coefficients=44 no_new_kappa` on one line. The second prints `PASS_P104_MOVED_HELPER_ALGEBRAIC_CUT`. +All replay commands are read-only. +`verify.py --emit` emits a freshly derived full receipt to stdout. Direct +replay also works without Git when this package and its five declared JSON +inputs are copied at the same relative paths. The registered metadata check +additionally uses pinned Git provenance. + +## Cost decision and limits + +This rejects one proposed realization before coefficient synthesis or physical +implementation. It retains the 208-helper premise and its 1,872 formal rank-one +steps. PR2920's favorable channel/transport/ideal-idle screen is inherited, +not recertified. Actual chronology, coefficients, restoration, native ADDs, +owners, routing, precision, tape and complete consumer charges are not supplied +or treated as zero. A support failure persists even with those charges waived. + +The decision is to **stop this fixed matching under this contract**. This is +not a new helper-lifetime lower bound, an exclusion of every endpoint matching, +a physical supplier admission, a complete multiplication theorem or a new +kappa. The selected result remains unchanged. No selected cold replay, Lean, +physical backend trace, hosted CI or independent human review is claimed. + +## Open next questions + +- A different matching or access/frame contract must pass a joint consistency + test before coefficient synthesis. State the changed premise and test its + source-to-target paths first; the complete consumer budget is still a blocker. + This result does not propose a larger matching search. +- Other archived PR3182 conclusions require their own audits. This check + isolates the helper-13 nested-flag conclusion; it establishes nothing about + one-hop propagation, subspace-memory propagation, helper 63, the secondary + cycle or the physical-price table. A next audit should name one such claim + and test its exact semantic premise. + +Structured questions and the complete task scope are in [TASK.json](TASK.json). + +## Sources and credit + +Base: `463113d675af7410ac91d53a4fed51ec6494eb9a`, priority revision 6. +PR3124: `ce468c5cf22f59db3071adda269ac4cc16469c8c`. +PR3182 comparator: `ad848966cd62e13de5ad8d4b5169c221d74d2fcd`. +[SOURCES.json](SOURCES.json) pins the five raw JSON inputs by Git blob and SHA256 +and records predecessor heads. The checker also reconstructs the oriented +four-cycle from the retained PR3013 control pairing, rather than trusting its +printed name. The claim is in +[Discussion #2245](https://github.com/CrocSwap/integer-mult-bounds/discussions/2245#discussioncomment-19001906). + +Credit Cinna Davis (@1337isnot1337), PR3124, for the matching and handoff; +dcharb78, PR3182, for the prior moved-helper obstruction and histogram; Ross +Richardson, PR3032, for the one-helper monotone cut technique; Nick Petalas, +PR2981/2996/3013/3019/2920/2909/2896, for covers and matching/contact evidence; +Arham Tahir, PR2997, for the fixed-full-flag audit; Rohan Arun, PR1972, and +Chafik Boukhalfa, PR1991, for the original channel and retained inputs. +Retain the attribution to Adam Gall/1940/2090, Jeremy Diviney/2113, Josie +Elliston/1071, Ali Romman/1125, Hiroki Kumazaki, Philippe Van Velzen, +Sudarsh Chaturvedi, Sagar Thakrar, ywz65 and the original geometry/native +contributors. The earlier commdata2338 acquisition/native/precision results +are distinct and are not replayed here. + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. +New code and writing are Apache-2.0. No independent human or formal-kernel +review is claimed. diff --git a/research/p104-moved-helper-cut/RESULT.json b/research/p104-moved-helper-cut/RESULT.json new file mode 100644 index 0000000000..389d8fc566 --- /dev/null +++ b/research/p104-moved-helper-cut/RESULT.json @@ -0,0 +1,7980 @@ +{ + "always_missing_pairs": [ + [ + 4, + 10 + ], + [ + 4, + 14 + ], + [ + 4, + 23 + ], + [ + 4, + 27 + ], + [ + 4, + 35 + ], + [ + 4, + 39 + ], + [ + 4, + 42 + ], + [ + 4, + 46 + ], + [ + 4, + 49 + ], + [ + 4, + 53 + ], + [ + 4, + 55 + ], + [ + 4, + 58 + ], + [ + 4, + 59 + ], + [ + 4, + 65 + ], + [ + 4, + 68 + ], + [ + 4, + 71 + ], + [ + 4, + 74 + ], + [ + 4, + 78 + ], + [ + 4, + 79 + ], + [ + 4, + 82 + ], + [ + 4, + 85 + ], + [ + 4, + 87 + ], + [ + 4, + 101 + ], + [ + 6, + 2 + ], + [ + 6, + 4 + ], + [ + 6, + 13 + ], + [ + 6, + 28 + ], + [ + 6, + 30 + ], + [ + 6, + 57 + ], + [ + 6, + 60 + ], + [ + 6, + 63 + ], + [ + 6, + 83 + ], + [ + 6, + 90 + ], + [ + 6, + 92 + ], + [ + 6, + 95 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 13 + ], + [ + 8, + 28 + ], + [ + 8, + 48 + ], + [ + 8, + 57 + ], + [ + 8, + 64 + ], + [ + 8, + 83 + ], + [ + 9, + 1 + ], + [ + 9, + 13 + ], + [ + 9, + 18 + ], + [ + 9, + 48 + ], + [ + 9, + 57 + ], + [ + 9, + 64 + ], + [ + 9, + 83 + ], + [ + 9, + 90 + ], + [ + 10, + 1 + ], + [ + 10, + 4 + ], + [ + 10, + 13 + ], + [ + 10, + 18 + ], + [ + 10, + 36 + ], + [ + 10, + 41 + ], + [ + 10, + 60 + ], + [ + 10, + 63 + ], + [ + 10, + 69 + ], + [ + 10, + 92 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 13 + ], + [ + 11, + 28 + ], + [ + 11, + 36 + ], + [ + 11, + 41 + ], + [ + 11, + 60 + ], + [ + 11, + 63 + ], + [ + 11, + 69 + ], + [ + 11, + 90 + ], + [ + 11, + 92 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 13 + ], + [ + 14, + 18 + ], + [ + 14, + 30 + ], + [ + 14, + 32 + ], + [ + 14, + 36 + ], + [ + 14, + 48 + ], + [ + 14, + 57 + ], + [ + 14, + 69 + ], + [ + 14, + 93 + ], + [ + 14, + 95 + ], + [ + 15, + 1 + ], + [ + 15, + 2 + ], + [ + 15, + 18 + ], + [ + 15, + 29 + ], + [ + 15, + 32 + ], + [ + 15, + 48 + ], + [ + 15, + 60 + ], + [ + 15, + 69 + ], + [ + 15, + 83 + ], + [ + 15, + 90 + ], + [ + 15, + 93 + ], + [ + 16, + 2 + ], + [ + 16, + 3 + ], + [ + 16, + 18 + ], + [ + 16, + 28 + ], + [ + 16, + 32 + ], + [ + 16, + 41 + ], + [ + 16, + 57 + ], + [ + 16, + 64 + ], + [ + 16, + 93 + ], + [ + 17, + 1 + ], + [ + 17, + 4 + ], + [ + 17, + 32 + ], + [ + 17, + 41 + ], + [ + 17, + 57 + ], + [ + 17, + 64 + ], + [ + 17, + 90 + ], + [ + 17, + 93 + ], + [ + 18, + 1 + ], + [ + 18, + 4 + ], + [ + 18, + 32 + ], + [ + 18, + 36 + ], + [ + 18, + 48 + ], + [ + 18, + 60 + ], + [ + 18, + 63 + ], + [ + 18, + 69 + ], + [ + 18, + 83 + ], + [ + 18, + 92 + ], + [ + 18, + 93 + ], + [ + 19, + 2 + ], + [ + 19, + 3 + ], + [ + 19, + 18 + ], + [ + 19, + 28 + ], + [ + 19, + 32 + ], + [ + 19, + 36 + ], + [ + 19, + 48 + ], + [ + 19, + 60 + ], + [ + 19, + 63 + ], + [ + 19, + 69 + ], + [ + 19, + 83 + ], + [ + 19, + 90 + ], + [ + 19, + 92 + ], + [ + 19, + 93 + ], + [ + 20, + 1 + ], + [ + 20, + 2 + ], + [ + 20, + 18 + ], + [ + 20, + 29 + ], + [ + 20, + 32 + ], + [ + 20, + 36 + ], + [ + 20, + 41 + ], + [ + 20, + 57 + ], + [ + 20, + 63 + ], + [ + 20, + 64 + ], + [ + 20, + 93 + ], + [ + 21, + 5 + ], + [ + 21, + 15 + ], + [ + 21, + 16 + ], + [ + 21, + 19 + ], + [ + 21, + 20 + ], + [ + 21, + 23 + ], + [ + 21, + 33 + ], + [ + 21, + 35 + ], + [ + 21, + 42 + ], + [ + 21, + 43 + ], + [ + 21, + 53 + ], + [ + 21, + 54 + ], + [ + 21, + 59 + ], + [ + 21, + 61 + ], + [ + 21, + 65 + ], + [ + 21, + 66 + ], + [ + 21, + 71 + ], + [ + 21, + 72 + ], + [ + 21, + 73 + ], + [ + 21, + 74 + ], + [ + 21, + 82 + ], + [ + 21, + 84 + ], + [ + 21, + 85 + ], + [ + 21, + 101 + ], + [ + 21, + 103 + ], + [ + 22, + 7 + ], + [ + 22, + 8 + ], + [ + 22, + 10 + ], + [ + 22, + 11 + ], + [ + 22, + 12 + ], + [ + 22, + 23 + ], + [ + 22, + 24 + ], + [ + 22, + 25 + ], + [ + 22, + 27 + ], + [ + 22, + 42 + ], + [ + 22, + 43 + ], + [ + 22, + 44 + ], + [ + 22, + 45 + ], + [ + 22, + 46 + ], + [ + 22, + 55 + ], + [ + 22, + 56 + ], + [ + 22, + 58 + ], + [ + 22, + 59 + ], + [ + 22, + 61 + ], + [ + 22, + 65 + ], + [ + 22, + 66 + ], + [ + 22, + 67 + ], + [ + 22, + 68 + ], + [ + 22, + 70 + ], + [ + 22, + 79 + ], + [ + 22, + 81 + ], + [ + 22, + 82 + ], + [ + 22, + 84 + ], + [ + 22, + 85 + ], + [ + 22, + 102 + ], + [ + 23, + 5 + ], + [ + 23, + 14 + ], + [ + 23, + 24 + ], + [ + 23, + 25 + ], + [ + 23, + 27 + ], + [ + 23, + 37 + ], + [ + 23, + 38 + ], + [ + 23, + 39 + ], + [ + 23, + 44 + ], + [ + 23, + 45 + ], + [ + 23, + 46 + ], + [ + 23, + 53 + ], + [ + 23, + 54 + ], + [ + 23, + 59 + ], + [ + 23, + 61 + ], + [ + 23, + 66 + ], + [ + 23, + 71 + ], + [ + 23, + 72 + ], + [ + 23, + 73 + ], + [ + 23, + 74 + ], + [ + 23, + 79 + ], + [ + 23, + 81 + ], + [ + 23, + 86 + ], + [ + 23, + 87 + ], + [ + 23, + 101 + ], + [ + 25, + 2 + ], + [ + 25, + 3 + ], + [ + 25, + 29 + ], + [ + 25, + 30 + ], + [ + 25, + 32 + ], + [ + 25, + 41 + ], + [ + 25, + 48 + ], + [ + 25, + 60 + ], + [ + 25, + 63 + ], + [ + 28, + 2 + ], + [ + 28, + 3 + ], + [ + 28, + 29 + ], + [ + 28, + 30 + ], + [ + 28, + 32 + ], + [ + 28, + 36 + ], + [ + 28, + 64 + ], + [ + 28, + 83 + ], + [ + 28, + 90 + ], + [ + 28, + 92 + ], + [ + 31, + 13 + ], + [ + 31, + 28 + ], + [ + 31, + 29 + ], + [ + 31, + 30 + ], + [ + 31, + 32 + ], + [ + 31, + 36 + ], + [ + 31, + 48 + ], + [ + 31, + 90 + ], + [ + 31, + 92 + ], + [ + 32, + 18 + ], + [ + 32, + 28 + ], + [ + 32, + 29 + ], + [ + 32, + 30 + ], + [ + 32, + 36 + ], + [ + 32, + 41 + ], + [ + 32, + 83 + ], + [ + 32, + 90 + ], + [ + 32, + 92 + ], + [ + 32, + 93 + ], + [ + 33, + 8 + ], + [ + 33, + 10 + ], + [ + 33, + 12 + ], + [ + 33, + 16 + ], + [ + 33, + 20 + ], + [ + 33, + 25 + ], + [ + 33, + 27 + ], + [ + 33, + 35 + ], + [ + 33, + 37 + ], + [ + 33, + 43 + ], + [ + 33, + 45 + ], + [ + 33, + 47 + ], + [ + 33, + 56 + ], + [ + 33, + 61 + ], + [ + 33, + 66 + ], + [ + 33, + 68 + ], + [ + 33, + 72 + ], + [ + 33, + 77 + ], + [ + 33, + 84 + ], + [ + 34, + 13 + ], + [ + 34, + 18 + ], + [ + 34, + 28 + ], + [ + 34, + 30 + ], + [ + 34, + 32 + ], + [ + 34, + 36 + ], + [ + 34, + 57 + ], + [ + 34, + 60 + ], + [ + 34, + 63 + ], + [ + 34, + 69 + ], + [ + 34, + 83 + ], + [ + 34, + 90 + ], + [ + 34, + 92 + ], + [ + 34, + 93 + ], + [ + 34, + 95 + ], + [ + 35, + 1 + ], + [ + 35, + 2 + ], + [ + 35, + 3 + ], + [ + 35, + 4 + ], + [ + 35, + 13 + ], + [ + 35, + 30 + ], + [ + 35, + 32 + ], + [ + 35, + 41 + ], + [ + 35, + 48 + ], + [ + 35, + 64 + ], + [ + 35, + 90 + ], + [ + 35, + 93 + ], + [ + 35, + 95 + ], + [ + 36, + 1 + ], + [ + 36, + 2 + ], + [ + 36, + 3 + ], + [ + 36, + 4 + ], + [ + 36, + 18 + ], + [ + 36, + 28 + ], + [ + 36, + 29 + ], + [ + 36, + 32 + ], + [ + 36, + 63 + ], + [ + 36, + 69 + ], + [ + 36, + 92 + ], + [ + 36, + 93 + ], + [ + 37, + 29 + ], + [ + 37, + 32 + ], + [ + 37, + 36 + ], + [ + 37, + 41 + ], + [ + 37, + 48 + ], + [ + 37, + 57 + ], + [ + 37, + 60 + ], + [ + 37, + 64 + ], + [ + 37, + 83 + ], + [ + 37, + 93 + ], + [ + 38, + 1 + ], + [ + 38, + 3 + ], + [ + 38, + 28 + ], + [ + 38, + 32 + ], + [ + 38, + 36 + ], + [ + 38, + 69 + ], + [ + 38, + 90 + ], + [ + 38, + 93 + ], + [ + 39, + 2 + ], + [ + 39, + 4 + ], + [ + 39, + 18 + ], + [ + 39, + 32 + ], + [ + 39, + 36 + ], + [ + 39, + 69 + ], + [ + 39, + 93 + ], + [ + 40, + 1 + ], + [ + 40, + 2 + ], + [ + 40, + 5 + ], + [ + 40, + 7 + ], + [ + 40, + 9 + ], + [ + 40, + 18 + ], + [ + 40, + 19 + ], + [ + 40, + 20 + ], + [ + 40, + 21 + ], + [ + 40, + 22 + ], + [ + 40, + 27 + ], + [ + 40, + 28 + ], + [ + 40, + 29 + ], + [ + 40, + 30 + ], + [ + 40, + 32 + ], + [ + 40, + 33 + ], + [ + 40, + 34 + ], + [ + 40, + 36 + ], + [ + 40, + 42 + ], + [ + 40, + 43 + ], + [ + 40, + 44 + ], + [ + 40, + 46 + ], + [ + 40, + 47 + ], + [ + 40, + 54 + ], + [ + 40, + 55 + ], + [ + 40, + 56 + ], + [ + 40, + 57 + ], + [ + 40, + 59 + ], + [ + 40, + 63 + ], + [ + 40, + 70 + ], + [ + 40, + 71 + ], + [ + 40, + 72 + ], + [ + 40, + 73 + ], + [ + 40, + 75 + ], + [ + 40, + 83 + ], + [ + 40, + 84 + ], + [ + 40, + 85 + ], + [ + 40, + 86 + ], + [ + 40, + 92 + ], + [ + 40, + 93 + ], + [ + 40, + 95 + ], + [ + 40, + 96 + ], + [ + 40, + 97 + ], + [ + 40, + 102 + ], + [ + 41, + 3 + ], + [ + 41, + 4 + ], + [ + 41, + 29 + ], + [ + 41, + 30 + ], + [ + 41, + 32 + ], + [ + 41, + 48 + ], + [ + 41, + 60 + ], + [ + 41, + 64 + ], + [ + 41, + 69 + ], + [ + 41, + 93 + ], + [ + 41, + 95 + ], + [ + 42, + 1 + ], + [ + 42, + 4 + ], + [ + 42, + 28 + ], + [ + 42, + 30 + ], + [ + 42, + 32 + ], + [ + 42, + 41 + ], + [ + 42, + 57 + ], + [ + 42, + 83 + ], + [ + 42, + 90 + ], + [ + 42, + 93 + ], + [ + 42, + 95 + ], + [ + 43, + 5 + ], + [ + 43, + 11 + ], + [ + 43, + 12 + ], + [ + 43, + 15 + ], + [ + 43, + 16 + ], + [ + 43, + 24 + ], + [ + 43, + 25 + ], + [ + 43, + 27 + ], + [ + 43, + 33 + ], + [ + 43, + 35 + ], + [ + 43, + 39 + ], + [ + 43, + 42 + ], + [ + 43, + 45 + ], + [ + 43, + 46 + ], + [ + 43, + 56 + ], + [ + 43, + 66 + ], + [ + 43, + 67 + ], + [ + 43, + 72 + ], + [ + 43, + 73 + ], + [ + 43, + 74 + ], + [ + 43, + 78 + ], + [ + 43, + 79 + ], + [ + 43, + 84 + ], + [ + 44, + 2 + ], + [ + 44, + 3 + ], + [ + 44, + 13 + ], + [ + 44, + 28 + ], + [ + 44, + 29 + ], + [ + 44, + 32 + ], + [ + 44, + 36 + ], + [ + 44, + 41 + ], + [ + 44, + 60 + ], + [ + 44, + 93 + ], + [ + 45, + 1 + ], + [ + 45, + 4 + ], + [ + 45, + 13 + ], + [ + 45, + 18 + ], + [ + 45, + 29 + ], + [ + 45, + 32 + ], + [ + 45, + 36 + ], + [ + 45, + 41 + ], + [ + 45, + 60 + ], + [ + 45, + 90 + ], + [ + 45, + 93 + ], + [ + 48, + 8 + ], + [ + 48, + 12 + ], + [ + 48, + 14 + ], + [ + 48, + 15 + ], + [ + 48, + 19 + ], + [ + 48, + 25 + ], + [ + 48, + 33 + ], + [ + 48, + 35 + ], + [ + 48, + 37 + ], + [ + 48, + 46 + ], + [ + 48, + 47 + ], + [ + 48, + 49 + ], + [ + 48, + 54 + ], + [ + 48, + 55 + ], + [ + 48, + 56 + ], + [ + 48, + 58 + ], + [ + 48, + 73 + ], + [ + 48, + 77 + ], + [ + 48, + 78 + ], + [ + 48, + 79 + ], + [ + 48, + 103 + ], + [ + 49, + 1 + ], + [ + 49, + 4 + ], + [ + 49, + 13 + ], + [ + 49, + 18 + ], + [ + 49, + 28 + ], + [ + 49, + 30 + ], + [ + 49, + 48 + ], + [ + 49, + 57 + ], + [ + 49, + 90 + ], + [ + 49, + 95 + ], + [ + 50, + 2 + ], + [ + 50, + 3 + ], + [ + 50, + 13 + ], + [ + 50, + 30 + ], + [ + 50, + 57 + ], + [ + 50, + 95 + ], + [ + 51, + 2 + ], + [ + 51, + 3 + ], + [ + 51, + 18 + ], + [ + 51, + 28 + ], + [ + 51, + 29 + ], + [ + 51, + 36 + ], + [ + 51, + 48 + ], + [ + 51, + 60 + ], + [ + 51, + 83 + ], + [ + 53, + 7 + ], + [ + 53, + 10 + ], + [ + 53, + 11 + ], + [ + 53, + 16 + ], + [ + 53, + 20 + ], + [ + 53, + 23 + ], + [ + 53, + 24 + ], + [ + 53, + 27 + ], + [ + 53, + 38 + ], + [ + 53, + 39 + ], + [ + 53, + 46 + ], + [ + 53, + 47 + ], + [ + 53, + 49 + ], + [ + 53, + 54 + ], + [ + 53, + 59 + ], + [ + 53, + 61 + ], + [ + 53, + 71 + ], + [ + 53, + 72 + ], + [ + 53, + 74 + ], + [ + 53, + 76 + ], + [ + 53, + 81 + ], + [ + 53, + 82 + ], + [ + 53, + 85 + ], + [ + 53, + 87 + ], + [ + 53, + 101 + ], + [ + 53, + 103 + ], + [ + 57, + 28 + ], + [ + 57, + 30 + ], + [ + 57, + 64 + ], + [ + 57, + 83 + ], + [ + 57, + 95 + ], + [ + 58, + 11 + ], + [ + 58, + 12 + ], + [ + 58, + 14 + ], + [ + 58, + 19 + ], + [ + 58, + 20 + ], + [ + 58, + 24 + ], + [ + 58, + 25 + ], + [ + 58, + 35 + ], + [ + 58, + 42 + ], + [ + 58, + 49 + ], + [ + 58, + 54 + ], + [ + 58, + 55 + ], + [ + 58, + 56 + ], + [ + 58, + 61 + ], + [ + 58, + 67 + ], + [ + 58, + 68 + ], + [ + 58, + 74 + ], + [ + 58, + 82 + ], + [ + 58, + 87 + ], + [ + 58, + 102 + ], + [ + 58, + 103 + ], + [ + 60, + 13 + ], + [ + 60, + 18 + ], + [ + 60, + 29 + ], + [ + 60, + 41 + ], + [ + 60, + 48 + ], + [ + 60, + 63 + ], + [ + 60, + 69 + ], + [ + 60, + 83 + ], + [ + 60, + 90 + ], + [ + 60, + 92 + ], + [ + 62, + 2 + ], + [ + 62, + 4 + ], + [ + 62, + 13 + ], + [ + 62, + 57 + ], + [ + 62, + 60 + ], + [ + 62, + 63 + ], + [ + 62, + 64 + ], + [ + 62, + 90 + ], + [ + 62, + 92 + ], + [ + 64, + 3 + ], + [ + 64, + 4 + ], + [ + 64, + 13 + ], + [ + 64, + 28 + ], + [ + 64, + 41 + ], + [ + 64, + 48 + ], + [ + 64, + 57 + ], + [ + 64, + 63 + ], + [ + 64, + 83 + ], + [ + 64, + 93 + ], + [ + 64, + 95 + ], + [ + 65, + 1 + ], + [ + 65, + 4 + ], + [ + 65, + 13 + ], + [ + 65, + 29 + ], + [ + 65, + 60 + ], + [ + 65, + 63 + ], + [ + 65, + 64 + ], + [ + 65, + 69 + ], + [ + 65, + 90 + ], + [ + 65, + 93 + ], + [ + 65, + 95 + ], + [ + 67, + 5 + ], + [ + 67, + 11 + ], + [ + 67, + 12 + ], + [ + 67, + 14 + ], + [ + 67, + 19 + ], + [ + 67, + 20 + ], + [ + 67, + 24 + ], + [ + 67, + 25 + ], + [ + 67, + 27 + ], + [ + 67, + 37 + ], + [ + 67, + 38 + ], + [ + 67, + 43 + ], + [ + 67, + 44 + ], + [ + 67, + 56 + ], + [ + 67, + 58 + ], + [ + 67, + 65 + ], + [ + 67, + 68 + ], + [ + 67, + 70 + ], + [ + 67, + 71 + ], + [ + 67, + 76 + ], + [ + 67, + 77 + ], + [ + 67, + 79 + ], + [ + 67, + 82 + ], + [ + 67, + 84 + ], + [ + 67, + 101 + ], + [ + 69, + 3 + ], + [ + 69, + 4 + ], + [ + 69, + 18 + ], + [ + 69, + 29 + ], + [ + 69, + 30 + ], + [ + 69, + 36 + ], + [ + 69, + 41 + ], + [ + 69, + 48 + ], + [ + 69, + 60 + ], + [ + 69, + 63 + ], + [ + 69, + 93 + ], + [ + 70, + 5 + ], + [ + 70, + 7 + ], + [ + 70, + 8 + ], + [ + 70, + 14 + ], + [ + 70, + 15 + ], + [ + 70, + 16 + ], + [ + 70, + 27 + ], + [ + 70, + 35 + ], + [ + 70, + 37 + ], + [ + 70, + 38 + ], + [ + 70, + 39 + ], + [ + 70, + 47 + ], + [ + 70, + 54 + ], + [ + 70, + 55 + ], + [ + 70, + 56 + ], + [ + 70, + 59 + ], + [ + 70, + 65 + ], + [ + 70, + 66 + ], + [ + 70, + 67 + ], + [ + 70, + 68 + ], + [ + 70, + 74 + ], + [ + 70, + 76 + ], + [ + 70, + 77 + ], + [ + 70, + 78 + ], + [ + 70, + 84 + ], + [ + 70, + 85 + ], + [ + 70, + 86 + ], + [ + 70, + 101 + ], + [ + 71, + 2 + ], + [ + 71, + 4 + ], + [ + 71, + 41 + ], + [ + 71, + 63 + ], + [ + 71, + 64 + ], + [ + 71, + 93 + ], + [ + 71, + 95 + ], + [ + 72, + 1 + ], + [ + 72, + 3 + ], + [ + 72, + 18 + ], + [ + 72, + 28 + ], + [ + 72, + 41 + ], + [ + 72, + 63 + ], + [ + 72, + 64 + ], + [ + 72, + 93 + ], + [ + 72, + 95 + ], + [ + 73, + 29 + ], + [ + 73, + 48 + ], + [ + 73, + 57 + ], + [ + 73, + 60 + ], + [ + 73, + 63 + ], + [ + 73, + 69 + ], + [ + 73, + 83 + ], + [ + 73, + 93 + ], + [ + 73, + 95 + ], + [ + 74, + 1 + ], + [ + 74, + 2 + ], + [ + 74, + 3 + ], + [ + 74, + 4 + ], + [ + 74, + 28 + ], + [ + 74, + 29 + ], + [ + 74, + 36 + ], + [ + 74, + 41 + ], + [ + 74, + 64 + ], + [ + 74, + 92 + ], + [ + 74, + 93 + ], + [ + 74, + 95 + ], + [ + 76, + 13 + ], + [ + 76, + 28 + ], + [ + 76, + 30 + ], + [ + 76, + 41 + ], + [ + 76, + 57 + ], + [ + 76, + 60 + ], + [ + 76, + 64 + ], + [ + 76, + 83 + ], + [ + 76, + 90 + ], + [ + 76, + 92 + ], + [ + 76, + 93 + ], + [ + 77, + 1 + ], + [ + 77, + 3 + ], + [ + 77, + 13 + ], + [ + 77, + 29 + ], + [ + 77, + 30 + ], + [ + 77, + 48 + ], + [ + 77, + 69 + ], + [ + 77, + 92 + ], + [ + 77, + 93 + ], + [ + 78, + 2 + ], + [ + 78, + 4 + ], + [ + 78, + 13 + ], + [ + 78, + 18 + ], + [ + 78, + 28 + ], + [ + 78, + 29 + ], + [ + 78, + 30 + ], + [ + 78, + 48 + ], + [ + 78, + 69 + ], + [ + 78, + 90 + ], + [ + 78, + 92 + ], + [ + 78, + 93 + ], + [ + 79, + 2 + ], + [ + 79, + 4 + ], + [ + 79, + 13 + ], + [ + 79, + 18 + ], + [ + 79, + 32 + ], + [ + 79, + 48 + ], + [ + 79, + 63 + ], + [ + 79, + 64 + ], + [ + 79, + 83 + ], + [ + 79, + 95 + ], + [ + 81, + 29 + ], + [ + 81, + 41 + ], + [ + 81, + 57 + ], + [ + 81, + 60 + ], + [ + 81, + 63 + ], + [ + 81, + 69 + ], + [ + 81, + 95 + ], + [ + 84, + 1 + ], + [ + 84, + 3 + ], + [ + 84, + 18 + ], + [ + 84, + 29 + ], + [ + 84, + 30 + ], + [ + 84, + 32 + ], + [ + 84, + 41 + ], + [ + 84, + 69 + ], + [ + 84, + 83 + ], + [ + 84, + 92 + ], + [ + 85, + 7 + ], + [ + 85, + 8 + ], + [ + 85, + 10 + ], + [ + 85, + 19 + ], + [ + 85, + 20 + ], + [ + 85, + 39 + ], + [ + 85, + 42 + ], + [ + 85, + 44 + ], + [ + 85, + 53 + ], + [ + 85, + 54 + ], + [ + 85, + 55 + ], + [ + 85, + 66 + ], + [ + 85, + 68 + ], + [ + 85, + 70 + ], + [ + 85, + 71 + ], + [ + 85, + 78 + ], + [ + 85, + 81 + ], + [ + 85, + 82 + ], + [ + 85, + 84 + ], + [ + 85, + 101 + ], + [ + 85, + 103 + ], + [ + 86, + 1 + ], + [ + 86, + 2 + ], + [ + 86, + 32 + ], + [ + 86, + 57 + ], + [ + 86, + 63 + ], + [ + 86, + 90 + ], + [ + 86, + 95 + ], + [ + 88, + 1 + ], + [ + 88, + 4 + ], + [ + 88, + 18 + ], + [ + 88, + 29 + ], + [ + 88, + 32 + ], + [ + 88, + 36 + ], + [ + 88, + 57 + ], + [ + 88, + 92 + ], + [ + 88, + 95 + ], + [ + 89, + 5 + ], + [ + 89, + 11 + ], + [ + 89, + 12 + ], + [ + 89, + 14 + ], + [ + 89, + 19 + ], + [ + 89, + 20 + ], + [ + 89, + 23 + ], + [ + 89, + 38 + ], + [ + 89, + 43 + ], + [ + 89, + 44 + ], + [ + 89, + 56 + ], + [ + 89, + 58 + ], + [ + 89, + 66 + ], + [ + 89, + 67 + ], + [ + 89, + 72 + ], + [ + 89, + 73 + ], + [ + 89, + 74 + ], + [ + 89, + 78 + ], + [ + 89, + 81 + ], + [ + 89, + 85 + ], + [ + 89, + 86 + ], + [ + 89, + 87 + ], + [ + 89, + 102 + ], + [ + 89, + 103 + ], + [ + 91, + 8 + ], + [ + 91, + 12 + ], + [ + 91, + 16 + ], + [ + 91, + 25 + ], + [ + 91, + 33 + ], + [ + 91, + 35 + ], + [ + 91, + 37 + ], + [ + 91, + 46 + ], + [ + 91, + 53 + ], + [ + 91, + 59 + ], + [ + 91, + 61 + ], + [ + 91, + 73 + ], + [ + 91, + 77 + ], + [ + 91, + 78 + ], + [ + 91, + 81 + ], + [ + 91, + 82 + ], + [ + 91, + 84 + ], + [ + 91, + 85 + ], + [ + 91, + 86 + ], + [ + 91, + 101 + ], + [ + 91, + 102 + ], + [ + 91, + 103 + ], + [ + 92, + 1 + ], + [ + 92, + 2 + ], + [ + 92, + 13 + ], + [ + 92, + 18 + ], + [ + 92, + 28 + ], + [ + 92, + 29 + ], + [ + 92, + 30 + ], + [ + 92, + 32 + ], + [ + 92, + 36 + ], + [ + 92, + 60 + ], + [ + 92, + 63 + ], + [ + 92, + 83 + ], + [ + 92, + 90 + ], + [ + 93, + 18 + ], + [ + 93, + 32 + ], + [ + 93, + 36 + ], + [ + 93, + 41 + ], + [ + 93, + 63 + ], + [ + 93, + 64 + ], + [ + 93, + 69 + ], + [ + 93, + 95 + ], + [ + 94, + 7 + ], + [ + 94, + 8 + ], + [ + 94, + 10 + ], + [ + 94, + 11 + ], + [ + 94, + 12 + ], + [ + 94, + 33 + ], + [ + 94, + 35 + ], + [ + 94, + 37 + ], + [ + 94, + 38 + ], + [ + 94, + 39 + ], + [ + 94, + 47 + ], + [ + 94, + 49 + ], + [ + 94, + 53 + ], + [ + 94, + 54 + ], + [ + 94, + 65 + ], + [ + 94, + 66 + ], + [ + 94, + 67 + ], + [ + 94, + 68 + ], + [ + 94, + 70 + ], + [ + 94, + 79 + ], + [ + 94, + 81 + ], + [ + 94, + 82 + ], + [ + 94, + 84 + ], + [ + 94, + 85 + ], + [ + 94, + 101 + ], + [ + 94, + 103 + ], + [ + 96, + 7 + ], + [ + 96, + 12 + ], + [ + 96, + 15 + ], + [ + 96, + 20 + ], + [ + 96, + 24 + ], + [ + 96, + 33 + ], + [ + 96, + 37 + ], + [ + 96, + 45 + ], + [ + 96, + 47 + ], + [ + 96, + 55 + ], + [ + 96, + 56 + ], + [ + 96, + 59 + ], + [ + 96, + 67 + ], + [ + 96, + 68 + ], + [ + 96, + 71 + ], + [ + 96, + 72 + ], + [ + 96, + 76 + ], + [ + 96, + 79 + ], + [ + 96, + 82 + ], + [ + 96, + 86 + ], + [ + 96, + 87 + ], + [ + 96, + 101 + ], + [ + 96, + 102 + ], + [ + 96, + 103 + ], + [ + 98, + 5 + ], + [ + 98, + 10 + ], + [ + 98, + 27 + ], + [ + 98, + 35 + ], + [ + 98, + 37 + ], + [ + 98, + 38 + ], + [ + 98, + 42 + ], + [ + 98, + 44 + ], + [ + 98, + 49 + ], + [ + 98, + 54 + ], + [ + 98, + 55 + ], + [ + 98, + 58 + ], + [ + 98, + 61 + ], + [ + 98, + 65 + ], + [ + 98, + 67 + ], + [ + 98, + 70 + ], + [ + 98, + 71 + ], + [ + 98, + 74 + ], + [ + 98, + 76 + ], + [ + 98, + 77 + ], + [ + 98, + 79 + ], + [ + 98, + 84 + ], + [ + 98, + 87 + ], + [ + 98, + 101 + ], + [ + 98, + 102 + ], + [ + 98, + 103 + ], + [ + 99, + 2 + ], + [ + 99, + 3 + ], + [ + 99, + 28 + ], + [ + 99, + 41 + ], + [ + 99, + 48 + ], + [ + 99, + 60 + ], + [ + 99, + 64 + ], + [ + 99, + 83 + ], + [ + 99, + 90 + ], + [ + 99, + 92 + ], + [ + 99, + 93 + ], + [ + 99, + 95 + ], + [ + 101, + 5 + ], + [ + 101, + 14 + ], + [ + 101, + 23 + ], + [ + 101, + 37 + ], + [ + 101, + 38 + ], + [ + 101, + 39 + ], + [ + 101, + 44 + ], + [ + 101, + 45 + ], + [ + 101, + 46 + ], + [ + 101, + 53 + ], + [ + 101, + 54 + ], + [ + 101, + 59 + ], + [ + 101, + 61 + ], + [ + 101, + 67 + ], + [ + 101, + 68 + ], + [ + 101, + 70 + ], + [ + 101, + 76 + ], + [ + 101, + 77 + ], + [ + 101, + 78 + ], + [ + 101, + 82 + ], + [ + 101, + 84 + ], + [ + 101, + 85 + ], + [ + 101, + 102 + ], + [ + 101, + 103 + ], + [ + 103, + 14 + ], + [ + 103, + 15 + ], + [ + 103, + 16 + ], + [ + 103, + 19 + ], + [ + 103, + 20 + ], + [ + 103, + 47 + ], + [ + 103, + 49 + ], + [ + 103, + 53 + ], + [ + 103, + 54 + ], + [ + 103, + 55 + ], + [ + 103, + 56 + ], + [ + 103, + 59 + ], + [ + 103, + 61 + ], + [ + 103, + 79 + ], + [ + 103, + 81 + ], + [ + 103, + 84 + ], + [ + 103, + 85 + ], + [ + 103, + 86 + ], + [ + 103, + 87 + ], + [ + 103, + 101 + ] + ], + "classes": [ + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 40, + 64, + 136, + 264 + ], + [ + 13, + 37, + 64, + 133, + 261 + ], + [ + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1026, + "multiplicity": 8217, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 40, + 64, + 136, + 264 + ], + [ + 13, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1023, + "multiplicity": 252, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000140", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d2315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 40, + 64, + 136, + 264 + ], + [ + 31, + 40, + 64, + 136, + 264 + ], + [ + 2, + 29, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1002, + "multiplicity": 36, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 40, + 64, + 136, + 264 + ], + [ + 2, + 40, + 64, + 136, + 264 + ], + [ + 2, + 29, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1023, + "multiplicity": 108, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000140", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d2315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 40, + 64, + 136, + 264 + ], + [ + 2, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1023, + "multiplicity": 54, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000140", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d2315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 37, + 77, + 133, + 261 + ], + [ + 18, + 37, + 77, + 133, + 261 + ], + [ + 15, + 18, + 37, + 66, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1025, + "multiplicity": 54, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821da1d0315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 55, + 95, + 151, + 279 + ], + [ + 2, + 53, + 93, + 149, + 277 + ], + [ + 2, + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1020, + "multiplicity": 36, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f466225f", + "1fff090823d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466227f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466265f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466225f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466225f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 31, + 104, + 160, + 288 + ], + [ + 31, + 39, + 79, + 135, + 263 + ], + [ + 2, + 29, + 37, + 77, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1002, + "multiplicity": 108, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 31, + 104, + 160, + 288 + ], + [ + 31, + 40, + 64, + 136, + 264 + ], + [ + 2, + 29, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1002, + "multiplicity": 18, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 64, + 136, + 288 + ], + [ + 2, + 64, + 136, + 288 + ], + [ + 2, + 56, + 64, + 136, + 280 + ], + [ + 2, + 13, + 53, + 64, + 133, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1023, + "multiplicity": 36, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000140", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d2315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 64, + 136, + 288 + ], + [ + 2, + 64, + 136, + 288 + ], + [ + 2, + 40, + 64, + 136, + 264 + ], + [ + 2, + 29, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1023, + "multiplicity": 18, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000140", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d2315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 64, + 136, + 288 + ], + [ + 2, + 64, + 136, + 288 + ], + [ + 2, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1023, + "multiplicity": 9, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000140", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d2315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 122, + 178, + 288 + ], + [ + 55, + 77, + 133, + 279 + ], + [ + 13, + 55, + 64, + 133, + 279 + ], + [ + 2, + 13, + 53, + 64, + 133, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1025, + "multiplicity": 54, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821da1d0315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 122, + 178, + 288 + ], + [ + 55, + 77, + 133, + 279 + ], + [ + 18, + 37, + 77, + 133, + 261 + ], + [ + 15, + 18, + 37, + 66, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1025, + "multiplicity": 9, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821da1d0315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 53, + 93, + 149, + 277 + ], + [ + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1020, + "multiplicity": 108, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f466225f", + "1fff090823d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466227f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466265f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466225f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466225f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 53, + 93, + 149, + 277 + ], + [ + 2, + 53, + 93, + 149, + 277 + ], + [ + 2, + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1020, + "multiplicity": 18, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f466225f", + "1fff090823d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466227f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466265f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466225f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466225f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 31, + 200, + 288 + ], + [ + 31, + 103, + 175, + 288 + ], + [ + 31, + 39, + 64, + 136, + 263 + ], + [ + 2, + 29, + 37, + 64, + 136, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1026, + "multiplicity": 252, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 31, + 200, + 288 + ], + [ + 31, + 104, + 160, + 288 + ], + [ + 31, + 39, + 79, + 135, + 263 + ], + [ + 2, + 29, + 37, + 77, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1002, + "multiplicity": 54, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 31, + 200, + 288 + ], + [ + 31, + 104, + 160, + 288 + ], + [ + 31, + 40, + 64, + 136, + 264 + ], + [ + 2, + 29, + 40, + 64, + 136, + 264 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1002, + "multiplicity": 9, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "1fff090821d21d0315f466221f", + "1fff090823d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466223f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466261f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f476221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466221f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466221f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466221f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 53, + 200, + 277 + ], + [ + 53, + 77, + 133, + 277 + ], + [ + 13, + 53, + 64, + 133, + 277 + ], + [ + 2, + 13, + 53, + 64, + 133, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1020, + "multiplicity": 252, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f466225f", + "1fff090823d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466227f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466265f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466225f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466225f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 53, + 200, + 277 + ], + [ + 53, + 93, + 149, + 277 + ], + [ + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1020, + "multiplicity": 54, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f466225f", + "1fff090823d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466227f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466265f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466225f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466225f" + ] + }, + { + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 53, + 200, + 277 + ], + [ + 53, + 93, + 149, + 277 + ], + [ + 2, + 53, + 93, + 149, + 277 + ], + [ + 2, + 13, + 53, + 80, + 149, + 277 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ], + "missing": 1020, + "multiplicity": 9, + "source_support_by_target_hex": [ + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff090821d21d2315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdff1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff5bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f466225f", + "1fff090823d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7fffe6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6ffefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0395f466227f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "00000000000000220000000100", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "5fff0d0821d61d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "1fff890821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfffdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff190821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0b15f466265f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4ff7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8fffdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdefcffbffe1", + "ffffffffffffffffffffffffff", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0335f466225f", + "1fff090821d21d0315f466225f", + "1fff090821d21d0315f476225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ff4bf7ffde6dfefdee8ffbdfe1", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d1315f466225f", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ff4bf7ffde6dfefdee8ffbdfe1", + "ffffffffffffffffffffffffff", + "1fff090821d21d0315f466225f", + "ffffffffffffffffffffffffff", + "5fff0d0821d61d0315f466225f" + ] + } + ], + "contact_profiles": 22, + "cut": { + "all_target_writers": [ + [ + 8, + 17 + ], + [ + 8, + 83 + ] + ], + "arrival_8_basis": [ + 2, + 13, + 20, + 37, + 64, + 133, + 261 + ], + "complete_contacts_by_dimension": { + "13": [ + [ + 12 + ], + [], + [ + 63, + 185 + ], + [ + 63, + 91, + 118, + 185 + ], + [ + 63, + 91, + 118, + 185 + ], + [ + 91 + ], + [], + [ + 124 + ] + ], + "17": [ + [ + 16 + ], + [], + [], + [], + [], + [], + [], + [ + 83 + ] + ], + "83": [ + [ + 82 + ], + [], + [], + [ + 91 + ], + [ + 91 + ], + [ + 91 + ], + [], + [ + 17 + ] + ], + "91": [ + [ + 90 + ], + [], + [], + [ + 13, + 83 + ], + [ + 13, + 83 + ], + [ + 13, + 83 + ], + [], + [ + 183 + ] + ] + }, + "distinguished_source": 1, + "local_reads_by_dimension": { + "13": [ + [ + 6 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "17": [ + [ + 8 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "83": [ + [ + 41 + ], + [], + [], + [], + [], + [], + [], + [] + ], + "91": [ + [ + 45 + ], + [], + [], + [], + [], + [], + [], + [] + ] + }, + "local_writes_by_dimension": { + "13": [ + [], + [], + [], + [], + [], + [], + [], + [ + 90 + ] + ], + "17": [ + [], + [], + [], + [], + [], + [], + [], + [ + 40 + ] + ], + "83": [ + [], + [], + [], + [], + [], + [], + [], + [ + 40 + ] + ], + "91": [ + [], + [], + [], + [], + [], + [], + [], + [ + 4 + ] + ] + }, + "missing_required_sources": [ + 1, + 2, + 5, + 7, + 9, + 18, + 19, + 20, + 21, + 22, + 27, + 28, + 29, + 30, + 32, + 33, + 34, + 36, + 42, + 43, + 44, + 46, + 47, + 54, + 55, + 56, + 57, + 59, + 63, + 70, + 71, + 72, + 73, + 75, + 83, + 84, + 85, + 86, + 92, + 93, + 95, + 96, + 97, + 102 + ], + "nonnested_positive_control": { + "X1_reaches_Y40": true, + "flag_bases": [ + [ + 200 + ], + [ + 200, + 288 + ], + [ + 104, + 160, + 288 + ], + [ + 2, + 53, + 200, + 277 + ], + [ + 13, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 37, + 64, + 133, + 261 + ], + [ + 2, + 13, + 16, + 37, + 64, + 133, + 261 + ], + [ + 1, + 2, + 12, + 16, + 36, + 64, + 132, + 260 + ] + ] + }, + "required_coefficient": "1/2", + "separators": [ + { + "incoming": 63, + "incoming_departure_basis": [ + 31, + 288 + ], + "outgoing": 91, + "outgoing_arrival_slot": 8, + "vector": 31 + }, + { + "incoming": 118, + "incoming_departure_basis": [ + 178, + 365 + ], + "outgoing": 91, + "outgoing_arrival_slot": 8, + "vector": 178 + }, + { + "incoming": 185, + "incoming_departure_basis": [ + 253, + 288 + ], + "outgoing": 91, + "outgoing_arrival_slot": 8, + "vector": 253 + } + ], + "source_support_upper_bound": [ + 6, + 8, + 41, + 45 + ], + "target": 40 + }, + "first_missing_coefficient": "1/2", + "flags": 9765, + "helper": 13, + "matching_sha256": "f0dcf1c7c8c206cab763184a36e959f6106bbe0269238265ec5c82949fdb3b56", + "missing_histogram": { + "1002": 225, + "1020": 477, + "1023": 477, + "1025": 117, + "1026": 8469 + }, + "no_new_kappa": true, + "quotient_subspace_counts": [ + 1, + 31, + 155, + 155, + 31, + 1 + ], + "relaxed_missing": 0, + "schema_version": 1, + "source_response_binding": { + "dirty_entrance_columns_replayed": false, + "events": 4058, + "native_realization_replayed": false, + "private_copies": 8, + "required_X1_Y40_correction": "1/2", + "scalar_adds": 2624, + "source_columns": 104, + "target_coefficients": 10816 + } +} diff --git a/research/p104-moved-helper-cut/SOURCES.json b/research/p104-moved-helper-cut/SOURCES.json new file mode 100644 index 0000000000..b5990853f0 --- /dev/null +++ b/research/p104-moved-helper-cut/SOURCES.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/p104-alternating-cycle-neighborhood/WITNESS.json", + "usage": "input", + "git_blob": "7afc436432e0396aef29b980ecedd1bc6cf1e6ee", + "sha256": "2feec3353d7e7fcf91863ae094a954c7ae3756ac7bb1b60113c1770e4885d42e" + }, + { + "path": "research/p104-joint-unit-flags/CERTIFICATE.json", + "usage": "input", + "git_blob": "0fa7d2d40566e92f3ea1539723abf438ba65adb8", + "sha256": "a98126428a8da6eae91c50afcc42e014a284c82b554ef77e5b3a34fc6d228128" + }, + { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "usage": "input", + "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "usage": "input", + "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + { + "path": "research/p104-coherent-support-witness/CONTROL.json", + "usage": "input", + "git_blob": "3eba7854a964479bce9edb90ef2a2f5da5416ea9", + "sha256": "3aa3b4bd1e7389005b6c05b08d43d390ebda0ac155945c01111c3da25f2cb74e" + } + ], + "predecessors": [ + { + "pr": 3124, + "head": "ce468c5cf22f59db3071adda269ac4cc16469c8c", + "author": "Cinna Davis (@1337isnot1337)", + "role": "Exact published cycle-A matching and joint-consistency handoff" + }, + { + "pr": 3182, + "head": "ad848966cd62e13de5ad8d4b5169c221d74d2fcd", + "author": "dcharb78", + "role": "Prior helper-13 obstruction and reported histogram, independently corroborated; no code or output imported" + }, + { + "pr": 3032, + "head": "5b1a7939393ef2778ec058ee8367cdad52c86fb3", + "author": "Ross Richardson", + "role": "One-helper monotone cut method for the different PR3019 matching" + }, + { + "pr": 3019, + "head": "44d12bdeb8ade4066645bd968bebd4756b06200a", + "author": "Nick Petalas", + "role": "Retained PR3013 control pairing" + }, + { + "pr": 3013, + "head": "504dc9a15f7a874a47564cdf3ae6857bbbc8d000", + "author": "Nick Petalas", + "role": "Cycle baseline and matching-coherent support screen" + }, + { + "pr": 2981, + "head": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "author": "Nick Petalas", + "role": "Static endpoint cover data" + } + ] +} diff --git a/research/p104-moved-helper-cut/TASK.json b/research/p104-moved-helper-cut/TASK.json new file mode 100644 index 0000000000..4746ba7d12 --- /dev/null +++ b/research/p104-moved-helper-cut/TASK.json @@ -0,0 +1,133 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 6, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "original_card": { + "id": "p104-side-correction", + "question": "Can the proposed P104 joint endpoint flags be realized by a chronological correction program with coefficients, dirty restoration and an affordable complete bill?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md", + "research/p104-joint-unit-flags/README.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2981 static joint flags, alongside the reviewed #1991 channel. #2981 is an author-checked source archive, not an independently validated executable correction or a refutation of program-level lifetime floors.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "After checking live handoffs, pin one named collection from #2981 and attach acquisition/delivery times, source dependencies and coefficient requirements. Test legal access and arbitrary dirty restoration; price any completion against the full channel/endpoint/hosting allowance. Stop with the exact missing implication or a scoped counterexample rather than expanding the static cover census.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.", + "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition", + "2981", + "joint unit flags", + "acquisition delivery", + "static nesting" + ], + "existing_checks": [ + { + "scope": "PR #2981 reports static joint endpoint flags and a matching of 208 departure and arrival flags; archival intake is not independent verification.", + "evidence": "research/p104-joint-unit-flags/README.md", + "remaining": "Independent flag check and a chronological coefficient program with dirty restoration and a complete cost.", + "status": "author-checked", + "source_commit": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Independent literal-subspace audit and small Y40 cut for helper 13 of the exact PR3124 cycle [13,203,191,63] matching; all 9765 nested flags, all other helpers relaxed.", + "scope_change_reason": "The revision 6 static-collection question now has a named successor and an archived moved-helper exclusion. Independently check that missing consistency implication, rather than reconstructing the old static matching or treating the newer archive as admitted.", + "bottleneck_link": "A failure to deliver a required I-G/2 coefficient rejects this exact proposed 208-helper correction before paying for coefficients, dirty restoration and the complete physical consumer.", + "budget_minutes": 60, + "stop_rule": "Finish the source-bound helper 13 certificate or a precise counterexample/gap. Do not search new matchings or infer a universal lifetime floor.", + "outcome": "completed", + "evidence": "RESULT.json; complete 9765-flag census in 22 interface classes; two new support algorithms agree; compact source-bound Y40 proof excludes 44 required coefficients; eleven behavioral test groups. All 104 original logical source columns bind the 10816 Gram coefficients to the actual word; native and independent dirty entrance columns remain inherited. A separately implemented algebraic interval-contact checker and reverse Y40 sensitivity agree with the literal geometry and forward replay; all 17424 F2^3 interval/contact cases checked.", + "author": "commdata2338", + "ai_assistance": "OpenAI Codex (GPT-6 Astra) derived, implemented, checked and wrote the package. No independent human or proof-kernel review is claimed.", + "open_questions": [ + { + "question": "Can a changed named matching or source/frame contract pass joint consistency before coefficient synthesis?", + "why_it_matters": "The exact PR3124 matching fails despite passing a relaxed support and helper-91 screen.", + "first_step": "State one changed premise and independently reconstruct its legal source-to-target paths; do not repeat this fixed matching.", + "blocked_by": "Consistent coefficients, real chronology, dirty restoration and complete physical/consumer cost remain unknown." + }, + { + "question": "Which other PR3182 archived conclusions survive independent semantic validation?", + "why_it_matters": "This audit covers only helper 13 of cycle A and cannot validate one-hop/memory propagation or the cost table.", + "first_step": "Choose one uncovered named claim, check active overlap, and test its precise graph or accounting premise.", + "blocked_by": "No other PR3182 result is imported or certified by this package." + } + ], + "scope_key": "72dfbf0708467ad34793/PR3124-cycleA-helper13-literal-frame-consistency-audit", + "declared_milestone": "independent audit and scoped proof", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2245#discussioncomment-19001906", + "overlap": { + "nearest_prs": [ + 2981, + 2996, + 3013, + 3019, + 3032, + 3124, + 3182 + ], + "added_value": "Separately implemented geometry and propagation corroborate the prior helper-13 exclusion; explicit three-vector Y40 proof and full source-support receipt. No code/results imported. Other PR3182 propagation claims are outside scope.", + "coverage": "Complete cached 245 open PRs at 2026-10-17T17:04:11.636955+00:00; 1985 Discussion records at 17:04:42.538402+00:00; main packages and exact-head intake checked. Offline cache may miss newer work.", + "final_coverage": "251 open PRs including drafts at 2026-10-17T17:37:12.534077+00:00; 2015 Discussion records at 17:39:04.580509+00:00; complete pagination. Final search 2026-10-17T17:49:04.839784+00:00; offline warnings retained.", + "parallel_claims": "Discussion #2245 comment 19001775 studies PR3182 one-hop/memory support semantics; Discussion #2750 comment 19001927 studies PR3131 multiplicity-two collector execution. Both are distinct from the nested helper-13 cut." + }, + "family_decision": { + "decision": "stop this matching under its fixed contract; no expansion", + "target": "208 monotone unit-step helper flags with immutable X and unread Y", + "proved": "Helper 13 cannot acquire an outside source through 63/118/185 and subsequently deliver it to 91. Y40 added support lies in {6,8,41,45}, so 44 coefficients are missing. All 9765 helper-13 flags fail the favorable full support test.", + "inherited": "Native transport realization and arbitrary dirty/target entrance columns; 1872 formal rank-one helper steps and favorable predecessor transport/idle screen, not revalidated.", + "unknown": [ + "actual chronological coefficients", + "dirty restoration", + "native scalar transfers", + "physical routing and owners", + "precision and tape", + "complete consumer bill" + ], + "reopen_if": "A named change of matching, cover, source access or monotonicity removes the separating obligation, followed by an updated complete ledger." + }, + "refresh_checkpoint": { + "utc": "2026-10-17T17:49:04.913005+00:00", + "canonical_main": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "priority_revision": 6, + "changes": "No main, guidance, selected-record or input changes since the initial base. Continue the scoped audit with frozen inputs." + } +} diff --git a/research/p104-moved-helper-cut/VERIFY.json b/research/p104-moved-helper-cut/VERIFY.json new file mode 100644 index 0000000000..9f0fad97e3 --- /dev/null +++ b/research/p104-moved-helper-cut/VERIFY.json @@ -0,0 +1,58 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-alternating-cycle-neighborhood/WITNESS.json", + "research/p104-joint-unit-flags/CERTIFICATE.json", + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-native-channel/inputs/P104-FIXTURE.json", + "research/p104-coherent-support-witness/CONTROL.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Original 104 source columns and common-frame binding; literal subspaces; all 9765 flags; two support engines; full receipt and geometric cut" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same complete mathematical certificate with Python assertions disabled" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/check_cut.py" + ], + "timeout_seconds": 120, + "checks": "Independent Gaussian elimination of local contact geometry and reverse pullback of all Y40 coefficients; no main/predecessor checker imported" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "Eleven behavioral groups including 17424 small exact interval cases, source/read/write/time semantics, nestedness, altered contacts/coefficient, basis/port-order binding and optimized Git-free corruption controls" + } + ] +} diff --git a/research/p104-moved-helper-cut/check_cut.py b/research/p104-moved-helper-cut/check_cut.py new file mode 100644 index 0000000000..f158b566db --- /dev/null +++ b/research/p104-moved-helper-cut/check_cut.py @@ -0,0 +1,175 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Second cut check: binary elimination and reverse scalar sensitivity. + +No imports from verify.py or any predecessor package. The interval-contact +lemma is credited to the PR2996 lineage. Prepared for commdata2338 with +substantial OpenAI Codex assistance; not a formal-kernel proof. +""" +import hashlib +import json +from collections import defaultdict +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def check(condition, message): + if not condition: + raise ValueError(message) + + +def reduced(rows): + pivots = {} + for value in rows: + for bit in sorted(pivots, reverse=True): + if value >> bit & 1: + value ^= pivots[bit] + if value: + bit = value.bit_length() - 1 + for other in list(pivots): + if pivots[other] >> bit & 1: + pivots[other] ^= value + pivots[bit] = value + return tuple(pivots[k] for k in sorted(pivots, reverse=True)) + + +def contains(large, small): + return len(reduced((*large, *small))) == len(large) + + +def hyperplane(rows, functional): + odd = [v for v in rows if (v & functional).bit_count() & 1] + check(odd, "nonconstant hyperplane functional") + pivot = odd[0] + return reduced(v ^ pivot if (v & functional).bit_count() & 1 else v + for v in rows if v != pivot) + + +def possible_contact(left, right, dimension): + a, b = left + c, d = right + joined_low = reduced((*a, *c)) + intersection_dimension = len(b) + len(d) - len(reduced((*b, *d))) + return (len(joined_low) <= dimension <= intersection_dimension + and contains(b, joined_low) and contains(d, joined_low)) + + +def fits(bounds, frame, dimension): + low, high = bounds + return len(frame) == dimension and contains(frame, low) and contains(high, frame) + + +def load(): + result = {} + manifest = json.loads((HERE / "SOURCES.json").read_text()) + for record in manifest["files"]: + if record["usage"] == "input": + raw = (ROOT / record["path"]).read_bytes() + check(hashlib.sha256(raw).hexdigest() == record["sha256"], "source digest") + result[Path(record["path"]).name] = json.loads(raw) + return result + + +def target_row(word, target=40): + """Reverse-mode scalar pullback of one complete logical target row.""" + weights = defaultdict(Fraction, {f"Y{target}": Fraction(1)}) + copies = 0 + for event in reversed(word["program"]): + op, name = event[:2] + if op == "add": + weights[event[2]] += Fraction(event[3]) * weights[name] + elif op == "copy": + weights[event[2]] += weights[name] + weights[name] = Fraction(0) + copies += 1 + elif op in ("erase", "zero"): + weights[name] = Fraction(0) + else: + check(op == "transport", "known logical opcode") + check(copies == 8, "all private lifetimes pulled back") + for name in word["initial_frames"]: + if not name.startswith("X"): + check(weights[name] == int(name == f"Y{target}"), "target entrance/dirt response") + return [Fraction(int(s == target)) - weights[f"X{s}"] for s in range(104)] + + +def derive(inputs): + word = inputs["LOWRANK-WITNESS.json"] + paths = {f"{kind}{i}": [reduced(word["initial_frames"][f"{kind}{i}"])] + for kind in "XY" for i in range(104)} + for event in word["program"]: + if event[0] == "transport" and event[1] in paths: + chain = paths[event[1]] + before, after = reduced(event[2]), reduced(event[3]) + check(chain[-1] == before and contains(after, before), "data path continuity") + chain.append(after) + for name, chain in paths.items(): + check(chain[-1] == reduced(word["final_frames"][name]), "final data frame") + forms = inputs["CERTIFICATE.json"]["forms"] + pairing = inputs["WITNESS.json"]["pairing"] + check(sorted(pairing) == list(range(208)), "perfect matching") + previous = inputs["CONTROL.json"]["pairing"] + reconstructed = list(previous) + cycle = [13, 203, 191, 63] + for i, h in enumerate(cycle): + reconstructed[h] = previous[cycle[(i + 1) % 4]] + check(pairing == reconstructed, "oriented cycle binding") + lows = [reduced((*paths[f"X{i}"][0], form)) for i in range(104) + for form in forms["departure"][i]] + highs = [hyperplane(paths[f"Y{i}"][-1], form) for i in range(104) + for form in forms["arrival"][i]] + check(all(len(a) == 2 for a in lows) and all(len(b) == 7 for b in highs), "endpoint ranks") + check(all(contains(highs[pairing[h]], lows[h]) for h in range(208)), "endpoint inclusion") + + def interval(h, dimension): + if dimension == 1: + fixed = paths[f"X{h // 2}"][0] + return fixed, fixed + if dimension == 8: + fixed = paths[f"Y{pairing[h] // 2}"][-1] + return fixed, fixed + return lows[h], highs[pairing[h]] + + contacts, reads, writes = {}, {}, {} + for h in (13, 17, 83, 91): + contacts[str(h)], reads[str(h)], writes[str(h)] = [], [], [] + for d in range(1, 9): + bounds = interval(h, d) + contacts[str(h)].append([k for k in range(208) if k != h + and possible_contact(bounds, interval(k, d), d)]) + reads[str(h)].append([s for s in range(104) + if any(fits(bounds, f, d) for f in paths[f"X{s}"])]) + writes[str(h)].append([t for t in range(104) + if any(fits(bounds, f, d) for f in paths[f"Y{t}"])]) + check(contacts[str(h)][0] == [h ^ 1], "one source-line partner") + partner_bounds = interval(h ^ 1, 1) + partner_reads = [s for s in range(104) if any(fits(partner_bounds, f, 1) for f in paths[f"X{s}"])] + check(partner_reads == [h // 2], "partner has only the same source") + writers = [[d, h] for d in range(1, 9) for h in range(208) + if any(fits(interval(h, d), f, d) for f in paths["Y40"])] + check(not any(set(paths[f"X{s}"]) & set(paths["Y40"]) for s in range(104)), "no direct read") + check(pairing[91] == 8, "outgoing arrival boundary") + for h, vector in ((63, 31), (118, 178), (185, 253)): + check(contains(lows[h], (vector,)) and not contains(highs[8], (vector,)), "separator") + row = target_row(word) + support = {6, 8, 41, 45} + missing = [s for s in range(104) if row[s] and s not in support] + check(row[1] == Fraction(1, 2) and len(missing) == 44, "required coefficients") + return {"complete_contacts_by_dimension": contacts, "local_reads_by_dimension": reads, + "local_writes_by_dimension": writes, "all_target_writers": writers, + "required_coefficient": str(row[1]), "missing_required_sources": missing} + + +def main(): + actual = derive(load()) + cut = json.loads((HERE / "RESULT.json").read_text())["cut"] + expected = {key: cut[key] for key in actual} + check(json.dumps(actual, sort_keys=True) == json.dumps(expected, sort_keys=True), + "independent cut receipt equality") + print("PASS_P104_MOVED_HELPER_ALGEBRAIC_CUT contacts=independent row=reverse_pullback missing=44") + + +if __name__ == "__main__": + main() diff --git a/research/p104-moved-helper-cut/test_verify.py b/research/p104-moved-helper-cut/test_verify.py new file mode 100644 index 0000000000..d9018abd0d --- /dev/null +++ b/research/p104-moved-helper-cut/test_verify.py @@ -0,0 +1,181 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Behavioral controls for the mathematical support/cut boundary.""" +import copy +import importlib.util +import json +import shutil +import subprocess +import sys +import tempfile +import unittest +from itertools import combinations +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("moved_helper_audit", HERE / "verify.py") +v = importlib.util.module_from_spec(spec) +spec.loader.exec_module(v) +cut_spec = importlib.util.spec_from_file_location("algebraic_cut", HERE / "check_cut.py") +c = importlib.util.module_from_spec(cut_spec) +cut_spec.loader.exec_module(c) + + +class AuditControls(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.inputs = v.load() + cls.g = v.geometry(cls.inputs) + cls.base = v.incidence(cls.g) + cls.matrix, cls.demands, _ = v.required_coefficients(cls.inputs["P104-FIXTURE.json"]) + + def compare_tiny(self, network, expected, count, sources): + actual, _ = v.propagate(network, count=count, target_count=len(expected)) + self.assertEqual(actual, expected) + self.assertEqual(v.bfs_outputs(network, source_count=sources, count=count), expected) + + def test_fresh_read_can_cross_same_layer_chain(self): + # Literal word: h0 += X0; h1 += h0; h2 += h1; Y0 += h2. + network = ({1: [{0, 1}, {0, 1, 2}, {1, 2}]}, + {1: [1, 0, 0]}, {1: [0, 0, 1]}, [0]) + self.compare_tiny(network, [1], 3, 1) + + def test_all_writers_and_direct_reads_accumulate(self): + # Two disjoint helper outputs and an independent direct read of X2. + network = ({1: [{0}, {1}]}, {1: [1, 2]}, {1: [1, 1]}, [4]) + self.compare_tiny(network, [7], 2, 3) + swapped = ({1: [{0}, {1}]}, {1: [2, 1]}, {1: [1, 1]}, [4]) + self.compare_tiny(swapped, [7], 2, 3) + + def test_late_source_cannot_travel_backwards(self): + network = ({1: [{0, 1}, {0, 1}], 2: [{0}, {1}]}, + {1: [0, 0], 2: [1, 0]}, {1: [0, 1], 2: [0, 0]}, [0]) + self.compare_tiny(network, [0], 2, 1) + + def test_independent_dirt_has_no_source_coefficient(self): + network = ({1: [{0, 1}, {0, 1}]}, {1: [0, 0]}, {1: [1, 1]}, [0]) + self.compare_tiny(network, [0], 2, 1) + + def test_nonnested_positive_control_is_illegal_but_effective(self): + cut = v.cut_receipt(self.g, self.base, self.matrix, self.demands) + flag = [v.span(b) for b in cut["nonnested_positive_control"]["flag_bases"]] + with self.assertRaisesRegex(ValueError, "nested flag"): + v.flag_profile(self.g, flag) + profile = v.flag_profile(self.g, flag, require_nested=False) + output, _ = v.propagate(v.constrain(self.base, profile)) + self.assertTrue(output[40] & (1 << 1)) + + def test_changed_contact_or_coefficient_invalidates_cut(self): + changed = copy.deepcopy(self.base) + changed[0][4][91].add(2) + changed[0][4][2].add(91) + with self.assertRaisesRegex(ValueError, "contact boundary"): + v.cut_receipt(self.g, changed, self.matrix, self.demands) + matrix = copy.deepcopy(self.matrix) + matrix[40][1] = 0 + with self.assertRaisesRegex(ValueError, "cut coefficient"): + v.cut_receipt(self.g, self.base, matrix, self.demands) + + def test_equivalent_basis_and_incompatible_pairing(self): + changed = copy.deepcopy(self.inputs) + word = changed["LOWRANK-WITNESS.json"] + for bank in (word["initial_frames"], word["final_frames"]): + for name in bank: + bank[name].reverse() + for event in word["program"]: + if event[0] == "transport": + event[2].reverse() + event[3].reverse() + g = v.geometry(changed) + self.assertEqual(g["frames"], self.g["frames"]) + self.assertEqual(g["paths"], self.g["paths"]) + changed["WITNESS.json"]["pairing"][13] = changed["WITNESS.json"]["pairing"][14] + with self.assertRaisesRegex(ValueError, "perfect matching"): + v.geometry(changed) + + def test_logical_channel_binds_port_order(self): + receipt = v.source_response(self.inputs["LOWRANK-WITNESS.json"], self.matrix) + self.assertEqual(receipt["target_coefficients"], 10816) + wrong = copy.deepcopy(self.matrix) + for row in wrong: + row[0], row[1] = row[1], row[0] + with self.assertRaisesRegex(ValueError, "Gram/channel port-order binding"): + v.source_response(self.inputs["LOWRANK-WITNESS.json"], wrong) + bad_word = copy.deepcopy(self.inputs["LOWRANK-WITNESS.json"]) + first = next(e for e in bad_word["program"] if e[0] == "add") + first[4] = [1] + with self.assertRaisesRegex(ValueError, "common-frame ADD"): + v.source_response(bad_word, self.matrix) + + def test_interval_contact_formula_against_all_f2_cubed_spaces(self): + # Pruning-free literal ground truth, unrelated to elimination ranks. + spaces = set() + for size in range(4): + for generators in combinations(range(1, 8), size): + space = {0} + for generator in generators: + space |= {x ^ generator for x in space} + spaces.add(frozenset(space)) + self.assertEqual(len(spaces), 16) + intervals = [(a, b) for a in spaces for b in spaces if a <= b] + self.assertEqual(len(intervals), 66) + choices = {(a, b, d): {s for s in spaces if a <= s <= b and len(s) == 1 << d} + for a, b in intervals for d in range(4)} + comparisons = 0 + for a, b in intervals: + for x, y in intervals: + for d in range(4): + literal = bool(choices[a, b, d] & choices[x, y, d]) + algebraic = c.possible_contact((c.reduced(a), c.reduced(b)), + (c.reduced(x), c.reduced(y)), d) + self.assertEqual(algebraic, literal) + comparisons += 1 + self.assertEqual(comparisons, 17424) + + def test_separate_algebraic_cut_and_reverse_row(self): + actual = c.derive(self.inputs) + primary = v.cut_receipt(self.g, self.base, self.matrix, self.demands) + self.assertEqual(actual, {key: primary[key] for key in actual}) + self.assertEqual(c.target_row(self.inputs["LOWRANK-WITNESS.json"]), self.matrix[40]) + + def test_optimized_gitfree_export_and_corruption_rejection(self): + with tempfile.TemporaryDirectory(prefix="p104-moved-cut-") as tmp: + root = Path(tmp) + package = root / "research" / HERE.name + package.mkdir(parents=True) + for name in ("verify.py", "check_cut.py", "SOURCES.json", "RESULT.json"): + shutil.copyfile(HERE / name, package / name) + for row in v.read_json(HERE / "SOURCES.json")["files"]: + if row["usage"] == "input": + destination = root / row["path"] + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(v.ROOT / row["path"], destination) + argv = [sys.executable, "-I", "-O", "-B", str(package / "verify.py"), "--cut-only"] + # Isolated mode and no imported repository modules make old pyc irrelevant. + def run(): + return subprocess.run(argv, cwd=root, text=True, capture_output=True, timeout=30) + before = {str(p.relative_to(root)): p.read_bytes() for p in root.rglob("*") if p.is_file()} + valid = run() + self.assertEqual(valid.returncode, 0, valid.stderr) + self.assertIn("PASS_P104_MOVED_HELPER_SMALL_CUT", valid.stdout) + independent = subprocess.run([sys.executable, "-I", "-O", "-B", str(package / "check_cut.py")], + cwd=root, text=True, capture_output=True, timeout=30) + self.assertEqual(independent.returncode, 0, independent.stderr) + self.assertIn("PASS_P104_MOVED_HELPER_ALGEBRAIC_CUT", independent.stdout) + after = {str(p.relative_to(root)): p.read_bytes() for p in root.rglob("*") if p.is_file()} + self.assertEqual(before, after) + receipt = v.read_json(package / "RESULT.json") + receipt["cut"]["required_coefficient"] = "0" + (package / "RESULT.json").write_text(json.dumps(receipt)) + invalid = run() + self.assertNotEqual(invalid.returncode, 0) + self.assertIn("receipt equality", invalid.stderr) + shutil.copyfile(HERE / "RESULT.json", package / "RESULT.json") + source = root / "research/p104-alternating-cycle-neighborhood/WITNESS.json" + source.write_bytes(source.read_bytes() + b"\n") + invalid = run() + self.assertNotEqual(invalid.returncode, 0) + self.assertIn("source hash:", invalid.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/p104-moved-helper-cut/verify.py b/research/p104-moved-helper-cut/verify.py new file mode 100644 index 0000000000..d1fbcd4726 --- /dev/null +++ b/research/p104-moved-helper-cut/verify.py @@ -0,0 +1,500 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Literal-subspace audit of PR3124's moved helper 13. + +Prepared for commdata2338 with substantial OpenAI Codex assistance. +No predecessor Python is imported. Model/method credit: README.md. +""" +import argparse +import hashlib +import json +from collections import Counter, defaultdict, deque +from fractions import Fraction +from itertools import combinations, product +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +HELPER, COUNT = 13, 208 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True) + + +def unique(pairs): + result = dict(pairs) + require(len(result) == len(pairs), "duplicate JSON key") + return result + + +def read_json(path): + return json.loads(path.read_text(), object_pairs_hook=unique) + + +def load(): + inputs = {} + for row in read_json(PACKAGE / "SOURCES.json")["files"]: + if row["usage"] != "input": + continue + raw = (ROOT / row["path"]).read_bytes() + require(hashlib.sha256(raw).hexdigest() == row["sha256"], "source hash: " + row["path"]) + inputs[Path(row["path"]).name] = json.loads(raw, object_pairs_hook=unique) + require(set(inputs) == {"WITNESS.json", "CONTROL.json", "CERTIFICATE.json", "LOWRANK-WITNESS.json", + "P104-FIXTURE.json"}, "input inventory") + return inputs + + +def points(mask): + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit + + +def encode(values): + return sum(1 << x for x in set(values)) + + +def extend(space, vector): + return space | encode(x ^ vector for x in points(space)) + + +def span(rows): + space = 1 + for vector in rows: + require(type(vector) is int and 0 < vector < 512, "binary label") + require(not (space >> vector) & 1, "independent basis") + space = extend(space, vector) + return space + + +def dim(space): + size = space.bit_count() + require(size > 0 and size & (size - 1) == 0, "frame cardinality") + return size.bit_length() - 1 + + +def subset(a, b): + return a & b == a + + +def basis(space): + generated, result = 1, [] + for x in points(space): + if not (generated >> x) & 1: + result.append(x) + generated = extend(generated, x) + require(generated == space, "linear subspace") + return result + + +def data_paths(word): + paths = {f"{k}{i}": [span(word["initial_frames"][f"{k}{i}"])] + for k in "XY" for i in range(104)} + require(len(word["program"]) == 4058, "original word length") + for event in word["program"]: + op, name = event[:2] + if op == "transport" and name in paths: + before, after = span(event[2]), span(event[3]) + require(before == paths[name][-1] and before != after and subset(before, after), "data chronology") + require(dim(after) - dim(before) == event[4], "data rank") + paths[name].append(after) + elif op != "transport": + require(op in {"add", "copy", "zero", "erase"}, "opcode") + require(not name.startswith("X"), "immutable source") + if op in {"add", "copy"}: + require(not event[2].startswith("Y"), "unread target") + for name, chain in paths.items(): + require(chain[-1] == span(word["final_frames"][name]), "data final frame") + expected = (1, 9) if name[0] == "X" else (0, 8) + require((dim(chain[0]), dim(chain[-1])) == expected, "data dimensions") + return paths + + +def quotient_layers(): + """Every literal subspace of F2^5, by exhaustive one-vector extension.""" + layers = [{1}] + for _ in range(5): + layers.append({extend(s, v) for s in layers[-1] for v in range(1, 32) if not (s >> v) & 1}) + require(list(map(len, layers)) == [1, 31, 155, 155, 31, 1], "quotient completeness") + return [sorted(layer) for layer in layers] + + +def helper_frames(low, high, line, cap, quotients): + require(dim(low) == 2 and dim(high) == 7 and subset(low, high), "helper endpoints") + current, generators = low, [] + for vector in points(high): + if not (current >> vector) & 1: + generators.append(vector) + current = extend(current, vector) + require(current == high and len(generators) == 5, "quotient generators") + cosets = [] + for q in range(32): + value = 0 + for i, generator in enumerate(generators): + if q >> i & 1: + value ^= generator + cosets.append(encode(x ^ value for x in points(low))) + require(len(set(cosets)) == 32, "distinct cosets") + frames = {1: {line}, 8: {cap}} + for d, layer in enumerate(quotients, 2): + frames[d] = {sum(cosets[q] for q in points(s)) for s in layer} + return frames + + +def geometry(inputs): + paths = data_paths(inputs["LOWRANK-WITNESS.json"]) + cert, witness = inputs["CERTIFICATE.json"], inputs["WITNESS.json"] + matching = witness["pairing"] + require(witness["cycle"] == [13, 203, 191, 63], "named cycle") + require(len(matching) == COUNT and all(type(x) is int for x in matching) + and sorted(matching) == list(range(COUNT)), "perfect matching") + previous = inputs["CONTROL.json"]["pairing"] + expected = list(previous) + cycle = witness["cycle"] + for i, h in enumerate(cycle): + expected[h] = previous[cycle[(i + 1) % len(cycle)]] + require(matching == expected, "exact alternating-cycle orientation") + lines = [paths[f"X{s}"][0] for s in range(104)] + caps = [paths[f"Y{t}"][-1] for t in range(104)] + require(len(set(lines)) == len(set(caps)) == 104, "distinct endpoints") + lows, highs = [], [] + for i in range(104): + for form in cert["forms"]["departure"][i]: + lows.append(extend(lines[i], form)) + for form in cert["forms"]["arrival"][i]: + highs.append(encode(x for x in points(caps[i]) if (x & form).bit_count() % 2 == 0)) + q = quotient_layers() + frames = [helper_frames(lows[h], highs[matching[h]], lines[h // 2], caps[matching[h] // 2], q) + for h in range(COUNT)] + read_frames, write_frames = defaultdict(int), defaultdict(int) + for s in range(104): + for frame in paths[f"X{s}"]: + read_frames[frame] |= 1 << s + for t in range(104): + for frame in paths[f"Y{t}"]: + write_frames[frame] |= 1 << t + return {"paths": paths, "matching": matching, "lows": lows, "highs": highs, + "frames": frames, "reads": read_frames, "writes": write_frames} + + +def required_coefficients(fixture): + roots = [] + for i, j in combinations(range(8), 2): + for sign in (-1, 1): + root = [0] * 8 + root[i], root[j] = 2, 2 * sign + roots.append(tuple(root)) + roots.extend((1, *tail) for tail in product((-1, 1), repeat=7) if tail.count(-1) % 2 == 0) + removed = fixture["section4_explicit_P104"] + ports = sorted(set(roots) - {tuple(x) for x in removed["F0"] + removed["C"]}) + require(len(roots) == 120 and len(ports) == 104, "root reconstruction") + matrix = [[Fraction(8 * (t == s) - sum(a * b for a, b in zip(ports[t], ports[s])), 8) + for s in range(104)] for t in range(104)] + demands = [encode(s for s in range(104) if matrix[t][s]) for t in range(104)] + require(sum(x.bit_count() for x in demands) == 4992, "correction demand count") + require(all(x.bit_count() == 48 for x in demands), "48 demands per target") + return matrix, demands, ports + + +def source_response(word, correction): + """Bind the independently reconstructed Gram matrix to all X columns. + + Transports preserve logical rows; their native realization is inherited. + Independent helper/target entrance columns are not replayed here. + """ + frames = {name: span(b) for name, b in word["initial_frames"].items()} + rows = {name: ({int(name[1:]): Fraction(1)} if name.startswith("X") else {}) + for name in frames} + scalar_adds, private_copies = 0, 0 + for event in word["program"]: + op, dst = event[:2] + if op == "transport": + require(frames[dst] == span(event[2]), "logical replay transport entry") + frames[dst] = span(event[3]) + elif op == "zero": + require(dst not in frames, "private allocation is fresh") + frames[dst], rows[dst] = span(event[2]), {} + elif op == "erase": + require(frames[dst] == span(event[2]), "private discard frame") + del frames[dst] + del rows[dst] + elif op == "copy": + src = event[2] + require(frames[dst] == frames[src] == span(event[3]) and not rows[dst], "private copy boundary") + rows[dst] = dict(rows[src]) + private_copies += 1 + elif op == "add": + src, coefficient = event[2], Fraction(event[3]) + require(dst != src and frames[dst] == frames[src] == span(event[4]), "common-frame ADD") + for source, value in rows[src].items(): + total = rows[dst].get(source, 0) + coefficient * value + if total: + rows[dst][source] = total + else: + rows[dst].pop(source, None) + scalar_adds += 1 + else: + raise ValueError("logical replay opcode") + require(frames == {name: span(b) for name, b in word["final_frames"].items()}, "logical replay final frames") + for name, row in rows.items(): + if name.startswith("X"): + require(row == {int(name[1:]): 1}, "source column preservation") + elif name.startswith("Y"): + target = int(name[1:]) + for source in range(104): + require(row.get(source, 0) == int(target == source) - correction[target][source], + "Gram/channel port-order binding") + else: + require(not row, "helper has no final source response") + return {"source_columns": 104, "target_coefficients": 104 * 104, + "events": len(word["program"]), "scalar_adds": scalar_adds, + "private_copies": private_copies, "required_X1_Y40_correction": str(correction[40][1]), + "native_realization_replayed": False, "dirty_entrance_columns_replayed": False} + + +def incidence(g): + adjacency, reads, writes = {}, {}, {} + for d in range(1, 9): + members = defaultdict(list) + for h in range(COUNT): + for frame in g["frames"][h][d]: + members[frame].append(h) + a, r, w = [set() for _ in range(COUNT)], [0] * COUNT, [0] * COUNT + for frame, helpers in members.items(): + for h in helpers: + a[h].update(helpers) + r[h] |= g["reads"][frame] + w[h] |= g["writes"][frame] + adjacency[d], reads[d], writes[d] = a, r, w + direct = [0] * 104 + for frame, source_bits in g["reads"].items(): + for t in points(g["writes"][frame]): + direct[t] |= source_bits + return adjacency, reads, writes, direct + + +def profiles(g): + """Merge flags only when every incident edge/read/write agrees.""" + layers = [sorted(g["frames"][HELPER][d]) for d in range(2, 8)] + successors = [{x: [y for y in layers[i + 1] if subset(x, y)] for x in layer} + for i, layer in enumerate(layers[:-1])] + per_frame = {} + for d in range(1, 9): + for f in g["frames"][HELPER][d]: + per_frame[d, f] = (tuple(h for h in range(COUNT) if f in g["frames"][h][d]), + g["reads"][f], g["writes"][f]) + result = {} + + def visit(flag): + if len(flag) < 6: + for nxt in successors[len(flag) - 1][flag[-1]]: + visit(flag + [nxt]) + return + full = [next(iter(g["frames"][HELPER][1])), *flag, next(iter(g["frames"][HELPER][8]))] + key = tuple(per_frame[d, f] for d, f in enumerate(full, 1)) + if key not in result: + result[key] = {"count": 0, "flag": full} + result[key]["count"] += 1 + + visit([layers[0][0]]) + require(sum(x["count"] for x in result.values()) == 9765, "complete flag count") + return result + + +def constrain(base, profile): + adjacency, reads, writes, direct = base + aa, rr, ww = {}, {}, {} + for d in range(1, 9): + neighbors, read, write = profile[d - 1] + aa[d] = [set(row) - {HELPER} for row in adjacency[d]] + aa[d][HELPER] = set(neighbors) + for h in neighbors: + aa[d][h].add(HELPER) + rr[d], ww[d] = list(reads[d]), list(writes[d]) + rr[d][HELPER], ww[d][HELPER] = read, write + return aa, rr, ww, direct + + +def flag_profile(g, flag, require_nested=True): + require(len(flag) == 8, "eight flag layers") + for d, frame in enumerate(flag, 1): + require(frame in g["frames"][HELPER][d], "flag frame in endpoint interval") + if require_nested: + require(all(subset(a, b) for a, b in zip(flag, flag[1:])), "nested flag") + return tuple((tuple(h for h in range(COUNT) if f in g["frames"][h][d]), + g["reads"][f], g["writes"][f]) for d, f in enumerate(flag, 1)) + + +def cut_receipt(g, base, matrix, demands): + """Source-bound small proof certificate, independent of the flag census.""" + adjacency, reads, writes, direct = base + # Exact complete neighborhoods, not selected edges from a path search. + expected = { + 13: [[12], [], [63, 185], [63, 91, 118, 185], [63, 91, 118, 185], [91], [], [124]], + 17: [[16], [], [], [], [], [], [], [83]], + 83: [[82], [], [], [91], [91], [91], [], [17]], + 91: [[90], [], [], [13, 83], [13, 83], [13, 83], [], [183]], + } + contacts, local_reads, local_writes = {}, {}, {} + for h in expected: + contacts[str(h)] = [sorted(adjacency[d][h] - {h}) for d in range(1, 9)] + local_reads[str(h)] = [list(points(reads[d][h])) for d in range(1, 9)] + local_writes[str(h)] = [list(points(writes[d][h])) for d in range(1, 9)] + require(contacts[str(h)] == expected[h], "complete local contact boundary") + require(local_reads[str(h)] == [[h // 2]] + [[] for _ in range(7)], "local source boundary") + # The dimension-one partner cannot inject a different source there. + component = adjacency[1][h] + require(component == {h, h ^ 1}, "source-line component") + require(all(reads[1][k] == 1 << (h // 2) for k in component), "paired source only") + writers = [[d, h] for d in range(1, 9) for h in range(COUNT) if writes[d][h] >> 40 & 1] + require(writers == [[8, 17], [8, 83]], "all Y40 writers") + require(direct[40] == 0, "no direct Y40 source read") + require(g["matching"][91] == 8 and g["matching"][13] == 180, "named arrival assignment") + separators = [] + for incoming in (63, 118, 185): + excluded = g["lows"][incoming] & ~g["highs"][8] + require(excluded != 0, "nested relay separator") + separators.append({"incoming": incoming, "outgoing": 91, + "vector": min(points(excluded)), + "incoming_departure_basis": basis(g["lows"][incoming]), + "outgoing_arrival_slot": 8}) + support_bound = {6, 8, 41, 45} + missing = [s for s in points(demands[40]) if s not in support_bound] + require(len(missing) == 44 and matrix[40][1] == Fraction(1, 2), "cut coefficient") + # One intentionally nonnested choice restores the missing X1 -> Y40 path. + broken_bases = [[200], [200, 288], [104, 160, 288], [2, 53, 200, 277], + [13, 37, 64, 133, 261], [2, 13, 37, 64, 133, 261], + [2, 13, 16, 37, 64, 133, 261], [1, 2, 12, 16, 36, 64, 132, 260]] + broken = [span(b) for b in broken_bases] + require(not subset(broken[3], broken[4]), "control breaks nestedness") + profile = flag_profile(g, broken, require_nested=False) + controlled = constrain(base, profile) + output, _ = propagate(controlled) + require(output == bfs_outputs(controlled), "nonnested control algorithms agree") + require(output[40] >> 1 & 1, "nonnested control restores distinguished path") + return {"target": 40, "distinguished_source": 1, "required_coefficient": "1/2", + "source_support_upper_bound": sorted(support_bound), "missing_required_sources": missing, + "complete_contacts_by_dimension": contacts, "local_reads_by_dimension": local_reads, + "local_writes_by_dimension": local_writes, "all_target_writers": writers, + "separators": separators, "arrival_8_basis": basis(g["highs"][8]), + "nonnested_positive_control": {"flag_bases": broken_bases, "X1_reaches_Y40": True}} + + +def propagate(network, count=COUNT, target_count=104): + """Exact source-support closure of the relaxed layered graph.""" + adjacency, reads, writes, direct = network + state, outputs, traces = [0] * count, list(direct), [] + for d in sorted(adjacency): + state = [x | r for x, r in zip(state, reads[d])] + unseen = set(range(count)) + while unseen: + seed = min(unseen) + component, todo, sources = {seed}, [seed], 0 + unseen.remove(seed) + while todo: + h = todo.pop() + sources |= state[h] + for neighbor in adjacency[d][h]: + if neighbor not in component: + component.add(neighbor) + unseen.discard(neighbor) + todo.append(neighbor) + for h in component: + state[h] = sources + for h in range(count): + for t in points(writes[d][h]): + require(t < target_count, "target index") + outputs[t] |= state[h] + traces.append(list(state)) + return outputs, traces + + +def bfs_outputs(network, source_count=104, count=COUNT): + """Separate per-source graph traversal, without component propagation.""" + adjacency, reads, writes, direct = network + layers, output = sorted(adjacency), list(direct) + for s in range(source_count): + todo = deque((i, h) for i, d in enumerate(layers) for h in range(count) if reads[d][h] >> s & 1) + visited = set(todo) + while todo: + i, h = todo.popleft() + d = layers[i] + for t in points(writes[d][h]): + output[t] |= 1 << s + following = [(i, k) for k in adjacency[d][h]] + if i + 1 < len(layers): + following.append((i + 1, h)) + for vertex in following: + if vertex not in visited: + visited.add(vertex) + todo.append(vertex) + return output + + +def derive(inputs): + g = geometry(inputs) + matrix, demands, _ = required_coefficients(inputs["P104-FIXTURE.json"]) + binding = source_response(inputs["LOWRANK-WITNESS.json"], matrix) + base = incidence(g) + cut = cut_receipt(g, base, matrix, demands) + relaxed, _ = propagate(base) + require(relaxed == bfs_outputs(base), "relaxed component/BFS agreement") + require(all(need & got == need for need, got in zip(demands, relaxed)), "relaxed matching passes") + groups, histogram, rows, union = profiles(g), Counter(), [], [0] * 104 + for profile, record in sorted(groups.items()): + net = constrain(base, profile) + outputs, _ = propagate(net) + require(outputs == bfs_outputs(net), "constrained component/BFS agreement") + missing = sum((need & ~got).bit_count() for need, got in zip(demands, outputs)) + histogram[missing] += record["count"] + union = [a | b for a, b in zip(union, outputs)] + rows.append({"multiplicity": record["count"], "missing": missing, + "flag_bases": [basis(frame) for frame in record["flag"]], + "source_support_by_target_hex": [f"{x:026x}" for x in outputs]}) + always_missing = [[t, s] for t in range(104) for s in points(demands[t] & ~union[t])] + return {"schema_version": 1, "helper": HELPER, + "matching_sha256": hashlib.sha256(canonical(g["matching"]).encode()).hexdigest(), + "quotient_subspace_counts": [1, 31, 155, 155, 31, 1], + "flags": sum(histogram.values()), "contact_profiles": len(groups), + "missing_histogram": {str(k): v for k, v in sorted(histogram.items())}, + "relaxed_missing": 0, "always_missing_pairs": always_missing, + "first_missing_coefficient": (str(matrix[always_missing[0][0]][always_missing[0][1]]) + if always_missing else None), + "source_response_binding": binding, "cut": cut, "classes": rows, "no_new_kappa": True} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", action="store_true", help="emit derived receipt to stdout") + parser.add_argument("--cut-only", action="store_true", help="check the small cut without enumerating flags") + args = parser.parse_args() + inputs = load() + if args.cut_only: + g = geometry(inputs) + matrix, demands, _ = required_coefficients(inputs["P104-FIXTURE.json"]) + source_response(inputs["LOWRANK-WITNESS.json"], matrix) + result = cut_receipt(g, incidence(g), matrix, demands) + else: + result = derive(inputs) + if args.emit: + print(json.dumps(result, indent=2, sort_keys=True)) + else: + expected = read_json(PACKAGE / "RESULT.json") + if args.cut_only: + expected = expected["cut"] + require(canonical(result) == canonical(expected), "receipt equality") + if args.cut_only: + print("PASS_P104_MOVED_HELPER_SMALL_CUT target=40 source=1 missing_coefficients=44 no_new_kappa") + else: + print("PASS_P104_MOVED_HELPER_CUT flags=9765 helper=13 profiles=" + f"{result['contact_profiles']} always_missing={len(result['always_missing_pairs'])} no_new_kappa") + + +if __name__ == "__main__": + main()