# WARNING! ЭТОТ КОД - ПОЛНОЕ ГОВНИЩЕ
# Если вы Роман Сакутин - немедленно закройте данную страницу!!!

code = open("main.asm").read().strip().lower().split("\n")
program = bytearray()
n = 0
errors = 0

def get_arg_type(arg: str) -> str:
    if arg in ["ax", "bx", "cx", "dx", "ex", "fx"]:
        return "reg"
    elif arg.isdecimal():
        return "dec"
    elif arg.startswith("0x") and all(c in "0123456789abcdefABCDEF" for c in arg[2:]) and len(arg) > 2:
        return "hex"
    return "unk"

def get_reg_hex(arg: str) -> int:
    return int(arg[0], 16)

def get_hex(arg: str) -> int:
    global errorsE
    value = int(arg[2:], 16)
    if value > 65535:
        print(f"[err] line {n}: value too large")
        errors += 1
    return value

def get_dec(arg: str) -> int:
    global errors
    value = int(arg)
    if value > 65535:
        print(f"[err] line {n}: value too large")
        errors += 1
    return value

for line in code:
    line = line.split(";")[0]
    n += 1
    args = line.split()
    if len(args) == 0:
        continue

    if args[0].startswith(":") and args[0].endswith(":") and get_arg_type(args[0].replace(":", "")) == "hex":
        value = get_hex(args[0].replace(":", ""))
        program.extend([0xFF, value >> 8, value & 255])
        
    elif args[0] == "hlt":
        program.append(0x00)

    elif args[0] == "mov":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue
        
        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: the first argument must be a register")
            errors += 1
            continue
        if arg2_type == "reg":
            reg1 = get_reg_hex(args[1])
            reg2 = get_reg_hex(args[2])
            program.extend([1, (reg1 << 4) + reg2])
        elif arg2_type == "hex":
            reg = get_reg_hex(args[1])
            value = get_hex(args[2])
            program.extend([reg, value >> 8, value & 255])
        elif arg2_type == "dec":
            reg = get_reg_hex(args[1])
            value = get_dec(args[2])
            program.extend([reg, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid second argument")
            errors += 1
            continue

    elif args[0] == "jmp":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            exit(-1)

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([3, reg])
        elif arg_type == "hex":
            value = get_hex(args[1])
            program.extend([2, value >> 8, value & 255])
        elif arg_type == "dec":
            value = get_dec(args[1])
            program.extend([2, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "cmp":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([4, (reg1 << 4) + reg2])

    elif args[0] == "je":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "hex":
            value = get_hex(args[1])
            program.extend([5, value >> 8, value & 255])
        elif arg_type == "dec":
            value = get_dec(args[1])
            program.extend([5, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "jne":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "hex":
            value = get_hex(args[1])
            program.extend([6, value >> 8, value & 255])
        elif arg_type == "dec":
            value = get_dec(args[1])
            program.extend([6, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "jg":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "hex":
            value = get_hex(args[1])
            program.extend([7, value >> 8, value & 255])
        elif arg_type == "dec":
            value = get_dec(args[1])
            program.extend([7, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "jl":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "hex":
            value = get_hex(args[1])
            program.extend([8, value >> 8, value & 255])
        elif arg_type == "dec":
            value = get_dec(args[1])
            program.extend([8, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue
    
    elif args[0] == "add":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x10, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x30, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x30, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")
    
    elif args[0] == "sub":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x11, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x31, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x31, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")

    elif args[0] == "inc":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x12, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "dec":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x13, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "mul":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x14, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x32, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x32, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")
    
    elif args[0] == "div":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x15, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x33, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x33, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")
    
    elif args[0] == "rod":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x16, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x34, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x34, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")

    elif args[0] == "and":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x17, (reg1 << 4) + reg2])

    elif args[0] == "or":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x18, (reg1 << 4) + reg2])

    elif args[0] == "xor":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x19, (reg1 << 4) + reg2])

    elif args[0] == "not":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x1A, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "shl":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x1B, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x35, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x35, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")

    elif args[0] == "shr":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x1C, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x36, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x36, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")

    elif args[0] == "save":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x1D, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x37, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x37, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")

    elif args[0] == "load":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg":
            print(f"[err] line {n}: first argument must be integers")
            errors += 1
            continue
        reg1 = get_reg_hex(args[1])
        if arg2_type == "reg":
            reg2 = get_reg_hex(args[2])
            program.extend([0x1E, (reg1 << 4) + reg2])
        elif arg2_type == "dec":
            value = get_dec(args[2])
            program.extend([0x38, value >> 8, value & 255, reg1])
        elif arg2_type == "hex":
            value = get_hex(args[2])
            program.extend([0x38, value >> 8, value & 255, reg1])
        else:
            print(f"[err] line {n}: invalid argument")

    elif args[0] == "ret":
        program.extend([0x20])

    elif args[0] == "call":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "hex":
            value = get_hex(args[1])
            program.extend([0x21, value >> 8, value & 255])
        elif arg_type == "dec":
            value = get_dec(args[1])
            program.extend([0x21, value >> 8, value & 255])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "wr":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x40, (reg1 << 4) + reg2])

    elif args[0] == "rd":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x41, (reg1 << 4) + reg2])

    elif args[0] == "awr":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x42, (reg1 << 4) + reg2])

    elif args[0] == "ard":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x43, (reg1 << 4) + reg2])

    elif args[0] == "del":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x44, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "uwr":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x45, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "del":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x46, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "del":
        if len(args) != 2:
            print(f"[err] line {n}: one argument required")
            errors += 1
            continue

        arg_type = get_arg_type(args[1])
        if arg_type == "reg":
            reg = get_reg_hex(args[1])
            program.extend([0x47, reg])
        else:
            print(f"[err] line {n}: invalid argument")
            errors += 1
            continue

    elif args[0] == "pin":
        if len(args) != 3:
            print(f"[err] line {n}: two arguments required")
            errors += 1
            continue

        arg1_type = get_arg_type(args[1])
        arg2_type = get_arg_type(args[2])

        if arg1_type != "reg" or arg2_type != "reg":
            print(f"[err] line {n}: all two arguments must be registers")
            errors += 1
            continue

        reg1 = get_reg_hex(args[1])
        reg2 = get_reg_hex(args[2])

        program.extend([0x48, (reg1 << 4) + reg2])

    else:
        print(f"[err] line {n}: unknown instruction: {args[0]}")
        errors += 1
        continue


if errors > 0:
    exit(1)
#print(list(map(hex, program)))
open("prog.bin", "wb").write(program)