diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 14:17:43 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 14:17:51 -0300 |
| commit | 4862e778af7779bbdb047b9c71adfb62add319b2 (patch) | |
| tree | 669715d535fe1a381adf95e053ba6a2986039de9 /design/mock/frame.py | |
| parent | 5941372c6c153ad595236193e61ea027a40a9950 (diff) | |
| download | computeranim-4862e778af7779bbdb047b9c71adfb62add319b2.tar.gz computeranim-4862e778af7779bbdb047b9c71adfb62add319b2.zip | |
design: the disassembly stays under the source; the graph as a track
From the user, on the sort render. Registers a scene never changes fold
three to a row, so the stack is twelve to fifteen slots and the
disassembly keeps its place under the source with eleven to seventeen
rows; a blocks lens has no view. The graph leaves the layered picture of
the reverse-engineering tools: blocks are pills on one line in the order
they run, a loop an arch over its blocks with the turn count at its
centre, every bend a quarter circle; sort's eleven blocks and both loops
are seen whole across the band. Sheets 42 and 43 set the layouts and the
graph's forms side by side.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'design/mock/frame.py')
| -rw-r--r-- | design/mock/frame.py | 410 |
1 files changed, 410 insertions, 0 deletions
diff --git a/design/mock/frame.py b/design/mock/frame.py new file mode 100644 index 0000000..15b3933 --- /dev/null +++ b/design/mock/frame.py @@ -0,0 +1,410 @@ +#!/usr/bin/env python3 +"""The working frame reworked: the disassembly under the source in every split, the registers a scene does not +move folded three to a row, the stack given what that frees, and the `blocks` lens's drawing across the band. + + python3 -B frame.py # 40-frame-beside, 41-frame-subject, 25-blocks-lens (.svg), 42-frame-layouts.png + +40 and 41 are mocks 9 and 11 in the reworked frame (the same recording of targets/list, the same moments, each +pane's minimap from the map as map.py draws it); 25 is sort with the `blocks` lens (graph.py's track, the stop in +sort-dbg.txt); 42 sets the three layouts weighed this round side by side, each as the list's `subject` and sort's +`blocks`, at a third of their size: A (recommended) folds the quiet registers, B keeps all seventeen and gives the +source's rows to the disassembly, C sets the registers in two columns. +""" +import math +import re +import subprocess + +from PIL import Image, ImageDraw, ImageFont + +import gen +import dense as D +import context as C +import map as M +import graph as G +from context import (PAGE, RAISED, RULE, VELLUM, BRIGHT, DIM, FAINT, GOLD, HEAP, STACK, CODE, DATA, A, S, ROW, TAG, + MONO, BOLD, b, ph, mix, Svg) + +HERE = G.HERE +TOP, FOOT = 48, 888 +WORDS = {6: "six", 8: "eight", 10: "ten", 11: "eleven", 12: "twelve", 13: "thirteen", 14: "fourteen", 15: "fifteen"} + +# ---- the splits ------------------------------------------------------------------------------------------------- +# What a scene gives its lens, and the program column's rows under it: (drawing, view, source, disassembly). The +# `blocks` lens has no view: its drawing is the band across both columns. +SPLITS = {"none": (0, 0, 14, 17), "beside": (152, 152, 8, 17), "subject": (296, 200, 8, 11), "blocks": (200, 0, 8, 15)} +LAYOUTS = { + "A": dict(regs="fold", src=None, dis=None), # the splits above + "B": dict(regs="all", src=6, dis=lambda d: d + 2), # all seventeen rows; the source gives two rows + "C": dict(regs="two", src=None, dis=None), # the registers in two columns of eight, rip across +} + + +def boxes(split, layout, quiet): + """Every panel's box in a split: x, y, h (the width is the column's, or both for the band across).""" + band, view, src, dis = SPLITS[split] + L = LAYOUTS[layout] + if L["src"] is not None and split != "none": + src, dis = L["src"], L["dis"](dis) + regs = {"fold": C.reg_rows(quiet), "all": 17, "two": 9}[L["regs"]] + out = {} + y = TOP + (band + 12 if band else 0) + out["source"] = (64, y, ph(src)) + out["disasm"] = (64, y + ph(src) + 12, ph(dis)) + assert out["disasm"][1] + out["disasm"][2] == FOOT or split == "none", (split, layout, out) + ys = TOP + (view + 12 if view else band + 12 if split == "blocks" else 0) + out["registers"] = (976, ys, ph(regs)) + yk = ys + ph(regs) + 12 + out["stack"] = (976, yk, FOOT - yk) + if band: + out["drawing"] = (64, TOP, band) + if view: + out["view"] = (976, TOP, view) + return out, regs, (FOOT - yk - TAG - 8) // ROW + + +# ---- the registers in two columns (layout C) ------------------------------------------------------------------ +def registers_two(g, y, regs, flags, marks): + """C: sixteen in two columns of eight, each 440 wide, its chain cut to that; rip across the foot with the flags.""" + legend = [("stack", STACK, False), ("heap", HEAP, False), ("code", CODE, False), ("data", DATA, False), + ("rwx", DATA, True), ("read-only", VELLUM, False)] + y0 = C.panel(g, C.RX, y, C.CW, 9, "registers", note=legend) + where = {} + for i, (name, links, end) in enumerate(regs[:16]): + x, yy = C.RX + (i // 8) * 440, y0 + (i % 8) * ROW + where[name] = yy + g.t(x + 12, b(yy), name, S, DIM, MONO) + if links: + C.chain(g, x + 60, yy, links, end, marks.get(name), room=x + 428) + else: + C.integer(g, x + 60, yy, end[1]) + yy = y0 + 8 * ROW + name, links, end = regs[16] + g.t(C.RX + 12, b(yy), name, S, C.current_row(g, C.RX + 2, yy, C.CW - 4, 54), BOLD) + C.chain(g, C.RX + 72, yy, links, end, room=C.RX + C.CW - 12) + x = C.RX + C.CW - 12 - len(flags) * 42 + 10 + for fl, on, changed in flags: + if on: + g.rect(x, yy + 2, 2 * A + 8, 20, RAISED) + g.t(x + 4, b(yy), fl, S, BRIGHT, BOLD) + else: + g.t(x + 4, b(yy), fl.lower(), S, mix(DIM, C.band(), 0.8), MONO) + x += 42 + where["rip"] = yy + return where + + +def draw_registers(g, layout, y, regs, flags, marks, quiet): + C.RX = 976 + if LAYOUTS[layout]["regs"] == "two": + return registers_two(g, y, regs, flags, marks) + return C.registers(g, y, regs, flags, marks, quiet if LAYOUTS[layout]["regs"] == "fold" else ()) + + +# ---- a pane's minimap from rows we hold (sort's), as map.py draws one from the map ---------------------------- +def strip(g, x, y, h, rows, w0, wn, marks=None, ticks=()): + """rows: per row of the column, its runs as (x, width, ink) in the panel's units. The window framed; the marks + at a row's left; a block's first row ticked at the strip's left; dots where the column goes on.""" + marks = marks or {} + g.rect(x, y, M.MW, h, C.WELL) + cap, total = int((h - 6) // M.MR), len(rows) + first = 0 if total <= cap else min(max(w0 + wn // 2 - cap // 2, 0), total - cap) + for r in range(first, min(first + cap, total)): + ry = y + 3 + (r - first) * M.MR + for rx, rw, ink in rows[r]: + g.rect(x + 2 + rx * M.KX, ry, max(rw * M.KX, 1), 3, mix(ink, PAGE, 0.65)) + if r in ticks: + g.rect(x, ry - 1, 2, 4, DIM) + if r in marks: + g.rect(x + 2, ry - 0.5, 4, 4, {"current": GOLD, "struck": gen.VERM, "read": gen.READ}[marks[r]]) + g.frame(x, y + 3 + (w0 - first) * M.MR - 3, M.MW, wn * M.MR + 5, VELLUM, 2) + for end, more in (("top", first > 0), ("foot", first + cap < total)): + if more: + yy = y + 1 if end == "top" else y + h - 3 + for d in range(3): + g.rect(x + M.MW / 2 - 7 + d * 6, yy, 2, 2, FAINT) + + +def strip_at(box): + x, y, h = box + return x + 880 - 2 - M.MW, y + TAG, h - TAG - 2 + + +# ---- the list: 40 (`beside`, at rest) and 41 (`subject`, mid-step) --------------------------------------------- +LIST_QUIET = ("rbx", "rdx", "rsi", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15") # reverse moves rax rcx rdi + + +def list_frame(g, split, step, layout="A", caption=None, strips=True): + subject = split == "subject" + bx, nregs, words = boxes(split, layout, LIST_QUIET) + band, view, src, dis = SPLITS[split] + src, dis = (bx["source"][2] - 32) // ROW, (bx["disasm"][2] - 32) // ROW + # the map, its windows set for this split's rows: each pane's column for its minimap + old = dict(C.SUBJECT), dict(C.BESIDE) + sp = C.SUBJECT if subject else C.BESIDE + sp.update(src=src, dis=dis, words=words) + m, win = M.map_log(step, False, subject) + M.stage(False) + C.SUBJECT.update(old[0]) + C.BESIDE.update(old[1]) + D.put(64) + M.strip(True) + first = 18 if subject else 19 + ys = C.source(g, bx["source"][1], src, D.SRC, first, 21, [], "list.c", 42) + at = C.disasm(g, bx["disasm"][1], D.window(dis, step), "reverse", 21) + M.strip(False) + marks = {"rax": {0: "tick"}, "rcx": {0: "tick"}, "rdi": {0: "strike" if step else "tick"}} + regs = draw_registers(g, layout, bx["registers"][1], D.regs(step), D.FLAGS, marks, LIST_QUIET) + M.strip(True) + C.RX = 976 + C.stack(g, bx["stack"][1], M.slot_rows(M.UNDER, words), M.frames_from(M.UNDER, words), rsp=M.RSP, + roles=M.roles_from(M.UNDER, words), note="%s words from rsp" % WORDS[words]) + rows_shown = M.SUBJECT_VIEW if subject else M.BESIDE_VIEW + vr = C.fields(g, TOP, view, "the heap, %x to %x" % (0x1004000 + 16 * rows_shown[0], 0x10040bf), 0x1004000, 512, + D.heap_fields(0x1004000, 512, 0x1004098), D.MEM, HEAP, D.region, marks=(9,) if step else (), + rows_shown=rows_shown, more_rows=False, touched={0x1004098} if step else ()) + M.strip(False) + D.put(64) + C.thread(g, ys, [(at[0x1001926], at[0x1001926] + ROW)]) + C.RX = 976 + C.lens(g, TOP, band, view, D.NODES, M.pins(step), M.node_marks(step), 0x1004000, 32, + link_from=(regs["rdi"], "rdi") if step else None, subject=subject, view_rows=vr) + if strips: + M.minimaps(g, m.log, {k: bx[k] for k in ("source", "disasm", "stack", "view")}) + M.clock(g, 3 if step else 2, 4) + gen.caption(g, caption) + return bx, words + + +CAP9 = [[("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.",)]] +CAP10 = [[("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.",)]] + + +# ---- sort, stopped at the 11th compare (sort-dbg.txt) ---------------------------------------------------------- +SORT_MEM = {} +for line in open(HERE + "/sort-dbg.txt"): + mm = re.match(r"^(7fffffff[0-9a-f]{4}) ((?:[0-9a-f]{2} ){16})", line) + if mm: + for i, v in enumerate(mm.group(2).split()): + SORT_MEM[int(mm.group(1), 16) + i] = int(v, 16) +SORT_NAMES = {0x401020: "_start", 0x4010e0: "__do_global_dtors_aux", 0x401120: "swap", 0x401150: "sort", 0x401200: "main"} +RSP_S = 0x7fffffffecd0 + + +def s_region(v): + for lo, hi, ink in [(0x401000, 0x402000, CODE), (0x400000, 0x401000, VELLUM), (0x402000, 0x403000, VELLUM), + (0x403000, 0x405000, DATA)]: + if lo <= v < hi: + return ink + return D.region(v) + + +def s_name(v): + if 0x7ffff7fbe000 <= v < 0x7ffff7fec000: + return "ld.so+%x" % (v - 0x7ffff7fbe000) + if v in D.LIBNAMES: + return D.LIBNAMES[v] + f = max(a for a in SORT_NAMES if a <= v) + return "%s+%d" % (SORT_NAMES[f], v - f) + + +def s_word(a): + return sum(SORT_MEM[a + i] << (8 * i) for i in range(8)) if all(a + i in SORT_MEM for i in range(8)) else None + + +def s_follow(v): + links = [] + while True: + ink = s_region(v) + if ink == CODE: + return links + [(v, CODE, s_name(v))], None + links.append((v, ink)) + s = "".join(chr(SORT_MEM[v + i]) for i in range(16) if v + i in SORT_MEM).split("\0")[0] + if ink == STACK and len(s) >= 2 and s.isprintable() and SORT_MEM.get(v + len(s)) == 0: + return links, ("str", s) + w = s_word(v) + if w is None or len(links) > 5: + return links, None + if w and s_region(w): + v = w + continue + return links, ("int", w) + + +def sort_slots(n): + rows = [] + for i in range(n): + a = RSP_S + 8 * i + w = s_word(a) + links, end = s_follow(w) if w and s_region(w) else ([], ("int", w)) + rows.append((a, {0: ["rsp"], 2: ["rbp"]}.get(i, []), links, end)) + return rows + + +E_ = [(0x7fffffffed00, STACK), (0x7fffffffedb0, STACK), (0x7fffffffee10, STACK)] +SORT_REGS = [("rax", [], ("int", 1)), ("rbx", [], ("int", 0)), ("rcx", [(0x404010, DATA)], ("int", 0x900000004)), + ("rdx", [], ("int", 4)), ("rsi", [(0x404024, DATA)], ("int", 0x1f0000001a)), + ("rdi", [(0x404020, DATA)], ("int", 0x1a00000005)), ("rbp", [(0x7fffffffece0, STACK)] + E_, ("int", 0)), + ("rsp", [(0x7fffffffecd0, STACK)], ("int", 0x401000000)), ("r8", [(0x7ffff7e19680, DATA)], None), + ("r9", [(0x7ffff7e1afa0, DATA)], None), ("r10", [(0x7fffffffea60, STACK)], ("int", 0)), + ("r11", [(0x7ffff7ffca90, DATA)], ("int", 0xba55a1098a503203)), + ("r12", [(0x7fffffffee38, STACK), (0x7fffffffefea, STACK)], ("str", "./sort")), ("r13", [], ("int", 1)), + ("r14", [(0x7ffff7ffd000, DATA), (0x7ffff7ffe3c0, DATA)], ("int", 0)), + ("r15", [(0x403e10, DATA), (0x4010e0, CODE, "__do_global_dtors_aux")], None), + ("rip", [(0x4011ab, CODE, "sort+91")], None)] +SORT_FLAGS = [("CF", 0, 0), ("PF", 0, 1), ("AF", 0, 1), ("ZF", 0, 0), ("SF", 0, 0), ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)] +SORT_QUIET = ("rbx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15") # sort moves the other eight +SORT_SRC = open(HERE + "/../../anim/tools/sort.c").read().split("\n") +TEXT = G.read_dis("sort-clang.dis") # the program's text: swap, sort, main +FUNC = lambda a: "swap" if a < 0x401150 else "sort" if a < 0x401200 else "main" + + +def sort_disasm(g, y, n): + """n rows round the pc; each block's first row under a rule, its visits ranged right in the annotation's room + (the pill's count, in its digits); the trail's three rows and the pc's with what they did.""" + i = [r[0] for r in TEXT].index(G.PC) + lo = max(0, min(i - n // 2, len(TEXT) - n)) + st = G.sort_state(G.UPTO, G.PC, G.TRAIL_ROWS) + notes = dict(G.NOTES) + notes[0x4011a3] = [("7fffffffecd3 ", STACK), ("◂ ", FAINT), ("1", VELLUM)] + rows = [] + for a, ln, mn, ops, t, callee in TEXT[lo:lo + n]: + state = "cur" if a == G.PC else {0x4011a9: "trail0", 0x4011a6: "trail1", 0x4011a3: "trail2"}.get(a) + note = ("runs", notes[a]) if a in notes else ("text", callee, VELLUM) if mn == "call" else None + rows.append((a, ln, mn, [(t, CODE)] if t and (mn.startswith("j") or mn == "call") else [(ops, VELLUM)], + state, note)) + at = C.disasm(g, y, rows, "sort", 12) + for a in at: + if a in G.SORT_BL and a != "note": # a block's first row: the rule over it, its pill's digits + yy = at[a] + g.rect(C.LX + 2, yy, C.CW - 4, 2, RULE) + n_ = st["blocks"][a]["count"] + g.t(C.LX + C.CW - 12, b(yy), "×%d" % n_, S, FAINT, MONO, "end") + line12 = [at[r[0]] for r in rows if r[1] == 12 and r[0] < 0x4011af] + return at, (min(line12), max(line12) + ROW), lo + + +def sort_strips(g, bx, lo, n, words): + """The panes' minimaps from what the stop holds: the file, the program's text (69 rows round the pc), the + stack from 16 words above rsp to as far as the dump goes.""" + src_rows = [[(64 + (len(l) - len(l.lstrip())) * A, len(l.strip()) * A, VELLUM)] if l.strip() else [] + for l in SORT_SRC[:22]] + strip(g, *strip_at(bx["source"]), src_rows, 8, 8, {11: "current"}) + i = [r[0] for r in TEXT].index(G.PC) + col = TEXT[max(0, i - 34):i + 35] + dis_rows = [[(40, 7 * A, CODE), (180, len(mn) * A, gen.KW), (264, len(ops) * A, VELLUM if FUNC(a) == "sort" else FAINT)] + for a, ln, mn, ops, t, c in col] + c0 = [r[0] for r in col] + strip(g, *strip_at(bx["disasm"]), dis_rows, c0.index(TEXT[lo][0]), n, {c0.index(G.PC): "current"}, + ticks={c0.index(a) for a in G.SORT_BL if a in c0}) + stk = [] + for k in range(-16, 110): + a = RSP_S + 8 * k + w = s_word(a) + if w is None: + break + ink = s_region(w) if w else None + stk.append([(184, 12 * A, STACK)] + ([(184 + 13 * A, 12 * A, ink or VELLUM)] if w else [(184 + 13 * A, A, FAINT)])) + strip(g, *strip_at(bx["stack"]), stk, 16, words) + + +def sort_frame(g, layout="A", strips=True): + """Mock 25 in a layout: the `blocks` lens across the band, the source and the disassembly under it.""" + bx, nregs, words = boxes("blocks", layout, SORT_QUIET) + st = G.sort_state(G.UPTO, G.PC, G.TRAIL_ROWS, G.NOTES) + G.track_lens(g, 64, TOP, 1792, 200, G.SORT_BL, G.SB[0], G.SORT_BASE, st, "the blocks of sort") + src, dis = (bx["source"][2] - 32) // ROW, (bx["disasm"][2] - 32) // ROW + C.LX, C.RX = 64, 976 + M.strip(strips) + first = max(1, 12 - src // 2) + ys = C.source(g, bx["source"][1], src, SORT_SRC, first, 12, [14, 13], "sort.c", 22) + at, run, lo = sort_disasm(g, bx["disasm"][1], dis) + M.strip(False) + draw_registers(g, layout, bx["registers"][1], SORT_REGS, SORT_FLAGS, {}, SORT_QUIET) + M.strip(strips) + C.RX = 976 + roles = {0: ("j, high half", VELLUM), 1: ("i, n", VELLUM), 2: ("saved rbp", DIM), 6: ("saved rbp", DIM)} + C.stack(g, bx["stack"][1], sort_slots(words), [("sort", 0, 3), ("main", 4, 7), ("libc.so.6+27781", 8, 29)], + rsp=RSP_S, roles={k: v for k, v in roles.items() if k < words}, note="%s words from rsp" % WORDS[words]) + M.strip(False) + C.thread(g, ys, [run]) + if strips: + sort_strips(g, bx, lo, dis, words) + M.clock(g, 434, 1905) + gen.caption(g, [[("The sixth pass, its third compare: ",), ("17 > 5", "mono"), (", so ",), ("jne", "mono"), + (" takes the swap.",)], + [("The swap has run 5 times so far, and each loop has turned 5.",)]]) + return bx, words + + +# ---- the frames ------------------------------------------------------------------------------------------------ +def save(name, draw, *a, **k): + gen.W, gen.H = 1920, 1080 + M.stage(False) + g = Svg() + out = draw(g, *a, **k) + g.save(name) + return out + + +def sheet(out): + """Mock 42: A, B, C as columns; the list's `subject` and sort's `blocks` as rows; a third of their size.""" + tiles, info = [], {} + for key in "ABC": + for kind in ("subject", "blocks"): + name = "42-%s-%s" % (key, kind) + if kind == "subject": + bx, words = save(name, list_frame, "subject", True, key, CAP10) + else: + bx, words = save(name, sort_frame, key) + src, dis = (bx["source"][2] - 32) // ROW, (bx["disasm"][2] - 32) // ROW + regs = (bx["registers"][2] - 32) // ROW + info[(key, kind)] = (src, dis, regs, words) + subprocess.run(["resvg", "-w", "608", HERE + "/" + name + ".svg", HERE + "/" + name + ".png"], check=True) + tiles.append((key, kind, Image.open(HERE + "/" + name + ".png").convert("RGB"))) + W_, H_ = 64 + 3 * 608 + 2 * 32 + 64, 210 + 2 * (342 + 120) + s = Image.new("RGB", (W_, H_), "#0a1030") + d = ImageDraw.Draw(s) + big = ImageFont.truetype("/usr/share/fonts/go/Go-Medium.ttf", 30) + head = ImageFont.truetype("/usr/share/fonts/go/Go-Medium.ttf", 24) + body = ImageFont.truetype("/usr/share/fonts/go/Go-Regular.ttf", 18) + d.text((64, 28), "The frame, three ways: where the room for the stack and the disassembly comes from", font=big, + fill="#fff8e8") + d.text((64, 72), "Each the same two moments: the list as `subject` mid-step (top), sort with the `blocks` lens (foot). " + "A third of their size: the layout, not the digits.", font=body, fill="#9aa6d9") + titles = {"A": ("A fold the quiet registers (recommended)", "#e8c46a"), + "B": ("B all seventeen; the source gives", "#eee6d2"), + "C": ("C the registers in two columns", "#eee6d2")} + subs = {"A": "the registers a scene moves keep their rows and chains; the rest three a row", + "B": "rule 6 as it stood: every chain whole; the stack does not grow", + "C": "two registers a row, 440 each: chains cut to a hop; the stack the most"} + for i, (key, kind, im) in enumerate(tiles): + col, row = "ABC".index(key), 0 if kind == "subject" else 1 + x, y = 64 + col * (608 + 32), 210 + row * (342 + 120) + if row == 0: + d.text((x, 118), titles[key][0], font=head, fill=titles[key][1]) + d.text((x, 152), subs[key], font=body, fill="#9aa6d9") + s.paste(im, (x, y)) + d.rectangle((x - 1, y - 1, x + 608, y + 342), outline="#e8c46a" if key == "A" else "#3a4a8a", width=2) + src, dis, regs, words = info[(key, kind)] + lab = "%s: source %d · disassembly %d · registers %d rows · stack %d" % ( + "list, subject" if kind == "subject" else "sort, blocks", src, dis, regs, words) + d.text((x, y + 352), lab, font=body, fill="#eee6d2") + if kind == "blocks": + d.text((x, y + 378), "the graph across the band: 1792 by 200, whole", font=body, fill="#9aa6d9") + else: + d.text((x, y + 378), "the drawing 296 and its view of 7 over the state column", font=body, fill="#9aa6d9") + s.save(HERE + "/" + out) + for key in "ABC": + for kind in ("subject", "blocks"): + for ext in ("svg", "png"): + subprocess.run(["rm", "-f", "%s/42-%s-%s.%s" % (HERE, key, kind, ext)], check=True) + return info + + +if __name__ == "__main__": + print("40", save("40-frame-beside", list_frame, "beside", False, "A", CAP9)) + print("41", save("41-frame-subject", list_frame, "subject", True, "A", CAP10)) + print("25", save("25-blocks-lens", sort_frame, "A")) + print("42", sheet("42-frame-layouts.png")) |
