LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x221c(%rax), %esi
callq 0x99e0
testb $0x1, -0x9(%rbp)
je 0xad98
movq -0x8(%rbp), %rdi
callq 0x9560
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x5, %eax
jne 0xad88
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xad96
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x9000
jmp 0xad98
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x221c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x221c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x21, %esi
callq 0xab90
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl $0x8, %esi
movzbl %al, %edx
callq 0x9620
movq -0x8(%rbp), %rdi
movl $0x1e, %esi
callq 0xab90
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x80(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xabe0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x100, 0x2018(%rax)    # imm = 0x100
jne 0xb53f
movq -0x8(%rbp), %rdi
leaq 0x3361(%rip), %rsi      # 0xe894
movl $0x100, %edx            # imm = 0x100
callq 0x9580
jmp 0xb5b6
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq -0x10(%rbp), %rdx
movl 0x2018(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2018(%rdx)
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2100
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x221c(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: loop_block
static void loop_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 loop block");

    end_scope(parser, false);

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x8e40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0xb662
movq -0x8(%rbp), %rdi
movl $0x36, %esi
callq 0x8e40
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xb66b
jmp 0xb676
movq -0x8(%rbp), %rdi
callq 0x8ca0
jmp 0xb635
movq -0x8(%rbp), %rdi
movl $0x23, %esi
leaq 0x35dc(%rip), %rdx      # 0xec62
callq 0x9240
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xad20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: arguments
static uint8_t arguments(Parser *parser) {
    if (consume_if(parser, TOKEN_RIGHT_PAREN)) return 0;

    int count = 0;
    do {
        expression(parser);

        if (count == PARAMS_LIMIT) {
            error_limit(parser, "function arguments", PARAMS_LIMIT);
            break;
        }

        count++;
    } while (consume_if(parser, TOKEN_COMMA));

    consume(parser, TOKEN_RIGHT_PAREN, "expect ')' after arguments");
    return (uint8_t)count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x8c60
testb $0x1, %al
jne 0xb6c0
jmp 0xb6c6
movb $0x0, -0x1(%rbp)
jmp 0xb72c
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8fe0
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jne 0xb6f6
movq -0x10(%rbp), %rdi
leaq 0x3644(%rip), %rsi      # 0xed2e
movl $0x100, %edx            # imm = 0x100
callq 0x9580
jmp 0xb711
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x25, %esi
callq 0x8c60
testb $0x1, %al
jne 0xb6cd
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x3620(%rip), %rdx      # 0xed41
callq 0x9240
movl -0x14(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: resolve_local
static inline int resolve_local(Context *context, Token *name) {
    for (int i = context->local_count - 1; i >= 0; i--) {
        Local *local = &context->locals[i];

        // Find an initialized local variable with this name.
        // The "local->depth != -1" test skips the edge case:
        //   let x = x;
        // But in the same time, allow same name shadowing:
        //   do
        //     let x = 1;
        //     do
        //       let x = x + x; // x -> 2
        //       ...
        //     end
        //     ...
        //   end
        if (local->depth != -1 && same_identifier(name, &local->name)) {
            return i;
        }
    }

    // Not Found
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x2018(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xb7af
movq -0x10(%rbp), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
je 0xb7a2
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x92e0
testb $0x1, %al
jne 0xb79a
jmp 0xb7a2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb7b6
jmp 0xb7a4
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb760
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb7ea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb878
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xb740
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0xb83a
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
movl $0x1, %ecx
movzbl %al, %edx
callq 0xb890
movl %eax, -0x4(%rbp)
jmp 0xb878
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xb7c0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
je 0xb871
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x28(%rbp), %eax
xorl %ecx, %ecx
movzbl %al, %edx
callq 0xb890
movl %eax, -0x4(%rbp)
jmp 0xb878
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xb91e
movq -0x18(%rbp), %rax
addq $0x201c, %rax           # imm = 0x201C
movslq -0x24(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0xb911
movq -0x30(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb911
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb982
jmp 0xb913
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb8c1
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jne 0xb945
movq -0x10(%rbp), %rdi
leaq 0x34da(%rip), %rsi      # 0xee0c
movl $0x100, %edx            # imm = 0x100
callq 0x9580
movl $0x0, -0x4(%rbp)
jmp 0xb982
movb -0x1a(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
andb $0x1, %dl
movb %dl, 0x201c(%rax,%rcx,2)
movb -0x19(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, 0x201d(%rax,%rcx,2)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl 0x1c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: skip_whitespace
static void skip_whitespace(Lexer *lexer) {
    for (;;) {
        switch (peek(lexer)) {
        case ' ':
        case '\t':
        case '\r':
            advance(lexer);
            break;

        case '\n':
            lexer->line++;
            advance(lexer);
            break;

        case '#':
            while (!at_end(lexer) && peek(lexer) != '\n') advance(lexer);
            break;

        default:
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc560
movsbl %al, %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x1a, %eax
ja 0xbeaf
movq -0x10(%rbp), %rax
leaq 0x3173(%rip), %rcx      # 0xefb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0xbf30
jmp 0xbeb5
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xbf30
jmp 0xbeb5
jmp 0xbe6f
movq -0x8(%rbp), %rdi
callq 0xbec0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xbe99
movq -0x8(%rbp), %rdi
callq 0xc560
movsbl %al, %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xbea2
jmp 0xbead
movq -0x8(%rbp), %rdi
callq 0xbf30
jmp 0xbe6f
jmp 0xbeb5
addq $0x20, %rsp
popq %rbp
retq
jmp 0xbe1c
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: new_token
static inline Token new_token(Lexer *lexer, TokenType type) {
    Token token;
    token.type = type;
    token.line = lexer->line;
    token.lexeme = lexer->start;
    token.length = lexer->current - lexer->start;

    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x14(%rdi)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
movl %ecx, 0x10(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: match
static inline bool match(Lexer *lexer, char expected) {
    if (!at_end(lexer) && peek(lexer) == expected) {
        lexer->current++;
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbec0
testb $0x1, %al
jne 0xbfc9
movq -0x10(%rbp), %rdi
callq 0xc560
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xbfc9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xbfcd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbec0
xorb $-0x1, %al
testb $0x1, %al
jne 0xc015
jmp 0xc0a3
movq -0x8(%rbp), %rdi
callq 0xc560
movb %al, -0xe(%rbp)
movsbl -0xe(%rbp), %eax
cmpl $0x22, %eax
jne 0xc04e
movq -0x8(%rbp), %rdi
callq 0xbf30
movsbl -0xd(%rbp), %eax
cmpl $0x22, %eax
jne 0xc045
movl $0x31, -0xc(%rbp)
jmp 0xc04c
movl $0x34, -0xc(%rbp)
jmp 0xc0a3
movsbl -0xe(%rbp), %eax
cmpl $0x7b, %eax
jne 0xc095
movq -0x8(%rbp), %rdi
callq 0xc580
movsbl %al, %eax
cmpl $0x7b, %eax
jne 0xc095
movq -0x8(%rbp), %rdi
callq 0xbf30
movq -0x8(%rbp), %rdi
callq 0xbf30
movsbl -0xd(%rbp), %eax
cmpl $0x22, %eax
jne 0xc08c
movl $0x32, -0xc(%rbp)
jmp 0xc093
movl $0x33, -0xc(%rbp)
jmp 0xc0a3
movq -0x8(%rbp), %rdi
callq 0xbf30
jmp 0xc001
movq -0x8(%rbp), %rdi
callq 0xbec0
testb $0x1, %al
jne 0xc0b2
jmp 0xc0c8
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x2fcd(%rip), %rdx      # 0xf08e
callq 0xc4e0
jmp 0xc0d8
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0xbee0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: string
static Token string(Lexer *lexer) {
    while (!at_end(lexer) && peek(lexer) != '\'') {
        advance(lexer);
    }

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

    advance(lexer); // closing quote
    return new_token(lexer, TOKEN_STRING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbec0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xc12e
movq -0x8(%rbp), %rdi
callq 0xc560
movsbl %al, %eax
cmpl $0x27, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xc137
jmp 0xc142
movq -0x8(%rbp), %rdi
callq 0xbf30
jmp 0xc104
movq -0x8(%rbp), %rdi
callq 0xbec0
testb $0x1, %al
jne 0xc151
jmp 0xc167
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x2f2e(%rip), %rdx      # 0xf08e
callq 0xc4e0
jmp 0xc182
movq -0x8(%rbp), %rdi
callq 0xbf30
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x31, %edx
callq 0xbee0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: identifier
static Token identifier(Lexer *lexer) {
    while (!at_end(lexer) && (isalnum(peek(lexer)) || peek(lexer) == '_')) {
        advance(lexer);
    }

    TokenType type = identifier_type(lexer);
    return new_token(lexer, type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbec0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xc206
callq 0x2210
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc560
movb %al, %cl
movq -0x30(%rbp), %rax
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
jne 0xc200
movq -0x8(%rbp), %rdi
callq 0xc560
movsbl %al, %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xc20f
jmp 0xc21a
movq -0x8(%rbp), %rdi
callq 0xbf30
jmp 0xc1a4
movq -0x8(%rbp), %rdi
callq 0xc5c0
movq -0x20(%rbp), %rdi
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0xbee0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: error_token
static Token error_token(Lexer *lexer, const char *message) {
    fprintf(stderr, "[%s: %d] SyntaxError at '%.1s': %s\n", lexer->file, lexer->line, lexer->start, message);

    Token token;
    token.type = TOKEN_ERROR;
    token.line = lexer->line;
    token.lexeme = NULL;
    token.length = 0;

    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq 0x6af9(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x10(%rbp), %r9
leaq 0x2b9b(%rip), %rsi      # 0xf0be
movb $0x0, %al
callq 0x2150
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x35, (%rdi)
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x14(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/lexer.c
// Function: is_keyword
static TokenType is_keyword(Lexer *lexer, int start, int length, const char *rest, TokenType type) {
    if (lexer->current - lexer->start == start + length &&
        memcmp(lexer->start + start, rest, length) == 0) {
        return type;
    }

    return TOKEN_IDENTIFIER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0xcb64
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x2120
cmpl $0x0, %eax
jne 0xcb64
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcb6b
movl $0x2f, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rsi
movzbl -0x15(%rbp), %edx
leaq 0x21d3(%rip), %rdi      # 0xf3bc
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movzbl -0x15(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rdi
callq 0x88b0
leaq 0xe4d(%rip), %rdi       # 0xe056
movb $0x0, %al
callq 0x20b0
movl -0x14(%rbp), %eax
addl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0x18(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x18(%rbp), %ecx
addl $0x3, %ecx
movl -0x14(%rbp), %eax
movzwl -0x1a(%rbp), %edi
imull %edi, %eax
addl %eax, %ecx
leaq 0x20fb(%rip), %rdi      # 0xf3d4
movb $0x0, %al
callq 0x20b0
movl -0x18(%rbp), %eax
addl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movzbl -0xd(%rbp), %edx
leaq 0x20a5(%rip), %rdi      # 0xf3e5
leaq 0x20a9(%rip), %rsi      # 0xf3f0
movb $0x0, %al
callq 0x20b0
movq -0x18(%rbp), %rdi
callq 0x88b0
movl $0xa, %edi
callq 0x2040
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0xd3fa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x26(%rbp)
movl -0xc(%rbp), %esi
subl $0x2, %esi
movzbl -0x25(%rbp), %ecx
leaq 0x2055(%rip), %rdx      # 0xf424
leaq 0x2048(%rip), %rax      # 0xf41e
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movzbl -0x26(%rbp), %ecx
leaq 0x2010(%rip), %rdi      # 0xf3f8
movb $0x0, %al
callq 0x20b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd37a
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/debug.c
// Function: short_instruction
static int short_instruction(const char *tag, Chunk *chunk, int offset) {
    uint16_t count = (uint16_t)(
        chunk->opcodes[offset + 1] << 8 |
        chunk->opcodes[offset + 2]
    );

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0x14(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rsi
movzwl -0x16(%rbp), %edx
leaq 0x1f64(%rip), %rdi      # 0xf3c9
movb $0x0, %al
callq 0x20b0
movl -0x14(%rbp), %eax
addl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/mem.c
// Function: allocator_init
void allocator_init(Allocator *allocator) {
    allocator->objects = NULL;
    allocator->gray_stack = NULL;
    allocator->gray_count = 0;
    allocator->gray_capacity = 0;
    allocator->bytes_allocated = 0;
    allocator->next_gc = GC_INITIAL_NEXT;
    allocator->gc_off = false;
    table_init(&allocator->strings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x100000, 0x38(%rax)   # imm = 0x100000
movq -0x8(%rbp), %rax
movb $0x0, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x7260
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7290
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd5a8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd5c0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xd57e
movq -0x8(%rbp), %rdi
callq 0xd4e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x40(%rax)
jne 0xd7fd
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xd7fd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jb 0xd7fb
movq -0x10(%rbp), %rdi
callq 0xd840
jmp 0xd7fd
cmpq $0x0, -0x28(%rbp)
jne 0xd817
movq -0x18(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
jmp 0xd828
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x21b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/mem.c
// Function: mark_roots
void mark_roots(Allocator *allocator) {
    VM *vm = (VM *)allocator;

    // Locals and Temporaries
    for (Value *slot = vm->stack; slot < vm->stack_top; slot++) {
        mark_value(allocator, *slot);
    }

    // Call Stack
    for (int i = 0; i < vm->frame_count; i++) {
        mark_object(allocator, (Object *)vm->frames[i].closure);
    }

    // Globals
    for (int i = 0; i <= vm->globals.hash_mask; i++) {
        Entry *entry = &vm->globals.entries[i];

        if (entry->key != NULL) {
            mark_object(allocator, (Object *)entry->key);
            mark_value(allocator, entry->value);
        }
    }

    // Upvalues
    for (RavUpvalue *upvalue = vm->open_upvalues; upvalue != NULL; ) {
        mark_object(allocator, (Object *)upvalue);
        upvalue = upvalue->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40058(%rcx), %rax
jae 0xd8df
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xd9c0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0xd8b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x40c68(%rcx), %eax
jge 0xd921
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x40068, %rax          # imm = 0x40068
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xda10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd8e6
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x40c7c(%rcx), %eax
jg 0xd989
movq -0x10(%rbp), %rax
movq 0x40c70(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd97c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0xda10
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xd9c0
jmp 0xd97e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd928
movq -0x10(%rbp), %rax
movq 0x40c80(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd9ba
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xda10
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xd998
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/mem.c
// Function: mark_object
static void mark_object(Allocator *allocator, Object *object) {
    if (object == NULL) return;
    if (object->marked) return;

#ifdef DEBUG_TRACE_MEMORY
    printf("[Memory] %p get marked: ", object);
    value_print(Obj_Value(object));
    putchar('\n');
#endif

    object->marked = true;

    // Strings and native functions have no nested references, so no need
    // to push them into the gray stack
    if (object->type == OBJ_STRING || object->type == OBJ_CFUNCTION) {
        return;
    }

    // Add the object to the marked stack.
    if (allocator->gray_count == allocator->gray_capacity) {
        int new_capacity = Grow_Capacity(allocator->gray_capacity);
        size_t size = sizeof (Object*) * new_capacity;

        allocator->gray_stack = realloc(allocator->gray_stack, size);
        allocator->gray_capacity = new_capacity;
    }

    allocator->gray_stack[allocator->gray_count++] = object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xda2c
jmp 0xdae4
movq -0x10(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0xda3b
jmp 0xdae4
movq -0x10(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xda55
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xda5a
jmp 0xdae4
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0xdac2
movq -0x8(%rbp), %rax
cmpl $0x8, 0x28(%rax)
jge 0xda7e
movl $0x8, %eax
movl %eax, -0x24(%rbp)
jmp 0xda8a
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
shll %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x21b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x2c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x2c(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/mem.c
// Function: sweep
static void sweep(Allocator *allocator) {
    Object **link = &allocator->objects;

    while (*link != allocator->objects_end) {
        if ((*link)->marked) {
            (*link)->marked = false;
            link = &(*link)->next;
        } else {
            Object *dead = *link;
            *link = (*link)->next;

            free_object(allocator, dead);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0xdbbe
movq -0x10(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x4(%rax)
je 0xdb92
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xdbbc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd5c0
jmp 0xdb58
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/shmem_init.c
// Function: find_data_pages
static void find_data_pages( void** ret_map_start, size_t* ret_map_size )
{

	long page_size = getpagesize();
	long page_mask = ~(page_size-1);
	intptr_t map_start = ((intptr_t)&__data_start) & page_mask;
	size_t map_size = ((intptr_t)&end) - map_start;

	if ((map_size & page_mask) != map_size) 
		map_size = (map_size & page_mask) + page_size;

	if (ret_map_start) *ret_map_start = (void*)map_start;
	if (ret_map_size) *ret_map_size = map_size;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1220
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
leaq 0x5456(%rip), %rax      # 0x7128
andq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x57d7(%rip), %rax      # 0x74b8
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x1d07
movq -0x30(%rbp), %rax
andq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d19
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x1d2b
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/shmem_init.c
// Function: remap_pages
static int remap_pages(int fd, off_t offset, void* map_start, size_t map_size)
{

	int i;

	// allocate memory to backup pages containing .data and .bss sections
	void* buf = mmap(0,map_size,PROT_READ|PROT_WRITE,
		MAP_PRIVATE|MAP_ANONYMOUS,-1,0);

	if (!buf) return(-1);

	// copy pages and DO NOT use memcpy
	long long* q = (long long*)map_start;
	long long* p = (long long*)buf;
	for(i=0;i<map_size/sizeof(long long);i++,p++,q++) *p = *q;

	// create a new mapping to hold the data and bss sections
	void* map_ptr = mmap(map_start,map_size,
		PROT_READ|PROT_WRITE,MAP_SHARED|MAP_FIXED,fd,offset);

	if (!map_ptr) return(-1);

	// XXX This is where things are a bit scary, the data sections of entire
	// XXX program have been cleared and must be restored from our backup.
	// XXX At this point we should probably have disabled interrupts and
	// XXX done just about everything else we can do to create a critical
	// XXX section.  -DAR

	// copy pages back into place and DO NOT use memcpy
	q = (long long*)buf;
	p = (long long*)map_ptr;
	for(i=0;i<map_size/sizeof(long long);i++,p++,q++) *p = *q;	

	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1fef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20db
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x3, %rcx
cmpq %rcx, %rax
jae 0x2048
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x2006
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x8(%rbp), %r8d
movq -0x10(%rbp), %r9
movl $0x3, %edx
movl $0x11, %ecx
callq 0x10e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x207b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20db
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x3, %rcx
cmpq %rcx, %rax
jae 0x20d4
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x2092
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/shmem_ptr.c
// Function: shmem_ptr
SHMEM_SCOPE
void* shmem_ptr(const void* dest, int pe)
{

	if (pe == __shmem.my_pe) return (void*)dest;

	void* remote;

	if ((intptr_t)dest < __shmem.heap_shm_base) {

		remote = (void*)((intptr_t)dest 
			+ (__shmem.data_shm_base - __shmem.data_base) + pe*__shmem.data_size);

	} else {

		remote = (void*)((intptr_t)dest + (pe - __shmem.my_pe)*__shmem.heap_size);

	}

	return remote;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x50ab(%rip), %rcx      # 0x71f0
cmpl 0x4(%rcx), %eax
jne 0x2157
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21dc
movq -0x10(%rbp), %rax
leaq 0x508e(%rip), %rcx      # 0x71f0
cmpq 0x158(%rcx), %rax
jge 0x21aa
movq -0x10(%rbp), %rax
leaq 0x507a(%rip), %rcx      # 0x71f0
movq 0x148(%rcx), %rcx
leaq 0x506c(%rip), %rdx      # 0x71f0
subq 0x140(%rdx), %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
leaq 0x5057(%rip), %rdx      # 0x71f0
imulq 0x138(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x21d4
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
leaq 0x5038(%rip), %rdx      # 0x71f0
subl 0x4(%rdx), %ecx
movslq %ecx, %rcx
leaq 0x502b(%rip), %rdx      # 0x71f0
imulq 0x150(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/shmem_sync_all.c
// Function: shmem_sync_all
SHMEM_SCOPE
void shmem_sync_all(void)
{
	int i;

	debug("shmem_sync_all begin");

	volatile int* pcount
		= (volatile int*)shmem_ptr((void*)&__shmem.giant_barrier_count,0);

	sem_t* pgate1 = (sem_t*)shmem_ptr((void*)&__shmem.giant_barrier_gate1,0);
	sem_t* pgate2 = (sem_t*)shmem_ptr((void*)&__shmem.giant_barrier_gate2,0);

	__giant_lock();
	if (++(*pcount) == __shmem.n_pes) {
		debug("shmem_sync_all: before sem_post on pgate1");
		for(i=0;i<__shmem.n_pes;i++) sem_post(pgate1);
		debug("shmem_sync_all: after sem_post on pgate1");
	}
	__giant_unlock();

	debug("shmem_sync_all: before sem_wait on pgate1");
	sem_wait(pgate1);
	debug("shmem_sync_all: after sem_wait on pgate1");

	__giant_lock();
	if (--(*pcount) == 0) {
		debug("shmem_sync_all: before sem_post on pgate2");
		for(i=0;i<__shmem.n_pes;i++) sem_post(pgate2);
		debug("shmem_sync_all: after sem_post on pgate2");
	}
	__giant_unlock();

	sem_wait(pgate2);

	debug("shmem_sync_all end");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4fe1(%rip), %rdi      # 0x71f0
addq $0xc8, %rdi
xorl %esi, %esi
callq 0x2130
movq %rax, -0x10(%rbp)
leaq 0x4fc8(%rip), %rdi      # 0x71f0
addq $0xd0, %rdi
xorl %esi, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
leaq 0x4faf(%rip), %rdi      # 0x71f0
addq $0xf0, %rdi
xorl %esi, %esi
callq 0x2130
movq %rax, -0x20(%rbp)
leaq 0x4f96(%rip), %rax      # 0x71f0
movq 0xc0(%rax), %rdi
callq 0x1070
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
leaq 0x4f78(%rip), %rcx      # 0x71f0
cmpl 0x8(%rcx), %eax
jne 0x22a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x4f62(%rip), %rcx      # 0x71f0
cmpl 0x8(%rcx), %eax
jge 0x22a7
movq -0x18(%rbp), %rdi
callq 0x1160
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2284
jmp 0x22a9
jmp 0x22ab
leaq 0x4f3e(%rip), %rax      # 0x71f0
movq 0xc0(%rax), %rdi
callq 0x1160
movq -0x18(%rbp), %rdi
callq 0x1070
leaq 0x4f22(%rip), %rax      # 0x71f0
movq 0xc0(%rax), %rdi
callq 0x1070
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x2316
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x4ef5(%rip), %rcx      # 0x71f0
cmpl 0x8(%rcx), %eax
jge 0x2314
movq -0x20(%rbp), %rdi
callq 0x1160
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x22f1
jmp 0x2316
jmp 0x2318
leaq 0x4ed1(%rip), %rax      # 0x71f0
movq 0xc0(%rax), %rdi
callq 0x1160
movq -0x20(%rbp), %rdi
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/xmalloc.c
// Function: wrtmessage
static void
wrtmessage(const char *p1, const char *p2, const char *p3, const char *p4)
{

    write(STDERR_FILENO, p1, strlen(p1));
    write(STDERR_FILENO, p2, strlen(p2));
    write(STDERR_FILENO, p3, strlen(p3));
    write(STDERR_FILENO, p4, strlen(p4));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x1090
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x1090
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x1090
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x1090
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)