# Multi-step chains: an inventory of the hops in this collection, every composition of them up to three steps, and what the compositions produce

Worker report, 22 August 2026. This report exists because roughly ten previous workers all
assumed the Act 1 puzzle has a one-step answer — find eleven artworks, read their Essence field,
stop — while all three of Pindar Van Arman's puzzles that were actually solved required two or
more hops. The podGALLERY puzzle required taking a SLIP-39 word, finding its index on the SLIP-39
list, and reading the BIP-39 word at that same index. The roboGAN puzzle required going from a
clue to a properties file, filtering it down to the BIP-39 words it contained, and then ordering
those by mint order. The Winter Solstice puzzle required ignoring the Essence field entirely,
because Pindar wrote in his own third clue that the pieces "hide their true BIP39 nature
elsewhere," and the words turned out to live in the Date property. My job was to treat
indirection as the default rather than the exception, build every hop in this collection as an
explicit function, compose those functions, and test the results.

Everything below is computed from `master_dataset.json` (513 artworks, 77 columns),
`bitgan_properties.csv` (Pindar's own published sheet, archived to Arweave on 1 January 2022),
`superrare_bitgans_onchain.json`, `slip39.txt`, and the sets recorded in `theories/*_sets.json`.
The code is in `hops.py`, `chains.py`, `compose.py`, `cycles.py` and `mrun.py` in the project
root, and every number quoted here is reproducible by running them.

---

## 0. The five findings that matter most

**First, the eleven-into-eleven closed loop the collection owner asked for does not exist.** I
built every artwork-to-artwork map I could define, ran a full cycle census on each of them, and
found no cycle of length greater than one anywhere except inside the forge, where the "burnt
with" relation is an involution and therefore produces nothing but two-cycles by construction.
There are nineteen of those two-cycles. There is no three-cycle, no eleven-cycle, and nothing in
between. If Pindar built a permutation of the collection onto itself, he did not build it out of
the Essence field, the GAN numbering, the mint order, the frame counts, or the SLIP-39 list.

**Second, there is a genuine fixed-point eleven, and it is the only non-trivial fixed-point
structure in the collection.** Define the map that sends an artwork to the artwork whose GAN
number equals its own Essence's one-based BIP-39 index. That map has exactly 137 fixed points.
One hundred and twenty-six of them are the skullGANs, which are fixed trivially because the
skullGAN drop *is* that register — its rule is `bip39_index(essence) = GAN − 1`, exact for 126 of
its 128 members. The remaining eleven are all in the Ghosts in the Machine drop: GANs 307, 322,
348, 368, 372, 380, 389, 404, 407, 429 and 444, carrying `chaos choice clock combine common
control correct crash crazy culture danger`. These are eleven pieces from a later drop whose
Essence field was filled in by the *earlier* drop's rule. That is a data-corruption glitch in
exactly the sense the Act 1 clue uses the word, and eleven of them is the count the clue asks
for. I did not go looking for eleven; I ran a fixed-point census and eleven is what came out
after the trivial cases were removed.

**Third, and against that, the fixed-point eleven sits inside a band of fifteen and is therefore a
threshold cut rather than a closed set.** Four more Ghosts pieces miss the diagonal by one or two:
#354 `cluster` is off by two, #360 `code` by one, #423 `cruel` by two, and #440 `cycle` by one.
Nothing else in the drop comes within eight. So Pindar built a near-diagonal register inside the
Ghosts drop with fifteen members, and eleven of them land exactly. Whether the eleven exact ones
or the four near-misses are "the glitches" is a judgement the data does not settle. I record this
because the calibration rule demands it: the eleven is real, but its boundary is drawn by an
equality test I chose, not by a wall in the data.

**Fourth, the podGALLERY hop has zero adherents in this collection.** This is the cleanest
negative in the report and it closes off a whole family of theories. I tested whether any artwork's
Essence is the podGALLERY image of its own register word — that is, whether `Essence(g)` equals
the BIP-39 word sitting at the SLIP-39 index of `WL[g−1]`. Not one of the 513 satisfies it, in
either direction of the hop. I also tested whether any Essence sits at the same index on both
word lists, which would make it its own podGALLERY image, and again nothing does. One hundred and
forty artworks have an Essence that happens to be a SLIP-39 word, so the hop is *defined* on 140
pieces, but it is never the rule that generated the field. Pindar reused the mechanism's
vocabulary in the podGALLERY drop and did not reuse the mechanism here.

**Fifth, Pindar's published CSV carries no ordering information at all.** The brief suggested that
row order in `bitgan_properties.csv` is not GAN order throughout, and that a piece's row position
might therefore be an independent index. It is not. Row position equals GAN number for all 513
rows without exception. What misleads is the `Number` column, which is written in whatever radix
the piece's own drop uses — plain decimal for 0–128, six-digit binary for the roboGANs at 129–192,
octal with an `0o` prefix for the spookyGANs at 193–208, decimal again through 464, then `0x20`
and `0x21` on 465 and 466, then decimal to the end. A reader who parses that column as decimal
gets 76 rows whose "number" disagrees with their position, and all 76 disagreements are the
roboGAN binary strings being read in the wrong base. The sheet is a radix puzzle, not an ordering
puzzle.

---

## 1. The hop inventory

A hop is a function from one kind of thing to another. I sorted them by the kind of thing they
start and end at, because that is what determines which hops can be composed with which. The
coverage column says how many of the 513 artworks the hop is actually defined on, which matters
enormously: a hop defined on forty pieces cannot be the second step of a chain that starts from
an eleven unless all eleven of those pieces are among the forty.

### Artwork to number

| Hop | Coverage | What it does | How well defined |
|---|---|---|---|
| `gan` | 513 | The artwork's Act 1 GAN number, 0 through 512. | Total and unambiguous. |
| `mint` | 498 | Its position in on-chain mint order. | Well defined; the fifteen misses are the pieces that never reached the chain, which are exactly the fourteen numbered in binary or hex plus #0. |
| `local` | 292 | The number printed inside the artwork's own title, decoded in that title's own radix. | Well defined where a title carries a parenthesised code. The skullGAN drop has no code at all, which is why coverage is not higher. |
| `frames` | 488 | The measured GIF frame count. | Well defined but nearly constant: 41 across the whole skullGAN drop, 55 across most of the rest. As a hop it is almost useless, because it maps eleven distinct artworks onto one number. |
| `eyes` | 513 | The Eyes trait. | Total, but takes only a handful of small values, so it collapses elevens into two or three distinct words. |
| `dims` | 512 | The Dimensions trait. | Same problem as Eyes, worse. |
| `hextype` | 172 | The Hidden Type letter read as a hexadecimal digit. | Well defined on the 172 pieces with a fetched letter, but it too collapses: only six distinct values survive, because `a` and `A` are both 10. |
| `radixtru` | 90 | The title code read in the radix its prefix declares. | Well defined on the 90 pieces carrying a coded title. |
| `radixdec` | 90 | The same code misread as decimal. | Well defined, and this is the hop that models the `0x20`/`0x21` corruption. |

### Artwork to artwork

| Hop | Coverage | What it does |
|---|---|---|
| `partner` | 40 | The bitGAN this one was burnt with in the forge, taken from the on-chain `Burned bitGANs` trait. |
| `permute` | 512 | The artwork whose GAN number equals this artwork's Essence index. This is the map the collection owner asked about. |

### Artwork to word

| Hop | Coverage | What it does |
|---|---|---|
| `essence` | 512 | The Essence trait. Every one of the 513 Essences is distinct — the field is injective across the whole collection — and exactly one of them, `err0r` on #191, is not a BIP-39 word. |
| `forged` | 40 | The Essence of the SuperRare piece this artwork was burnt into. |

### Number to word

`bip1` reads the BIP-39 word at one-based index n, which is the skullGAN register rule. `bip0`
reads it at zero-based index n. Both are total on their ranges. I carried both throughout rather
than guessing which convention Pindar used, because the two differ by one word everywhere and the
whole puzzle is an off-by-one question.

### Word to word

`pod` is the podGALLERY hop: take the word's index on the SLIP-39 list and read the BIP-39 word
at that same index. It is defined on 140 of the 512 Essences. `podinv` runs the same hop the
other way, and is defined on 199. `reg` sends a word to the Essence of the artwork whose GAN
number equals that word's BIP-39 index, and is defined on 278.

### The hops I looked for and could not build

The brief asked for a hop from an Act 1 Review reprise to the artwork it reprises. **There is no
such hop, because the reprise relation is block-to-drop and not piece-to-piece.** Pindar's own
description in `news__the-final-bitgan-drop.txt` says the first eight are skullGANs looking back
at the first drop and the second eight are roboGANs from the second drop. He never says which
skullGAN any particular reprise looks back at, and the metadata does not encode it. What the
Review does carry is a *numbering* continuation, which is a different and genuinely well-defined
hop: the eight roboGAN reprises at #457–464 are numbered `1000000` through `1000111`, decimal 64
through 71, continuing the roboGAN drop's own six-bit binary series past its end, and #497–500
continue it again at 72 through 75. Fourteen pieces are numbered this way and fourteen pieces have
no mint index, and they are the same fourteen. Fourteen is not eleven, so this hop cannot supply
the answer on its own, but it is real and it is worth having written down.

The brief also asked for a hop from CSV row position. As set out in §0, row position is GAN
number, so that hop is the identity and carries no information.

---

## 2. The compositions

I composed the hops mechanically rather than by inspiration. The type signatures constrain what
can follow what, and the legal shapes up to three steps are these: a single artwork-to-word hop;
an artwork-to-number hop followed by a number-to-word hop; an artwork-to-artwork hop followed by
an artwork-to-word hop; an artwork-to-word hop followed by a word-to-word hop; and then the
depth-three extensions of each of those, including artwork-to-artwork twice before the final
read, and word-to-word twice after it. That enumeration yields **162 distinct chains**.

I applied all 162 to **61 source elevens**: the 47 recorded in `theories/*_sets.json` that name
eleven GANs, plus the Fibonacci eleven Pindar told holders to hold because it would "unlock
special things in upcoming drops," plus the eleven burnt Flaming skullGANs, plus their corrected
partner set, plus the fixed-point eleven found here, plus the Hidden-Type sets described in §4,
plus the ten unions of glitch-flag columns that happen to land on eleven.

The raw result is that **1,076 combinations of a source eleven and a chain produce eleven words
that are all in the BIP-39 list**, and those collapse to **378 distinct word vectors**. That
number is far less impressive than it looks, and the reason is instructive. Most of it is
collapse: `frames` maps all eleven members of most sets onto 55, so the chain `frames -> bip1`
returns the word `agree` eleven times over. `eyes` and `dims` do the same thing with two or three
values instead of one. After discarding every vector with fewer than nine distinct words, **304
genuinely distinct candidate phrases remain**, and those are what I tested.

A second and more interesting collapse is that many chains are secretly the identity. Because the
skullGAN drop's Essence rule *is* `bip1` composed with `gan`, the chains `essence`,
`gan -> bip1`, `permute -> essence`, `essence -> reg`, `gan -> bip1 -> reg` and
`permute -> gan -> bip1` all return the same eleven words whenever the source eleven lies inside
the skullGAN drop. Thirty distinct chain expressions collapse onto the single word vector for the
burnt Flaming eleven. This is not a defect in the enumeration; it is a fact about the collection,
and it means the register hop is an idempotent that absorbs most compositions built around it.

---

## 3. The cycle and fixed-point census

This is the part of the brief I take most seriously, because a closed loop of eleven would be
strong evidence rather than a coincidence of counting. I built sixteen artwork-to-artwork maps —
the Essence-index map at both offsets, the same map with the podGALLERY hop inserted before it,
the register word fed through the podGALLERY hop in both directions, the Essence-index map applied
twice, the forge pairing, the mint index read as a GAN number, the frame count read as a GAN
number, and the title code misread as decimal and read as a GAN number — and for each one I
computed every cycle.

| Map | Edges inside the collection | Fixed points | Cycles longer than 1 |
|---|---|---|---|
| Essence → BIP-39 index (+1) → that artwork | 278 | **137** | 0 |
| Essence → BIP-39 index (+0) → that artwork | 278 | 1 (#360 `code`) | 0 |
| Essence → podGALLERY → index → that artwork | 95 | 0 | 0 |
| Essence → podGALLERY inverse → index → that artwork | 121 | 0 | 0 |
| Register word → podGALLERY → index → that artwork | 124 | 0 | 0 |
| Essence-index map applied twice | 186 | 137 | 0 |
| Mint index read as a GAN number | 383 | 0 | 0 |
| Frame count read as a GAN number | 488 | 1 (#41 `agree`) | 0 |
| Title code misread as decimal, read as a GAN number | 26 | 0 | 0 |
| **The forge pairing** | 40 | 0 | **19, all of length 2** |

The nineteen forge two-cycles are worth listing because two of them touch pieces that are
independently anomalous. The pair `[57, 319]` burns the skullGAN whose Essence `mistake` is one of
the drop's two register violations. The pair `[126, 360]` burns the only artwork that is a fixed
point of the zero-based register, #360 `code`. I do not think either is a signal — with nineteen
pairs and a collection this dense in anomalies, some overlap is expected — but they should be on
the record rather than rediscovered.

The single-fixed-point results are also worth naming. Under the zero-based reading the only fixed
point in the whole collection is #360, the Frozen skullGAN in the Ghosts drop, whose Essence is
`code` and whose GAN number is 360, which is the zero-based index of `code`. Under the frame-count
map the only fixed point is #41, whose Essence is `agree` and whose frame count is 41. Both are
cute and neither is eleven of anything.

---

## 4. Structure found along the way

### 4.1 The Essence field is injective, and one word is missing from the world

No two of the 513 artworks share an Essence. That makes every word-to-artwork hop a genuine
function rather than a one-to-many relation, which is why the backward chains in §5 resolve
cleanly. It also means the collection consumes exactly 512 of the 2,048 BIP-39 words plus the
non-word `err0r`.

Inside the skullGAN drop the register `bip39_index(essence) = GAN − 1` holds for 126 of 128. The
two breaks are #21, which carries `bean` where the register demands `action`, and #57, which
carries `mistake` where the register demands `alpha`. Those two displaced words behave completely
differently from each other. **`alpha` reappears as the Essence of #129, the first piece of the
very next drop, and #129 is the only artwork in the entire collection wearing another drop's
register word.** `action`, by contrast, appears nowhere. It is the one BIP-39 word that a stated
rule of this collection demands and that no artwork anywhere supplies. A single missing word is
not eleven glitches, so it cannot be the answer, but it is the sharpest unexplained hole I found
and it is the kind of thing an eleventh member could be hiding behind.

### 4.2 The Solstice register skips exactly four words, and all four are explained

The Solstice drop, GANs 209 through 300, is a second BIP-39 register: 92 pieces covering 96
consecutive indices from `avoid` at 128 to `brief` at 223. Four indices inside that span are
unused, and they are `awkward` (134), `bean` (156), `blind` (190) and `blue` (194). I chased each
one. `awkward` is the Essence of #141, `bean` of #21, `blind` of #131 and `blue` of #189 — and all
four of those artworks come from the skullGAN and roboGAN drops, both of which predate the
Solstice drop. **The Solstice register skips precisely the words that were already spent.** That
is a de-duplication rule, it explains the gaps completely, and it explains why the Essence field is
injective in the first place. These four are therefore not glitches and any candidate set built on
them should be retired.

The Solstice drop does contain one real defect, and it is a transposition: #259 carries `bless`
(index 189) and #268 carries `bird` (index 180), where the register wants the opposite. Those two
pieces have been swapped with each other. It is the only place in 513 artworks where two Essences
have exchanged positions.

### 4.3 The Hidden Type field takes exactly eleven values, and its breaks number exactly eleven

The Hidden Type field is Pindar's published classification: Fibonacci numbers get `a`, remaining
primes `b`, squares `c`, remaining odds `d`, remaining evens `e`, lowercase in the skullGAN drop
and uppercase in the drops after it, with an undocumented sixth uppercase value `F`. That is
eleven distinct letter values — `a b c d e A B C D E F` — and no lowercase `f` anywhere, exactly as
the brief describes. Two things follow, one useful and one that must be retired.

The useful one: taking the eleven classes as the source set and reading a representative artwork
from each gives two clean elevens with a motivation entirely independent of their size, because
eleven is how many values the field takes and not something I chose. Reading the lowest-numbered
member of each class gives `abandon absorb absurd achieve absent quantum dance math flame ghost
alpha`; reading the highest-numbered gives `arch asthma anxiety auto avocado grain grab govern
grape grant glue`. Both were tested.

The one to retire: the brief's suggestion that #55 carries a blank Hidden Type where a Fibonacci
`a` belongs. **It does not — #55's blank is a fetch artefact.** The master dataset flags #55 and
#119 both as pieces whose on-chain metadata carries no attributes at all, an artefact of the
Blockscout cache that is spread evenly across all six drops and is not a property of any
particular GAN. The Hidden Type field has exactly two genuine defects: #32, which holds the literal
string `32` where a class letter belongs and which is the only numeric value in any categorical
field in the whole collection, and #187, which is typed `C` when the number rule demands `E`.

Combining those two defects with the nine `F`-typed pieces produces an eleven —
`advance alpha awkward cat dog twin olive wolf mirror zero glue`. I tested it, and I flag it as
bent. The `F` class is not a defect; it is the palindrome marker, sitting on `RoboboR`,
`Dr Awkward`, `Taco Cat`, `Dog God`, `Star Rats`, `Evil Olive`, `Flow Wolf` and `CalcuclaC`. Adding
two genuine field errors to nine correctly-classified palindromes reaches eleven by putting two
different kinds of thing in one bag, which is exactly what the calibration rule warns against.

### 4.4 Two of the fixed-point eleven are Pindar's own jokes about their own numbers

Nine of the 144 Ghosts pieces carry a bespoke name instead of the drop's formula title, and two of
those nine are members of the fixed-point eleven. **#404 is titled "Not Found" and carries the
Essence `crash`.** HTTP 404 is the not-found status code, so Pindar named that piece after its own
GAN number, and then gave it a word that means a computer failure. **#407 is titled "Mint Bot".**
The other seven bespoke names are `Eye Swarm` (#370), `Twinvader` (#373), `Test Test` (#374),
`Spin Twins` (#379), `Space-Clops` (#383), `Fire Squid` (#401) and `Primordial Phantom` (#441).

I record this because it cuts both ways and I cannot tell which way it cuts. It is corroboration
that the fixed-point eleven contains pieces Pindar treated as special, since he stopped to write a
number joke on two of them. It is also a warning, because the bespoke-name set has nine members and
the fixed-point set has eleven, and they overlap in only two — so "the pieces Pindar paid extra
attention to" and "the pieces whose Essence obeys the wrong drop's rule" are mostly different sets.

---

## 5. The chains run backwards

The brief asked me to start from eleven BIP-39 words and ask what set of artworks maps to them.
Because the Essence field is injective, every word-to-artwork hop inverts cleanly, so this is a
well-posed question rather than a search. I inverted five hops — `essence`, `gan -> bip1`,
`gan -> bip0`, `pod` and `mint -> bip1` — against four candidate answers. The most important
result is a negative and it is decisive.

**The eleven pre-clue forged SuperRare Essences have no preimage in Act 1.** Of the eleven words
`super rare series ritual level secret update switch symbol upgrade chief`, not one is the Essence
of any of the 513 artworks; only `chief` has a BIP-39 index small enough to name an Act 1 GAN at
all, and it names #319, which has nothing to do with it. Under the podGALLERY hop, one word
resolves. Under mint order, one. This confirms what the forge report concluded from the other
direction: the forged Essences are a separate vocabulary that the Act 1 collection never touches.
If that eleven is the answer, it is a standalone set reached by no hop from the main collection,
and the multi-step framing gives no help with ordering it.

By contrast the fixed-point eleven and the burnt Flaming eleven both invert perfectly, eleven out
of eleven, under both `essence` and `gan -> bip1` — which is another way of saying they are
skullGAN-register sets and the register is its own inverse. The Fibonacci eleven inverts ten out of
eleven, and the one failure is `bean`, which resolves to #157 instead of #21. That is the #21
register break showing up again, and it means any chain applied to the Fibonacci eleven that
routes through BIP-39 indices will put the wrong artwork in the eighth slot.

---

## 6. What I tested

Testing is cheap and I used that. The harness is `mrun.py`, built on the project's existing
`fast3.py` and the 33 derivation paths in `paths_wide.py`. Before running anything I proved the
harness detects a seed it is supposed to find, which is the discipline the brief demanded: I
computed the address of a phrase I chose myself, `chaos choice clock combine common control
correct crash crazy culture danger author`, which is
`0x9310de71a116d3b8d9de0a6ea1e1d4ee981239d2`, and wired that address into the runner alongside the
real target `0x18f87ec9c527aba1db44f715456bf28b0dae478d`. Every run therefore reports a `PLANT`
hit when it reaches that phrase, and every run did. I also re-checked the standard BIP-39 test
vector: `abandon` eleven times plus `about` derives
`0x9858EfFD232B4033E47d90003D41EC34EcaEda94` at `m/44'/60'/0'/0/0`, which it does.

For every candidate the runner enumerates all 128 checksum-legal twelfth words — the twelfth word
goes last and only last, exactly as the clue says — and derives all 33 paths for each, so 4,224
derivations per ordering. I ran each candidate in six to ten stateable orderings and never
attempted a permutation sweep: as given by the chain, reversed, BIP-39 index ascending and
descending, alphabetical and reverse alphabetical, and where the source artworks were known, mint
order and GAN order and both of their reverses. Mint order was included on every set that has one,
because mint order is Pindar's ordering convention in every puzzle of his that was solved.

Two batches ran, on two cores, with the other eight left for the concurrent sweep.

- **Batch 1**: the 221 non-degenerate word vectors produced by applying the 162 chains to the 47
  pre-existing source elevens plus the four structural elevens. 690 orderings, 2,914,560
  derivations.
- **Batch 2**: the 83 further non-degenerate vectors produced by the Hidden-Type sources, the
  chain-corrupt-side eleven, and the ten bent glitch-column unions. 278 orderings, 1,174,272
  derivations.
- **Batch 3**: 919 orderings, 3,881,856 derivations — a bounded perturbation sweep on the seven
  strongest sets. This is not a permutation
  sweep and it is not inspiration; it is motivated by a defect that demonstrably exists in this
  collection. The Solstice register has #259 and #268 exchanged with each other, which means a
  single transposition of an otherwise-correct order is a *documented* failure mode here. So for
  each of the seven sets I tested the natural order perturbed by every one of the 55 single
  transpositions, in both directions, plus all ten cyclic rotations, plus the eleven orders that
  move one member to the end — the last of these because the clue says the twelfth word goes last,
  and a member displaced to the end is the shape that mistake would take.

Across the three batches that is **1,887 orderings and 7,970,688 derivations**.

**Result: no hit on the target wallet in any batch.** Batches 1 and 3 both contain the planted
phrase among their candidates and both recovered the planted address, so the code path is proven
immediately before and after batch 2. Batch 2 itself reported zero hits of either kind, which is
what it should report, because none of its 83 candidates is the planted phrase — it is the same
binary in the same run, but it is fair to say it does not carry its own internal proof.

One further fact about the fixed-point eleven came out of setting batch 3 up, and it is worth
stating plainly. **That set has effectively only one stateable ordering.** Its members' GAN order,
mint order, drop-local numbers, BIP-39 indices and alphabetical order are all the same permutation,
because the register that defines the set forces its words to run up the BIP-39 list in step with
the GAN numbers. Their frame counts are all 55, their loop durations all 5,500 ms, and their
Dimensions are all 4 or 5. There is no second property to order them by. So if that eleven is the
answer, the ordering cannot come from the collection at all, and the two orderings it can state
have both now been tested and both have failed.

---

## 7. What this rules out, and what I would do next

The multi-step hypothesis is not refuted, but the specific shape the collection owner hoped for is.
There is no eleven-cycle. There is no eleven-to-eleven correspondence. The forge maps eleven burnt
Flaming skullGANs onto ten forged pieces, with a hole where the 49/20 pair was never redeemed, and
the podGALLERY mechanism was not reused. The three hops that most obviously existed — the register,
the forge, and the podGALLERY cross-list read — compose into far fewer distinct phrases than their
count suggests, because the register absorbs most compositions built around it.

What survives, in the order I would pursue it:

**The fixed-point eleven deserves a harder ordering search than anyone has given it.** It is the
only non-trivial fixed-point structure in the collection, its motivation is independent of its size
in the sense that I found it by census rather than by filter, and it has now been tested in ten
orderings against thirty-three paths without a hit. Ten orderings out of 39,916,800 is not a test.
The right next move is not a blind permutation sweep but a search over orderings that a *second*
property of those eleven pieces could state — their drop-local numbers, their frame counts, their
Arweave filenames, their token indices — since a second property is exactly what a two-step puzzle
would supply for the ordering.

**The `action` hole should be chased.** One BIP-39 word that a stated rule of this collection
demands and that nothing supplies is the most specific unexplained fact I found. If eleven glitches
are hiding somewhere, a word Pindar deliberately declined to spend is a plausible place for the
eleventh to be pointing.

**The Ghosts drop's near-diagonal band should be mapped properly.** Fifteen pieces track the
skullGAN register, eleven exactly and four by one or two. Nobody has established whether that band
has a rule of its own, and until somebody does, the choice between "the eleven exact ones are the
glitches" and "the four near-misses are the glitches" is being made by taste.

**And the forged eleven should be treated as what the backward run shows it to be** — a set with
no preimage, no hop into it, and therefore no ordering that the collection itself can state. If it
is the answer, the ordering has to come from the SuperRare contract, and the only orderings that
contract states are mint order, token id and stroke count, all three of which have been tested.