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.
1. Player input8 frames × 12 bitsChronological masks, each from 000 to fff.
2. Dynamic transformationPermutation + phaseThe graph's previous activity changes the next stimulus.
3. Synthetic lockConstraints + traces + aggregatesAll parts must align at the genuine target.
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.
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
Offset
Field
Size
Meaning
0x00
magic
4 bytes
ASCII FLY5.
0x04
nn
u32
Node-record count.
0x08
ne
u32
Edge-record count.
0x0c
encoded_marker
u32
Marker index XORed with the derived index key.
0x10
s1
u32
Seed used to derive the lane key.
0x14
s2
u32
Seed used to derive the index key.
0x18
frame_count
u16
Eight input frames.
0x1a
input_width
u16
Twelve bits per frame.
0x1c
ciphertext_length
u16
Length of the encrypted genuine success response.
0x1e
decoy_count
u16
Eight 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.
Statefulness, strict comparison, and hold duration.
+14
Padding
2 bytes
No 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.
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.
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.
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.
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.
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.
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.
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:
Frame
Mask
12-bit form
0
43c
0100 0011 1100
1
42a
0100 0010 1010
2
d5a
1101 0101 1010
3
f02
1111 0000 0010
4
854
1000 0101 0100
5
1bf
0001 1011 1111
6
66f
0110 0110 1111
7
01c
0000 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
Symptom
First thing to inspect
Decoded nodes look nonsensical
30-vs-32-byte header assumption, record sizes, endian order, signed conversion.
The target cone is unexpectedly tiny
Wrong marker, decoy sink, v2 rather than v3 specimen, missing aggregate predecessors.
Equations look right but no consistent assignment exists
Lane permutation direction, frame-depth off-by-one, complementary polarity, signed-weight sum.
Trace hold counters, aggregate counts, target sampling, settling-loop duration.
Output looks successful but is a sentence-shaped decoy
Header-selected target and honeypot branch, rather than output formatting alone.
Known masks work but the flag differs
Per-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 PDF
v3 hardening
Lesson
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 7: release packaging and per-download ciphertext injection.
Files described in the PDF
Reported path
Role
Player package?
Present here?
dist/fly
Player executable; loader, simulator, and conditional flag decryption.
Yes
No
dist/connectome.fly
Encoded graph specimen and encrypted response.
Yes
No
dist/README.md
Input format and run instructions, without spoilers.
Yes
No
neuro-lock-specimen03.zip
Download containing exactly the three player files.
The package
No
author/build.py author/build.seed
Deterministic specimen builder and 32-byte build seed.
No
No
author/engine.cpp
Reference C++ simulator used to build the executable.
No
No
author/solve.py author/CONSTRAINTS.json
Private solver and constraint/latch/relay metadata.
No
No
author/naive_check.py
Regression check that the older shortcut strategy fails.
No
No
author/decoy_check.py author/DECOY_SEQUENCES.json
Reachable honeypot audit and private decoy sequences.
No
No
author/test_release.py author/SOLUTION.md
Release tests and current private answer.
No
No
author/inject.ts author/inject.js
Bun-based per-download flag injector.
No
No
neurons.csv.gz connections_princeton.csv.gz
Build-time FlyWire source tables.
No
No
Discrepancy register
Topic
What the PDF says
How 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 duration
v3 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 holds
Construction section: 12/10/8/6. Temporal walkthrough: 8/6/4/2.
Preserves both claims. Decode actual node flags and stateful-update semantics.
Version naming
Lock 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 details
Names 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” solution
Reports 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 flags
Injector 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.