LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/raven.c
// Function: main
int main(int argc, char **argv) {
    if (argc == 1) {
        repl();
    } else if (argc == 2) {
        execute_file(argv[1]);
    } else {
        usage();
    }

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40d88, %rsp          # imm = 0x40D88
cmpl $0x2, %edi
je 0x23de
cmpl $0x1, %edi
jne 0x251e
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
callq 0x2588
movq 0xbc62(%rip), %r13      # 0xdfc8
leaq 0x6c97(%rip), %r14      # 0x9004
movq 0xbc5c(%rip), %rbp      # 0xdfd0
movq %rsp, %r15
leaq 0x6c89(%rip), %r12      # 0x9007
movq (%r13), %rsi
movq %r14, %rdi
callq 0x20f0
movq (%rbp), %rdx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2120
testq %rax, %rax
je 0x24b8
movq (%rbp), %rdi
callq 0x2160
testl %eax, %eax
jne 0x24b8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2847
testl %eax, %eax
jne 0x237e
movq 0x150(%rsp), %rdi
callq 0x56a8
pushq $0xa
popq %rdi
callq 0x2040
jmp 0x237e
movq 0x8(%rsi), %rbx
leaq 0x100(%rsp), %rdi
callq 0x2588
leaq 0x6c17(%rip), %rsi      # 0x900d
movq %rbx, %rdi
callq 0x21c0
testq %rax, %rax
je 0x2536
movq %rax, %r15
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x21a0
movq %r15, %rdi
callq 0x2150
movq %rax, %r12
movq %r15, %rdi
callq 0x20c0
leaq 0x1(%r12), %rdi
callq 0x2180
testq %rax, %rax
je 0x2565
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2080
cmpq %r12, %rax
jb 0x24ff
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x24ff
movq %r15, %rdi
callq 0x20a0
movb $0x0, (%r14,%r12)
leaq 0x100(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2847
testl %eax, %eax
je 0x24c2
movl %eax, %ebx
movq %r14, %rdi
callq 0x2030
leaq 0x100(%rsp), %rdi
callq 0x281f
cmpl $0x1, %ebx
je 0x2580
cmpl $0x2, %ebx
jne 0x24eb
jmp 0x2580
leaq 0x100(%rsp), %rdi
jmp 0x24e6
leaq 0x100(%rsp), %rbx
movq 0x50(%rbx), %rdi
callq 0x56a8
pushq $0xa
popq %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x281f
xorl %eax, %eax
addq $0x40d88, %rsp          # imm = 0x40D88
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbaea(%rip), %rax      # 0xdff0
movq (%rax), %r14
callq 0x2050
movl (%rax), %edi
callq 0x2210
leaq 0x6b3c(%rip), %rsi      # 0x9058
jmp 0x2553
movq 0xbaa3(%rip), %rax      # 0xdfc8
movq (%rax), %rsi
leaq 0x6b49(%rip), %rdi      # 0x9078
callq 0x20f0
jmp 0x2580
movq 0xbab3(%rip), %rax      # 0xdff0
movq (%rax), %r14
callq 0x2050
movl (%rax), %edi
callq 0x2210
leaq 0x6abd(%rip), %rsi      # 0x9010
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2140
jmp 0x2580
movq 0xba84(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x6abb(%rip), %rsi      # 0x9031
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2140
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: init_vm
void init_vm(VM *vm) {
    vm->open_upvalues = NULL;
    vm->reset_on_exit = true;

    allocator_init(&vm->allocator);
    table_init(&vm->globals);
    reset_stack(vm);
    register_natives(vm);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x40c80(%rdi)
movb $0x1, 0x40060(%rdi)
callq 0x8094
leaq 0x40c70(%rbx), %rdi
callq 0x4a70
leaq 0x58(%rbx), %rax
movq %rax, 0x40058(%rbx)
andl $0x0, 0x40c68(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x25c4
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: interpret
InterpretResult interpret(VM *vm, const char *source, const char *path) {
    // Disable the GC while compiling.
    vm->allocator.gc_off = true;
    vm->x = Nil_Value;

    RavFunction *function = compile(vm, source, path);
    if (function == NULL) {
        return INTERPRET_COMPILE_ERROR;
    }

    RavClosure *closure = object_closure(&vm->allocator, function);
    push(vm, Obj_Value(closure));

    // Top-level code is wrapped in a function for convenience,
    // to run the code, we simply call the wrapping function.
    push_frame(vm, closure, 0);

    vm->path = path;
    vm->allocator.gc_off = false;
    return run_vm(vm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movb $0x1, 0x40(%rdi)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x50(%rdi)
callq 0x5744
testq %rax, %rax
je 0x28bb
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5072
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rax, %rcx
movq 0x40058(%rbx), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x40058(%rbx)
movq %rcx, (%rdx)
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x28c6
movq %r14, 0x48(%rbx)
movb $0x0, 0x40(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2936
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: push_frame
static inline bool push_frame(VM *vm, RavClosure *closure, int count) {
    if (vm->frame_count == FRAMES_LIMIT) {
        runtime_error(vm, "call stack overflows");
        return false;
    }

    CallFrame *frame = &vm->frames[vm->frame_count++];
    frame->closure = closure;
    frame->ip = closure->function->chunk.opcodes;
    frame->slots = vm->stack_top - count - 1;
    return true;
}

// Assembly:
pushq %rbx
movslq 0x40c68(%rdi), %rbx
cmpq $0x80, %rbx
je 0x291d
leal 0x1(%rbx), %eax
movl %eax, 0x40c68(%rdi)
imulq $0x18, %rbx, %rax
movq %rsi, 0x40068(%rdi,%rax)
movq 0x10(%rsi), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x40070(%rdi,%rax)
movq 0x40058(%rdi), %rcx
movl %edx, %edx
shlq $0x3, %rdx
negq %rdx
addq %rdx, %rcx
addq $-0x8, %rcx
movq %rcx, 0x40078(%rdi,%rax)
jmp 0x292b
leaq 0x6a95(%rip), %rsi      # 0x93b9
xorl %eax, %eax
callq 0x46b0
cmpl $0x80, %ebx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_assert
static bool native_assert(VM *vm, Value *arguments, size_t count, Value *result) {
    Value expression = arguments[0];
    Value message = Nil_Value;

    // message is optional
    if (count == 2) {
        message = arguments[1];

        if (Is_String(message) == false) {
            runtime_error(vm, "`assert` expected string as second argument, got %s", type_repr(message));
            return false;
        }
    }

    if (is_falsy(expression)) {
        if (count == 2) {
            runtime_error(vm, "assertion failed: %s", As_String(message)->chars);
        } else {
            runtime_error(vm, "assertion failed");
        }
        return false;
    }

    *result = Nil_Value;
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x7ffc000000000001, %r8 # imm = 0x7FFC000000000001
movq (%rsi), %r9
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
movq %r8, %rdi
cmpq $0x2, %rdx
jne 0x429b
movq 0x8(%rsi), %rdi
movq %rdi, %rsi
shrq $0x32, %rsi
cmpl $0x3fff, %esi           # imm = 0x3FFF
jb 0x4285
movq %rdi, %rsi
andq %rax, %rsi
cmpl $0x0, (%rsi)
je 0x429b
callq 0x4864
leaq 0x4f81(%rip), %rsi      # 0x9212
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
jmp 0x42ce
cmpq %r8, %r9
je 0x42b5
leaq 0x2(%r8), %rsi
cmpq %rsi, %r9
je 0x42ec
leaq 0x1(%r8), %rsi
andq %rsi, %r9
cmpq %rsi, %r9
jne 0x42ec
cmpq $0x2, %rdx
jne 0x42d7
andq %rax, %rdi
movq 0x18(%rdi), %rdx
leaq 0x4f7d(%rip), %rsi      # 0x9246
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x46b0
jmp 0x42f2
leaq 0x4f7d(%rip), %rsi      # 0x925b
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x46b0
jmp 0x42f2
movq %r8, (%rcx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_print
static bool native_print(VM *vm, Value *arguments, size_t count, Value *result) {
    MAYBE_UNUSED(vm);

    for (size_t i = 0; i < count; ++i) {
        value_print(arguments[i]);
        putchar(' ');
    }

    *result = Nil_Value;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
pushq $0x20
popq %rbp
cmpq %r12, %r14
je 0x432c
movq (%r15,%r12,8), %rdi
callq 0x56a8
movl %ebp, %edi
callq 0x2040
incq %r12
jmp 0x4312
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, (%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_len
static bool native_len(VM *vm, Value *arguments, size_t count, Value *result) {
    MAYBE_UNUSED(count);

    Value argument = arguments[0];
    if (Is_String(argument)) {
        *result = Num_Value(As_String(argument)->length);
        return true;
    }
    if (Is_Array(argument)) {
        *result = Num_Value(As_Array(argument)->count);
        return true;
    }
    if (Is_Map(argument)) {
        *result = Num_Value(As_Map(argument)->table.count);
        return true;
    }

    runtime_error(vm, "`len` expected collection, got %s", type_repr(argument));
    return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x43d0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rdi, %rax
movl (%rax), %edx
cmpl $0x3, %edx
je 0x4413
cmpl $0x2, %edx
je 0x43ed
testl %edx, %edx
jne 0x43d0
cvtsi2sdl 0x10(%rax), %xmm0
jmp 0x4418
callq 0x4864
leaq 0x4e90(%rip), %rsi      # 0x926c
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x46b0
jmp 0x441f
movsd 0x18(%rax), %xmm0
unpcklps 0x4c97(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4c9f(%rip), %xmm0     # 0x90a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
jmp 0x441c
cvtsi2sdl 0x18(%rax), %xmm0
movsd %xmm0, (%rcx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_push
static bool native_push(VM *vm, Value *arguments, size_t count, Value *result) {
    Value argument = arguments[0];
    if (Is_Array(argument) == false) {
        runtime_error(vm, "`push` expected array as firt argument, got %s", type_repr(argument));
        return false;
    }

    RavArray *array = As_Array(argument);
    for (size_t i = 1; i < count; ++i) {
        // Grow array memory, if needed
        if (array->count == array->capacity) {
            size_t old_cap = array->capacity;
            size_t new_cap = Grow_Capacity(old_cap);
            array->capacity = new_cap;
            array->values = Grow_Array(&vm->allocator, array->values, Value, old_cap, new_cap);
        }
        array->values[array->count++] = arguments[i];
    }

    *result = argument;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x44bf
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
andq %r15, %rbp
cmpl $0x2, (%rbp)
jne 0x44bf
movq %rdx, %r12
movq %rsi, %r13
movq %rcx, (%rsp)
pushq $0x1
popq %r14
cmpq %r12, %r14
jae 0x44df
movq 0x10(%rbp), %rax
movq 0x18(%rbp), %rdx
cmpq 0x20(%rbp), %rdx
jne 0x44a9
leaq (%rdx,%rdx), %rcx
cmpq $0x8, %rdx
pushq $0x8
popq %rsi
cmovbq %rsi, %rcx
movq %rcx, 0x20(%rbp)
shlq $0x3, %rdx
shlq $0x3, %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x81a8
movq %rax, 0x10(%rbp)
movq 0x18(%rbp), %rdx
movq (%r13,%r14,8), %rcx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x18(%rbp)
movq %rcx, (%rax,%rdx,8)
incq %r14
jmp 0x4468
movq %r15, %rdi
callq 0x4864
leaq 0x4dc0(%rip), %rsi      # 0x928e
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x46b0
jmp 0x44e9
movq (%rsp), %rax
movq %r15, (%rax)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_pop
static bool native_pop(VM *vm, Value *arguments, size_t count, Value *result) {
    MAYBE_UNUSED(count);

    Value argument = arguments[0];
    if (Is_Array(argument) == false) {
        runtime_error(vm, "`pop` expected array, got %s", type_repr(argument));
        return false;
    }

    RavArray *array = As_Array(argument);
    if (array->count == 0) {
        runtime_error(vm, "`pop` on an empty array");
        return false;
    }

    *result = array->values[--array->count];
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x4545
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rdi, %rax
cmpl $0x2, (%rax)
jne 0x4545
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x4569
movq 0x10(%rax), %rsi
leaq -0x1(%rdx), %rdi
movq %rdi, 0x18(%rax)
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, (%rcx)
movb $0x1, %bpl
jmp 0x4560
callq 0x4864
leaq 0x4d6c(%rip), %rsi      # 0x92bd
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x46b0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4d6a(%rip), %rsi      # 0x92da
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x46b0
jmp 0x4560
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_insert
static bool native_insert(VM *vm, Value *arguments, size_t count, Value *result) {
    MAYBE_UNUSED(count);

    Value argument1 = arguments[0];
    if (Is_Map(argument1) == false) {
        runtime_error(vm, "`insert` expected map as first argument, got %s", type_repr(argument1));
        return false;
    }
    RavMap *map = As_Map(argument1);

    Value argument2 = arguments[1];
    if (Is_String(argument2) == false) {
        runtime_error(vm, "`insert` expected string as second argument, got %s", type_repr(argument2));
        return false;
    }
    RavString *key = As_String(argument2);

    Value value = arguments[2];
    table_set(&map->table, key, value);
    *result = value;
    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq %rcx, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x45da
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
movq %rcx, %rdi
andq %rax, %rdi
cmpl $0x3, (%rdi)
jne 0x45da
movabsq $-0x4000000000001, %rdx # imm = 0xFFFBFFFFFFFFFFFF
movq 0x8(%rsi), %rcx
cmpq %rdx, %rcx
jbe 0x45c9
andq %rcx, %rax
cmpl $0x0, (%rax)
je 0x45ff
movq %rcx, %rdi
callq 0x4864
leaq 0x4d4a(%rip), %rsi      # 0x9322
jmp 0x45e9
movq %rcx, %rdi
callq 0x4864
leaq 0x4d09(%rip), %rsi      # 0x92f2
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x46b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rsi), %rbx
addq $0x10, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x4b15
movq %rbx, (%r14)
movb $0x1, %bpl
jmp 0x45f8
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: native_remove
static bool native_remove(VM *vm, Value *arguments, size_t count, Value *result) {
    MAYBE_UNUSED(count);

    Value argument1 = arguments[0];
    if (Is_Map(argument1) == false) {
        runtime_error(vm, "`remove` expected map as firt argument, got %s", type_repr(argument1));
        return false;
    }
    RavMap *map = As_Map(argument1);

    Value argument2 = arguments[1];
    if (Is_String(argument2) == false) {
        runtime_error(vm, "`remove` expected string as second argument, got %s", type_repr(argument2));
        return false;
    }
    RavString *key = As_String(argument2);

    *result = table_remove(&map->table, key);
    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq %rcx, %rdx
shrq $0x32, %rdx
cmpl $0x3fff, %edx           # imm = 0x3FFF
jb 0x467a
movq %rsi, %rax
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
movq %rcx, %rdi
andq %rsi, %rdi
cmpl $0x3, (%rdi)
jne 0x467a
movabsq $-0x4000000000001, %rcx # imm = 0xFFFBFFFFFFFFFFFF
movq 0x8(%rax), %rax
cmpq %rcx, %rax
jbe 0x4669
andq %rax, %rsi
cmpl $0x0, (%rsi)
je 0x469f
movq %rax, %rdi
callq 0x4864
leaq 0x4d0d(%rip), %rsi      # 0x9385
jmp 0x4689
movq %rcx, %rdi
callq 0x4864
leaq 0x4ccd(%rip), %rsi      # 0x9356
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x46b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
addq $0x10, %rdi
callq 0x4c80
movq %rax, (%r14)
movb $0x1, %bpl
jmp 0x4698
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: runtime_error
static void runtime_error(VM *vm, const char *format, ...) {
    va_list arguments;
    va_start(arguments, format);

    CallFrame *frame = &vm->frames[vm->frame_count - 1];
    RavFunction *function = frame->closure->function;

    // -1 because ip is sitting on the next instruction to be executed.
    size_t offset = frame->ip - function->chunk.opcodes - 1;
    int line = chunk_decode_line(&function->chunk, offset);
    fprintf(stderr, "[%s | line: %d] ", vm->path, line);

    vfprintf(stderr, format, arguments);
    putc('\n', stderr);

    dump_stack_trace(vm, stderr);

    va_end(arguments);
    reset_stack(vm);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x4717
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r15
movq %rsi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
movslq 0x40c68(%rdi), %rax
imulq $0x18, %rax, %rax
movq 0x40050(%rax,%rdi), %rcx
movq 0x10(%rcx), %rdi
movl 0x28(%rdi), %esi
addq $0x20, %rdi
notl %esi
addl 0x40058(%rax,%rbx), %esi
callq 0x4a2e
movq 0x9886(%rip), %r12      # 0xdff0
movq (%r12), %rdi
movq 0x48(%rbx), %rdx
leaq 0x49e4(%rip), %rsi      # 0x915d
movl %eax, %ecx
xorl %eax, %eax
callq 0x2140
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21d0
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x2130
movq (%r12), %r14
leaq 0x49c6(%rip), %rdi      # 0x916e
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x2200
movl 0x40c68(%rbx), %ebp
imulq $0x18, %rbp, %rax
leaq 0x40058(%rbx), %r13
addq %rax, %r13
leaq 0x49af(%rip), %r12      # 0x9180
testl %ebp, %ebp
jle 0x4840
movq -0x8(%r13), %rax
movq 0x10(%rax), %r15
leaq 0x20(%r15), %rdi
movl 0x28(%r15), %esi
notl %esi
addl (%r13), %esi
callq 0x4a2e
movq 0x48(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x2140
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0x4823
leaq 0x497f(%rip), %rdi      # 0x9192
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x2200
jmp 0x4838
movq 0x18(%rax), %rdx
movq %r14, %rdi
leaq 0x4821(%rip), %rsi      # 0x9052
xorl %eax, %eax
callq 0x2140
decl %ebp
addq $-0x18, %r13
jmp 0x47d1
leaq 0x58(%rbx), %rax
movq %rax, 0x40058(%rbx)
andl $0x0, 0x40c68(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: type_repr
static const char* type_repr(Value value) {
    if (Is_Nil(value))       return "nil";
    if (Is_Bool(value))      return "boolean";
    if (Is_Num(value))       return "number";
    if (Is_String(value))    return "string";
    if (Is_Pair(value))      return "pair";
    if (Is_Array(value))     return "array";
    if (Is_Map(value))       return "map";
    if (Is_Function(value))  return "function";
    if (Is_Closure(value))   return "function";
    if (Is_CFunction(value)) return "native-function";

    assert(!"unreachable: invalid value tag");
    return NULL;
}

// Assembly:
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
leaq 0x1(%rax), %rcx
cmpq %rcx, %rdi
jne 0x487f
leaq 0x4920(%rip), %rax      # 0x919e
retq
leaq 0x2(%rax), %rdx
movq %rdi, %rcx
notq %rcx
testq %rcx, %rdx
jne 0x4896
leaq 0x490d(%rip), %rax      # 0x91a2
retq
testq %rcx, %rax
jne 0x48d7
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x48df
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rdi
movl (%rdi), %eax
cmpq $0x8, %rax
jae 0x48df
movl $0xdf, %ecx
btl %eax, %ecx
jae 0x48df
leaq 0x4d1d(%rip), %rcx      # 0x95ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x48cc(%rip), %rax      # 0x91aa
retq
pushq %rax
leaq 0x48e3(%rip), %rdi      # 0x91ca
leaq 0x48fe(%rip), %rsi      # 0x91ec
leaq 0x4900(%rip), %rcx      # 0x91f5
pushq $0x20
popq %rdx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/vm.c
// Function: close_upvalues
static void close_upvalues(VM *vm, Value *slot) {
    while (vm->open_upvalues != NULL &&
           vm->open_upvalues->location >= slot) {
        RavUpvalue *upvalue = vm->open_upvalues;
        upvalue->captured = *upvalue->location;
        upvalue->location = &upvalue->captured;
        vm->open_upvalues = upvalue->next;
    }
}

// Assembly:
movq 0x40c80(%rdi), %rax
testq %rax, %rax
je 0x492e
movq 0x10(%rax), %rcx
cmpq %rsi, %rcx
jb 0x492e
movq (%rcx), %rcx
leaq 0x18(%rax), %rdx
movq %rcx, 0x18(%rax)
movq %rdx, 0x10(%rax)
movq 0x20(%rax), %rax
movq %rax, 0x40c80(%rdi)
jmp 0x4904
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/chunk.c
// Function: chunk_write_byte
void chunk_write_byte(Chunk *chunk, uint8_t byte, int line) {
    if (chunk->count == chunk->capacity) {
        chunk->capacity = Grow_Capacity(chunk->capacity);
        chunk->opcodes = realloc(chunk->opcodes, chunk->capacity);
    }

    chunk->opcodes[chunk->count++] = byte;
    write_line(chunk, line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %ecx
pushq $0x8
popq %r15
cmpl 0x4(%rdi), %ecx
jne 0x49a4
leal (%rcx,%rcx), %esi
cmpl $0x8, %ecx
cmovll %r15d, %esi
movl %esi, 0x4(%r14)
movq 0x8(%r14), %rdi
callq 0x21b0
movq %rax, 0x8(%r14)
movl (%r14), %ecx
jmp 0x49a8
movq 0x8(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movslq %ecx, %rcx
movb %bpl, (%rax,%rcx)
movslq 0x10(%r14), %rcx
testq %rcx, %rcx
jle 0x49c8
movq 0x18(%r14), %rax
cmpl %ebx, -0x8(%rax,%rcx,8)
je 0x4a0d
cmpl 0x14(%r14), %ecx
jne 0x49f3
leal (%rcx,%rcx), %esi
cmpl $0x8, %ecx
cmovll %r15d, %esi
movl %esi, 0x14(%r14)
movq 0x18(%r14), %rdi
shlq $0x3, %rsi
callq 0x21b0
movq %rax, 0x18(%r14)
movl 0x10(%r14), %ecx
jmp 0x49f7
movq 0x18(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x10(%r14)
movslq %ecx, %rcx
movl %ebx, (%rax,%rcx,8)
movl (%r14), %edx
decl %edx
movl %edx, 0x4(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/chunk.c
// Function: chunk_decode_line
int chunk_decode_line(Chunk *chunk, int offset) {
    int start = 0;
    int end = chunk->lines_count - 1;

    for (;;) {
        int mid = (start + end) / 2;
        Line *line = &chunk->lines[mid];

        if (offset < line->offset) {
            end = mid - 1;
        }  else if (mid == chunk->lines_count - 1 || offset < chunk->lines[mid + 1].offset) {
            return line->line;
        } else {
            start = mid + 1;
        }
    }
}

// Assembly:
movl 0x10(%rdi), %ecx
decl %ecx
movq 0x18(%rdi), %rdi
xorl %r10d, %r10d
pushq $0x2
popq %r8
movl %ecx, %r9d
leal (%r10,%r9), %eax
cltd
idivl %r8d
movslq %eax, %rdx
cmpl %esi, 0x4(%rdi,%rdx,8)
jg 0x4a63
cmpl %ecx, %eax
je 0x4a6a
incl %eax
movl %eax, %r10d
cmpl %esi, 0xc(%rdi,%rdx,8)
jle 0x4a41
jmp 0x4a6a
decl %eax
movl %eax, %r9d
jmp 0x4a41
movl (%rdi,%rdx,8), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: table_get
bool table_get(Table *table, RavString *key, Value *value) {
    if (table->count == 0) {
        return false;
    }

    Entry *entry = find_entry(table->entries, key, table->hash_mask);
    if (entry->key == NULL) {
        return false;
    }

    *value = entry->value;
    return true;
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
je 0x4acc
pushq %rbx
movq %rdx, %rbx
movq (%rdi), %rax
movl 0xc(%rdi), %edx
movq %rax, %rdi
callq 0x4ad3
cmpq $0x0, (%rax)
je 0x4acf
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movb $0x1, %al
jmp 0x4ad1
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: find_entry
static Entry *find_entry(Entry *entries, RavString *key, int hash_mask) {
    uint32_t index = key->hash & hash_mask;
    Entry *tombstone = NULL;

    for (;;) {
        Entry *entry = &entries[index];

        if (entry->key == NULL) {
            if (Is_Nil(entry->value)) {
                return tombstone ? tombstone : entry;
            }

            if (tombstone == NULL) tombstone = entry;
        } else if (entry->key == key) {
            return entry;
        }

        index = (index + 1) & hash_mask;
    }
}

// Assembly:
movl 0x14(%rsi), %ecx
xorl %r8d, %r8d
movabsq $0x7ffc000000000001, %r9 # imm = 0x7FFC000000000001
andl %edx, %ecx
movq %rcx, %r10
shlq $0x4, %r10
leaq (%rdi,%r10), %rax
movq (%rdi,%r10), %r10
testq %r10, %r10
je 0x4b00
cmpq %rsi, %r10
jne 0x4b10
jmp 0x4b14
testq %r8, %r8
cmoveq %rax, %r8
cmpq %r9, 0x8(%rax)
movq %r8, %rax
je 0x4b14
incl %ecx
jmp 0x4ae3
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: table_set
bool table_set(Table *table, RavString *key, Value value) {
    int capacity = table->hash_mask + 1;

    if (table->count >= capacity * TABLE_MAX_LOAD) {
        int new_capacity = Grow_Capacity(capacity);
        adjust_capacity(table, new_capacity - 1);
    }

    Entry *entry = find_entry(table->entries, key, table->hash_mask);

    bool is_new_key = entry->key == NULL;
    if (is_new_key && Is_Nil(entry->value)) {
        table->count++;
    }

    entry->key = key;
    entry->value = value;
    return is_new_key;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %r13d
leal 0x1(%r13), %eax
cvtsi2sdl 0x8(%rdi), %xmm0
cvtsi2sd %eax, %xmm1
mulsd 0x4ace(%rip), %xmm1     # 0x9610
movq %rsi, %r15
ucomisd %xmm1, %xmm0
movabsq $0x7ffc000000000001, %rbp # imm = 0x7FFC000000000001
jae 0x4b5d
movq (%r14), %r12
jmp 0x4c42
movq %rbx, 0x20(%rsp)
cmpl $0x7, %r13d
leal -0x1(%rax,%rax), %eax
pushq $0x7
popq %r12
cmovgel %eax, %r12d
movslq %r12d, %rbx
movq %rbx, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
callq 0x2180
testl %ebx, %ebx
pushq $-0x1
popq %rcx
movl %ecx, %edx
movl %r12d, 0xc(%rsp)
cmovnsl %r12d, %edx
movq %rax, %r12
incl %edx
shlq $0x4, %rdx
xorl %eax, %eax
cmpq %rax, %rdx
je 0x4bb5
andq $0x0, (%r12,%rax)
movq %rbp, 0x8(%r12,%rax)
addq $0x10, %rax
jmp 0x4ba0
movq %r15, 0x18(%rsp)
andl $0x0, 0x8(%r14)
movq %r14, %rbp
movq (%r14), %rax
testl %r13d, %r13d
cmovnsl %r13d, %ecx
movslq %ecx, %rbx
incq %rbx
movq %rax, 0x10(%rsp)
leaq 0x8(%rax), %r15
xorl %r14d, %r14d
subq $0x1, %rbx
jb 0x4c13
movq -0x8(%r15), %r13
testq %r13, %r13
je 0x4c0d
movq %r12, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x4ad3
movq %r13, (%rax)
movq (%r15), %rcx
movq %rcx, 0x8(%rax)
incl %r14d
movl %r14d, 0x8(%rbp)
addq $0x10, %r15
jmp 0x4bde
movq 0x10(%rsp), %rdi
callq 0x2030
movq %rbp, %r14
movq %r12, (%rbp)
movl 0xc(%rsp), %eax
movl %eax, 0xc(%rbp)
movl %eax, %r13d
movq 0x20(%rsp), %rbx
movq 0x18(%rsp), %r15
movabsq $0x7ffc000000000001, %rbp # imm = 0x7FFC000000000001
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x4ad3
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x4c62
cmpq %rbp, 0x8(%rax)
jne 0x4c62
incl 0x8(%r14)
testq %rcx, %rcx
sete %cl
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: table_remove
Value table_remove(Table *table, RavString *key) {
    if (table->count == 0) {
        return Nil_Value;
    }

    Entry *entry = find_entry(table->entries, key, table->hash_mask);
    if (entry->key == NULL) {
        return Nil_Value;
    }

    Value value = entry->value;
    entry->key = NULL;
    entry->value = Bool_Value(false); // Any non-nil value

    return value;
}

// Assembly:
pushq %rbx
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
cmpl $0x0, 0x8(%rdi)
je 0x4cb7
movq (%rdi), %rax
movl 0xc(%rdi), %edx
movq %rax, %rdi
callq 0x4ad3
cmpq $0x0, (%rax)
je 0x4cb7
movq 0x8(%rax), %rcx
andq $0x0, (%rax)
incq %rbx
movq %rbx, 0x8(%rax)
movq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: table_copy
void table_copy(Table *from, Table *to) {
    for (int i = 0; i <= from->hash_mask; i++) {
        Entry *entry = &from->entries[i];

        if (entry->key) {
            table_set(to, entry->key, entry->value);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r15
xorl %r12d, %r12d
movslq 0xc(%r14), %rax
cmpq %rax, %r12
jg 0x4cfc
movq (%r14), %rax
movq -0x8(%rax,%r15), %rsi
testq %rsi, %rsi
je 0x4cf3
movq (%rax,%r15), %rdx
movq %rbx, %rdi
callq 0x4b15
incq %r12
addq $0x10, %r15
jmp 0x4cd1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: table_interned
RavString *table_interned(Table *table, const char *chars, uint32_t hash, int length) {
    if (table->count == 0) {
        return NULL;
    }

    uint32_t index = hash & table->hash_mask;
    for (;;) {
        Entry *entry = &table->entries[index];

        if (entry->key == NULL) {
            if (Is_Nil(entry->value)) {
                return NULL;
            }
        } else {
            RavString *key = entry->key;
            if (key->length == length &&
                key->hash == hash &&
                memcmp(key->chars, chars, length) == 0) {
                return key;
            }
        }

        index = (index + 1) & table->hash_mask;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
cmpl $0x0, 0x8(%rdi)
je 0x4d93
movl %ecx, %ebx
movl 0xc(%rdi), %r14d
movl %r14d, %r13d
andl %edx, %r13d
movq (%rdi), %r15
movslq %ecx, %rax
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rbp # imm = 0x7FFC000000000001
movl %edx, 0x4(%rsp)
movl %r13d, %eax
shlq $0x4, %rax
movq (%r15,%rax), %r12
testq %r12, %r12
je 0x4d82
cmpl %ebx, 0x10(%r12)
jne 0x4d8b
cmpl %edx, 0x14(%r12)
jne 0x4d8b
movq 0x18(%r12), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2190
movl 0x4(%rsp), %edx
testl %eax, %eax
jne 0x4d8b
jmp 0x4d96
addq %r15, %rax
cmpq %rbp, 0x8(%rax)
je 0x4d93
incl %r13d
andl %r14d, %r13d
jmp 0x4d46
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/table.c
// Function: table_remove_weak
void table_remove_weak(Table *table) {
    for (int i = 0; i <= table->hash_mask; i++) {
        Entry *entry = &table->entries[i];

        if (entry->key != NULL && !entry->key->header.marked) {
            table_remove(table, entry->key);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jg 0x4de2
movq (%rbx), %rax
movq (%rax,%r14), %rsi
testq %rsi, %rsi
je 0x4dd9
cmpb $0x0, 0x4(%rsi)
jne 0x4dd9
movq %rbx, %rdi
callq 0x4c80
incq %r15
addq $0x10, %r14
jmp 0x4db6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_string
RavString *object_string(Allocator *allocator, const char *chars, int length) {
    uint32_t hash = hash_string(chars, length);
    RavString *interned = table_interned(&allocator->strings, chars, hash, length);
    if (interned != NULL) {
        return interned;
    }

    char *copy = Alloc(allocator, char, length + 1);
    memcpy(copy, chars, length);
    copy[length] = '\0';

    return construct_string(allocator, length, hash, copy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0x4e6f
movl %eax, %ebp
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
movl %ebx, %ecx
callq 0x4d08
testq %rax, %rax
je 0x4e2a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal 0x1(%rbx), %eax
movslq %eax, %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x81a8
movq %rax, %r12
movslq %ebx, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2170
movb $0x0, (%r12,%r13)
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e92
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: hash_string
static uint32_t hash_string(const char *key, int length) {
    uint32_t hash = 2166136261u;

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

    return hash;
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
cmpq %rcx, %rsi
je 0x4e91
movsbl (%rdi,%rcx), %edx
xorl %edx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
incq %rcx
jmp 0x4e7b
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: construct_string
static RavString *construct_string(Allocator *allocator, int length, uint32_t hash, char *chars) {
    RavString *string = Alloc_Object(allocator, RavString, OBJ_STRING);
    string->length = length;
    string->hash = hash;
    string->chars = chars;

    table_set(&allocator->strings, string, Nil_Value);
    return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x20
popq %rdx
xorl %esi, %esi
callq 0x4f6d
movq %rax, %r12
movl %r14d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movq %rbx, 0x18(%rax)
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
movq %r15, %rdi
movq %rax, %rsi
callq 0x4b15
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_string_box
RavString *object_string_box(Allocator *allocator, char *chars, int length) {
    uint32_t hash = hash_string(chars, length);
    RavString *interned = table_interned(&allocator->strings, chars, hash, length);

    // object_string_box takes ownership of chars memory, so if
    // the string is already interned, it frees this memory,
    // as it's no longer needed.
    if (interned != NULL) {
        Free_Array(allocator, char, chars, length + 1);
        return interned;
    }

    return construct_string(allocator, length, hash, chars);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0x4e6f
movl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl %ebp, %ecx
callq 0x4d08
testq %rax, %rax
je 0x4f30
movq %rax, %r15
incl %ebp
movslq %ebp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x81a8
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4e92
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_pair
RavPair *object_pair(Allocator *allocator, Value head, Value tail) {
    RavPair *pair = Alloc_Object(allocator, RavPair, OBJ_PAIR);

    pair->head = head;
    pair->tail = tail;

    return pair;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x1
popq %rsi
pushq $0x20
popq %rdx
callq 0x4f6d
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: alloc_object
static Object *alloc_object(Allocator *allocator, ObjectType type, size_t size) {
    Object *object = (Object *)allocate(allocator, NULL, 0, size);
    object->type = type;
    object->marked = false;
    object->next = allocator->objects;

#ifdef DEBUG_TRACE_MEMORY
    printf("[Memory] %p : allocate %ld for %d\n", object, size, type);
#endif

    allocator->objects = object;
    return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x81a8
movl %ebx, (%rax)
movb $0x0, 0x4(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_array
RavArray *object_array(Allocator *allocator, Value *values, size_t count) {
    RavArray *array = Alloc_Object(allocator, RavArray, OBJ_ARRAY);

    array->header.marked = true; // for gc
    array->values = Alloc(allocator, Value, count);
    array->header.marked = false;
    array->count = count;
    array->capacity = count;

    memcpy(array->values, values, count * sizeof (Value));

    return array;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %rsi
pushq $0x28
popq %rdx
callq 0x4f6d
movq %rax, %r12
movb $0x1, 0x4(%rax)
leaq (,%rbx,8), %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
callq 0x81a8
movq %rax, 0x10(%r12)
movb $0x0, 0x4(%r12)
movq %rbx, 0x18(%r12)
movq %rbx, 0x20(%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2170
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_function
RavFunction *object_function(Allocator *allocator) {
    RavFunction *function = Alloc_Object(allocator, RavFunction, OBJ_FUNCTION);

    function->name = NULL;
    function->arity = 0;
    function->upvalue_count = 0;

    chunk_init(&function->chunk);
    return function;
}

// Assembly:
pushq %rbx
pushq $0x4
popq %rsi
movl $0x850, %edx            # imm = 0x850
callq 0x4f6d
movq %rax, %rbx
leaq 0x20(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
callq 0x4930
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_upvalue
RavUpvalue *object_upvalue(Allocator *allocator, Value *location) {
    RavUpvalue *upvalue = Alloc_Object(allocator, RavUpvalue, OBJ_UPVALUE);

    upvalue->location = location;
    upvalue->captured = Nil_Value;
    upvalue->next = NULL;

    return upvalue;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
pushq $0x5
popq %rsi
pushq $0x28
popq %rdx
callq 0x4f6d
movq %rbx, 0x10(%rax)
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_closure
RavClosure *object_closure(Allocator *allocator, RavFunction *function) {
    RavUpvalue **upvalues = Alloc(allocator, RavUpvalue*, function->upvalue_count);

    for (int i = 0; i < function->upvalue_count; i++) {
        upvalues[i] = NULL;
    }

    RavClosure *closure = Alloc_Object(allocator, RavClosure, OBJ_CLOSURE);
    closure->function = function;
    closure->upvalues = upvalues;
    closure->upvalue_count = function->upvalue_count;

    return closure;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x1c(%rsi), %rcx
shlq $0x3, %rcx
xorl %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x81a8
movq %rax, %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r12
jge 0x50aa
andq $0x0, (%r15,%r12,8)
incq %r12
jmp 0x509b
pushq $0x6
popq %rsi
pushq $0x28
popq %rdx
movq %r14, %rdi
callq 0x4f6d
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
movl 0x1c(%rbx), %ecx
movl %ecx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: object_cfunction
RavCFunction *object_cfunction(Allocator *allocator, CFunc func, int arity_min, int arity_max) {
    RavCFunction *cfunction = Alloc_Object(allocator, RavCFunction, OBJ_CFUNCTION);
    cfunction->func = func;
    cfunction->arity_min = arity_min;
    cfunction->arity_max = arity_max;
    return cfunction;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
pushq $0x7
popq %rsi
pushq $0x20
popq %rdx
callq 0x4f6d
movq %r14, 0x10(%rax)
movl %ebp, 0x18(%rax)
movl %ebx, 0x1c(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/object.c
// Function: string_buf_into
RavString *string_buf_into(StringBuffer *self) {
    // shrink the string buffer into the string needed length
    self->buffer = allocate(self->allocator, self->buffer, self->capacity, self->count + 1);
    self->buffer[self->count] = '\0';

    // allocate a string object pointing to the buffer string
    RavString *result = object_string_box(self->allocator, self->buffer, self->count);

    // reset the buffer state
    *self = (StringBuffer){0};
    return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rbx), %rsi
movslq 0xc(%rbx), %rdx
movslq 0x8(%rbx), %rcx
incq %rcx
callq 0x81a8
movq %rax, 0x10(%rbx)
movslq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
callq 0x4ede
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/value.c
// Function: value_print
void value_print(Value value) {
#ifdef NAN_TAGGING
    if (Is_Num(value)) {
        printf("%g", As_Num(value));
        return;
    }

    if (Is_Bool(value)) {
        printf(As_Bool(value) ? "true" : "false");
        return;
    }

    if (Is_Nil(value)) {
        printf("nil");
        return;
    }

    if (Is_Obj(value)) {
        object_print(value);
        return;
    }

    assert(!"invalid value type");
#else
    switch (value.type) {
    case VALUE_NUM:  printf("%g", As_Num(value)); break;
    case VALUE_BOOL: printf(As_Bool(value) ? "true" : "false"); break;
    case VALUE_NIL:  printf("nil"); break;
    case VALUE_OBJ:  object_print(value); break;
    default:
        assert(!"invalid value type");
    }
#endif
}

// Assembly:
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rdi, %rcx
notq %rcx
testq %rax, %rcx
jne 0x56e1
leaq 0x2(%rax), %rdx
testq %rcx, %rdx
jne 0x56f4
addq $0x3, %rax
cmpq %rax, %rdi
leaq 0x3fde(%rip), %rax      # 0x96b2
leaq 0x3fdc(%rip), %rdi      # 0x96b7
cmoveq %rax, %rdi
jmp 0x5703
movq %rdi, %xmm0
leaq 0x3fd0(%rip), %rdi      # 0x96bd
movb $0x1, %al
jmp 0x20b0
incq %rax
cmpq %rax, %rdi
jne 0x570a
leaq 0x3a9b(%rip), %rdi      # 0x919e
xorl %eax, %eax
jmp 0x20b0
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jae 0x50f7
pushq %rax
leaq 0x4014(%rip), %rdi      # 0x9738
leaq 0x4023(%rip), %rsi      # 0x974e
leaq 0x4028(%rip), %rcx      # 0x975a
pushq $0x1e
popq %rdx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x2298, %rsp           # imm = 0x2298
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x7320
leaq 0x20(%rsp), %rbx
movq %r15, (%rbx)
andq $0x0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
andw $0x0, 0x48(%rbx)
orq $-0x1, 0x4c(%rbx)
movq %rbx, %rdi
callq 0x5a44
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x57d4
pushq $0x36
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5876
testb %al, %al
jne 0x57ac
movq %rbx, %rdi
callq 0x5893
jmp 0x5794
leaq 0x20(%rsp), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5a17
xorl %ecx, %ecx
cmpb $0x0, 0x48(%rbx)
cmovneq %rcx, %rax
addq $0x2298, %rsp           # imm = 0x2298
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/compiler.c
// Function: init_context
static inline void init_context(Context *context, Parser *parser, FunctionType type) {
    // TODO: limit the amount of nesting function declaration.
    context->enclosing = parser->context; // Save the previous scope.
    parser->context = context;            // Push the new scope.

    context->toplevel = type == FunctionToplevel;
    context->local_count = 0;
    context->scope_depth = 0;
    context->function = object_function(&parser->vm->allocator);

    // Reserve the first slot of the stack for the function itself.
    Local *local = &context->locals[context->local_count++];
    local->depth = 0;
    local->name.lexeme = "";
    local->name.length = 0;
    local->is_captured = false;

    if (type == FunctionDeclaration) {
        context->function->name = object_string(
            &parser->vm->allocator,
            parser->previous.lexeme,
            parser->previous.length
        );
    } else if (type == FunctionLambda || type == FunctionLambdaHeadless) {
        static const char LAMBDA_NAME[] = "\\lambda";

        context->function->name = object_string(
            &parser->vm->allocator,
            LAMBDA_NAME,
            sizeof LAMBDA_NAME
        );
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, (%rdi)
movq %rdi, 0x8(%rsi)
testl %edx, %edx
sete 0x10(%rdi)
andl $0x0, 0x2018(%rdi)
andl $0x0, 0x221c(%rdi)
movq 0x10(%rsi), %rdi
callq 0x5024
movq %rax, 0x8(%rbx)
movslq 0x2018(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2018(%rbx)
shlq $0x5, %rax
andl $0x0, 0x30(%rbx,%rax)
leaq 0x382b(%rip), %rcx      # 0x9057
movq %rcx, 0x20(%rbx,%rax)
andl $0x0, 0x28(%rbx,%rax)
movb $0x0, 0x34(%rbx,%rax)
cmpl $0x1, %ebp
jne 0x584e
movq 0x10(%r14), %rdi
movq 0x38(%r14), %rsi
movl 0x40(%r14), %edx
jmp 0x5864
andl $-0x2, %ebp
cmpl $0x2, %ebp
jne 0x5871
movq 0x10(%r14), %rdi
leaq 0x3f3b(%rip), %rsi      # 0x979c
pushq $0x8
popq %rdx
callq 0x4de8
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mahrr[P]raven/src/compiler.c
// Function: consume_if
static inline bool consume_if(Parser *parser, TokenType type) {
    if (!current_is(parser, type)) {
        return false;
    }

    advance(parser);
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl 0x18(%rdi), %ebp
cmpl %esi, %ebp
jne 0x5887
callq 0x5a44
cmpl %ebx, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq