From bbabc78dcfd00a98abb5ececae6761bccc496eb8 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 10 Nov 2026 22:16:50 -0300 Subject: design: four times the context on a 4K stage; the loupe; quieter marks From the user, after the second videos. The stage is 3840 by 2160 at the same type size: four columns (source, disassembly, state, stack), 69 lines, rows and slots with no lens, 43 with a lens as subject, dumps of 32 rows. Code reads at 1440p and up; the caption, the clock and a lens's drawing are doubled, and the camera at x2 is the old frame. The stack's rows carry their offset from rsp and a role. A loupe is the telescope as a floating panel: the memory round what a pointer leads to, lifted over the context, a pointer inside it opening the next. The current row is a white wash, a strike a softened vermilion, held a turned corner; sheet 15 sets the alternatives side by side. Co-Authored-By: Claude Fable 5.2 --- design/mock/dense.py | 441 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 441 insertions(+) create mode 100644 design/mock/dense.py (limited to 'design/mock/dense.py') diff --git a/design/mock/dense.py b/design/mock/dense.py new file mode 100644 index 0000000..cb047ac --- /dev/null +++ b/design/mock/dense.py @@ -0,0 +1,441 @@ +#!/usr/bin/env python3 +"""The frame on the 4K stage: four columns of 880, the context at mono 20, four times what 1080 held. + + python3 -B dense.py # writes 15-marks.svg, 16-none.svg, 17-subject.svg, 18-loupes.svg + +The blocks are context.py's, placed on the 4K stage's columns; what is new here is the stage, the thread across +the gutter, the `loupe`, and the marks sheet. The moment is real: a fresh recording of the same `targets/list`, +`ztrace dbg --stack 1024` with a breakpoint at `reverse+22` (the load at line 21), its second stop and the +instruction after (`list-dbg.txt`, kept beside this file), and the program's disassembly with its lines +(`objdump -dl`, `list.dis`). +""" +import re + +import gen +gen.W, gen.H = 3840, 2160 # the Svg's canvas: the 4K stage, in units +import context as C +from context import (PAGE, RAISED, VELLUM, BRIGHT, DIM, FAINT, INK, GOLD, VERM, READ, HEAP, STACK, A, S, ROW, + TAG, PAD, MONO, BOLD, b, ph, tw, mix, bracket, chain, Svg, S_, H_, C_, D_, P) + +W4, H4 = 3840, 2160 +COL = [112, 1024, 1936, 2848] # four columns of 880, gutters of 32 +CW = 880 +TOP4, BOT4 = 96, 1784 # the stage: 1688, a single panel of 69 rows +C.W = W4 +C.TOP, C.BOTTOM = TOP4, BOT4 +C.LANE_LINK, C.LANE_VIEW = 1912, 1924 # the gutter between the program's columns and the state's +THREAD_X = 1008 # the gutter between the source and the disassembly +LIFT, LIFT_TAG, SHADE = "#121c52", "#22317a", "#02061a" # a loupe's surface, its tag, its shadow + + +def put(x): + """Place the next block in the column at x.""" + C.LX = C.RX = x + + +# ---- the recording ---------------------------------------------------------------------------------- +DBG = open(__file__.replace("dense.py", "list-dbg.txt")).read() +MEM = {} +for line in DBG.split("\n"): + m = re.match(r"^([0-9a-f]{12}) ((?:[0-9a-f?]{2} ){16})", line) + if m and "??" not in m.group(2): + for i, v in enumerate(m.group(2).split()): + MEM[int(m.group(1), 16) + i] = int(v, 16) +NAMES = {0x1001730: "_start", 0x1001830: "list_done", 0x1001860: "main", 0x10018e0: "push", 0x1001910: "reverse", + 0x1001938: "_init", 0x1001954: "_fini"} +LIBNAMES = {0x7ffff7c27781: "libc+27781", 0x7ffff7c278b9: "__libc_start_main+137", 0x7ffff7fe0c60: "ld.so+22c60", + 0x7ffff7fbc000: "vdso+0"} + + +def region(v): + """The ink of what v points into, by the run's mappings (None: no mapping).""" + for lo, hi, ink in [(0x7ffffffde000, 0x7ffffffff000, S_), (0x1004000, 0x1025000, H_), (0x1001000, 0x1002000, C_), + (0x1000000, 0x1001000, VELLUM), (0x1002000, 0x1003000, VELLUM), (0x1003000, 0x1004000, D_), + (0x7ffff7c24000, 0x7ffff7d9f000, C_), (0x7ffff7c00000, 0x7ffff7c24000, VELLUM), + (0x7ffff7e15000, 0x7ffff7e23000, D_), (0x7ffff7fbc000, 0x7ffff7fbe000, C_), + (0x7ffff7fbf000, 0x7ffff7fec000, C_), (0x7ffff7ffb000, 0x7ffff7fff000, D_)]: + if lo <= v < hi: + return ink + return None + + +def name(v): + if v in LIBNAMES: + return LIBNAMES[v] + f = max((a for a in NAMES if a <= v), default=None) + return "%s+%d" % (NAMES[f], v - f) if f is not None else "%x" % v + + +def word(a): + if all(a + i in MEM for i in range(8)): + return sum(MEM[a + i] << (8 * i) for i in range(8)) + return None + + +def text(a): + """The C string at a, if there is one of two characters or more.""" + out = [] + while a + len(out) in MEM and MEM[a + len(out)] and 32 <= MEM[a + len(out)] < 127: + out.append(chr(MEM[a + len(out)])) + return "".join(out) if len(out) >= 2 and MEM.get(a + len(out)) == 0 else None + + +def follow(v, depth=5): + """A chain from the address v, as far as the recording holds the memory: (links, end) for context.chain.""" + links = [] + while True: + ink = region(v) + if ink == C_: + return links + [(v, C_, name(v))], None + links.append((v, ink)) + s = text(v) + if s: + return links, ("str", s) + w = word(v) + if w is None or len(links) > depth: + return links, None + if w and region(w): + v = w + continue + return links, ("int", w) + + +def value(v): + return follow(v) if v and region(v) else ([], ("int", v)) + + +RSP = 0x7fffffffece0 +FRAMES = [("reverse", 0, 1), ("main", 2, 5), ("libc+27781", 6, 27), ("__libc_start_main", 28, 39), ("_start", 40, 99)] +# What a slot is, where the recording can know it: a saved register (the frame-pointer chain; the prologue's pushes, +# from the call frame information), the process's start (argc, argv, envp, auxv, from the first stack pointer). A +# return address needs no word: its chain is code, named, and its frame's bracket ends on it. +ROLES = {0: "saved rbp", 3: "saved rbx", 4: "saved rbp", 26: "saved rbp", 38: "saved rbp", 42: "argc", 43: "argv[0]", + 44: "argv end", 45: "envp end", 46: "auxv"} + + +def stack_rows(n, rbp_rsp=True): + rows = [] + for i in range(n): + a = RSP + 8 * i + links, end = value(word(a)) + rows.append((a, (["rbp", "rsp"] if i == 0 and rbp_rsp else []), links, end)) + return rows + + +def roles(n): + return {i: (t, DIM) for i, t in ROLES.items() if i < n} + + +def regs(step): + rdi = 0x1004070 if step else 0x1004090 + out = [] + for r, v in [("rax", 0x1004090), ("rbx", 0), ("rcx", 0x10040b0), ("rdx", 0), ("rsi", 0x10040c0), ("rdi", rdi), + ("rbp", RSP), ("rsp", RSP), ("r8", 0x7ffff7e19ac0), ("r9", 0x20), ("r10", 0x10), ("r11", 0x7ffff7e19ac8), + ("r12", 0x7fffffffee38), ("r13", 1), ("r14", 0x7ffff7ffd000), ("r15", 0x10029c0)]: + links, end = value(v) + if r == "r14": # ld.so's data: the recording followed it (ztrace's own telescope) + links, end = [(0x7ffff7ffd000, D_), (0x7ffff7ffe3c0, D_)], ("int", 0) + if r == "r15": + links, end = [(0x10029c0, VELLUM)], ("int", 1) + out.append((r, links, end)) + out.append(("rip", [(0x1001926, C_, "reverse+22")], None)) + return out + + +FLAGS = [("CF", 0, 0), ("PF", 1, 0), ("AF", 0, 0), ("ZF", 0, 0), ("SF", 0, 0), ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)] +BT = [("reverse+22", "", "list.c", 21), ("main+80", "", "list.c", 40), ("libc+27781", "", None, 0), + ("__libc_start_main+137", "", None, 0), ("_start+37", "", None, 0)] +NODES = [(0x10040b0, 1, 0), (0x1004090, 4, 0x1004070), (0x1004070, 9, 0x1004050), (0x1004050, 16, 0x1004030), + (0x1004030, 25, 0x1004010), (0x1004010, 36, 0)] +SRC = C.SRC[:42] + [""] * 40 + + +def heap_fields(base, length, read_at=None): + """The heap's words by what the program and malloc made of them: each node a value and a next, each chunk's + size word malloc's, the top chunk's size word, and the rest loose. The word at read_at carries mark 9.""" + out = [] + for a, _, _ in NODES: + out += [(a - base, 8, "number", False, None), (a + 8 - base, 8, "pointer", False, 9 if a + 8 == read_at else None), + (a - 8 - base, 8, "malloc", False, None)] + out.append((0x10040c8 - base, 8, "malloc", False, None)) + return [f for f in out if 0 <= f[0] < length] + + +def conv(mn, ops): + """objdump's Intel syntax as the recording's disassembler writes it.""" + if mn.startswith("data16") or mn == "cs": + return "nop", "word ptr cs:[rax + rax]" + ops = ops.lower().replace(",", ", ") + ops = re.sub(r"\[(.*?)\]", lambda m: "[" + re.sub(r"([+*-])", r" \1 ", m.group(1)).replace(" * ", "*") + "]", ops) + ops = ops.replace("*1 + 0x0", "").replace(" + 0x0]", "]") + + def num(m): + v = int(m.group(1), 16) + return str(v) if v < 10 else "0x%x" % v + ops = re.sub(r"rip \+ 0x(f{8}[0-9a-f]+)", lambda m: "rip - 0x%x" % ((1 << 64) - int(m.group(1), 16)), ops) + ops = re.sub(r"(?:", l) + if m: + func = m.group(2) + continue + m = re.match(r"^targets/list\.c:(\d+)", l) + if m: + line = int(m.group(1)) + continue + m = re.match(r"^\s+([0-9a-f]+):\s+(\S+)\s*(.*)$", l) + if m: + ops = re.sub(r"\s*<[^>]+>", "", re.sub(r"\s+#.*", "", m.group(3))).strip() + mn, ops = conv(m.group(2), ops) + own = func in ("main", "push", "reverse", "list_done") + rows.append((int(m.group(1), 16), func, line if own else None, mn, ops)) + return rows + + +CALLEES = {0x1001990: "printf", 0x10019a0: "malloc", 0x1001980: "strtol"} + + +def window(n, step): + """n instructions round the pc: the function's and its neighbours', each neighbour under a rule and its name.""" + rows = disasm_rows() + i = [r[0] for r in rows].index(0x1001926) + lo = max(0, min(i - n // 2, len(rows) - n)) + out, last_func = [], None + for a, func, line, mn, ops in rows[lo:lo + n]: + target = re.fullmatch(r"([0-9a-f]{6,})", ops) + parts = [(int(ops, 16), C_)] if target else ([(ops, P)] if ops else []) + st = "cur" if a == 0x1001926 else None + note = None + if func != "reverse": + st = "other_first" if func != last_func else "other" + if func != last_func: + note = ("text", func, DIM) + if mn == "call" and target and int(ops, 16) in CALLEES: + note = ("text", CALLEES[int(ops, 16)], VELLUM) + if a == 0x1001926: + note = ("chain", [(0x1004098, H_), (0x1004070, H_)], ("int", 9), {0: "read"} if step else None) + out.append((a, line, mn, parts, st, note)) + last_func = func + return out + + +# ---- the stage's blocks ------------------------------------------------------------------------------- +def thread_across(g, ys, spans): + """The thread on the 4K stage: the source and the disassembly side by side, the gutter between them its + channel. A bracket on the line at the source's right edge, one on each run at the disassembly's left, a + line down the gutter between.""" + x0, x1 = COL[0] + CW + 6, COL[1] - 6 + bracket(g, x0, ys + 2, ys + ROW - 2, GOLD, 4, 7, side=-1) + tops = [ys + 12] + for ya, yb in spans: + bracket(g, x1, ya + 2, yb - 2, GOLD, 4, 7) + tops.append((ya + yb) / 2) + g.rect(THREAD_X, (ya + yb) / 2 - 2, x1 - THREAD_X, 4, GOLD) + g.rect(x0, ys + 10, THREAD_X - x0, 4, GOLD) + g.rect(THREAD_X - 2, min(tops) - 2, 4, max(tops) - min(tops) + 4, GOLD) + + +def clock4(g, moment, total): + g.rect(COL[0], 1798, 3616, 4, C.RULE) + g.rect(COL[0], 1796, 3616 * moment / total, 8, GOLD) + g.t(COL[3] + CW, 1852, "moment %d of %d" % (moment, total), 40, FAINT, "mono", "end") + + +def caption4(g, lines): + """The caption, twice the 1080 frame's: Go 80 on 108, code mono 70; so it reads the same at 1080p.""" + y = 1824 + (104 if len(lines) == 2 else 156) + for parts in lines: + g.rich(COL[0], y, [(p[0], VELLUM) + tuple(p[1:]) for p in parts], 80) + y += 108 + + +def loupe(g, x, y, title, note, base, flist, framed, depth): + """`loupe`: the memory round a pointer's target, floating over the context, tied to the pointer it opens + from. Nine rows, the target's in the middle; the target framed bright. Lifted: its own surface, a shadow + under it, deeper for a loupe opened from another. Returns its rows' y.""" + h = ph(9) + sx, sy = (12, 16) if depth == 1 else (20, 26) + g.rect(x + sx, y + sy, CW, h, SHADE) + g.rect(x, y, CW, h, LIFT) + g.rect(x, y, CW, TAG, LIFT_TAG) + g.frame(x, y, CW, h, DIM, 2) + xx = x + 12 + for s_, ink in title: + g.t(xx, y + 18, s_, S, ink, MONO) + xx += len(s_) * A + g.t(x + CW - 10, y + 18, note, 18, DIM, "sans", "end") + return C.fields(g, y, h, "", base, 144, flist, MEM, HEAP, region, framed=framed, bare=True, x=x) + + +def stem(g, pts): + """The tie from a pointer to its loupe: a link, in the ink of what it points into, head on the loupe.""" + gen.arrow(g, pts, HEAP, 4, r=8, hl=12, hw=12) + + +# ---- the frames ---------------------------------------------------------------------------------------- +def frame_none(name, step, loupes=False): + """`none` on the 4K stage: source | disassembly | registers, backtrace, memory | stack.""" + g = Svg() + put(COL[0]) + ys = C.source(g, TOP4, 69, SRC, 1, 21, [], "list.c", 42) + put(COL[1]) + at = C.disasm(g, TOP4, window(69, step), "reverse", 21) + thread_across(g, ys, [(at[0x1001926], at[0x1001926] + ROW)]) + put(COL[2]) + marks = {"rax": {0: "tick"}, "rcx": {0: "tick"}, "rdi": {0: "strike" if step else "tick"}} + where = C.registers(g, TOP4, regs(step), FLAGS, marks) + C.backtrace(g, 548, 416, BT, x=COL[2], note="newest on top") + C.fields(g, 976, 808, "the heap, round what the step reads", 0x1004000, 512, + heap_fields(0x1004000, 512, 0x1004098), MEM, HEAP, region, marks=(9,) if step else (), title="memory") + put(COL[3]) + C.stack(g, TOP4, stack_rows(69), FRAMES, note="69 words from rsp", rsp=RSP, roles=roles(69)) + if loupes: + ry = where["rdi"] + x1, y1 = 2728, ry + r1 = loupe(g, x1, y1, [("rdi", DIM), (" → ", FAINT), ("1004070", HEAP)], "heap · struct node, 16 bytes", + 0x1004030, heap_fields(0x1004030, 144), [(0x1004070 - 0x1004030, 16)], 1) + stem(g, [(COL[2] + 72 + 7 * A + 30 + A + 16, ry + 12), (x1, ry + 12)]) # from the end of rdi's chain + # the next word in it opens the next: the field's bytes bracketed, a stem down into the deeper loupe + fy = r1[0x1004070] + bx0 = x1 + 132 + 8 * 30 + 12 - 4 + bx1 = x1 + 132 + 15 * 30 + 12 + 28 + g.rect(bx0, fy + ROW + 1, bx1 - bx0, 3, HEAP) + x2, y2 = x1 + 120, fy + ROW + 34 + loupe(g, x2, y2, [("1004078", HEAP), (" → ", FAINT), ("1004050", HEAP)], "heap · struct node, 16 bytes", + 0x1004010, heap_fields(0x1004010, 144), [(0x1004050 - 0x1004010, 16)], 2) + stem(g, [((bx0 + bx1) / 2, fy + ROW + 4), ((bx0 + bx1) / 2, y2)]) + clock4(g, 3 if step else 2, 4) + if loupes: + caption4(g, [[("The load is done: ",), ("rdi", "mono"), (" holds ",), ("1004070", "mono"), + (", and beside it the heap round it opens.",)], + [("Its ",), ("next", "mono"), (" word opens the node after it, one deeper.",)]]) + else: + caption4(g, [[("Stopped in ",), ("reverse", "mono"), (", about to load ",), ("head->next", "mono"), (".",)], + [("rdi", "mono"), (" points at a node; the word after its value is the next node.",)]]) + g.save(name) + + +def frame_subject(name): + """`subject` on the 4K stage, mid-step: the list drawn twice the size over the program's two columns, its + bytes over the third, the context under and beside them.""" + g = Svg() + band = 604 + put(COL[2]) + view = C.fields(g, TOP4, 800, "the heap, 1004000 to 10041ff", 0x1004000, 512, + heap_fields(0x1004000, 512, 0x1004098), MEM, HEAP, region, marks=(9,)) + where = C.registers(g, 908, regs(True), FLAGS, {"rax": {0: "tick"}, "rcx": {0: "tick"}, "rdi": {0: "strike"}}) + C.backtrace(g, 1360, 424, BT, x=COL[2], note="newest on top") + put(COL[0]) + pins = {0x10040b0: ["rcx"], 0x1004090: ["rax"], 0x1004070: ["rdi"]} + C.RX = COL[2] # the link leaves the registers, the projection the view + C.lens(g, TOP4, band, 800, NODES, pins, {"tick": [0x10040b8], "read": 0x1004098}, 0x1004000, 32, + link_from=(where["rdi"], "rdi"), subject=True, dw=2 * CW + 32, k=2, view_rows=view) + put(COL[0]) + ys = C.source(g, TOP4 + band + 12, 43, SRC, 1, 21, [], "list.c", 42) + put(COL[1]) + at = C.disasm(g, TOP4 + band + 12, window(43, True), "reverse", 21) + thread_across(g, ys, [(at[0x1001926], at[0x1001926] + ROW)]) + put(COL[3]) + C.stack(g, TOP4, stack_rows(69), FRAMES, note="69 words from rsp", rsp=RSP, roles=roles(69)) + clock4(g, 2, 4) + caption4(g, [[("The load read the word at ",), ("1004098", "mono"), (": the address of the next node.",)], + [("rdi", "mono"), (" holds it now, and points at the node whose value is 9.",)]]) + g.save(name) + + +def frame_marks(name): + """Mock 15: current, struck and held, as the first videos drew them (A), as the catalogue now does (B), and + the other reading of "white, with less opacity" (C), on real rows of the same moment and the one after.""" + g = Svg() + xs = [112, 1376, 2640] + titles = [("A", "the first videos: gold band, solid vermilion, a tick"), + ("B", "recommended: a white wash, a softened strike, a turned corner"), + ("C", "white: a white plaque, a white strike framed in vermilion, a bar under")] + g.t(112, 120, "current, struck, held", 40, BRIGHT, "sansm") + g.t(112, 164, "Rows of targets/list at the load in reverse (moment 3) and the store after it (moment 4), at the " + "4K stage's density: mono 20, rows of 24. Look at it at full size.", 24, DIM, "sans") + for (key, label), x in zip(titles, xs): + C.STYLE.update(current=key, struck=key, held=key) + g.t(x, 244, key, 56, GOLD if key == "B" else BRIGHT, "sansb") + g.t(x + 56, 236, label, 22, DIM, "sans") + put(x) + y = 280 + ys = C.source(g, y, 6, SRC, 18, 21, [20], "list.c", 42) + y += ph(6) + 24 + rows = [r for r in window(69, True) if 0x1001919 <= r[0] <= 0x100192e] + rows = [(a, ln, mn, ops, "trail0" if a == 0x1001923 else st, note) for a, ln, mn, ops, st, note in rows] + C.disasm(g, y, rows, "reverse", 21) + y += ph(len(rows)) + 24 + reg = [r for r in regs(True) if r[0] in ("rax", "rcx", "rsi", "rdi", "rbp")] + [regs(True)[-1]] + y0 = C.panel(g, x, y, CW, len(reg), "registers") + for i, (r, links, end) in enumerate(reg): + yy = y0 + i * ROW + if r == "rip": + g.t(x + 12, b(yy), r, S, C.current_row(g, x + 2, yy, CW - 4, 54), BOLD) + else: + g.t(x + 12, b(yy), r, S, DIM, MONO) + m = {"rax": {0: "tick"}, "rcx": {0: "tick"}, "rdi": {0: "strike"}}.get(r) + chain(g, x + 72, yy, links, end, m, room=x + CW - 12) + y += ph(len(reg)) + 24 + mem4 = dict(MEM) # moment 4: the store wrote 10040b0 into the word at 1004098 + for i, v in enumerate((0x10040b0).to_bytes(8, "little")): + mem4[0x1004098 + i] = v + flist = heap_fields(0x1004080, 64) + flist = [(a, n, r, bg, 7 if a == 0x18 else m) for a, n, r, bg, m in flist] + yr = C.fields(g, y, ph(4), "moment 4: the store, struck; 10040b8, held", 0x1004080, 64, flist, mem4, HEAP, + region, marks=()) + # struck on the run the store wrote, held on the one iteration 1 wrote (its own row, 10040b0's next) + r_y = yr[0x1004090] + x0 = x + 132 + 8 * 30 + 12 - 4 + ink = C.struck(g, x0, r_y, 30) # only the byte that changed: 70 to b0; 40 00 01 kept their value + g.t(x + 132 + 8 * 30 + 12, b(r_y), "b0", S, ink, BOLD) + C.held(g, x + 132 + 8 * 30 + 12, yr[0x10040b0], 8 * 30 - 6) + y += ph(4) + 36 + # a lens's cells, at the drawing's scale on this stage (2): a node held, a node struck + g.t(x, y, "in a lens's cell, twice the size", 20, DIM, "sansm") + y += 16 + for j, (lab, mark) in enumerate([("4", "held"), ("4", "struck")]): + cx = x + j * 300 + g.rect(cx, y, 152, 88, RAISED) + g.rect(cx + 152, y, 96, 88, C.WELL) + if mark == "struck": + ink = C.struck(g, cx, y - 1, 152, 90) + else: + ink = VELLUM + C.held_cell(g, cx + 152, y, 96, 88, 2) + g.t(cx + 76, y + 44 + 18, lab, 50, ink, "mono", "middle") + g.rect(cx + 190, y + 34, 20, 20, HEAP) + g.t(cx + 124, y + 118, mark, 20, DIM, "sansm", "middle") + # the same rows, closer: 1.4 times, for judging on a screen smaller than 4K + g.t(x, 1236, "the same, 1.35 times", 20, DIM, "sansm") + g.o.append('' % (x, 1256)) + put(0) + C.source(g, 0, 3, SRC, 19, 21, [20], "list.c", 42) + y0 = C.panel(g, 0, ph(3) + 16, CW, 4, "registers") + for i, r in enumerate([r for r in regs(True) if r[0] in ("rax", "rdi")] + [regs(True)[-1]]): + yy = y0 + i * ROW + nm, links, end = r + if nm == "rip": + g.t(12, b(yy), nm, S, C.current_row(g, 2, yy, CW - 4, 54), BOLD) + else: + g.t(12, b(yy), nm, S, DIM, MONO) + chain(g, 72, yy, links, end, {"rax": {0: "tick"}, "rdi": {0: "strike"}}.get(nm), room=CW - 12) + yy = y0 + 3 * ROW + g.t(12, b(yy), "rcx", S, DIM, MONO) + chain(g, 72, yy, [(0x10040b0, H_)], ("int", 1), {0: "tick"}, room=CW - 12) + g.o.append("") + put(x) + C.STYLE.update(current="B", struck="B", held="B") + g.save(name) + + +if __name__ == "__main__": + frame_marks("15-marks") + frame_none("16-none", False) + frame_subject("17-subject") + frame_none("18-loupes", True, loupes=True) -- cgit v1.3