summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--design/README.md86
-rw-r--r--design/mock/29-intro-bytes.pngbin83086 -> 78336 bytes
-rw-r--r--design/mock/29-intro-bytes.svg6
-rw-r--r--design/mock/30-intro-words-480.pngbin21208 -> 21282 bytes
-rw-r--r--design/mock/30-intro-words.pngbin128243 -> 128806 bytes
-rw-r--r--design/mock/30-intro-words.svg4
-rw-r--r--design/mock/31-intro-stack.pngbin144165 -> 148516 bytes
-rw-r--r--design/mock/31-intro-stack.svg15
-rw-r--r--design/mock/37-regroup.pngbin138314 -> 125817 bytes
-rw-r--r--design/mock/37-regroup.svg112
-rw-r--r--design/mock/context.py6
-rw-r--r--design/mock/intro.py159
-rw-r--r--design/motion.md194
13 files changed, 340 insertions, 242 deletions
diff --git a/design/README.md b/design/README.md
index 0899e50..b51f057 100644
--- a/design/README.md
+++ b/design/README.md
@@ -86,7 +86,7 @@ this table.
| | [`echo`](#4-ties) | the same mark in two panels at once | for a step |
| | [`touch`](#4-ties) | this instruction reads or writes that word | for a walked step, while the row is current; `tied` only |
| | [`carry`](#4-ties) | this value went from that word to this register, or back | a scene's knob, off by default; for a walked step |
-| | [`aim`](#4-ties) | this word holds the address of that instruction | the author's knob, off by default; for a step, or standing through a beat |
+| | [`aim`](#4-ties) | this word holds the address of that instruction | the author's knob, off by default; for a step, or standing through a beat, or drawn on its beat and then standing |
| 5 frame | [`stage`](#5-the-frame) | the working frame: the band and the two columns | split `none`, `beside`, `subject`, `blocks` |
| | [`segments`](#segments) | the process's address space to scale, each end enlarged, its bands' addresses at their edges | treatments A (default), B, C; the ink's source: a band framed when a word is inked; a dump's place |
| | [`aligned`](#aligned) | the source and its instructions in one panel, each line level with its code | `interleaved`, `columns`; a split a scene chooses |
@@ -435,14 +435,16 @@ A word of the stack, pwndbg's way and a little more.
| --- | --- | --- |
| 4, 10 | arcs | the [`arc`](#arc) lanes: a word holding the address of another slot in the window |
| 16 | pins | the `row` pin's lane, to 112: every register whose value is this word's address |
-| 172 | offset | hex, faint, ranged right in four characters, from the newest frame's base: the register its code addresses its words by (the call frame information's CFA register: rbp in a body that keeps a frame pointer, rsp at a function's entry, in its prologue before `mov rbp, rsp`, after its `pop rbp` or `leave`, and in a function that keeps none), so that `[rbp - 0x18]` and its word's `-18` are one number. The base's row is `+0`. Under [`whole`](#insn) pwndbg's: from rsp, `+18`, and `-8` above rsp |
+| 172 | offset | hex, faint, ranged right in four characters, from the newest frame's base: the register its code addresses its words by (the call frame information's CFA register: rbp in a body that keeps a frame pointer, rsp at a function's entry, in its prologue before `mov rbp, rsp`, after its `pop rbp` or `leave`, and in a function that keeps none), so that `[rbp - 0x18]` and its word's `-18` are one number. The base's row is `+0`. Under [`whole`](#insn) pwndbg's: from rsp, `+18`, and `-8` above rsp. In the introduction, from 0x10 up with `0x` (`-8`, `+0x10`, `-0x18`), as the operands and the values are written: beside a symbol's decimal offset (`main+50`) a bare `-10` after `-8` reads as ten |
| 184 | address | stack ink, `lead`; then the chain, its first hop the word's content |
| 88 | shadow | in a run built with AddressSanitizer: the shadow byte that stands for this word's eight bytes, a `byte` cell in the pin lane's end, before the address it stands for (a fake frame's words have no offset from rsp, and no pins). `00`, addressable: faint, no paper. `f1` `f2` `f3`, the stack's left, middle and right redzones: bright on the `freed` hatch, the poison's sign. `01` to `07`, the first k bytes addressable: bright, the hatch over the other 8 − k eighths of its cell. The panel's tag gives where the shadow is, `shadow at addr >> 3 + 7fff8000` |
| right | role | what the word is, where the recording knows it, ranged right where the chain's room ends: `saved rbp`, `saved rbx` (dim); a local's name (primary), and which part of the word when it is narrower (`n, high half`, `f, low half`); at the process's start `argc`, `argv[0]`, `argv end`, `envp end`, `auxv` (dim). It is the name a `tied` annotation gives the word ([`insn`](#insn)) |
| 14 from the right | span | the [`call`](#call) bracket, its name left of it |
A return address needs no word: its chain is code, named (`10018b0
-main+80`), and its frame's bracket ends on it. Room runs out from the
+main+80`), and its frame's bracket ends on it. The introduction, which
+leaves nothing to the eye, gives it the role `the way back` (its caption's
+words; `return address` would cut the name beside it). Room runs out from the
right: a span's name is never cut, a role is never cut, and the chain on
the rows they sit on ends 12 before them, cut by its own rule
(`sqlite3BtreeInsert` beside `7fffffffe980 → 7fffffffeb90 → …`).
@@ -593,7 +595,7 @@ bytes and a pointer 8, never two fields and never a store's width.
| 24 | bracket | `quiet`, on a row that holds a drawn thing; `tie` when a projection ends here |
| 34 | address | region ink, `lead`; at 60% on a row that holds no drawn thing |
| 132 | sixteen `byte`s | on a pitch of 30, 12 more after the eighth |
-| 640 | reading | what the runs read as, left to right, a character apart: a number in decimal (in its byte order); a pointer as `points` and its `address`, `NULL` dim; text in quotes, C's escapes, in a string's ink; a run left to the eye, or `loose`, as nothing; the chunk's size word before an allocation as a note in Go 18, faint (`malloc's: a chunk of 32`). Cut at the panel's edge with a faint `…` |
+| 640 | reading | what the runs read as, left to right, a character apart, but no space before a pointer's arrow, which has its own room as in a chain (`9 → 407030`): a number in decimal (in its byte order); a pointer as `points` and its `address`, `NULL` dim; text in quotes, C's escapes, in a string's ink; a run left to the eye, or `loose`, as nothing; the chunk's size word before an allocation as a note in Go 18, faint (`malloc's: a chunk of 32`). Cut at the panel's edge with a faint `…` |
**Wide address.** The bytes begin 12 after the address ends, and at 132
at least: an address of up to seven digits leaves them at 132; the stack's
@@ -732,7 +734,10 @@ the stack gains.
### stack
-`slot`s from rsp, low addresses on top: as many as the state column has
+`slot`s from rsp, low addresses on top (where it first stands beside a
+drawing with high addresses on top, as the introduction's address space,
+the scene says so: "lower addresses are drawn higher: down a word is up a
+row"): as many as the state column has
under the registers ([the frame](#5-the-frame): twelve as the subject
beside eleven rows of registers, fourteen beside a lens, fifteen with
none, twenty with the `blocks` lens). `call` spans down its right edge for every frame in view: the
@@ -781,7 +786,10 @@ to the stack's top.
it, and the pane rolls back in at the new place.
- While the camera is on the stack the window holds still
([`visit`](#6-verbs)): pushes fill `free` slots in the middle of the
- frame, and rsp's pin climbs to them.
+ frame, and rsp's pin climbs to them. A scene may hold it the same way
+ while a frame is made: the introduction's chapter II holds it from its
+ first picture with four `free` words over rsp, enough for `push rbp` and
+ `sub rsp, 0x18`, so that only pins move and no row.
Tag: `twelve words`, or the range when scrolled (`rsp+20 to rsp+78`); what
the offsets count from, `· offsets from rbp` (`tied`: the frame's base, which
@@ -1358,8 +1366,8 @@ page while a beat lasts), `active` (full ink, for the step that causes it).
| `thread` | this line is these instructions, and the machine is here | the current `line` ⋈ the `insn` rows of that line | none · always | 0: never gives way | gold, 3; a `tie` bracket on the line and on each run | the left margin, x 54 (on the map, the gutter at x 1008) | standing; moves with `advance` |
| `link` | this register now points at that | a struck `reg`'s value ⋈ `places` by address, where the target has a pin lane (a node, a slot) | `link`: `off`, `step` · `step` | 2 | the target region's ink, 3; a filled head; the pin rides it | the gutter's left lane up into the band, the right lane down to a slot | `link`: s+6, 24 f (36 over 400 units), back 18 |
| `projection` | these bytes are that part of the drawing | a read or write `event`'s run ⋈ the drawing's part made of those bytes | `projection`: `off`, `step` · `step` where a lens with a view is up | 3 | the mark's colour, 2; a bracket at each end | the gutter's right lane; a lens's top or bottom lane | `project`: bracket 6 f, line 18 (30 over 600), back 18 |
-| `aim` | this word holds the address of that instruction | `values` of region code ⋈ `insn` rows (or a graph's pills) by address | `aim`: `off`, `step`, `standing` · `off` | 4 | code's ink, 2; a filled head; the row's address framed | the gutter's left lane, x 950 | `aim`: after its word's mark, 18 f (24 past ten rows); glide 24 to a new row; fray 12 + 18 |
-| `carry` | this value went from there to here | a load, store, push or pop `event`'s source ⋈ its destination | `carry`: `off`, `arrow`, `value` · `off` | 5 | primary, 2; an open chevron | the gutter's right lane, x 962 | `carry`: after the source's read, 18 f (24 past eight rows), back 18 with the strike |
+| `aim` | this word holds the address of that instruction | `values` of region code ⋈ `insn` rows (or a graph's pills) by address | `aim`: `off`, `step`, `standing`, `drawn` · `off` | 4 | code's ink, 2; a filled head 10 by 10; the row's address framed | the gutter's left lane, x 950 | `aim`: after its word's mark, 18 f (24 past ten rows); glide 24 to a new row; fray 12 + 18 |
+| `carry` | this value went from there to here | a load, store, push or pop `event`'s source ⋈ its destination | `carry`: `off`, `arrow`, `value`, `after_touch` · `off` | 5 | primary, 2; an open chevron | the gutter's right lane, x 962 | `carry`: after the source's read, 18 f (24 past eight rows), back 18 with the strike |
| `touch` | this instruction reads or writes that word | a read or write `event`'s `insn` row ⋈ the `slot` by address | `touch`: `off`, `step` · `step` under `annotation = .tied` | 6 | the mark's colour, 2; a head on the stack's rule | the gutter's middle lane, x 956 | `touch`: 12 f (18 past six rows), before the word reacts; back with the advance |
| `arc` | this word points at that row of its own panel | `values` in a panel ⋈ `places` in the same panel by address | `arcs`: `off`, `standing` · `standing`, active in the step that writes or reads it | its panel's: lanes, not the frame's budget | the target region's ink, 2, 60%; full when touched | the panel's left lanes (three; the stack two) | `arc` |
| `stem` | this text speaks of that | a bubble ⋈ the row or tag it is level with | `stems`: `off`, `rest` · `rest` in the [column](#column) | rests only: never with a step's lines | `dim`, 2 | across the gutter, level | in 12 f with the bubble, back 12 f with the fire |
@@ -1492,9 +1500,12 @@ first (the stack, a dump), or the arrow ends in a stub on the panel's rule
with a count, as a link's does; a folded register (`quiet`) takes it on its
cell. A second value, `carry = .value`, sends the value's digits along the
arrow on a chip of `raised`, landing as the destination's strike: for the
-introduction's one walked load, where the viewer first learns that a
-register can hold what memory holds; never in a scene's ordinary steps
-([mock 56](mock/56-carry.png)).
+one walked load where the viewer first learns that a register can hold
+what memory holds; never in a scene's ordinary steps
+([mock 56](mock/56-carry.png)). A third, `carry = .after_touch`, draws a
+store's touch first and then its carry, the row naming the word before the
+value goes there: for the introduction's `push rbp`, where the push is the
+lesson ([motion.md](motion.md#a-word-touched)).
**The aim.** Off unless the author turns it on (`aim = .step` or
`.standing`, for a scene or a beat). On, it finds every value on screen that
@@ -1513,9 +1524,14 @@ a row shown, the head glides to that row (24 f, `glide`) after the strike;
code with no row shown, the head goes to the rule as a stub with the row's
name; no longer code, the aim **frays**: it goes dashed (12 on 8) over 12 f
and fades over 18 f. Standing, it rides its rows when they scroll, and a word
-that leaves its window takes it away. Route: out of the word's panel's left
-rule level with it, the gutter's left lane (x 950), onto the disassembly's
-right rule level with the row ([mock 57](mock/57-aim.png)).
+that leaves its window takes it away. `drawn` is a standing aim the beat
+itself introduces, with no step to draw it: it draws as a step's does, head
+first at full ink (18 f), the row's address framed as the head lands (6 f),
+and falls to the standing 60% only when the next step begins (the
+introduction's return address, II3 to II4). Route: out of the word's panel's
+left rule level with it, the gutter's left lane (x 950), onto the
+disassembly's (or a descent window's) right rule level with the row, its head
+10 by 10 ([mock 57](mock/57-aim.png)).
**Order.** A tie arrives before the thing it points to reacts: see
[`link`, `project`, `touch`, `carry` and `aim`](#6-verbs). Mock 9 shows the standing ties; 10 and
@@ -1702,7 +1718,7 @@ named band carry their addresses, and the bands their sizes.
| the names | right of the box, from 64 past it (the leaders' room). A row for each edge of a named band: its address in mono 20, in the ink of the band it bounds, and a leader (2, `rule`) from the edge, 8 out, straight to 20 short of the address, 12 in. Between two edges a row for the band, indented 24: its permissions and its size (`dim`, ranged right 132 in), and its file in primary at 252 (`[stack]`, `libc.so.6`); a file of several named bands once, on a `quiet` bracket over their rows. Rows 24 apart, each as near its edge as the others let it (crowded rows pooled round their mean), inside the box's share of the stage; a leader never crosses another, as the rows keep the edges' order |
| what is named | the program by segment: each of its mappings a band with its two addresses, permissions and size, under a bracket with its name, because the scenes point into them (its code, its data). Every other file once: its mappings as one (an anonymous mapping after a file's data, its bss, with it; the vDSO with its data), its start, stop, size and name, its permissions where they are one (`rw-` for the stack and the heap), and where they differ, each part's written inside its band, centred, where the band is 28 tall. A band under 6 tall is drawn and not named (an anonymous page; in mock 34 the vDSO) |
| live | rsp an `under` pin in the stack's band; rip a row pin at the end of its band's row (`◂ rip`). In the introduction's first chapter neither: there are no registers yet |
-| a dump's place | in the introduction, where the dump the scene has built stands beside it: a `tie` bracket on the dump's rows, and a [`link`](#4-ties) in the stack's ink from the bracket's top, up into the stage's top margin (y 56), across, and down onto the stack's box at the dump's address, its head on it. It draws in its own beat and then stands, quiet (60% toward the page), while both are on screen |
+| a dump's place | in the introduction, where the dump the scene has built stands beside it: a `tie` bracket on the dump's rows, and a [`link`](#4-ties) in the stack's ink from the bracket's top, up into the stage's top margin (y 56), across, and down onto the stack's box at the dump's address, its head on it. It draws in its own beat (the dump's addresses take the stack's ink as its head lands, never before) and then stands, quiet (60% toward the page), while both are on screen. For a camera's visit, where the dump is still far thinner than a unit, its place is marked on the box: a 2-unit tick across it in the stack's ink at the dump's address, the dump's size over it (`128 bytes`) left of the link's head |
| `ink`'s echo | the band a word points into, framed as read inside the box (2 units, 4 in from its sides, 6 over and under the band), and that band's row of names framed with it |
The physical comparison is the caption's, worked from the recording: if
@@ -1968,7 +1984,7 @@ caption's and the clock's.
| before the first step it describes fires | 60 f after it has arrived; 120 f for a scene's first |
| a scene's first | arrives at 1.0 s; the first step fires by 4.0 s (5.0 s when the scene opens on the map and dives) |
| changes | only in a rest, never under a moving thing |
- | names | only what is on screen at the pace it plays: no register a run veils, no step that has not happened or that played more than its 60 f lead ago |
+ | names | only what is on screen at the pace it plays: no register a run veils, no step that has not happened or that played more than its 60 f lead ago; and nothing before it has been shown, in a caption or a label (a dump's header, a tag): the introduction's first bytes are `128 bytes at 7fffffffebc8`, not the stack's, until the stack is on screen |
| checked | by the instruments' CAPTION ([motion.md](motion.md#the-instruments)) |
| longer than two lines | two captions, split at a phrase rest |
| the last | its reading time before the cut, and 2 s on the finished picture; the scene grows to fit |
@@ -2017,7 +2033,11 @@ glide and resize to their boxes (24 f), their rows riding with them; the
text column opens and the first bubble arrives (18 f). Back to the working
frame: the bubbles leave together (12 f); the panes glide to their working
frame's boxes (24 f); the folded panes unfold from the shelf in their places
-(18 f, rows in 6 f); the caption arrives. About 70 f each way. A drawing that
+(18 f, rows in 6 f); the caption arrives. About 70 f each way. A part with
+no panel round it (the introduction's dump: a header over its rows) folds by
+its own rows: they glide up into its header (24 f, `glide`), the header
+becomes the tag where it stands, and the tag slides to the shelf (24 f,
+`glide`); back, the reverse. Nothing goes out in a few frames. A drawing that
changes size between the forms keeps its labels inside its box at every frame:
it scales as one (24 f) and its tag's note crossfades if it no longer fits.
@@ -2064,7 +2084,9 @@ it); it is never drawn empty, not for a frame (the built scene emptied its
descent for 40 f while it grew).
**`bubble`.** A piece of narration: Go 40 on 54 as the caption is, code in
-mono 35, lines of at most 40 characters, 16 of padding, 812 wide at most. The
+mono 35, lines of at most 40 characters (80 for a text `above` a subject
+that spans both columns: two lines in its band of 120), 16 of padding, 812
+wide at most at 40. The
newest is on `raised` paper, primary: the one being said. An older one loses
its paper and dims to `dim` (18 f, as the next arrives), and stays as the
account the viewer can glance back at. Three stand at most; a fourth's
@@ -2167,13 +2189,13 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves:
| `cool` | a struck value | starts with the advance: 24 f, `glide`, the paper to nothing, and the turned corner of `held` fades in over its last 6 f, for three steps (then out over 36 f); the same in a lens's cell. The digits go to their ordinary face at its middle |
| `read` | a value read | in over 6 f; held to the advance; out over 18 f. No arm, no pulse |
| `extend` | a chain whose first hop was struck | each later hop is followed again, 4 f apart, fading in over 6 f |
-| `link` | a `reg` just struck, and its target | s+6: the old pin fades (12 f) and the line draws from the register's row, head first, 24 f (36 f over 400 units), `standard`, the pin riding its head; the pin lands with the head and settles (12 f); held; at the advance the line draws back into the pin over 18 f. A target out of the window: the line ends in its stub, and the pin waits for the window |
+| `link` | a `reg` just struck, and its target | s+6: the old pin fades (12 f) and the line draws from the register's row, head first, 24 f (36 f over 400 units), `standard`, the pin riding its head; the pin lands with the head and settles (12 f); held; at the advance the line draws back into the pin over 18 f. A target out of the window: the line ends in its stub, and the pin waits for the window. **On a beat** the caption names, with no step (rsp in the introduction's II2, rax in its III3): the register framed as read (6 f), the line 6 f after (36 f, `standard`, the name riding its head), held as the beat says, then drawn back toward its head over 18 f with the register's frame, the head fading over the draw-back's last third: never gone in one frame |
| `project` | a run read or struck, and its part of the drawing | on the run's mark: the bracket on the row (6 f), the line draws from the bytes to the drawing (18 f; 30 f over 600 units; `standard`); only when it arrives does the part react (its own `read`, or `arm` and `strike`; a new call's node fades in, 6 f); out with the advance, 18 f |
-| `touch` | the current row and the stack word it reads or writes (`tied`) | right after the fire, before anything the word causes: the line draws from the row's end across the gutter to the word's row, head first, 12 f (18 f when its leg is longer than six rows), `standard`; only when the head has landed is the word armed (a write: 12 f, then struck) or framed (a read, 6 f); only after that does what follows from the word move (a register it fills, rsp's pin climbing onto a pushed word, a span, a role). Held to the advance; drawn back into the row with it, 12 f, or (with `carry` on, for a load) as the carry leaves the word. A store of the value the word already held: the head lands, the arm's frame comes and goes and nothing is struck. A word the window must scroll to: the scroll first, then the touch. At a run and a sprint none: the names stand, and the marks are the run's |
-| `carry` | a value's way from its source to its destination (`carry = .arrow`) | the source framed `read` first (a register 6 f; a word by its touch); then the arrow draws from it to the destination, head first, 18 f (24 f past eight rows), `standard`; on its landing the destination is armed (12 f) and struck; the arrow draws back as the strike lands (18 f); only then what follows (a link from the register filled, a pin's travel). At a run and a sprint none |
-| `aim` | a code address and its row (`aim = .step` or `.standing`, the author's) | after the word's own strike or read: the line draws from the word to the row, head first, 18 f (24 past ten rows), `standard`, the row's address framed in code's ink as it lands (6 f); held to the advance, or standing at 60% through the beat; a word written again: the head glides to the new row (24 f, `glide`), goes to the rule as a stub with the row's name, or frays (dashed 12 f, then out 18 f) when the value is no longer code; at a `ret`, the plaque jumps where it points and the aim draws back as it lands. At a run and a sprint none |
+| `touch` | the current row and the stack word it reads or writes (`tied`) | right after the fire, before anything the word causes: the line draws from the row's end across the gutter to the word's row, head first, 12 f (18 f when its leg is longer than six rows), `standard`; only when the head has landed is the word armed (a write: 12 f, then struck) or framed (a read, 6 f); only after that does what follows from the word move (a register it fills, rsp's pin climbing onto a pushed word, a span, a role). Held to the advance; drawn back into the row with it, 12 f, or (with `carry` on, for a load) as the carry leaves the word. A store of the value the word already held: the head lands, the arm's frame comes and goes and nothing is struck (in the introduction, where the push is the lesson, it is struck: [motion.md](motion.md#a-word-touched)). A word the window must scroll to: the scroll first, then the touch. At a run and a sprint none: the names stand, and the marks are the run's |
+| `carry` | a value's way from its source to its destination (`carry = .arrow`; `.after_touch`: a store's touch first, then its carry) | the source framed `read` first (a register 6 f; a word by its touch); then the arrow draws from it to the destination, head first, 18 f (24 f past eight rows), `standard`; on its landing the destination is armed (12 f) and struck; the arrow draws back as the strike lands (18 f); only then what follows (a link from the register filled, a pin's travel). At a run and a sprint none |
+| `aim` | a code address and its row (`aim = .step`, `.standing` or `.drawn`, the author's) | after the word's own strike or read: the line draws from the word to the row, head first, 18 f (24 past ten rows), `standard`, the row's address framed in code's ink as it lands (6 f); held to the advance, or standing at 60% through the beat (`drawn`: drawn so on its beat, at full ink, falling to 60% (18 f) as the next step begins); a word written again: the head glides to the new row (24 f, `glide`), goes to the rule as a stub with the row's name, or frays (dashed 12 f, then out 18 f) when the value is no longer code; at a `ret`, the plaque jumps where it points and the aim draws back as it lands. At a run and a sprint none |
| `follow` | the stack's window, after rsp's pin | only once the pin has landed and never with it: where the headroom over rsp is under two free words, or the newest frame's return address under the window's foot, the rows glide by whole slots, 24 f and 2 f a further slot, 36 f at most, `glide`, the pins riding their rows, the strip's window with them. A climb longer than the room over the pin is one move: the pin travels to the window's top, and the rows take the rest of the distance under it on the same curve. Farther than the window: `unroll`, the pin along the column, `roll` |
-| `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end. **rsp's and rbp's pins** are the stack's event and are given time: 24 f to the next row and 6 f a further row, 48 f at most, `glide`; the amount on the pin from its first frame, counting as it crosses each row (`rsp -8`, `-10`, `-18`, in write's vermilion, bold), held to the advance and then crossfading to the bare name (12 f); each row it reaches gained (brightening from `free`, 12 f, from the frame the pin's head reaches it, its role fading in with it) or released (to `free`, 12 f); the bracket over the rows crossed drawing with it; the newest span's end riding it; the register struck as the pin lands, and the row's amount with it. rbp's flight to rsp's row: the same, the names meeting in pwndbg's order (rsp slides aside, 12 f, before rbp lands). At a run: 8 f and 2 f a row, 16 f at most, drawn over the veil (the pins, the bracket, the span and the rows' gain or release stand clear of it; the rest of the stack stays veiled), no amount; at a sprint, on the map, rsp is the edge of the stack column's newest frame, moving with each moment (4 f), the spans growing and shrinking with it |
+| `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end. **rsp's and rbp's pins** are the stack's event and are given time: 24 f to the next row and 6 f a further row, 48 f at most, `glide`; the amount on the pin from its first frame, counting as it crosses each row (`rsp -8`, `-10`, `-18`, in write's vermilion, bold; in the introduction `-0x10`, `-0x18`, as its offsets are written: [slot](#slot)), held to the advance and then crossfading to the bare name (12 f); each row it reaches gained (brightening from `free`, 12 f, from the frame the pin's head reaches it, its role fading in with it) or released (to `free`, 12 f); the bracket over the rows crossed drawing with it; the newest span's end riding it; the register struck as the pin lands, and the row's amount with it. rbp's flight to rsp's row: the same, the names meeting in pwndbg's order (rsp slides aside, 12 f, before rbp lands). At a run: 8 f and 2 f a row, 16 f at most, drawn over the veil (the pins, the bracket, the span and the rows' gain or release stand clear of it; the rest of the stack stays veiled), no amount; at a sprint, on the map, rsp is the edge of the stack column's newest frame, moving with each moment (4 f), the spans growing and shrinking with it |
| `open` | a loupe, from a pointer | the pointer's hop framed `read` (6 f); the stem draws from it to the loupe's place, head first, 18 f (30 f over 600 units), `standard`; the loupe rises with the stem's head: it fades in over 12 f from 8 units lower, its shadow growing from nothing to its offset (18 f, `standard`); the target's bright frame lands 6 f after. From a pointer inside a loupe the same, over it, and a third closes the first as it starts. In the slot of the level that read the pointer, or on a beat the caption names |
| `close` | a loupe | the deepest first: its stem draws back into its pointer (12 f) and the loupe sinks, fading out over 12 f as it falls 8 units and its shadow shrinks; with the advance of the step it opened in. A loupe the narration keeps across steps closes at each advance and opens again in the idea's slot of the next step that concerns it (36 f, as `open`): the steps between are not drawn under it. Open 120 f without a change is the most |
| `dive` | from the map to the working frame | one continuous move in which the windows become the panels and each pane's column of the map becomes its minimap. 0 to 6: the windows' outlines go bright. 6 to 24: the rest of the map takes the veil (50%). 24 to 96, `glide`: each window goes from its place on the map to its panel's place, its scale on a logarithm from the map's (half, filling the frame) to the frame's (whole), so its rows grow from 10 units to 20 under the eye, the panels 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over those before; on the same move the rest of each window's column (the map's panel it is a window on) squeezes into its pane's strip: from its place at half size to the strip's rect, its width and its height each on its logarithm (to 36 of 880, and 4 of 24 a row), so the text thins to strokes as it lands, the window's outline riding on it to become the strip's window; the map's parts no pane takes (the backtrace, the key, the memory round pointers, a loupe's panel) fade where they are, 24 to 72. On the same move the registers' window (the panel whole on the map, every chain) folds as it lands: each quiet register's row glides into its cell, three to a row, its chain past the first hop fading over the move's first 24 f, so that the panel arrives at its height in the frame. 72 to 96: the drawing, whose sizes may differ between the two, crossfades from the map's to the frame's within its box. 84 to 96: each squeezed column crossfades into its strip's strokes; the frame's tags, rules and lanes fade in; the veil goes with the last of the map. 96 to 132: still (mock 20) |
@@ -2187,7 +2209,7 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves:
| `turn` | a loop's back edge | `leave` round the ring's foot from the latch up into the header at 9 o'clock: an arc, the mark at its speed (sort's inner, 58 units, and outer, 50, 12 f each); the count at the ring's centre is armed as the mark leaves the latch and struck as it lands. The mark going round the ring, step by step and then this, is the picture of iteration; at a run the whole loop goes round in one sweep of 8 f a step |
| `reach` | a block or an edge of a graph the run reaches for the first time | the edge draws gold under the mark, from `rule` (the `leave`'s own draw); as the mark lands, the pill fills from the page to `raised` (12 f), its offset brightening from faint to primary, and `×1` fades in (6 f) and is struck. Its counts begin here, never before |
| `unfold` | a fold of blocks not reached yet, when the run reaches one of them | as the mark sets off along the edge into the fold: the pills beyond the fold make room along the layout's own way (round the ring, or down the layers), 24 f, `glide`; the dashed pill splits into its blocks' quiet pills in their places (12 f, 2 f apart in address order); then the mark lands on the one reached (`reach`). A fold only opens |
-| `regroup` | bytes into a word (the introduction) | walked, on one word ([chart](motion.md#a-word-read), mock 37): the dump goes from sixteen bytes a row to eight (each right half down a row, then left); the other rows are veiled; the word's offsets fade in under its bytes, `low byte` under the first, `high byte` under the last; then the bytes themselves fly, the low byte first, 6 f apart, 36 f each, `glide`: straight up, over on nested arcs a quarter as high as they are long (34 to 120), straight down onto their pair's place in the word's field, 30 apart and ranged right, so that they land reversed, each offset and label going with its byte, and a faint copy fading into each one's place in the dump once it has left; the gaps close to sixteen digits (12 f); the zeros in front are bracketed, `zeros in front`, and fade (12 f). At a run (the other fifteen): each row's word fades in (8 f) as its bytes dim, rows 6 f apart. The word field is eight pairs wide, so a word is always ranged right, its low byte last |
+| `regroup` | bytes into a word (the introduction) | walked, on the dump's first word, the return address at a function's first instruction ([chart](motion.md#a-word-read), mock 37): the dump goes from sixteen bytes a row to eight (each right half down a row, then left); the other rows are veiled and the dump's header goes; the word's offsets fade in over its bytes, in the header's row, `low byte` left of the first and `high byte` right of the last, outside the run; then the bytes themselves fly, the low byte first, one at a time (24 f each, 18 f apart: the next lifts as one comes down, so none crosses another): straight up to 40 over the row, clear of the offsets, over, and straight down onto their pair's place in the word's field, 30 apart and ranged right, so that they land reversed; each bright and bold in the air on its own ground, its offset riding over it and landing over it; a label goes as its byte lifts (`high byte` as the byte that lands under it lifts) and comes back on the far side as it lands; a faint copy fades into each one's place in the dump once it has left: no row of memory is crossed or printed over; the gaps close to sixteen digits (12 f), the offsets and labels going with them; the zeros in front are bracketed, `zeros in front` on a ground only as wide as its label, and fade (12 f). At a run (the other fifteen): each row's word fades in (8 f) as its bytes dim, rows 6 f apart, each written as the stack will write it (an address bare, a number as [`value`](#value) writes it). The word field is eight pairs wide, so a word is always ranged right, its low byte last |
| `ink` | a word becoming an address | its digits go from primary to its region's ink (12 f), and the band it points into in `segments` is framed as read inside its box, with the band's row of names (6 f): an echo, no line. The first walked, held 60 f; the rest at a run, 2 f apart, each band framed 12 f |
| `enlarge` | a box of `segments`, out of its line on the whole | 0 to 6 the cluster's line on the whole framed bright; 6 to 78, `glide`, the box rides out along the magnification: its left corners travel the two lines from the line to their places, the lines drawn behind them, the box as tall as they are apart and as wide as the ride is far (the bar's 20 to its 180), its bands drawn at its scale all the way (a mapping a 2-unit line until it is taller; the gaps opening); 78 to 90 its page lines fade in and the frame on the line goes; then its names, rows top down, 2 f apart: an edge's leader draws from the box (6 f), then its address fades in (12 f); a band's row fades in (12 f). The clusters in address order, each riding out as the one before lands ([chart](motion.md#the-address-space-enlarged)) |
| `column` | rows gaining a column (offsets, roles, pins, lines) | the rows make room (18 f, as rows do), then the column's values fade in top down, 2 f apart, 12 f each |
@@ -2370,15 +2392,15 @@ python3 -B column.py # 49 to 55 (the same)
| [27](mock/27-pair-store.png) | one turn of the loop, row by row: plain's eight instructions each facing its counterpart among ASan's seventeen | `only here` bars; the page facing the check; the check's values (`0 : 0 ZF`, `taken`); the partial check and the report's call faint, off the path at 00; under each, its `buf` as bytes, the turn's one byte struck and the reading a letter longer, ASan's shadow framed as read |
| [28](mock/28-pair-part.png) | i = 16, the step in which they part | plain's store struck on the saved rbp's first byte, `41` among its stack-ink bytes, its reading `→ 7fffffffed41`; ASan's shadow load framed reading `f3`, its compare and the branch not taken, its redzone still `00`; `differs` on the facing rows |
| [38](mock/38-pair-ret.png) | i = 27, plain alone: the return address half overwritten; the ASan scene's poster | the saved rbp all letters, reading `0x4141414141414141`; the return address `41 41 41 41 00 00 00 00`, held on three bytes and struck on the fourth, reading `0x41414141`, no arrow, no name; ASan stopped: its disassembly down to `call __asan_report_store1`, `never returned`; its stderr panel, the report's lines cut at the edge, four framed; its frame's last picture |
-| [29](mock/29-intro-bytes.png) | the introduction's first picture, the camera at x2: 128 bytes of the stack, nothing else | a raw hexdump, before any ink |
+| [29](mock/29-intro-bytes.png) | the introduction's first picture, the camera at x2: 128 bytes, nothing else | a raw hexdump, before any ink, its header naming only what is shown (`128 bytes at 7fffffffece0`) |
| [30](mock/30-intro-words.png) | the `ink` beat: the words, eight bytes a row, where the stack will be; the address space in the program column | `regroup` landed, each word ranged right; `segments` at 108 wide, no pins; a dump's place, the `link` standing; `ink`'s echo: the return address and list's code band, with its row |
-| [31](mock/31-intro-stack.png) | the same words as the stack panel, the registers built over it, at x1.25 | the stack's conventions: rsp and rbp pins, offsets, roles, spans |
+| [31](mock/31-intro-stack.png) | the same words as the stack panel, the registers built over it, at x1.25 | the stack's conventions: rsp and rbp pins, offsets (the introduction's, `0x` from 0x10 up), roles (`the way back` on a return address), spans |
| [32](mock/32-intro-code.png) | the code chapter: `aligned` with each instruction's bytes between its address and mnemonic | an instruction as bytes, decoded, level with its line |
| [33](mock/33-aligned.png) | the `aligned` split, `interleaved`: reverse and its neighbours, the pc at the load | a line with two runs (20), lines with no code, rows of no line, the band as the thread |
| [34](mock/34-segments.png) | `segments` as a frame, treatment A: the list recording's mappings (`ztrace show`) | the whole with its ends and size; three boxes; the program by segment under its bracket, every other file once; addresses at the edges, sizes, permissions in a row or inside a band; leaders pooled; rsp and rip |
| [35](mock/35-segments-abc.png) | the three treatments as frames, saying less and less | A as 34; B every file once; C the whole alone |
| [36](mock/36-aligned-columns.png) | the `aligned` split, `columns`, on 33's data and `_init` after it | the seam after the longest line; places at each column's start; line 20's cell eight rows tall; its second run; lines 23 to 25 with no code; rows of no line; the pc's wash across both columns |
-| [37](mock/37-regroup.png) | `regroup` walked on the return address, `b0 18 00 01 00 00 00 00`: eight instants with their frames | the reflow to eight a row; the offsets and the low and high byte; the flight on nested arcs; landed reversed; the gaps closed; the zeros gone; the run; the ink |
+| [37](mock/37-regroup.png) | `regroup` walked on the return address, `b0 18 00 01 00 00 00 00`: eight instants with their frames | the reflow to eight a row; the offsets over the row, the low and high byte beside them; the flight one at a time over the offsets, the landed offsets over their pairs; landed reversed; the gaps closed; the zeros gone; the run, the numbers as `value` writes them; the ink |
| [1](mock/01-fib-recursion.png) | first pass | `calls` at camera scale |
| [2](mock/02-list-insert.png) | first pass | `nodes` at camera scale; `allocated` |
| [3](mock/03-syscall-write.png) | first pass | `syscalls`; `kernel` (the kernel's side is now the descent's floor, 16) |
@@ -2666,7 +2688,7 @@ is not checked here. The tokens are under [Token changes](#token-changes).
for it: the ASan pair and the introduction.
16. **The carry** ([`carry`](#4-ties)), a scene's knob `carry` (`.off`,
- the default; `.arrow`; `.value` for the introduction's one walked load):
+ the default; `.arrow`; `.value` for a walked load; `.after_touch` for the introduction's push):
2 units in primary, an open chevron, the gutter's right lane, from the
source's read to the destination's strike; with `tied`, a load's touch
withdrawing as its carry leaves the word, a store drawing its carry and
@@ -2769,9 +2791,9 @@ and `metric.bytes` and `metric.slot`'s new columns are in, as asked.
| `time.descend` | none | `close` 0.20 then 0.30 (`glide`), `ring` 0.20, `lane` 0.30, `head` 0.20, `rows` 0.20 a row 0.03 apart, from 1.10 after the fire, the given-up rows fading before the kept glide, never both; from 1.80 after the fire once the push is in cause order (touch, word, rsp's pin, the window following); the step 3.60 |
| `time.cross` | none | the registers framed 0.10 apart from 0.30; `lane` 0.40 from 0.80; the kernel's window 0.20; the answer up 0.40; the step 3.60, 4.90 when it moves bytes |
| `time.ascend` | none | `close` 0.20 a row, 0.03 apart, from 1.60 (after the touch, the read, rsp's pin falling and the window following); the lane back 0.20; the caller's kept rows 0.30 (`glide`), then the given-back rows 0.20; the step 3.30 |
-| `metric.segments` | none | the whole 20 wide, the stage's height, its labels 12 left of it; a box 180 wide (108 in a column of 880), framed 2 out, 48 apart; bands 30% over the page, named from 6 tall, permissions inside from 28; the names 64 past the box, rows 24, a band's row indented 24, sizes ranged right 132 in, files at 252 on a bracket at 240; leaders 8 out, 20 short, 12 in; the magnification 2 `rule`; a dump's place: its link 3 in the stack's ink over y 56, standing at 60% toward the page |
+| `metric.segments` | none | the whole 20 wide, the stage's height, its labels 12 left of it; a box 180 wide (108 in a column of 880), framed 2 out, 48 apart; bands 30% over the page, named from 6 tall, permissions inside from 28; the names 64 past the box, rows 24, a band's row indented 24, sizes ranged right 132 in, files at 252 on a bracket at 240; leaders 8 out, 20 short, 12 in; the magnification 2 `rule`; a dump's place: its link 3 in the stack's ink over y 56, standing at 60% toward the page; for a visit, a 2-unit tick across the box and its size in Go 20, the stack's ink |
| `time.enlarge` | none | the line framed 0.10; the ride 1.20 (`glide`); page lines 0.20; names 0.20 each, 0.033 apart, a leader 0.10 before its address; the next cluster as one lands |
-| `time.regroup` | none | rows making room 0.30, down 0.20, left 0.30; veil 0.30; offsets 0.20 each, 0.033 apart; a byte's flight 0.60, 0.10 apart; the gaps 0.20; the zeros 0.20; at a run a word 0.133, rows 0.10 apart |
+| `time.regroup` | none | the rows in 0.30 each, 0.30 apart; rows making room 0.30, down 0.20, left 0.30; veil 0.30; offsets 0.20 each, 0.033 apart; a byte's flight 0.40, 0.30 apart (one in the air at a time), 40 over its row, its offset 22 over it; the gaps 0.20; the zeros 0.20; at a run a word 0.133, rows 0.10 apart; the dump's fold 0.40 and 0.40 |
| `insn.annotation` | none (the chain always) | `tied` (the default) or `whole`, a scene's, settable per beat |
| `metric.slot.offset` | from rsp | from the frame's base (the CFA's register at the newest frame's pc) under `tied`; the tag's note names it; a change of base crossfades 0.20 |
| `metric.touch` | none | 2, in the mark's colour; the gutter's middle lane at 956; a head 7 by 8 on the stack's rule (on its right rule, pointing left, in the column); corners 6 |
@@ -2780,10 +2802,10 @@ and `metric.bytes` and `metric.slot`'s new columns are in, as asked.
| `time.sp_travel` | `time.pin` (24 f, 2 f a row, 36 at most) for every pin | rsp's and rbp's: 0.40, 0.10 a further row, 0.80 at most (`glide`); the amount's crossfade 0.20 at the advance; a row's gain or release 0.20; at a run 0.13, 0.03 a row, 0.27 at most |
| `time.follow` | none | after the landing: 0.40, 0.03 a further slot, 0.60 at most (`glide`) |
| `metric.carry`, `time.carry` | none | 2 in primary, an open chevron 7 by 8 in two strokes; the gutter's right lane, 962; the source's read 0.10, the arrow 0.30 (0.40 past eight rows), the destination's arm 0.20 and strike, back 0.30 with it; `carry = .value`: a chip of `raised`, mono 20, on the head |
-| `metric.aim`, `time.aim` | none | 2 in code's ink, a filled head 7 by 8 on the disassembly's right rule, the row's address framed 2 in code's ink; the gutter's left lane, 950; 0.30 (0.40 past ten rows), `standard`; a new row 0.40 (`glide`); fraying: dashed 0.20, out 0.30; standing at 60% |
+| `metric.aim`, `time.aim` | none | 2 in code's ink, a filled head 10 by 10 on the disassembly's right rule, the row's address framed 2 in code's ink; the gutter's left lane, 950; 0.30 (0.40 past ten rows), `standard`; a new row 0.40 (`glide`); fraying: dashed 0.20, out 0.30; standing at 60% |
| `relations` | each kind its own | the kinds' table ([ties](#4-ties)); the budget: the thread, two active, one standing across panes; the pass within 1 ms on the map |
| `metric.column` | none | the panes at 64 and the text at 976, 880 each; the shelf at 48, 24 high, its tags 12 apart; the panes from 84, narrated rows above 888, the floor to 1032; the clock under the text column at 900 |
-| `metric.bubble` | none | Go 40 on 54, code mono 35; 40 characters and three lines at most; padding 16, 812 wide at most; the newest on `raised`, older ones `dim` and bare; three at most; 12 between bubbles; the stem 2 in `dim`, a head 7 by 8 |
+| `metric.bubble` | none | Go 40 on 54, code mono 35; 40 characters and three lines at most (80 and two `above` a subject across both columns); padding 16, 812 wide at most; the newest on `raised`, older ones `dim` and bare; three at most; 12 between bubbles; the stem 2 in `dim`, a head 7 by 8 |
| `time.bubble` | none | in 0.30 rising 8 (`enter`), out 0.20; dim 0.30; out of the newest's way 0.40 (`glide`); the stem 0.20 in with the bubble, 0.20 back with the fire; between beats: fold 0.20 then 0.40 (the panel closing as its tag travels to the shelf), the stayers 0.40, unfold 0.40 (the tag back as the panel opens) then 0.20 |
| `metric.aligned` | `interleaved` only | `columns`: the seam 48 after the longest line in the window; each column's place ranged right 132 into it, its text 24 after; a line's first row `raised` |
diff --git a/design/mock/29-intro-bytes.png b/design/mock/29-intro-bytes.png
index e382abe..3d6c1a9 100644
--- a/design/mock/29-intro-bytes.png
+++ b/design/mock/29-intro-bytes.png
Binary files differ
diff --git a/design/mock/29-intro-bytes.svg b/design/mock/29-intro-bytes.svg
index fcd07cc..e9fad54 100644
--- a/design/mock/29-intro-bytes.svg
+++ b/design/mock/29-intro-bytes.svg
@@ -2,7 +2,7 @@
<defs><pattern id="hatch" width="20" height="20" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><rect width="5" height="20" fill="#3a4a8a"/></pattern><pattern id="hazard" width="24" height="24" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><rect width="24" height="24" fill="#050a24"/><rect width="12" height="24" fill="#ff6a4a"/></pattern></defs>
<rect width="1920" height="1080" fill="#0a1030"/>
<g transform="translate(300,170) scale(2)">
-<text x="0.0" y="-10.0" font-family="Go" font-size="18" fill="#6a7ab8" xml:space="preserve">128 bytes, from where rsp points</text>
+<text x="0.0" y="-10.0" font-family="Go" font-size="18" fill="#6a7ab8" xml:space="preserve">128 bytes at 7fffffffece0</text>
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffece0</text>
<text x="156.0 168.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
<text x="186.0 198.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">ed</text>
@@ -140,6 +140,6 @@
<text x="588.0 600.0" y="187.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
<text x="618.0 630.0" y="187.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
</g>
-<text x="64.0" y="964.0" font-size="40" xml:space="preserve"><tspan font-family="Go" font-weight="normal" fill="#eee6d2">A running program is bytes in memory.</tspan></text>
-<text x="64.0" y="1018.0" font-size="40" xml:space="preserve"><tspan font-family="Go" font-weight="normal" fill="#eee6d2">These are 128 of them, sixteen to a row.</tspan></text>
+<text x="64.0" y="964.0" font-size="40" xml:space="preserve"><tspan font-family="Go" font-weight="normal" fill="#eee6d2">A running program is bytes in memory:</tspan></text>
+<text x="64.0" y="1018.0" font-size="40" xml:space="preserve"><tspan font-family="Go" font-weight="normal" fill="#eee6d2">here are 128 of them.</tspan></text>
</svg>
diff --git a/design/mock/30-intro-words-480.png b/design/mock/30-intro-words-480.png
index 4f4c1b4..c1768f9 100644
--- a/design/mock/30-intro-words-480.png
+++ b/design/mock/30-intro-words-480.png
Binary files differ
diff --git a/design/mock/30-intro-words.png b/design/mock/30-intro-words.png
index d4a29db..1abc71b 100644
--- a/design/mock/30-intro-words.png
+++ b/design/mock/30-intro-words.png
Binary files differ
diff --git a/design/mock/30-intro-words.svg b/design/mock/30-intro-words.svg
index 37708fc..63b0416 100644
--- a/design/mock/30-intro-words.svg
+++ b/design/mock/30-intro-words.svg
@@ -190,7 +190,7 @@
<text x="1354.0 1366.0" y="291.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="1384.0 1396.0" y="291.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="1414.0 1426.0" y="291.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
-<text x="1600.0 1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0" y="291.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">1f7fbe000</text>
+<text x="1576.0 1588.0 1600.0 1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0" y="291.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">0x1f7fbe000</text>
<text x="1048.0 1060.0 1072.0 1084.0 1096.0 1108.0 1120.0 1132.0 1144.0 1156.0 1168.0 1180.0" y="315.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">7fffffffed28</text>
<text x="1204.0 1216.0" y="315.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">60</text>
<text x="1234.0 1246.0" y="315.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">18</text>
@@ -240,7 +240,7 @@
<text x="1354.0 1366.0" y="411.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">35</text>
<text x="1384.0 1396.0" y="411.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">e3</text>
<text x="1414.0 1426.0" y="411.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">1f</text>
-<text x="1516.0 1528.0 1540.0 1552.0 1564.0 1576.0 1588.0 1600.0 1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0" y="411.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">1fe335fc95a5781c</text>
+<text x="1492.0 1504.0 1516.0 1528.0 1540.0 1552.0 1564.0 1576.0 1588.0 1600.0 1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0" y="411.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">0x1fe335fc95a5781c</text>
<text x="1048.0 1060.0 1072.0 1084.0 1096.0 1108.0 1120.0 1132.0 1144.0 1156.0 1168.0 1180.0" y="435.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">7fffffffed50</text>
<text x="1204.0 1216.0" y="435.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">38</text>
<text x="1234.0 1246.0" y="435.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">ee</text>
diff --git a/design/mock/31-intro-stack.png b/design/mock/31-intro-stack.png
index a85abd2..69ea78c 100644
--- a/design/mock/31-intro-stack.png
+++ b/design/mock/31-intro-stack.png
Binary files differ
diff --git a/design/mock/31-intro-stack.svg b/design/mock/31-intro-stack.svg
index e3eadcd..7eb286a 100644
--- a/design/mock/31-intro-stack.svg
+++ b/design/mock/31-intro-stack.svg
@@ -133,26 +133,27 @@
<rect x="1518.0" y="706.0" width="3.0" height="3.0" fill="#6a7ab8"/>
<rect x="1526.0" y="706.0" width="3.0" height="3.0" fill="#6a7ab8"/>
<text x="1124.0 1136.0" y="735.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+8</text>
+<text x="1576.0 1588.0 1600.0 1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0 1708.0" y="735.2" font-family="JetBrains Mono NL" font-size="20" fill="#9aa6d9" xml:space="preserve" font-weight="500">the way back</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="735.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="735.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">ce8</text>
<rect x="1310.0" y="727.0" width="11.0" height="2.0" fill="#6a7ab8"/>
<path d="M1328,728 l-8,-5 v10 Z" fill="#6a7ab8"/>
<text x="1334.0 1346.0 1358.0 1370.0 1382.0 1394.0 1406.0" y="735.2" font-family="JetBrains Mono NL" font-size="20" fill="#ff8f9a" xml:space="preserve" font-weight="500">10018b0</text>
<text x="1428.0 1440.0 1452.0 1464.0 1476.0 1488.0 1500.0" y="735.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">main+80</text>
-<text x="1112.0 1124.0 1136.0" y="759.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+10</text>
+<text x="1088.0 1100.0 1112.0 1124.0 1136.0" y="759.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0x10</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="759.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="759.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">cf0</text>
<rect x="1310.0" y="751.0" width="11.0" height="2.0" fill="#6a7ab8"/>
<path d="M1328,752 l-8,-5 v10 Z" fill="#6a7ab8"/>
<text x="1334.0 1346.0 1358.0 1370.0 1382.0 1394.0 1406.0 1418.0 1430.0 1442.0 1454.0 1466.0" y="759.2" font-family="JetBrains Mono NL" font-size="20" fill="#d59cf5" xml:space="preserve" font-weight="500">7ffff7e20de8</text>
-<text x="1112.0 1124.0 1136.0" y="783.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+18</text>
+<text x="1088.0 1100.0 1112.0 1124.0 1136.0" y="783.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0x18</text>
<text x="1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0 1708.0" y="783.2" font-family="JetBrains Mono NL" font-size="20" fill="#9aa6d9" xml:space="preserve" font-weight="500">saved rbx</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="783.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="783.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">cf8</text>
<path d="M1310,776 l8,-5 v10 Z" fill="#6a7ab8"/>
<rect x="1317.0" y="775.0" width="11.0" height="2.0" fill="#6a7ab8"/>
<text x="1334.0" y="783.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">0</text>
-<text x="1112.0 1124.0 1136.0" y="807.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+20</text>
+<text x="1088.0 1100.0 1112.0 1124.0 1136.0" y="807.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0x20</text>
<text x="1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0 1708.0" y="807.2" font-family="JetBrains Mono NL" font-size="20" fill="#9aa6d9" xml:space="preserve" font-weight="500">saved rbp</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="807.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="807.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">d00</text>
@@ -164,21 +165,21 @@
<rect x="1510.0" y="802.0" width="3.0" height="3.0" fill="#6a7ab8"/>
<rect x="1518.0" y="802.0" width="3.0" height="3.0" fill="#6a7ab8"/>
<rect x="1526.0" y="802.0" width="3.0" height="3.0" fill="#6a7ab8"/>
-<text x="1112.0 1124.0 1136.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+28</text>
+<text x="1088.0 1100.0 1112.0 1124.0 1136.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0x28</text>
+<text x="1576.0 1588.0 1600.0 1612.0 1624.0 1636.0 1648.0 1660.0 1672.0 1684.0 1696.0 1708.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#9aa6d9" xml:space="preserve" font-weight="500">the way back</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">d08</text>
<rect x="1310.0" y="823.0" width="11.0" height="2.0" fill="#6a7ab8"/>
<path d="M1328,824 l-8,-5 v10 Z" fill="#6a7ab8"/>
<text x="1334.0 1346.0 1358.0 1370.0 1382.0 1394.0 1406.0 1418.0 1430.0 1442.0 1454.0 1466.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#ff8f9a" xml:space="preserve" font-weight="500">7ffff7c27781</text>
-<text x="1488.0 1500.0 1512.0 1524.0 1536.0 1548.0 1560.0 1572.0 1584.0 1596.0" y="831.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">libc+27781</text>
-<text x="1112.0 1124.0 1136.0" y="855.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+30</text>
+<text x="1088.0 1100.0 1112.0 1124.0 1136.0" y="855.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0x30</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="855.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="855.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">d10</text>
<rect x="1310.0" y="847.0" width="11.0" height="2.0" fill="#6a7ab8"/>
<path d="M1328,848 l-8,-5 v10 Z" fill="#6a7ab8"/>
<text x="1334.0 1346.0 1358.0 1370.0 1382.0 1394.0 1406.0 1418.0 1430.0 1442.0 1454.0 1466.0" y="855.2" font-family="JetBrains Mono NL" font-size="20" fill="#ff8f9a" xml:space="preserve" font-weight="500">7ffff7fe0c60</text>
<text x="1488.0 1500.0 1512.0 1524.0 1536.0 1548.0 1560.0 1572.0 1584.0 1596.0 1608.0" y="855.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">ld.so+22c60</text>
-<text x="1112.0 1124.0 1136.0" y="879.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+38</text>
+<text x="1088.0 1100.0 1112.0 1124.0 1136.0" y="879.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0x38</text>
<text x="1160.0 1172.0 1184.0 1196.0 1208.0 1220.0 1232.0 1244.0 1256.0" y="879.2" font-family="JetBrains Mono NL" font-size="20" fill="#958759" xml:space="preserve" font-weight="500">7fffffffe</text>
<text x="1268.0 1280.0 1292.0" y="879.2" font-family="JetBrains Mono NL" font-size="20" fill="#f2d675" xml:space="preserve" font-weight="500">d18</text>
<rect x="1310.0" y="871.0" width="11.0" height="2.0" fill="#6a7ab8"/>
diff --git a/design/mock/37-regroup.png b/design/mock/37-regroup.png
index b984d76..b1a23a1 100644
--- a/design/mock/37-regroup.png
+++ b/design/mock/37-regroup.png
Binary files differ
diff --git a/design/mock/37-regroup.svg b/design/mock/37-regroup.svg
index d500058..0737821 100644
--- a/design/mock/37-regroup.svg
+++ b/design/mock/37-regroup.svg
@@ -28,98 +28,101 @@
<text x="990.0" y="56.0" font-family="Go" font-size="26" fill="#e8c46a" xml:space="preserve" font-weight="bold">2</text>
<text x="1020.0" y="56.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">which byte is which</text>
<text x="1252.7 1264.7 1276.7 1288.7 1300.7 1312.7 1324.7 1336.7 1348.7 1360.7" y="56.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 66 to 96</text>
-<text x="1020.0" y="82.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">its offsets under it; the low byte is the first in memory</text>
+<text x="1020.0" y="82.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">its offsets over it, in the header's row; the low byte is the first</text>
<g transform="translate(1000,250) scale(1.25)">
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffece8</text>
<text x="156.0 168.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">b0</text>
+<text x="156.0 168.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0</text>
<text x="186.0 198.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">18</text>
+<text x="186.0 198.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+1</text>
<text x="216.0 228.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="216.0 228.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+2</text>
<text x="246.0 258.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">01</text>
+<text x="246.0 258.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+3</text>
<text x="276.0 288.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="276.0 288.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+4</text>
<text x="306.0 318.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="306.0 318.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+5</text>
<text x="336.0 348.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="336.0 348.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+6</text>
<text x="366.0 378.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="156.0 168.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0</text>
-<text x="186.0 198.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+1</text>
-<text x="216.0 228.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+2</text>
-<text x="246.0 258.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+3</text>
-<text x="276.0 288.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+4</text>
-<text x="306.0 318.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+5</text>
-<text x="336.0 348.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+6</text>
-<text x="366.0 378.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+7</text>
-<text x="168.0" y="64.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="middle">low byte</text>
-<text x="378.0" y="64.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="middle">high byte</text>
+<text x="366.0 378.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+7</text>
+<text x="150.0" y="-4.8" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="end">low byte</text>
+<text x="396.0" y="-4.8" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">high byte</text>
</g>
<text x="40.0" y="426.0" font-family="Go" font-size="26" fill="#e8c46a" xml:space="preserve" font-weight="bold">3</text>
-<text x="70.0" y="426.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">in flight, the low byte first</text>
-<text x="366.2 378.2 390.2 402.2 414.2" y="426.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 138</text>
-<text x="70.0" y="452.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">6 f apart, 36 f each, on nested arcs; a faint copy stays</text>
+<text x="70.0" y="426.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">in flight, one at a time</text>
+<text x="326.1 338.1 350.1 362.1 374.1" y="426.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 174</text>
+<text x="70.0" y="452.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">the low byte first, 24 f each, 18 f apart, 40 over the offsets</text>
<g transform="translate(50,620) scale(1.25)">
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffece8</text>
<text x="156.0 168.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">b0</text>
+<text x="636.0 648.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">b0</text>
+<text x="636.0 648.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0</text>
<text x="186.0 198.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">18</text>
+<text x="606.0 618.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">18</text>
+<text x="606.0 618.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+1</text>
<text x="216.0 228.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
+<text x="576.0 588.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="576.0 588.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+2</text>
<text x="246.0 258.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">01</text>
+<path d="M258.2,-5.6 L258.9,-10.4 L260.0,-15.0 L261.6,-19.1 L263.7,-22.5 L266.4,-25.0 L269.5,-26.7 L273.3,-27.7 L277.6,-28.0 L282.5,-28.0 L288.0,-28.0 L294.0,-28.0 L300.7,-28.0 L308.1,-28.0 L316.0,-28.0 L324.4,-28.0 L333.5,-28.0 L343.0,-28.0 L353.1,-28.0 L363.5,-28.0 L374.3,-28.0 L385.4,-28.0 L396.7,-28.0 L408.0,-28.0 L419.3,-28.0 L430.6,-28.0 L441.7,-28.0 L452.5,-28.0 L462.9,-28.0 L473.0,-28.0 L482.5,-28.0 L491.6,-28.0 L500.0,-28.0 L507.9,-28.0 L515.3,-28.0 L522.0,-28.0 L528.0,-28.0 L533.5,-28.0 L538.4,-28.0 L542.7,-27.7 L546.5,-26.7 L549.6,-25.0 L552.3,-22.5 L554.4,-19.1 L556.0,-15.0 L557.1,-10.4 L557.8,-5.6" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
+<rect x="393.0" y="-37.8" width="30.0" height="20.0" fill="#0a1030"/>
+<text x="396.0 408.0" y="-20.8" font-family="JetBrains Mono NL" font-size="20" fill="#fff8e8" xml:space="preserve" font-weight="bold">01</text>
+<text x="396.0 408.0" y="-42.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+3</text>
+<text x="276.0 288.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="276.0 288.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+4</text>
<text x="306.0 318.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="306.0 318.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+5</text>
<text x="336.0 348.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
+<text x="336.0 348.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+6</text>
<text x="366.0 378.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="306.0 318.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+5</text>
-<text x="336.0 348.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+6</text>
-<text x="366.0 378.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+7</text>
-<text x="378.0" y="64.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="middle">high byte</text>
-<path d="M171.5,-10.8 L174.1,-17.9 L177.4,-24.7 L181.4,-31.2 L186.1,-37.5 L191.3,-43.5 L197.2,-49.2 L203.6,-54.7 L210.5,-59.9 L217.9,-64.8 L225.8,-69.5 L234.2,-73.9 L243.0,-78.0 L252.2,-81.9 L261.8,-85.5 L271.7,-88.8 L281.9,-91.9 L292.4,-94.7 L303.2,-97.2 L314.3,-99.5 L325.5,-101.5 L337.0,-103.2 L348.6,-104.7 L360.3,-105.9 L372.1,-106.8 L384.0,-107.5 L396.0,-107.9 L408.0,-108.0 L420.0,-107.9 L432.0,-107.5 L443.9,-106.8 L455.7,-105.9 L467.4,-104.7 L479.0,-103.2 L490.5,-101.5 L501.7,-99.5 L512.8,-97.2 L523.6,-94.7 L534.1,-91.9 L544.3,-88.8 L554.2,-85.5 L563.8,-81.9 L573.0,-78.0 L581.8,-73.9 L590.2,-69.5 L598.1,-64.8 L605.5,-59.9 L612.4,-54.7 L618.8,-49.2 L624.7,-43.5 L629.9,-37.5 L634.6,-31.2" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<text x="632.4 644.4" y="-4.0" font-family="JetBrains Mono NL" font-size="20" fill="#fff8e8" xml:space="preserve" font-weight="bold">b0</text>
-<path d="M201.0,-7.9 L203.4,-14.1 L206.3,-20.1 L209.8,-25.8 L213.8,-31.3 L218.4,-36.5 L223.5,-41.5 L229.1,-46.3 L235.2,-50.9 L241.7,-55.2 L248.6,-59.3 L255.9,-63.1 L263.6,-66.8 L271.7,-70.1 L280.0,-73.3 L288.7,-76.2 L297.7,-78.9 L306.9,-81.3 L316.3,-83.5 L326.0,-85.5 L335.8,-87.3 L345.8,-88.8 L356.0,-90.1 L366.2,-91.1 L376.6,-92.0 L387.0,-92.5 L397.5,-92.9 L408.0,-93.0 L418.5,-92.9 L429.0,-92.5 L439.4,-91.9 L449.8,-91.1 L460.0,-90.1 L470.2,-88.8 L480.2,-87.3 L490.0,-85.5 L499.7,-83.5 L509.1,-81.3 L518.3,-78.9 L527.3,-76.2 L536.0,-73.3" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<path d="M592.5,-41.6 L597.6,-36.5 L602.2,-31.3 L606.2,-25.8 L609.7,-20.1 L612.6,-14.1 L615.0,-8.0" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<text x="553.3 565.3" y="-53.2" font-family="JetBrains Mono NL" font-size="20" fill="#fff8e8" xml:space="preserve" font-weight="bold">18</text>
-<path d="M230.6,-5.1 L232.6,-10.4 L235.1,-15.5 L238.1,-20.4 L241.6,-25.1 L245.5,-29.6 L249.9,-33.9 L254.7,-38.0 L259.9,-41.9 L265.4,-45.6 L271.4,-49.1 L277.7,-52.4 L284.2,-55.5 L291.1,-58.4 L298.3,-61.1 L305.8,-63.6 L313.4,-65.9 L321.3,-68.0 L329.4,-69.9 L337.7,-71.6 L346.1,-73.1 L354.7,-74.4 L363.4,-75.5 L372.2,-76.4 L381.1,-77.1" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<path d="M434.9,-77.1 L443.8,-76.4 L452.6,-75.5 L461.3,-74.4 L469.9,-73.1 L478.3,-71.6 L486.6,-69.9 L494.7,-68.0 L502.6,-65.9 L510.2,-63.6 L517.7,-61.1 L524.9,-58.4 L531.8,-55.5 L538.3,-52.4 L544.6,-49.1 L550.6,-45.6 L556.1,-41.9 L561.3,-38.0 L566.1,-33.9 L570.5,-29.6 L574.4,-25.1 L577.9,-20.4 L580.9,-15.5 L583.4,-10.4 L585.4,-5.1" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<text x="396.0 408.0" y="-70.8" font-family="JetBrains Mono NL" font-size="20" fill="#fff8e8" xml:space="preserve" font-weight="bold">00</text>
-<path d="M261.8,-6.7 L263.9,-10.9 L266.4,-15.0 L269.3,-18.9 L272.6,-22.7" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<path d="M322.8,-51.0 L329.2,-52.9 L335.8,-54.7 L342.5,-56.2 L349.4,-57.7 L356.5,-58.9 L363.6,-60.0 L370.8,-60.9 L378.2,-61.7 L385.6,-62.2 L393.0,-62.7 L400.5,-62.9 L408.0,-63.0 L415.5,-62.9 L423.0,-62.7 L430.4,-62.2 L437.8,-61.7 L445.2,-60.9 L452.4,-60.0 L459.5,-58.9 L466.6,-57.7 L473.5,-56.2 L480.2,-54.7 L486.8,-52.9 L493.2,-51.0 L499.4,-48.9 L505.4,-46.7 L511.1,-44.2 L516.6,-41.7 L521.9,-38.9 L526.8,-36.0 L531.4,-32.9 L535.8,-29.7 L539.8,-26.3 L543.4,-22.7 L546.7,-18.9 L549.6,-15.0 L552.1,-10.9 L554.2,-6.7" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<text x="283.6 295.6" y="-32.5" font-family="JetBrains Mono NL" font-size="20" fill="#fff8e8" xml:space="preserve" font-weight="bold">01</text>
-<path d="M299.7,-15.7 L302.6,-18.6 L305.8,-21.3 L309.2,-23.9 L313.0,-26.4 L316.9,-28.7 L321.1,-30.9 L325.5,-33.0 L330.1,-34.9 L334.9,-36.7 L339.8,-38.4 L345.0,-39.9 L350.2,-41.3 L355.6,-42.6 L361.1,-43.7 L366.8,-44.7 L372.5,-45.6 L378.3,-46.3 L384.1,-46.9 L390.1,-47.4 L396.0,-47.7 L402.0,-47.9 L408.0,-48.0 L414.0,-47.9 L420.0,-47.7 L425.9,-47.4 L431.9,-46.9 L437.7,-46.3 L443.5,-45.6 L449.2,-44.7 L454.9,-43.7 L460.4,-42.6 L465.8,-41.3 L471.0,-39.9 L476.2,-38.4 L481.1,-36.7 L485.9,-34.9 L490.5,-33.0 L494.9,-30.9 L499.1,-28.7 L503.0,-26.4 L506.8,-23.9 L510.2,-21.3 L513.4,-18.6 L516.3,-15.7 L519.0,-12.7 L521.3,-9.6 L523.3,-6.3" fill="none" stroke="#3a4a8a" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt" stroke-dasharray="12 8"/>
-<text x="277.8 289.8" y="7.6" font-family="JetBrains Mono NL" font-size="20" fill="#fff8e8" xml:space="preserve" font-weight="bold">00</text>
+<text x="366.0 378.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+7</text>
+<text x="666.0" y="-4.8" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">low byte</text>
+<text x="396.0" y="-4.8" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">high byte</text>
</g>
<text x="990.0" y="426.0" font-family="Go" font-size="26" fill="#e8c46a" xml:space="preserve" font-weight="bold">4</text>
<text x="1020.0" y="426.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">landed, reversed</text>
-<text x="1222.0 1234.0 1246.0 1258.0 1270.0" y="426.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 186</text>
-<text x="1020.0" y="452.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">the low byte last; each offset lands under its byte</text>
+<text x="1222.0 1234.0 1246.0 1258.0 1270.0" y="426.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 258</text>
+<text x="1020.0" y="452.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">the low byte last; each offset lands over its byte</text>
<g transform="translate(1000,620) scale(1.25)">
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffece8</text>
<text x="156.0 168.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">b0</text>
-<text x="186.0 198.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">18</text>
-<text x="216.0 228.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
-<text x="246.0 258.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">01</text>
-<text x="276.0 288.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
-<text x="306.0 318.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
-<text x="336.0 348.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
-<text x="366.0 378.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="636.0 648.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">b0</text>
-<text x="636.0 648.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0</text>
+<text x="636.0 648.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+0</text>
+<text x="186.0 198.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">18</text>
<text x="606.0 618.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">18</text>
-<text x="606.0 618.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+1</text>
+<text x="606.0 618.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+1</text>
+<text x="216.0 228.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="576.0 588.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="576.0 588.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+2</text>
+<text x="576.0 588.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+2</text>
+<text x="246.0 258.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">01</text>
<text x="546.0 558.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">01</text>
-<text x="546.0 558.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+3</text>
+<text x="546.0 558.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+3</text>
+<text x="276.0 288.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="516.0 528.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="516.0 528.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+4</text>
+<text x="516.0 528.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+4</text>
+<text x="306.0 318.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="486.0 498.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="486.0 498.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+5</text>
+<text x="486.0 498.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+5</text>
+<text x="336.0 348.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="456.0 468.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="456.0 468.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+6</text>
+<text x="456.0 468.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+6</text>
+<text x="366.0 378.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="426.0 438.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00</text>
-<text x="426.0 438.0" y="43.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+7</text>
-<text x="648.0" y="64.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="middle">low byte</text>
-<text x="438.0" y="64.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="middle">high byte</text>
+<text x="426.0 438.0" y="-4.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">+7</text>
+<text x="666.0" y="-4.8" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">low byte</text>
+<text x="420.0" y="-4.8" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="end">high byte</text>
</g>
<text x="40.0" y="796.0" font-family="Go" font-size="26" fill="#e8c46a" xml:space="preserve" font-weight="bold">5</text>
<text x="70.0" y="796.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">the spaces close</text>
-<text x="272.2 284.2 296.2 308.2 320.2" y="796.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 216</text>
+<text x="272.2 284.2 296.2 308.2 320.2" y="796.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 288</text>
<text x="70.0" y="822.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">sixteen digits, the same eight bytes</text>
<g transform="translate(50,990) scale(1.25)">
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffece8</text>
+<text x="468.0 480.0 492.0 504.0 516.0 528.0 540.0 552.0 564.0 576.0 588.0 600.0 612.0 624.0 636.0 648.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00000000010018b0</text>
+<path d="M469,16 v6 H575 v-6" fill="none" stroke="#6a7ab8" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt"/>
+<text x="468.0" y="46.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">zeros in front</text>
<text x="156.0 168.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">b0</text>
<text x="186.0 198.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">18</text>
<text x="216.0 228.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
@@ -128,13 +131,10 @@
<text x="306.0 318.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="336.0 348.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
<text x="366.0 378.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#7c7b81" xml:space="preserve" font-weight="500">00</text>
-<text x="468.0 480.0 492.0 504.0 516.0 528.0 540.0 552.0 564.0 576.0 588.0 600.0 612.0 624.0 636.0 648.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#eee6d2" xml:space="preserve" font-weight="500">00000000010018b0</text>
-<path d="M469,26 v6 H575 v-6" fill="none" stroke="#6a7ab8" stroke-width="2" stroke-linejoin="round" stroke-linecap="butt"/>
-<text x="522.0" y="54.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve" text-anchor="middle">zeros in front</text>
</g>
<text x="990.0" y="796.0" font-family="Go" font-size="26" fill="#e8c46a" xml:space="preserve" font-weight="bold">6</text>
<text x="1020.0" y="796.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">the zeros in front go</text>
-<text x="1257.9 1269.9 1281.9 1293.9 1305.9" y="796.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 240</text>
+<text x="1257.9 1269.9 1281.9 1293.9 1305.9" y="796.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 312</text>
<text x="1020.0" y="822.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">a word is written without them</text>
<g transform="translate(1000,990) scale(1.25)">
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="19.2" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffece8</text>
@@ -150,7 +150,7 @@
</g>
<text x="40.0" y="1166.0" font-family="Go" font-size="26" fill="#e8c46a" xml:space="preserve" font-weight="bold">7</text>
<text x="70.0" y="1166.0" font-family="Go Medium" font-size="24" fill="#eee6d2" xml:space="preserve">the other fifteen at a run</text>
-<text x="351.4 363.4 375.4 387.4 399.4 411.4 423.4 435.4 447.4 459.4 471.4 483.4" y="1166.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 288 to 386</text>
+<text x="351.4 363.4 375.4 387.4 399.4 411.4 423.4 435.4 447.4 459.4 471.4 483.4" y="1166.0" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve">f 360 to 458</text>
<text x="70.0" y="1192.0" font-family="Go" font-size="18" fill="#9aa6d9" xml:space="preserve">rows 6 f apart: each word fades in (8 f) as its bytes dim</text>
<g transform="translate(50,1360) scale(1.25)">
<text x="0.0 12.0 24.0 36.0 48.0 60.0 72.0 84.0 96.0 108.0 120.0 132.0" y="-28.8" font-family="JetBrains Mono NL" font-size="20" fill="#6a7ab8" xml:space="preserve" font-weight="500">7fffffffed30</text>
diff --git a/design/mock/context.py b/design/mock/context.py
index 5549d02..2e8b450 100644
--- a/design/mock/context.py
+++ b/design/mock/context.py
@@ -99,6 +99,7 @@ def held_cell(g, x, y, w, h, k=1):
MINIMAP = 0 # a pane with its own minimap: the frame this much wider than its content
+HEX0X = False # the introduction's offsets: `0x` from 0x10 up (`-8`, `+0x10`)
def tag(g, x, y, w, h, title, focus=False, note=None):
@@ -407,9 +408,10 @@ def stack(g, y, rows, frames, note=None, rsp=None, roles=None, touched=(), chain
ys.append(yy)
if pins:
pin(g, RX + 16, yy, pins, STACK)
- if rsp is not None: # the offset from rsp, pwndbg's way: +18
+ if rsp is not None: # the offset from rsp, pwndbg's way: +18 (the introduction's +0x18)
off = slot - rsp
- g.t(RX + 172, b(yy), ("+%x" % off) if off >= 0 else ("-%x" % -off), S, FAINT, MONO, "end")
+ p = "0x" if HEX0X and abs(off) >= 0x10 else ""
+ g.t(RX + 172, b(yy), ("+%s%x" % (p, off)) if off >= 0 else ("-%s%x" % (p, -off)), S, FAINT, MONO, "end")
end_x = room.get(i, RX + CW - 136)
if marks and marks[0].get("free"): # above rsp: not the stack's yet; its word faint, no chain
g.t(first, b(yy), "%x" % slot, S, mix(STACK, PAGE, 0.6), MONO)
diff --git a/design/mock/intro.py b/design/mock/intro.py
index 87d22bf..a35ddb3 100644
--- a/design/mock/intro.py
+++ b/design/mock/intro.py
@@ -290,6 +290,12 @@ def camera(g, k, cx, cy):
g.o.append(f'<g transform="translate({960 - cx * k},{468 - cy * k}) scale({k})">')
+def word_text(w):
+ """A word as the stack writes it: an address bare; a number as the `value` atom writes it (a digit, `0x` and its
+ hex; a small number's decimal is left out here, as none is in these words)."""
+ return "%x" % w if ink_of(w) or w < 10 else "0x%x" % w
+
+
def raw_dump(g, x, y, rows, per=16, words=False, inked=False):
"""The stack's bytes from rsp, `per` to a row; with words, each row's eight bytes read right to left as the
word they make, beside them, in the ink of what it points into when inked. Returns the rows' y."""
@@ -306,7 +312,7 @@ def raw_dump(g, x, y, rows, per=16, words=False, inked=False):
if words: # the word, ranged right in its field (its eight pairs as they land): low byte last
w_ = D.word(a0)
ink = (ink_of(w_) or VELLUM) if inked else VELLUM
- g.t(bx + per * 30 + 24 + 8 * 30, b(yy), "%x" % w_, S, ink, MONO, "end")
+ g.t(bx + per * 30 + 24 + 8 * 30, b(yy), word_text(w_), S, ink, MONO, "end")
return ys
@@ -315,11 +321,11 @@ def frame_bytes(name):
gen.W, gen.H = 1920, 1080
g = Svg()
g.o.append('<g transform="translate(300,170) scale(2)">')
- g.t(0, -10, "128 bytes, from where rsp points", 18, FAINT, "sans")
+ g.t(0, -10, "128 bytes at %x" % RSP, 18, FAINT, "sans") # nothing named before it is shown: no stack, no rsp
raw_dump(g, 0, 0, 8)
g.o.append("</g>")
- gen.caption(g, [[("A running program is bytes in memory.",)],
- [("These are 128 of them, sixteen to a row.",)]])
+ gen.caption(g, [[("A running program is bytes in memory:",)],
+ [("here are 128 of them.",)]])
g.save(name)
@@ -370,78 +376,68 @@ def glide(t):
return 3 * (1 - m) * m * m + m ** 3
-def flight(k, t, closed=False):
- """Where byte k is at t of its flight: straight up off its place, over on an arc a quarter as high as it is long
- (34 to 120), straight down onto its pair's place in the word, the pairs 30 apart as they land. Returns the
- byte's x and rise, its two ends and the arc's height; arc(k, u) is the path."""
- sx = BX + 30 * k
- ex = FR - (24 if closed else 30) * (k + 1) + (0 if closed else 6)
- h = min(max((ex - sx) / 4, 34), 120)
- x, y = arc(sx, ex, h, glide(t))
- return x, y, sx, ex, h
+LIFT, OFF_AIR = 40, 22 # a byte flies 40 over its row; its offset rides 22 over it
+
+def clamp01(x):
+ return min(max(x, 0.0), 1.0)
-def arc(sx, ex, h, u):
- """The cubic from (sx, 0) to (ex, 0) leaving and arriving upright, h high at its middle."""
- H = h / 0.75
- return sx + (ex - sx) * (3 * u * u - 2 * u ** 3), -3 * (1 - u) * u * H
+
+def flight(k, f):
+ """Byte k at frame f of the beat: one in the air at a time, 24 f each, 18 f apart, the low byte first (motion.md,
+ "A word read"). Straight up to 40 over the row (a quarter of the flight), over, straight down (the last quarter);
+ across on `glide` between a tenth and nine tenths of it. Returns its flight's progress, x and rise, and its ends."""
+ s = (f - 108 - 18 * k) / 24
+ sx, ex = BX + 30 * k, FR - 24 - 30 * k
+ u = clamp01(s)
+ x = sx + (ex - sx) * glide(clamp01((u - 0.1) / 0.8))
+ lift = LIFT * min(glide(clamp01(u / 0.25)), glide(clamp01((1 - u) / 0.25)))
+ return s, x, lift, sx, ex
def walk_row(g, y, state, f=0):
- """The walked row at frame f of the beat: state names the instant (see regroup_strip). The bytes themselves
- fly; each one's place in the dump takes a faint copy once it has left (from a third of its flight)."""
+ """The walked row at frame f of the beat: state names the instant (see regroup_strip). Its offsets stand over it,
+ in the header's row (the walked word is the dump's first); the bytes themselves fly over them, one at a time;
+ each one's place in the dump takes a faint copy once it has left (from a third of its flight)."""
vals = [D.MEM[WALK + k] for k in range(8)]
faint = mix(VELLUM, PAGE, 0.5)
C.addr(g, 0, y, WALK, STACK if state == "ink" else FAINT)
- t_ = lambda k: (f - 108 - 6 * k) / 36 if state == "flight" else (1 if state != "which" else 0)
- for k, v in enumerate(vals):
- t = t_(k)
- if t <= 0:
- g.t(BX + 30 * k, b(y), "%02x" % v, S, VELLUM, MONO)
- elif t >= 1 / 3:
- g.t(BX + 30 * k, b(y), "%02x" % v, S, faint, MONO)
- if state in ("which", "flight"):
- for k in range(8): # the offsets: where each byte is, under it
- if t_(k) <= 0:
- g.t(BX + 30 * k + 12, b(y + ROW), "+%d" % k, S, FAINT, MONO, "middle")
- if t_(0) <= 0:
- g.t(BX + 12, y + 2 * ROW + 16, "low byte", 18, DIM, "sans", "middle")
- if t_(7) <= 0:
- g.t(BX + 7 * 30 + 12, y + 2 * ROW + 16, "high byte", 18, DIM, "sans", "middle")
- if state == "flight":
- for k in range(8):
- t = t_(k)
- x, yy, sx, ex, h = flight(k, min(max(t, 0), 1))
- if 0 < t < 1: # the path, for the still only, broken round the byte
- pts = [(arc(sx, ex, h, u)[0] + 12, y + ROW / 2 + arc(sx, ex, h, u)[1]) for u in [i / 60 for i in range(61)]]
- seg = []
- for p in pts + [None]:
- if p is not None and p[1] < y - 4 and (abs(p[0] - x - 12) > 26 or abs(p[1] - (y + yy + ROW / 2)) > 16):
- seg.append(p)
- continue
- if len(seg) > 1:
- g.path("M" + " L".join("%.1f,%.1f" % q for q in seg), RULE, 2, dash="12 8")
- seg = []
- g.t(x, b(y + yy), "%02x" % vals[k], S, BRIGHT, BOLD)
- if t >= 1:
- g.t(ex, b(y), "%02x" % vals[k], S, VELLUM, MONO)
- g.t(ex + 12, b(y + ROW), "+%d" % k, S, FAINT, MONO, "middle")
- if t_(0) >= 1:
- g.t(FR - 12, y + 2 * ROW + 16, "low byte", 18, DIM, "sans", "middle")
- if state == "landed":
- for k in range(8):
- ex = FR - 30 * (k + 1) + 6
- g.t(ex, b(y), "%02x" % vals[k], S, VELLUM, MONO)
- g.t(ex + 12, b(y + ROW), "+%d" % k, S, FAINT, MONO, "middle")
- g.t(FR - 12, y + 2 * ROW + 16, "low byte", 18, DIM, "sans", "middle")
- g.t(FR - 234 + 12, y + 2 * ROW + 16, "high byte", 18, DIM, "sans", "middle")
+ if state in ("which", "flight", "landed"):
+ f = {"which": 96, "landed": 258}.get(state, f)
+ xs = {}
+ for k, v in enumerate(vals):
+ s, x, lift, sx, ex = flight(k, f)
+ xs[k] = (s, x)
+ if s > 0 and f >= 108 + 8 + 18 * k: # its place keeps a faint copy
+ g.t(sx, b(y), "%02x" % v, S, faint, MONO)
+ if 0 < s < 1: # the path, for the still only: up, over, down
+ pts = [flight(k, 108 + 18 * k + 24 * i / 60)[1:3] for i in range(61)]
+ seg = [(px + 12, y + ROW / 2 - pl) for px, pl in pts if pl > ROW / 2 + 4] # above the row only
+ g.path("M" + " L".join("%.1f,%.1f" % q for q in seg), RULE, 2, dash="12 8")
+ g.rect(x - 3, b(y) - lift - 17, 2 * A + 6, 20, PAGE)
+ g.t(x, b(y) - lift, "%02x" % v, S, BRIGHT, BOLD)
+ g.t(x + 12, b(y) - lift - OFF_AIR, "+%d" % k, S, FAINT, MONO, "middle")
+ else:
+ g.t(x, b(y), "%02x" % v, S, VELLUM, MONO)
+ g.t(x + 12, b(y - ROW), "+%d" % k, S, FAINT, MONO, "middle")
+ # `low byte` left of `+0` at rest, right of it landed (the word's last pair); `high byte` right of `+7` at
+ # rest, left of it landed; each goes as a byte lifts and comes back as its own lands
+ s0, x0 = xs[0]
+ if s0 <= 0 or s0 >= 1:
+ g.t(x0 - 6 if s0 <= 0 else x0 + 30, b(y - ROW), "low byte", 18, DIM, "sans", "end" if s0 <= 0 else "start")
+ s6, s7, x7 = xs[6][0], xs[7][0], xs[7][1]
+ if s6 <= 0 or s7 >= 1:
+ g.t(x7 + 30 if s6 <= 0 else x7 - 6, b(y - ROW), "high byte", 18, DIM, "sans", "start" if s6 <= 0 else "end")
if state == "closed":
word = "".join("%02x" % vals[k] for k in reversed(range(8)))
g.t(FR, b(y), word, S, VELLUM, MONO, "end")
lead = len(word) - len(word.lstrip("0"))
x0, x1 = FR - 16 * A, FR - (16 - lead) * A
- g.path(f"M{x0 + 1},{y + ROW + 2} v6 H{x1 - 1} v-6", FAINT, 2)
- g.t((x0 + x1) / 2, y + ROW + 30, "zeros in front", 18, DIM, "sans", "middle")
+ g.path(f"M{x0 + 1},{y + ROW - 8} v6 H{x1 - 1} v-6", FAINT, 2)
+ g.t(x0, y + ROW + 22, "zeros in front", 18, DIM, "sans")
+ if state in ("closed", "zeros", "ink"):
+ for k, v in enumerate(vals):
+ g.t(BX + 30 * k, b(y), "%02x" % v, S, faint, MONO)
if state in ("zeros", "ink"):
ink = CODE if state == "ink" else VELLUM
g.t(FR, b(y), "10018b0", S, ink, MONO, "end")
@@ -451,18 +447,19 @@ def walk_row(g, y, state, f=0):
def regroup_strip(name):
- """Mock 37: `regroup` walked, on the return address's real bytes, seven instants with their frames (from the
- beat's step, 552 in the introduction's chart). Each is the frame's x2 camera on the dump, drawn here at x1.5."""
+ """Mock 37: `regroup` walked, on the return address's real bytes, eight instants with their frames (from the
+ beat's step, motion.md's "A word read"). Each is the frame's x2 camera on the walked row, drawn here at x1.25."""
gen.W, gen.H = 1920, 1520
g = Svg()
cells = [("0 to 48", "eight to a row", "the rows make room; each right half goes down a row, then left", "reflow"),
- ("66 to 96", "which byte is which", "its offsets under it; the low byte is the first in memory", "which"),
- ("138", "in flight, the low byte first", "6 f apart, 36 f each, on nested arcs; a faint copy stays",
+ ("66 to 96", "which byte is which", "its offsets over it, in the header's row; the low byte is the first",
+ "which"),
+ ("174", "in flight, one at a time", "the low byte first, 24 f each, 18 f apart, 40 over the offsets",
"flight"),
- ("186", "landed, reversed", "the low byte last; each offset lands under its byte", "landed"),
- ("216", "the spaces close", "sixteen digits, the same eight bytes", "closed"),
- ("240", "the zeros in front go", "a word is written without them", "zeros"),
- ("288 to 386", "the other fifteen at a run", "rows 6 f apart: each word fades in (8 f) as its bytes dim",
+ ("258", "landed, reversed", "the low byte last; each offset lands over its byte", "landed"),
+ ("288", "the spaces close", "sixteen digits, the same eight bytes", "closed"),
+ ("312", "the zeros in front go", "a word is written without them", "zeros"),
+ ("360 to 458", "the other fifteen at a run", "rows 6 f apart: each word fades in (8 f) as its bytes dim",
"run"),
("ink beat", "then its ink, and its mapping", "framed with its band in the address space (mock 30)", "ink")]
for i, (fr, title, sub, state) in enumerate(cells):
@@ -489,9 +486,9 @@ def regroup_strip(name):
for k, v in enumerate(vals):
g.t(BX + 30 * k, b(y), "%02x" % v, S, mix(VELLUM, PAGE, 1 - 0.5 * fade), MONO)
if fade:
- g.t(FR, b(y), "%x" % D.word(a), S, mix(VELLUM, PAGE, fade), MONO, "end")
+ g.t(FR, b(y), word_text(D.word(a)), S, mix(VELLUM, PAGE, fade), MONO, "end")
else:
- walk_row(g, 0, state, {"which": 96, "flight": 138}.get(state, 0))
+ walk_row(g, 0, state, {"which": 96, "flight": 174, "landed": 258}.get(state, 0))
g.o.append("</g>")
g.save(name)
@@ -502,8 +499,20 @@ def frame_stack(name):
camera(g, 1.25, 976 + 440, 212 + 330)
C.RX = 976
C.registers(g, 212, D.regs(False), D.FLAGS, {})
- rows = [r for r in __import__("map").slot_rows(16, 8)]
- C.stack(g, 664, rows, __import__("map").frames_from(16, 8), rsp=RSP, roles=__import__("map").roles_from(16, 8))
+ M = __import__("map")
+ rows = [r for r in M.slot_rows(16, 8)]
+ frames = M.frames_from(16, 8)
+ roles = M.roles_from(16, 8)
+ for _, _, z in frames: # the introduction names the way back too: each frame's last word
+ if z < len(rows):
+ roles[z] = ("the way back", DIM)
+ slot, pins, links, end = rows[z][:4]
+ v, ink, sym = links[0] # its symbol gives way to the role where both do not fit, as the renderer's
+ if 184 + 12 * A + 30 + (len("%x" % v) + 1 + len(sym)) * A > C.CW - 136 - len("the way back") * A - 12:
+ rows[z] = (slot, pins, [(v, ink)], end)
+ C.HEX0X = True # and writes its offsets with `0x` from 0x10 up
+ C.stack(g, 664, rows, frames, rsp=RSP, roles=roles)
+ C.HEX0X = False
g.o.append("</g>")
gen.caption(g, [[("The same words as the stack: rsp points at its top, each word",)],
[("has its offset, a frame is a span, and the registers sit over it.",)]])
diff --git a/design/motion.md b/design/motion.md
index 9a01afb..07ffabc 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -446,6 +446,15 @@ outside the window: the window scrolls (24 f) before the touch draws, and the
touch draws to where the word now is. At a run no touch is drawn: the names
change in place under the run's crossfade.
+With `carry = .after_touch` a store draws both, the row naming the word and
+then the value going there: the touch to the word first (18 to 30), then the
+source register framed read and the carry down from its row to the word, the
+word armed and struck as it lands; what follows (rsp's pin climbing onto a
+pushed word) only after. The introduction's `push rbp` (II4) is drawn so,
+and there a store of the value the word held is struck as any write, its
+mark gone by the step's end and no corner held: the store is the event the
+viewer is being shown, and the carry would otherwise land on nothing.
+
### A pointer written
| Frames | Memory | The idea (one slot later) |
@@ -829,41 +838,46 @@ arrow lands.
### A word read
-`regroup`, walked, on the return address's eight bytes (`b0 18 00 01 00 00
-00 00` at `7fffffffece8`, [mock 37](mock/37-regroup.png)), from the beat's
-step. The camera is at x2 on the dump the whole time; the dump is built
-where the stack panel will stand. What the viewer must leave with: which
-byte is the low one (the first in memory), the order they are read in (the
-last first), and that the sixteen digits are the same eight bytes.
+`regroup`, walked, on the return address's eight bytes (`72 12 40 00 00 00
+00 00` at `7fffffffebc8`, the dump's first word: at a function's first
+instruction rsp points at the way back; [mock 37](mock/37-regroup.png)
+draws it on the older list recording's `b0 18 00 01 00 00 00 00`), from the
+beat's step. The camera is at x2 on the dump the whole time, with the room
+over it that the bytes fly in; the dump is built where the stack panel will
+stand. What the viewer must leave with: which byte is the low one (the first
+in memory), the order they are read in (the last first), and that the
+sixteen digits are the same eight bytes.
| Frames | |
| --- | --- |
| 0 to 18 | sixteen a row to eight: every row glides down as many rows as there are rows above it, making room (`glide`) |
| 18 to 30 | each right half goes down a row, under its left half (`glide`) |
| 30 to 48 | and left, to the bytes' column (`glide`); the new rows' addresses fade in, 36 to 48. Down, then left: a half never passes over a byte |
-| 48 to 66 | the veil over every row but the walked one |
-| 66 to 92 | its offsets fade in under its bytes, `+0` to `+7`, left to right, 2 f apart, 12 f each (`column`) |
-| 84 to 96 | `low byte` under `+0`, `high byte` under `+7` |
+| 48 to 66 | the veil over every row but the walked one; the dump's header fades, leaving its row to the offsets (it comes back as the veil lifts) |
+| 66 to 92 | its offsets fade in over its bytes, in the header's row, `+0` to `+7`, left to right, 2 f apart, 12 f each (`column`) |
+| 84 to 96 | `low byte` left of `+0`, `high byte` right of `+7`, in the same row: outside the run, never under another row's bytes |
| 96 to 108 | still: the question is on screen |
-| 108 to 186 | the bytes fly, the low byte first: byte k lifts at 108 + 6k and lands at 144 + 6k, 36 f, `glide`: straight up off its place, over on an arc a quarter as high as it is long (34 to 120), straight down onto its pair's place in the word's field, the pairs 30 apart and ranged right. The arcs nest (the low byte's the highest and longest) and never cross; each byte is bright and bold in the air. Its offset goes with it and lands under it, so the field reads `+7` to `+0`; `low byte` and `high byte` go with theirs. Its place in the dump takes a faint copy, fading in from a third of the flight (12 f): nothing is ever printed over it |
-| 192 to 204 | the gaps close: the pairs glide right to sixteen digits, `00000000010018b0` (12 f, `glide`) |
-| 204 to 216 | the offsets and the two labels fade; a faint bracket under the nine zeros in front, `zeros in front`, fades in |
-| 216 to 228 | still |
-| 228 to 240 | the zeros and their bracket fade: `10018b0`, ranged right where it was |
-| 240 to 270 | still |
-| 270 to 288 | the veil lifts |
-| 288 to 386 | the other fifteen at a run: rows top down, 6 f apart, each word fading in (8 f) as its bytes dim (8 f) |
+| 108 to 258 | the bytes fly, the low byte first, one at a time: byte k lifts at 108 + 18k, 24 f, so that the next lifts as it comes down and none crosses another in the air. Each goes straight up off its place to 40 over its row (clear of the offsets standing there), over, and straight down onto its pair's place in the word's field, the pairs 30 apart and ranged right (`glide` across, the rise and the fall each a quarter of the flight). In the air it is bright and bold on its own ground of page, its offset riding 22 over it; the offset lands over it, so the field reads `+7` to `+0`. `low byte` goes as its byte lifts and comes back right of `+0` as it lands (the word's last pair); `high byte` goes as `+6`'s byte lifts (it stands where `+6` lands) and comes back left of `+7` as its own lands. Its place in the dump takes a faint copy, fading in from a third of the flight (12 f): nothing is ever printed over it, and no row of memory is crossed |
+| 264 to 276 | the gaps close: the pairs glide right to sixteen digits, `0000000000401272` (12 f, `glide`); the offsets and labels fade with them (closed, their pairs would touch) |
+| 276 to 288 | a faint bracket under the zeros in front, `zeros in front` under it on a ground of page only as wide as its label, fades in |
+| 288 to 300 | still |
+| 300 to 312 | the zeros and their bracket fade: `401272`, ranged right where it was |
+| 312 to 342 | still |
+| 342 to 360 | the veil lifts |
+| 360 to 458 | the other fifteen at a run: rows top down, 6 f apart, each word fading in (8 f) as its bytes dim (8 f), each as the stack will write it (an address bare, a number as [`value`](README.md#value) writes it: `0x100000000`) |
The bytes fly, not copies of them, so that at the lift there is nothing
under them; the faint bytes left in the dump are what stays of where they
-were. Eight flights at once would cross; one after another, low byte first,
-they nest, and the order of the landing is the order of the reading.
+were. Eight flights at once would cross; one at a time, low byte first, the
+order of the landing is the order of the reading, and over the row there is
+room for one.
### The address space enlarged
-The whole first: the bar (18 f), its ends' addresses and its size (12
-f), the 2-unit lines at its ends (12 f). Then `enlarge`, a box a cluster,
-from its start e:
+The whole first, deliberately: the bar grows from the top down (72 f,
+`standard`), its ends' addresses and its size (18 f), then the 2-unit lines
+of every mapping at its ends (12 f each, over 72 f). Then `enlarge`, a box a
+cluster, from its start e:
| Frames | |
| --- | --- |
@@ -874,8 +888,9 @@ from its start e:
| e+90 on | its names, rows top down, 2 f apart: an edge's leader draws from the box (6 f), then its address fades in (12 f); a band's row fades in (12 f); a file's bracket and name with its last row |
The stack's box rides first, the libraries' at e+78 (as the stack's
-lands), the program's at e+156: three rides one after another, never two
-at once, in address order, so the eye goes down the stage with them. The
+lands), the program's in a beat of its own: three rides one after another,
+never two at once, in address order, so the eye goes down the stage with
+them. The
camera is still (x1): the whole stays on screen, and the box is the
magnification's own picture, not a camera's.
@@ -886,9 +901,17 @@ names:
| --- | --- |
| l to l+6 | the `tie` bracket on the dump's rows, in the stack's ink |
| l+6 to l+42 | the `link` draws from the bracket's top, head first, `standard`: up into the top margin, across the gutter and the program column, down onto the stack's box |
-| l+42 to l+54 | the head lands; the stack's band framed bright (6 f in, 12 out) |
+| l+42 to l+54 | the head lands; the stack's band framed bright (6 f in, 12 out); with it, never before, the dump's addresses take the stack's ink and its header goes (12 f): the place is said, so the header's words give way to its ink |
| the next beat | the link and the bracket quiet to standing (24 f, `glide`, 60% toward the page) and stay while the dump and the space share the frame |
+A visit to it (I8) at x2 frames the stack's box and the dump's top rows
+together, so that the link standing between them is whole and no label is
+cut at the frame's edge (only the dump's rows run on out of it). At that
+scale the 128 bytes are still far thinner than a unit, so their place is
+marked: a 2-unit tick across the box in the stack's ink at the dump's
+address, `128 bytes` over it left of the link's head (12 f in once the
+camera has landed, held 60 f, 12 f out before it goes back).
+
### The camera
In, to x2:
@@ -1485,11 +1508,18 @@ from its slot), so a step can be one line or one turn in both.
## A scene: the introduction
-The frame built from its bytes up, on the recording mocks 9 to 21 use
-(`targets/list`, stopped at the load in `reverse`). Three short scenes,
-not one: each is a chapter with its own opening and its own last picture,
-which the next opens from, so a viewer can stop between them; together
-123 s. Each view grows out of the rawer thing under it, in the order the
+The frame built from its bytes up, on a recording of its own (`intro`:
+`anim/tools/list.c`, three nodes pushed onto a global list and the list
+reversed, built as the compiler alone makes it, clang `-O0 -g
+-mno-red-zone`, with no instrumentation: nothing the viewer is walked
+through is a tracer's, `reverse` gets a real prologue, `push rbp; mov rbp,
+rsp; sub rsp, 0x18`, and its locals are named by the debug info). Chapters
+I and II stand at reverse's first instruction, its `push rbp`, where rsp
+holds the way back to main (`401272 main+50`); III at the load on line 21,
+`mov rax, [rax + 8]`. Three short scenes, not one: each is a chapter with
+its own opening and its own last picture, which the next opens from, so a
+viewer can stop between them; together 157 s. Each view grows out of the
+rawer thing under it, in the order the
direction rule gives: memory first (the deepest), then the stack that is
made of it, then the code that acts on it, and the idea last, at the top.
Nothing cuts to a finished panel: the same bytes become the word, the
@@ -1501,7 +1531,8 @@ will stand (the state column), the address space in the program column,
which is empty until the code comes. The camera frames the part being
built (x2 for the bytes and the words, x1 for the address space beside
them and for the stack and registers, whose text stands in the program
-column while it is empty), so the frame's empty parts are
+column while it is empty; once more at x2 for the visit of I8, and none
+in III, where the band is whole at x1), so the frame's empty parts are
out of shot until the parts that fill them come. An introduction earns
that emptiness; nothing else does. A panel's tag and rule come last
(`frame up`): first the rows, then what they are called.
@@ -1514,55 +1545,88 @@ bubbles level with each end as it is enlarged, so the chapter goes down the
address space with them, while the bytes wait on the shelf; the working
frame again to tie the bytes to their place; in chapter II the text `beside`
on the left, in the program column, which holds nothing else until III but
-the three rows of main the return address aims at (II2, the scene's one
-`aim`), level with the stack's rows it speaks of; in III `above` the aligned source and code, which
-span both columns and read down, then `below` as the working frame assembles,
-and `on` the map. Every text lands in a rest, leads its step by 60 f (120 for
-a chapter's first), is up its reading time and at most 720 f, and is covered
-by its lead, its steps and a hold of at most 84 f.
+main's three rows round its call (the return address aims at one: II3, the
+scene's one `aim`) and reverse's first seven under them (the disassembly II
+walks), level with the stack's rows it speaks of; in III `above` the aligned
+source and code, which span both columns and read down (wrapped at 80
+characters: two lines in the band of 120), then `below` as the working frame
+assembles, and still `below` as the map surfaces under it. Every text lands
+in a rest, leads its step by 60 f (120 for a form's first in III: III1
+above, III3 below; I1's is 60 too, so that its rows come while it is read
+rather than its "here" standing over an empty stage), is up its reading time
+and at most 720 f, and is covered by its lead, its steps and a hold of at
+most 84 f. A chapter's last picture holds until its last text is read and
+2 s at least ([caption](README.md#clock-and-caption)); II and III hold the
+2 s after the reading, so that the map is never cut while it is read about.
+
+**Names after the things.** Nothing is named before it is shown, in a text
+or a label: the first text says bytes, not the stack; the dump's header is
+`128 bytes at 7fffffffebc8` and its tag on the shelf `the 128 bytes`; the
+stack is named at I7, where its box is on screen, and rsp at II2, where its
+row arrives. A convention is said where it first shows: the chain's arrows
+at I10, the stack panel's direction at II1 (the bar draws high addresses on
+top, the panel low on top, and the push goes up a row), the width squares
+with `columns`, the minimaps at III4.
+
+**Notation.** From I's regroup on, a word that is no address is written as
+the stack will write it (the [`value`](README.md#value) atom: `0`, `1`,
+`0x100000000`), so a number reads the same in I and in II. The stack's
+offsets and a pin's amount take `0x` from 0x10 up (`-8`, `+0x10`, `rsp
+-0x18`): beside a symbol's decimal offset (`main+50`), `-10` after `-8`
+would read as ten.
+
+The frames are the build's: a text *lands* when it has arrived, its step
+*fires* its lead after, and it *leaves* when it starts to go (a bubble
+that stays as the account *dims* instead).
-**I. Memory** (66.2 s)
+**I. Memory** (70.0 s)
| | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| I1 | working frame · below; the camera at x2 on the state column | the dump of 128 bytes, sixteen a row, eight rows, no ink, the addresses faint (mock 29) | | the bytes fade in a row at a time (18 f, 12 f apart) | A running program is bytes in memory: here, 128 of them at the top of the stack. (80) | 78 | 198 | 456 |
-| I2 | the same | the dump | | `regroup`: sixteen a row to eight, the return address walked, the other fifteen at a run (mock 37, [chart](#a-word-read)) | Eight bytes make a word, stored low byte first: the lowest byte is its last two digits. (87) | 474 | 534 | 956 |
-| I3 | the same | the dump, sixteen words | | three words that hold addresses framed as read, one at a time, 30 f apart | Some words are addresses: they name a place in memory. (54) | 974 | 1034 | 1258 |
-| | | | | 1276 to 1384, into the column: the camera out to x1 (72 f); the dump folds to its tag (`the stack's 128 bytes`) on the shelf; the program column opens to the column's height for `segments` | | | | |
-| I4 | column · beside | `segments` (treatment A, mock 34), the panes' column from 84 to 888: a slim bar the column's height, true scale | the bar's middle | the whole builds, deliberately: the bar grows from the top down (48 f), its two ends' addresses and its size, then the lines of every mapping at its ends (48 f) | Its address space, 128 TiB, to scale: mapped only at each end. (62) | 1384 | 1444 | 1698 |
-| I5 | column · beside | `segments` | the stack's box, at the top | `enlarge`: the stack's box rides out (78 f) and its names come, each band with its start and end addresses and its size; then the libraries' box the same | Enlarged, the top end: the stack, then the libraries, each band with its addresses and size. (92) | 1716 | 1776 | 2137 |
-| I6 | column · beside | `segments` | the program's box, at the foot (the bubble's way down) | `enlarge`: the program's box, by segment (code, read-only data, data, the heap), its names | At the foot, the program: its code, its data, its heap. (55) | 2155 | 2215 | 2443 |
-| | | | | 2461 to 2557, back to the working frame: the bubbles leave; `segments` keeps the program column, its height eased to the stage's (24 f, the drawing scaling as one); the dump unfolds from the shelf in the state column, at x1 | | | | |
-| I7 | working frame · below | `segments` in the program column; the dump in the state column | | the dump's place: the `tie` bracket on its rows (6 f), the `link` over the top onto the stack's box (36 f), the band framed bright as it lands (mock 30) | These 128 bytes are here, at the very top of the stack. (55) | 2557 | 2617 | 2845 |
-| I8 | working frame · below | the same | | a camera `visit` at x4 to the top of the stack's box, where the link lands, and back (72 f each way) | Were the bar the Eiffel Tower, they would be an atom thick, at its top. (71) | 2863 | 2923 | 3208 |
-| I9 | working frame · below | the same | | `ink` on the return address, walked: its digits, its band and its row framed (an echo); the rest at a run, 2 f apart; the link quiets | A word takes the ink of where it points: 10018b0 is list's code. (64) | 3226 | 3286 | 3547 |
-| I10 | working frame · below | the same | | the words glide to their field's left (24 f) to give their chains room; three chains grow (`extend`), walked | Follow an address and you reach another word: a chain. (54) | 3565 | 3625 | 3849 |
+| I1 | working frame · below; the camera at x2 on the state column | the dump of 128 bytes, sixteen a row, eight rows, no ink, the addresses faint, its header over them, `128 bytes at 7fffffffebc8` (mock 29) | | the rows fade in a row at a time (18 f each, 18 f apart: they come while the text is read) | A running program is bytes in memory: here are 128 of them. (59) | 78 | 138 | 380 |
+| I2 | the same | the dump | | `regroup`: sixteen a row to eight, the return address (the dump's first word) walked, the other fifteen at a run (mock 37, [chart](#a-word-read)) | Eight bytes make a word, stored low byte first: the lowest byte is its last two digits. (87) | 416 | 476 | 965 |
+| I3 | the same | the dump, sixteen words | | three words that hold addresses framed as read, one at a time, 30 f apart | Some words are addresses: they name a place in memory. (54) | 1000 | 1060 | 1285 |
+| | | | | 1285 to 1476, into the column: the text leaves (12 f); the camera out to x1 (72 f, then 36 still); the dump folds to its tag on the shelf, `the 128 bytes` (its rows glide up into its header, the header becomes the tag, the tag slides to the shelf, 24 f each way: README, [column](README.md#column), "Mixing them"); the program column opens to the column's height for `segments` | | | | |
+| I4 | column · beside | `segments` (treatment A, mock 34), the panes' column from 84 to 888: a slim bar the column's height, true scale | the bar's middle | the whole builds, deliberately ([chart](#the-address-space-enlarged)) | Its address space, 128 TiB, to scale: mapped only at each end. (62) | 1476 | 1536 | dims 1790 |
+| I5 | column · beside | `segments` | the stack's box, at the top | `enlarge`: the stack's box rides out (78 f) and its names come, each band with its start and end addresses and its size; the libraries' box rides as the stack's lands | Enlarged, the top end: the stack, then the libraries, each file with its addresses and size. (92) | 1808 | 1868 | dims 2229 |
+| I6 | column · beside | `segments` | the program's box, at the foot (the bubble's way down) | `enlarge`: the program's box, by segment (code, read-only data, data, the heap), its names | At the foot, the program: its code, its data, its heap. (55) | 2247 | 2307 | 2542, the three together |
+| | | | | 2542 to 2661, back to the working frame: the texts leave together (12 f); `segments` keeps the program column, its height eased to the stage's (24 f, the drawing scaling as one); the dump unfolds from the shelf in the state column, at x1, the fold backwards (2578 to 2626) | | | | |
+| I7 | working frame · below | `segments` in the program column; the dump in the state column | | the dump's place ([chart](#the-address-space-enlarged), mock 30): the `tie` bracket on its rows, the `link` over the top onto the stack's box, the band framed bright as it lands, and with it the dump's addresses taking the stack's ink | These 128 bytes are here, at the very top of the stack. (55) | 2661 | 2721 | 2949 |
+| I8 | working frame · below | the same | | a camera `visit` at x2 to the dump's place, the stack's box and the dump's top rows framed together ([chart](#the-address-space-enlarged)): the move (72 f), the place marked `128 bytes` on the box, back (72 f) | Were the bar the Eiffel Tower, they would be an atom thick, at its top. (71) | 2985 | 3045 | 3370 |
+| I9 | working frame · below | the same | | `ink` on the return address, walked: its digits, its bytes, its band and the band's row framed (an echo); the rest at a run, 2 f apart; the link and its bracket quiet to standing (24 f) | A word takes the ink of where it points: 401272 is list's code. (63) | 3405 | 3465 | 3729 |
+| I10 | working frame · below | the same | | the words glide to their field's left (24 f) to give their chains room; three chains grow (`extend`), 36 f apart | Follow an address and you reach another word: a chain. → points to a word, ← holds a value. (91) | 3765 | 3825 | |
-The chapter's last picture, 2 s, to 3969.
+The chapter's last picture: 2 s after the last step, and on until its text
+is read, to 4199.
-**II. The stack** (26.5 s), opening on I's last picture
+**II. The stack** (42.5 s), opening on I's last picture
| | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| II1 | working frame, text beside on the left (the program column, empty until III) | the address space and the dump's link fade (18 f); the words become the stack panel in the state column, 16 slots, the headroom over rsp | rsp's row | rsp's row arrives over the stack, its pin landing on the top word; `reverse`'s `push rbp` replayed from the recording by instruction: the touch, the word, rsp's pin climbing onto it (README, stack) | rsp holds the address of the top of the stack. A push moves it down a word. (75) | 78 | 198 | 438 |
-| II2 | the same; `aim = .step` for this beat | the stack; under the bubble, in the program column, three rows of main's code arrive (a descent's head row, `main`, then `call reverse`, `10018b0`, the next): the first code on screen | the return address's row | the word `10018b0 main+80` framed (516 to 522); the three rows fade in (528 to 546); the aim draws from the word across the gutter to the row `10018b0`, the one after the call (552 to 570), its address framed; the offsets arrive (`column`, 582 to 630). The rows stay, faint, and III's disassembly opens round them | A call pushes the address to come back to: here, main+80. (57) | 456 | 516 | 751 |
-| II3 | the same | the stack | the frame's span | roles (`column`), the spans, rbp's pin; the stack's tag (`frame up`) | A function's words are its frame: the saved rbp, its locals, the way back. (74) | 769 | 829 | 1126 |
-| II4 | the same | the registers built over the stack, a row at a time, top down, then their tag, its legend the inks of I (mock 31) | rax's row | the build | The registers are the other place values live: seventeen of them. (65) | 1144 | 1204 | 1468 |
+| | | | | 0 to 96: I's last picture (30 f); the address space and the dump's link fade (18 f); the words glide into the stack panel's rows where it stands in the working frame (36 f, the bytes going first and the addresses travelling to the slots' column) and become it (12 f): sixteen words and four `free` over rsp. The window is held there through the chapter: the push and `sub rsp` fill the free words and only pins move, no row | | | | |
+| II1 | working frame, text beside on the left (the program column, empty until II3) | the stack; its offsets, roles, spans and tag, and the registers, under the page until their beats | the stack's first row | the convention said where the panel first stands: the offsets come down the rows (`column`, 4 f apart), counting from rsp | Here lower addresses are drawn higher: down a word is up a row. (63) | 114 | 174 | 431 |
+| II2 | the same | rbp's and rsp's rows, the registers' first two, arrive over the stack | rsp's row | the two rows (12 f); rsp's pin lands on the top word (12 f); rsp's link from its row down to the word, a link on the beat (README, [`link`](README.md#6-verbs)): rsp framed, the link (36 f), held 1 s, drawn back (18 f) | rsp holds the address of the top of the stack. (46) | 466 | 526 | 730 |
+| II3 | the same; the scene's one `aim`, `drawn` | main's three rows in the program column, level with the lower stack (a descent's head, `main`; `40126d call 4011a0 reverse`; `401272 call 401200 clear`; `401277 xor eax, eax`): the first code on screen | the return address's row | the call first, as it happened, before the push: the word `401272 main+50` framed as read (6 f); main's rows (12 f each, 2 f apart); the `aim` from the word down the gutter's left lane to `401272`, the row after the call, head first at full ink (18 f), the address framed as the head lands (6 f) | A call pushes the address to come back to: here, main+50. (57) | 765 | 825 | 1068 |
+| II4 | the same | reverse's first seven rows, the disassembly, under main's (its rules, tag and strip under the page until II5); rbp's pin | the free word over rsp | the aim falls to standing at 60% (18 f), the word's frame goes and main's rows go faint (18 f); reverse's rows (12 f) and rbp's pin (12 f); `push rbp` walked, its row fired by the pc's mark: the touch to the word, then rbp's value carried there from rbp's row (`carry` `after_touch`) and struck, though the word held that value; rsp's pin climbs onto it, `rsp -8`, and rsp is struck | A push moves rsp down a word and stores there: push rbp keeps the caller's rbp. (79) | 1104 | 1164 | 1500 |
+| II5 | the same | the stack, its roles and spans; the disassembly's and the stack's rules and tags | the frame's span | the aim leaves (18 f); `mov rbp, rsp` walked (rbp's pin flies to rsp's row; the offsets now count from rbp), `sub rsp, 0x18` walked (rsp's pin climbs three rows, `rsp -0x18`, `3 words`); the roles (`column`: `cur`, `prev`, `saved rbp`, `the way back`, and the callers' below), the spans (`column`); `frame up` on the disassembly and the stack, the rules (12 f) then the tags and strips (12 f) | rbp marks the frame's base. A function's words are its frame: the saved rbp, its locals, the way back. (102) | 1536 | 1596 | dims 2088 |
+| II6 | the same | the registers' other rows built over the stack, a row at a time, top down, then their rules and tag, its legend the inks of I (mock 31) | the registers' third row | the build, 12 f a row, 12 f apart | The registers are the other place values live: seventeen of them. (65) | 2106 | 2166 | |
-The chapter's last picture, 2 s, to 1588.
+The chapter's last picture, 2 s after its text is read, to 2552.
-**III. Code and meaning** (30.3 s)
+**III. Code and meaning** (44.8 s), opening on II's last picture
| | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| III1 | working frame · above | the code's bytes as a dump row in code's ink, across the stage | | the row arrives (12 f), its sixteen bytes take code's ink 2 f apart, one instruction's four bytes framed | Code is bytes too: 48 8b 7f 08 is one instruction. (50) | 78 | 198 | 348 |
-| III2 | `aligned` · above | `aligned`, `interleaved`, across both columns (mock 32) | | `decode`, the instruction walked and its neighbours at a run; the source's lines arrive level with their runs | Decoded: mov rdi, [rdi + 8], from line 21. Each line sits level with its code. (78) | 366 | 426 | 737 |
-| | | | | 755 to 803: the text above leaves; `stack`: the aligned columns become the program column | | | | |
-| III3 | working frame · below | the program column, the state column as II left it; the band | | the heap's dump arrives in the band's right half, then the nodes drawn from it (`establish`) | rdi pointed at a list node on the heap: its bytes, and drawn, the node. (71) | 803 | 863 | 1148 |
-| III4 | working frame · below | the working frame of mock 9 | | the camera out to x1; each pane's minimap draws itself last, top down | This is the whole frame. Every view in it is these same bytes. (62) | 1166 | 1226 | 1480 |
-| III5 | the map · on, in the key's corner | the map | | `surface` | And all of it at once: the map. (31) | 1498 | 1558 | 1699 |
+| | | | | 0 to 96: II's last picture (30 f); its texts leave (12 f) and its code fades (18 f); its state column is veiled at 50% (18 f) and stays, veiled, until the decoded rows come to span it | | | | |
+| III1 | working frame · above | the code's bytes as a dump row in code's ink, in the program column | | the row arrives (12 f), its sixteen bytes take code's ink 2 f apart, one instruction's four bytes framed | Code is bytes too: 48 8b 40 08 is one instruction. (50) | 96 | 216 | 374 |
+| III2 | `aligned` · above | `aligned`, `interleaved`, across both columns (mock 32) | | `decode`, the instruction walked (60 f) as II's state column goes under it (12 f); its neighbours at half a run's pace (rows 4 f apart), each line heading its run, while the text is read; the panel's rules and tag (24 f) | Decoded: mov rax, [rax + 8], from line 21. Each line heads the instructions it compiled to. (91) | 409 | 469 | 834 |
+| III2b | `aligned` · above | `aligned`, `columns` (mock 36) | | `align` to `columns` at two thirds of its pace (120 f), while the text is read | Two columns: each line by its first instruction. A square after ]: a byte it touches. (85) | 870 | 930 | 1274 |
+| | | | | 1274 to 1435, into the working frame: the texts above leave (12 f); `stack`: the lines glide to the source panel's rows, the instructions to the disassembly's (60 f), those panels coming in under them as the aligned panel goes (12 f); `establish`: the clock, the registers, the stack and the ties, at III's moment | | | | |
+| III3 | working frame · below | the program column, the state column at the load; the band | | the heap's dump in the band's right half (18 f), then the nodes drawn from it, rising (`establish`); rax framed as read and its link up to the node it points at, a link on the beat | Later, at line 21, rax points at a list node on the heap: its bytes, and drawn, the node. (89) | 1435 | 1555 | 1853 |
+| III4 | working frame · below | the working frame of mock 9 | | each pane's minimap draws itself, last, top down (24 f each, 72 f apart, while the text is read). No camera: at x1.5 the nodes and their bytes would not both be in frame | This is the whole frame. Every view in it is these same bytes; each strip, the whole of its pane. (97) | 1888 | 1948 | 2328 |
+| III5 | the map · below: the text lands before the move and stays under the map as under the frame | the map | | `surface` | And all of it at once: the map. (31) | 2364 | 2424 | |
-The last picture, 2 s, to 1819. Together 123 s.
+The last picture, the map, 2 s after its text is read, to 2687. Together 157 s.
## A scene in the column: `open` followed down