diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 12:49:15 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 13:22:07 -0300 |
| commit | 576a78b4de02c4c6566c327d85c465554d293975 (patch) | |
| tree | ea9df8139a511768480696712495d62533e048b3 /design/mock/pair.py | |
| parent | 4c7dcadeddaa50fb52fd44a2cc71df1f570e092a (diff) | |
| download | computeranim-576a78b4de02c4c6566c327d85c465554d293975.tar.gz computeranim-576a78b4de02c4c6566c327d85c465554d293975.zip | |
design: the overflow as bytes; a minimap in each pane
From the user. In the pair a frame is a dump of eight bytes a row read
by its own fields, so each turn of the loop is one more letter and the
letters are seen to cross from buf into the saved rbp and the return
address, which reads as code until they reach it. Each pane with more
than it shows carries its own minimap, a strip of its column of the map
at four units a row with the pane's window outlined and what happens off
the window marked there; the corner minimap is gone, and in the dive
each column of the map folds into its pane's strip.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'design/mock/pair.py')
| -rw-r--r-- | design/mock/pair.py | 311 |
1 files changed, 260 insertions, 51 deletions
diff --git a/design/mock/pair.py b/design/mock/pair.py index 1311b95..3adb60d 100644 --- a/design/mock/pair.py +++ b/design/mock/pair.py @@ -102,12 +102,188 @@ def source_pair(g, cur_l, cur_r, waiting_r=False): return ys -def frame(name, part): - """The pair at the loop. part=False: i = 15, both builds at the line's store (plain) and its check (asan). - part=True: i = 16, the step in which they part: plain's store struck into the saved rbp; asan's check read f3.""" +# ---- the frame as bytes: `hexdump` `eight`, by the frame's own fields -------------------------------------------- +PX, AX, BX8, RD = 12, 118, 274, 522 # a row: the pin lane, the address, eight bytes 30 apart, the reading +SHX = 62 # in a run with ASan, the row's shadow byte, in the pin lane's end + + +def plain_region(v): + """Where a word of the plain build points, by its mappings; None: nowhere (a number).""" + if 0x7ffffffde000 <= v < 0x7ffffffff000: + return S_ + if 0x401000 <= v < 0x402000: + return C_ + if 0x404000 <= v < 0x405000: + return D_ + return None + + +def asan_region(v): + if 0x7ffffffde000 <= v < 0x7ffffffff000: + return S_ + if 0x7bfff58e7000 <= v < 0x7bfff6400000: + return D_ + if 0x42c000 <= v < 0x524000: + return C_ + if 0x524000 <= v < 0x55f000: + return VELLUM + return None + + +CODE_NAMES = {0x401120: "main", 0x401140: "fill", 0x523c40: "main", 0x523c60: "fill"} + + +def code_name(v): + f = max((a for a in CODE_NAMES if a <= v and v - a < 0x100), default=None) + return None if f is None else (CODE_NAMES[f] + ("+%d" % (v - f) if v > f else "")) + + +def plain_mem(stored, i): + """The plain build's stack from 7fffffffecb0 to 7fffffffed00 after `stored` of the loop's stores, i in its slot.""" + m = {a: 0 for a in range(0x7fffffffecb0, 0x7fffffffed00)} + for k, v in enumerate([0x00, 0xed, 0xff, 0xff, 0xff, 0x7f, 0, 0, 0x34, 0x11, 0x40, 0, 0, 0, 0, 0]): + m[0x7fffffffece0 + k] = v + for k in range(4): + m[0x7fffffffeccc + k] = i >> (8 * k) & 0xff + for k in range(stored): + m[0x7fffffffecd0 + k] = 0x41 + return m + + +def asan_mem(stored): + """ASan's fake frame (the header as its prologue wrote it, buf, the redzone) and the real stack's way back.""" + m = {} + for off, v in [(0, 0x41b58ab3), (8, 0x5387a7), (0x10, 0x523c60), (0x18, 0x7fffffffec10), (0x38, 0x7bfff58e8000)]: + for k in range(8): + m[FAKE + off + k] = v >> (8 * k) & 0xff + for k in range(0x20, 0x38): + m[FAKE + k] = 0x41 if 0x20 <= k < 0x20 + stored else 0 + for a, v in [(0x7fffffffecc0, 0x7fffffffece0), (0x7fffffffecc8, 0x523c54)]: + for k in range(8): + m[a + k] = v >> (8 * k) & 0xff + return m + + +DESCR = {0x5387a7: "1 32 16 5 buf:3"} + + +def frame_dump(g, x, y, title, note, rows, mem, region, pins=None, shadow=None, struck=None, held=(), letters=(), + read_shadow=None, span=None, rule_after=None, differs=(), seam=None): + """`hexdump` `eight` by the frame's fields: a row a word of the stack (eight bytes), its pins and address, the + bytes on their field's paper, the reading: the field's name (Go 18, dim) and what its type makes of its bytes. + rows: (address, [(offset, length, reads, name)]); reads in text | pointer | number | bytes; what no field + covers is loose. letters: bytes stored past the field the store aimed at, which keep its ink (text) wherever + they land. shadow: {row: byte}. span: (name, first row, last row). Returns the rows' y.""" + pins = pins or {} + y0 = C.panel(g, x, y, C.CW, len(rows) + (0 if rule_after is None else 0), title, note=note) + lead = C.shared([a for a, _ in rows if region(a) == region(rows[0][0])]) + ys = [] + for r, (a0, flist) in enumerate(rows): + yy = y0 + r * ROW + ys.append(yy) + if rule_after is not None and r == rule_after + 1: # another region (the real stack): a rule before it + g.rect(x + 2, yy - 1, C.CW - 4, 2, RULE) + if r in pins: + C.pin(g, x + PX, yy, pins[r], S_) + if shadow and r in shadow: + shadow_cell(g, x + SHX, yy, shadow[r], read=read_shadow == r) + ink_a = region(a0) or VELLUM + C.addr(g, x + AX, yy, a0, ink_a, lead=lead if region(a0) == region(rows[0][0]) else 0) + bx = lambda k: x + BX8 + 30 * k + covered = {} + for f in flist: + for k in range(f[0], f[0] + f[1]): + covered[k] = f + rx = x + RD + for f in flist: + off, n, reads, name = f + vals = [mem[a0 + off + k] for k in range(n)] + word = sum(v << (8 * k) for k, v in enumerate(vals)) + g.rect(bx(off) - 4, yy + 1, 30 * n - 2, ROW - 2, RAISED) + ink = {"text": LIT, "number": VELLUM, "bytes": VELLUM, "pointer": region(word) or VELLUM}[reads] + nz = [k for k, v in enumerate(vals) if v] + for k, v in enumerate(vals): + a = a0 + off + k + xx = bx(off + k) + if a == struck: + g.t(xx, b(yy), "%02x" % v, S, C.struck(g, xx - 5, yy, 34), BOLD) + continue + if a in held: + C.held(g, xx, yy, 24) + padded = reads in ("number", "pointer") and nz and k > nz[-1] + kink = LIT if a in letters else ink + g.t(xx, b(yy), "%02x" % v, S, mix(kink, PAGE, 0.45) if padded else kink, MONO) + # the reading: the field's name, then its value + g.t(rx, b(yy) - 1, name, 18, DIM, "sans") + vx = rx + gen.tw(name, 18, "sans") + 10 + if reads == "text": + s_ = '"' + bytes(v for v in vals).split(b"\0")[0].decode("latin1") + '"' + g.t(vx, b(yy), s_, S, LIT, MONO) + elif reads == "number": # a count: in decimal, as the source writes it + g.t(vx, b(yy), str(word), S, VELLUM, MONO) + elif reads == "pointer": + ink_w = region(word) + if ink_w: + vx = C.addr(g, C.link_arrow(g, vx, yy), yy, word, ink_w) + nm = code_name(word) if ink_w == C_ else None + if nm: + g.t(vx + 10, b(yy), nm, S, VELLUM, MONO) + elif word in DESCR: + room = int((x + C.CW - 24 - vx - 10) // A) + t_ = '"%s"' % DESCR[word] + g.t(vx + 10, b(yy), t_ if len(t_) <= room else t_[:room - 1] + "…", S, LIT, MONO) + else: # no longer an address: a number, no arrow, no name + g.t(vx, b(yy), "0x%x" % word, S, VELLUM, MONO) + rx = vx + 200 + for k in range(8): # what no field covers: loose + if k not in covered: + v = mem.get(a0 + k) + g.t(bx(k), b(yy), "%02x" % v, S, mix(DIM, PAGE, 0.6), MONO) + if r in differs: + bar(g, seam, yy, BRIGHT) + if span: # the frame's span, as the stack's: a bracket 14 in, its name left of it + name, r0, r1 = span + bx_, ya, yb = x + C.CW - 14, ys[r0] + 3, ys[r1] + ROW - 3 + g.rect(bx_ - 1, ya, 2, yb - ya, GOLD) + g.rect(bx_ - 7, ya, 8, 2, GOLD) + g.rect(bx_ - 7, yb - 2, 8, 2, GOLD) + g.t(bx_ - 14, (ya + yb) / 2 + 6, name, 18, BRIGHT, "sansm", "end") + return ys + + +PLAIN_ROWS = [(0x7fffffffecb0, []), (0x7fffffffecb8, []), (0x7fffffffecc0, []), + (0x7fffffffecc8, [(4, 4, "number", "i")]), (0x7fffffffecd0, [(0, 8, "text", "buf[0..7]")]), + (0x7fffffffecd8, [(0, 8, "text", "buf[8..15]")]), (0x7fffffffece0, [(0, 8, "pointer", "saved rbp")]), + (0x7fffffffece8, [(0, 8, "pointer", "return")]), (0x7fffffffecf0, []), (0x7fffffffecf8, [])] +ASAN_ROWS = [(FAKE, [(0, 8, "bytes", "magic")]), (FAKE + 8, [(0, 8, "pointer", "descr")]), + (FAKE + 0x10, [(0, 8, "pointer", "pc")]), (FAKE + 0x18, [(0, 8, "pointer", "real stack")]), + (FAKE + 0x20, [(0, 8, "text", "buf[0..7]")]), (FAKE + 0x28, [(0, 8, "text", "buf[8..15]")]), + (FAKE + 0x30, [(0, 8, "bytes", "redzone")]), (FAKE + 0x38, [(0, 8, "bytes", "redzone")]), + (0x7fffffffecc0, [(0, 8, "pointer", "saved rbp")]), (0x7fffffffecc8, [(0, 8, "pointer", "return")])] +SHADOW = {0: 0xf1, 1: 0xf1, 2: 0xf1, 3: 0xf1, 4: 0, 5: 0, 6: 0xf3, 7: 0xf3} + + +def plain_dump(g, i, stored, struck=None, held=(), note="fill's frame as bytes, eight a row"): + letters = {0x7fffffffecd0 + k for k in range(16, stored)} + return frame_dump(g, LEFT, 612, "plain · stack", note, PLAIN_ROWS, plain_mem(stored, i), plain_region, + pins={6: ["rbp", "rsp"]}, struck=struck, held=held, letters=letters, span=("fill", 3, 7), + differs=(6, 7), seam=LEFT + 880 - 6) + + +def asan_dump(g, stored, read=False): + return frame_dump(g, RIGHT, 612, "asan · fake frame", "its shadow at addr >> 3 + 7fff8000 · then the real " + "stack's way back", ASAN_ROWS, asan_mem(stored), asan_region, pins={8: ["rbp"]}, shadow=SHADOW, + read_shadow=6 if read else None, span=("fill", 0, 9), rule_after=7, differs=(6, 7), + seam=RIGHT + 2) + + +def frame(name, i): + """The pair at the loop, the frame as bytes in each column. i = 15: both builds at the line's store (plain) + and its check (asan). i = 16: the step in which they part: plain's store struck into the saved rbp; asan's + check read f3.""" gen.W, gen.H = 1920, 1080 g = Svg() - i = 16 if part else 15 + part = i == 16 source_pair(g, 4, 4) # ---- the left column: plain ---- at_side(LEFT) @@ -119,16 +295,8 @@ def frame(name, part): [("rax", [], ("int", i)), ("rbp", [(0x7fffffffece0, S_), (0x7fffffffed41 if part else 0x7fffffffed00, S_)], None), ("rsp", [(0x7fffffffece0, S_)], None), ("rip", [(0x401155, C_, "fill+21")], None)], {"rax": {0: "tick"}}) - sv = 0x7fffffffed41 if part else 0x7fffffffed00 - prow = [(0x7fffffffecb0, [], [], ("int", 0)), (0x7fffffffecb8, [], [], ("int", 0)), - (0x7fffffffecc0, [], [], ("int", 0)), (0x7fffffffecc8, [], [], ("int", i << 32)), - (0x7fffffffecd0, [], [], ("str", "AAAAAAAA")), (0x7fffffffecd8, [], [], ("str", "AAAAAAA" if not part else "AAAAAAAA")), - (0x7fffffffece0, ["rbp", "rsp"], [(sv, S_)], None) + (({1: "strike"},) if part else ()), - (0x7fffffffece8, [], [(0x401134, C_, "main+20")], None), - (0x7fffffffecf0, [], [], ("int", 0)), (0x7fffffffecf8, [], [], ("int", 0))] - py = C.stack(g, 612, prow, [("fill", 3, 7)], note="red zone, buf, the frame · rsp at +0", rsp=0x7fffffffece0, - roles={3: ("i, high half", VELLUM), 4: ("buf[0..7]", VELLUM), 5: ("buf[8..15]", VELLUM), - 6: ("saved rbp", DIM), 7: ("return", DIM)}, title="plain · stack") + plain_dump(g, i, i + 1 if part else i, struck=0x7fffffffece0 if part else None, + held={0x7fffffffecdf, 0x7fffffffeccc} if part else {0x7fffffffecde, 0x7fffffffeccc}) # ---- the right column: asan ---- at_side(RIGHT) an = {0x523d38: ("chain", [(0xf807eb16006 if part else 0xf807eb16005, D_)], ("int", 0xf3 if part else 0), @@ -138,53 +306,89 @@ def frame(name, part): if part: an[0x523d41] = ("runs", [("f3", VELLUM), (" : ", FAINT), ("0", VELLUM), (" ", FAINT), ("zf", DIM)]) an[0x523d43] = ("runs", [("not taken", DIM)]) - ar = rows_of(ASAN, 0x523d26, 9, ast, an) - at = C.disasm(g, 212, ar, "asan · fill", 4) + at = C.disasm(g, 212, rows_of(ASAN, 0x523d26, 9, ast, an), "asan · fill", 4) for a, yy in at.items(): if a in ONLY: bar(g, RIGHT + 2, yy, DIM) # its seam is on its left regs(g, RIGHT, 472, "asan · registers", [("rax", [], ("int", (FAKE + 0x20 + i) >> 3)), ("rbx", [(0x7fffffffec20, S_), (FAKE + 0x20 + i, D_)], None), ("rcx", [], ("int", i)), ("rip", [(0x523d38, C_, "fill+216")], None)], {"rax": {0: "tick"}}) - arow = [(FAKE + 0x00, [], [], ("int", 0x41b58ab3)), (FAKE + 0x08, [], [(0x5387a7, VELLUM)], ("str", "1 32 16 5 buf:3")), - (FAKE + 0x10, [], [(0x523c60, C_, "fill")], None), (FAKE + 0x18, [], [(0x7fffffffec10, S_)], None), - (FAKE + 0x20, [], [], ("str", "AAAAAAAA")), (FAKE + 0x28, [], [], ("str", "AAAAAAA" if not part else "AAAAAAAA")), - (FAKE + 0x30, [], [], ("int", 0)), (FAKE + 0x38, [], [(0x7bfff58e8000, D_)], None)] - ay = C.stack(g, 612, arow + [(0x7fffffffecc0, ["rbp"], [(0x7fffffffece0, S_)], None), - (0x7fffffffecc8, [], [(0x523c54, C_, "main+20")], None)], - [("fill", 0, 9)], note="the fake frame, its shadow · the real stack's way back", rsp=None, - roles={0: ("magic", DIM), 1: ("descr", DIM), 2: ("pc", DIM), 3: ("real stack", DIM), - 4: ("buf[0..7]", VELLUM), 5: ("buf[8..15]", VELLUM), 6: ("redzone", DIM), 7: ("redzone", DIM), - 8: ("saved rbp", DIM), 9: ("return", DIM)}, title="asan · fake stack", - ink_of=lambda a: S_ if a >= 0x7ffffffde000 else D_) - sh = [0xf1, 0xf1, 0xf1, 0xf1, 0, 0, 0xf3, 0xf3] - ys = sorted(ay.values()) if isinstance(ay, dict) else ay - base_y = 612 + TAG + PAD - for k, v in enumerate(sh): - shadow_cell(g, RIGHT + 88, base_y + k * ROW, v, read=part and k == 6) - # the real stack is another region: a rule before its two rows - g.rect(RIGHT + 2, base_y + 8 * ROW, C.CW - 4, 2, RULE) - # `differs`: the rows that face each other across the seam and hold different things (buf's end: saved rbp vs redzone) - for k in (6, 7): - bar(g, LEFT + 880 - 6, base_y + k * ROW, BRIGHT if part or k == 6 else BRIGHT) - bar(g, RIGHT + 2, base_y + k * ROW, BRIGHT) - # the clock: one rule, each run's moment - g.rect(64, 899, 1792, 2, RULE) - g.rect(64, 898, 1792 * (17 if part else 16) / 33, 4, GOLD) - g.t(1648, 934, "i %d · moments %d / %d" % (i, 164 if part else 156, 770 if part else 753), S, FAINT, MONO, "end") + asan_dump(g, 16 if part else 15, read=part) + clock(g, 17 if part else 16, "i %d · moments %d / %d" % (i, 164 if part else 156, 770 if part else 753)) if part: - gen.caption(g, [[("i = 16, one past ",), ("buf", "mono"), (": plain writes ",), ("'A'", "mono"), - (" into the saved rbp. ASan reads",)], - [("the shadow first: ",), ("f3", "mono"), (", a redzone. Its branch to the store is not taken.",)]]) + gen.caption(g, [[("i = 16, one past ",), ("buf", "mono"), (": plain writes ",), ("41", "mono"), + (", an ",), ("'A'", "mono"), (", into the saved rbp.",)], + [("ASan reads the shadow first: ",), ("f3", "mono"), (", a redzone. It does not store.",)]]) else: - gen.caption(g, [[("The same line, two builds: plain stores the byte; ASan first",)], - [("reads the byte of shadow that stands for it: ",), ("00", "mono"), (", so it may.",)]]) + gen.caption(g, [[("Each turn is one more byte: ",), ("41", "mono"), (", the letter ",), ("A", "mono"), + (". Fifteen in ",), ("buf", "mono"), (",",)], + [("on both sides; ASan read ",), ("00", "mono"), (" in the shadow before each one.",)]]) + g.save(name) + + +def clock(g, steps, text): + g.rect(64, 899, 1792, 2, RULE) + g.rect(64, 898, 1792 * steps / 33, 4, GOLD) + g.t(1648, 934, text, S, FAINT, MONO, "end") + + +REPORT = [("==1438870==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7bfff58f0030 at pc 0x000000523d5b", + "stack-buffer-overflow"), + ("WRITE of size 1 at 0x7bfff58f0030 thread T0", "WRITE of size 1"), + ("Address 0x7bfff58f0030 is located in stack of thread T0 at offset 48 in frame", None), + (" This frame has 1 object(s):", None), + (" [32, 48) 'buf' (line 3) <== Memory access at offset 48 overflows this variable", "[32, 48) 'buf'"), + ("=>0x7bfff58f0000: f1 f1 f1 f1 00 00[f3]f3 00 00 00 00 00 00 00 00", "[f3]")] + + +def report(g, x, y, lines): + """A run's stderr, as written: a panel of its lines, the ones the narration names framed; cut at its edge.""" + y0 = C.panel(g, x, y, C.CW, len(lines), "asan · stderr", note="its report, as written · exit 1") + room = (C.CW - 24) // A + for k, (t, mark) in enumerate(lines): + yy = y0 + k * ROW + s_ = t if len(t) <= room else t[:room - 1] + "…" + g.t(x + 12, b(yy), s_, S, VELLUM, MONO) + if mark and mark in s_: + c = s_.index(mark) + g.frame(x + 12 + c * A, yy, len(mark) * A, ROW, BRIGHT, 2) + + +def frame_ret(name): + """Mock 38: i = 27, plain alone: its store struck into the return address's fourth byte, which now reads + 0x41414141, no longer an address; ASan stopped at i = 16, its report in place of its registers.""" + gen.W, gen.H = 1920, 1080 + g = Svg() + source_pair(g, 4, 4) + at_side(LEFT) + pn = {0x401155: ("chain", [(0x7fffffffeceb, S_)], ("int", 0x41), {"end": "strike"})} + ps = {0x401155: "cur", 0x401151: "trail0", 0x40114f: "trail1", 0x40114b: "trail2"} + C.disasm(g, 212, rows_of(PLAIN, 0x401144, 9, ps, pn), "plain · fill", 4) + regs(g, LEFT, 472, "plain · registers", + [("rax", [], ("int", 27)), ("rbp", [(0x7fffffffece0, S_)], ("int", 0x4141414141414141)), + ("rsp", [(0x7fffffffece0, S_)], None), ("rip", [(0x401155, C_, "fill+21")], None)], + {"rax": {0: "tick"}}) + plain_dump(g, 27, 28, struck=0x7fffffffeceb, held={0x7fffffffece8, 0x7fffffffece9, 0x7fffffffecea, 0x7fffffffeccc}) + # ---- asan: stopped at i = 16. Its disassembly's upper rows, down to the call; its report in place of the rest + at_side(RIGHT) + ar = rows_of(ASAN, 0x523d4b, 5, {0x523d56: "trail0", 0x523d53: "trail1", 0x523d51: "trail2"}, + {0x523d56: ("text", "never returned", DIM)}) + at = C.disasm(g, 212, ar, "asan · fill · stopped", 4) + for a, yy in at.items(): + if a in ONLY: + bar(g, RIGHT + 2, yy, DIM) + report(g, RIGHT, 376, REPORT) + asan_dump(g, 16) + clock(g, 28, "i 27 · moment 252 · asan exited") + gen.caption(g, [[("i = 27: the return address is half ",), ("41", "mono"), ("s, and reads",)], + [("41414141", "mono"), (", no longer an address. ASan stopped at i = 16.",)]]) g.save(name) def sheet_store(name): """Mock 27: one turn of the loop, row by row, the plain build's rows facing their counterparts in the ASan - build's; the rows only ASan has barred on the seam side, the plain side's page facing them. i = 3.""" + build's; the rows only ASan has barred on the seam side, the plain side's page facing them. i = 3. Under + each, its buf as bytes: the turn's one byte struck, the letter it is.""" gen.W, gen.H = 1920, 1080 g = Svg() face = {0x40114b: 0x523d1e, 0x40114f: 0x523d22, 0x401151: 0x523d2a, 0x401155: 0x523d5e, 0x40115a: 0x523d61, @@ -217,8 +421,12 @@ def sheet_store(name): continue parts = [(ops, C_)] if isinstance(ops, int) else [(ops, P)] C.insn_rows(g, at[face[a]], [(a, ln if a == 0x40114b else None, mn, parts, None, pnotes.get(a))], 4, lead=4) - gaps = [a for a in order if a in ONLY and a not in skipped] g.t(LEFT + 400, at[0x523d34] + 18, "the check: plain has nothing here", 18, FAINT, "sans") + # the turn's one byte, in each build's buf: the store struck, the reading one letter longer + frame_dump(g, LEFT, 740, "plain · buf", "the turn's byte", PLAIN_ROWS[4:6], plain_mem(4, 3), plain_region, + struck=0x7fffffffecd3) + frame_dump(g, RIGHT, 740, "asan · buf", "its shadow, read before the store", ASAN_ROWS[4:6], asan_mem(4), + asan_region, shadow={0: 0, 1: 0}, read_shadow=0, struck=FAKE + 0x23) gen.caption(g, [[("Plain: one store. ASan: the address, its shadow byte (",), ("addr >> 3", "mono"), (" + ",), ("7fff8000", "mono"), ("),", )], [("a compare with 0, a branch; the partial check and the report only if it is not 0.",)]]) @@ -226,6 +434,7 @@ def sheet_store(name): if __name__ == "__main__": - frame("26-pair-rest", False) + frame("26-pair-rest", 15) sheet_store("27-pair-store") - frame("28-pair-part", True) + frame("28-pair-part", 16) + frame_ret("38-pair-ret") |
