Labyrinth · Areas

Labyrinth

This minisite awaits a maintainer’s check. A model this site has not proven yet worked on it (claude-sonnet-5-5), so a maintainer will measure its listing on one it has (how the check works).

Every area of the maze: how you reach it, what you do there, and how it is passed.

← Overview · All areas · Reading scope

Evidence and route gaps

Coverage: the text opening, gate entry, first-corridor exits, Brick Hallway doors, and the shared Alph and Ralph opening conversation. The Alph and Ralph check starts from a controlled room load; its connecting journey remains open. Local checks continue through the Wall of Hands and the Stone Corridor’s first door, archway, guarded-door refusal, and ladder. The guide is a set of checked local routes; the controlled guard-room setup leaves a gap in a complete journey.

Every area of the maze

The first seven areas are explained, in the order a player meets them. The Brick Hallway does not yet lead to the guards’ room, and no way past the Stone Corridor’s guarded door is known. The other fifteen are read from the code and one capture each; none has been played through. Choose an area to see how you reach it, what you do there, and how it is passed.

Area 1 · The text adventure

The text adventure

Labyrinth begins with a text adventure. You name your character, answer the setup questions, and explore the streets outside a movie theater. Two word wheels hold the available actions and objects. Entering go home takes you from the sidewalk to a room with a television and a camcorder.2 ($9114)

The rainy sidewalk described in text, above the action and object wheels
The playable opening, before the first command. The active wheel shows neighboring choices around the selected word.
The response to GO HOME describes a television and a video camera
The result of go home. Both pictures were captured from the supplied disk image.

Areas: follow the city’s command routes →
How the opening’s text is stored and drawn →

The city’s command routes

Commands depend on where you are and what you carry. The ticket counter blocks entry without a ticket; the popcorn stand adds choices about payment, change, and the dropped nickel. Follow these connections on the city workflow. The Controls page explains how to enter a command.

GO HOME checks where you are

The command stays the same, but its result depends on your location. On the street, go home selects the home location. At home, the command replies “You are home!” At the ticket counter, the command says you cannot go home from there. ($9114)


Sources and checks

The opening’s handler at $9114 reads the location’s entry from $AA58 and $AA66. A zero high byte selects a destination; another value selects a reply. All 14 table entries are checked against the original handler. Destinations are shown before their arrival routine runs.

The ticket changes GO EAST

At the ticket counter, go east checks whether you carry a ticket before consulting the movement table. Without a ticket, the reply is “You can't enter without a ticket.” With one, the table selects the lobby destination. ($90F4, $9327)

The purchase follows a shared payment path. Giving the dollar bill with at least five dollars available deducts four dollars in the ticket handler, then another dollar in the common give routine. The girl hands over one ticket.

Sources and checks

The east handler at $90F4 checks the ticket entry at $6740. The purchase path starts at $9327 and uses $087F to remove the final dollar. The eastward table decision is checked for every location index and every ticket byte; the purchase is checked with one through nine dollars. Arrival effects remain separate.

Two dollars for cold popcorn

At the popcorn stand, giving a dollar bill can spend two dollars: one in the counter’s branch and one in the shared GIVE routine. The first purchase adds a box of popcorn. After that, a purchase flag makes the woman refuse another dollar payment, leaving your money alone. ($93E1, $087F)


Sources and checks

The dollar-payment branch at $93E1 checks $9688, updates the dollar and popcorn inventory entries, and reaches the shared debit at $087F. The example is checked against the original GIVE handler with one through nine dollars and every purchase-flag byte. The response mentions change and a dropped nickel; the change collection example below follows their collection.

Two complaints recover the missing quarter

The popcorn menu asks $1.25, but the woman takes two dollars and leaves only two quarters in change. The first complaint gets an excuse. The second produces another quarter. Three quarters in change restore the advertised $1.25 price. Further complaints produce a rebuke. ($95B7, $927C, $943A)

This example starts just after the purchase. TAKE collects the available quarters together, then exposes the dropped nickel. Complaining before collecting the change puts three quarters on the counter; complaining after collecting it adds one more to pick up.

The starting inventory includes one nickel from character setup. The dropped nickel is an additional coin. This example follows a route that keeps the starting nickel.

The nickel changes the later offer

Returning a nickel after picking up the dropped one gets the woman’s thanks. The game remembers the return. While the teenager in the main theater accepts popcorn, keeping the dropped nickel makes him take the whole box. Returning it makes him take a handful and leave the box in your inventory. ($9485)

Sources and checks

TAKE at $927C, the complaint branch at $95B7, and the return branch at $943A update the pickup slot, quarter count, and nickel flags. The later offer checks $0575 at $9485. Counter sequences were replayed with ordinary inputs in VICE. The example is also compared with the original routines, including both later popcorn-offer branches; that later comparison isolates the offer before the movie transition.

See the counter route on the city workflow →

Browse the opening’s stored replies →

01 · City routes

The city as a workflow

This diagram puts those routes on one map. Select a place or an arrow to see its description, condition, and result. Solid arrows move between locations. Dashed arrows show actions at the counter. The dotted arrow follows the coin choice into the later theater encounter. ($90F4, $9327, $95B7)

A route through the cinema, with optional change collection. Details appear below the diagram; on narrow screens, scroll the diagram sideways. The counter actions can be taken in either order. This is a guide to verified decisions, rather than a complete playable opening.


Sources and checks

Movement selections are checked against the original direction handlers. The five-dollar ticket, two-dollar purchase and counter changes have original-code tests; the counter route also has live command observations. Later conversation timing and the graphical maze remain outside this diagram.

Try the counter’s change and nickel choices →

How the text is stored and drawn

01 · Character graphics

The opening’s letters

The dialogue’s letters are eight pixels wide and eight high. Each stored byte supplies one row, with a set bit lighting a pixel. The same font holds graphical symbols and blank slots alongside the letters. ($D000)

Sources and checks

The RAM font at $D000, extracted from the opening’s saved state. Every embedded byte is checked against the source listing; all 256 glyphs are compared with the site’s C64 character renderer. The viewer shows monochrome shapes.

View the opening’s letter shapes
The opening font rendered from RAM, with hexadecimal indices
The opening’s glyph sheet. Digits and letters occupy their ASCII positions; other slots include shapes and blank cells. The source listing documents the identified font data.

02 · Text storage

Words stored once

Labyrinth can insert a dictionary word into a sentence using two bytes: a format code and a word number. The format can give the word a capital initial or add a following space. Choose a word to see the stored instruction expand. ($67B5, $68D4)

Stored bytes:

A visible ␣ marks a space in this display. These words come from the opening’s dictionary; the controls show combinations independently of a particular sentence.

A passage, piece by piece

The opening mixes ordinary letters with dictionary references. Step through a stored passage to see which words come from the dictionary and where the game starts a new line. ($9867, $98A7)


Sources and checks

Passages at $9867 and $98A7, checked against the stored bytes and the game’s parser at each step. Line breaks follow the stored instructions; the display uses a browser font.

Sources and checks

The $67B5 parser chooses the format; $68D4 reads the word through the pointer tables at $D800 and $D900. All dictionary entries and four formats were checked against the game’s routine in a 6502 simulator: 1,024 cases.

03 · Stored replies

Replies from the city

The city’s replies mix ordinary letters with dictionary words. The same format carries street descriptions, shop transactions, and the beggar’s one-word hints. All 127 opening text streams are available below. Search for a word or hexadecimal start address, then choose a reply to read its expansion. ($67B5)

Sources and checks

Text records at $7910, $968E, and $9816 through $A9E7, checked against the original text parser at $67B5. The records include the menu asking $1.25 for popcorn, while the payment branch spends two dollar bills and its reply describes change. The counter interaction follows coin collection and the missing-quarter refund. Pronoun substitutions reflect the captured setup; the game can change them.

The cinema leads into the graphical adventure.

Continue to the entrance gate →

Area 2 · Entry mechanic verified · Other gate behavior remains open

The entrance gate

After the cinema, the graphical adventure places you outside the gate. Holding up from the starting position begins the entry sequence. Moving to either side first leaves the character against the foreground boundary.4 ($8D92)

The movement map divides the approach into horizontal columns. In the four columns shown here, the doorway column permits a deeper approach than its neighbors. Reaching depth 50 starts a script that changes the gate state and queues the first corridor. The diagram shows those world-coordinate checks, rather than a rectangle painted over the screen.

The player standing at the entrance gate before the approach sequence
The gate before any movement. With no input, the player stays here.
The player beside the gate after moving right and approaching the wall
Moving right before approaching leaves the player beside the doorway, at depth 24.

The doorway boundary

50240 064128255 side boundaryside boundary doorwaystart script at 50

A candidate-position check before the gate script takes control. The columns labelled “side boundary” lie beyond the neighboring columns’ movement limit.

Walking straight up to the gate reaches depth 51 and starts the scripted sequence. Approaching from the left or right stops the player at depth 24. The sequence then queues scene 2, which opens with a title card and the first brick corridor.

Sources and checks

The classifier at $4171 reads map cells at $0600, translates their type through $073E, and selects the depth bound from $41F0. The gate threshold is at $8D92. Gate stage $8CC0 requests sound 5, waits through four sixty-tick intervals, and queues scene 2 for the resident dispatcher at $59AF. The diagram’s lookup and threshold are compared with the original code across every low horizontal-coordinate and depth byte. The gate listing is partial; its remaining code, art and shared-engine ownership remain open.

See the corridor reached through the gate

A speech stored beside the gate script

The same resource holds seven lines addressing the cinema audience, including the player by name. Choose a line to read it. The player name is shown as ANON for privacy. In a nonzero scene, the phase-zero branch skips the seven speech records and starts phase 7. ($4171, $8D92) ($8E09, $8CD8)

The script keeps a phase and a countdown. When a countdown expires, it loads the next delay and advances the phase. Phases 0–6 select these messages; phases 7–13 continue the actor and gate sequence. Pressing fire on joystick port 1 sets the latch that can jump an early phase to 7. At phase 14, the script goes directly to checking the player’s approach depth.

Sources and checks

Message selection at $8E09, pointer tables at $8ED4/$8EDB, countdowns at $8EC5, and sequence dispatcher at $8CD8. The port-one sampler at $19AE supplies the fire latch at $1993; ordinary press, hold and release were checked live. The reader below normalizes whitespace and omits the stored formatting controls. All seven texts are checked against the original parser; phase/countdown decisions are checked separately against the original dispatcher.

← Back to the text adventureContinue to the first corridor →

03 · The Labyrinth

The first corridor

The first corridor stretches past a repeating brick wall. Its movement map divides the wall into 64 columns. Eight columns permit a deeper approach and allow the exit routine to choose an entry into the Brick Hallway. ($4171, $4115)

Where the openings lead

Choose a column, then change the exit variant. Each stored opening leads to the Brick Hallway. The variant changes the entry position within that room. ($4115)

Bold, underlined columns are openings; the other columns stop the approach. The single corridor strip wraps onto four rows for display. Each cell spans 64 world units.

Through the first opening

The first opening leads into the Brick Hallway. The exit selects entry position 35, which the room loader converts to world X=2272, with the player at depth 6. ($543A)

Compare departure and arrival
The first corridor before the checked walk
Departure: walk right to the first opening, then approach the wall.
The player in the Brick Hallway after taking the first corridor opening
Arrival: the naturally loaded Brick Hallway, after 60 frames without movement input.

The continuous-mode placement rule starts the player halfway through the selected column: entry × 64 + 32. The variant selector above includes this calculation.

The exit chooses an entry position

The exit uses a changing random state to select one of four route-table variants. Other activity advances that state, so the selector shows possible outcomes rather than predicting an outcome from walking time. Entry numbers identify positions inside the destination room. ($4115)

Evidence and limits

The natural corridor capture uses map mode $0343 = $FF and column mask $3F. Classifier $4171 reads the map at $0600, translates its cell through $073E, and obtains the depth limit from $41F0. Ordinary wall approach stopped at depth 24. An ordinary approach at world X=546 reached the first opening at depth 32 and called exit routine $4115. The dispatcher requested scene 3, entry position 35. The ordinary route loaded the Brick Hallway; player placement at $543A used entry 35 and mode zero to produce X=2272/depth 6. The entry request was then cleared.

The route thresholds begin at $074E; scene and entry banks begin at $077E and $078E. All eight openings select scene 3, the Brick Hallway, across all four banks. The page’s classifier and route lookup are compared with the original routines in the committed test. The other seven openings have code-checked destinations; their complete walking routes remain open.

← Back to the entrance gateContinue to the Brick Hallway →

04 · The Brick Hallway

The Brick Hallway

The Brick Hallway is a wall of doors. Its map holds fifteen door cells in a repeating 64-column strip, three open and twelve closed, and the player’s position decides which door a command reaches. The commands below start from two positions: the arrival and the neighboring door.

OPEN DOOR checks the map cell at the player’s position. At the arrival position the command replies “Nothing happens.” Walking right to the neighboring door and using the same command opens it. ($9053)

This example reproduces the command decision and map-cell change. Follow the route through this door.

The map cell changes when the door opens

The closed door’s cell has value 7. OPEN DOOR replaces that value with 6, which the room’s type table treats as an open door. Using OPEN DOOR again selects “It's already opened.” ($9053)

Sources and checks

The command pair at $8B94 selects handler $9053. Its query at $0998 returns the cell nibble and translated type. Type 2 uses replacement table $071E, then mutation routine $58C8 records the new cell and a zero scene request refreshes the view. The handler also requests sound 1 and increments $0569; the sound’s audible identity remains open.

Ordinary input reached world X=2348, depth 24. OPEN DOOR changed column 36 from 7 to 6, while current scene stayed 3. The handler and mutation routine each recorded one live hit. The page’s command decision is compared with the original handler, including the actual initial positions and the repeated-command branch. This checks opening the door, not the destination behind it.

Closing a door takes one off the count

CLOSE DOOR shuts the neighboring door and reduces the opened-door count from 4 to 3. Opening that door again restores 4. Repeating CLOSE DOOR on the closed door or OPEN DOOR on the open door leaves the count alone. ($8E9E, $9053)

See how the guards respond to the opened-door count →

Sources and checks

The CLOSE DOOR pair at $8B2E selects $8E9E. In negative map mode, the handler accepts translated type 3 and uses the closing replacement table at $072E. At this door, cell 6 becomes 7. The handler requests sound 2 and decrements $0569. A type 2 door instead selects “It's already closed.”

Ordinary input from the naturally opened column-36 state ran CLOSE, CLOSE, OPEN, OPEN at world X=2348, depth 24. The count went 4→3→3→4→4; the cell went 6→7→7→6→6. Each command had a positive handler hit. The mutation routine ran only for the first close and the reopening. The original handler is compared over every cell/map-mode byte, with full classifier/mutation checks for the displayed cycle.

The example models the commands and counter, with live captures for each result. Walking and the other actors are not simulated. Other door commands, complete room crossings, and disk persistence remain open.

The door leads elsewhere in the same hallway

Holding up through the opened door brings the player to another part of the Brick Hallway. The door at column 36 arrives at column 12. The room stays the same while the player’s entry position changes. ($4115, $543A)

This steps between two pictures of the route.

Route evidence and limits

The exit routine $4115 selects region 11 for column 36. Its selector uses bits $60 of state $0500 to choose a route bank. Every bank requests scene zero: banks 0/1 choose entry 12, and banks 2/3 choose entry 44. The meaning of that state byte remains open here.

With current scene 3, a zero request takes the retained-room branch at $50EA and placement at $543A. The live route selected entry 12, producing world X=800 and depth 6. After the view refresh, current scene remained 3 and the pending request was cleared. Entry 44 is code-checked; its ordinary journey remains unverified. Return travel and other door routes remain open.

The arrival panel fails the door check

At column 12, the spiral panel looks door-shaped. ASK DOOR replies “There's no door here.” OPEN DOOR replies “Nothing happens.” The command handlers use the map’s type for this position when deciding what they accept. ($8DD1, $09E9)

Choose a command to compare its recorded response.

The door prerequisite accepts map types 2 and 3. The arrival panel’s cell translates to type 11, so ASK DOOR stops at the prerequisite. OPEN DOOR has a separate type check and selects its fallback response at this position.

Sources and checks

The ASK DOOR pair at $8B0C selects $8DD1. Its prerequisite $09E9 calls the player-cell query, then accepts only types 2 and 3. On rejection it removes the caller’s return address and queues the message at $0D49, bypassing the rest of the handler. The arrival map cell at $060C is 1, translated to type 11.

Ordinary input at world X=800, depth 6 produced both displayed replies, with one dispatch for each command and one prerequisite hit for ASK DOOR. Up for 300 frames reached depth 24, with 30 movement hits and zero exit/loader hits. The original prerequisite and caller are checked for every type/mode byte, including both page commands at the observed position. These checks do not establish the behavior of other actions or a complete return route.

Trying the way back

The Brick Hallway arrival faces a wall cell. Holding up from that position approaches the brickwork; holding down moves into the foreground. Both movements stay in the Brick Hallway.4

Input from the arrivalFrames testedFinal depthRoom
None1206Brick Hallway
Up30024Brick Hallway
Down3000Brick Hallway
Compare the forward and backward approaches
The player close to the brick wall after holding up
Up: the player stops at depth 24, against the brickwork.
The player in the foreground after holding down
Down: the player reaches depth 0 and stays in the room.

Neither direction leads back to the first corridor, and no other return route has been found.

See the OPEN DOOR response
Checks behind these results

Each trial restored the same naturally reached arrival. The movement routine ran in all three movement trials; neither the generic exit routine nor the scene loader was called. The command trial recorded one command dispatch. These observations apply to this position and these inputs; other positions and actions remain untested.

← Back to the first corridorAlph and Ralph · separate room check →

05 · Alph and Ralph

Alph and Ralph

Alph and Ralph guard the two doors of their room, Alph the left one and Ralph the right. One doorway leads on and the other ends the game, and a random bit decides which. Alph comes out when called beside the left door. CALL ALPH produces “I'm here! You don't have to shout!” ASK ALPH then begins a conversation about the two doors. ($90C3, $8FA8)

This area starts inside the guard room, with the female avatar. The crossing from the Brick Hallway has not been walked.

The first three replies

Alph warns that one door leads to the center of the Labyrinth and the other to certain death. A second question gets a demand to open every door in the Brick Hallway. The third gets “We're not saying another word.” ($8FB1)

The opening exchange advances through three replies. Once the third reply is selected, the conversation index stays there. Later dialogue has a separate progress condition; the demonstration covers this opening exchange.

Sources and checks

The ASK ALPH pair at $8B0C selects $8FA8. After the presence check, the shared conversation at $8FB1 uses index $8F04 and split pointer tables $8FFE/$9001. With progress byte $0569 below 15 and nonnegative $8F0C, valid opening indices 0, 1, and 2 select these three replies. The routine keeps index 2 after the third question. Other seeded indices are outside this example.

From the controlled reference state, moving left reached world X=99, depth 6. CALL ALPH and three ASK ALPH commands recorded one call-handler hit and three ask-handler hits; the conversation index became 1, 2, and 2 while progress stayed 3. These pictures are live captures. The page’s three transitions are compared with the original caller across all progress values below 15, and the reply texts with the original parser. Ralph’s conversation, the later progress branch, and the outcomes behind the doors remain open.

Changing speakers keeps the conversation’s place

Ralph answers CALL RALPH beside the right door. Starting with Ralph gives the same three opening replies as starting with Alph. Asking both characters shares one conversation: after Alph gives the warning, Ralph’s next answer is the request to open every door in the Brick Hallway. ($8FAE, $90CC)

The example begins after Alph’s first answer. CALL RALPH brings Ralph out beside the other door. ASK RALPH then continues with the second answer.

Start the exchange with Ralph instead
Ralph appears beside the right door after being called
CALL RALPH: “I'm here! You don't have to shout!”
Ralph gives the warning about the two doors
The first ASK RALPH gives the same warning as Alph’s first answer.
Sources and checks

ASK RALPH at $8FAE calls its own presence check, then joins Alph’s conversation at $8FB1. Both use $8F04 as the opening reply index. CALL RALPH at $90CC preserves the index.

The fresh Ralph trial reached world X=220, depth 6 and recorded one call-handler hit and three ask-handler hits. The separate speaker-switch trial began after Alph’s first answer, moved to X=225, depth 6, and recorded one CALL RALPH and one ASK RALPH hit. The shared index stayed 1 through the call, then became 2 on the question. These were ordinary inputs inside the controlled reference room; entry from the Brick Hallway remains unverified.

The comparison runs both original ASK handlers with their real presence-check branches, intercepting the distance query with an accepted door-side state. It also checks CALL RALPH for all 256 query-result bytes at each valid opening index. These checks cover reply selection and shared state, rather than the distance producer or the later puzzle.

The next reply waits for a door count of 15

The guards’ request leads back to the Brick Hallway. Its map has fifteen door cells: three open and twelve closed. The opened-door counter starts at three. Opening a closed door adds one; closing it removes one. Repeating a command on a door already in that state leaves the count alone. ($8FBD)

At count 14, Alph keeps refusing. At count 15, the next question gets “Thanks for opening those doors! It gets kind of stuffy in here!”

Choose a count, then ask Alph.

Each command starts from the same refusal, with only the door counter changed to 14 or 15.

Trying OPEN DOOR twice

The checked Brick Hallway door raised the count from 3 to 4 when it opened. Repeating OPEN DOOR at that door replied “It's already opened.” and kept the count at 4. Read how the map cell changes.

Sources and checks

The new-game initialization at $575A sets the counter to 3. The Brick Hallway map and its type table contain three open-door cells and twelve closed-door cells in the repeating 64-column strip. Its OPEN DOOR handler increments the counter on the closed-door path. The repeat-command trial recorded one handler hit and zero mutation hits.

In this room, $8FBD compares $0569 with 15. At or above 15, a negative acknowledgement byte $056B causes the guard to store the count and queue the thanks at $9C28. These comparisons restore acknowledgement $FF, reply index 2, phase 1, and nonnegative $8F0C before each command. Count 14 retained acknowledgement $FF; count 15 stored 15, with one acknowledgement-write hit. Both trials recorded an ASK ALPH hit.

The page’s reply selection, conversation index, and acknowledgement are compared with both original ASK handlers for every byte value of the count and valid opening indices 0–2. The real presence checks run with an accepted distance query supplied. Text is expanded with the original parser. Later dialogue after acknowledgement remains outside this example.

After the thanks, Alph leaves the choice to you

After the thanks, the next question gets “Figure it out for yourself.” Asking again gets the same reply. ($9004, $9ABD)

This continues the count-15 conversation above.

Sources and checks

After the thanks, the acknowledgement is 15, the conversation index is 2, and phase $056A is 1. The next ASK reaches $9004. This branch preserves index 2 and selects “Figure it out for yourself.” because the local flag $8F13 is $FF. Three ordinary follow-up commands reached this branch, keeping the count, acknowledgement, phase, and index unchanged.

The branch has other responses: an index of 0 selects the warning about the two doors and advances to 1. Otherwise a zero local flag selects “Sorry, we're not sure which is which. Open the door and find out for yourself.” Opening the left door changes that flag and selects this reply. The example above keeps the original closed-door state, with index 2 and flag $FF.

The reply decision is compared with the original phase-one branch for all 256 index values and all 256 flag values. Both ASK handlers are also checked through their accepted presence branches for indices 0–2 and every flag value. The two new texts are expanded with the original parser. The controlled doorway routes and later conversation checks follow below. Ordinary phase progression remains open.

Opening the door changes Alph’s answer

After the thanks, opening the left door gets a different answer from Alph: “Sorry, we're not sure which is which. Open the door and find out for yourself.” Close the door and ask again, and “Figure it out for yourself” returns. ($92B3, $9273, $9004)

The sequence starts after walking closer to the left door, continuing from the count-15 thanks.

Sources and checks

The approach reached X=99, depth 24. OPEN DOOR at $92B3 changed the left map cell from 1 to 2 and local byte $8F13 from $FF to 0. ASK ALPH then selected the unsure reply. CLOSE DOOR at $9273 restored cell 1 and byte $FF; the next question selected “Figure it out for yourself.” Each door handler ran once, each question ran once, and the map mutation ran twice.

The Brick Hallway counter stayed 15, its acknowledgement stayed 15, and the conversation stayed at phase 1 and index 2. The local door byte controls these two replies independently of that Brick Hallway count. Opening from depth 6 instead replied “You're not close enough.” The checked left-door entry continues to The Wall of Hands. The other door’s outcome, later phases, and a complete ordinary journey into this room remain open.

The page’s left-door change is compared with the original OPEN/CLOSE handlers for every byte value of the local flag, both captured cell states, and all depth values. These checks run the real map query, proximity test, and mutation routines, intercepting sound and message output. The four-step conversation is compared separately through the real ASK presence paths, using an accepted distance result. The earlier conversation check expands the two texts with the original parser.

Through the left door to The Wall of Hands

Walking through the opened left door gets “How did she figure it out?” The sequence then advances the guard puzzle to its next phase and loads The Wall of Hands. ($8DDF, $8E9E)

This route continues from the count-15 setup above, with the door selector at 1. The example steps through its recorded stages.

Sources and checks

The route began at X=99, depth 24 with the left door open. Up input reached depth 45 at X=96. The guard displayed the entry reaction, completed the successful countdown branch, and advanced $056A from 1 to 2 at $8E9E. A separate continuation recorded one phase-advance hit and one loader hit. The generic exit handler did not run during the initial approach.

The loader selected scene 5 and entry 1, displayed “The Wall of Hands,” and returned with the player at X=84, depth 6. After 60 more frames, the scene remained 5 and the arrival capture showed the hands. The code and interactions inside that room remain unanalysed.

At $8DDF, column 1 with a nonzero door-selection byte takes the continuation used here. The decision is checked for every byte value of column and selector; other values are code comparisons, rather than live route claims. Phase advancement is checked for every phase byte. A nine-call successful countdown check retains the original sound choices and delay call, while intercepting their effects. The reaction text is expanded with the original parser. The complete ordinary journey to the guards, the alternate entry outcome, and later puzzle phases remain open.

06 · The other doorway

Through the other door

When the selector is 1, the right doorway takes the losing path. OPEN DOOR changes its map cell to 3. Walking through it produces “You are falling down an endless tunnel,” then “Ok, we lied. It wasn't endless,” followed by the loss panel. ($8EAE, $8EC1, $9F44)

Step through the recorded route. The selector is 1 throughout.

Sources and checks

The entry-choice routine selects the alternate branch for captured column 3 and selector 1. That branch sets outcome 1 and starts the nine-count sequence. At its end, the game queues the two messages and the loss description. The recording stops at the game’s own instruction boundaries for the completed messages, then allows the loss panel to finish drawing. Original-code checks cover all entry-choice bytes, the alternate countdown, its requests and all three text expansions. The original emulator state was restored. The selector initializer is checked below; other full traversals and restarting after the loss remain open.

07 · Choosing the door branches

A random bit chooses the doorway

Room setup advances the random state and stores one bit from the result. A stored 1 selects the continuation branch for the left doorway and the losing branch for the right; 0 reverses those code choices. The recorded doorway routes above both use 1. ($8F15, $8F06, $8DDF)

The setup guard lets this happen when its byte is negative, then changes that byte to zero. Calling setup again with a nonnegative guard returns immediately. In the captured entry, the chosen bits stayed unchanged over 240 idle frames while the random state advanced.

The setup draws two random bits. The first chooses the doorway; the second also chooses a later answer.

Sources and checks

The first call stores bit 0 of its returned high byte at $8F06; the second stores another bit at $8F07. Each call advances the 16-bit random state as (37 × state + 17) modulo 65536. The page function is compared against the original setup prefix and random generator for all 65,536 states. Every byte value of the setup guard is checked for its early-return or initialization path. The live entry has guard $FF, state 63287 and chosen bits 1/1; controlled states 0 and 7 give 0/0 and 1/1. The saved entry is a controlled room load; ordinary return-visit behavior remains unverified.

08 · Later conversation

The second bit changes an answer

The later conversation introduces the guards’ claim that one always lies and the other tells the truth. Its fourth answer points to either the castle or certain death. The choice compares the two stored random bits: equal gives the castle answer; different gives the death answer. ($9087, $90A6, $90B9)

Alph says this door leads to certain death
Phase 4, doorway selector 1, second bit 0.

Both pictures show ASK ALPH in the same room, at phase 4 with the conversation index at 3. Only the second bit differs.

Sources and checks

With valid shared indices 0–3, this branch gives three fixed replies, then repeats the fourth answer. At that fourth answer it also marks which guard was asked. The reply comparison itself uses the two random bits, without reading that speaker selector. The original code is compared with the page function for both speakers, both values of each bit and all four valid indices. The original parser expands all five reply records. In VICE each controlled ASK ALPH hit the branch and comparison once, kept index 3, and set Alph’s flag to 1. The second bit also selects the congratulations reply. The departure reaction is checked below for these controlled phase-4 states.

09 · Congratulating the guards

Congratulate after asking

In the later conversation, asking a guard about the door prepares a new reply to CONGRATULATE. Alph then says either “Thanks, I think I lie pretty well!” or “Yes, telling the truth's a virtue.” Congratulate him before that question, and he protests that he hasn't done anything yet. ($90E5, $910D, $911A)

The second random bit chooses the lying or truth-telling wording by comparison with the selected guard. The accepted congratulations also remembers which guard was selected. An insult takes priority: the next congratulations gets “You sure are fickle!” and clears the insult flag. ($90EE, $9148)

Alph protests that he hasn't done anything yet

These recordings use the same room at phase 4 and conversation index 3; the lying comparison also sets the second bit to 0. The doorway reaction below uses the remembered guard from these recordings.

Sources and checks

The fourth later ASK sets a separate flag for the guard addressed. In phase 4, CONGRATULATE checks that guard’s flag before comparing the second bit with the speaker selector. Alph uses selector 0 and Ralph uses 1. Equal selects the lying reply; different selects the truth reply. Other phases use “Don't mention it,” unless a negative insult flag takes priority. The code comparison retains both guards’ presence checks with their distance input intercepted. It checks phase, flag, asked-byte and second-byte boundaries, the remembered selection, all five congratulations texts, and the insult reply. The live recordings check Alph; Ralph’s congratulations remain code-checked.

10 · The reaction at the doorway

The other guard gives the game away

In phase 4, congratulating Alph changes Ralph’s reaction at the left doorway. Ralph identifies Alph as either the guard who always lies or the one who tells the truth. Without a congratulated guard selected, the reaction is “How did she figure it out?” ($8DF8, $8E25, $8E43)

The generic doorway reaction

The remembered guard selects both the wording and who says it. The code flips the remembered guard’s selector to choose the other speaker. In phase 4, matching the remembered guard with the second random bit selects the lying accusation; a different value selects the truth accusation. ($8F0A, $9DC9, $9E10)

These phase-4 recordings continue the conversations above. The reaction and countdown depths are 40 and 44 because the phase changed after room setup; setup begun in phase 2 or later writes 54 and 64. The recordings stop before the phase advances. The next section continues through the load.

Sources and checks

All three trials approached X99/depth24 and opened the left map cell from 1 to 4. The reaction queued at X96/depth42. The selected-Alph trials changed the speaker selector from 0 to 1, while the unselected trial kept 0. All reached depth45, completed the existing successful countdown, and stopped at $8E9E before advancing the phase. The screenshots show completed messages. The reaction gate clears after queuing; the countdown has its own depth test. Original-code comparisons check those separate gates, both valid remembered guards and byte boundaries. All three texts are expanded by the original parser. The setup threshold prefix is checked for every phase byte. The ordinary arrival in the guard room at phase 4, Ralph-selected live departure and phases2/3 reaction dispatch remain open.

11 · The next room

Back at the Wall of Hands

From phase 4, the left door loads the Wall of Hands whichever reaction appeared. The player arrives at the same position after the generic reaction, the lying accusation, and the truth accusation. The guard phase stays at 4: its increment is capped there. ($8E9E, $59AF) Wall of Hands capture

Saved conversationChecked load
No guard congratulatedScene 5, entry 1
Alph congratulated · lying replyScene 5, entry 1
Alph congratulated · truth replyScene 5, entry 1

The guard reaction is complete. The queued scene request is 5.

The truth accusation before the next load
The truth-reply recording, stopped before phase advancement.

The guard sequence leaves a request for scene 5. The resident load service transfers that request and supplies entry 1 when the entry byte is unset. In these trials, the service reaches the same request regardless of which of the three reactions appeared. ($8E9B, $59D1)

This continues the three phase-4 recordings above, with their earlier depth thresholds and doorway selector 1. The example switches between the recorded images.

Sources and checks

Each trial resumed at $8E9E. The original phase increment attempts 5 and caps the phase at 4. At loader entry $5098, all three had pending scene 5, entry 1, queued request $FF, and current scene 4. At return $59DC, scene 5 was installed and the entry field had returned to $FF. After 60 further frames, all were at X84/depth6 in scene 5, with phase 4 retained. The image shown is the truth-reply trial. The address range $59AF–$59DB matches the opening’s retained resident code byte for byte. Its bounded comparison checks queued/pending bytes and entry defaults with wheel-closing and loading intercepted. Real completed loads supply the arrival evidence. Guard-overlay addresses are not interpreted as guard state after scene 5 replaces that overlay.

← Back to the Brick HallwayContinue to the Wall of Hands →

06 · The Wall of Hands

The Wall of Hands

A wall of hands talks to you, and a manicure is how you get out. The sequence runs for nine manicures: the eighth costs an hour, and the ninth lets you down into the Stone Corridor. The conversation comes first.

The hands open the conversation themselves: “Do you realize how many people have fallen to their doom because of us?” ASK WALL continues with “Millions!” Four further questions bring the conversation back to its opening line. ($8DE4, $903D) Room capture

The hands ask how many people have fallen to their doom

The automatic question and typed questions use the same reply index. The fifth reply resets the next index to the beginning, while still displaying its own text. A separate gate can reject the command with “Nothing happens” and preserve the index. Its connection to movement and hand animation remains untraced. ($8EA5, $9284)

The room opens with an automatic question, and five ASK commands follow. The example replays the recorded replies. The first MANICURE WALL response and the departure are explained below.

Sources and checks

The callback’s bounded branch increments its negative automatic flag, then calls the same ASK handler. In the saved state $FF becomes 0, so that branch supplies the opening question once. Other negative bytes can remain negative after increment; they are byte-domain checks, not reached room states. Valid reply indices 0–4 use the old index to select text, then advance 0→1→2→3→4→0. Original-code comparisons retain the command gate and its stack-discard rejection path. All five replies and the rejection text are expanded by the original parser. The values 24/4/10/14/12 stored alongside the replies have no assigned wall-clock meaning here. This part has its own snapshot, symbols and listing; shared resident ownership and its remaining loaded data are unresolved.

07 · The first manicure

The hands want shears

MANICURE WALL checks whether the player has shears. Without them, the reply is “That would have been nice, but you have no tools!” Usable shears get “A manicure? How nice of you!” A damage flag can instead stop the command with “Your shears were damaged.” ($90E2, $90C3)

The hands reply that the player has no tools

The first accepted command advances the manicure counter from 0 to 1. Both refusals leave it at 0. The item-present trials keep the shears’ stored count unchanged. A separate command gate runs before either inventory check, and can reject the command with “Nothing happens.” ($90FA, $8EA6, $9284)

Continue through the first seven accepted commands.

Sources and checks

The command queries inventory slot 21 through $0830. The real reader returns the byte at $673E; negative means absent, while 0 represents one owned unit. In the captured inventory wheel, that slot maps to dictionary entry 72, shears. A negative damage flag at $056C discards the caller continuation before the counter increment. The accepted first branch requests sound 11 and writes 9/4/16 to its animation fields. Those values have no assigned duration here. The original-code comparison retains both inventory and command checks, intercepting sound/output and supplying controlled random values. It checks the first counter state, three text records, the generic rejection, and the varied output-mode helper. The eighth command is checked below. Later stages, the damage producer, and complete animation effects remain open.

08 · Repeated manicures

The hands ask for polish and lotion

Keep using MANICURE WALL with usable shears and the hands continue talking. The hands ask for polish and hand lotion, thank the player, then ask about the green liquid they are soaking in. Each accepted command advances the same counter. ($910B, $8EA6)

The hands accept the first manicure

The seven accepted commands keep the shears’ stored count unchanged. The missing-tools and damage checks still run before the counter advances, so either refusal preserves the current stage. ($90E2, $90C3)

These pictures follow seven commands in one room session, starting with one shears unit in the inventory. The sequence ends at count 7. The eighth command costs an hour. The ninth leaves for the Stone Corridor.

Sources and checks

The reply selection compares the incremented counter with 2, 3, 4, 5, and 6; each match selects its own text. A count of at least 7 selects the green-liquid text before further checks. The seven checked successful calls queue their replies through the same varied output-mode helper and write the same animation values 9/4/16. Each live command released Return on the handler’s first stop, and the captured inventory byte remained 0. The comparison executes the original command gate, inventory reader, damage test, counter increment, and reply selector for initial counts 0–6, with sound/output intercepted. The eighth command is checked in the next section. Later stages and animation timing are outside this replay.

09 · One hour later

The eighth manicure costs an hour

The eighth accepted MANICURE WALL interrupts the conversation with “One hour later…” The clock loses one hour, then the Wall of Hands returns. The manicure counter reaches 8 and the shears remain in inventory. ($913B, $0C61)

One hour later event panel

The captured clock changes from 12 hours, 51 minutes to 11 hours, 51 minutes at the decrement. The hour is removed directly; the minutes stay unchanged by that operation. With zero hours remaining, the same decrement triggers the time-expired ending. ($0C61)

The first trial continues the seven-command session. A second starts with the hour byte at zero before the penalty and reaches the time-expired ending. The ninth command leads out to the Stone Corridor.

Sources and checks

The exact count-8 branch jumps through $084E to the resident penalty helper. That helper presents event 57, then decrements $0376, the hour field. A negative result clears $0580; other results preserve that state. Event 57 selects $730A, the “One hour later…” record, through its split pointers. Original-code checks retain the real command prerequisites and hour arithmetic, intercept the event presenter, and compare all hour/outcome byte combinations separately. The original selector and text parser check the panel’s record. Arbitrary byte inputs are arithmetic checks, not reached clock states. The normal and zero-hour panels were both checked live; complete event presentation and later room behavior are outside the JavaScript comparison.

10 · Leaving the hands

The ninth manicure leads to the Stone Corridor

After the hour penalty, another MANICURE WALL brings back “A manicure? How nice of you!” The counter advances to 9 and the player descends from the hands. The game then loads the Stone Corridor. ($9142, $8CD8) Stone Corridor arrival

The hands repeat their first manicure reply

The ninth command sets movement state 12. Its downward movement reaches an exit threshold, then selects the first exit slot. In this captured room state that slot requests scene 6, entry 7. The actual arrival places the player at X480, depth6 in the Stone Corridor. ($8D81, $077E, $078E)

The ninth command descends out of the room and loads the Stone Corridor, with the shears still in the inventory. Continue to the Stone Corridor’s first door.

Sources and checks

The accepted ninth command queues the first reply again and writes 12 to $0356 and $8EA3, preserving $8EAA. The bounded movement prefix adds 4 modulo 256 to the vertical drawing byte, and calls exit slot 0 when the result reaches at least 128. The live threshold stop records 130, then selector 0 and request 6/7 before the load. The loader returns in scene 6 at X480/depth6, followed by the visible arrival capture. Original-code checks cover the ninth command, the later-count comparison, the bounded movement prefix, and exit selection. Pose advancement and elapsed animation time are outside the model. Higher counter values in tests are seeded branch inputs; an attempted ordinary tenth command did not dispatch because this trajectory left the room. The counter’s wrap and alternate entry remain open.

← Back to Alph and RalphWall of Hands capture →

07 · The Stone Corridor

The Stone Corridor

The ninth manicure drops the player into the Stone Corridor. Along it stand a first door, an archway, a second door guarded by a companion, and a ladder, and this area follows them in that order.

OPEN DOOR gives “Nothing happens” at the arrival position. After the player approaches the door, the same command opens it. Repeating the command gives “It’s already opened.” The command checks the cell at the player’s column. ($8F30, $0998) Stone Corridor capture

Nothing happens at the Stone Corridor arrival

The arrival is at X480, column7, where the stored cell has value0. The ordinary approach stops at X147, column2, where the cell has value1. OPEN replaces that cell with7 and refreshes the room. Its new type produces the already-opened reply on the next command. ($071E, $073E, $8F7B)

CLOSE DOOR reverses the change: cell7 becomes1, and the door shuts. Another CLOSE gives “It’s already closed.” ($8E91, $072E)

Walking through the open doorway brings the player to another position in the Stone Corridor, beside an arch and bars. This crossing selects entry30 and refreshes scene6. The arrival is at X1952, depth6. ($4115, $07EF)

These pictures compare the arrival with an approach from the same position, then opening the door and repeating OPEN. The last comparison walks through the opened door. The guarded door’s blocked reply is explained below.

Sources and checks

This part has its own play snapshot, symbols, and listing. The cell query executes the real world-column classifier; the opening comparison also executes the real mutation wrapper and its record-update path. The page model fixes the captured negative room mode and scene6. Tests seed empty record arrays and intercept sound/output; arbitrary map bytes and coordinates are arithmetic checks, not reached states. The separate column24 branch and its companion-position check are verified in the guarded-door section below. The first-initialization hand-over remains open: the matching comparison snapshot is the later loader return. Resource matches and seven retained uncounted stretches are listed in the technical reference.

08 · Through the archway

The arch leads to a ladder

Continuing through the arch brings the player to another stretch of the Stone Corridor, with a ladder visible on the left. The route stays in the same scene. ($4115, $07FD) Stone Corridor capture

The player stands beside the Stone Corridor archway

The doorway and arch select different entries into the corridor. Each entry places the player at the middle of its column: X = 64 × entry + 32. The first crossing uses entry 30; the arch uses entry 26. ($543A, $5496)

The first door’s cell stays open through both crossings. The ladder route is explained below.

Sources and checks

Ordinary up input reaches depth 70 at column 30, then requests refresh 0/entry 26 using exit slot 15 and stored selector 96. The arrival is X1696/depth6 in scene 6. A separate 300-frame no-input control stays at the arch. The page reuses the nonnegative placement calculation already checked for the first corridor; the original bytes match. Tests execute the real exit and placement prefix, retaining the map and current scene. The negative-mode placement branch, movement threshold, and other route selectors remain outside this model.

09 · Beside the ladder

A companion blocks the guarded door

Another door stands beside the ladder. On the checked approach, the companion is in its doorway. OPEN DOOR replies “He's in the way!” and the door stays closed. ($8F5A, $8F6F)

The Stone Corridor says He's in the way when OPEN DOOR is used beside the occupied doorway
The saved route reaches the second door after the first doorway and arch. The companion is visible inside it.

How to move the companion, and what follows once the door is clear, are not yet known.

Sources and checks

The player is at X1563, depth6, column24, where map cell $0618 is1. The first companion is at X1568 and depth24. The code blocks OPEN when the companion's two X bytes equal $0620 and its depth is at least22, selecting reply $987D. VICE showed “He's in the way!” with scene6 and the cell unchanged. The original code comparison checks the position boundary and expands the same reply. If the condition fails, code sets scene4 before the common door mutation; its reached outcome has not been checked.

10 · The ladder

The ladder returns to the hands

Hold up near the centre of the ladder to start climbing. Once the climb begins, the player continues without held movement input. The ladder leads back to the Wall of Hands, whose opening question appears again. ($3796, $3DF1, $078B) Wall of Hands capture

The player stands off centre at the foot of the ladder

The alignment check accepts eight positions within the ladder’s 64-position column. An off-centre approach can reach the wall without starting the climb.

The accepted approach starts at X1633. The completed load reaches the Wall of Hands at X84, depth 6.

Sources and checks

The local ladder cell is type4. In negative room mode, offsets28–35 within its column clear the ladder state. The state dispatcher then calls the climb routine. Its completion selects exit slot13, bank0, requesting scene5/entry1. Ordinary input and the actual loader confirm that destination. The page compares the alignment gate with the original code; tests also execute the real dispatcher, climb and exit. Off-centre trials at X1641 and X1637 stay at depth24 after600 up frames. The captured no-input continuation after the accepted gate reaches completion. Routine calls have no assigned frame duration, and the surrounding movement prerequisites remain outside the slider model.

The Hedge Maze: the goblin

Read from code

The goblin has one of four kinds

The goblin’s kind is a number from 0 to 3, chosen at random ($9A0E, $99FA). The kind decides how it answers. HIT goblin brings a cry for its mother (“MOMMY! MOMMY! ! ! ! !”) from kinds 1 to 3. INSULT goblin gets “That won’t work with me!” from kind 0, “Why you . . .” from kind 1, “I will get you for that!” from kind 2, and “HUH?” from kind 3. ($8F1B, $8FBB)

Gifts work on one kind each. A rock pleases kind 3 (“Oh!, a rock!”) and a bag of popcorn pleases kind 2 (“Why, thank you!”). Every other kind answers “Hah!” and still takes the item. CONGRATULATE goblin gets “Nothing happens.” from kinds 0 and 1, “Hmph.” from kind 2, and “Gee, that’s nice.” from kind 3. ($8D46, $8D85, $8ECF)

The shears work on doors and walls, and break on rocks

OPEN door and CLOSE door swap the hedge door’s map cell for the open or closed form, and a second try gets “It’s already opened.” or “It’s already closed.” ($8F7B, $8F9A) MANICURE door, MANICURE wall, and USE shears start a seven-step trimming animation. At the end, a door opens only if the player stands close enough (“Try moving closer.” otherwise), a wall earns “Want a job as a gardener?”, and rocks damage the shears for good. Without shears the reply is “You have nothing to manicure with.” ($9077, $90A4)

Four spoken words are trades

SPEAK avocado, jaggies, owl, or plastics gets “I won’t help you!”, “Save it for when you REALLY need it.”, or, when a counter allows it, “So be it, you are freed in exchange for 1 hour of time.” After that last reply the game waits and plays a sound. What the two flags behind these replies count is not identified. In an emulator test with the goblin forced into reach, “avocado” gave “Save it for when you REALLY need it.”, while “owl”, “jaggies”, and “plastics” gave only “Nothing happens.” Why those three differ is not known. ($9CDA, $9D0A)

Sources and checks

Command table $8B00, handlers $8BC0; goblin routines $8F1B, $8FBB, $9A0E; shears $9077; texts $91C9 to $99D8. Exits are read from the tables at $077E to $07FD. On 25 October 2026 the goblin replies to HIT, INSULT, and CONGRATULATE were checked in the emulator for all four kinds, with the goblin made present by setting $0252, $02F5, and $0544 by hand; every reply matched the text above. Gifts, shears, and door cells were not reached.

The Persecution of Ludo

Read from code

Ludo is freed with the shears, but only after the goblins are gone

MANICURE Ludo starts the shears routine. If either goblin is still active the game answers “Maybe you’d have time if you got rid of the goblins first!” Once both are gone it shows “Congratulations! You have set Ludo free! Sir Didymus will be pleased.” and loads the next scene. If the player is not in one of those four cells the reply is “Ludo is too far away.” ($8F68, $8F86, $8F95)

Ludo answers every other command with a growl: ASK, CALL, CONGRATULATE, and INSULT bring “Ludo down!!!”, and HIT brings “No scratch Ludo! Ludo down!!” when the player stands in one of the four cells beside him (anywhere else HIT gets “Nothing happens.”). GIVE to Ludo, when he is near, gets “Ludo don’t want. Ludo down!!!” ($8FC3, $8FD4, $8FEE)

Two goblins react to the same commands

HIT goblin and INSULT goblin each start a short reaction for the nearest goblin, cost an opening bonus point, and bring “MOMMY! MOMMY!” or “HUH?”. CONGRATULATE goblin gets “Gee, that’s nice.” and CALL goblin “I’ll get you yet!” A goblin has to be within range for these commands, or the reply is “There is no one here.” How a goblin is removed is not shown by the command handlers alone. ($8E64, $8E87, $8E44, $8D75, $90D3)

Sources and checks

Handlers $8CFD to $913F; Ludo routines $8F68 to $8FEE; goblin slots $994D to $9A80; texts $9157 onward. The scene request at $8F95 is scene $0A (10) with entry 1. Emulator check (25 October 2026, scene loaded by force with the goblin and shears state poked): ASK, CALL, CONGRATULATE, and INSULT Ludo gave “Ludo down!!!”; HIT Ludo gave “No scratch Ludo! Ludo down!!” in the cell $27; MANICURE Ludo gave “Ludo is too far away.” from far off and “Maybe you’d have time if you got rid of the goblins first!” beside him with goblins active, and with both gone it requested scene 10 (the Hedge Maze title card). GIVE to Ludo was not reached.

The Wise Man’s Garden

Read from code

The hat wants a donation before the Wise Man talks

ASK Wise Man starts a donation. The hat says “Please place your donation in the box.” and the Wise Man answers a second ask with “You again, cheepskate? No wisdom until you pay up.” until the debt is paid. Insulting or hitting the hat adds one more to the debt (“Just for that you pay double!”). When the debt is paid, one of four thanks is picked at random: “Thank you, now step aside.”, “Now move along.”, “Run along now.”, or “All right, now scoot!” ($8FC1, $90AD, $9060)

Each hint matches a walking test on the nine cells

The first ASK Wise Man picks one of eight hints at random and runs the test that goes with it every frame while the player walks the cells. The hints are “The way out is all that is left.”, “The right door’s the only one on the left that’s left when the left door and the on…”, “The only way out is to be right in every way you can.”, “Even the right door is only correct one time in three.”, “If at first you don’t succeed, try, try again.”, “Thoroughness is a virtue, but order is paramount.”, “The hands of the clock trace the path to the ninth hour.”, and “If you go to the left first, then you will know the bloomin’ way out.” ($8FC1, $90DE)

The tests are of four kinds. Two of three cells in the first row, or in the last row, opens the exit at the cell not yet stepped on. Stepping on the same cell twice opens its exit, in either the last row or any row. Walking eight steps around the ring of cells in one direction, or going up the ring one cell at a time, opens the exit beside the last cell. A single step on cell 0 opens cell 4. A broken walk clears every counter and starts again. ($9112, $9136, $9159, $917D, $919D, $9210, $9223, $9253)

The hat and the Wise Man talk back

Both need you close: otherwise the reply is “Come over here. We’re not about to come to you!” ASK hat gets “Don’t ask me, I’m only a hat!”, CALL hat “I may be a hat, but I can hear!”, and CALL Wise Man “He may be old, but he’s not deaf!” MANICURE the hat or the Wise Man gets “Stay away from me with that thing!” Between the sequence steps the hat’s idle remarks (“Did you hear that?” to “Who wrote his lines?”) come from a table of eight. ($8FA1, $9099, $90A3, $90D1, $92CD)

Sources and checks

Sequence dispatcher $90DE with its eight steps; exit opener $922E; hint tables $929D to $92C9; texts $9945 to $9E33. The exit scene byte at $8D39 is set by setup to $0A, $0F, or $10. Emulator check (25 October 2026, scene loaded by force, player walked beside the Wise Man): far away every command gave “Come over here. We’re not about to come to you!”; close up the first ASK Wise Man gave the hint “Thoroughness is a virtue, but order is paramount.”, the second “You again, cheepskate? No wisdom until you pay up.”, ASK hat then showed “Please place your donation in the box.” after a short delay, CALL hat and CALL Wise Man gave their lines, and INSULT hat gave “Just for that you pay double!”. Paying, the thanks lines, and the exits were not reached.

The Hedge Maze: Ludo and the rocks

Read from code

Ludo comes when called, and perfume keeps him away

CALL Ludo replies “He’s coming.” and starts him moving toward the player. If he is already near, the reply is “He’s already here.” Perfume changes this: with perfume on, CALL Ludo is answered with “Smell bad!” or “He won’t come. Your odor is overpowering.”, and a short delay after the perfume is used the screen says “Smell bad!” on its own. ($918B, $91EB, $8F48)

HIT Ludo is scratching him. The four hit replies are “Ludo like!”, “Please scratch higher.”, “Please scratch lower.”, and “No more scratch Ludo.”, picked by a hit count that stops at 3. The other commands get “Ludo friend!” for ASK, “Ludo don’t understand.” for INSULT, and “Ludo don’t want.” for MANICURE. ($91FB, $91DF, $9232, $923E)

Calling the rocks makes Ludo shout, and the rocks roll

CALL rocks starts a 20-step countdown. At the end Ludo’s shouting rolls a pile of rocks in from one side, with the text “Ludo is making a tremendous racket. It’s enough noise to cause the rocks to roll!” A second CALL while a pile lies on the ground says “The last rocks Ludo called are still here.” If the carried rocks have reached eight, the reply is “You can’t carry any more rocks.” ($8F55, $8F6E, $8F79, $8DF7)

TAKE picks up the pile (“You take the pile of rocks.”), adding three rocks to the inventory. If six or more are already carried, the reply is “You take as many rocks as you can hold.” If the player stands too far, “They’re too far away.” ($9058, $907C) USE camcorder while a pile is in view records it (“You video tape a bunch of rocks. Nice.”) and sets a flag; that rock video is what Firey asks for in the forest. ($90AD)

Sources and checks

Rock routines $8F55 to $8F96 and $8D8E to $8E56; Ludo routines $918B to $9232; TAKE $9058; texts $94D1 onward. Emulator check (25 October 2026, scene loaded by force, byte $0565 set to $FF to stand for a freed Ludo): with Ludo away every Ludo command answered “Ludo is hanging around somewhere else.”, and CALL rocks gave the gag “Here, rocks! Here, rocks! They don’t seem to answer.” (then “What would you like to call them?” on a repeat). With Ludo called in, CALL Ludo gave “He’s coming.”, ASK “Ludo friend!”, INSULT “Ludo don’t understand.”, MANICURE “Ludo don’t want.”, and HIT the “Please scratch higher.”, “Please scratch lower.”, “No more scratch Ludo.” series. CALL rocks with Ludo beside the player showed “Ludo is making a tremendous racket…” within a few seconds, and a repeat gave “The last rocks Ludo called are still here.” Not reached: TAKE, the rocks themselves, perfume, USE camcorder.

The Door Knockers

Read from code

The knockers speak only when the door is closed

The room has two doors, each with a knocker, and the code tracks the player’s horizontal position as a value from 0 to 3, and positions 1 and 3 are the two knockers. Standing at position 2, between them, gets “Who are you talking to? Please step closer.” A knocker needs you close, or the reply is “You’re too far from it.” ASK and INSULT work only from position 3: from position 0 or 1 the knocker answers at random with “What?”, “I can’t hear you.”, “Again please?”, or “Speak up.” With the door open, the hint is “Close the door so the knocker can talk.” ($91E1, $921A)

ASK knocker starts a spoken hint, beginning “Remember, if you get trapped,”, and the knocker finishes with one of eight, such as “Two bits will buy you almost anything.”, “A door isn’t always a door.”, “Cross any color but red!”, or “Food can be helpful when you are stuck.” ($910E, $8D7B)

Insulting a knocker starts a knock-knock joke

INSULT knocker picks one of eight jokes at random. The jokes run “Knock knock.” / “Who’s there?” and then name the speaker: Lil’ Abby, Hoggle, Sir Didymus, Ludo, Goblin, A maze, Romeo, or Jareth. Jareth’s punch line is the angry “What do you mean, ‘Jareth who’! It’s MY Labyrinth!” ($9000, $9014)

Four items fit the knockers’ mouths and locks

INSERT key works at position 1: it uses up the key and changes the door’s map cell by adding two. INSERT ring and INSERT bracelet need the knocker at position 3: a closed mouth gives “His mouth is closed.” and a full one “Its mouth has something in it.” Otherwise the item is taken and the cell is restored by subtracting two. A ring in place of a bracelet says “So it wasn’t a bracelet after all!” INSERT popcorn and GIVE popcorn put popcorn in an empty mouth; with an empty box the reply is “All you have is an empty box.” If the ring is gone, OPEN door says “You can’t open the door, the knocker ring is gone.” ($917B, $9127, $91A9, $8EBA)

Sources and checks

Knocker routines $8FF1 to $91A9; side check $91E1; joke table $9014; texts $9889 to $9D5A. The joke index is the byte at $8D79. Emulator check (25 October 2026, scene loaded by force, walking with the joystick): at position 2 ASK and INSULT gave “Who are you talking to? Please step closer.”; at position 1 ASK and INSULT gave “Again please?” and “Speak up.”; at position 3 ASK gave “Remember, if you get trapped,” and OPEN door gave “You can’t open the door, the knocker ring is gone.” Not reached: the jokes, INSERT, GIVE popcorn, the shears.

The Forest: Firey and the thrown head

Read from code

Firey wants a rock video

ASK Firey and GIVE (any object) get “We want a ROCK VIDEO!” until the player has given him a camcorder that holds a rock video. GIVE camcorder with an empty tape gets “I don’t want this boring stuff, get me a rock video.” With the rock video, Firey says “Oh thanks! Let me give you a piece of my mind.” and the camcorder is taken. ($8D39, $8D62, $8CFF)

After that ASK Firey answers “I’ve got something for you!” while fewer than three gifts have been taken, and “You’ve taken enough!” at three. The code holds the offers “Let me give you a piece of my mind.”, “Let me lend you a hand.”, and “Now he is a foot shorter.” HIT Firey and INSULT Firey get “Hey, that’s not nice!” and cost an opening bonus point; CONGRATULATE Firey gets “Like, thanks, that’s nice.” and earns one. ($8D39, $8E69, $8EEB)

Throwing the head shows what lies ahead

THROW head starts a short flight. When it lands, the reply describes the region ahead: “Wow! I see an old man in a chair!” (the garden of the Wise Man), “I see a bunch of hedges!”, “I see two funny doors!” (see the door knockers), “Yuck! Does that look disgusting!”, or “I just see more trees.” Thrown from too far in, the reply is “You can’t throw it in there!” ($8FFB, $9017)

CALL Firey brings “I’m coming!”, or “I’m here already!” once he is within range. CALL Ludo and CALL rocks only get the gag replies “He doesn’t answer.”, “Ludo is hanging around somewhere else.”, and “Here, rocks! Here, rocks! They don’t seem to answer.” ($8DB1, $8E0E, $8E21)

Sources and checks

Firey routines $8CFF to $8EEB; head throw $8FFB, $9017; texts $930B to $9A2B. Exit selectors are at $076E and the four exit banks at $077E to $07FD. Emulator check (25 October 2026, scene loaded by force, Firey not on screen): CALL Firey gave “I’m coming!” and later “I’m here already!”, ASK Firey gave “We want a ROCK VIDEO!”, CALL Ludo and CALL rocks gave the gag replies, HIT Firey gave “Hey, that’s not nice!” once, and HIT, INSULT, or CONGRATULATE otherwise gave “There’s no one nearby.” or “He’s not here.”, so those three need Firey within range. THROW head without the head gave “You can’t throw that!”. Not reached: the camcorder trade and the head throw.

The Forest: the second strip

Read from code

This scene’s code, text, pictures, font, and costumes are byte-for-byte those of the first forest strip, so every command there behaves the same here. Only the 64-cell map and the exit tables differ. Counting all four exit banks, the first strip sends 4 entries to scene 9, 2 to scene 10, 7 to scene 11, 4 to scene 13, and 13 to scene 16; this strip sends 4, 2, 3, 4, and 4. ($8D39, $8FFB)

Sources and checks

Same overlay as scene 12; exit tables $077E to $07FD differ. Entry counts per destination are read from the four exit banks.

The Stone Faces

Read from code

The faces warn you off as you come near

Standing close to the wall brings one of sixteen random warnings, once per approach. They include “I’d turn back if I were you!”, “Abandon all hope all ye who enter here!”, “Certain death is ahead!”, “Beware! Beware!”, and “Lasciate ogni speranza voi ch’entrate!” ASK wall, CALL wall, and CONGRATULATE wall give another warning. ($8FAA, $8CBA, $8FA5)

Hitting a face gives one of four hints, then repeats

HIT wall or INSULT wall picks one of four hints, chosen at random from 18 when the scene starts. The face says “Sorry, just doing my job. Here’s something you’ll really like:”, shows the hint, and ends “But don’t tell Jareth I told you!” A hint already given is introduced with “We already gave you the hint:”. ($8FC0, $8FF3, $8DB8, $8DBE, $8D27)

The 18 hints are: “Defeeting a Firey will make you sure-footed.”, “You’ll need to arm yourself to enter the castle.”, “To enter the castle, you must first disarm a Firey.”, “Two heads are better than one.”, “To see the castle you will need to get a head.”, “It helps if great things are afoot.”, “Within every lump of wood lies beautiful music.”, “There’s music in the trees.”, “If you don’t C sharp you’ll B flat.”, “Heavy rock lovers make great videos.”, “A sweet smell can do much for unwelcome ones.”, “The unencumbered tight rope walker has the best balance.”, “Don’t knock the jewelry.”, “Goblins are short sighted.”, “Disguises sometimes work.”, “Jareth can’t take his own medicine thrown at him.”, “Open the log to reveal the hidden key.”, and “Make a logjam for safety.” ($903E, $9050, $9062)

Sources and checks

Warnings $8FAA; hint logic $8FC0 to $8FF3; hint tables $903E to $9062; texts $9764 to $9CE5. The pick list at $8DB8 is replaced by four distinct random values at setup. Emulator check (25 October 2026, scene loaded by force with entry 20, which puts a face on the left): HIT wall gave “Sorry, just doing my job. Here’s something you’ll really like:”, ASK wall “I’d turn back if I were you!”, CALL wall “It will soon be too late!”, CONGRATULATE wall “Take heed and go no further!”, and INSULT wall “We already gave you the hint:”. With entry 35 the scene shows a plain brick wall and the ordinary wall replies (“Ouch! You hurt your hand.”) come instead. The hint lines themselves were not read off the screen.

The Bog of Eternal Stench

Read from code

This scene’s overlay differs from the Ludo maze’s by only seven state bytes. Every handler there, including freeing Ludo with the shears and the goblin reactions, is present here, and the exit table is the same: region 0 requests scene 10 and region 1 requests this scene. ($8F68, $8F95)

The capture shows Sir Didymus beside a ladder. Neither the speech nor Sir Didymus is described by this scene’s text records, so the picture comes from the loaded resources, not from these handlers.

Sources and checks

Same bytes as scene 8 except seven state bytes; handlers and exits as for scene 8. Emulator check (25 October 2026, scene loaded by force with entry 35, which shows a hedge maze with a goblin tree, not the ladder): HIT goblin gave “MOMMY! MOMMY!”, CONGRATULATE and CALL goblin “There is no one here.” when the goblin was away, ASK Ludo “Ludo down!!!”, and MANICURE Ludo “You have nothing to manicure with.”

The Goblin Village

Read from code

Two goblins move on their own and catch you

Two goblin slots each hold a mode, two counters, and a last move from 1 to 8. A goblin picks its next move either by turning one step around the ring of eight directions or, while the helmet is on and no perfume is worn, at random, which fits the hints “Goblins are short sighted.” and “Disguises sometimes work.” Wearing perfume instead starts a countdown with a random length, and each time it runs out the screen says “Oh! He smells awful! Get him!” ($9834, $986A, $98F3, $97F3)

HIT goblin sets a short reaction (“MOMMY! MOMMY!”), INSULT goblin “HUH?”, and CONGRATULATE goblin “Gee, that’s nice.” Each needs the goblin within range, or the reply is “There’s no one nearby.” CALL goblin gets “I’ll get you yet!” ($8E7C, $8E9F, $8E5E, $8D76, $9048)

Calling the elephant draws a block of tiles

Once an elephant has been adumbrated, CALL elephant draws a 12 by 9 block of tiles over the village, with a sound, whenever the state byte $0343 is not negative. Before that, the reply is “Elephant? There’s no elephant inside the Labyrinth.” ($8DC2, $8DF3, $9B0E) What the tile block shows has not been identified.

Sources and checks

Goblin routines $97F4 to $9998; elephant tile block $9B0E; texts $90A9 to $9C06. Exit selectors at $076E. Emulator check (25 October 2026, scene loaded by force with entry 35, no goblin near): HIT, INSULT, CONGRATULATE, and CALL goblin all gave “There’s no one nearby.”, as the page says. The goblin reactions and the chase were not reached.

The Underground

Read from code

The log blocks a door only where the map has a door

DROP log and USE log check the map cell under the player. On a door cell (class 0) the cell is replaced, the log leaves the inventory, and a sound plays. Anywhere else the reply is “You can’t block the door.” ($8E8C) The hint in the stone faces is “Make a logjam for safety.” ASK door, CONGRATULATE door, and INSULT door get “Nothing happens.”, “The door seems rather board.”, and “The door is not open to criticism.” ($8F04, $8F61)

A patch of wall changes colour in steps

While the player stands in a zone near the wall (deep enough, and within a range of columns), a hook fills 16 colour cells in a step from 7 down to 1 on each entry, and refills them with one colour when the zone is left. The change shows one step per entry, not a continuous fade. What the colours mean in the story is not identified. ($99A1, $99C5, $99D0, $99F7)

The overlay also holds a moving object that switches between two headings and a three-step sequence once the player is deep in the picture. Their purpose is not identified. ($8D19, $8E13) Jareth’s only line here is “I’m quite delighted you find my humble Labyrinth to your liking.”

Sources and checks

Log handler $8E8C; zone hook $99A1 to $99F7; texts $92D0 to $97C4. Exit tables $077E to $07FD. Emulator check (25 October 2026, scene loaded by force with entry 35, no door on screen): INSULT door gave “The door is not open to criticism.”; ASK door and CONGRATULATE door gave “There’s no door here.” (the other replies need a door cell); DROP of an item that is not the log gave “You can’t drop that here, Jareth hates litterbugs.” The log, the wall patch, and the exits were not reached.

The Castle of the Goblin King

Read from code

The nerd talks in a 22-line monologue

Woken, the nerd speaks one line every 30 updates, from “You know it’s really amazing how” through a story about being locked in a closet by his sister Kim, to “Oh! You weren’t listening! No problem, I’ll start over from the beginning!” If the player gets too close while he talks, the screen says “The nerd is driving you up the wall!” While the walking-view state byte $0343 is negative, ASK nerd and CALL nerd only bring “Shh! You’re ruining my concentration!” or “He is busy watching a movie.”; in the other view they wake him. ($9090, $90A7, $9902, $9937, $9955, $996B)

Ludo’s noise rolls the rocks, but he leaves if you smell

CALL Ludo starts a noise sequence (“He’s coming.”). With perfume on, he refuses (“He won’t come. Your odor is overpowering.”) and later leaves (“Smell bad! Ludo leave!”). Left alone, the sequence ends with “Ludo scared! Ludo not come closer!”, and CALL rocks first answers “Maybe they’d come if you could yell louder.” If eight rocks are already carried, CALL rocks says “You can’t carry any more rocks.” ($8FF0, $8D62, $8E8A)

Throwing an object starts a target game

THROW crystal ball, head, helmet, or rock share one routine. It refuses outside the walking view (“Impossible!”) and while no rocks roll (“First get the rocks.”). A thrown helmet that was stuck to the head comes unstuck (“It came unstuck!”). The routine then runs a sequence against five moving targets that turn at set limits. Each hit lowers a counter and a kill-count; a hit at one of two positions raises a digit on screen. ($90EA, $9108, $9CF3, $9D90, $9E3E)

The door answers the key, the log, and the arm: INSERT key and USE log both apply a door effect, and USE arm works only within reach (“Your arm’s too short to reach it.” otherwise). The door’s default replies are “There is no door here.”, “The door’s unmoved.”, and “Don’t knock it!” ($8EC9, $8ED4, $8F0E, $8E5D, $8E6A)

Sources and checks

Nerd monologue $9902, tables $9955 and $996B; throw routines $90B6 to $9108; target game $9CF3 to $9EE7; door handlers $8EC9 to $8F26. Emulator check (25 October 2026, scene loaded by force with entry 35): ASK nerd gave “Shh! You’re ruining my concentration!”, CALL nerd “He is busy watching a movie.”, CALL Ludo “His line is busy.”, and CALL rocks “Maybe they’d come if you could yell louder.”; the last two are gag replies for Ludo and the rocks being away. The monologue, the throwing game, and the door were not reached.

The Secret Corridor

Read from code

The door is locked, and the helmet is a disguise that is refused

OPEN door at the door answers “The door is locked.” until the key has been used, and “It’s already opened.” afterwards. INSERT key or USE key at a door cell, deep enough in, uses up the key and plays a sound; elsewhere the reply is “There’s no place to insert it.” Once the door is open, standing at it with the helmet on (it is “stuck to your head”) brings “I will not face one who looks that silly! Enter without your disguise.” once, and again only after the player has stepped away. ($8D01, $8F3F)

Hitting the wall plays a note

HIT wall at a wall cell plays a pitch picked from a 64-entry table by the player’s position, grouped into six bands of about nine columns each, and by the row. Outside the zone it only makes a sound. The plank is a second instrument: INSERT plank or USE plank near the wall starts an eight-step sequence that restores a map cell and plays a pitch. Too far away the reply is “You’re not close enough.” ($8E86, $97BE, $8EEA)

The door’s other replies are the common ones: “The door seems rather board.” for CONGRATULATE door and “The door feels your verbal attack is unjustified.” for an insult. ($8E23)

Sources and checks

Disguise check $8D01; key $8F3F; wall $8E86 with table $97BE; plank $8EEA; texts $918F to $974A. Emulator check (25 October 2026, scene loaded by force with entry 35): OPEN door gave “There’s no door here.” away from the door, HIT wall “Nothing happens.” outside the zone, CALL Ludo “He’s tied up right now.”, and INSERT with something that is not the key “There’s no place to insert it.” The locked door, the note zone, the disguise refusal, and the plank were not reached.

The Upside-Down Room

Read from code

Jareth speaks first, and force does not work

On arrival Jareth says “So, you’ve finally made it to my castle. Think you’re clever? Your hours have become minutes.” HIT Jareth within reach gets “You can’t defeat me with force. Your hands pass right through me!” and farther away “No one can reach that far!” His other replies include “You think you can defeat me with words?”, “You’re really grasping at straws!”, “Do you think I’m a door?”, “Ludo is not here to help you now!”, and, for the cup, “So you’ve decided to return my cup did you? Did you have fun with it?” ($90A3, $916C, $9176)

The crystal ball is the weapon

THROW crystal ball starts a throw. When it lands the game plays a short tune and says “You hit Jareth with the crystal ball, but it’s not over yet!” THROW head and THROW rock follow the same routine with a different sound and a delay. Anything else gets “You can’t throw that!”, ($91CC, $91D2, $91DE, $91E2, $90D3)

The nerd hints, until you insult him

ASK nerd without a crystal ball gets “How do you expect to win without a crystal ball?” and with one “Why don’t you hit Jareth with a crystal ball already!” CALL nerd gets “Hey, this is great stuff!” HIT nerd or INSULT nerd gets “Ok then, I won’t help you!” and after that every nerd command answers “I’m not talking to you.” ($918E, $91A6, $91B0, $91BD)

Four actors move over a graph of nodes

The room is a graph of nodes with direction flags. Actor 0 (the player) steers by the joystick direction, actors 1 and 3 trail it, and actor 2 chases it, keeping a distance that switches between two limits ($A0, then $50). If actor 2 overlaps the player, the followers are cleared and actor 3 stops. ($8C95, $8CB3, $8DAC, $902A)

Sources and checks

Jareth’s replies $916C to $91E2; nerd $918E to $91BD; movement engine $8C95 to $902A; texts $92AC to $9841. Emulator check (25 October 2026, scene loaded by force with entry 35): HIT Jareth from far away gave “No one can reach that far!”, GIVE to Jareth the same, ASK Jareth “It’s pointless to ask. You’ll never better me!”, ASK nerd “How do you expect to win without a crystal ball?”, CALL nerd “Hey, this is great stuff!”, HIT nerd “Ok then, I won’t help you!” and, after that, ASK nerd “I’m not talking to you.” (the first command typed after a forced load answers “That won’t work!”, so the ASK was typed twice), and THROW with nothing throwable “You can’t throw that!” The crystal ball hit and the way to scene 26 were not reached.

The Final Confrontation

Read from code

Six phrases lead to the same ending

Jareth opens with “I am still your master and you must remain with me until the end of time.” The scene replaces the command wheel with one built for this fight, and six phrases play it: YOU HAVE NO power over me, DO YOU HAVE power over me, DO YOU HAVE towels over me, THROW SOME power over me, THROW SOME towels over me, and YOU HAVE NO towels over me. Each starts a reply with sound 28, sets a different pose for Jareth, and then counts down 21 updates. ($8CC9, $8DC2, $8DDD, $8DED, $8E10, $8E1E, $8E3E, $8CF6)

When the countdown ends the win ending plays a tune and shows “Congratulations! You have defeated Jareth. You proudly walk back to your seat at the theater where the cute girl is waiting for you.” ($8E5F)

Leaving the safe range ends the game

Each row of the ledge has a safe range of positions. If the player’s position falls outside it, a nine-step fall begins, ending with “You fell off the edge and met your doom! And you were SO close to defeating Jareth!” ($8EAB, $8CAD, $8EDA, $8ECA, $8ED2)

Sources and checks

Update $8C99; command handlers $8DC2 to $8E3E; endings $8E5F, $8EDA; edge check $8EAB; word-wheel descriptor $8F2B. Texts at $902C, $907F, $90FD. Emulator check (25 October 2026, scene loaded by force with entry 35): the capture opens with Jareth saying “I am still your master and you must remain with me until the end of time.” and the command line reads “Throw some power over me”, as the word wheel describes. In the same forced load the player began outside the ledge’s safe range, and after a few seconds the game showed “You fell off the edge and met your doom! And you were SO close to defeating Jareth!”, as the page says. The win ending was reached in a second forced load, with the safe range widened and the reply countdown at $8D9A set to 2 by hand: the game then played the tune and showed the win text word for word, “Congratulations! You have defeated Jareth. You proudly walk back to your seat at the theater where the cute girl is waiting for you.” Typing “throw some power over me” did start the countdown at its first value, but the 21 steps of the reply then drew garbage and the emulator stopped at a BRK in the costume area; that load did not come through the earlier scenes, so this is more likely a forced-load artefact than a game fault, and the reply animation was not seen to the end.