import hashlib
import time

class CodexByteVM:
    def __init__(self):
        self.reg = [0] * 8
        self.mem = {}
        self.pc = 0
        self.flags = {"Z": False}
        self.ledger = []

    def _hash(self, v):
        return hashlib.sha256(str(v).encode()).hexdigest()

    def step(self, prog):
        op = prog[self.pc]
        self.pc += 1

        if op == 0x00:  # HALT
            return False

        elif op == 0x01:  # LOAD_IMM r v
            r, v = prog[self.pc], prog[self.pc + 1]
            self.pc += 2
            self.reg[r] = v

        elif op == 0x02:  # LOAD_MEM r a
            r, a = prog[self.pc], prog[self.pc + 1]
            self.pc += 2
            self.reg[r] = self.mem.get(a, 0)

        elif op == 0x03:  # STORE r a
            r, a = prog[self.pc], prog[self.pc + 1]
            self.pc += 2
            self.mem[a] = self.reg[r]

        elif op == 0x04:  # ADD r1 r2
            r1, r2 = prog[self.pc], prog[self.pc + 1]
            self.pc += 2
            self.reg[r1] += self.reg[r2]

        elif op == 0x08:  # CMP r1 r2
            r1, r2 = prog[self.pc], prog[self.pc + 1]
            self.pc += 2
            self.flags["Z"] = (self.reg[r1] == self.reg[r2])

        elif op == 0x0A:  # JZ addr
            addr = prog[self.pc]
            self.pc += 1
            if self.flags["Z"]:
                self.pc = addr

        elif op == 0x0C:  # HASH r
            r = prog[self.pc]
            self.pc += 1
            self.reg[r] = self._hash(self.reg[r])

        elif op == 0x0F:  # COMMIT
            state = (tuple(self.reg), dict(self.mem))
            self.ledger.append(self._hash(state))

        elif op == 0x11:  # EMIT r
            r = prog[self.pc]
            self.pc += 1
            self.mem["LAST_PROOF"] = self.reg[r]

        return True

    def run(self, prog):
        self.pc = 0
        self.ledger.clear()
        while self.step(prog):
            pass
        return self.ledger