LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: compile
RavFunction *compile(VM *vm, const char *source, const char *file) {
    Lexer lexer;
    lexer_init(&lexer, source, file);

    Parser parser;
    init_parser(&parser, &lexer, vm);

    Context context;
    init_context(&context, &parser, FunctionToplevel);

    while (!consume_if(&parser, TOKEN_EOF)) {
        declaration(&parser);
    }

    RavFunction *function = end_context(&parser, true);
    return parser.had_error ? NULL : function;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x22b0, %rsp           # imm = 0x22B0
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x97e8
leaq 0x30(%rsp), %r12
movq %r14, -0x30(%r12)
movq $0x0, -0x28(%r12)
movq %rbx, -0x20(%r12)
movw $0x0, 0x18(%r12)
movq $-0x1, 0x1c(%r12)
leaq 0x18(%rsp), %rbx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x97fb
cmpl $0x35, 0x18(%rsp)
je 0x5dbd
movq %rsp, %r14
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdi
leaq 0x90(%rsp), %r15
movq %rax, (%r15)
movq %r15, 0x8(%r14)
movb $0x1, 0x10(%r15)
xorl %ebp, %ebp
movl %ebp, 0x2018(%r15)
movl %ebp, 0x221c(%r15)
callq 0x554a
movq %rax, 0x8(%r15)
movslq 0x2018(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2018(%r15)
shlq $0x5, %rax
movl %ebp, 0xc0(%rsp,%rax)
leaq 0x522c(%rip), %rcx      # 0xb057
movq %rcx, 0xb0(%rsp,%rax)
movl %ebp, 0xb8(%rsp,%rax)
movb $0x0, 0xc4(%rsp,%rax)
leaq 0x58(%rsp), %r15
movl 0x18(%rsp), %ebp
cmpl $0x36, %ebp
jne 0x5e8a
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r12)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x58(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpl $0x35, 0x18(%rsp)
je 0x5e61
cmpl $0x36, %ebp
je 0x5e94
movq %r14, %rdi
callq 0x5eca
jmp 0x5e47
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rbx
leaq 0x20(%rbx), %rdi
movl 0x44(%rsp), %edx
movl $0x35, %esi
callq 0x4d19
xorl %eax, %eax
cmpb $0x0, 0x48(%rsp)
cmoveq %rbx, %rax
addq $0x22b0, %rsp           # imm = 0x22B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: variable
static uint8_t variable(Parser *parser, const char *error) {
    consume(parser, TOKEN_IDENTIFIER, error);

    // global scope
    if (parser->context->scope_depth <= 0) {
        return identifier_constant(parser, &parser->previous);
    }

    // local scope
    Context *context = parser->context;
    Token *name = &parser->previous;

    // Check if the variable was already declared, since raven doesn't
    // support shadowing in local scopes.
    for (int i = context->local_count - 1; i >= 0; i--) {
        Local *local = &context->locals[i];

        if (local->depth == -1 || local->depth < context->scope_depth) {
            break; // Not previously declared in the current scope.
        }

        if (same_identifier(name, &local->name)) {
            error_previous(parser, "name is already declared");
        }
    }

    // Declare the local variable.
    add_local(parser, *name);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
cmpl $0x2f, 0x18(%rdi)
jne 0x62ef
movq 0x10(%r14), %rax
movq %rax, 0x40(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movq %rsp, %r15
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movups (%rsp), %xmm0
movups %xmm0, (%r14)
cmpl $0x35, 0x18(%rbx)
je 0x62cb
jmp 0x62fd
movq %rsi, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64ec
movq 0x8(%rbx), %r12
cmpl $0x0, 0x221c(%r12)
jle 0x63ba
leaq 0x30(%rbx), %r14
movslq 0x2018(%r12), %rax
testq %rax, %rax
jle 0x637f
leaq 0x1(%rax), %r13
shlq $0x5, %rax
leaq (%rax,%r12), %rbp
addq $0x10, %rbp
leaq 0x5455(%rip), %r15      # 0xb78d
movl (%rbp), %eax
cmpl $-0x1, %eax
je 0x637f
cmpl 0x221c(%r12), %eax
jl 0x637f
movslq 0x40(%rbx), %rdx
cmpl -0x8(%rbp), %edx
jne 0x6372
movq 0x38(%rbx), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
testl %eax, %eax
jne 0x6372
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x64ec
decq %r13
addq $-0x20, %rbp
cmpq $0x1, %r13
jg 0x6338
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq 0x8(%rbx), %rax
movslq 0x2018(%rax), %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x63ea
leaq 0x5423(%rip), %rsi      # 0xb7ce
movq %rbx, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x6518
jmp 0x6417
movq 0x10(%rbx), %rdi
movq 0x38(%rbx), %rsi
movl 0x40(%rbx), %edx
callq 0x52a0
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x4db9
jmp 0x6419
leal 0x1(%rcx), %edx
movl %edx, 0x2018(%rax)
shlq $0x5, %rcx
movq 0x10(%rsp), %rdx
movq %rdx, 0x28(%rax,%rcx)
movaps (%rsp), %xmm0
movups %xmm0, 0x18(%rax,%rcx)
movl $0xffffffff, 0x30(%rax,%rcx) # imm = 0xFFFFFFFF
movb $0x0, 0x34(%rax,%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: define_variable
static void define_variable(Parser *parser, uint8_t name_index) {
    // local scope
    if (parser->context->scope_depth > 0) {
        mark_initialized(parser->context);
        return;
    }

    // global scope
    emit_bytes(parser, OP_DEF_GLOBAL, name_index);
}

// Assembly:
movq 0x8(%rdi), %rax
movl 0x221c(%rax), %ecx
testl %ecx, %ecx
jle 0x6446
movslq 0x2018(%rax), %rdx
shlq $0x5, %rdx
movl %ecx, 0x10(%rdx,%rax)
retq
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r14), %edx
movl $0x16, %esi
callq 0x4d19
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r14), %edx
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: consume
static inline void consume(Parser *parser, TokenType type, const char *message) {
    if (parser->current.type == type) {
        advance(parser);
    } else {
        error_current(parser, message);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
cmpl %esi, 0x18(%rdi)
jne 0x64db
movq 0x10(%rbx), %rax
movq %rax, 0x40(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14)
leaq 0x8(%rsp), %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpl $0x35, 0x18(%r14)
je 0x64ae
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x64ec
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: parameters
static void parameters(Parser *parser, TokenType closing_token) {
    if (consume_if(parser, closing_token)) return;

    RavFunction *function = parser->context->function;
    do {
        function->arity++;

        if (function->arity > UINT8_MAX) {
            error_limit(parser, "parameters", 255);
        }

        uint8_t index = variable(parser, "expect parameter name");
        define_variable(parser, index);
    } while (consume_if(parser, TOKEN_COMMA));

    consume(parser, closing_token, "expect a closing pararmeters token");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movl 0x18(%rdi), %ebp
cmpl %esi, %ebp
jne 0x68cd
movq 0x10(%rbx), %rax
movq %rax, 0x40(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14)
leaq 0x10(%rsp), %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpl $0x35, 0x18(%r14)
je 0x68a1
cmpl %r12d, %ebp
je 0x69b7
movl %r12d, 0xc(%rsp)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rbp
leaq 0x30(%r14), %r15
leaq 0x10(%rsp), %r13
movl 0x18(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rbp)
cmpl $0xff, %eax
jl 0x6907
movq %r14, %rdi
leaq 0x4f40(%rip), %rsi      # 0xb83d
movl $0xff, %edx
callq 0x6518
movq %r14, %rdi
leaq 0x4f37(%rip), %rsi      # 0xb848
callq 0x629d
movzbl %al, %esi
movq %r14, %rdi
callq 0x6428
movl 0x18(%r14), %r12d
cmpl $0x25, %r12d
jne 0x6963
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r15)
movups (%rbx), %xmm0
movups %xmm0, (%r15)
movq (%r14), %rsi
movq %r13, %rdi
callq 0x97fb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpl $0x35, 0x18(%r14)
je 0x693a
cmpl $0x25, %r12d
je 0x68e3
movl 0xc(%rsp), %eax
cmpl %eax, (%rbx)
jne 0x69a5
movq 0x10(%rbx), %rax
movq %rax, 0x40(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14)
leaq 0x10(%rsp), %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpl $0x35, 0x18(%r14)
je 0x6980
jmp 0x69b7
leaq 0x4eb2(%rip), %rdx      # 0xb85e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64ec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: unwind_stack
static void unwind_stack(Parser *parser, int depth) {
    Context *context = parser->context;
    int local_count = 0;
    bool do_closing = false;

    for (int i = context->local_count - 1; i >= 0; i--) {
        if (context->locals[i].depth < depth) {
            break;
        }

        if (context->locals[i].is_captured) {
            emit_byte(parser, OP_CLOSE_UPVALUE);
            do_closing = true;
        } else {
            emit_byte(parser, OP_POP);
        }

        local_count++;
    }
    context->local_count -= local_count;

    // If no closing occurs, optimize the consecutive pop instructions.
    if (!do_closing && local_count != 0) {
        parser_chunk(parser)->count -= local_count;
        emit_bytes(parser, OP_POPN, (uint8_t)local_count);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movslq 0x2018(%rcx), %r13
testq %r13, %r13
jle 0x6a4c
movl %esi, %ebp
movq %r13, %rax
shlq $0x5, %rax
movq %rcx, (%rsp)
leaq (%rax,%rcx), %r15
addq $0x14, %r15
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpl %ebp, -0x4(%r15)
jl 0x6a46
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movzbl %r12b, %r12d
cmpb $0x0, (%r15)
movl $0x1, %eax
cmovnel %eax, %r12d
movl 0x44(%rbx), %edx
movl $0x7, %esi
movl $0x23, %eax
cmovnel %eax, %esi
callq 0x4d19
incl %r14d
addq $-0x20, %r15
cmpl %r14d, %r13d
jne 0x69ff
movl %r13d, %r14d
movq (%rsp), %rcx
jmp 0x6a52
xorl %r14d, %r14d
xorl %r12d, %r12d
subl %r14d, 0x2018(%rcx)
testb $0x1, %r12b
jne 0x6aa7
testl %r14d, %r14d
je 0x6aa7
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
subl %r14d, 0x20(%rdi)
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x8, %esi
callq 0x4d19
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %r14b, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: parse_precedence
static void parse_precedence(Parser *parser, Precedence precedence) {
    Debug_Logf(parser, "expression(%s)", precedence_string[precedence]);

    advance(parser);

    ParseFn prefix = token_rule(parser->previous.type)->prefix;
    if (prefix == NULL) {
        error_previous(parser, "Unexpected token, expect expression");
        return;
    }

    prefix(parser);
    while (precedence <= token_rule(parser->current.type)->precedence) {
        advance(parser);
        token_rule(parser->previous.type)->infix(parser);
    }

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq 0x28(%rdi), %rax
movq %rax, 0x40(%rdi)
movups 0x18(%rdi), %xmm0
movups %xmm0, 0x30(%rdi)
movq %rsp, %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r12)
movups (%rsp), %xmm0
movups %xmm0, (%r12)
cmpl $0x35, 0x18(%r14)
je 0x6ae4
movl (%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq 0x8d8a(%rip), %r13      # 0xf8a0
movq (%r13,%rax,8), %rax
testq %rax, %rax
je 0x6b8e
movq %r14, %rdi
callq *%rax
movl 0x18(%r14), %eax
leaq (%rax,%rax,2), %rax
cmpl %ebp, 0x10(%r13,%rax,8)
jb 0x6ba0
movq %rsp, %r15
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq (%r14), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r12)
movups (%rsp), %xmm0
movups %xmm0, (%r12)
cmpl $0x35, 0x18(%r14)
je 0x6b48
movl 0x30(%r14), %eax
leaq (%rax,%rax,2), %rax
movq %r14, %rdi
callq *0x8(%r13,%rax,8)
movl 0x18(%r14), %eax
leaq (%rax,%rax,2), %rax
cmpl %ebp, 0x10(%r13,%rax,8)
jae 0x6b37
jmp 0x6ba0
leaq 0x4d85(%rip), %rdx      # 0xb91a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64ec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: binary
static void binary(Parser *parser) {
    Debug_Log(parser);

    TokenType operator = parser->previous.type;

    ParseRule *rule = token_rule(operator);
    parse_precedence(parser, (Precedence)(rule->precedence + 1));

    switch (operator) {
    case TOKEN_PLUS:          emit_byte(parser, OP_ADD); break;
    case TOKEN_MINUS:         emit_byte(parser, OP_SUB); break;
    case TOKEN_STAR:          emit_byte(parser, OP_MUL); break;
    case TOKEN_SLASH:         emit_byte(parser, OP_DIV); break;
    case TOKEN_PERCENT:       emit_byte(parser, OP_MOD); break;
    case TOKEN_LESS:          emit_byte(parser, OP_LT);  break;
    case TOKEN_LESS_EQUAL:    emit_byte(parser, OP_LTQ); break;
    case TOKEN_GREATER:       emit_byte(parser, OP_GT);  break;
    case TOKEN_GREATER_EQUAL: emit_byte(parser, OP_GTQ); break;
    case TOKEN_EQUAL_EQUAL:   emit_byte(parser, OP_EQ);  break;
    case TOKEN_BANG_EQUAL:    emit_byte(parser, OP_NEQ); break;
    default:
        assert(!"invalid token type");
    }

    Debug_Exit(parser);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x30(%rdi), %r14d
leaq (%r14,%r14,2), %rax
leaq 0x8116(%rip), %rcx      # 0xf8a0
movl 0x10(%rcx,%rax,8), %esi
incl %esi
callq 0x6ab6
leal -0x10(%r14), %eax
cmpl $0x12, %eax
jae 0x77d0
movl $0x3781f, %ecx          # imm = 0x3781F
btl %eax, %ecx
jae 0x77d0
movl %eax, %eax
leaq 0x3fb3(%rip), %rcx      # 0xb764
movzbl (%rax,%rcx), %esi
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d19
leaq 0x43ac(%rip), %rdi      # 0xbb83
leaq 0x4050(%rip), %rsi      # 0xb82e
leaq 0x43b4(%rip), %rcx      # 0xbb99
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: unary
static void unary(Parser *parser) {
    Debug_Log(parser);

    TokenType operator = parser->previous.type;
    parse_precedence(parser, PREC_UNARY);

    switch (operator) {
    case TOKEN_MINUS: emit_byte(parser, OP_NEG); break;
    case TOKEN_NOT:   emit_byte(parser, OP_NOT); break;
    default:
        assert(!"invalid token type");
    }

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x30(%rdi), %ebp
movl $0xa, %esi
callq 0x6ab6
movb $0xe, %al
cmpl $0x11, %ebp
je 0x7810
cmpl $0x16, %ebp
jne 0x782d
movb $0x15, %al
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %al, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d19
leaq 0x434f(%rip), %rdi      # 0xbb83
leaq 0x3ff3(%rip), %rsi      # 0xb82e
leaq 0x436d(%rip), %rcx      # 0xbbaf
movl $0x5e0, %edx            # imm = 0x5E0
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: and_
static void and_(Parser *parser) {
    // Operator Flow:
    //
    // [Left Operand]
    // OP_JMP_FALSE   ---.
    // OP_POP            |
    // [Right Operand]   |
    // ....    <----------

    Debug_Log(parser);

    int jump = emit_jump(parser, OP_JMP_FALSE);

    emit_byte(parser, OP_POP);
    parse_precedence(parser, PREC_AND + 1);

    patch_jump(parser, jump);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0x20, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
movslq 0x20(%rdi), %rbp
addq $0x20, %rdi
addq $-0x2, %rbp
movl 0x44(%r15), %edx
movl $0x7, %esi
callq 0x4d19
movq %r15, %rdi
movl $0x4, %esi
callq 0x6ab6
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
movl 0x20(%r14), %ebx
subl %ebp, %ebx
cmpl $0x10002, %ebx          # imm = 0x10002
jl 0x78fc
leaq 0x18(%r15), %rsi
leaq 0x4085(%rip), %rdx      # 0xb979
movq %r15, %rdi
callq 0x64ec
addl $-0x2, %ebx
movq 0x28(%r14), %rax
movb %bh, (%rax,%rbp)
movq 0x28(%r14), %rax
movb %bl, 0x1(%rax,%rbp)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: or_
static void or_(Parser *parser) {
    // Operator Flow:
    //
    // [Left Operand]
    // OP_JMP_FALSE   ---.
    // OP_JMP         ---|--.
    // OP_POP  <----------  |
    // [Right Operand]      |
    // ....    <-------------

    Debug_Log(parser);

    // first operand is falsy
    int false_jump = emit_jump(parser, OP_JMP_FALSE);

    // first operand is not falsy
    int true_jump = emit_jump(parser, OP_JMP);

    patch_jump(parser, false_jump);

    emit_byte(parser, OP_POP);
    parse_precedence(parser, PREC_OR + 1);

    patch_jump(parser, true_jump);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0x20, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
movslq 0x20(%rdi), %rbp
addq $0x20, %rdi
addq $-0x2, %rbp
movl 0x44(%r15), %edx
movl $0x1e, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
movslq 0x20(%r14), %rbx
movq %rbx, %rax
addq $-0x2, %rax
movq %rax, %r12
subl %ebp, %ebx
cmpl $0x10002, %ebx          # imm = 0x10002
jl 0x79fb
leaq 0x18(%r15), %rsi
leaq 0x3f86(%rip), %rdx      # 0xb979
movq %r15, %rdi
callq 0x64ec
addl $-0x2, %ebx
movq 0x28(%r14), %rax
movb %bh, (%rax,%rbp)
movq 0x28(%r14), %rax
movb %bl, 0x1(%rax,%rbp)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r15), %edx
movl $0x7, %esi
callq 0x4d19
movq %r15, %rdi
movl $0x3, %esi
callq 0x6ab6
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
movl 0x20(%r14), %ebx
movq %r12, %rbp
subl %ebp, %ebx
cmpl $0x10002, %ebx          # imm = 0x10002
jl 0x7a60
leaq 0x18(%r15), %rsi
leaq 0x3f21(%rip), %rdx      # 0xb979
movq %r15, %rdi
callq 0x64ec
addl $-0x2, %ebx
movq 0x28(%r14), %rax
movb %bh, (%rax,%rbp)
movq 0x28(%r14), %rax
movb %bl, 0x1(%rax,%rbp)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: concat
static void concat(Parser *parser) {
    Debug_Log(parser);

    parse_precedence(parser, PREC_CONCAT + 1);
    emit_byte(parser, OP_CONCAT);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x8, %esi
callq 0x6ab6
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x24, %esi
popq %rbx
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: cons
static void cons(Parser *parser) {
    Debug_Log(parser);

    // Not PREC_CONS + 1, since cons is right associated operator.
    parse_precedence(parser, PREC_CONS);
    emit_byte(parser, OP_CONS);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x6, %esi
callq 0x6ab6
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x25, %esi
popq %rbx
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: assignment
static void assignment(Parser *parser) {
    Debug_Log(parser);

    Chunk *chunk = parser_chunk(parser);
    if (chunk->count < 2) {
        error_previous(parser, "invalid assignment target");
        return;
    }

    // Special case of indexing
    if (chunk->opcodes[chunk->count - 1] == OP_GET_ELEMENT) {
        chunk->count--;
        parse_precedence(parser, PREC_ASSIGNMENT);
        emit_byte(parser, OP_SET_ELEMENT);
        return;
    }

    // Check if the left hand side was an identifier, it's kind of a hack.
    // If it's an identifier, the last written opcode should be one of
    // these getters opcodes.
    uint8_t opcode = chunk->opcodes[chunk->count - 2];
    if (opcode != OP_GET_GLOBAL &&
        opcode != OP_GET_LOCAL &&
        opcode != OP_GET_UPVALUE) {
        error_previous(parser, "invalid assignment target");
        return;
    }

    // Get slot index of the variable and extract the corresponding
    // set instruction, and then discard the get instruction.
    uint8_t index = chunk->opcodes[chunk->count - 1];
    uint8_t set_op = opcode - 1;
    chunk->count -= 2;

    // Not PREC_ASSIGNMENT + 1, since assignment is right associated.
    parse_precedence(parser, PREC_ASSIGNMENT);
    emit_bytes(parser, set_op, index);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movslq 0x20(%rax), %rcx
cmpq $0x1, %rcx
jg 0x7afb
leaq 0x30(%rbx), %rsi
leaq 0x40d5(%rip), %rdx      # 0xbbc4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x64ec
movq 0x28(%rax), %rdx
movb -0x1(%rdx,%rcx), %bpl
cmpb $0x2b, %bpl
jne 0x7b32
decl %ecx
movl %ecx, 0x20(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6ab6
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x2a, %esi
jmp 0x7b89
addl $-0x2, %ecx
movzbl (%rdx,%rcx), %r14d
cmpl $0x1c, %r14d
ja 0x7ae4
movl $0x15000000, %edx       # imm = 0x15000000
btl %r14d, %edx
jae 0x7ae4
decb %r14b
movl %ecx, 0x20(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6ab6
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %r14b, %esi
callq 0x4d19
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %bpl, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: block
static void block(Parser *parser) {
    Debug_Log(parser);

    begin_scope(parser);

    while (!current_is(parser, TOKEN_END) && !current_is(parser, TOKEN_EOF)) {
        declaration(parser);
    }

    consume(parser, TOKEN_END, "expect closing 'end' after block");

    end_scope(parser, true);

    Debug_Exit(parser);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
incl 0x221c(%rax)
movl 0x18(%rbx), %eax
cmpl $0x23, %eax
je 0x7bd4
cmpl $0x36, %eax
je 0x7bbf
movq %rbx, %rdi
callq 0x5eca
jmp 0x7ba8
leaq 0x18(%rbx), %rsi
leaq 0x4014(%rip), %rdx      # 0xbbde
movq %rbx, %rdi
callq 0x64ec
jmp 0x7c10
leaq 0x18(%rbx), %r15
movq 0x28(%rbx), %rax
movq %rax, 0x40(%rbx)
movups 0x18(%rbx), %xmm0
movups %xmm0, 0x30(%rbx)
leaq 0x8(%rsp), %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x97fb
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r15)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%r15)
cmpl $0x35, 0x18(%rbx)
je 0x7bed
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8879
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: grouping
static void grouping(Parser *parser) {
    Debug_Log(parser);

    expression(parser);
    consume(parser, TOKEN_RIGHT_PAREN, "Expect closing ')' after group expression");

    Debug_Exit(parser);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x6ab6
leaq 0x18(%rbx), %r14
cmpl $0x29, 0x18(%rbx)
jne 0x7c9b
movq 0x10(%r14), %rax
movq %rax, 0x40(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x30(%rbx)
leaq 0x8(%rsp), %r15
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%r14)
cmpl $0x35, 0x18(%rbx)
je 0x7c6e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3f5d(%rip), %rdx      # 0xbbff
movq %rbx, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x64ec
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: indexing
static void indexing(Parser *parser) {
    Debug_Log(parser);

    expression(parser);
    consume(parser, TOKEN_RIGHT_BRACKET, "expect ']' after index");

    emit_byte(parser, OP_GET_ELEMENT);

    Debug_Exit(parser);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x6ab6
leaq 0x18(%rbx), %r14
cmpl $0x2d, 0x18(%rbx)
jne 0x8378
movq 0x10(%r14), %rax
movq %rax, 0x40(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x30(%rbx)
leaq 0x8(%rsp), %r15
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x97fb
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%r14)
cmpl $0x35, 0x18(%rbx)
je 0x8353
jmp 0x838a
leaq 0x3971(%rip), %rdx      # 0xbcf0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64ec
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x2b, %esi
callq 0x4d19
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: identifier
static void identifier(Parser *parser) {
    Debug_Log(parser);

    Token *name = &parser->previous;
    int index = resolve_local(parser->context, name);

    uint8_t get_op;

    // Local?
    if (index != -1) {
        get_op = OP_GET_LOCAL;
    } else {
        index = resolve_upvalue(parser, parser->context, name);

        // Upvalue?
        if (index != -1) {
            get_op = OP_GET_UPVALUE;
        } else {
            index = identifier_constant(parser, &parser->previous);
            get_op = OP_GET_GLOBAL;
        }
    }

    emit_bytes(parser, get_op, index);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %r15
movl 0x2018(%r15), %r12d
leaq 0x18(%r15), %r13
testl %r12d, %r12d
jle 0x8416
decq %r12
movl %r12d, %eax
shlq $0x5, %rax
movb $0x1, %r14b
cmpl $-0x1, 0x18(%r13,%rax)
je 0x840f
addq %r13, %rax
movslq 0x40(%rbx), %rdx
cmpl 0x10(%rax), %edx
jne 0x840f
movq 0x38(%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x2190
testl %eax, %eax
jne 0x840f
xorl %r14d, %r14d
movl %r12d, %ebp
testb %r14b, %r14b
jne 0x83d2
jmp 0x841b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movb $0x1a, %al
cmpl $-0x1, %ebp
jne 0x846e
movq %rbx, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
callq 0x967c
cmpl $-0x1, %eax
je 0x843c
movl %eax, %ebp
movb $0x1c, %al
jmp 0x846e
movq 0x10(%rbx), %rdi
movq 0x38(%rbx), %rsi
movl 0x40(%rbx), %edx
callq 0x52a0
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x4db9
movl %eax, %ebp
movb $0x18, %al
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %al, %esi
callq 0x4d19
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %bpl, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: number
static void number(Parser *parser) {
    Debug_Log(parser);

    Value value = Num_Value(strtod(parser->previous.lexeme, NULL));
    emit_constant(parser, value);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
xorl %esi, %esi
callq 0x2090
movq %xmm0, %rsi
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
callq 0x4db9
cmpl $0x100, %eax            # imm = 0x100
jl 0x8503
leaq 0x33cb(%rip), %rsi      # 0xb8ab
movq %rbx, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x6518
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x848(%rax)
xorl %ebp, %ebp
jmp 0x8505
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x3, %esi
callq 0x4d19
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %bpl, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: string
static void string(Parser *parser) {
    Debug_Log(parser);

    // +1 and -2 for the literal string quotes
    RavString *string = object_string(
        &parser->vm->allocator,
        parser->previous.lexeme + 1,
        parser->previous.length - 2
    );
    emit_constant(parser, Obj_Value(string));

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x38(%rbx), %rsi
incq %rsi
movl 0x40(%rbx), %edx
addl $-0x2, %edx
callq 0x52a0
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %rax, %rsi
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
callq 0x4db9
cmpl $0x100, %eax            # imm = 0x100
jl 0x85a7
leaq 0x3327(%rip), %rsi      # 0xb8ab
movq %rbx, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x6518
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x848(%rax)
xorl %ebp, %ebp
jmp 0x85a9
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movl $0x3, %esi
callq 0x4d19
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%rbx), %edx
movzbl %bpl, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: end_scope
static void end_scope(Parser *parser, bool loading) {
    unwind_stack(parser, parser->context->scope_depth);

    // Push the value of the last expression in the block.
    if (loading) {
        Chunk *chunk = parser_chunk(parser);

        // If possible optimize out OP_SAVE_X/OP_PUSH_X pattern.
        if (chunk->opcodes[chunk->count - 1] == OP_POP_X) {
            chunk->count--;
        } else {
            emit_byte(parser, OP_PUSH_X);
        }
    }
    parser->context->scope_depth--;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x221c(%rax), %esi
callq 0x69c6
testl %ebp, %ebp
je 0x88c2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
leaq 0x20(%rax), %rdi
movq 0x28(%rax), %rcx
movslq 0x20(%rax), %rax
cmpb $0x5, -0x1(%rcx,%rax)
jne 0x88b5
decl %eax
movl %eax, (%rdi)
jmp 0x88c2
movl 0x44(%rbx), %edx
movl $0x4, %esi
callq 0x4d19
movq 0x8(%rbx), %rax
decl 0x221c(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: pattern_fail_if_true
static void pattern_fail_if_true(Parser *parser, Pattern_Context *context, bool subvalue) {
    // count of the values that are needed to be poped from the stack if the
    // pattern failed, note that the match value is discarded only if it is
    // subvalue, toplevel `match` value shouldn't be discarded because it could
    // be used in subsequent patterns
    int values_count = context->bindings_count + (int)subvalue;

    // Skip the failure handling, if the pattern matched the value.
    int success_jump = emit_jump(parser, OP_JMP_POP_FALSE);                 // ---- false
                                                                            //    |
    // Unwind the binding introduced by the failed pattern.                 //    |
    emit_bytes(parser, OP_POPN, (uint8_t)(values_count));                   //    |
                                                                            //    |
    // Finally jump to the next case, as the pattern didn't match.          //    |
    context->cases_next[context->cases_count] = emit_jump(parser, OP_JMP);  // -------
    context->cases_count += 1;                                              //    |  |
                                                                            //    |  :
    patch_jump(parser, success_jump);                                       // <---  V
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
addl 0x84(%rsi), %r15d
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movl $0x21, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
movslq 0x20(%rdi), %rbp
addq $0x20, %rdi
addq $-0x2, %rbp
movl 0x44(%r12), %edx
movl $0x8, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movzbl %r15b, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movl $0x1e, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movl 0x44(%r12), %edx
movl $0xff, %esi
callq 0x4d19
movq 0x8(%r12), %rax
movq 0x8(%rax), %r15
movl 0x20(%r15), %eax
addl $-0x2, %eax
movslq 0x80(%r14), %rcx
movl %eax, (%r14,%rcx,4)
incl 0x80(%r14)
movl 0x20(%r15), %ebx
subl %ebp, %ebx
cmpl $0x10002, %ebx          # imm = 0x10002
jl 0x958d
leaq 0x18(%r12), %rsi
leaq 0x23f4(%rip), %rdx      # 0xb979
movq %r12, %rdi
callq 0x64ec
addl $-0x2, %ebx
movq 0x28(%r15), %rax
movb %bh, (%rax,%rbp)
movq 0x28(%r15), %rax
movb %bl, 0x1(%rax,%rbp)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: add_dummy_local
static void add_dummy_local(Parser* parser) {
    Context *context = parser->context;

    if (context->local_count == LOCALS_LIMIT) {
        error_limit(parser, "function locals", LOCALS_LIMIT);
        return;
    }

    Local *local = &context->locals[context->local_count++];
    local->name = (Token){0};
    local->depth = context->scope_depth;
    local->is_captured = false;
}

// Assembly:
movq 0x8(%rdi), %rax
movslq 0x2018(%rax), %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x95cd
leaq 0x220b(%rip), %rsi      # 0xb7ce
movl $0x100, %edx            # imm = 0x100
jmp 0x6518
leal 0x1(%rcx), %edx
movl %edx, 0x2018(%rax)
shlq $0x5, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax,%rcx)
movq $0x0, 0x28(%rax,%rcx)
movl 0x221c(%rax), %edx
movl %edx, 0x30(%rax,%rcx)
movb $0x0, 0x34(%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: resolve_upvalue
static int resolve_upvalue(Parser *parser, Context *context, Token *name) {
    if (context->enclosing == NULL) {
        return -1;
    }

    int local = resolve_local(context->enclosing, name);
    if (local != -1) {
        context->enclosing->locals[local].is_captured = true;
        return add_upvalue(parser, context, (uint8_t)local, true);
    }

    int upvalue = resolve_upvalue(parser, context->enclosing, name);
    if (upvalue != -1) {
        return add_upvalue(parser, context, (uint8_t)upvalue, false);
    }

    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r12
testq %r12, %r12
je 0x9750
movq %rdx, %r15
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl 0x2018(%r12), %r14d
leaq 0x18(%r12), %r13
testl %r14d, %r14d
jle 0x96f1
decq %r14
movl %r14d, %eax
shlq $0x5, %rax
movb $0x1, %bl
cmpl $-0x1, 0x18(%r13,%rax)
je 0x96eb
addq %r13, %rax
movslq 0x10(%r15), %rdx
cmpl 0x10(%rax), %edx
jne 0x96eb
movq 0x8(%r15), %rdi
movq 0x8(%rax), %rsi
callq 0x2190
testl %eax, %eax
jne 0x96eb
xorl %ebx, %ebx
movl %r14d, %ebp
testb %bl, %bl
jne 0x96b0
jmp 0x96f6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebp
je 0x9715
movl %ebp, %eax
shlq $0x5, %rax
movb $0x1, 0x1c(%r13,%rax)
movl %ebp, %eax
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rbx
jmp 0x9732
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x967c
cmpl $-0x1, %eax
movq 0x10(%rsp), %rsi
je 0x9750
xorl %ecx, %ecx
cmpl $-0x1, %ebp
setne %cl
movzbl %al, %edx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9764
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/compiler.c
// Function: add_upvalue
static int add_upvalue(Parser *parser, Context *context, uint8_t index, bool is_local) {
    int upvalue_count = context->function->upvalue_count;

    // Check first if the upvalue is already captured.
    for (int i = 0; i < upvalue_count; i++) {
        Upvalue *upvalue = &context->upvalues[i];

        if (upvalue->index == index && upvalue->is_local == is_local) {
            return i;
        }
    }

    if (upvalue_count == UPVALUES_LIMIT) {
        error_limit(parser, "captured variables", UPVALUES_LIMIT);
        return 0;
    }

    context->upvalues[upvalue_count].is_local = is_local;
    context->upvalues[upvalue_count].index = index;

    return context->function->upvalue_count++;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %r8
movslq 0x1c(%r8), %r9
testq %r9, %r9
setg %r10b
jle 0x97a6
xorl %r11d, %r11d
movb $0x1, %bl
cmpb %dl, 0x201d(%rsi,%r11,2)
jne 0x9794
cmpb %cl, 0x201c(%rsi,%r11,2)
jne 0x9794
xorl %ebx, %ebx
movl %r11d, %eax
testb %bl, %bl
je 0x97a6
incq %r11
cmpq %r9, %r11
setb %r10b
jne 0x9779
jmp 0x97a6
testb $0x1, %r10b
jne 0x97e5
cmpl $0x100, %r9d            # imm = 0x100
jne 0x97ca
leaq 0x254b(%rip), %rsi      # 0xbd07
movl $0x100, %edx            # imm = 0x100
callq 0x6518
xorl %eax, %eax
jmp 0x97e5
movb %cl, 0x201c(%rsi,%r9,2)
movb %dl, 0x201d(%rsi,%r9,2)
leal 0x1(%r9), %eax
movl %eax, 0x1c(%r8)
movl %r9d, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/lexer.c
// Function: lexer_init
void lexer_init(Lexer *lexer, const char *source, const char *file) {
    lexer->file = file;
    lexer->start = source;
    lexer->current = source;
    lexer->line = 1;
}

// Assembly:
movq %rdx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/lexer.c
// Function: string_interpolated
static Token string_interpolated(Lexer *lexer) {
    //
    // "interpolated {{exp_1}} string {{exp_2}} example"
    //
    // This is scanned into three string tokens (besides expressions tokens):
    //   1. "interpolated {{ -> STRING_BEGIN
    //   2. }} string {{     -> STRING_PART
    //   3. }} example"      -> STRING_END
    //
    // "double quoted string example"
    //
    // This is scanned into one string token:
    //   1. "double quoted string example" -> STRING
    //

    TokenType token_type;
    char begin = *lexer->start;

    while (!at_end(lexer)) {
        char current = peek(lexer);

        // full string or string-end
        if (current == '"') {
            advance(lexer); // consume double quote

            if (begin == '"')
                token_type = TOKEN_STRING;
            else
                token_type = TOKEN_STRING_END;
            break;
        }

        // string part or string-begin
        if (current == '{' && peek_next(lexer) == '{') {
            advance(lexer);
            advance(lexer); // consume '{{'

            if (begin == '"')
                token_type = TOKEN_STRING_BEGIN;
            else
                token_type = TOKEN_STRING_PART;
            break;
        }

        advance(lexer);
    }

    if (at_end(lexer)) {
        return error_token(lexer, "Unterminated string");
    }
    return new_token(lexer, token_type);
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rdx
xorl %edi, %edi
xorl %ecx, %ecx
cmpb $0x22, (%rsi)
setne %dil
sete %cl
xorl $0x33, %ecx
leal (%rdi,%rdi,2), %edi
addl $0x31, %edi
movzbl (%rdx), %r10d
movl $0x1, %r9d
cmpl $0x22, %r10d
je 0x9bd1
cmpl $0x7b, %r10d
je 0x9baa
testl %r10d, %r10d
jne 0x9bcc
jmp 0x9be9
cmpb $0x7b, 0x1(%rdx)
jne 0x9bcc
leaq 0x1(%rdx), %r11
movq %r11, 0x10(%rax)
movl $0x2, %r9d
xorl %r10d, %r10d
cmpb $0x0, 0x1(%rdx)
movl %ecx, %r8d
jne 0x9bd7
jmp 0x9be1
movb $0x1, %r10b
jmp 0x9bd7
xorl %r10d, %r10d
movl %edi, %r8d
addq %r9, %rdx
movq %rdx, 0x10(%rax)
movq %rdx, %r11
movq %r11, %rdx
testb %r10b, %r10b
jne 0x9b8d
movq 0x10(%rax), %rcx
cmpb $0x0, (%rcx)
je 0x9c09
movl %r8d, (%rbx)
movl 0x18(%rax), %eax
movl %eax, 0x14(%rbx)
movq %rsi, 0x8(%rbx)
subl %esi, %ecx
movl %ecx, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
movq %rbx, %rdx
callq 0x25cc
xorl %ecx, %ecx
jmp 0x9c01
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/debug.c
// Function: const_instruction
static int const_instruction(const char *tag, Chunk *chunk, int offset) {
    uint8_t constant_index = chunk->opcodes[offset + 1];
    printf("%-16s %4x = ", tag, constant_index);
    value_print(chunk->constants[constant_index]);
    printf("\n");
    return offset + 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x8(%rbx), %rax
movslq %edx, %r14
movzbl 0x1(%rax,%r14), %r15d
leaq 0x1aca(%rip), %rdi      # 0xc14c
movl %r15d, %edx
xorl %eax, %eax
callq 0x20b0
movq 0x20(%rbx,%r15,8), %rdi
callq 0x5cd4
movl $0xa, %edi
callq 0x2040
addl $0x2, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/debug.c
// Function: jump_instruction
static int jump_instruction(const char *tag, Chunk *chunk, int sign, int offset) {
    uint16_t jump = (uint16_t)(
        chunk->opcodes[offset + 1] << 8 |
        chunk->opcodes[offset + 2]
    );

    printf("%-16s %4d -> %d\n", tag, offset, offset + 3 + sign * jump);
    return offset + 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq 0x8(%rsi), %rsi
movslq %ecx, %r8
movzwl 0x1(%rsi,%r8), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leal 0x3(%r8), %ebx
imull %edx, %ecx
addl %r8d, %ecx
addl $0x3, %ecx
leaq 0x1a8b(%rip), %rdi      # 0xc164
movq %rax, %rsi
movl %r8d, %edx
xorl %eax, %eax
callq 0x20b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/debug.c
// Function: closure_instruction
static int closure_instruction(Chunk *chunk, int offset) {
    offset++;
    uint8_t index = chunk->opcodes[offset++];
    Value value = chunk->constants[index];

    printf("%-16s %4d ", "CLOSURE", index);
    value_print(value);
    putchar('\n');

    RavFunction *function = As_Function(value);
    for (int i = 0; i < function->upvalue_count; i++) {
        uint8_t is_local = chunk->opcodes[offset++];
        uint8_t index = chunk->opcodes[offset++];
        printf("%04d     |                     %s %d\n",
               offset - 2, is_local ? "local" : "upvalue", index);
    }

    return offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movslq %esi, %r15
movzbl 0x1(%rax,%r15), %edx
movq 0x20(%rdi,%rdx,8), %r12
leaq 0x1a62(%rip), %rdi      # 0xc175
leaq 0x1a66(%rip), %rsi      # 0xc180
xorl %eax, %eax
callq 0x20b0
movq %r12, %rdi
callq 0x5cd4
movl $0xa, %edi
callq 0x2040
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r12, %r13
addl $0x2, %r15d
cmpl $0x0, 0x1c(%r13)
jle 0xa799
movslq %r15d, %r12
leaq 0x1a33(%rip), %r15      # 0xc188
xorl %ebp, %ebp
movq 0x8(%r14), %rax
leaq (%rax,%r12), %rcx
cmpb $0x0, (%rcx,%rbp,2)
leaq 0x1a4a(%rip), %rdx      # 0xc1b4
je 0xa773
leaq 0x1a3b(%rip), %rdx      # 0xc1ae
movslq %ebx, %rbx
movzbl 0x3(%rax,%rbx), %ecx
addl $0x2, %ebx
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x20b0
incq %rbp
cmpl 0x1c(%r13), %ebp
jl 0xa757
addl $0x2, %ebx
movl %ebx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/mem.c
// Function: allocator_free
void allocator_free(Allocator *allocator) {
    table_free(&allocator->strings);
    free(allocator->gray_stack);

    Object *objects = allocator->objects;
    while (objects) {
        Object *next = objects->next;
        free_object(allocator, objects);
        objects = next;
    }

    allocator_init(allocator);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4e3e
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xa839
movq 0x8(%rsi), %r15
movq %rbx, %rdi
callq 0xa863
movq %r15, %rsi
testq %r15, %r15
jne 0xa825
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x100000, 0x38(%rbx)   # imm = 0x100000
movb $0x0, 0x40(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4e28
// File: /workspace/github_c_makefile_star2_O1/mahrr[P]raven/src/mem.c
// Function: allocate
void *allocate(Allocator *allocator, void *previous, size_t old_size, size_t new_size) {
    allocator->bytes_allocated += new_size - old_size;

    if (!allocator->gc_off && new_size > old_size) {
#ifdef DEBUG_STRESS_GC
        allocator_gc(allocator);
#else
        if (allocator->bytes_allocated >= allocator->next_gc) {
            allocator_gc(allocator);
        }
#endif
    }

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

    return realloc(previous, new_size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rcx, %rax
subq %rdx, %rax
addq 0x30(%rdi), %rax
movq %rax, 0x30(%rdi)
cmpq %rdx, %rcx
jbe 0xa94a
cmpb $0x0, 0x40(%rdi)
jne 0xa94a
cmpq 0x38(%rdi), %rax
jb 0xa94a
callq 0xa970
movq %r14, %rdi
testq %rbx, %rbx
je 0xa961
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
callq 0x2030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq