It's a Fly

PDF-based reference

Eight hexadecimal frames. A noisy neural graph. One genuine target hidden among convincing decoys. The real puzzle is reconstructing the state machine—not spotting a flag-shaped string.

Reverse engineeringBinary parsingGraph traversalConstraint solvingStateful simulation
  1. 1. Player input8 frames × 12 bitsChronological masks, each from 000 to fff.
  2. 2. Dynamic transformationPermutation + phaseThe graph's previous activity changes the next stimulus.
  3. 3. Synthetic lockConstraints + traces + aggregatesAll parts must align at the genuine target.
  4. 4. Conditional decryptionState-dependent flag keyA correct firing state unlocks the encrypted answer.
The fly connectome supplies the background dynamics; a planted threshold circuit supplies the lock. The write-up explicitly describes this as a challenge mechanic, not a validated biological model.

The lab in plain English

You are given a stripped player executable, fly, and a binary specimen, connectome.fly. The executable consumes eight three-digit hexadecimal masks. Each mask drives twelve logical input bits for one frame. After the input sequence and settling ticks, it checks whether a particular target cell fired.

The specimen mixes real connectome-derived connectivity with synthetic relays, equality comparators, memory traces, and aggregate gates. Its records are shuffled, its rail lanes are encoded, and its target is selected indirectly. Several alternative sinks can print convincing-looking decoy responses.

A full solve reconstructs the binary layout and simulator, follows the correct target's ancestry, solves the joint input constraints, and reverses the history-dependent transformation to obtain the masks the player should actually enter.

What was actually available

This reference was made from the supplied seven-page author PDF and its extracted text. The player executable, specimen, source CSVs, and author/ tree described in that PDF are not present in this collection. No lab, binary, solver, or build script was run. The reported answer below is not an independently reproduced result.

What success would mean

  • Resolve the header-selected marker and follow its outgoing edge to the real target—not a lookalike sink.
  • Recover a consistent assignment to all 96 frame bits, rather than eight independent exact-match keys.
  • Reproduce signed weights, delayed edges, strict comparisons, stateful holds, and phase history exactly.
  • Obtain the genuine success response using the correct sequence and final state; do not count a decoy preamble as proof.

The central idea

Structure gives you constraints. Exact simulation tells you which raw inputs satisfy them over time.

The central trap

An attractive node, a tiny dependency cone, or a familiar-looking output can all belong to a decoy.

Reveal the author-reported sequence and flag

The PDF labels this the current author solution. A rebuilt specimen can require different masks; a per-download injector can change the flag without changing the masks.

Frame 043c
Frame 142a
Frame 2d5a
Frame 3f02
Frame 4854
Frame 51bf
Frame 666f
Frame 701c
Reported masks · chronological order
43c 42a d5a f02 854 1bf 66f 01c
Reported flag · not runtime-verified here
luh{WH0_137_7H3_F1Y_0UT}

How the lock works

Model described by the PDF

The eight frames are coupled by constraints and history. You cannot recover the current lock by reading one tiny detector per frame.

1. Background graph and synchronous ticks

The builder reportedly selects 28,000 neurons from medulla, lobula, and lobula-plate groups, retaining roughly 223,000 real connections for this build. Synapse counts become small integer weights; GABA connections become negative. These are signed contributions, so inhibition matters just as much as excitation.

Ordinary background edges carry delays of one to three ticks through ring buffers. Rail sources are externally forced and deliver within the current tick. Roughly 15% of background cells use sum > threshold rather than sum >= threshold. Those one-unit differences can change the background signature and every subsequent phase value.

Conceptual update · not a complete executable simulator
for each tick:
    drive this tick's rails from the transformed input
    collect signed arrivals using each edge's delay
    compute every next cell state from the same old state
    apply the cell's comparison and stateful-hold rules
    commit all next states together
    update signatures, history and the 12-bit phase

Never update one cell and immediately let its new state
influence a later cell in the same iteration.

This is synchronous simulation, not a traversal-order-dependent propagation. The precise order of queue operations, signature sampling, and hold-counter updates must come from the actual loader and tick implementation if they become available.

2. Positive and complementary sensory rails

There are twelve positive rails and twelve complementary rails. The twelve lane positions are shuffled by an LCG-based Fisher–Yates permutation derived from the header's lane key.

Logical bit to physical rail relationship
logical bit b = 1  → positive lane perm[b] is active
logical bit b = 0  → complementary lane 12 + perm[b] is active

perm maps logical bit → stored lane.
Its inverse maps stored lane → logical bit.

Do not confuse a node's root ID, its array index, its decoded lane, and its logical bit number. They are four different identifiers.

3. Relays preserve which frame a bit came from

A simple persistent latch would OR a bit across frames, destroying its frame identity. v3 instead uses positive and complementary relay chains that shift each frame's bit forward one stage per tick.

The documented relationship is depth = RELAY_DEPTH − j, with RELAY_DEPTH = 8 and zero-based frame j. Depth 1 is undelayed because rails deliver same-tick. Thus frame 0 is read at depth 8, while frame 7 is read at depth 1. The relay wiring is uniform; it is not itself a readable answer key.

4. Mirrored threshold cells implement equality

Each of 100 joint constraints draws bits from two to four different frames and asserts Σ(wᵢxᵢ) = t. The PDF describes weights of +1 or −1. Two mirrored cells enforce each equality, giving 200 constraint cells at the true sink.

Why the mirrored pair is an equality
S = Σ(wᵢ × xᵢ)       W = Σ(wᵢ)

Positive cell:       S ≥ t
Complement cell:    Σ(wᵢ × (1 − xᵢ)) ≥ W − t
                    W − S ≥ W − t
                    S ≤ t

Both current comparisons hold exactly when S = t.

The complementary threshold is the sum of the signed weights minus the target, not the number of terms minus the target. That distinction is essential when negative weights appear. This algebra describes simultaneous comparison of the same input; stateful comparator latches still require the engine's temporal rules.

A small example

Suppose S = x₀,₂ − x₂,₇ + x₄,₀ + x₇,₉ must equal 1. Here W = 2. The two threshold conditions are S ≥ 1 and 2 − S ≥ 1, forcing S = 1. This is an illustrative equation, not one extracted from the absent specimen.

The full problem has 8 × 12 = 96 unknown bits. Solve the equations together with propagation plus depth-first search, or with an SMT solver. Independent 4,096-value searches for each frame discard the cross-frame relationships.

5. Traces and aggregates make timing unavoidable

The target has three classes of predecessors: 200 constraint cells, four memory traces, and four background aggregate gates. The documented sink condition requires all of them. The traces relate to frames 0, 2, 4, and 6 and retain activity for a configured hold interval.

The aggregate gates reportedly demand exact weighted counts across 1,000 background neurons, divided into four groups of 250. They force the target's ancestry into the real background instead of allowing a tiny isolated lock-only simulation. The PDF reports a backward cone of 26,167 out of 33,337 cells—roughly 78% of the graph.

Do not choose a timing model from prose alone

The v3 description specifies two zero-input settling ticks and trace holds of 12/10/8/6. Later walkthrough text specifies one settling tick and holds of 8/6/4/2. These are incompatible descriptions; the actual engine and node flags are needed to resolve them.

6. The history-dependent phase hides the raw masks

Before driving the rails, the engine maps the player frame into lane space and XORs it with a 12-bit phase register. The register changes with the background's activation signatures and previous history. Lock cells in region 255 are excluded from the background signature.

Phase update expression quoted by the author PDF
rotl3(phase) ^ sig ^ (sig2 * 0x9E37)
             ^ histmix(prevSig) ^ 0x5a3

The write-up says sig accumulates active background cells, sig2 folds odd-ID ones, and prevSig is the previous tick's signature. It does not supply enough implementation detail here to invent a correct initial phase, LCG constants, signature formulas, or histmix.

Constraint solving recovers the transformed stimuli seen by the lock. Exact chronological background simulation is then needed to reverse the phase and permutation and obtain the raw masks the player enters. Keep these two sequences separate in your notes.

7. Why ciphertext extraction is not the solve

The genuine ciphertext is decrypted only when the target fires. Its stream-cipher key depends on the final activation bitmap, all eight submitted frames, and the decoded target index. A wrong simulation state or a forced branch generally yields an incorrect key, not the genuine answer.

Eight reachable honeypot entries can produce success-mimicking output when their own sinks fire. Twenty other chains and four near-miss chains add structural ambiguity; the PDF says the near-miss constructions are based on the genuine stimuli with a flipped bit. Start from the selected marker rather than guessing from degree, threshold, ID, or record position.

Binary format

Documented, not parsed here

Decode identity before topology. The records are little-endian and independently shuffled; an array position is not a biological root ID.

A header-size discrepancy worth catching early

The PDF calls the header 30 bytes, but all ten fields it lists add up to 32 bytes. The last listed uint16 decoy_count would extend the header from 30 to 32. The offsets below are arithmetic consequences of the complete field list—not offsets verified against a supplied binary.

Header, as listed in the write-up

OffsetFieldSizeMeaning
0x00magic4 bytesASCII FLY5.
0x04nnu32Node-record count.
0x08neu32Edge-record count.
0x0cencoded_markeru32Marker index XORed with the derived index key.
0x10s1u32Seed used to derive the lane key.
0x14s2u32Seed used to derive the index key.
0x18frame_countu16Eight input frames.
0x1ainput_widthu16Twelve bits per frame.
0x1cciphertext_lengthu16Length of the encrypted genuine success response.
0x1edecoy_countu16Eight honeypot entries in the described release.

Key and lane derivations

Formulas reported in the PDF
lane_key  = s1 XOR (nn * 2654435761) XOR 0x9E3779B9
index_key = s2 XOR rotl32(ne, 7) XOR 0xC2B2AE35
marker    = encoded_marker XOR index_key

Apply 32-bit wrapping to the key arithmetic.

raw       = encoded_lane_byte XOR (lane_key & 0xff)
lane      = raw if raw < 128 else raw - 256
perm      = LCG-Fisher-Yates([0..11], seed=lane_key)

Read the encoded lane as an unsigned byte before the XOR, then reinterpret the result as signed. The decoded value −1 denotes an ordinary cell. The exact LCG and shuffle implementation must be recovered from the binary or engine; its seed alone is not enough to reproduce it.

Node records: 16 bytes each

The documented struct format is <QhBBbB2x. The leading < specifies little-endian, standard-size fields without native alignment.

Record offsetFieldTypeInterpretation
+0Root IDu64Label, not node-array offset.
+8Thresholdi16Signed comparison threshold.
+10Transmitteru8Transmitter metadata.
+11Regionu8254: marker; 255: synthetic lock/complement cells.
+12Encoded lanei8 storageXOR low lane-key byte, then reinterpret signed.
+13Flagsu8Statefulness, strict comparison, and hold duration.
+14Padding2 bytesNo documented semantic value.
Node-flag meanings from the write-up
flags & 0x01   → stateful cell
flags & 0x02   → strict-greater comparison
flags >> 2     → hold duration

Region 254     → marker cell candidates
Region 255     → lock/complement cells; excluded from phase signature

Several marker candidates have the same profile. Only the header-selected marker identifies the genuine target. Region filtering alone does not select the right chain.

Edge records: 10 bytes each

The documented format is <IIbB: source node index (u32), destination node index (u32), signed weight (i8), and delay (u8). Background delays are 1–3; lock edges reportedly use delay 1 and constant pairs delay 2. Externally forced rails have special same-tick behavior, so do not model every source identically.

Adjacency representation · schematic only
incoming[destination_index].append(
    (source_index, signed_weight, delay)
)
outgoing[source_index].append(
    (destination_index, signed_weight, delay)
)

target = the sole destination of outgoing[decoded_marker]

Use indices for adjacency. Preserve weights and delays; stripping either produces the wrong circuit. The PDF does not give the actual graph records, so no target index can be filled in here.

Ciphertext and honeypot table

The release contains genuine ciphertext and a trailing honeypot table, with each honeypot described as u32 cell_xored, u16 length, and that many payload bytes. Decode the sink with cell_xored XOR index_key. The table is reported to end at EOF.

Do not treat the variable-length honeypot records as part of a fixed-size header. Before assigning ciphertext or table offsets, establish the loader's actual ordering, count fields, and bounds checks. A pre-decoy 30-byte assumption would shift every subsequent section if the described 32-byte layout is present.

Static parser checklist for a future specimen

  • Validate the magic, frame count, and bit width before using the counts.
  • Confirm the real header size and record ordering from the loader, not this prose alone.
  • Check the available length against nn × 16 and ne × 10 without integer overflow.
  • Check every decoded marker and edge endpoint is inside the node array.
  • Decode signed thresholds, signed weights, and signed lanes correctly.
  • Require the selected marker's expected outgoing edge and preserve all delay values.
  • Bounds-check ciphertext and each variable-length honeypot entry; account for the entire file.

Solve walkthrough

Static study plan

Work backward to discover the constraints, then forward to reconstruct the timing. Keep graph-derived stimuli separate from the masks entered by the player.

This adapts the intended route from PDF pages 4–6 for reading and static analysis. It does not run the program, author helper, or simulator. The absent player files are prerequisites for independently reproducing the solve.

  1. Establish the interface and actual execution path

    From the documented interface, record eight chronological masks, twelve bits each, with a valid range of 000–fff. In a future static review of fly, begin at main and follow the parser into the specimen loader, input loop, tick routine, and success branch.

    The PDF explicitly warns about a dead legacy 0x-prefix parser and an unused alternate key derivation. A decompiler showing a function is not proof that the live path calls it.

    Record: accepted syntax, frame count, input width, reachable loader, live key derivations, and the exact post-input settling loop.
  2. Recover the simulator contract before writing one

    Identify how it drives rails, queues delayed arrivals, accumulates signed weights, performs > versus >=, updates stateful cells, samples signatures, and advances the phase. Also locate the initial state and rotation/masking widths.

    Hold counters and delays are not implementation decoration. An off-by-one hold or an in-place state update can produce a plausible but false solve.

    Record: a single tick's ordered operations and the provenance of every state variable. Leave unresolved values blank instead of selecting one of the PDF's conflicting descriptions.
  3. Decode the specimen's identifiers

    Parse the header and records, derive lane_key and index_key with 32-bit wrapping, decode the signed lanes, and reproduce the live LCG permutation. Build forward and reverse adjacency keyed by node-array indices.

    Use the decoded header marker's single outgoing edge to select the true target. Other region-254 markers point to decoys; shuffled file order and root-ID magnitude are not selectors.

    Record: the selected marker index, target index, inverse lane permutation, and section boundaries. These cannot be obtained from the supplied PDF alone.
  4. Turn the target's ancestry into equations

    Separate constraint cells, memory traces, and aggregate gates. For each mirrored comparator pair, trace inputs backward through relay chains to positive or complementary rails. Translate relay depth into frame index and physical lane into logical bit.

    For depth d, the documented frame relationship gives j = 8 − d. Collect the signed coefficients and threshold into one equation per pair. Check the mirror uses Σw − t, not a term-count shortcut.

    Constraint representation · conceptual
    x[frame][bit] ∈ {0, 1}
    
    for each of 100 recovered mirrored pairs:
        Σ(weight × x[recovered_frame][recovered_bit]) = threshold
    
    Each equation can tie together several different frames.
    Record: 100 equations over 96 Boolean variables, plus trace and aggregate conditions. Do not invent missing coefficients from the reported final masks.
  5. Solve jointly, with signed bounds

    Use propagation and DFS or an SMT solver. During propagation, compute the minimum and maximum contribution still possible from unassigned bits. For a −1 coefficient, an unassigned bit contributes in [−1, 0], not [0, 1]. Prune a branch if the target is outside the reachable interval.

    When an equation leaves only one viable value for a bit, propagate it into all related equations before branching again. If several assignments remain, validate their temporal and aggregate behavior instead of assuming the first assignment is unique.

    Result at this stage: the transformed frame stimuli seen by the lock—not yet the raw author-reported input sequence.
  6. Invert the phase chronologically

    Reconstruct the exact background state from the initial tick. For each recovered stimulus, reverse the lane permutation and phase transformation in the order established from the engine. Advance the exact background simulation and its two signature accumulators to obtain the next phase.

    You cannot use one constant XOR for all frames: the phase depends on the preceding background activity and previous signature. Delayed edges and strict comparisons therefore influence later raw masks.

    Record: a per-tick table of transformed stimulus, raw mask, phase before/after, signatures, and trace counters. This is the useful debugging artifact if a candidate eventually fails.
  7. Check the genuine sink and final-state key

    With the real engine's timing, account for all 200 constraint cells, four traces, and four aggregate gates at the sampled target tick. The PDF disagrees about one versus two settling ticks, so independent validation must use the actual implementation.

    Inspect how the final activation bitmap, raw masks, and target index feed key derivation. A flag-shaped string from another sink is not equivalent to satisfying the true target.

    Expected evidence for a future reproduction: the selected target fired, the exact final state produced the genuine response, and deliberately altered sequences were not mistaken for success. None of that runtime evidence is claimed here.
Reveal the worked answer reported by the author

The PDF gives these masks for its current specimen, in zero-based frame order:

FrameMask12-bit form
043c0100 0011 1100
142a0100 0010 1010
2d5a1101 0101 1010
3f021111 0000 0010
48541000 0101 0100
51bf0001 1011 1111
666f0110 0110 1111
701c0000 0001 1100
One mask per frame · inert reference text
43c
42a
d5a
f02
854
1bf
66f
01c
Author-reported success response
luh{WH0_137_7H3_F1Y_0UT}

Reversing these masks or concatenating them into one number changes the temporal input. The PDF says settling is automatic, but does not consistently specify how many ticks.

If a future recreation disagrees

SymptomFirst thing to inspect
Decoded nodes look nonsensical30-vs-32-byte header assumption, record sizes, endian order, signed conversion.
The target cone is unexpectedly tinyWrong marker, decoy sink, v2 rather than v3 specimen, missing aggregate predecessors.
Equations look right but no consistent assignment existsLane permutation direction, frame-depth off-by-one, complementary polarity, signed-weight sum.
One frame works, later phases divergeEdge delays, strict comparison, signature membership, update order, previous-signature mixing.
Constraints fire but the target stays silentTrace hold counters, aggregate counts, target sampling, settling-loop duration.
Output looks successful but is a sentence-shaped decoyHeader-selected target and honeypot branch, rather than output formatting alone.
Known masks work but the flag differsPer-download ciphertext injection. The graph and eight-frame solution can remain unchanged.

Things to learn

Takeaways & design lessons

This lab rewards precise models, not clever-looking shortcuts. Its best lessons apply well beyond reverse-engineering a graph puzzle.

Follow behavior, not appearances

Recover the live data flow from parser to loader to simulator to decryption. A dead parser, unused formula, high-ID sink, or familiar output string can all mislead you. Treat each hypothesis as a statement that needs evidence from the actual execution path.

Separate representation from meaning

An encoded lane is not a bit; a root ID is not an offset; a transformed stimulus is not a player mask. Keep explicit maps between representations. Most “almost correct” solutions to this challenge can be explained by collapsing two of those identities.

Use graph structure to reduce the search intelligently

Reverse adjacency turns the selected target into a meaningful dependency cone. But a large cone is not a license to drop inconvenient background cells: the aggregate gates and phase register make the background part of the answer.

Translate circuits into mathematics

Mirrored threshold pairs encode equality. Relays encode time. Complement rails encode negation. Once these relationships are identified, the task becomes a constrained Boolean problem rather than blind enumeration of every eight-frame combination.

Time is a first-class variable

Signed weights, edge delays, strict thresholds, hold counters, and synchronous commits define the state machine. Documenting them precisely matters more than using a particular solver library or decompiler.

Keep claims and evidence separate

The supplied PDF reports a solve and describes a release, but does not include the artifacts needed to reproduce either. Its answer is useful reference material; it is not independent proof that a missing or future specimen accepts that input.

Why the older shortcut stopped working

v2 property reported by the PDFv3 hardeningLesson
Backward cone: 34 of 30,581 cells.Background aggregate gates expand the reported dependency cone to roughly 78%.Make the intended mechanism causally relevant, not decorative.
Exact 12-bit detector per frame, readable by 4,096 candidate tests.100 joint equalities tie together bits from multiple frames.Remove independent subproblem shortcuts when joint reasoning is the intended challenge.
A simplified delay-1 model and direct target assumptions could be useful.Real delays, history-dependent phase, marker resolution, and strict cells matter.Use regression checks to detect the old exploit strategy surviving a redesign.
Simple success-looking output can be overtrusted.Reachable self-labeling decoys mimic success.Establish the genuine acceptance condition before interpreting an output.

Challenge hardening is not production security

Shuffled records, encoded indices, decoy graphs, and state-derived decryption make this puzzle more demanding. They are not substitutes for cryptographic access control: a client that contains the entire simulator and ciphertext can be studied. Do not generalize the anti-shortcut design into a claim of tamper-proof software.

For a challenge author or maintainer

  • Version the format explicitly. The magic is FLY5, the lock is called v3, and the injector section refers to a v2 honeypot table. State how those versions relate.
  • Generate documentation from actual definitions. Header size, settling count, hold duration, and record layout should have one authoritative source.
  • Keep player and author packages separate. The player package should contain only instructions, executable, and specimen—not the solution, seed, solver, or source tables.
  • Test negative cases as carefully as positive ones. A correct sequence should be accepted by the genuine target; near misses must not be classified as genuine success merely because a decoy prints text.
  • Validate per-download injection. Change only the intended ciphertext, keep executable permissions and other payloads intact, and regenerate the embedded keystream after a fresh specimen build.
  • Treat binary input as untrusted. Check counts, arithmetic, endpoint bounds, variable-length entries, and file completeness before allocating or indexing.

Self-check before closing the guide

  • Can I explain why a positive/complementary pair enforces equality even with negative weights?
  • Can I map frame 0 and frame 7 to the documented relay depths?
  • Can I explain why a same-tick rail is not the same as a delayed background edge?
  • Can I distinguish the header-selected marker from three lookalike markers?
  • Can I explain why solving the 96 lock bits is not yet enough to know the player masks?
  • Can I list the three unresolved specification conflicts without choosing values arbitrarily?
  • Can I explain why a success-like decoy response is not proof of solving the genuine target?

Useful next study topics

Little-endian parsing and signed integers; reverse graph traversal; incremental constraint propagation; SMT Boolean/integer encodings; discrete-time simulation and ring buffers; state-dependent stream-cipher key derivation; and evidence-based release testing.

Files & source notes

Evidence boundary

Keep this page with the walkthrough. It distinguishes files named in the author guide from files actually supplied, and preserves the details that need checking later.

The source used for this reference

Arshlaan_s Write-ups/It_s a Fly - Author Guide and Complete Walkthrough.pdf

Seven pages. The supplied PDF's extracted text was read to create this reference. Direct PDF preview was not supported in this environment. Its embedded source references describe a separate challenge repository that was not provided here.

This HTML is self-contained: the explanations, tables, diagrams, styling, and navigation are all in this file. It needs no server, internet connection, CDN, or adjacent assets. The original PDF and missing lab artifacts are not embedded. Nothing here launches them.

Where to revisit the original write-up

  • Page 1: author/player file roles and packaging boundaries.
  • Page 2: player task, older v2 shortcuts, and current v3 construction.
  • Page 3: rails, joint constraints, graph decoys, phase behavior, and header fields.
  • Page 4: remaining format details and the beginning of the solve route.
  • Page 5: derivations, marker resolution, target ancestry, equations, and aggregates.
  • Page 6: phase inversion, temporal checks, decryption, reported answer, and build notes.
  • Page 7: release packaging and per-download ciphertext injection.

Files described in the PDF

Reported pathRolePlayer package?Present here?
dist/flyPlayer executable; loader, simulator, and conditional flag decryption.YesNo
dist/connectome.flyEncoded graph specimen and encrypted response.YesNo
dist/README.mdInput format and run instructions, without spoilers.YesNo
neuro-lock-specimen03.zipDownload containing exactly the three player files.The packageNo
author/build.py
author/build.seed
Deterministic specimen builder and 32-byte build seed.NoNo
author/engine.cppReference C++ simulator used to build the executable.NoNo
author/solve.py
author/CONSTRAINTS.json
Private solver and constraint/latch/relay metadata.NoNo
author/naive_check.pyRegression check that the older shortcut strategy fails.NoNo
author/decoy_check.py
author/DECOY_SEQUENCES.json
Reachable honeypot audit and private decoy sequences.NoNo
author/test_release.py
author/SOLUTION.md
Release tests and current private answer.NoNo
author/inject.ts
author/inject.js
Bun-based per-download flag injector.NoNo
neurons.csv.gz
connections_princeton.csv.gz
Build-time FlyWire source tables.NoNo

Discrepancy register

TopicWhat the PDF saysHow this guide handles it
Header size“30-byte header,” but the complete listed fields—including decoy_count—sum to 32 bytes.Shows the complete field-list arithmetic and labels offsets unverified. Confirm the live loader before parsing.
Settling durationv3 section: SETTLE = 2. Later model and walkthrough: one all-zero tick.Does not select either as established behavior. The engine's post-input loop must settle it.
Memory-trace holdsConstruction section: 12/10/8/6. Temporal walkthrough: 8/6/4/2.Preserves both claims. Decode actual node flags and stateful-update semantics.
Version namingLock v3, file magic FLY5, and a “v2 honeypot table” in the injector section.Does not assume these are the same version axis or that older wording matches the release.
Missing implementation detailsNames an LCG shuffle, phase initializer, signatures, history mixer, and stream-cipher key derivation without full code here.Explains their role but does not invent constants or supply a supposedly complete solver.
“Current” solutionReports masks and a flag for the author's current specimen; rebuilding the seed changes the specimen.Labels the answer author-reported and specimen-specific, not independently reproduced.
Per-download flagsInjector changes a fixed 24-byte genuine ciphertext; the same masks work across instances using that graph.Notes that flag changes do not necessarily indicate a different solution sequence. A fresh graph requires a fresh injector keystream.

What is and is not established

  • Established from the supplied document: its reported architecture, structures, formulas, intended solve route, answer, and packaging policy.
  • Derived in this guide: the 32-byte total from the listed header fields, field offsets under that layout, the mirrored-equality algebra, and binary representations of the reported masks.
  • Not established: the missing binary's actual header, target index, coefficients, initialization, precise timing, cipher implementation, or acceptance of the listed masks.
  • Not performed: executable launch, specimen simulation, author-script execution, build, exploit testing, or live challenge access.
No commands need to be run to use this reference. Copy buttons copy text only; the print button prints the guide. Navigation and dark mode are local browser features.