LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: argument_list
static size_t argument_list(void) {
    size_t arg_count = 0;

    if (!check(TOKEN_RIGHT_PAREN)) {
        do {
            expression();
            arg_count++;
        } while (match(TOKEN_COMMA));
    }

    consume(TOKEN_RIGHT_PAREN, "Expected ')' after function call arguments");

    return arg_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x1, %edi
callq 0x5e80
testb $0x1, %al
jne 0x5ba1
jmp 0x5b80
callq 0x57e0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x4, %edi
callq 0x5710
testb $0x1, %al
jne 0x5b80
jmp 0x5ba1
movl $0x1, %edi
leaq 0x66e4(%rip), %rsi      # 0xc291
callq 0x57f0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: alloc_register
static int alloc_register(void) {
    for (int i = 0; i < NUM_REGISTERS; i++) {
        if (parser.free_registers[i]) {
            parser.free_registers[i] = false;
            register_alloc_counter++;
            return i;
        }
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jge 0x5c1a
movslq -0x8(%rbp), %rcx
leaq 0x139c9(%rip), %rax     # 0x195a8
testb $0x1, 0x7a(%rax,%rcx)
je 0x5c0d
movslq -0x8(%rbp), %rcx
leaq 0x139b7(%rip), %rax     # 0x195a8
movb $0x0, 0x7a(%rax,%rcx)
movl 0x1399c(%rip), %eax     # 0x19598
addl $0x1, %eax
movl %eax, 0x13993(%rip)     # 0x19598
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5c21
jmp 0x5c0f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5bcb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: free_register
static void free_register(uint8_t reg) {
    if (parser.free_registers[reg]) {
        error("Register double free");
    }

    parser.free_registers[reg] = true;
    register_alloc_counter--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x1393d(%rip), %rax     # 0x195a8
testb $0x1, 0x7a(%rax,%rcx)
je 0x5c7e
leaq 0x665f(%rip), %rdi      # 0xc2d8
callq 0x57b0
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x1391d(%rip), %rax     # 0x195a8
movb $0x1, 0x7a(%rax,%rcx)
movl 0x13902(%rip), %eax     # 0x19598
addl $-0x1, %eax
movl %eax, 0x138f9(%rip)     # 0x19598
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_opcode
static void emit_opcode(uint16_t opcode) {
    uint8_t first_byte = (uint8_t) (opcode >> 8);
    if (first_byte == EXTENDED_OPCODE_TABLE1 || first_byte == EXTENDED_OPCODE_TABLE2) {
        EMIT(uint16_t, opcode);
    } else {
        EMIT(uint8_t, (uint8_t) opcode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0xf8, %eax
je 0x5d0f
movzbl -0x3(%rbp), %eax
cmpl $0xf9, %eax
jne 0x5d40
jmp 0x5d11
movw -0x2(%rbp), %ax
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, -0x8(%rbp)
callq 0x5ea0
movq %rax, %rdi
leaq -0x8(%rbp), %rdx
movq 0x138b4(%rip), %rcx     # 0x195e8
movl $0x2, %esi
callq 0x4300
jmp 0x5d6e
jmp 0x5d42
movw -0x2(%rbp), %ax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0xa(%rbp)
callq 0x5ea0
movq %rax, %rdi
leaq -0xa(%rbp), %rdx
movq 0x13886(%rip), %rcx     # 0x195e8
movl $0x1, %esi
callq 0x4300
jmp 0x5d6e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_stack_push_value
static void emit_stack_push_value(int32_t val) {
    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;

    emit_leti(reg, val);
    emit_stack_push(reg);

    free_register(reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x5bc0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x5e20
callq 0x5c30
jmp 0x5e46
movl -0x8(%rbp), %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movl -0x4(%rbp), %esi
movzbl %al, %edi
callq 0x5eb0
movzbl -0x9(%rbp), %edi
callq 0x5b30
movzbl -0x9(%rbp), %edi
callq 0x5c50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: take_label
static size_t take_label(void) {
    size_t label = ++parser.labels_count;
    if (label > UINT16_MAX) {
        error("Too many labels");
    }
    return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x13799(%rip), %rax     # 0x19728
addq $0x1, %rax
movq %rax, 0x1378e(%rip)     # 0x19728
movq %rax, -0x8(%rbp)
cmpq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jbe 0x5fb4
leaq 0x634c(%rip), %rdi      # 0xc2fb
callq 0x57b0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_conditional_jump_rr
static void emit_conditional_jump_rr(uint16_t opcode, uint8_t reg1, uint8_t reg2, size_t label) {
    emit_opcode(opcode);
    emit_register(reg1);
    emit_register(reg2);
    emit_word((int16_t) label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %dl
movw %di, %si
movw %si, -0x2(%rbp)
movb %dl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movq %rcx, -0x10(%rbp)
movzwl -0x2(%rbp), %edi
callq 0x5ce0
movzbl -0x3(%rbp), %edi
callq 0x5d80
movzbl -0x4(%rbp), %edi
callq 0x5d80
movq -0x10(%rbp), %rax
movswl %ax, %edi
callq 0x5f30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_conditional_jump_ri
static void emit_conditional_jump_ri(uint16_t opcode, uint8_t reg, int32_t val, size_t label) {
    emit_opcode(opcode);
    emit_register(reg);
    emit_dword(val);
    emit_word((int16_t) label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movw %di, %si
movw %si, -0x2(%rbp)
movb %al, -0x3(%rbp)
movl %edx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movzwl -0x2(%rbp), %edi
callq 0x5ce0
movzbl -0x3(%rbp), %edi
callq 0x5d80
movl -0x8(%rbp), %edi
callq 0x5ef0
movq -0x10(%rbp), %rax
movswl %ax, %edi
callq 0x5f30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: named_variable
static void named_variable(Token name, bool can_assign) {
    Local* local = resolve_local(current, &name);

    if (local == NULL) {
        const OpcodeDefinition* opcode = get_opcode_definition_from_token(&name);
        Function* function = NULL;

        if (opcode == NULL) {
            function = resolve_function(&name);

            if (function == NULL) {
                error("Could not resolve variable");
                return;
            }
        }

        if (!check(TOKEN_LEFT_PAREN)) {
            // Not a call, must be a reference

            if (opcode != NULL) {
                error("Opcodes cannot be referenced");
                return;
            }

            emit_stack_push_value((int32_t) function->label);
        }
    } else {
        if (can_assign && match(TOKEN_EQUAL)) {
            // Variable write
            expression();
            emit_stack_peek(local->reg);
            local->initialized = true;
        } else if (local->depth != -1) {
            // Variable read

            if (!local->initialized) {
                char str[256];
                snprintf(str, 256, "Variable \"%.*s\" used before initialization", (int) local->name.length, local->name.start);
                error(str);
                return;
            }

            emit_stack_push(local->reg);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movb %dil, %al
leaq 0x10(%rbp), %rsi
movq %rsi, -0x128(%rbp)
andb $0x1, %al
movb %al, -0x1(%rbp)
movq 0x13463(%rip), %rdi     # 0x19588
callq 0x6260
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x61b9
movq -0x128(%rbp), %rdi
callq 0x5a10
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6182
movq -0x128(%rbp), %rdi
callq 0x5a80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6180
leaq 0x6195(%rip), %rdi      # 0xc30b
callq 0x57b0
jmp 0x624a
jmp 0x6182
xorl %edi, %edi
callq 0x5e80
testb $0x1, %al
jne 0x61b4
cmpq $0x0, -0x18(%rbp)
je 0x61a5
leaq 0x618b(%rip), %rdi      # 0xc326
callq 0x57b0
jmp 0x624a
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl %eax, %edi
callq 0x5e00
jmp 0x624a
testb $0x1, -0x1(%rbp)
je 0x61eb
movl $0xe, %edi
callq 0x5710
testb $0x1, %al
jne 0x61cf
jmp 0x61eb
callq 0x57e0
movq -0x10(%rbp), %rax
movzbl 0x2e(%rax), %edi
callq 0x60d0
movq -0x10(%rbp), %rax
movb $0x1, 0x2c(%rax)
jmp 0x6248
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
je 0x6246
movq -0x10(%rbp), %rax
testb $0x1, 0x2c(%rax)
jne 0x6239
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x611f(%rip), %rdx      # 0xc343
movb $0x0, %al
callq 0x40a0
leaq -0x120(%rbp), %rdi
callq 0x57b0
jmp 0x624a
movq -0x10(%rbp), %rax
movzbl 0x2e(%rax), %edi
callq 0x5b30
jmp 0x6248
jmp 0x624a
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: resolve_local
static Local* resolve_local(Compiler* compiler, Token* name) {
    for (int i = (int) compiler->local_count - 1; i >= 0; i--) {
        Local* local = &compiler->locals[i];
        if (identifiers_equal(name, &local->name)) {
            if (local->depth == -1) {
                error("Cannot access variable in its own initializer");
            }

            return local;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x3000(%rax), %rax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x62da
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62f0
testb $0x1, %al
jne 0x62ad
jmp 0x62cd
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
jne 0x62c3
leaq 0x60b0(%rip), %rdi      # 0xc36e
callq 0x57b0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x62e2
jmp 0x62cf
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6281
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: let_declaration
static void let_declaration(void) {
    int ret = parse_variable("Expected variable name");

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;

    bool initialized = false;

    if (match(TOKEN_EQUAL)) {
        expression();
        initialized = true;
    } else {
        emit_stack_push_value(0);
    }

    consume(TOKEN_SEMICOLON, "Expected ';' after variable declaration");

    Local* local = &current->locals[current->local_count - 1];
    define_variable(reg, local);

    local->initialized = initialized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x6153(%rip), %rdi      # 0xc4d2
callq 0x6900
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6394
callq 0x5c30
jmp 0x6411
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
movb $0x0, -0x6(%rbp)
movl $0xe, %edi
callq 0x5710
testb $0x1, %al
jne 0x63ae
jmp 0x63b9
callq 0x57e0
movb $0x1, -0x6(%rbp)
jmp 0x63c0
xorl %edi, %edi
callq 0x5e00
movl $0x7, %edi
leaq 0x611d(%rip), %rsi      # 0xc4e9
callq 0x57f0
movq 0x131b0(%rip), %rax     # 0x19588
movq 0x131a9(%rip), %rcx     # 0x19588
movq 0x3000(%rcx), %rcx
subq $0x1, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movb -0x5(%rbp), %al
movq -0x10(%rbp), %rsi
movzbl %al, %edi
callq 0x6950
movb -0x6(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x2c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: statement
static void statement(void) {
    if (match(TOKEN_PRINT)) {
        print_statement();
    } else if (match(TOKEN_IF)) {
        if_statement();
    } else if (match(TOKEN_RETURN)) {
        return_statement();
    } else if (match(TOKEN_FOR)) {
        for_statement();
    } else if (match(TOKEN_WHILE)) {
        while_statement();
    } else if (match(TOKEN_LEFT_BRACE)) {
        begin_scope();
        block();
        end_scope();
    } else {
        expression_statement();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x24, %edi
callq 0x5710
testb $0x1, %al
jne 0x6434
jmp 0x643e
callq 0x6d40
jmp 0x64ca
movl $0x22, %edi
callq 0x5710
testb $0x1, %al
jne 0x644e
jmp 0x6455
callq 0x6ef0
jmp 0x64c8
movl $0x25, %edi
callq 0x5710
testb $0x1, %al
jne 0x6465
jmp 0x646c
callq 0x6fc0
jmp 0x64c6
movl $0x20, %edi
callq 0x5710
testb $0x1, %al
jne 0x647c
jmp 0x6483
callq 0x7020
jmp 0x64c4
movl $0x28, %edi
callq 0x5710
testb $0x1, %al
jne 0x6493
jmp 0x649a
callq 0x7170
jmp 0x64c2
movl $0x2, %edi
callq 0x5710
testb $0x1, %al
jne 0x64aa
jmp 0x64bb
callq 0x67a0
callq 0x69a0
callq 0x6a30
jmp 0x64c0
callq 0x7210
jmp 0x64c2
jmp 0x64c4
jmp 0x64c6
jmp 0x64c8
jmp 0x64ca
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: synchronize
static void synchronize(void) {
    parser.panic_mode = false;

    while (parser.current.type != TOKEN_EOF) {
        if (parser.previous.type == TOKEN_SEMICOLON) {
            return;
        }

        switch (parser.current.type) {
            case TOKEN_FUNCTION:
            case TOKEN_LET:
            case TOKEN_FOR:
            case TOKEN_IF:
            case TOKEN_WHILE:
            case TOKEN_PRINT:
            case TOKEN_RETURN:
                return;
            default:
                break;
        }

        advance();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, 0x13142(%rip)     # 0x19621
cmpl $0x2a, 0x130c2(%rip)    # 0x195a8
je 0x652b
cmpl $0x7, 0x130e1(%rip)     # 0x195d0
jne 0x64f3
jmp 0x652b
movl 0x130af(%rip), %eax     # 0x195a8
movl %eax, -0x4(%rbp)
addl $-0x20, %eax
subl $0x3, %eax
jb 0x6520
jmp 0x6506
movl -0x4(%rbp), %eax
addl $-0x24, %eax
subl $0x2, %eax
jb 0x6520
jmp 0x6513
movl -0x4(%rbp), %eax
addl $-0x27, %eax
subl $0x1, %eax
ja 0x6522
jmp 0x6520
jmp 0x652b
jmp 0x6524
callq 0x5690
jmp 0x64df
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: define_function
static void define_function(Function* func) {
    if (get_opcode_definition_from_token(&func->name) != NULL) {
        char str[128];
        snprintf(str, 128, "Function shadows opcode \"%.*s\"", (int) func->name.length, func->name.start);
        error(str);
        return;
    }

    if (parser.functions_capacity < parser.functions_count + 1) {
        size_t old_capacity = parser.functions_capacity;
        parser.functions_capacity = GROW_CAPACITY(old_capacity);
        parser.functions = GROW_ARRAY(Function*, parser.functions,
            old_capacity, parser.functions_capacity);
    }

    parser.functions[parser.functions_count] = func;
    parser.functions_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5a10
cmpq $0x0, %rax
je 0x681b
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movl $0x80, %esi
leaq 0x5c51(%rip), %rdx      # 0xc454
movb $0x0, %al
callq 0x40a0
leaq -0x90(%rbp), %rdi
callq 0x57b0
jmp 0x68c8
movq 0x12f26(%rip), %rax     # 0x19748
movq 0x12f17(%rip), %rcx     # 0x19740
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x68a0
movq 0x12f0f(%rip), %rax     # 0x19748
movq %rax, -0x98(%rbp)
cmpq $0x8, -0x98(%rbp)
jae 0x6858
movl $0x8, %eax
movq %rax, -0xa0(%rbp)
jmp 0x6869
movq -0x98(%rbp), %rax
shlq %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, 0x12ed1(%rip)     # 0x19748
movq 0x12eba(%rip), %rdi     # 0x19738
movq -0x98(%rbp), %rsi
shlq $0x3, %rsi
movq 0x12eb8(%rip), %rdx     # 0x19748
shlq $0x3, %rdx
callq 0x79e0
movq %rax, 0x12e98(%rip)     # 0x19738
movq -0x8(%rbp), %rdx
movq 0x12e8d(%rip), %rax     # 0x19738
movq 0x12e8e(%rip), %rcx     # 0x19740
movq %rdx, (%rax,%rcx,8)
movq 0x12e83(%rip), %rax     # 0x19740
addq $0x1, %rax
movq %rax, 0x12e78(%rip)     # 0x19740
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: parse_variable
static int parse_variable(const char* error) {
    consume(TOKEN_IDENTIFIER, error);

    declare_variable();
    if (current->scope_depth > 0) {
        return alloc_register();
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x1a, %edi
callq 0x57f0
callq 0x6af0
movq 0x12c62(%rip), %rax     # 0x19588
cmpl $0x0, 0x3008(%rax)
jle 0x6939
callq 0x5bc0
movl %eax, -0x4(%rbp)
jmp 0x6940
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: define_variable
static void define_variable(uint8_t reg, Local* local) {
    if (current->scope_depth > 0) {
        local->allocated = true;
        local->reg = reg;
        mark_initialized(local);
        emit_stack_pop(reg);
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x12c1f(%rip), %rax     # 0x19588
cmpl $0x0, 0x3008(%rax)
jle 0x6996
movq -0x10(%rbp), %rax
movb $0x1, 0x2d(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2e(%rax)
movq -0x10(%rbp), %rdi
callq 0x6c80
movzbl -0x1(%rbp), %edi
callq 0x5cb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_void_return
static void emit_void_return(void) {
    emit_stack_push_value(0);

    if (parser.current_function_label != entry_point_label) {
        emit_stack_swap();
    }

    emit_opcode(OP_RET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x5e00
movq 0x12d3e(%rip), %rax     # 0x19750
cmpq 0x12b77(%rip), %rax     # 0x19590
je 0x6a20
callq 0x6cb0
movl $0x1, %edi
callq 0x5ce0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: end_scope
static void end_scope(void) {
    current->scope_depth--;

    while (current->local_count > 0 && current->locals[current->local_count - 1].depth > current->scope_depth) {
        free_register(current->locals[current->local_count - 1].reg);
        current->local_count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x12b49(%rip), %rax     # 0x19588
movl 0x3008(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3008(%rax)
movq 0x12b33(%rip), %rcx     # 0x19588
xorl %eax, %eax
cmpq $0x0, 0x3000(%rcx)
movb %al, -0x1(%rbp)
jbe 0x6a9a
movq 0x12b1d(%rip), %rax     # 0x19588
movq 0x12b16(%rip), %rcx     # 0x19588
movq 0x3000(%rcx), %rcx
subq $0x1, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x28(%rax), %eax
movq 0x12afa(%rip), %rcx     # 0x19588
cmpl 0x3008(%rcx), %eax
setg %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x6aa3
jmp 0x6aea
movq 0x12ade(%rip), %rax     # 0x19588
movq 0x12ad7(%rip), %rcx     # 0x19588
movq 0x3000(%rcx), %rcx
subq $0x1, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movzbl 0x2e(%rax), %edi
callq 0x5c50
movq 0x12ab5(%rip), %rax     # 0x19588
movq 0x3000(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x3000(%rax)
jmp 0x6a4e
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: declare_variable
static void declare_variable(void) {
    if (current->scope_depth == 0) {
        return;
    }

    Token* name = &parser.previous;

    for (int i = (int) current->local_count - 1; i >= 0; i--) {
        Local* local = &current->locals[i];
        if (local->depth != -1 && local->depth < current->scope_depth) {
            break;
        }

        if (identifiers_equal(name, &local->name)) {
            error("Identifier has already been declared");
        }
    }

    add_local(*name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x12a89(%rip), %rax     # 0x19588
cmpl $0x0, 0x3008(%rax)
jne 0x6b0d
jmp 0x6bbc
leaq 0x12a94(%rip), %rax     # 0x195a8
addq $0x28, %rax
movq %rax, -0x8(%rbp)
movq 0x12a65(%rip), %rax     # 0x19588
movq 0x3000(%rax), %rax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x6b9a
movq 0x12a4b(%rip), %rax     # 0x19588
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
je 0x6b6e
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movq 0x12a24(%rip), %rcx     # 0x19588
cmpl 0x3008(%rcx), %eax
jge 0x6b6e
jmp 0x6b9a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x62f0
testb $0x1, %al
jne 0x6b81
jmp 0x6b8d
leaq 0x58eb(%rip), %rdi      # 0xc473
callq 0x57b0
jmp 0x6b8f
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6b30
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6bd0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: add_local
static Local* add_local(Token name) {
    if (current->local_count >= UINT8_COUNT) {
        error("Too many local variable in scope");
        return NULL;
    }

    Local* local = &current->locals[current->local_count++];
    local->name = name;
    local->depth = -1;
    local->initialized = false;
    local->allocated = false;
    local->reg = 0;

    return local;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x129a1(%rip), %rax     # 0x19588
cmpq $0x100, 0x3000(%rax) # imm = 0x100
jb 0x6c0a
leaq 0x589d(%rip), %rdi      # 0xc498
callq 0x57b0
movq $0x0, -0x8(%rbp)
jmp 0x6c75
movq -0x18(%rbp), %rsi
movq 0x12973(%rip), %rax     # 0x19588
movq 0x1296c(%rip), %rdx     # 0x19588
movq 0x3000(%rdx), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x3000(%rdx)
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %edx
callq 0x4110
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x2d(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x2e(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_stack_swap
static void emit_stack_swap(void) {
    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg1 = (uint8_t) ret;

    ret = alloc_register();

    if (ret < 0) {
        free_register(reg1);
        error_alloc_register();
        return;
    }

    uint8_t reg2 = (uint8_t) ret;

    emit_stack_pop(reg1);
    emit_stack_pop(reg2);
    emit_stack_push(reg1);
    emit_stack_push(reg2);

    free_register(reg1);
    free_register(reg2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5bc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6ccd
callq 0x5c30
jmp 0x6d2d
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
callq 0x5bc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6cf1
movzbl -0x5(%rbp), %edi
callq 0x5c50
callq 0x5c30
jmp 0x6d2d
movl -0x4(%rbp), %eax
movb %al, -0x6(%rbp)
movzbl -0x5(%rbp), %edi
callq 0x5cb0
movzbl -0x6(%rbp), %edi
callq 0x5cb0
movzbl -0x5(%rbp), %edi
callq 0x5b30
movzbl -0x6(%rbp), %edi
callq 0x5b30
movzbl -0x5(%rbp), %edi
callq 0x5c50
movzbl -0x6(%rbp), %edi
callq 0x5c50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: if_statement
static void if_statement(void) {
    consume(TOKEN_LEFT_PAREN, "Expected '(' after 'if'");
    expression();
    consume(TOKEN_RIGHT_PAREN, "Expect ')' after condition");

    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;
    size_t else_label = take_label();

    emit_stack_pop(reg);

    emit_conditional_jump_ri(OP_JMPI_EQ, reg, CONSTANT_FALSE, else_label);

    statement();

    if (match(TOKEN_ELSE)) {
        size_t else_end_label = take_label();

        emit_jump(else_end_label);

        set_label_here(else_label);

        statement();

        set_label_here(else_end_label);
    } else {
        set_label_here(else_label);
    }

    free_register(reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %edi, %edi
leaq 0x562e(%rip), %rsi      # 0xc52f
callq 0x57f0
callq 0x57e0
movl $0x1, %edi
leaq 0x5630(%rip), %rsi      # 0xc547
callq 0x57f0
callq 0x5bc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6f34
callq 0x5c30
jmp 0x6fb4
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
callq 0x5f80
movq %rax, -0x10(%rbp)
movzbl -0x5(%rbp), %edi
callq 0x5cb0
movb -0x5(%rbp), %al
movq -0x10(%rbp), %rcx
movl $0x2d, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x6080
callq 0x6420
movl $0x1e, %edi
callq 0x5710
testb $0x1, %al
jne 0x6f77
jmp 0x6fa2
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6010
movq -0x10(%rbp), %rdi
callq 0x6040
callq 0x6420
movq -0x18(%rbp), %rdi
callq 0x6040
jmp 0x6fab
movq -0x10(%rbp), %rdi
callq 0x6040
movzbl -0x5(%rbp), %edi
callq 0x5c50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: return_statement
static void return_statement(void) {
    if (match(TOKEN_SEMICOLON)) {
        emit_void_return();
    } else {
        expression();
        consume(TOKEN_SEMICOLON, "Expected ';' after return value");

        if (parser.current_function_label != entry_point_label) {
            emit_stack_swap();
        }

        emit_opcode(OP_RET);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x7, %edi
callq 0x5710
testb $0x1, %al
jne 0x6fd4
jmp 0x6fdb
callq 0x6a00
jmp 0x7010
callq 0x57e0
movl $0x7, %edi
leaq 0x5576(%rip), %rsi      # 0xc562
callq 0x57f0
movq 0x12758(%rip), %rax     # 0x19750
cmpq 0x12591(%rip), %rax     # 0x19590
je 0x7006
callq 0x6cb0
movl $0x1, %edi
callq 0x5ce0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: for_statement
static void for_statement(void) {
    begin_scope();

    consume(TOKEN_LEFT_PAREN, "Expected '(' after 'for'");

    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;
    
    if (match(TOKEN_SEMICOLON)) {
        // No initializer
    } else if (match(TOKEN_LET)) {
        let_declaration();
    } else {
        expression_statement();
    }

    size_t exit_label = take_label();
    size_t start_label = put_label_here();

    if (!match(TOKEN_SEMICOLON)) {
        expression();
        consume(TOKEN_SEMICOLON, "Expected ';' after condition");

        emit_stack_pop(reg);

        emit_conditional_jump_ri(OP_JMPI_NEQ, reg, CONSTANT_FALSE, exit_label);
    }

    if (!match(TOKEN_RIGHT_PAREN)) {
        size_t body_label = take_label();
        emit_jump(body_label);

        size_t orig_start_label = start_label;
        start_label = put_label_here();

        expression();
        emit_stack_pop(reg);
        consume(TOKEN_RIGHT_PAREN, "Expected ')' after for clauses");

        emit_jump(orig_start_label);

        set_label_here(body_label);
    }

    statement();

    emit_jump(start_label);

    set_label_here(exit_label);

    free_register(reg);

    end_scope();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x67a0
xorl %edi, %edi
leaq 0x554c(%rip), %rsi      # 0xc582
callq 0x57f0
callq 0x5bc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x7053
callq 0x5c30
jmp 0x7165
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
movl $0x7, %edi
callq 0x5710
testb $0x1, %al
jne 0x7069
jmp 0x706b
jmp 0x7089
movl $0x27, %edi
callq 0x5710
testb $0x1, %al
jne 0x707b
jmp 0x7082
callq 0x6370
jmp 0x7087
callq 0x7210
jmp 0x7089
callq 0x5f80
movq %rax, -0x10(%rbp)
callq 0x68e0
movq %rax, -0x18(%rbp)
movl $0x7, %edi
callq 0x5710
testb $0x1, %al
jne 0x70de
callq 0x57e0
movl $0x7, %edi
leaq 0x54e1(%rip), %rsi      # 0xc59b
callq 0x57f0
movzbl -0x5(%rbp), %edi
callq 0x5cb0
movb -0x5(%rbp), %al
movq -0x10(%rbp), %rcx
movl $0x2f, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x6080
movl $0x1, %edi
callq 0x5710
testb $0x1, %al
jne 0x7140
callq 0x5f80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6010
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x68e0
movq %rax, -0x18(%rbp)
callq 0x57e0
movzbl -0x5(%rbp), %edi
callq 0x5cb0
movl $0x1, %edi
leaq 0x548f(%rip), %rsi      # 0xc5b8
callq 0x57f0
movq -0x28(%rbp), %rdi
callq 0x6010
movq -0x20(%rbp), %rdi
callq 0x6040
callq 0x6420
movq -0x18(%rbp), %rdi
callq 0x6010
movq -0x10(%rbp), %rdi
callq 0x6040
movzbl -0x5(%rbp), %edi
callq 0x5c50
callq 0x6a30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: while_statement
static void while_statement(void) {
    size_t start_label = put_label_here();

    consume(TOKEN_LEFT_PAREN, "Expected '(' after 'while'");
    expression();
    consume(TOKEN_RIGHT_PAREN, "Expected ')' after condition");

    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;
    size_t exit_label = take_label();

    emit_stack_pop(reg);

    emit_conditional_jump_ri(OP_JMPI_EQ, reg, CONSTANT_FALSE, exit_label);

    statement();

    emit_jump(start_label);

    set_label_here(exit_label);

    free_register(reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x68e0
movq %rax, -0x8(%rbp)
xorl %edi, %edi
leaq 0x544d(%rip), %rsi      # 0xc5d7
callq 0x57f0
callq 0x57e0
movl $0x1, %edi
leaq 0x5452(%rip), %rsi      # 0xc5f2
callq 0x57f0
callq 0x5bc0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x71ba
callq 0x5c30
jmp 0x7208
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
callq 0x5f80
movq %rax, -0x18(%rbp)
movzbl -0xd(%rbp), %edi
callq 0x5cb0
movb -0xd(%rbp), %al
movq -0x18(%rbp), %rcx
movl $0x2d, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x6080
callq 0x6420
movq -0x8(%rbp), %rdi
callq 0x6010
movq -0x18(%rbp), %rdi
callq 0x6040
movzbl -0xd(%rbp), %edi
callq 0x5c50
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: expression_statement
static void expression_statement(void) {
    expression();
    consume(TOKEN_SEMICOLON, "Expected ';' after expression");

    int ret = alloc_register();
    if (ret < 0) {
        error_alloc_register();
    } else {
        uint8_t reg = (uint8_t) ret;
        emit_stack_pop(reg);

        free_register(reg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x57e0
movl $0x7, %edi
leaq 0x52e8(%rip), %rsi      # 0xc511
callq 0x57f0
callq 0x5bc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x7243
callq 0x5c30
jmp 0x725b
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %edi
callq 0x5cb0
movzbl -0x5(%rbp), %edi
callq 0x5c50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: emit_string
static void emit_string(uint16_t* str) {
    while (*str != 0) {
        uint16_t chr = *str;
        uint8_t b1 = (uint8_t) (chr >> 8);
        uint8_t b2 = (uint8_t) (chr & 0xff);
        chr = (uint16_t) ((b2 << 8) | b1);
        EMIT(uint16_t, chr);
        str++;
    }

    EMIT(uint16_t, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
je 0x72f5
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, -0xb(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, -0xc(%rbp)
movzbl -0xc(%rbp), %eax
shll $0x8, %eax
movzbl -0xb(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
movw %ax, -0x10(%rbp)
callq 0x5ea0
movq %rax, %rdi
leaq -0x10(%rbp), %rdx
movq 0x1230b(%rip), %rcx     # 0x195e8
movl $0x2, %esi
callq 0x4300
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x727c
jmp 0x72f7
movw $0x0, -0x12(%rbp)
movw -0x12(%rbp), %ax
movw %ax, -0x14(%rbp)
callq 0x5ea0
movq %rax, %rdi
leaq -0x14(%rbp), %rdx
movq 0x122d0(%rip), %rcx     # 0x195e8
movl $0x2, %esi
callq 0x4300
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/interpreter.c
// Function: main
int main(int argc, const char* argv[]) {
    init_vm();

    int ret = 0;

    if (argc == 1) {
        repl();
    } else {
        bool bytecode_input = false;

        for (int i = 1; i < argc; i++) {
            if (strcmp(argv[i], "--bytecode") == 0) {
                bytecode_input = true;
                break;
            }
        }

        const char* input_file = argv[argc - 1];

        InterpretResult result;
        if (bytecode_input) {
            result = run_bytecode_file(input_file);
        } else {
            result = run_source_file(input_file);
        }

        switch (result) {
            case INTERPRET_RUNTIME_ERROR:
                fprintf(stderr, "Runtime error\n");
                __attribute__((fallthrough));
            case INTERPRET_COMPILE_ERROR:
                fprintf(stderr, "Compile error\n");
                ret = 1;
                break;
            default:
                break;
        }
    }

    free_vm();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x9cd0
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x77f2
callq 0x78d0
jmp 0x78be
movb $0x0, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7835
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x4eea(%rip), %rsi      # 0xc702
callq 0x40e0
cmpl $0x0, %eax
jne 0x7828
movb $0x1, -0x15(%rbp)
jmp 0x7835
jmp 0x782a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x77fd
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x15(%rbp)
je 0x785e
movq -0x28(%rbp), %rdi
callq 0x7930
movl %eax, -0x2c(%rbp)
jmp 0x786a
movq -0x28(%rbp), %rdi
callq 0x7990
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x1, %eax
je 0x7899
jmp 0x7877
movl -0x30(%rbp), %eax
subl $0x2, %eax
jne 0x78ba
jmp 0x7881
movq 0x11768(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0x4e7b(%rip), %rsi      # 0xc70d
movb $0x0, %al
callq 0x40f0
movq 0x11750(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0x4e72(%rip), %rsi      # 0xc71c
movb $0x0, %al
callq 0x40f0
movl $0x1, -0x14(%rbp)
jmp 0x78bc
jmp 0x78bc
jmp 0x78be
callq 0x9d90
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/interpreter.c
// Function: repl
static void repl(void) {
    char* line = NULL;
    size_t buf_size = 0;

    while (true) {
        long line_len = getline(&line, &buf_size, stdin);

        if (line_len < 0) {
            printf("\n");
            break;
        }

        interpret_source(line);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x116e1(%rip), %rax     # 0x18fd0
movq (%rax), %rdx
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x791a
leaq 0x69ff(%rip), %rdi      # 0xe310
movb $0x0, %al
callq 0x4090
jmp 0x7925
movq -0x8(%rbp), %rdi
callq 0xb070
jmp 0x78e8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/interpreter.c
// Function: run_bytecode_file
static InterpretResult run_bytecode_file(const char* path) {
    uint8_t* file_buf = NULL;
    read_file(path, &file_buf, true);

    Chunk chunk;
    init_chunk(&chunk);
    chunk.code = file_buf;

    InterpretResult result = interpret_bytecode(&chunk);
    free(file_buf);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x4700
leaq -0x60(%rbp), %rdi
callq 0x4280
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9ea0
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4030
movl -0x64(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/interpreter.c
// Function: run_source_file
static InterpretResult run_source_file(const char* path) {
    uint8_t* file_buf = NULL;
    read_file(path, &file_buf, false);
    InterpretResult result = interpret_source((char*) file_buf);
    free(file_buf);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x4700
movq -0x10(%rbp), %rdi
callq 0xb070
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4030
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/memory.c
// Function: reallocate
void* reallocate(void* pointer, size_t old_size, size_t new_size) {
    (void) old_size;

    if (new_size == 0) {
        free(pointer);
        return NULL;
    }

    void* result = realloc(pointer, new_size);
    if (result == NULL) exit(1);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7a0e
movq -0x10(%rbp), %rdi
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0x7a38
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7a30
movl $0x1, %edi
callq 0x4160
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/object.c
// Function: hash_string
static uint32_t hash_string(const char* key, size_t length) {
    uint32_t hash = 2166136261u;

    for (size_t i = 0; i < length; i++) {
        hash ^= (unsigned char) key[i];
        hash *= 16777619;
    }

    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x811c9dc5, -0x14(%rbp) # imm = 0x811C9DC5
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7adf
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0x1000193, -0x14(%rbp), %eax # imm = 0x1000193
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7aab
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/object.c
// Function: allocate_string
static ObjString* allocate_string(char* chars, size_t length, uint32_t hash) {
    ObjString* string = ALLOCATE_OBJ(ObjString, OBJ_STRING);
    string->length = length;
    string->chars = chars;
    string->hash = hash;
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x20, %edi
xorl %esi, %esi
callq 0x7bb0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/object.c
// Function: copy_string
ObjString* copy_string(const char* chars, size_t length) {
    uint32_t hash = hash_string(chars, length);

    char* heap_chars = ALLOCATE(char, length + 1);
    memcpy(heap_chars, chars, length);
    heap_chars[length] = '\0';

    return allocate_string(heap_chars, length, hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7a90
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x79e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4110
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x7af0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/opcodes.c
// Function: get_opcode_definition
const OpcodeDefinition* get_opcode_definition(Opcode opcode) {
    for (size_t i = 0; i < NUM_OPCODES; i++) {
        if (opcodes[i].opcode == opcode) {
            return &opcodes[i];
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x1f9, -0x18(%rbp)     # imm = 0x1F9
jae 0x7c4b
movq -0x18(%rbp), %rcx
leaq 0x938c(%rip), %rax      # 0x10fa0
shlq $0x6, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x7c3b
movq -0x18(%rbp), %rcx
leaq 0x9372(%rip), %rax      # 0x10fa0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7c53
jmp 0x7c3d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7bff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/opcodes.c
// Function: get_opcode_definition_by_name
const OpcodeDefinition* get_opcode_definition_by_name(char* name) {
    for (size_t i = 0; i < NUM_OPCODES; i++) {
        if (strcmp(opcodes[i].name, name) == 0) {
            return &opcodes[i];
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x1f9, -0x18(%rbp)     # imm = 0x1F9
jae 0x7cca
movq -0x18(%rbp), %rcx
leaq 0x9317(%rip), %rax      # 0x10fa0
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40e0
cmpl $0x0, %eax
jne 0x7cba
movq -0x18(%rbp), %rcx
leaq 0x92f3(%rip), %rax      # 0x10fa0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7cd2
jmp 0x7cbc
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7c74
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/opcodes.c
// Function: get_opcode_arity
size_t get_opcode_arity(const OpcodeDefinition* opcode) {
    size_t arity = 0;

    for (size_t i = 0; i < OPCODE_MAX_ARITY; i++) {
        if (opcode->parameters[i] == T_NONE) {
            break;
        } else if (opcode->parameters[i] != T_ARGS && opcode->parameters[i] != T_IMED) {
            arity++;
        }
    }

    return arity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0xb, -0x18(%rbp)
jae 0x7d8c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpl $0x0, 0x10(%rax,%rcx,4)
jne 0x7d50
jmp 0x7d8c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpl $0x1, 0x10(%rax,%rcx,4)
je 0x7d7a
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpl $0x9, 0x10(%rax,%rcx,4)
je 0x7d7a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7d7c
jmp 0x7d7e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7d38
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/qst.c
// Function: create_bin
QstBin* create_bin(
    uint32_t quest_number,
    uint32_t language,
    char* quest_name,
    char* short_description,
    char* long_description) {

    QstBin* bin = calloc(1, sizeof(QstBin));

    bin->quest_number = quest_number;
    bin->language = language;

    copy_to_wide_string(bin->quest_name, quest_name, 32);
    copy_to_wide_string(bin->short_description, short_description, 128);
    copy_to_wide_string(bin->long_description, long_description, 288);

    return bin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x1, %edi
movl $0x1250, %esi           # imm = 0x1250
callq 0x40d0
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x8840
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
movl $0x80, %edx
callq 0x8840
movq -0x28(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x20(%rbp), %rsi
movl $0x120, %edx            # imm = 0x120
callq 0x8840
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/qst.c
// Function: copy_to_wide_string
static void copy_to_wide_string(uint16_t* dst, char* src, size_t len) {
    size_t n = 0;
    while (*src != '\0' && n < len) {
        dst[n * 2] = (uint16_t) *src;
        n++;
        src++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x8877
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8880
jmp 0x88b3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8858
popq %rbp
retq
nopw %cs:(%rax,%rax)