LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/OpenGene[P]pecheck/src/read.cpp
// Function: Read::firstIndex[abi:cxx11]()
string Read::firstIndex(){
	int len = mName.length();
	int end = len;
	if(len<5)
		return "";
	for(int i=len-3;i>=0;i--){
		if(mName[i]=='+')
			end = i-1;
		if(mName[i]==':'){
			return mName.substr(i+1, end-i);
		}
	}
	return "";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %edi
cmpl $0x4, %edi
jg 0xb269
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x28ef(%rip), %rdx      # 0xdb4b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4ce4
jmp 0xb2b4
leal -0x3(%rdi), %ecx
movq (%rsi), %rax
leal -0x2(%rdi), %edx
incq %rdx
movslq %ecx, %rcx
leal -0x4(%rdi), %r8d
testl %ecx, %ecx
js 0xb24e
movl %edi, %r9d
movl %ecx, %edi
movb (%rax,%rdi), %r10b
cmpb $0x2b, %r10b
movl %r9d, %edi
cmovel %r8d, %edi
decq %rdx
decq %rcx
decl %r8d
cmpb $0x3a, %r10b
jne 0xb27c
movslq %r9d, %rax
notq %rcx
addq %rax, %rcx
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/OpenGene[P]pecheck/src/read.cpp
// Function: Read::lowQualCount(int)
int Read::lowQualCount(int qual){
	int count = 0;
	for(int q=0;q<mQuality.size();q++){
		if(mQuality[q] < qual + 33)
			count++;
	}
	return count;
}

// Assembly:
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xb2e9
movq 0x60(%rdi), %rdx
addl $0x21, %esi
xorl %edi, %edi
xorl %eax, %eax
movsbl (%rdx,%rdi), %r8d
xorl %r9d, %r9d
cmpl %r8d, %esi
setg %r9b
addl %r9d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0xb2ce
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/OpenGene[P]pecheck/src/read.cpp
// Function: ReadPair::~ReadPair()
ReadPair::~ReadPair(){
	if(mLeft){
		delete mLeft;
		mLeft = NULL;
	}
	if(mRight){
		delete mRight;
		mRight = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xbb14
movq 0x60(%r14), %rdi
leaq 0x70(%r14), %rax
cmpq %rax, %rdi
je 0xbab9
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movq 0x40(%r14), %rdi
leaq 0x50(%r14), %rax
cmpq %rax, %rdi
je 0xbad1
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0xbae9
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xbb00
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movl $0x88, %esi
movq %r14, %rdi
callq 0x32d0
movq $0x0, (%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xbb91
movq 0x60(%r14), %rdi
leaq 0x70(%r14), %rax
cmpq %rax, %rdi
je 0xbb35
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movq 0x40(%r14), %rdi
leaq 0x50(%r14), %rax
cmpq %rax, %rdi
je 0xbb4d
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0xbb65
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xbb7c
movq (%rax), %rsi
incq %rsi
callq 0x32d0
movl $0x88, %esi
movq %r14, %rdi
callq 0x32d0
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/OpenGene[P]pecheck/src/sequence.cpp
// Function: Sequence::reverseComplement()
Sequence Sequence::reverseComplement(){
    string str(mStr.length(), 0);
    for(int c=0;c<mStr.length();c++){
        char base = mStr[c];
        switch(base){
            case 'A':
            case 'a':
                str[mStr.length()-c-1] = 'T';
                break;
            case 'T':
            case 't':
                str[mStr.length()-c-1] = 'A';
                break;
            case 'C':
            case 'c':
                str[mStr.length()-c-1] = 'G';
                break;
            case 'G':
            case 'g':
                str[mStr.length()-c-1] = 'C';
                break;
            default:
                str[mStr.length()-c-1] = 'N';
        }
    }
    return Sequence(str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x3350
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xca0c
movq $-0x1, %rcx
xorl %edx, %edx
movq (%r14), %rsi
movzbl (%rsi,%rdx), %edi
movb $0x54, %sil
cmpl $0x60, %edi
jg 0xc9c0
cmpl $0x46, %edi
jg 0xc9d4
cmpl $0x41, %edi
je 0xc9f5
cmpl $0x43, %edi
je 0xc9cf
jmp 0xc9de
cmpl $0x66, %edi
jg 0xc9e3
cmpl $0x61, %edi
je 0xc9f5
cmpl $0x63, %edi
jne 0xc9de
movb $0x47, %sil
jmp 0xc9f5
cmpl $0x47, %edi
je 0xc9f2
cmpl $0x54, %edi
je 0xc9ed
movb $0x4e, %sil
jmp 0xc9f5
cmpl $0x67, %edi
je 0xc9f2
cmpl $0x74, %edi
jne 0xc9de
movb $0x41, %sil
jmp 0xc9f5
movb $0x43, %sil
addq (%rsp), %rax
movb %sil, (%rcx,%rax)
incq %rdx
movq 0x8(%r14), %rax
decq %rcx
cmpq %rdx, %rax
ja 0xc9a0
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4d7a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xc90c
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xca4f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32d0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xca65
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0xca91
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0xca91
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xcaa7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0x3500
nop
// File: /workspace/github_c_makefile_star2_O3/mahrr[P]raven/src/compiler.c
// Function: error_header
static void error_header(Parser *parser, Token *where) {
    parser->panic_mode = true;
    parser->had_error = true;

    fprintf(stderr, "[%s: %d] SyntaxError",
            parser->lexer->file, where->line);

    if (where->type == TOKEN_EOF) {
        fprintf(stderr, " at end");
    } else if (where->type != TOKEN_ERROR) {
        fprintf(stderr, " at '%.*s'", where->length, where->lexeme);
    }

    fprintf(stderr, ": ");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movw $0x101, 0x48(%rdi)      # imm = 0x101
movq 0xdb3b(%rip), %r14      # 0xfff0
movq (%r14), %rax
movq (%rdi), %rcx
movq (%rcx), %rdx
movl 0x14(%rsi), %ecx
leaq 0x931e(%rip), %rsi      # 0xb7e6
movq %rax, %rdi
xorl %eax, %eax
callq 0x2140
movl (%rbx), %eax
cmpl $0x35, %eax
je 0x250d
cmpl $0x36, %eax
jne 0x24f5
movq (%r14), %rcx
leaq 0x9313(%rip), %rdi      # 0xb7fb
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2200
jmp 0x250d
movq (%r14), %rdi
movl 0x10(%rbx), %edx
movq 0x8(%rbx), %rcx
leaq 0x92fd(%rip), %rsi      # 0xb803
xorl %eax, %eax
callq 0x2140
movq (%r14), %rcx
leaq 0x9212(%rip), %rdi      # 0xb729
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r9
movq %rsi, %rbx
movq %rdi, %r14
movq 0xdab3(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movl 0x18(%rsi), %ecx
movq (%rsi), %rdx
movq 0x8(%rsi), %r8
leaq 0x993f(%rip), %rsi      # 0xbe90
xorl %eax, %eax
callq 0x2140
movl $0x35, (%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x14(%r14)
andq $0x0, 0x8(%r14)
andl $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x274e
cmpl $0x1, %edi
jne 0x286c
leaq 0x100(%rsp), %rdi
callq 0x289c
movq 0xd925(%rip), %r13      # 0xffc8
movq (%r13), %rsi
leaq 0x8956(%rip), %rdi      # 0xb004
callq 0x20f0
movq 0xd916(%rip), %rbp      # 0xffd0
movq (%rbp), %rdx
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2120
testq %rax, %rax
je 0x2741
leaq 0x8930(%rip), %rbx      # 0xb007
leaq 0x100(%rsp), %r14
movq %rsp, %r15
leaq 0x891b(%rip), %r12      # 0xb004
movq (%rbp), %rdi
callq 0x2160
testl %eax, %eax
jne 0x2741
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2b71
testl %eax, %eax
jne 0x271f
movq 0x150(%rsp), %rdi
callq 0x59b8
movl $0xa, %edi
callq 0x2040
movq (%r13), %rsi
movq %r12, %rdi
callq 0x20f0
movq (%rbp), %rdx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2120
testq %rax, %rax
jne 0x26e9
leaq 0x100(%rsp), %rdi
jmp 0x284b
movq 0x8(%rsi), %rbx
leaq 0x100(%rsp), %rdi
callq 0x289c
leaq 0x88a7(%rip), %rsi      # 0xb00d
movq %rbx, %rdi
callq 0x21c0
testq %rax, %rax
je 0x288c
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
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 0x2894
movq %rax, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2080
cmpq %r12, %rax
jb 0x2864
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2864
movq %r15, %rdi
callq 0x20a0
movb $0x0, (%r14,%r12)
leaq 0x100(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2b71
testl %eax, %eax
je 0x2825
movl %eax, %ebx
movq %r14, %rdi
callq 0x2030
leaq 0x100(%rsp), %rdi
callq 0x2b49
cmpl $0x1, %ebx
je 0x2882
cmpl $0x2, %ebx
jne 0x2850
jmp 0x2882
leaq 0x100(%rsp), %rbx
movq 0x50(%rbx), %rdi
callq 0x59b8
movl $0xa, %edi
callq 0x2040
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2b49
xorl %eax, %eax
addq $0x40d88, %rsp          # imm = 0x40D88
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x2240
movq 0xd755(%rip), %rax      # 0xffc8
movq (%rax), %rsi
leaq 0x87fb(%rip), %rdi      # 0xb078
callq 0x20f0
movl $0x1, %edi
callq 0x21f0
movq %rbx, %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x227c
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x40c80(%rdi)
movb $0x1, 0x40060(%rdi)
callq 0xa418
leaq 0x40c70(%rbx), %rdi
callq 0x4bf8
leaq 0x58(%rbx), %rax
movq %rax, 0x40058(%rbx)
movl $0x0, 0x40c68(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x28de
// File: /workspace/github_c_makefile_star2_O3/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 0x5a54
testq %rax, %rax
je 0x2c15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5308
movabsq $-0x4000000000000, %rdx # imm = 0xFFFC000000000000
orq %rax, %rdx
movq 0x40058(%rbx), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x40058(%rbx)
movq %rdx, (%rcx)
movslq 0x40c68(%rbx), %rdx
cmpq $0x80, %rdx
je 0x2c22
leal 0x1(%rdx), %esi
movl %esi, 0x40c68(%rbx)
leaq (%rdx,%rdx,2), %rdx
movq %rax, 0x40068(%rbx,%rdx,8)
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, 0x40070(%rbx,%rdx,8)
movq %rcx, 0x40078(%rbx,%rdx,8)
movq %r14, 0x48(%rbx)
movb $0x0, 0x40(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c35
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8790(%rip), %rsi      # 0xb3b9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22dc
jmp 0x2c01
// File: /workspace/github_c_makefile_star2_O3/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, %rax # imm = 0x7FFC000000000001
movq (%rsi), %r8
movq %rax, %rdi
cmpq $0x2, %rdx
jne 0x45b2
movq 0x8(%rsi), %rdi
movq %rdi, %rsi
shrq $0x32, %rsi
cmpl $0x3fff, %esi           # imm = 0x3FFF
jb 0x4600
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
andq %rdi, %rsi
cmpl $0x0, (%rsi)
jne 0x4600
cmpq %rax, %r8
je 0x45db
leaq 0x2(%rax), %rsi
cmpq %rsi, %r8
je 0x45cc
leaq 0x1(%rax), %rsi
andq %rsi, %r8
cmpq %rsi, %r8
je 0x45db
movq %rax, (%rcx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $0x2, %rdx
jne 0x461d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rdi
movq 0x18(%rdi), %rdx
leaq 0x6c4d(%rip), %rsi      # 0xb246
xorl %ebp, %ebp
movq %rbx, %rdi
jmp 0x4614
callq 0x4a12
leaq 0x6c06(%rip), %rsi      # 0xb212
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22dc
jmp 0x45d2
leaq 0x6c37(%rip), %rsi      # 0xb25b
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22dc
jmp 0x45d2
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rdx, %rdx
je 0x4666
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x59b8
movl $0x20, %edi
callq 0x2040
incq %r12
cmpq %r12, %r14
jne 0x464b
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4750
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rdi, %rax
movl (%rax), %edx
cmpl $0x3, %edx
je 0x4715
cmpl $0x2, %edx
je 0x4720
testl %edx, %edx
jne 0x4750
cvtsi2sdl 0x10(%rax), %xmm0
jmp 0x471a
cvtsi2sdl 0x18(%rax), %xmm0
movsd %xmm0, (%rcx)
jmp 0x4744
movsd 0x18(%rax), %xmm0
unpcklps 0x6964(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x696c(%rip), %xmm0     # 0xb0a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4a12
leaq 0x6b10(%rip), %rsi      # 0xb26c
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22dc
jmp 0x4747
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x483f
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
andq %rdi, %rbp
cmpl $0x2, (%rbp)
jne 0x483f
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x2, %rdx
jb 0x481e
movq %rsi, %r13
movq 0x10(%rbp), %rax
movl $0x1, %r14d
movl $0x8, %r15d
movq 0x18(%rbp), %rdx
cmpq 0x20(%rbp), %rdx
jne 0x4805
leaq (%rdx,%rdx), %rcx
cmpq $0x8, %rdx
cmovbq %r15, %rcx
movq %rcx, 0x20(%rbp)
shlq $0x3, %rdx
shlq $0x3, %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa554
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
cmpq %r14, %r12
jne 0x47d0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4a12
leaq 0x6a43(%rip), %rsi      # 0xb28e
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22dc
jmp 0x482e
// File: /workspace/github_c_makefile_star2_O3/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 0x48ae
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rdi, %rax
cmpl $0x2, (%rax)
jne 0x48ae
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x48cb
movq 0x10(%rax), %rsi
leaq -0x1(%rdx), %rdi
movq %rdi, 0x18(%rax)
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, (%rcx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4a12
leaq 0x6a03(%rip), %rsi      # 0xb2bd
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22dc
jmp 0x48a5
leaq 0x6a08(%rip), %rsi      # 0xb2da
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22dc
jmp 0x48a5
// File: /workspace/github_c_makefile_star2_O3/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 0x4946
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
movq %rcx, %rdi
andq %rax, %rdi
cmpl $0x3, (%rdi)
jne 0x4946
movabsq $-0x4000000000001, %rdx # imm = 0xFFFBFFFFFFFFFFFF
movq 0x8(%rsi), %rcx
cmpq %rdx, %rcx
jbe 0x4957
andq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x4957
movq 0x10(%rsi), %rbx
addq $0x10, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x4c93
movq %rbx, (%r14)
movb $0x1, %bpl
jmp 0x4975
movq %rcx, %rdi
callq 0x4a12
leaq 0x699d(%rip), %rsi      # 0xb2f2
jmp 0x4966
movq %rcx, %rdi
callq 0x4a12
leaq 0x69bc(%rip), %rsi      # 0xb322
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22dc
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49dc
movq %rsi, %rax
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
movq %rcx, %rdi
andq %rsi, %rdi
cmpl $0x3, (%rdi)
jne 0x49dc
movabsq $-0x4000000000001, %rcx # imm = 0xFFFBFFFFFFFFFFFF
movq 0x8(%rax), %rax
cmpq %rcx, %rax
jbe 0x49ed
andq %rax, %rsi
cmpl $0x0, (%rsi)
jne 0x49ed
addq $0x10, %rdi
callq 0x4e1e
movq %rax, (%r14)
movb $0x1, %bpl
jmp 0x4a0b
movq %rcx, %rdi
callq 0x4a12
leaq 0x696b(%rip), %rsi      # 0xb356
jmp 0x49fc
movq %rax, %rdi
callq 0x4a12
leaq 0x6989(%rip), %rsi      # 0xb385
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22dc
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4a2d
leaq 0x6772(%rip), %rax      # 0xb19e
retq
leaq 0x2(%rax), %rdx
movq %rdi, %rcx
notq %rcx
testq %rcx, %rdx
jne 0x4a44
leaq 0x675f(%rip), %rax      # 0xb1a2
retq
testq %rcx, %rax
jne 0x4a85
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x4a8d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rdi
movl (%rdi), %eax
cmpq $0x8, %rax
jae 0x4a8d
movl $0xdf, %ecx
btl %eax, %ecx
jae 0x4a8d
leaq 0x6b6f(%rip), %rcx      # 0xb5ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x671e(%rip), %rax      # 0xb1aa
retq
pushq %rax
leaq 0x6735(%rip), %rdi      # 0xb1ca
leaq 0x6750(%rip), %rsi      # 0xb1ec
leaq 0x6752(%rip), %rcx      # 0xb1f5
movl $0x20, %edx
callq 0x20e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %ecx
cmpl 0x4(%rdi), %ecx
jne 0x4b27
leal (%rcx,%rcx), %eax
cmpl $0x8, %ecx
movl $0x8, %esi
cmovgel %eax, %esi
movl %esi, 0x4(%r14)
movq 0x8(%r14), %rdi
callq 0x21b0
movq %rax, 0x8(%r14)
movl (%r14), %ecx
jmp 0x4b2b
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 0x4b4b
movq 0x18(%r14), %rax
cmpl %ebx, -0x8(%rax,%rcx,8)
je 0x4b94
cmpl 0x14(%r14), %ecx
jne 0x4b7a
leal (%rcx,%rcx), %eax
cmpl $0x8, %ecx
movl $0x8, %esi
cmovgel %eax, %esi
movl %esi, 0x14(%r14)
movq 0x18(%r14), %rdi
shlq $0x3, %rsi
callq 0x21b0
movq %rax, 0x18(%r14)
movl 0x10(%r14), %ecx
jmp 0x4b7e
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)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %eax
decl %eax
movq 0x18(%rdi), %rcx
xorl %edi, %edi
movl %eax, %edx
leal (%rdi,%rdx), %r9d
movl %r9d, %r8d
shrl $0x1f, %r8d
addl %r9d, %r8d
sarl %r8d
movslq %r8d, %r9
cmpl %esi, 0x4(%rcx,%r9,8)
jg 0x4beb
cmpl %eax, %r8d
je 0x4bf3
incl %r8d
movl %r8d, %edi
cmpl %esi, 0xc(%rcx,%r9,8)
jle 0x4bbc
jmp 0x4bf3
decl %r8d
movl %r8d, %edx
jmp 0x4bbc
movl (%rcx,%r9,8), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c90
movq (%rdi), %rax
movl 0xc(%rdi), %edi
movl 0x14(%rsi), %r8d
xorl %ecx, %ecx
movabsq $0x7ffc000000000001, %r9 # imm = 0x7FFC000000000001
andl %edi, %r8d
movq %r8, %r11
shlq $0x4, %r11
leaq (%rax,%r11), %r10
movq (%rax,%r11), %r11
testq %r11, %r11
je 0x4c6b
cmpq %rsi, %r11
jne 0x4c78
jmp 0x4c86
testq %rcx, %rcx
cmoveq %r10, %rcx
cmpq %r9, 0x8(%r10)
je 0x4c7d
incl %r8d
jmp 0x4c4d
cmpq $0x0, (%rcx)
movq %rcx, %r10
je 0x4c90
movq 0x8(%r10), %rax
movq %rax, (%rdx)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x7ffc000000000001, %r13 # imm = 0x7FFC000000000001
movl 0xc(%rdi), %ebx
leal 0x1(%rbx), %eax
cvtsi2sdl 0x8(%rdi), %xmm0
cvtsi2sd %eax, %xmm1
mulsd 0x6948(%rip), %xmm1     # 0xb610
ucomisd %xmm1, %xmm0
jae 0x4cd8
movq (%r15), %r12
movl %ebx, %ebp
jmp 0x4db7
movq %rdx, 0x10(%rsp)
cmpl $0x7, %ebx
movq %rax, 0x8(%rsp)
leal -0x1(%rax,%rax), %eax
movl $0x7, %ebp
cmovgel %eax, %ebp
movslq %ebp, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
callq 0x2180
movq %rax, %r12
testl %ebp, %ebp
js 0x4d29
leal 0x1(%rbp), %eax
movl %eax, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
movq $0x0, (%r12,%rcx)
movq %r13, 0x8(%r12,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4d13
movl $0x0, 0x8(%r15)
movq (%r15), %rdi
testl %ebx, %ebx
js 0x4da6
movl 0x8(%rsp), %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq %rdx, %rsi
shlq $0x4, %rsi
movq (%rdi,%rsi), %r8
testq %r8, %r8
je 0x4d9e
addq %rdi, %rsi
movl 0x14(%r8), %r9d
xorl %r10d, %r10d
andl %ebp, %r9d
movq %r9, %rbx
shlq $0x4, %rbx
leaq (%r12,%rbx), %r11
movq (%r12,%rbx), %rbx
testq %rbx, %rbx
je 0x4d78
cmpq %r8, %rbx
jne 0x4d88
jmp 0x4d8d
testq %r10, %r10
cmoveq %r11, %r10
cmpq %r13, 0x8(%r11)
movq %r10, %r11
je 0x4d8d
incl %r9d
jmp 0x4d5a
movq %r8, (%r11)
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%r11)
incl %ecx
movl %ecx, 0x8(%r15)
incq %rdx
cmpq %rax, %rdx
jne 0x4d40
callq 0x2030
movq %r12, (%r15)
movl %ebp, 0xc(%r15)
movq 0x10(%rsp), %rdx
movl 0x14(%r14), %eax
xorl %ecx, %ecx
andl %ebp, %eax
movq %rax, %rsi
shlq $0x4, %rsi
leaq (%r12,%rsi), %rdi
movq (%r12,%rsi), %rsi
testq %rsi, %rsi
je 0x4dda
cmpq %r14, %rsi
jne 0x4de7
jmp 0x4deb
testq %rcx, %rcx
cmoveq %rdi, %rcx
cmpq %r13, 0x8(%rdi)
je 0x4def
incl %eax
jmp 0x4dbd
xorl %eax, %eax
jmp 0x4e08
cmpq $0x0, (%rcx)
je 0x4df9
xorl %eax, %eax
jmp 0x4e05
movb $0x1, %al
cmpq %r13, 0x8(%rcx)
jne 0x4e05
incl 0x8(%r15)
movq %rcx, %rdi
movq %r14, (%rdi)
movq %rdx, 0x8(%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpl $0x0, 0x8(%rdi)
je 0x4e88
movq (%rdi), %rcx
movl 0xc(%rdi), %edi
movl 0x14(%rsi), %r8d
xorl %edx, %edx
andl %edi, %r8d
movq %r8, %r10
shlq $0x4, %r10
leaq (%rcx,%r10), %r9
movq (%rcx,%r10), %r10
testq %r10, %r10
je 0x4e58
cmpq %rsi, %r10
jne 0x4e65
jmp 0x4e73
testq %rdx, %rdx
cmoveq %r9, %rdx
cmpq %rax, 0x8(%r9)
je 0x4e6a
incl %r8d
jmp 0x4e3a
cmpq $0x0, (%rdx)
movq %rdx, %r9
je 0x4e88
movq 0x8(%r9), %rcx
movq $0x0, (%r9)
incq %rax
movq %rax, 0x8(%r9)
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0xc(%rdi), %eax
testl %eax, %eax
js 0x4ee2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x1, %r15
movl $0x8, %r12d
movq (%r14), %rcx
movq -0x8(%rcx,%r12), %rsi
testq %rsi, %rsi
je 0x4ec8
movq (%rcx,%r12), %rdx
movq %rbx, %rdi
callq 0x4c93
movl 0xc(%r14), %eax
movslq %eax, %rcx
incq %r15
addq $0x10, %r12
cmpq %rcx, %r15
jl 0x4eab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f6e
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 0x4f5d
cmpl %ebx, 0x10(%r12)
jne 0x4f66
cmpl %edx, 0x14(%r12)
jne 0x4f66
movq 0x18(%r12), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2190
movl 0x4(%rsp), %edx
testl %eax, %eax
jne 0x4f66
jmp 0x4f71
addq %r15, %rax
cmpq %rbp, 0x8(%rax)
je 0x4f6e
incl %r13d
andl %r14d, %r13d
jmp 0x4f21
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_O3/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:
movl 0xc(%rdi), %eax
testl %eax, %eax
js 0x4fcd
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $-0x1, %r14
xorl %r15d, %r15d
movq (%rbx), %rcx
movq (%rcx,%r15), %rsi
testq %rsi, %rsi
je 0x4fb9
cmpb $0x0, 0x4(%rsi)
jne 0x4fb9
movq %rbx, %rdi
callq 0x4e1e
movl 0xc(%rbx), %eax
movslq %eax, %rcx
incq %r14
addq $0x10, %r15
cmpq %rcx, %r14
jl 0x4f9c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
testl %edx, %edx
jle 0x5007
movl %ebx, %eax
movl $0x811c9dc5, %ebp       # imm = 0x811C9DC5
xorl %ecx, %ecx
movsbl (%r15,%rcx), %edx
xorl %ebp, %edx
imull $0x1000193, %edx, %ebp  # imm = 0x1000193
incq %rcx
cmpq %rcx, %rax
jne 0x4ff0
jmp 0x500c
movl $0x811c9dc5, %ebp       # imm = 0x811C9DC5
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x4ee3
testq %rax, %rax
je 0x502f
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 0xa554
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 0x5074
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa554
movq %rax, %r12
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq 0x10(%r15), %rax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r15)
movl %r14d, 0x10(%r12)
movl %ebp, 0x14(%r12)
movq %rbx, 0x18(%r12)
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c93
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testl %edx, %edx
jle 0x5115
movl %ebp, %eax
movl $0x811c9dc5, %r15d      # imm = 0x811C9DC5
xorl %ecx, %ecx
movsbl (%rbx,%rcx), %edx
xorl %r15d, %edx
imull $0x1000193, %edx, %r15d # imm = 0x1000193
incq %rcx
cmpq %rcx, %rax
jne 0x50fd
jmp 0x511b
movl $0x811c9dc5, %r15d      # imm = 0x811C9DC5
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x4ee3
testq %rax, %rax
je 0x5151
movq %rax, %r12
incl %ebp
movslq %ebp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xa554
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5074
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl $0x28, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa554
movq %rax, %r12
movl $0x2, (%rax)
movq 0x10(%r15), %rax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r15)
movb $0x1, 0x4(%r12)
leaq (,%r14,8), %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
callq 0xa554
movq %rax, 0x10(%r12)
movb $0x0, 0x4(%r12)
movq %r14, 0x18(%r12)
movq %r14, 0x20(%r12)
movq %rax, %rdi
movq %rbx, %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_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x850, %ecx            # imm = 0x850
xorl %esi, %esi
xorl %edx, %edx
callq 0xa554
movq %rax, %r14
movl $0x4, (%rax)
movb $0x0, 0x4(%rax)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x10(%rbx)
leaq 0x20(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
callq 0x4ab0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa554
movq %rax, 0x10(%rbx)
movslq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
callq 0x50df
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x59f1
leaq 0x2(%rax), %rdx
testq %rcx, %rdx
jne 0x5a04
addq $0x3, %rax
cmpq %rax, %rdi
leaq 0x5cce(%rip), %rax      # 0xb6b2
leaq 0x5ccc(%rip), %rdi      # 0xb6b7
cmoveq %rax, %rdi
jmp 0x5a13
movq %rdi, %xmm0
leaq 0x5cc0(%rip), %rdi      # 0xb6bd
movb $0x1, %al
jmp 0x20b0
incq %rax
cmpq %rax, %rdi
jne 0x5a1a
leaq 0x578b(%rip), %rdi      # 0xb19e
xorl %eax, %eax
jmp 0x20b0
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jae 0x53c3
pushq %rax
leaq 0x5d04(%rip), %rdi      # 0xb738
leaq 0x5d13(%rip), %rsi      # 0xb74e
leaq 0x5d18(%rip), %rcx      # 0xb75a
movl $0x1e, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x22b8, %rsp           # imm = 0x22B8
movq %rdi, %r14
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0x940c
leaq 0x38(%rsp), %r12
movq %r15, -0x30(%r12)
movq $0x0, -0x28(%r12)
movq %r14, -0x20(%r12)
movw $0x0, 0x18(%r12)
movq $-0x1, 0x1c(%r12)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x941f
movl 0x20(%rsp), %ebp
cmpl $0x35, %ebp
je 0x5aa3
leaq 0x98(%rsp), %r15
movq $0x0, (%r15)
movq %r15, 0x10(%rsp)
movb $0x1, 0x10(%r15)
xorl %r13d, %r13d
movl %r13d, 0x2018(%r15)
movl %r13d, 0x221c(%r15)
movq %r14, %rdi
callq 0x526e
movq %rax, 0x8(%r15)
movslq 0x2018(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2018(%r15)
shlq $0x5, %rax
movl %r13d, 0xc8(%rsp,%rax)
leaq 0x5546(%rip), %rcx      # 0xb057
movq %rcx, 0xb8(%rsp,%rax)
movl %r13d, 0xc0(%rsp,%rax)
movb $0x0, 0xcc(%rsp,%rax)
cmpl $0x36, %ebp
je 0x5b42
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5bb5
cmpl $0x36, 0x20(%rsp)
jne 0x5b33
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r12)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
leaq 0x60(%rsp), %r14
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x941f
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x60(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpl $0x35, 0x20(%rsp)
je 0x5b58
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rbx
movl 0x4c(%rsp), %edx
leaq 0x20(%rbx), %rdi
movl $0x35, %esi
callq 0x4af1
xorl %eax, %eax
cmpb $0x0, 0x50(%rsp)
cmoveq %rbx, %rax
addq $0x22b8, %rsp           # imm = 0x22B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mahrr[P]raven/src/compiler.c
// Function: variable
static uint8_t variable(Parser *parser, const char *error) {
    consume(parser, TOKEN_IDENTIFIER, error);

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
cmpl $0x2f, 0x18(%rdi)
jne 0x5fd8
movq 0x10(%r14), %rax
movq %rax, 0x40(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movq %rsp, %r15
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x941f
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movups (%rsp), %xmm0
movups %xmm0, (%r14)
cmpl $0x35, 0x18(%rbx)
je 0x5fb4
jmp 0x5fe6
movq %rsi, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61ef
movq 0x8(%rbx), %r12
cmpl $0x0, 0x221c(%r12)
jle 0x60a6
leaq 0x30(%rbx), %r14
movslq 0x2018(%r12), %rax
testq %rax, %rax
jle 0x60d6
leaq 0x1(%rax), %r13
shlq $0x5, %rax
leaq (%rax,%r12), %rbp
addq $0x10, %rbp
leaq 0x57a8(%rip), %r15      # 0xb7cd
movl (%rbp), %eax
cmpl $-0x1, %eax
je 0x606c
cmpl 0x221c(%r12), %eax
jl 0x606c
movslq 0x40(%rbx), %rdx
cmpl -0x8(%rbp), %edx
jne 0x605f
movq 0x38(%rbx), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
testl %eax, %eax
jne 0x605f
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x61ef
decq %r13
addq $-0x20, %rbp
cmpq $0x1, %r13
ja 0x6025
movq 0x8(%rbx), %r12
movl 0x2018(%r12), %eax
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
cmpl $0x100, %eax            # imm = 0x100
jne 0x60e7
leaq 0x5777(%rip), %rsi      # 0xb80e
movq %rbx, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x621b
jmp 0x611b
movq 0x10(%rbx), %rdi
movq 0x38(%rbx), %rsi
movl 0x40(%rbx), %edx
callq 0x4fd0
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rdi
addq $0x20, %rdi
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x4b99
jmp 0x611d
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
leal 0x1(%rax), %ecx
movl %ecx, 0x2018(%r12)
cltq
shlq $0x5, %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%r12,%rax)
movaps (%rsp), %xmm0
movups %xmm0, 0x18(%r12,%rax)
movl $0xffffffff, 0x30(%r12,%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x34(%r12,%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq