"""Two-pass Zilog Z80 assembler.

Covers the practical subset most LED / UART demos need:

  * Loads:        LD r,n  /  LD r,r'  /  LD rp,nn  /  LD (nn),A  /  LD A,(nn)
                  LD (nn),HL  /  LD HL,(nn)  /  LD A,(BC|DE)  /  LD (BC|DE),A
                  LD SP,HL
  * 8-bit ALU:    ADD/ADC/SUB/SBC/AND/XOR/OR/CP A,r and A,n
  * 8-bit unary:  INC r  /  DEC r
  * 16-bit:       INC rp  /  DEC rp  /  ADD HL,rp
  * Control:      JP nn / JP cc,nn / JR n / JR cc,n / DJNZ n
                  CALL nn / CALL cc,nn / RET / RET cc / RST n / NOP / HALT
  * Stack:        PUSH rp / POP rp
  * I/O:          IN A,(n) / OUT (n),A
  * Exchanges:    EX DE,HL / EX (SP),HL / EX AF,AF' / EXX
  * Interrupts:   DI / EI / IM 0|1|2 / RETI / RETN
  * Rotates:      RLCA / RRCA / RLA / RRA
  * Block:        LDI / LDIR / LDD / LDDR
  * Misc:         CPL / SCF / CCF / DAA / NEG

Not covered today: CB-prefix bit ops (BIT/SET/RES/RL/RR/SLA/SRA/SRL),
DD/FD-prefix IX/IY indexed addressing, ED-prefix variants beyond what is
listed. The chip emulator implements them; the assembler can be extended
when a demo needs them.

Output is a raw byte stream; the user adds `ORG`/labels/`DB`/`DW` in the
usual way. Used by `POST /api/compile-rom` with `target=z80`.
"""
from __future__ import annotations

import re

# ── Register tables (Z80 encoding) ────────────────────────────────────────
R8  = {'B': 0, 'C': 1, 'D': 2, 'E': 3, 'H': 4, 'L': 5, '(HL)': 6, 'A': 7}
RP  = {'BC': 0, 'DE': 1, 'HL': 2, 'SP': 3}
RP2 = {'BC': 0, 'DE': 1, 'HL': 2, 'AF': 3}   # used by PUSH/POP
CC  = {'NZ': 0, 'Z': 1, 'NC': 2, 'C': 3, 'PO': 4, 'PE': 5, 'P': 6, 'M': 7}
CC_REL = {'NZ': 0, 'Z': 1, 'NC': 2, 'C': 3}  # 8-bit-displacement relative branches


def _atom(tok: str, labels: dict[str, int]) -> int:
    tok = tok.strip()
    if tok.startswith("'") and tok.endswith("'") and len(tok) == 3:
        return ord(tok[1])
    if tok in labels:
        return labels[tok]
    if tok.startswith('0x') or tok.startswith('0X'):
        return int(tok, 16)
    if tok.endswith('h') or tok.endswith('H'):
        return int(tok[:-1], 16)
    if tok.endswith('b') or tok.endswith('B'):
        return int(tok[:-1], 2)
    if tok.lstrip('-').isdigit():
        return int(tok)
    raise ValueError(f"asm-z80: can't parse {tok!r}")


def parse_imm(tok: str, labels: dict[str, int]) -> int:
    tok = tok.strip().rstrip(',').strip()
    # Tiny expression parser — supports a single + or - between two atoms,
    # ignoring operators that sit inside char literals.
    for op_char, sign in [('+', 1), ('-', -1)]:
        in_q = False
        for i, ch in enumerate(tok):
            if ch == "'":
                in_q = not in_q
            elif ch == op_char and not in_q and i > 0:
                return _atom(tok[:i], labels) + sign * _atom(tok[i + 1:], labels)
    return _atom(tok, labels)


def imm16(val: int) -> tuple[int, int]:
    val &= 0xFFFF
    return (val & 0xFF, (val >> 8) & 0xFF)


# ── Parsing helpers ───────────────────────────────────────────────────────
def _split_args(arg_str: str) -> list[str]:
    """Split on commas that aren't inside parens or char literals."""
    out: list[str] = []
    buf = ''
    depth = 0
    in_q = False
    for ch in arg_str:
        if ch == "'":
            in_q = not in_q
            buf += ch
        elif ch == '(' and not in_q:
            depth += 1; buf += ch
        elif ch == ')' and not in_q:
            depth -= 1; buf += ch
        elif ch == ',' and depth == 0 and not in_q:
            out.append(buf.strip())
            buf = ''
        else:
            buf += ch
    if buf.strip():
        out.append(buf.strip())
    return out


def _is_indirect(tok: str) -> bool:
    tok = tok.strip()
    return tok.startswith('(') and tok.endswith(')')


def _strip_paren(tok: str) -> str:
    return tok.strip()[1:-1].strip()


# ── Encoders ──────────────────────────────────────────────────────────────
def _enc_ld(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) != 2:
        raise ValueError(f"LD needs two operands, got {args}")
    dst, src = args[0].upper(), args[1].upper()

    # LD rp,nn  (BC/DE/HL/SP <- immediate)
    if dst in RP and not _is_indirect(src):
        opc = 0x01 | (RP[dst] << 4)
        lo, hi = imm16(parse_imm(src, labels))
        return bytes([opc, lo, hi])

    # LD (nn),A / LD (nn),HL
    if _is_indirect(dst):
        inner = _strip_paren(dst)
        if inner == 'BC' and src == 'A': return bytes([0x02])
        if inner == 'DE' and src == 'A': return bytes([0x12])
        if inner == 'HL':
            if src in R8 and src != '(HL)':
                return bytes([0x70 | R8[src]])
            # LD (HL),n
            lo, hi = imm16(parse_imm(src, labels))
            return bytes([0x36, lo])
        # LD (nn),A or (nn),HL
        lo, hi = imm16(parse_imm(inner, labels))
        if src == 'A':  return bytes([0x32, lo, hi])
        if src == 'HL': return bytes([0x22, lo, hi])
        if src == 'BC': return bytes([0xED, 0x43, lo, hi])
        if src == 'DE': return bytes([0xED, 0x53, lo, hi])
        if src == 'SP': return bytes([0xED, 0x73, lo, hi])
        raise ValueError(f"LD (nn),{src} not supported")

    # LD A,(BC) / LD A,(DE) / LD HL,(nn) / LD A,(nn)
    if _is_indirect(src):
        inner = _strip_paren(src)
        if dst == 'A' and inner == 'BC': return bytes([0x0A])
        if dst == 'A' and inner == 'DE': return bytes([0x1A])
        if dst in R8 and dst != '(HL)' and inner == 'HL':
            return bytes([0x46 | (R8[dst] << 3)])
        lo, hi = imm16(parse_imm(inner, labels))
        if dst == 'A':  return bytes([0x3A, lo, hi])
        if dst == 'HL': return bytes([0x2A, lo, hi])
        if dst == 'BC': return bytes([0xED, 0x4B, lo, hi])
        if dst == 'DE': return bytes([0xED, 0x5B, lo, hi])
        if dst == 'SP': return bytes([0xED, 0x7B, lo, hi])
        raise ValueError(f"LD {dst},({inner}) not supported")

    # LD SP,HL
    if dst == 'SP' and src == 'HL':
        return bytes([0xF9])

    # LD r,r'
    if dst in R8 and src in R8:
        if dst == '(HL)' and src == '(HL)':
            raise ValueError("LD (HL),(HL) is invalid (would be HALT)")
        return bytes([0x40 | (R8[dst] << 3) | R8[src]])

    # LD r,n
    if dst in R8:
        return bytes([0x06 | (R8[dst] << 3), parse_imm(src, labels) & 0xFF])

    # LD I,A / LD A,I / LD R,A / LD A,R
    if dst == 'I' and src == 'A': return bytes([0xED, 0x47])
    if dst == 'R' and src == 'A': return bytes([0xED, 0x4F])
    if dst == 'A' and src == 'I': return bytes([0xED, 0x57])
    if dst == 'A' and src == 'R': return bytes([0xED, 0x5F])

    raise ValueError(f"LD {dst},{src} not supported")


def _enc_alu(base8: int, immcode: int):
    """Build an encoder for an A,r / A,n ALU op.
    base8 is the 8-bit register-form base (e.g. 0x80 for ADD A,r).
    immcode is the 2-byte immediate-form opcode (e.g. 0xC6 for ADD A,n).
    """
    def enc(args: list[str], labels: dict[str, int]) -> bytes:
        # Z80 syntax is `ADD A,r` but plain `ADD r` is also accepted.
        if len(args) == 2 and args[0].upper() == 'A':
            args = [args[1]]
        if len(args) != 1:
            raise ValueError(f"ALU needs one operand (besides A), got {args}")
        tok = args[0].upper()
        if tok in R8:
            return bytes([base8 | R8[tok]])
        # Immediate
        return bytes([immcode, parse_imm(args[0], labels) & 0xFF])
    return enc


def _enc_inc_dec(is_inc: bool):
    def enc(args: list[str], labels: dict[str, int]) -> bytes:
        if len(args) != 1:
            raise ValueError("INC/DEC takes one operand")
        tok = args[0].upper()
        if tok in RP:
            base = 0x03 if is_inc else 0x0B
            return bytes([base | (RP[tok] << 4)])
        if tok in R8:
            base = 0x04 if is_inc else 0x05
            return bytes([base | (R8[tok] << 3)])
        raise ValueError(f"INC/DEC {tok!r} not supported")
    return enc


def _enc_push_pop(is_push: bool):
    def enc(args: list[str], labels: dict[str, int]) -> bytes:
        if len(args) != 1 or args[0].upper() not in RP2:
            raise ValueError(f"PUSH/POP needs BC/DE/HL/AF, got {args}")
        base = 0xC5 if is_push else 0xC1
        return bytes([base | (RP2[args[0].upper()] << 4)])
    return enc


def _enc_addhl(args: list[str], labels: dict[str, int]) -> bytes:
    # Accept ADD HL,rp.
    if len(args) == 2 and args[0].upper() == 'HL':
        rp = args[1].upper()
        if rp in RP:
            return bytes([0x09 | (RP[rp] << 4)])
    raise ValueError(f"ADD HL,rp expected, got {args}")


def _enc_jp(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) == 1:
        if args[0].upper() == '(HL)':
            return bytes([0xE9])
        lo, hi = imm16(parse_imm(args[0], labels))
        return bytes([0xC3, lo, hi])
    if len(args) == 2 and args[0].upper() in CC:
        lo, hi = imm16(parse_imm(args[1], labels))
        return bytes([0xC2 | (CC[args[0].upper()] << 3), lo, hi])
    raise ValueError(f"JP {args} not supported")


def _rel(addr_from_after_instr: int, target: int) -> int:
    delta = target - addr_from_after_instr
    if delta < -128 or delta > 127:
        raise ValueError(f"JR/DJNZ out of range: delta={delta}")
    return delta & 0xFF


def _enc_jr(pc_after, args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) == 1:
        tgt = parse_imm(args[0], labels)
        return bytes([0x18, _rel(pc_after, tgt)])
    if len(args) == 2 and args[0].upper() in CC_REL:
        tgt = parse_imm(args[1], labels)
        return bytes([0x20 | (CC_REL[args[0].upper()] << 3), _rel(pc_after, tgt)])
    raise ValueError(f"JR {args} not supported")


def _enc_djnz(pc_after, args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) != 1:
        raise ValueError(f"DJNZ takes one operand")
    tgt = parse_imm(args[0], labels)
    return bytes([0x10, _rel(pc_after, tgt)])


def _enc_call(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) == 1:
        lo, hi = imm16(parse_imm(args[0], labels))
        return bytes([0xCD, lo, hi])
    if len(args) == 2 and args[0].upper() in CC:
        lo, hi = imm16(parse_imm(args[1], labels))
        return bytes([0xC4 | (CC[args[0].upper()] << 3), lo, hi])
    raise ValueError(f"CALL {args} not supported")


def _enc_ret(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) == 0:
        return bytes([0xC9])
    if len(args) == 1 and args[0].upper() in CC:
        return bytes([0xC0 | (CC[args[0].upper()] << 3)])
    raise ValueError(f"RET {args} not supported")


def _enc_rst(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) != 1:
        raise ValueError("RST takes one operand")
    n = parse_imm(args[0], labels)
    if n not in (0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38):
        raise ValueError(f"RST {n:02x}h is not a legal vector")
    return bytes([0xC7 | n])


def _enc_in(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) == 2 and args[0].upper() == 'A' and _is_indirect(args[1]):
        return bytes([0xDB, parse_imm(_strip_paren(args[1]), labels) & 0xFF])
    raise ValueError(f"IN {args} not supported")


def _enc_out(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) == 2 and _is_indirect(args[0]) and args[1].upper() == 'A':
        return bytes([0xD3, parse_imm(_strip_paren(args[0]), labels) & 0xFF])
    raise ValueError(f"OUT {args} not supported")


def _enc_ex(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) != 2:
        raise ValueError("EX needs two operands")
    a, b = args[0].upper(), args[1].upper()
    if a == 'DE' and b == 'HL':       return bytes([0xEB])
    if a == 'AF' and b == "AF'":      return bytes([0x08])
    if a == "AF" and b == "AF'":      return bytes([0x08])
    if a == '(SP)' and b == 'HL':     return bytes([0xE3])
    raise ValueError(f"EX {args} not supported")


def _enc_im(args: list[str], labels: dict[str, int]) -> bytes:
    if len(args) != 1:
        raise ValueError("IM takes one operand")
    n = parse_imm(args[0], labels)
    return {0: bytes([0xED, 0x46]), 1: bytes([0xED, 0x56]), 2: bytes([0xED, 0x5E])}.get(n) or _bad(f"IM {n}")


def _bad(msg: str):
    raise ValueError(msg)


def _simple(opc: int):
    if isinstance(opc, int):
        return lambda a, l: bytes([opc])
    return lambda a, l: bytes(opc)


def _two(b0: int, b1: int):
    return lambda a, l: bytes([b0, b1])


# Build dispatch tables.
INSTR_SIZE: dict[str, int] = {}
INSTR_ENCODE: dict[str, callable] = {}   # type: ignore[type-arg]


def _reg(name: str, size: int, fn) -> None:
    INSTR_SIZE[name] = size
    INSTR_ENCODE[name] = fn


# ── Static (no operands) ─────────────────────────────────────────────────
_reg('NOP',   1, _simple(0x00))
_reg('HALT',  1, _simple(0x76))
_reg('CPL',   1, _simple(0x2F))
_reg('SCF',   1, _simple(0x37))
_reg('CCF',   1, _simple(0x3F))
_reg('DAA',   1, _simple(0x27))
_reg('RLCA',  1, _simple(0x07))
_reg('RRCA',  1, _simple(0x0F))
_reg('RLA',   1, _simple(0x17))
_reg('RRA',   1, _simple(0x1F))
_reg('DI',    1, _simple(0xF3))
_reg('EI',    1, _simple(0xFB))
_reg('EXX',   1, _simple(0xD9))
_reg('NEG',   2, _two(0xED, 0x44))
_reg('RETI',  2, _two(0xED, 0x4D))
_reg('RETN',  2, _two(0xED, 0x45))
_reg('LDI',   2, _two(0xED, 0xA0))
_reg('LDIR',  2, _two(0xED, 0xB0))
_reg('LDD',   2, _two(0xED, 0xA8))
_reg('LDDR',  2, _two(0xED, 0xB8))
_reg('CPI',   2, _two(0xED, 0xA1))
_reg('CPIR',  2, _two(0xED, 0xB1))

# ── ALU 8-bit ─────────────────────────────────────────────────────────────
def _reg_alu(name: str, base8: int, immcode: int) -> None:
    INSTR_ENCODE[name] = _enc_alu(base8, immcode)
    # Size depends on operand — set in pass 1 dynamically (see assemble()).

for n, base, imm in [('ADD', 0x80, 0xC6), ('ADC', 0x88, 0xCE),
                     ('SUB', 0x90, 0xD6), ('SBC', 0x98, 0xDE),
                     ('AND', 0xA0, 0xE6), ('XOR', 0xA8, 0xEE),
                     ('OR',  0xB0, 0xF6), ('CP',  0xB8, 0xFE)]:
    _reg_alu(n, base, imm)

INSTR_ENCODE['INC'] = _enc_inc_dec(True)
INSTR_ENCODE['DEC'] = _enc_inc_dec(False)
INSTR_ENCODE['LD']  = _enc_ld
INSTR_ENCODE['PUSH'] = _enc_push_pop(True)
INSTR_ENCODE['POP']  = _enc_push_pop(False)
INSTR_ENCODE['JP']   = _enc_jp
INSTR_ENCODE['CALL'] = _enc_call
INSTR_ENCODE['RET']  = _enc_ret
INSTR_ENCODE['RST']  = _enc_rst
INSTR_ENCODE['IN']   = _enc_in
INSTR_ENCODE['OUT']  = _enc_out
INSTR_ENCODE['EX']   = _enc_ex
INSTR_ENCODE['IM']   = _enc_im

# JR and DJNZ are PC-relative — they need pc_after to encode.
# Handled specially in the assemble() pass below.
INSTR_ENCODE['JR']   = '__JR__'      # sentinel
INSTR_ENCODE['DJNZ'] = '__DJNZ__'
INSTR_ENCODE['ADD']  = _enc_alu(0x80, 0xC6)


# ── Static-size table (used only when encoder doesn't depend on operand) ─
STATIC_SIZE = {
    'NOP': 1, 'HALT': 1, 'CPL': 1, 'SCF': 1, 'CCF': 1, 'DAA': 1,
    'RLCA': 1, 'RRCA': 1, 'RLA': 1, 'RRA': 1, 'DI': 1, 'EI': 1, 'EXX': 1,
    'NEG': 2, 'RETI': 2, 'RETN': 2, 'LDI': 2, 'LDIR': 2, 'LDD': 2,
    'LDDR': 2, 'CPI': 2, 'CPIR': 2,
    'RST': 1, 'JR': 2, 'DJNZ': 2, 'IM': 2,
    'IN':  2, 'OUT': 2,
    'PUSH': 1, 'POP': 1, 'INC': 1, 'DEC': 1, 'EX': 1,
}


def _size_for(mnem: str, args: list[str]) -> int:
    """Estimate the size of an instruction (pass 1) without resolving labels.
    Conservative — returns the LARGER of the possible encodings when in doubt
    so labels resolve to stable addresses.
    """
    if mnem in STATIC_SIZE:
        return STATIC_SIZE[mnem]
    if mnem == 'LD':
        # Distinguish LD r,r' (1) vs LD r,n (2) vs LD rp,nn (3) vs LD (nn),A (3 or 4)
        if len(args) != 2: return 1
        a, b = args[0].upper(), args[1].upper()
        if _is_indirect(a):
            inner = _strip_paren(a)
            if inner in ('BC', 'DE'):     return 1
            if inner == 'HL':
                if b in R8 and b != '(HL)': return 1
                return 2     # LD (HL),n
            # LD (nn),X
            if b in ('A',):                return 3
            if b == 'HL':                  return 3
            if b in ('BC', 'DE', 'SP'):    return 4
            return 3
        if _is_indirect(b):
            inner = _strip_paren(b)
            if inner in ('BC', 'DE'):     return 1
            if inner == 'HL':              return 1
            if a == 'A':                  return 3
            if a == 'HL':                 return 3
            if a in ('BC', 'DE', 'SP'):   return 4
            return 3
        if a in RP:                       return 3
        if a == 'SP' and b == 'HL':       return 1
        if a in R8 and b in R8:           return 1
        return 2                           # LD r,n
    if mnem in ('ADD', 'ADC', 'SUB', 'SBC', 'AND', 'XOR', 'OR', 'CP'):
        # `ADD HL,rp` is 1 byte, ALU A,r is 1, ALU A,n is 2.
        if mnem == 'ADD' and len(args) == 2 and args[0].upper() == 'HL':
            return 1
        # Strip leading "A," if present.
        if len(args) == 2 and args[0].upper() == 'A':
            args = [args[1]]
        if len(args) == 1 and args[0].upper() in R8: return 1
        return 2
    if mnem == 'JP':
        if len(args) == 1 and args[0].upper() == '(HL)': return 1
        return 3
    if mnem == 'CALL':
        return 3
    if mnem == 'RET':
        return 1
    raise ValueError(f"asm-z80 pass1: unknown mnemonic {mnem!r}")


def assemble(src: str) -> bytes:
    """Two-pass assembler: pass 1 sizes + labels, pass 2 emits."""
    # ── Tokenize ─────────────────────────────────────────────────────────
    lines: list[tuple[str | None, str | None, list[str]]] = []
    for raw in src.splitlines():
        text = raw.split(';', 1)[0].rstrip()
        if not text.strip():
            lines.append((None, None, [])); continue
        label = None
        # Find first ':' outside parens / quotes — same scheme as asm8080.
        in_q = False; depth = 0; colon = -1
        for i, ch in enumerate(text):
            if ch == "'": in_q = not in_q
            elif ch == '(': depth += 1
            elif ch == ')': depth = max(0, depth - 1)
            elif ch == ':' and not in_q and depth == 0:
                colon = i; break
        if colon >= 0:
            label = text[:colon].strip()
            text = text[colon + 1:]
        text = text.strip()
        if not text:
            lines.append((label, None, [])); continue
        m = re.match(r'\s*(\S+)\s*(.*)$', text)
        if not m:
            lines.append((label, None, [])); continue
        mnem = m.group(1).upper()
        args = _split_args(m.group(2).strip())
        lines.append((label, mnem, args))

    # ── Pass 1: estimate sizes + assign labels ───────────────────────────
    labels: dict[str, int] = {}
    sizes: list[int] = []
    pc = 0
    for (lbl, mnem, args) in lines:
        if lbl:
            labels[lbl] = pc
        if mnem is None:
            sizes.append(0); continue
        if mnem == 'ORG':
            new_pc = parse_imm(args[0], labels)
            if new_pc < pc:
                raise ValueError(f"ORG cannot move backwards (at {pc} -> {new_pc})")
            sizes.append(new_pc - pc); pc = new_pc; continue
        if mnem == 'DB':
            n = 0
            for a in args:
                if a.startswith('"') and a.endswith('"'):
                    n += len(bytes(a[1:-1], 'utf-8').decode('unicode_escape'))
                else:
                    n += 1
            sizes.append(n); pc += n; continue
        if mnem == 'DW':
            sizes.append(2 * len(args)); pc += 2 * len(args); continue
        sz = _size_for(mnem, args)
        sizes.append(sz); pc += sz

    # ── Pass 2: emit ──────────────────────────────────────────────────────
    out = bytearray()
    pc = 0
    for (i, (lbl, mnem, args)) in enumerate(lines):
        if mnem is None:
            continue
        if mnem == 'ORG':
            tgt = parse_imm(args[0], labels)
            while pc < tgt:
                out.append(0x00); pc += 1
            continue
        if mnem == 'DB':
            for a in args:
                if a.startswith('"') and a.endswith('"'):
                    blob = bytes(a[1:-1], 'utf-8').decode('unicode_escape').encode('latin1')
                    out.extend(blob); pc += len(blob)
                else:
                    v = parse_imm(a, labels) & 0xFF
                    out.append(v); pc += 1
            continue
        if mnem == 'DW':
            for a in args:
                lo, hi = imm16(parse_imm(a, labels))
                out.append(lo); out.append(hi); pc += 2
            continue

        enc = INSTR_ENCODE.get(mnem)
        if enc is None:
            raise ValueError(f"asm-z80: unknown mnemonic {mnem!r}")

        # JR / DJNZ need pc_after (pc + size) for relative encoding.
        if enc == '__JR__':
            data = _enc_jr(pc + 2, args, labels)
        elif enc == '__DJNZ__':
            data = _enc_djnz(pc + 2, args, labels)
        elif mnem == 'ADD' and len(args) == 2 and args[0].upper() == 'HL':
            data = _enc_addhl(args, labels)
        else:
            data = enc(args, labels)
        out.extend(data); pc += len(data)

    return bytes(out)


if __name__ == '__main__':
    import sys
    if len(sys.argv) < 2:
        print('usage: asmz80.py <input.s>'); sys.exit(2)
    rom = assemble(open(sys.argv[1], encoding='utf-8').read())
    print(f"// {len(rom)} bytes")
    print('static const uint8_t ROM[] = {')
    for i in range(0, len(rom), 12):
        chunk = ', '.join(f'0x{b:02x}' for b in rom[i:i+12])
        print(f"    {chunk},")
    print('};')