diff options
Diffstat (limited to 'design/README.md')
| -rw-r--r-- | design/README.md | 224 |
1 files changed, 161 insertions, 63 deletions
diff --git a/design/README.md b/design/README.md index 86a217e..3ac5fb6 100644 --- a/design/README.md +++ b/design/README.md @@ -11,7 +11,7 @@ scene that draws every block in every state is the test of this page. - The numbers are tokens in `anim/src/theme.zig`: [what to change there](#token-changes). - + ## The rules @@ -76,7 +76,7 @@ this table. | | [`source`](#source) | a window on the file | 14, 8 or 10 lines | | | [`disasm`](#disasm) | the instructions round the pc | 17 or 9 rows; a [`descent`](#descent): a window a call deep, the kernel at the floor; a [`graph`](#graph): the function's blocks | | | [`lens`](#lenses) | a drawing of some state over the program's two columns, and in the third the pane it is a view of | `beside`, `subject` | -| | [`hexdump`](#hexdump) | memory, a `bytes` row a line | typed or by `fields`; `more` rows; `seen`; `given`; `memory` | +| | [`hexdump`](#hexdump) | memory, a `bytes` row a line | typed or by `fields`; `eight` (a stack frame, a word a row); `more` rows; `seen`; `given`; `memory` | | | [`loupe`](#loupe) | the memory round a pointer's target, floating over the context | two at most, in depth | | | [`nodes`](#nodes) [`array`](#array) [`calls`](#calls) [`syscalls`](#syscalls) [`blocks`](#graph) `pages` | the drawings a lens can hold | `nodes` in two rows, a `bin` heading the second | | 4 tie | [`thread`](#4-ties) | the current line is these instructions | standing | @@ -86,9 +86,9 @@ this table. | 5 frame | [`stage`](#5-the-frame) | the working frame: the band and the two columns | split `none`, `beside`, `subject` | | | [`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 | -| | [`pair`](#pair) | two runs of one program against each other, a seam between them | `only here`, `differs`; the shadow on an ASan run's stack | +| | [`pair`](#pair) | two runs of one program against each other, a seam between them | `only here`, `differs`; each run's frame as bytes, an ASan run's shadow beside its rows | | | [`map`](#the-map-and-the-minimap) | the working frame unfolded, every panel whole: 3840 by 2160 | the key | -| | [`minimap`](#the-map-and-the-minimap) | the map at a twentieth, in the working frame's corner | windows, marks, `flash` | +| | [`minimap`](#the-map-and-the-minimap) | a pane's whole column of the map, small, in a strip at its right | its window, marks, `flash` | | | [`clock`](#clock-and-caption) | where in the recording | | | | [`caption`](#clock-and-caption) | the narrator | | | | [`veil`](#clock-and-caption) | page over what a beat does not touch, or a pace cannot show | | @@ -110,9 +110,9 @@ master is two pixels a unit. It is where a scene is told, and everything in it reads at 1080p. **The map** is 3840 by 2160 units at the same type size: the working frame unfolded, every panel at its full length. It is shown filling the frame (at half its size, so at 1080p its text is -texture), and small in the corner of the working frame as the -[`minimap`](#the-map-and-the-minimap). The working frame's panels are -windows onto the map's columns. +texture), and a column at a time, small, in a strip inside each pane of the +working frame as its [`minimap`](#the-map-and-the-minimap). The working +frame's panels are windows onto the map's columns. | Token | Value | | --- | --- | @@ -457,7 +457,7 @@ An instruction, pwndbg's way: what it is, and what its operands are now. | 134 | line | the source line this run of instructions came from, ranged right in three characters, faint; on the first row of each run only; gold and bold for the current line. Wide numbers (see [`line`](#line)) widen it, and every column right of it moves by the extra: mnemonic, operands and annotation, the row's room 12 characters less for six digits | | 180 | mnemonic | keyword, bold; `nop` and `endbr64` faint, with their operands: padding, which touches nothing | | 264 | operands | as the disassembler writes them, whole, less the size words (`qword ptr `): a [`width`](#width) after the bracket where no register says the size. A jump's or call's target is an `address` in code ink; a PLT stub's, named by the stub: `401070 open@plt` | -| 564 | annotation | from 564, or a character after operands that run past it; a chain, cut at its far end by the chain's rule | +| 564 | annotation | from 564 (540 in a pane with a [minimap](#the-map-and-the-minimap), whose strip takes 48 of the row), or a character after operands that run past it; a chain, cut at its far end by the chain's rule | **Wide addresses.** An address of more than seven digits (a library's twelve, `7ffff7d10fc5`) moves every column right of it by the extra, 12 a @@ -470,7 +470,7 @@ edge. Operands are never cut where the row has room, and never inside `[]`: we do not hide what the instruction says. When the operands and the whole annotation do not fit, in this order: -1. the annotation moves left to where it just fits, never left of 564; +1. the annotation moves left to where it just fits, never left of 564 (540 beside a minimap); 2. the operands give way to the annotation: they end where it begins, in a faint `…`. A cut that would fall inside `[]` falls before the `[`, and the annotation's first hop is the address the brackets named. @@ -625,7 +625,7 @@ since every pointer's reading names its target. but not shown: in the step that writes or reads it, a stub along its lane to the panel's rule, head on the rule; otherwise nothing. No count, unlike a link's stub: the lane has no room for one, the reading names the -address, and the minimap shows where. +address, and the panel's minimap shows where. **Which form carries a pointer**, when more than one could: @@ -852,9 +852,10 @@ the run will reach but has not yet. the lanes. A descent on the map stacks graphs: a caller folded to the block that holds its waiting call and one block either side, the callee's graph whole under it, the kernel's window under that. -- **The minimap** shows it at a twentieth: block outlines, row strokes, - edges 1 px, the pc's block gold. A sprint on the map reads there as the - gold going from block to block. +- **The disassembly's minimap** stays the linear column, each block's + first row ticked at its left (2, `rule`), the pc's row gold. A sprint + on the map reads on the map itself as the gold going from block to + block. - **The working frame** keeps the linear rows (rule 6) and shows their blocks: a 2-unit `rule` across over each block's first row, and the block's visits ranged right in that row's annotation room (`×11`, @@ -974,6 +975,38 @@ Its runs come one of two ways. program's memory is drawn when the debug info does not type it, or the meaning is the file's and not the C's (an SQLite page). +**`eight`: a stack frame as bytes.** Where what a step does to the stack +is a byte at a time (a loop storing into a buffer, a `strcpy`, an +overflow), the words of the [`stack`](#stack) panel hide it: a word going +`41`, `4141`, `414141` says neither that a letter was written nor where +one field ends and the next begins. The frame is then a hexdump by +`fields`, eight bytes a row, so that a row is one word of the stack: + +| x | Column | | +| --- | --- | --- | +| 12 | pins | rsp's and rbp's `row` pins on their rows, as the stack's | +| 62 | shadow | in a run built with ASan, the row's shadow byte, as on a [`slot`](#slot) | +| 118 | address | in its region's ink, `lead`. No offset from rsp: the reading needs the room, and the pins say where rsp is | +| 274 | eight `byte`s | on a pitch of 30, each field's on its paper (`raised`), what no field covers `loose`. A field's run never crosses a row, so a boundary between fields is a row's edge or a gap in the paper | +| 522 | reading | the field's name in Go 18 `dim` (`buf[0..7]`, `i`, `saved rbp`, `return`), then what its type makes of its bytes: a buffer's text in quotes in a string's ink, a count in decimal, a pointer as `points` and its address and name. A pointer that is no longer an address reads as the number it is, `0x4141414141414141`, with no arrow and no name. A string too long for the row is cut at the frame's span with a faint `…` | +| 866 | span | the frame's [`call`](#call) span, as the stack's, its name on a row whose reading is short | + +The fields are the frame's own, from the debug info and the call frame +information: its locals, the saved registers, the return address; in an +ASan run's fake frame its header (`magic`, `descr`, `pc`, `real stack`), +the buffer and the redzones. **A byte stored past the field the store +aimed at keeps that field's ink**: the letters a loop writes into `buf` +are in a string's ink in `buf`, and stay in it when they land in the +saved rbp and the return address, whose readings say what the CPU will +make of them (`→ 7fffffffed41`, then `→ 401141 fill+1`, then `0x41414141`). +So each turn is one more byte and one more letter, and the moment the +letters cross from one field into the next is a row's edge being crossed. +The store's byte is struck as in `bytes` (one byte, never the word). + +It is the stack panel's other form, a scene's choice: the default +everywhere is the words with their chains; `eight` where the narration is +about bytes. A pair puts it in each column (mocks 26 to 28 and 38). + **`more`.** Rows that hold no field (a dump by `fields`), or a gap in the addresses (a typed one), are one row: at the address column, `more`'s arrow and three dots, then the count of rows it stands for in faint mono @@ -1124,8 +1157,8 @@ stem down the gutter's right lane (x 962) from the foot of its row to the tag. Where the step changes a word of the stack under it, it does not open in that step. On the map it is a panel of its own beside the memory it shows (the map has room), and on -the minimap a lifted box there, its target's row outlined in its region's -ink. +the working frame it has no minimap of its own: the pane it lies over keeps +its strip, covered where the loupe covers it. **How many.** Two at most. A third, followed from the second, closes the first as it opens, so a chain of any length is walked two loupes at a @@ -1213,11 +1246,11 @@ The working frame: where a scene is told. | margin | 0 to 48 | page | | stage | 48 to 888 | 840: the lens band and the two columns | | clock | 898 to 902 | | -| caption | 912 to 1032; the minimap at its right end, 1664 to 1856 by 912 to 1020 | | +| caption | 912 to 1032; the clock's count ranged right at 1856 | | | margin | 1032 to 1080 | page | -No data below 888 but the minimap, which the narration never depends on: -a player's controls may cover its foot. +No data below 888: the caption and the clock's count, which a player's +controls may cover the foot of, and which the narration says again. **The program column** (left): source over disassembly: what was written, what runs. **The state column** (right): registers over stack: what they @@ -1232,7 +1265,7 @@ thing about the layout a scene chooses. | `subject` | 296, 48 to 344 | 200, 48 to 248: 7 rows | 10 lines, 356 to 628 | 9, 640 to 888 | 260 to 700 | 6, 712 to 888 | in the stack; the view of `calls` | Each panel is a window onto a column of the [map](#the-map-and-the-minimap), -and the minimap shows where. **What gave** for seventeen instructions: a +and its minimap shows where. **What gave** for seventeen instructions: a lens, the whole of a function and seventeen instructions do not fit one column of 840. So the lens left the program column for a band of its own; the backtrace became spans on the stack; the flags moved into rip's row; @@ -1241,13 +1274,13 @@ eight lines. As the subject the drawing takes eight rows from the disassembly, the source gets two back, and the view stops two rows short of the drawing so that the stack keeps six slots. With a lens open the source is a window of eight or ten lines on the file: the map holds the -rest, and the minimap shows it. +rest, and the source's minimap shows it. | Of the frame | `none` | `beside` | `subject` | | --- | --- | --- | --- | | context | 68% | 56% | 48% | | lens band (the drawing and its view) | | 13% | 21% | -| caption band, with the minimap | 10% | 10% | 10% | +| caption band | 10% | 10% | 10% | ### Direction and nearness @@ -1405,13 +1438,13 @@ once, the ones that differ twice, one on each side of a seam. | --- | --- | | the seam | the gutter between the columns (944 to 976): the left column is one run, the right the other, each panel's tag naming its run (`plain · disassembly`, `asan · disassembly`). Down is still deeper in each; across the seam is the other run | | the source | shared when both runs are the same file: one panel across both columns, 1792 wide, five lines (48 to 200). Each run's current line is marked on its own side of it: the left run's gold plaque on the number at the left, the right run's ranged right at the panel's right edge, the wash across the row once when both are on it. Two files: two panels, as below | -| each column | its run's context cut to what the scene's line touches: its disassembly, nine rows (212 to 460); the registers the line reads or writes and rip, rsp, rbp, four rows (472 to 600); the stack frame from rsp to the return address, ten rows (612 to 884). A run built with ASan adds the shadow to its stack's rows ([`slot`](#slot)) | -| alignment | the two disassemblies are scrolled so that the current line's first row is at one height on both; below it each runs on. The two stacks are scrolled so that the same variable's first row (`buf`) is at one height. Corresponding things face each other across the seam | +| each column | its run's context cut to what the scene's line touches: its disassembly, nine rows (212 to 460); the registers the line reads or writes and rip, rsp, rbp, four rows (472 to 600); the frame, ten rows (612 to 884): the stack panel's words, or, where the scene's stores are bytes (an overflow), the frame as bytes ([`hexdump`](#hexdump) `eight`). A run built with ASan adds the shadow to its frame's rows. A dump of ten rows is the stack panel's height, so the four registers and the nine instructions keep their places and nothing gives | +| alignment | the two disassemblies are scrolled so that the current line's first row is at one height on both; below it each runs on. The two frames are scrolled so that the same variable's first row (`buf`) is at one height: then what lies past it faces what lies past it (plain's saved rbp and return address, ASan's redzone). Rows the alignment shows that hold no field are loose bytes. Corresponding things face each other across the seam | | only here | a row one run has and the other has not (the instrumentation; a function only one build calls): a 4-unit `dim` bar on its seam-side edge. Its counterpart is the page facing it, or nothing | | differs | a value that differs from its counterpart at the same step (the saved rbp kept on one side and overwritten on the other): a 4-unit `bright` bar on its seam-side edge, on both sides. It is the difference across runs; a strike is a change in time, and both can stand together | | the clock | one rule, counting the pair's steps; under it, ranged right, each run's moment: `plain moment 61 · asan moment 412` | | the caption | one, for the pair: it narrates the difference | -| the minimap | both runs' maps at a fortieth, side by side in its box (96 by 54 each), each with its windows. The map itself is one run's at a time: a `surface` goes to the side in focus | +| the minimaps | each pane's own, as anywhere, its run's column; the shared source's at its right end. The map is one run's at a time: a `surface` goes to the side in focus | **Keeping the two in step.** A pair's step is one source line in both runs, or one turn of a loop when the narration says so: the unit both @@ -1433,10 +1466,12 @@ struck. A run that writes to stderr (ASan's report) shows it in its own column, in place of its registers and its disassembly's lower rows once it has -stopped: a panel of the run's output, its lines as written, the ones the -narration names framed. +stopped: a panel of the run's output, its lines as written and cut at its +edge with `…`, the words the narration names framed bright (mock 38). Its +disassembly keeps the rows down to the call that stopped it, which reads +`never returned`; its frame keeps its last picture. -Mocks 26 to 28; [the scene](motion.md#a-scene-asan-against-a-plain-build). +Mocks 26 to 28 and 38; [the scene](motion.md#a-scene-asan-against-a-plain-build). ### The map and the minimap @@ -1485,34 +1520,81 @@ lens's drawing, and the loupes open. it there, and the map is never on screen for reading at 1080p: it is for where, not for what. -**The minimap** is the map at a twentieth, 192 by 108, in the working -frame's corner: the caption band's right end, 1664 to 1856 across and 912 -to 1020 down, under the clock's right end. The caption keeps its 1400 (it -ends at 1464); the clock's count moves left of the minimap, ranged right -at 1648. +**The minimap** is a pane's own: its whole column of the map, small, in a +strip inside its frame at its right, the way a code editor shows a file +beside its text. Every pane that shows less than its column has one: the +source, the disassembly, the stack, a dump (the band's view, a hexdump +panel), a backtrace longer than twice its window. The registers show all +their rows and have none; a lens's drawing is whole and has none; a loupe +has none (it is held over the frame for a step or two, and its tag says +what it is). | Part | Drawn | | --- | --- | -| ground | the page, framed 1 in `rule` | -| panels | each map panel's outline, 1 in `rule`; a lens's drawing a `raised` block; a loupe a `lift` block | -| rows | each row of text a stroke 1 high, from where its text starts as long as it is (a twentieth of its characters' width), in its dominant ink at 45% toward the page: the file's shape, the stack's chains, a dump's bytes | -| windows | each working panel's window, 1 in primary, the panel in focus 2 | -| marks | the current row a gold stroke across its column, 2 high; a strike a vermilion block 3 by 3 at the row's start; a read a 3 by 3 frame in read's colour; held a vermilion pixel; the thread a gold stroke across the gutter | +| strip | 40 wide, inside the pane's frame at its right, 2 in from the rule, over its body (under the tag), on `well` (`101a48`). The pane's content keeps 8 from it: a pane with a strip has 832 for its content, the frame and tag still 880 | +| scale | fixed: a row of the map is 4 units (a stroke 3 high, 1 between), a row's 880 units 36 (a character two thirds of a unit). A column that fits is drawn whole from the strip's top; a longer one shows the rows round the pane's window, the window in the strip's middle and the strip clamped to the column's ends, with three faint dots at an end where it goes on, and it scrolls with the pane | +| rows | each run of text a stroke from where it starts, as long as it is, in its ink 65% of the way from the page: the file's indents and lengths; the disassembly's address, mnemonic, operands and a call's name; the stack's chains in their inks; a dump's bytes and readings. No text: at 4 units a row none could be read | +| window | the rows the pane shows, framed 2 in primary across the strip: the brightest thing in it | +| marks | at the row's left, 4 by 4, in this order: the current row gold (the pc's in the disassembly, the line's in the source), a strike vermilion, a read in read's colour; held a vermilion 2 by 2. An `arc` with an end off the window: a 2-unit line in its ink down the strip's left edge between its two rows. A block's first row (a graph's, shown linear): a 2-unit `rule` tick at the strip's left | -A mark outside every window is on the minimap and nowhere else: when the -step strikes a word the stack's window does not show, its block on the -minimap strikes with it, and `flash`es (a ring 8 across drawing out to -14 and gone, 12 f) so the eye goes there once. That is how nothing is -hidden at the working frame's size: it is only small. The minimap is -secondary action: every change on it starts 6 f after the primary onset -it follows, never on that frame; it fades and never travels, except its -windows, which glide with their scrolls. +It says where the window is in the whole (the line in the file, the +function among its neighbours, the frame in the stack, the node's row in +the heap), and what happens outside the window. A mark outside the window +is on the minimap and nowhere else: when the step strikes a word the +stack's window does not show, its row on the minimap strikes with it and +`flash`es so the eye goes there once. That is how nothing is hidden at the +working frame's size: it is only small. The minimap is secondary action: +every change on it starts 6 f after the primary onset it follows, never on +that frame. Its window glides with the pane's `scroll`. A far jump in the +same column (a `continue` to another loop, a return to a caller in view) +shows there first: the mark's new row lights gold on the strip and the +window glides to it (24 f, `glide`) before the pane fades through (12 out, +12 in); a jump out of the column (another function, another file) fades +the strip through with the pane. + +**What it costs**, measured on the rows the videos draw: 48 units of each +pane's width. The source's lines are cut four characters sooner (at 63 in +place of 67). The disassembly's annotation starts at 540 in place of 564, +so its room loses 24, not 48: `1004098 → 1004070 ← 9` stays whole, and +operands longer than 23 characters push it right as before. The stack's +roles and spans move 48 left and its chains end 48 sooner (one hop fewer, +then `more`, where a chain was long: `sqlite3VdbeExec+189…` is cut four +characters sooner). A dump's reading is cut 48 sooner, its pins 48 to the +left (`malloc's: a chunk of 32` still whole). The registers lose nothing, +and the registers carry the longest chains. + +**In the other forms.** + +- A [`descent`](#descent): one strip for the panel, the column of the + deepest window's function (the pc's), its window framed; the callers' + windows are other functions and not in it. A `descend` or `ascend` + fades the strip through (12 f) as the new window opens. +- The [`graph`](#graph) and the `blocks` lens: the lens's drawing is whole + and has none; its view, the disassembly round the pc, has the linear + column's strip with each block's first row ticked. The graph itself is + on the map, which is its own whole. +- [`aligned`](#aligned): one strip at the right of its 1792 panel, the + listing's whole column, a row of the listing a row of the strip; in + `columns` a row's two cells side by side, at the one scale. +- A [`pair`](#pair): each column's panes their own strips, and the shared + source its one. +- A [`loupe`](#loupe): none of its own; the pane it lies over keeps its + strip, covered where the loupe covers it. + +**The corner minimap is gone.** The working frame carried the whole map at +a twentieth in the caption band's corner (192 by 108): a column was 44 +units wide there and a row 1.2, and nothing in it could be told apart. +The map stays the picture of everything at once (a scene's opening, a +sprint, a far `continue`); in the working frame each pane carries its own +column at a size that reads, beside the rows it is the whole of, and the +`dive` makes each column into its pane's strip. The caption band is the +caption's and the clock's. ### clock and caption - **`clock`**: a 2-unit rule the width of the stage at y 900; gold, 4 high, along it as far as the recording has run; `moment 72 of 95` in - mono 20, faint, ranged right at 1648, left of the minimap. It says where the recording is, so + mono 20, faint, ranged right at 1856. It says where the recording is, so at a walk and a run it is still while a step plays: when the step's mark has landed, the step's piece of gold fades in (12 f; 8 f at a run) and the count changes as the fade starts. At a sprint the gold grows @@ -1561,9 +1643,9 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `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 | | `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 the map becomes the 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; the map, veiled, goes the same 72 f to the minimap's rect (1664, 912, 192 by 108), continuously, its scale from a half to a twentieth on its logarithm, so the windows rise out of it as it falls away; it is never dropped or hidden on the way; their outlines stay on it and land as the minimap's windows; as it lands (90 to 96) it crossfades into the minimap's own drawing. 72 to 96: the drawing, whose sizes differ between the two, crossfades from the map's to the frame's within its box. 84 to 96: the frame's tags, rules and lanes fade in; the veil on the map lifts as it lands. 96 to 132: still | -| `surface` | from the working frame to the map | the dive backwards, a little quicker: 0 to 12 the tags, rules and lanes fade out; 12 to 84, `glide`, the panels shrink into their windows as the minimap grows to fill the frame; 84 to 96 its veil lifts; then the map is still 36 f before anything plays on it | -| `flash` | the minimap, at a mark no window shows | a ring 8 across in the mark's colour draws out to 14 and is gone, 12 f, with the mark's own strike or read | +| `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. 72 to 96: the drawing, whose sizes 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) | +| `surface` | from the working frame to the map | the dive backwards, a little quicker: 0 to 12 the tags, rules and lanes fade out and each strip's strokes become its column's text; 12 to 84, `glide`, each pane shrinks into its window on the map as its strip unfolds into the column round it, the map's other parts fading in where they are; 84 to 96 the veil lifts; then the map is still 36 f before anything plays on it | +| `flash` | a pane's minimap, at a mark its window does not show | a ring 8 across in the mark's colour, on the mark's row in the strip, draws out to 14 and is gone, 12 f, with the mark's own strike or read | | `descend` | a call the narration follows down | 0 to 12 fire on the call row; rsp struck (24); the stack slides and the return address is struck (30 to 60), as for any call; then the caller's window closes round its call row, in two moves and never both at once: 66 to 78 the rows it gives up fade (those after its return row, and from its top as many as the callee needs), then 78 to 96 the rows it keeps glide up to their places (`glide`), where they move at all; 84 to 96 the call row's plaque becomes the ring; 96 to 114 the call lane draws down from the ring, head first, `standard`; 108 to 120 the callee's head fades in rising 8 as the lane reaches it; 114 to 138 its rows, top down, 2 f apart, 12 f each; 138 to 150 the advance: the plaque lands on the callee's first row, and the source line goes `waiting` (6 f) where the callee has none. Through a stub's `jmp`: the stub's other rows fade (12 f), then its `jmp` row, `pass`, glides to its place (18 f, `glide`), the lane runs on to the next head (18 f), the next window comes in the same way. A label that changes with it (the stack span's name, the source's tag) crossfades, 12 f | | `cross` | a `syscall` row, in a descent | 0 to 12 fire; 18 to 36 the registers that carry the call framed as read, 6 f apart, the argument rows under the row with them (`echo`); 48 to 72 the crossing lane draws down, 3 units, vellum; 66 to 78 the kernel's window opens as it lands, the vellum filling down from the lane's head; 78 to 90 its head and the call fade in, 6 f apart; the work (bytes given or filled, motion.md's chart); `returns` struck; then the answer climbs the lane (24 f) and rax is struck as it lands, the clobbered registers 6 f apart after it, the log's new row fading in (secondary); hold 36; the advance: the kernel's window draws back up into the lane (12 f) and the lane into the plaque (12 f) as the plaque moves on | | `ascend` | a `ret` out of a descent's window | 0 to 12 fire; 18 to 24 the return address framed as read on the stack; rsp struck (36); 48 to 72 the window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; 72 to 84 the lane draws back up into the ring; the caller's window opens in the reverse order of its closing: 84 to 102 the rows it kept glide back down (`glide`), then 102 to 114 the rows it gave up fade in; 114 to 126 the ring becomes a trail bar, the call row's annotation takes the result (6 f), and the plaque lands on the row after the call; the source line from `waiting` to `current` | @@ -1582,9 +1664,9 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `cascade` | a step | `fire` (12); then its effects a level at a time, 18 f apart: CPU (`reg`s, the pc's annotation), memory (`slot`s, `bytes`), the idea (the drawing, by `project`); each armed, then struck; hold 36 f after the last strike and 12 f a further value, 84 at most; `advance`; rest 24 f. A level with nothing on screen to change gives up its slot | | `continue` | a stop far from the last: a breakpoint, not a step. Where the windows' new places are farther than their own heights (another function, another file), it is told on the map: `surface`, the jump there, `dive` | `fire` on the line it leaves from; then the levels as in a `cascade`, but CPU is a wave: every register that changed is struck 2 f after the one above it, in pwndbg's order, the fill in over 6 f, no arm and no pulse (a dozen pulses at once are a flash, and a dozen arms a crowd); memory: the stack's window scrolls or fades to its new place, and the [backtrace](#backtrace)'s frames leave, slide and arrive; the idea; hold 36 f after the last strike; `advance`, the source and disassembly fading through if far; rest. Its marks are only on what was on screen to change | | `run` | steps that need not be read | over a graph, the mark goes from block to block in 8 f, each edge taken flashes to gold and cools in 8 f, counts change in place; at a sprint (on the map) the gold moves only when the block changes, 4 f at most each, the trail's three edges following and the lanes' counts ticking, and the picture settles at the phrase's end. Elsewhere: 18 f a step; no fire, arm or pulse; the mark, cards, nodes and pins ease in 8 f; no strikes, no held corners and no arcs drawing: a value changes in place under an 8 f crossfade, unmarked, and what the run changed is shown settled when it ends (its arcs fade in, 8 f, standing; no corners); no ties but the thread. A caption never names what a run veils. Registers, stack and disassembly are veiled from the first shortened step to the last; the source, the band and the clock are not. 24 steps at most. A run longer than a phrase may `surface` and play on the map | -| `sprint` | steps to be got through | 4 f a step. The drawing grows and the clock sweeps; the source and the band's view are veiled as well; the mark and the pins move only at a phrase's end. Each change of pace ramps at 0.6 of the step before. A sprint plays on the map: `surface` before it, `dive` after it, at the stop it reaches; the windows glide with the pc, the minimap's marks flash and fade | +| `sprint` | steps to be got through | 4 f a step. The drawing grows and the clock sweeps; the source and the band's view are veiled as well; the mark and the pins move only at a phrase's end. Each change of pace ramps at 0.6 of the step before. A sprint plays on the map: `surface` before it, `dive` after it, at the stop it reaches; the windows glide with the pc, the marks flash and fade | | `establish` | a scene's opening | done by 54 f: the panels fade in, 18 f each, 6 f apart (registers, stack, source, disassembly, the band's view, the drawing's panel: 0 to 48); from 30 f the drawing's elements fade in rising 8 units, 12 f each, 2 f apart in address order and all begun by 42 f, each with its row's quiet bracket (an `echo`: no lines). The first caption arrives at 60 f | -| `scroll` | a `source`, `disasm` or `stack` window | whole rows, 24 f, `glide`, before the level it makes room for; marks ride with their rows; the window's outline on the minimap glides with it, the same 24 f. A column's `lead` and the line numbers are the rows' on screen: they change on the scroll's first frame, never before. A window going farther than its own height (ten lines, nine instructions, six slots) does not scroll, which would only blur: it fades out (12 f) and in at its new place (12 f), and what it brings comes in with no marks | +| `scroll` | a `source`, `disasm` or `stack` window | whole rows, 24 f, `glide`, before the level it makes room for; marks ride with their rows; the window on the pane's minimap glides with it, the same 24 f (a window fading through moves on its minimap with the fade's out, so the strip shows where it went first). A column's `lead` and the line numbers are the rows' on screen: they change on the scroll's first frame, never before. A window going farther than its own height (ten lines, nine instructions, six slots) does not scroll, which would only blur: it fades out (12 f) and in at its new place (12 f), and what it brings comes in with no marks | | `relayout` | a change of split | the drawing fades out (12 f); every panel moves to its new box, clipped to the box as it moves (48 f, `glide`); the drawing fades in at its new size (12 f). Nothing else moves under it | | `visit` | the camera | the target framed first (24 f), the rest veiled (18 f); the move 72 f, `glide`. The panel's tag and whole rows in frame, the rows the visit's steps change in its middle third, never at its edge; a stack visited holds its window still. A visit never veils or clears a panel a drawn tie starts or ends in: it waits until the tie has drawn back, or frames both ends. 120 f at most without a change; back | | `say` | the caption | out 12 f, gap 6 f, in 18 f; the numbers are under [caption](#clock-and-caption) | @@ -1681,7 +1763,7 @@ python3 -B context.py && for n in 12-calls-subject 13-sqlite-row 14-sqlite-page; resvg 17-operands.svg 17-operands.png python3 -B heap.py && for n in 18-heap 18-heap-free; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done python3 -B graph.py && for n in 22-graph-sort 23-graph-open 24-graph-strip 25-blocks-lens; do resvg $n.svg $n.png; done -python3 -B pair.py && for n in 26-pair-rest 27-pair-store 28-pair-part; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done +python3 -B pair.py && for n in 26-pair-rest 27-pair-store 28-pair-part 38-pair-ret; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done python3 -B intro.py && for n in 29-intro-bytes 30-intro-words 31-intro-stack 32-intro-code 33-aligned 34-segments \ 35-segments-abc 36-aligned-columns 37-regroup; do resvg $n.svg $n.png; done for n in 30-intro-words 34-segments 36-aligned-columns; do resvg -w 480 $n.svg $n-480.png; done @@ -1694,16 +1776,17 @@ python3 -B gen.py # 1 to 8, then resvg the same way | Mock | Is | Blocks it shows | | --- | --- | --- | -| [9](mock/09-context.png) | `beside`, at rest: `targets/list` stopped at the load in `reverse` (`mock/list-dbg.txt`, moment 2) | every panel; the band as two panels; `address` with `lead`; `chain` cut by `more`; `reg`, rip with flags; `slot` with offsets and roles, `pin` row; `call` spans; `insn` current, ahead, outside under a rule and its name; `line`; `bytes` by fields with number, pointer, loose; an `arc` standing in the view; `nodes` with pins under, two names on one; `thread`; marks current, held; the minimap, its windows | -| [10](mock/10-context-step.png) | the same, mid-step: the load done (moment 3) | `struck` on rdi; `read` on the annotation, the run and the node's half (`echo`); `link` ending in rdi's pin; `projection`; the read pointer's `arc` at full ink; the minimap | -| [11](mock/11-context-lens.png) | `subject`, mid-step | the band at 296 and 200, the drawing a size up, a dump of seven, nine instructions, six slots; the minimap with the subject's windows | +| [9](mock/09-context.png) | `beside`, at rest: `targets/list` stopped at the load in `reverse` (`mock/list-dbg.txt`, moment 2) | every panel; the band as two panels; `address` with `lead`; `chain` cut by `more`; `reg`, rip with flags; `slot` with offsets and roles, `pin` row; `call` spans; `insn` current, ahead, outside under a rule and its name; `line`; `bytes` by fields with number, pointer, loose; an `arc` standing in the view; `nodes` with pins under, two names on one; `thread`; marks current, held; each pane's minimap (source, disassembly, stack, the view), its window, the current row; the registers and the drawing without | +| [10](mock/10-context-step.png) | the same, mid-step: the load done (moment 3) | `struck` on rdi; `read` on the annotation, the run and the node's half (`echo`); `link` ending in rdi's pin; `projection`; the read pointer's `arc` at full ink; the minimaps: the pc gold and the read cyan on the disassembly's, the read row on the view's; the annotation at 540, whole | +| [11](mock/11-context-lens.png) | `subject`, mid-step | the band at 296 and 200, the drawing a size up, a dump of seven, nine instructions, six slots; the minimaps at the subject's window sizes, the disassembly's and the stack's scrolled round their windows | | [12](mock/12-calls-subject.png) | `calls` as subject, mid-step: moments 752 to 753 of the fib scene, `fib(4)` calling `fib(2)` | `calls`: nodes current, waiting, done, the caller, results on the shoulder; the `backtrace` as its view, with arguments, newest at the bottom beside the tree; `call` spans with arguments; the stack's row with offsets and a role; a `projection` from the return address to the new node; operands of 27 characters whole | | [13](mock/13-sqlite-row.png) | the `backtrace` lens, at rest after a `continue`: stop 120 of the sqlite scene, at `sqlite3BtreeInsert+4` | the backtrace as the band's drawing, `#0` at the bottom over its source line; a `hexdump` by `fields` of a struct on the stack: twelve-digit addresses, pointer fields and `NULL`, `loose` padding and the bytes past the struct, `pad`, two fields framed as the caption names them, the reading as a list; wide line numbers in the source and the disassembly; frame names whole, shortening the chains beside them; `held` on every register the continue changed, none on the stack's window, which faded in | | [14](mock/14-sqlite-page.png) | `syscalls` as subject, at rest after the crossing: stop 169, `pwrite64` back in `unixWrite` | the calls so far in the band, strace's way, the newest whole and held; the call through a pointer by its target's name, `→ __pwrite64`; a page by `fields` as the kernel took it (`given`): big-endian numbers, bytes left to the eye, text, a `more` row of 253; the stack's window scrolled into the frame (`rsp+20 to rsp+48`), its span open above; flags and registers the crossing changed | | [15](mock/15-marks.png) | the marks sheet: `current`, `struck`, `held` as A (the first videos), B (the catalogue's) and C (a whiter reading), on rows of the list at the load and the store after it | the source's current line; the pc's row; rip; a struck and two held registers; a dump row struck on the one byte that changed and one held; a lens's cell held and struck; the same rows at 1.35 times | | [19](mock/19-map.png) | the map, mid-step with a loupe open: the same moment unfolded on 3840 by 2160 ([at 1080p](mock/19-map-1080.png)) | the file whole; 69 instructions; memory, the registers, the backtrace whole; the stack from 16 words above rsp, continued at the third column's foot and folded into `more` at the process's start; the loupe as a panel beside memory; `arc`s in memory, the loupe and the stack (the frame chain left to the spans); the key; the thread across the gutter; the working frame's windows outlined | -| [20](mock/20-dive.png) | `dive`, four instants on one sheet, each at the working frame's size | frame 0 the map; 24 the windows bright, the rest veiled; 60 halfway, the panels rising out of the map as it falls to the corner; 96 the working frame with its minimap | -| [21](mock/21-loupe.png) | the working frame mid-step with a `loupe` open | the loupe hanging from rdi over the registers under it, its node framed, the chain 1004090 → 1004070 → 1004050 as `arc`s in one lane (the view withholds them while the loupe is open); the minimap with the loupe at its place on the map, outlined bright | +| [20](mock/20-dive.png) | `dive`, four instants on one sheet, each at the working frame's size | frame 0 the map; 24 the windows bright, the rest veiled; 60 halfway, the panels rising out of the map, each column squeezing toward its pane's strip, the rest fading where it is; 96 the working frame, each pane with its minimap | +| [21](mock/21-loupe.png) | the working frame mid-step with a `loupe` open | the loupe hanging from rdi over the registers under it, its node framed, the chain 1004090 → 1004070 → 1004050 as `arc`s in one lane (the view withholds them while the loupe is open); no minimap for the loupe: the panes' strips stand as in 10 | +| [39](mock/39-minimap-1to1.png) | three panes' minimaps cut from 10 at 1:1, a pixel of 1080p a unit | what a strip lets a viewer read at 1080p: the column's shape and inks, the window, the pc gold, a read cyan; the stack's 48 of 103 rows round its window | | [16](mock/16-descent.png) | the syscalls scene's `open` followed down, four instants of the program column (`ztrace dbg` on `anim/tools/hello.c`, moments 1 to 6) | `descent`: main's window, its spare rows above its call and one row after it, the PLT stub's head directly under that row (its neighbour `_start` `outside`), libc's `open`, the kernel's window on vellum; `insn` `waiting` and `pass`; the call lane and the crossing lane; `line` `waiting` and the waiting thread; a PLT target named, an indirect jump's target, a `lea`'s result, a named place (the canary), a system call's number and its arguments hanging under it; libc's twelve-digit addresses moving their own window's columns; the descent closed again, the call `ran` with its result | | [17](mock/17-operands.png) | operands before and after, on real rows of list, hello and libc's `open`; then the row's detail | size words gone; `width` on an immediate store, a byte compare, a sign-extending load; padding faint; a compare's two values and the flags it leaves; conditionals reading them; `lea`'s sum; an indirect jump through `open@got` | | [18](mock/18-heap.png) | the heap scene, five instants of the band: `ztrace dbg` on `mock/heap.c`, glibc 2.44, after each malloc and free (2 a run's end, settled, unmarked) | `nodes` in two rows, a `bin` heading the second (`dummy tcache` before the first free); a free chunk drawn `freed`, its link in its first word; `bytes` read as `size` (`0x20 a m P`) and `protected` (`→ 405050 ^ 405`), notes (`key`, `the old link`); the free list and the program's list as `arc`s; struck bytes, one byte of a pointer struck alone | @@ -1712,9 +1795,10 @@ python3 -B gen.py # 1 to 8, then resvg the same way | [23](mock/23-graph-open.png) | libc's `open` at its `syscall` (mock 16's moment 4): 19 blocks, the run's 8, the 11 never reached folded into five boxes by what they are | folds of unreached blocks, named; blocks the run will reach but has not yet, plain; twelve-digit heads, offsets in the rows | | [24](mock/24-graph-strip.png) | reverse's loop, four instants | `leave`: the condition's chips, the edge lit, the mark halfway along it; `turn`: the back edge climbing with the mark on it, its count struck; the way out | | [25](mock/25-blocks-lens.png) | sort at moment 370 in the working frame with the `blocks` lens | the graph as shapes in the band, the pc's box gold, the trail; its view the disassembly round the pc, out of the program column, which holds the source alone; registers and stack of the moment | -| [26](mock/26-pair-rest.png) | the `pair` at the loop, i = 15: plain and ASan builds of `overflow.c` | the shared source with each run's mark on its side; two disassemblies aligned by line, ASan's `only here` rows; the line's registers; plain's stack with the red zone's `buf` and `i`, ASan's fake frame with its shadow on each word's row, `buf` facing `buf`, the saved rbp facing the redzone (`differs`) | -| [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 | -| [28](mock/28-pair-part.png) | i = 16, the step in which they part | plain's store struck into the saved rbp's low byte; ASan's shadow load framed reading `f3`, its compare and the branch not taken; `differs` on the facing rows | +| [26](mock/26-pair-rest.png) | the `pair` at the loop, i = 15: plain and ASan builds of `overflow.c` | the shared source with each run's mark on its side; two disassemblies aligned by line, ASan's `only here` rows; the line's registers; each frame as bytes (`hexdump` `eight`): plain's `i`, `buf` (`41`s and their `"AAAAAAA"`), the saved rbp and the return address under the span; ASan's fake frame, its header's fields and shadow beside each row, the real stack's way back under a rule; `buf` facing `buf`, the saved rbp facing the redzone (`differs`) | +| [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 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 | | [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 | @@ -1763,7 +1847,9 @@ the band. band's view); two in the working frame; a third closing the first. - The minimaps of 12 to 18: their recordings hold a stack of 64 words or less and no bytes round targets, so their maps would be mostly gaps. -- `surface`, `flash`, a window's outline gliding on the minimap. +- `surface`, `flash`, a window gliding on its minimap, a far jump seen on a + strip before the pane fades through; an `arc`'s end on a strip; a + `descent`'s and `aligned`'s strips. - `enlarge` and a dump's place in motion (charts only); treatments B and C of `segments` at their own sizes (the sheet has them as frames); `align` between `interleaved` and `columns`; `columns` with a pc in a long run, @@ -1849,8 +1935,9 @@ is not checked here. The tokens are under [Token changes](#token-changes). and the sprint over it. 8. **The pair** ([`pair`](#pair)): the split with a seam, the shared source with a mark per run, two columns of one run each, alignment by - line and by variable, `only here` and `differs`, the shadow on an ASan - run's stack rows, one clock with two moment counts, two minimaps at a + line and by variable, `only here` and `differs`, each run's frame as bytes + (`hexdump` `eight`, by the frame's fields, a byte stored past its field + keeping that field's ink), the shadow beside an ASan run's rows, one clock with two moment counts, each pane's minimap at a fortieth, the stopped side holding, a run's stderr as a panel; steps matched by source line or loop turn. 9. **The introduction's blocks** ([`segments`](#segments), [`aligned`](#aligned)): @@ -1874,6 +1961,16 @@ is not checked here. The tokens are under [Token changes](#token-changes). `time.first_step` 4 s (5 s when a scene opens on the map), `time.dive` and `time.flash`. +11. **Each pane's minimap** ([the minimap](#the-map-and-the-minimap)), + in place of the corner one: a strip inside each pane's frame drawn from + its column of the map, at the fixed scale, scrolled round the window; + its window, marks and arcs' ends; `flash` there; the pane's content 48 + narrower and the disassembly's annotation at 540; the window gliding + with `scroll` and a far jump shown on the strip before the pane fades + through; `dive` and `surface` squeezing each column into its strip and + back; the clock's count at 1856. The corner minimap and its `K = 1/20` + go. + **What the recordings must hold**, with the tracer's options: - For the map, as before: `--stack 1024`, `--disasm 69`, `--around 256`; @@ -1948,6 +2045,7 @@ loupe's and the arc's tokens, the lift's colours, the clock's count at | `time.spread` | none | rows 0.60 (`glide`, blocks 0.067 apart), then frames 0.20, then edges 0.20 each, 0.033 apart | | `time.ascend` | none | `close` 0.20 a row, 0.03 apart, from 0.80; the lane back 0.20; the caller's kept rows 0.30 (`glide`), then the given-back rows 0.20; the step 2.50 | | `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.minimap` | the corner's: 192 by 108 at 1664, 912, a twentieth; the clock's count at 1648 | a pane's own: a strip 40 wide inside its frame at its right, 2 in, over its body, on `well`; the content 8 from it (832 of 880); a row 4 (a stroke 3), a row's 880 to 36; strokes 65% of their ink; the window 2 in primary; marks 4 by 4 at a row's left; three dots where a column goes on; no strip on the registers, a lens's drawing, a loupe. The disassembly's annotation at 540 in a pane with a strip. The clock's count at 1856 | | `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 | | `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` | |
