LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenGene[P]pecheck/src/read.cpp
// Function: Read::toString[abi:cxx11](bool)
string Read::toString(bool lineBreak) {
	if(lineBreak)
		return mName + "\n" + mSeq.mStr + "\n" + mStrand + "\n" + mQuality + "\n";
	else 
		return mName + mSeq.mStr + mStrand + mQuality;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x18(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
andb $0x1, %al
movb %al, 0x147(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x147(%rsp)
je 0x13403
movq 0x28(%rsp), %rsi
leaq 0x3ad6(%rip), %rdx      # 0x16d0c
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x102a0
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rsi
addq $0x20, %rdx
leaq 0xa0(%rsp), %rdi
callq 0xf270
jmp 0x13265
leaq 0x3aa0(%rip), %rdx      # 0x16d0c
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xceb0
jmp 0x13283
movq 0x28(%rsp), %rdx
addq $0x40, %rdx
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xf270
jmp 0x132a3
leaq 0x3a62(%rip), %rdx      # 0x16d0c
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xceb0
jmp 0x132c1
movq 0x28(%rsp), %rdx
addq $0x60, %rdx
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0xf270
jmp 0x132e1
movq 0x18(%rsp), %rdi
leaq 0x3a1f(%rip), %rdx      # 0x16d0c
leaq 0x120(%rsp), %rsi
callq 0xceb0
jmp 0x132fc
leaq 0x120(%rsp), %rdi
callq 0x4758
leaq 0x100(%rsp), %rdi
callq 0x4758
leaq 0xe0(%rsp), %rdi
callq 0x4758
leaq 0xc0(%rsp), %rdi
callq 0x4758
leaq 0xa0(%rsp), %rdi
callq 0x4758
leaq 0x80(%rsp), %rdi
callq 0x4758
jmp 0x1349c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x133f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x133e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x133d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x133ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x133bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x4758
leaq 0x100(%rsp), %rdi
callq 0x4758
leaq 0xe0(%rsp), %rdi
callq 0x4758
leaq 0xc0(%rsp), %rdi
callq 0x4758
leaq 0xa0(%rsp), %rdi
callq 0x4758
leaq 0x80(%rsp), %rdi
callq 0x4758
jmp 0x134a9
movq 0x28(%rsp), %rsi
movq %rsi, %rdx
addq $0x20, %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x149f0
movq 0x28(%rsp), %rdx
movq 0x8(%rsp), %rsi
addq $0x40, %rdx
leaq 0x50(%rsp), %rdi
callq 0xf270
jmp 0x13438
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq $0x60, %rdx
leaq 0x50(%rsp), %rsi
callq 0xf270
jmp 0x13452
leaq 0x50(%rsp), %rdi
callq 0x4758
leaq 0x30(%rsp), %rdi
callq 0x4758
jmp 0x1349c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x13490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4758
leaq 0x30(%rsp), %rdi
callq 0x4758
jmp 0x134a9
movq 0x20(%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
movq 0x78(%rsp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenGene[P]pecheck/src/read.cpp
// Function: Read::test()
bool Read::test(){
	Read r("@NS500713:64:HFKJJBGXY:1:11101:20469:1097 1:N:0:TATAGCCT+GGTCCCGA",
		"CTCTTGGACTCTAACACTGTTTTTTCTTATGAAAACACAGGAGTGATGACTAGTTGAGTGCATTCTTATGAGACTCATAGTCATTCTATGATGTAGTTTTCCTTAGGAGGACATTTTTTACATGAAATTATTAACCTAAATAGAGTTGATC",
		"+",
		"AAAAA6EEEEEEEEEEEEEEEEE#EEEEEEEEEEEEEEEEE/EEEEEEEEEEEEEEEEAEEEAEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE<EEEEAEEEEEEEEEEEEEEEAEEE/EEEEEEEEEEAAEAEAAEEEAEEAA");
	string idx = r.lastIndex();
	return idx == "GGTCCCGA";
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
leaq 0xdf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x46b0
movq 0x28(%rsp), %rdx
leaq 0x32e9(%rip), %rsi      # 0x167ce
leaq 0xe0(%rsp), %rdi
callq 0x67f0
jmp 0x134f4
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x46b0
movq 0x20(%rsp), %rdx
leaq 0x32fe(%rip), %rsi      # 0x16810
leaq 0xa8(%rsp), %rdi
callq 0x67f0
jmp 0x13521
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x46b0
movq 0x18(%rsp), %rdx
leaq 0x3290(%rip), %rsi      # 0x167cc
leaq 0x80(%rsp), %rdi
callq 0x67f0
jmp 0x1354b
leaq 0x57(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x46b0
movq 0x10(%rsp), %rdx
leaq 0x3342(%rip), %rsi      # 0x168a8
leaq 0x58(%rsp), %rdi
callq 0x67f0
jmp 0x13572
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0x80(%rsp), %rcx
leaq 0x58(%rsp), %r8
xorl %r9d, %r9d
callq 0x11e30
jmp 0x135a1
leaq 0x58(%rsp), %rdi
callq 0x4758
leaq 0x57(%rsp), %rdi
callq 0x43e0
leaq 0x80(%rsp), %rdi
callq 0x4758
leaq 0x7f(%rsp), %rdi
callq 0x43e0
leaq 0xa8(%rsp), %rdi
callq 0x4758
leaq 0xa7(%rsp), %rdi
callq 0x43e0
leaq 0xe0(%rsp), %rdi
callq 0x4758
leaq 0xdf(%rsp), %rdi
callq 0x43e0
leaq 0x30(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x12e70
jmp 0x13614
leaq 0x31ec(%rip), %rsi      # 0x16807
leaq 0x30(%rsp), %rdi
callq 0x68b0
movb %al, 0xf(%rsp)
jmp 0x1362b
leaq 0x30(%rsp), %rdi
callq 0x4758
leaq 0x100(%rsp), %rdi
callq 0x6b10
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x188, %rsp            # imm = 0x188
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x13711
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x136f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x136e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x136c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4758
leaq 0x57(%rsp), %rdi
callq 0x43e0
leaq 0x80(%rsp), %rdi
callq 0x4758
leaq 0x7f(%rsp), %rdi
callq 0x43e0
leaq 0xa8(%rsp), %rdi
callq 0x4758
leaq 0xa7(%rsp), %rdi
callq 0x43e0
leaq 0xe0(%rsp), %rdi
callq 0x4758
leaq 0xdf(%rsp), %rdi
callq 0x43e0
jmp 0x13761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x13754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4758
leaq 0x100(%rsp), %rdi
callq 0x6b10
movq 0xd0(%rsp), %rdi
callq 0x46a0
nop
// File: /workspace/github_c_makefile_star2_O0/OpenGene[P]pecheck/src/read.cpp
// Function: ReadPair::~ReadPair()
ReadPair::~ReadPair(){
	if(mLeft){
		delete mLeft;
		mLeft = NULL;
	}
	if(mRight){
		delete mRight;
		mRight = NULL;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0x137f1
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x137e5
movq 0x10(%rsp), %rdi
callq 0x6b10
movq 0x10(%rsp), %rdi
movl $0x88, %esi
callq 0x4370
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13837
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1382a
movq 0x8(%rsp), %rdi
callq 0x6b10
movq 0x8(%rsp), %rdi
movl $0x88, %esi
callq 0x4370
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenGene[P]pecheck/src/sequence.cpp
// Function: Sequence::test()
bool Sequence::test(){
    Sequence s("AAAATTTTCCCCGGGG");
    Sequence rc = ~s;
    if (s.mStr != "AAAATTTTCCCCGGGG" ){
        cerr << "Failed in reverseComplement() expect AAAATTTTCCCCGGGG, but get "<< s.mStr;
        return false;
    }
    if (rc.mStr != "CCCCGGGGAAAATTTT" ){
        cerr << "Failed in reverseComplement() expect CCCCGGGGAAAATTTT, but get "<< rc.mStr;
        return false;
    }
    return true;
}

// Assembly:
subq $0xb8, %rsp
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x46b0
movq 0x28(%rsp), %rdx
leaq 0x143a(%rip), %rsi      # 0x16c3c
leaq 0x70(%rsp), %rdi
callq 0x67f0
jmp 0x1580e
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x15430
jmp 0x15822
leaq 0x70(%rsp), %rdi
callq 0x4758
leaq 0x6f(%rsp), %rdi
callq 0x43e0
leaq 0x38(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x157b0
jmp 0x1584a
leaq 0x13eb(%rip), %rsi      # 0x16c3c
leaq 0x90(%rsp), %rdi
callq 0x14a80
movb %al, 0x27(%rsp)
jmp 0x15864
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x15871
jmp 0x1591b
movq 0x8778(%rip), %rdi      # 0x1dff0
leaq 0x13ce(%rip), %rsi      # 0x16c4d
callq 0x4340
movq %rax, 0x18(%rsp)
jmp 0x1588b
movq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x42f0
jmp 0x1589f
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0x15989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x158dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4758
leaq 0x6f(%rsp), %rdi
callq 0x43e0
jmp 0x159be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x159b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6f80
jmp 0x159b1
leaq 0x136b(%rip), %rsi      # 0x16c8d
leaq 0x38(%rsp), %rdi
callq 0x14a80
movb %al, 0x17(%rsp)
jmp 0x15932
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1593c
jmp 0x15979
movq 0x86ad(%rip), %rdi      # 0x1dff0
leaq 0x1354(%rip), %rsi      # 0x16c9e
callq 0x4340
movq %rax, 0x8(%rsp)
jmp 0x15956
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x42f0
jmp 0x15967
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0x15989
movb $0x1, 0xb7(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6f80
leaq 0x90(%rsp), %rdi
callq 0x6f80
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x6f80
movq 0x60(%rsp), %rdi
callq 0x46a0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x2343
callq 0x2420
jmp 0x235f
cmpl $0x2, -0x8(%rbp)
jne 0x2358
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2370
jmp 0x235d
callq 0x2650
jmp 0x235f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/raven.c
// Function: execute_file
static void execute_file(const char *path) {
    VM vm;
    init_vm(&vm);

    char *source = scan_file(path);
    InterpretResult result = interpret(&vm, source, path);
    if (result == INTERPRET_OK) {
        value_print(vm.x);
        putchar('\n');
    }

    free(source);
    free_vm(&vm);

    if (result == INTERPRET_RUNTIME_ERROR) exit(EXIT_FAILURE);
    if (result == INTERPRET_COMPILE_ERROR) exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40ca0, %rsp          # imm = 0x40CA0
movq %rdi, -0x8(%rbp)
leaq -0x40c90(%rbp), %rdi
callq 0x2680
movq -0x8(%rbp), %rdi
callq 0x24e0
movq %rax, -0x40c98(%rbp)
movq -0x40c98(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x40c90(%rbp), %rdi
callq 0x2af0
movl %eax, -0x40c9c(%rbp)
cmpl $0x0, -0x40c9c(%rbp)
jne 0x23d7
movq -0x40c40(%rbp), %rdi
callq 0x88b0
movl $0xa, %edi
callq 0x2040
movq -0x40c98(%rbp), %rdi
callq 0x2030
leaq -0x40c90(%rbp), %rdi
callq 0x2a80
cmpl $0x2, -0x40c9c(%rbp)
jne 0x2402
movl $0x1, %edi
callq 0x21f0
cmpl $0x1, -0x40c9c(%rbp)
jne 0x2415
movl $0x1, %edi
callq 0x21f0
addq $0x40ca0, %rsp          # imm = 0x40CA0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/raven.c
// Function: repl
static void repl() {
    VM vm;
    init_vm(&vm);

    char buf[256];
    for (;;) {
        fputs("> ", stdout);
        if (!fgets(buf, 256, stdin) || feof(stdin)) {
            break;
        }
        InterpretResult result = interpret(&vm, buf, "stdin");
        if (result == INTERPRET_OK) {
            value_print(vm.x);
            putchar('\n');
        }
    }

    free_vm(&vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40da0, %rsp          # imm = 0x40DA0
leaq -0x40c88(%rbp), %rdi
callq 0x2680
movq 0x10b92(%rip), %rax     # 0x12fd0
movq (%rax), %rsi
leaq 0xbbbc(%rip), %rdi      # 0xe004
callq 0x20f0
leaq -0x40d90(%rbp), %rdi
movq 0x10b7d(%rip), %rax     # 0x12fd8
movq (%rax), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2130
cmpq $0x0, %rax
je 0x2482
movq 0x10b63(%rip), %rax     # 0x12fd8
movq (%rax), %rdi
callq 0x2170
cmpl $0x0, %eax
je 0x2484
jmp 0x24c8
leaq -0x40d90(%rbp), %rsi
leaq -0x40c88(%rbp), %rdi
leaq 0xbb6e(%rip), %rdx      # 0xe007
callq 0x2af0
movl %eax, -0x40d94(%rbp)
cmpl $0x0, -0x40d94(%rbp)
jne 0x24c3
movq -0x40c38(%rbp), %rdi
callq 0x88b0
movl $0xa, %edi
callq 0x2040
jmp 0x2437
leaq -0x40c88(%rbp), %rdi
callq 0x2a80
addq $0x40da0, %rsp          # imm = 0x40DA0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/raven.c
// Function: scan_file
static char *scan_file(const char *path) {
    FILE *file = fopen(path, "rb");
    if (file == NULL) {
        fprintf(stderr, "Fatal: error openning '%s' (%s)\n", path, strerror(errno));
        exit(EXIT_FAILURE);
    }

    fseek(file, 0L, SEEK_END);
    size_t size = ftell(file);
    rewind(file);

    char *buf = (char *)malloc(size + 1);
    if (buf == NULL) {
        fprintf(stderr, "Fatal: not enough memory to scan '%s'\n", path);
        exit(EXIT_FAILURE);
    }

    size_t bytes_read = fread(buf, sizeof (char), size, file);
    if (bytes_read < size || ferror(file)) {
        fprintf(stderr, "Fatal: error reading '%s' (%s)\n", path, strerror(errno));
        exit(EXIT_FAILURE);
    }

    fclose(file);

    buf[size] = '\0';
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbb16(%rip), %rsi      # 0xe00d
callq 0x21c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x254c
movq 0x10aea(%rip), %rax     # 0x12ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x2200
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xbad5(%rip), %rsi      # 0xe010
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x21f0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21a0
movq -0x10(%rbp), %rdi
callq 0x2160
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x2190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x25b2
movq 0x10a65(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xba90(%rip), %rsi      # 0xe031
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x21f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x2070
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x25e4
movq -0x10(%rbp), %rdi
callq 0x2060
cmpl $0x0, %eax
je 0x2629
movq 0x10a0d(%rip), %rax     # 0x12ff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x2200
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0xba40(%rip), %rsi      # 0xe058
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x21f0
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x40c80(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x40060(%rax)
movq -0x8(%rbp), %rdi
callq 0xd4e0
movq -0x8(%rbp), %rdi
addq $0x40c70, %rdi          # imm = 0x40C70
callq 0x7260
movq -0x8(%rbp), %rdi
callq 0x26e0
movq -0x8(%rbp), %rdi
callq 0x2710
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x40(%rax)
movq -0x10(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x89f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2b43
movl $0x1, -0x4(%rbp)
jmp 0x2b9d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7ce0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x2bb0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x2be0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x2ca0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x80, 0x40c68(%rax)
jne 0x2c1b
movq -0x10(%rbp), %rdi
leaq 0xb7ab(%rip), %rsi      # 0xe3b9
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x2c92
movq -0x10(%rbp), %rax
addq $0x40068, %rax          # imm = 0x40068
movq -0x10(%rbp), %rdx
movl 0x40c68(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x40c68(%rdx)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40058(%rax), %rcx
movslq -0x1c(%rbp), %rdx
xorl %eax, %eax
subq %rdx, %rax
shlq $0x3, %rax
addq %rax, %rcx
addq $-0x8, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, -0x38(%rbp)
cmpq $0x2, -0x20(%rbp)
jne 0x5eb7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5eb5
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6790
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x836a(%rip), %rsi      # 0xe212
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x5f20
jmp 0x5eb7
movq -0x30(%rbp), %rdi
callq 0x6a40
testb $0x1, %al
jne 0x5ec6
jmp 0x5f0b
cmpq $0x2, -0x20(%rbp)
jne 0x5ef3
movq -0x10(%rbp), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x835c(%rip), %rsi      # 0xe246
movb $0x0, %al
callq 0x6630
jmp 0x5f05
movq -0x10(%rbp), %rdi
leaq 0x835d(%rip), %rsi      # 0xe25b
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x5f20
movq -0x28(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5f83
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x88b0
movl $0x20, %edi
callq 0x2040
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5f50
movq -0x20(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x65e0
testb $0x1, %al
jne 0x6054
jmp 0x607f
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x30(%rbp), %rax
cvtsi2sdl 0x10(%rax), %xmm0
callq 0x6ab0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6146
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x65e0
testb $0x1, %al
jne 0x6093
jmp 0x60e0
movq -0x30(%rbp), %rax
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movq 0x18(%rax), %xmm0
movaps 0x7fe0(%rip), %xmm1     # 0xe090
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x7fe4(%rip), %xmm1     # 0xe0a0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x6ab0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6146
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x65e0
testb $0x1, %al
jne 0x60f4
jmp 0x611c
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x30(%rbp), %rax
cvtsi2sdl 0x18(%rax), %xmm0
callq 0x6ab0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6146
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6790
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x8131(%rip), %rsi      # 0xe26c
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x61ca
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6790
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0x80d4(%rip), %rsi      # 0xe28e
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x62b8
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x62a9
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x626d
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x8, -0x48(%rbp)
jae 0x6222
movl $0x8, %eax
movq %rax, -0x60(%rbp)
jmp 0x622d
movq -0x48(%rbp), %rax
shlq %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x48(%rbp), %rdx
shlq $0x3, %rdx
movq -0x50(%rbp), %rcx
shlq $0x3, %rcx
callq 0xd7a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rsi
movq 0x18(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x18(%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x61e4
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6337
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6790
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x7f93(%rip), %rsi      # 0xe2bd
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x6397
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x636c
movq -0x10(%rbp), %rdi
leaq 0x7f7b(%rip), %rsi      # 0xe2da
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x6397
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rdx
movq 0x18(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x18(%rdx)
movq -0x8(%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x641a
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6790
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0x7ee8(%rip), %rsi      # 0xe2f2
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x64bb
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6479
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6790
movq -0x60(%rbp), %rdi
movq %rax, %rdx
leaq 0x7eb6(%rip), %rsi      # 0xe322
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x64bb
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x73f0
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x653a
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6790
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x7e2c(%rip), %rsi      # 0xe356
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x65ca
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x65e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6599
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6790
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0x7df9(%rip), %rsi      # 0xe385
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x65ca
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq -0x48(%rbp), %rsi
callq 0x7610
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x666e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x40c68(%rax), %ecx
decl %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x40068(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
notq %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movl -0x48(%rbp), %esi
callq 0x71c0
movl %eax, -0x4c(%rbp)
movq 0xc8e3(%rip), %rax      # 0x12ff8
movq %rax, -0x108(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdx
movl -0x4c(%rbp), %ecx
leaq 0x7a2c(%rip), %rsi      # 0xe15d
xorl %eax, %eax
callq 0x2150
movq -0x108(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x21d0
movq -0x108(%rbp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2140
movq -0x108(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rsi
callq 0x6930
movq -0x8(%rbp), %rdi
callq 0x26e0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, -0x10(%rbp)
jne 0x67bc
leaq 0x79eb(%rip), %rax      # 0xe19e
movq %rax, -0x8(%rbp)
jmp 0x6925
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
andq -0x10(%rbp), %rax
movabsq $0x7ffc000000000002, %rcx # imm = 0x7FFC000000000002
cmpq %rcx, %rax
jne 0x67e9
leaq 0x79c2(%rip), %rax      # 0xe1a2
movq %rax, -0x8(%rbp)
jmp 0x6925
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq -0x10(%rbp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x6816
leaq 0x799d(%rip), %rax      # 0xe1aa
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x65e0
testb $0x1, %al
jne 0x6827
jmp 0x6837
leaq 0x8609(%rip), %rax      # 0xee37
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x65e0
testb $0x1, %al
jne 0x684b
jmp 0x685b
leaq 0x795f(%rip), %rax      # 0xe1b1
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x65e0
testb $0x1, %al
jne 0x686f
jmp 0x687f
leaq 0x7a76(%rip), %rax      # 0xe2ec
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x65e0
testb $0x1, %al
jne 0x6893
jmp 0x68a3
leaq 0x791c(%rip), %rax      # 0xe1b6
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x65e0
testb $0x1, %al
jne 0x68b7
jmp 0x68c4
leaq 0x7903(%rip), %rax      # 0xe1c1
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x65e0
testb $0x1, %al
jne 0x68d8
jmp 0x68e5
leaq 0x78e2(%rip), %rax      # 0xe1c1
movq %rax, -0x8(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x65e0
testb $0x1, %al
jne 0x68f9
jmp 0x6906
leaq 0x78ba(%rip), %rax      # 0xe1ba
movq %rax, -0x8(%rbp)
jmp 0x6925
leaq 0x78bd(%rip), %rdi      # 0xe1ca
leaq 0x78d8(%rip), %rsi      # 0xe1ec
movl $0x20, %edx
leaq 0x78d5(%rip), %rcx      # 0xe1f5
callq 0x20e0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/vm.c
// Function: dump_stack_trace
static void dump_stack_trace(VM *vm, FILE *out) {
    fprintf(out, "stack traceback:\n");

    // TODO: an option to control the stack trace dumping order.
    for (int i = vm->frame_count - 1; i >= 0; i--) {
        CallFrame *frame = &vm->frames[i];
        RavFunction *function = frame->closure->function;

        size_t offset = frame->ip - function->chunk.opcodes - 1;
        int line = chunk_decode_line(&function->chunk, offset);

        fprintf(out, "\t%s | line:%d in ", vm->path, line);

        if (function->name == NULL) {
            fprintf(out, "<toplevel>\n");
        } else {
            fprintf(out, "'%s'\n", function->name->chars);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x7823(%rip), %rsi      # 0xe16e
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rax
movl 0x40c68(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6a2f
movq -0x8(%rbp), %rax
addq $0x40068, %rax          # imm = 0x40068
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0x71c0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdx
movl -0x34(%rbp), %ecx
leaq 0x77a5(%rip), %rsi      # 0xe180
movb $0x0, %al
callq 0x2150
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6a01
movq -0x10(%rbp), %rdi
leaq 0x779a(%rip), %rsi      # 0xe192
movb $0x0, %al
callq 0x2150
jmp 0x6a1f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
leaq 0x763a(%rip), %rsi      # 0xe052
movb $0x0, %al
callq 0x2150
jmp 0x6a21
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6962
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/vm.c
// Function: call_value
static bool call_value(VM *vm, Value value, int count) {
    if (Is_Closure(value)) {
        return call_closure(vm, As_Closure(value), count);
    }
    if (Is_CFunction(value)) {
        return call_cfunction(vm, As_CFunction(value), count);
    }

    runtime_error(vm, "call to a non-callable");
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x6, %esi
callq 0x65e0
testb $0x1, %al
jne 0x6b77
jmp 0x6b98
movq -0x10(%rbp), %rdi
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
andq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x6d60
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6be3
movq -0x18(%rbp), %rdi
movl $0x7, %esi
callq 0x65e0
testb $0x1, %al
jne 0x6bac
jmp 0x6bcd
movq -0x10(%rbp), %rdi
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
andq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x6dd0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6be3
movq -0x10(%rbp), %rdi
leaq 0x797d(%rip), %rsi      # 0xe555
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/vm.c
// Function: capture_upvalue
static RavUpvalue *capture_upvalue(VM *vm, Value *location) {
    RavUpvalue *previous = NULL;
    RavUpvalue *current = vm->open_upvalues;

    while (current != NULL && current->location > location) {
        previous = current;
        current = current->next;
    }

    if (current && current->location == location) return current;

    RavUpvalue *upvalue = object_upvalue(&vm->allocator, location);
    upvalue->next = current;

    if (previous == NULL) {
        vm->open_upvalues = upvalue;
    } else {
        previous->next = upvalue;
    }

    return upvalue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40c80(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x6c35
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
seta %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6c3e
jmp 0x6c54
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6c17
cmpq $0x0, -0x28(%rbp)
je 0x6c73
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6c73
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cbc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c80
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x6ca8
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40c80(%rax)
jmp 0x6cb4
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40c80(%rcx)
movb %al, -0x19(%rbp)
je 0x6d08
movq -0x8(%rbp), %rax
movq 0x40c80(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
setae %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x6d11
jmp 0x6d58
movq -0x8(%rbp), %rax
movq 0x40c80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40c80(%rax)
jmp 0x6cdc
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/vm.c
// Function: call_closure
static bool call_closure(VM *vm, RavClosure *closure, int count) {
    RavFunction *function = closure->function;

    if (function->arity != count) {
        runtime_error(vm, "expect %d arguments, but got %d", function->arity, count);
        return false;
    }

    return push_frame(vm, closure, count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x6dad
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
movl -0x1c(%rbp), %ecx
leaq 0x77cc(%rip), %rsi      # 0xe56c
movb $0x0, %al
callq 0x6630
movb $0x0, -0x1(%rbp)
jmp 0x6dc2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2be0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/chunk.c
// Function: chunk_init
void chunk_init(Chunk *chunk) {
    chunk->count = 0;
    chunk->capacity = 0;
    chunk->opcodes = NULL;

    chunk->lines_count = 0;
    chunk->lines_capacity = 0;
    chunk->lines = NULL;

    chunk->constants_count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x828(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x706e
movq -0x8(%rbp), %rax
cmpl $0x8, 0x4(%rax)
jge 0x7038
movl $0x8, %eax
movl %eax, -0x14(%rbp)
jmp 0x7044
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rsi
callq 0x21b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x70a0
addq $0x20, %rsp
popq %rbp
retq
nop