LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/chunk.c
// Function: write_line
static void write_line(Chunk *chunk, int line) {
    if (chunk->lines_count > 0 &&
        chunk->lines[chunk->lines_count - 1].line == line) {
        return;
    }

    if (chunk->lines_count == chunk->lines_capacity) {
        chunk->lines_capacity = Grow_Capacity(chunk->lines_capacity);
        chunk->lines = realloc(chunk->lines, chunk->lines_capacity * sizeof (Line));
    }

    Line *line_encoding = &chunk->lines[chunk->lines_count++];
    line_encoding->line = line;
    line_encoding->offset = chunk->count - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x70db
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,8), %eax
cmpl -0xc(%rbp), %eax
jne 0x70db
jmp 0x7177
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x7139
movq -0x8(%rbp), %rax
cmpl $0x8, 0x14(%rax)
jge 0x70ff
movl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x710b
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rsi
shlq $0x3, %rsi
callq 0x21b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x10(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rdx)
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x721e
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x725c
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x7249
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl -0x18(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jge 0x7251
movq -0x20(%rbp), %rax
movl (%rax), %eax
popq %rbp
retq
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x725c
jmp 0x71df
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x72e4
movb $0x0, -0x1(%rbp)
jmp 0x7322
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x7330
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x730f
movb $0x0, -0x1(%rbp)
jmp 0x7322
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%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/table.c
// Function: find_entry
static Entry *find_entry(Entry *entries, RavString *key, int hash_mask) {
    uint32_t index = key->hash & hash_mask;
    Entry *tombstone = NULL;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
andl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x73b8
movq -0x30(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x8(%rax)
jne 0x73a7
cmpq $0x0, -0x28(%rbp)
je 0x7395
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x739d
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x73e2
cmpq $0x0, -0x28(%rbp)
jne 0x73b6
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x73d1
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x73cf
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x73e2
jmp 0x73d1
movl -0x20(%rbp), %eax
addl $0x1, %eax
andl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x7354
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
movsd 0x71c9(%rip), %xmm2     # 0xe5f0
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x745e
cmpl $0x8, -0x1c(%rbp)
jge 0x7441
movl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0x7449
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
callq 0x74e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x7330
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x74b0
movq -0x28(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x8(%rax)
jne 0x74b0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/table.c
// Function: adjust_capacity
static void adjust_capacity(Table *table, int hash_mask) {
    Entry *entries = malloc((hash_mask + 1) * sizeof (Entry));

    for (int i = 0; i <= hash_mask; i++) {
        entries[i].key = NULL;
        entries[i].value = Nil_Value;
    }

    table->count = 0;
    for (int i = 0; i <= table->hash_mask; i++) {
        Entry *entry = &table->entries[i];
        if (entry->key == NULL) {
            continue;
        }

        Entry *copy = find_entry(entries, entry->key, hash_mask);
        copy->key = entry->key;
        copy->value = entry->value;
        table->count++;
    }

    free(table->entries);
    table->entries = entries;
    table->hash_mask = hash_mask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x4, %rdi
callq 0x2190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x7552
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x750c
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x75df
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7592
jmp 0x75d4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl -0xc(%rbp), %edx
callq 0x7330
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7564
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/table.c
// Function: table_remove
Value table_remove(Table *table, RavString *key) {
    if (table->count == 0) {
        return Nil_Value;
    }

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

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

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x763a
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, -0x8(%rbp)
jmp 0x76a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x7330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x766f
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, -0x8(%rbp)
jmp 0x76a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movabsq $0x7ffc000000000002, %rcx # imm = 0x7FFC000000000002
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/table.c
// Function: table_copy
void table_copy(Table *from, Table *to) {
    for (int i = 0; i <= from->hash_mask; i++) {
        Entry *entry = &from->entries[i];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x7718
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x770b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x73f0
jmp 0x770d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x76c7
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x774d
movq $0x0, -0x8(%rbp)
jmp 0x77f7
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
andl 0xc(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7799
movq -0x30(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x8(%rax)
jne 0x7797
movq $0x0, -0x8(%rbp)
jmp 0x77f7
jmp 0x77e2
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0x77e0
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x77e0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x2120
cmpl $0x0, %eax
jne 0x77e0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x77f7
jmp 0x77e2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
andl 0xc(%rcx), %eax
movl %eax, -0x24(%rbp)
jmp 0x775a
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/table.c
// Function: table_remove_weak
void table_remove_weak(Table *table) {
    for (int i = 0; i <= table->hash_mask; i++) {
        Entry *entry = &table->entries[i];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x7879
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x786c
movq -0x18(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x4(%rax)
jne 0x786c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x7610
jmp 0x786e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7823
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7930
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x7720
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x78ca
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x791f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
shlq $0x0, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xd7a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2180
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x7980
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: hash_string
static uint32_t hash_string(const char *key, int length) {
    uint32_t hash = 2166136261u;

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

    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x811c9dc5, -0x10(%rbp) # imm = 0x811C9DC5
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7978
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
imull $0x1000193, -0x10(%rbp), %eax # imm = 0x1000193
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7949
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x7ad0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
callq 0x73f0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7930
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x7720
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7a58
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
shlq $0x0, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xd7a0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a6f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x7980
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: object_pair
RavPair *object_pair(Allocator *allocator, Value head, Value tail) {
    RavPair *pair = Alloc_Object(allocator, RavPair, OBJ_PAIR);

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

    return pair;
}

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

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

    allocator->objects = object;
    return object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xd7a0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x28, %edx
callq 0x7ad0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xd7a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x2180
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
movl $0x850, %edx            # imm = 0x850
callq 0x7ad0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x6f60
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: object_upvalue
RavUpvalue *object_upvalue(Allocator *allocator, Value *location) {
    RavUpvalue *upvalue = Alloc_Object(allocator, RavUpvalue, OBJ_UPVALUE);

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

    return upvalue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
movl $0x28, %edx
callq 0x7ad0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: object_closure
RavClosure *object_closure(Allocator *allocator, RavFunction *function) {
    RavUpvalue **upvalues = Alloc(allocator, RavUpvalue*, function->upvalue_count);

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

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

    return closure;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x1c(%rax), %rcx
shlq $0x3, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xd7a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x7d3e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d17
movq -0x8(%rbp), %rdi
movl $0x6, %esi
movl $0x28, %edx
callq 0x7ad0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: object_cfunction
RavCFunction *object_cfunction(Allocator *allocator, CFunc func, int arity_min, int arity_max) {
    RavCFunction *cfunction = Alloc_Object(allocator, RavCFunction, OBJ_CFUNCTION);
    cfunction->func = func;
    cfunction->arity_min = arity_min;
    cfunction->arity_max = arity_max;
    return cfunction;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7, %esi
movl $0x20, %edx
callq 0x7ad0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: object_print
void object_print(Value value) {
    switch (Obj_Type(value)) {
    case OBJ_STRING: {
        RavString *string = As_String(value);
        printf("%.*s", string->length, string->chars);
        break;
    }
    case OBJ_PAIR: {
        putchar('(');
        print_pair(As_Pair(value));
        putchar(')');
        break;
    }
    case OBJ_ARRAY: {
        print_array(As_Array(value));
        break;
    }
    case OBJ_MAP: {
        print_map(As_Map(value));
        break;
    }
    case OBJ_FUNCTION: {
        print_function(As_Function(value));
        break;
    }
    case OBJ_UPVALUE: {
        printf("<upvalue>");
        break;
    }
    case OBJ_CLOSURE: {
        print_function(As_Closure(value)->function);
        break;
    }
    case OBJ_CFUNCTION: {
        printf("<native @ %p>", As_CFunction(value)->func);
        break;
    }
    default:
        assert(!"invalid object type");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x7f1e
movq -0x18(%rbp), %rax
leaq 0x67d0(%rip), %rcx      # 0xe5f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x67bf(%rip), %rdi      # 0xe618
movb $0x0, %al
callq 0x20b0
jmp 0x7f3d
movl $0x28, %edi
callq 0x2040
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rdi
callq 0x7f50
movl $0x29, %edi
callq 0x2040
jmp 0x7f3d
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rdi
callq 0x7fe0
jmp 0x7f3d
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rdi
callq 0x8080
jmp 0x7f3d
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rdi
callq 0x81a0
jmp 0x7f3d
leaq 0x6743(%rip), %rdi      # 0xe61d
movb $0x0, %al
callq 0x20b0
jmp 0x7f3d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x81a0
jmp 0x7f3d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6712(%rip), %rdi      # 0xe627
movb $0x0, %al
callq 0x20b0
jmp 0x7f3d
leaq 0x6710(%rip), %rdi      # 0xe635
leaq 0x6720(%rip), %rsi      # 0xe64c
movl $0x108, %edx            # imm = 0x108
leaq 0x6721(%rip), %rcx      # 0xe659
callq 0x20e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: print_pair
static void print_pair(RavPair *pair) {
    value_print(pair->head);

    // end of a proper list?
    if (Is_Nil(pair->tail)) {
        return;
    }

    if (Is_Pair(pair->tail)) {
        printf(", ");
        print_pair(As_Pair(pair->tail));
    } else {
        printf(" . ");
        value_print(pair->tail);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x88b0
movq -0x8(%rbp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x18(%rax)
jne 0x7f7f
jmp 0x7fd9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x87b0
testb $0x1, %al
jne 0x7f97
jmp 0x7fbe
leaq 0x6744(%rip), %rdi      # 0xe6e2
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rax), %rdi
callq 0x7f50
jmp 0x7fd9
leaq 0x6720(%rip), %rdi      # 0xe6e5
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x88b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: print_array
static void print_array(RavArray *array) {
    putchar('[');

    for (int i = 0; i < (int)array->count - 1; i++) {
        value_print(array->values[i]);
        printf(", ");
    }

    if (array->count > 0) {
        value_print(array->values[array->count - 1]);
    }

    putchar(']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x5b, %edi
callq 0x2040
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x803d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x88b0
leaq 0x66b7(%rip), %rdi      # 0xe6e2
movb $0x0, %al
callq 0x20b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7ffd
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x8065
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x88b0
movl $0x5d, %edi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: print_map
static void print_map(RavMap *map) {
    putchar('{');

    Entry *entries = map->table.entries;
    int last_index = map->table.hash_mask;

    for (int i = 0; i < last_index; i++) {
        if (entries[i].key == NULL) {
            continue;
        }

        object_print(Obj_Value(entries[i].key));
        printf(": ");
        value_print(entries[i].value);
        printf(", ");
    }

    if (last_index >= 0) {
        object_print(Obj_Value(entries[last_index].key));
        printf(": ");
        value_print(entries[last_index].value);
    }

    putchar('}');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x7b, %edi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8138
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x80d2
jmp 0x812a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rdi
callq 0x7df0
leaq 0x65ec(%rip), %rdi      # 0xe6e9
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x88b0
leaq 0x65bf(%rip), %rdi      # 0xe6e2
movb $0x0, %al
callq 0x20b0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x80b3
cmpl $0x0, -0x14(%rbp)
jl 0x8188
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rdi
callq 0x7df0
leaq 0x6580(%rip), %rdi      # 0xe6e9
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x88b0
movl $0x7d, %edi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/object.c
// Function: print_function
static void print_function(RavFunction *function) {
    if (function->name == NULL) {
        printf("<top-level>");
        return;
    }

    printf("<fn %s>", function->name->chars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x81c7
leaq 0x652e(%rip), %rdi      # 0xe6ec
movb $0x0, %al
callq 0x20b0
jmp 0x81e1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x64f3(%rip), %rdi      # 0xe6cd
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
callq 0xd7a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x79f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2100
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq -0x8(%rbp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x88f5
movq -0x8(%rbp), %rdi
callq 0x89b0
leaq 0x5d94(%rip), %rdi      # 0xe67d
movb $0x1, %al
callq 0x20b0
jmp 0x89a5
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
andq -0x8(%rbp), %rax
movabsq $0x7ffc000000000002, %rcx # imm = 0x7FFC000000000002
cmpq %rcx, %rax
jne 0x893e
movq -0x8(%rbp), %rcx
movabsq $0x7ffc000000000003, %rdx # imm = 0x7FFC000000000003
leaq 0x5d50(%rip), %rdi      # 0xe677
leaq 0x5d44(%rip), %rax      # 0xe672
cmpq %rdx, %rcx
cmoveq %rax, %rdi
movb $0x0, %al
callq 0x20b0
jmp 0x89a5
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, -0x8(%rbp)
jne 0x895e
leaq 0x5849(%rip), %rdi      # 0xe19e
movb $0x0, %al
callq 0x20b0
jmp 0x89a5
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq -0x8(%rbp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x8986
movq -0x8(%rbp), %rdi
callq 0x7df0
jmp 0x89a5
leaq 0x5d6b(%rip), %rdi      # 0xe6f8
leaq 0x5d7a(%rip), %rsi      # 0xe70e
movl $0x1e, %edx
leaq 0x5d7a(%rip), %rcx      # 0xe71a
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x22c0, %rsp           # imm = 0x22C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xb990
movq -0x8(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8ab0
leaq -0x22b0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
xorl %edx, %edx
callq 0x8b20
leaq -0x90(%rbp), %rdi
movl $0x36, %esi
callq 0x8c60
xorb $-0x1, %al
testb $0x1, %al
jne 0x8a5a
jmp 0x8a68
leaq -0x90(%rbp), %rdi
callq 0x8ca0
jmp 0x8a41
leaq -0x90(%rbp), %rdi
movl $0x1, %esi
callq 0x8d60
movq %rax, -0x22b8(%rbp)
testb $0x1, -0x48(%rbp)
je 0x8a91
xorl %eax, %eax
movq %rax, -0x22c0(%rbp)
jmp 0x8a9f
movq -0x22b8(%rbp), %rax
movq %rax, -0x22c0(%rbp)
movq -0x22c0(%rbp), %rax
addq $0x22c0, %rsp           # imm = 0x22C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: init_parser
static inline void init_parser(Parser *parser, Lexer *lexer, VM *vm) {
    parser->lexer = lexer;
    parser->context = NULL;
    parser->vm = vm;
    parser->had_error = false;
    parser->panic_mode = false;
    parser->inner_loop_start = -1;
    parser->inner_loop_depth = -1;

#ifdef DEBUG_TRACE_PARSING
    parser->level = 0;
#endif

    advance(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x49(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x8dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: init_context
static inline void init_context(Context *context, Parser *parser, FunctionType type) {
    // TODO: limit the amount of nesting function declaration.
    context->enclosing = parser->context; // Save the previous scope.
    parser->context = context;            // Push the new scope.

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x0, -0x14(%rbp)
sete %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2018(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x221c(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7c20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq -0x8(%rbp), %rdx
movl 0x2018(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2018(%rdx)
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
leaq 0x5483(%rip), %rcx      # 0xe057
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x1c(%rax)
cmpl $0x1, -0x14(%rbp)
jne 0x8c1e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %edx
callq 0x7880
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x8c54
cmpl $0x2, -0x14(%rbp)
je 0x8c2a
cmpl $0x3, -0x14(%rbp)
jne 0x8c52
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x5bfb(%rip), %rsi      # 0xe834
movl $0x8, %edx
callq 0x7880
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x8c54
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: consume_if
static inline bool consume_if(Parser *parser, TokenType type) {
    if (!current_is(parser, type)) {
        return false;
    }

    advance(parser);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8e40
testb $0x1, %al
jne 0x8c85
movb $0x0, -0x1(%rbp)
jmp 0x8c92
movq -0x10(%rbp), %rdi
callq 0x8dc0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: declaration
static void declaration(Parser *parser) {
    Debug_Log(parser);

    if (consume_if(parser, TOKEN_LET)) {
        let_declaration(parser);
    } else if (consume_if(parser, TOKEN_FN)) {
        fn_declaration(parser);
    } else if (consume_if(parser, TOKEN_RETURN)) {
        return_statement(parser);
    } else if (consume_if(parser, TOKEN_CONTINUE)) {
        continue_statement(parser);
    } else {
        expression(parser);
        emit_byte(parser, OP_POP_X);
    }

    if (parser->panic_mode) {
        recover(parser);
    }

    Debug_Exit(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x8c60
testb $0x1, %al
jne 0x8cc0
jmp 0x8ccb
movq -0x8(%rbp), %rdi
callq 0x8e60
jmp 0x8d45
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x8c60
testb $0x1, %al
jne 0x8cdf
jmp 0x8cea
movq -0x8(%rbp), %rdi
callq 0x8ec0
jmp 0x8d43
movq -0x8(%rbp), %rdi
movl $0xc, %esi
callq 0x8c60
testb $0x1, %al
jne 0x8cfe
jmp 0x8d09
movq -0x8(%rbp), %rdi
callq 0x8f20
jmp 0x8d41
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x8c60
testb $0x1, %al
jne 0x8d1d
jmp 0x8d28
movq -0x8(%rbp), %rdi
callq 0x8f90
jmp 0x8d3f
movq -0x8(%rbp), %rdi
callq 0x8fe0
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x9000
jmp 0x8d41
jmp 0x8d43
jmp 0x8d45
movq -0x8(%rbp), %rax
testb $0x1, 0x49(%rax)
je 0x8d58
movq -0x8(%rbp), %rdi
callq 0x9040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mahrr[P]raven/src/compiler.c
// Function: end_context
static inline RavFunction *end_context(Parser *parser, bool toplevel) {
    RavFunction *function = parser->context->function;
    emit_byte(parser, toplevel ? OP_EXIT : OP_RETURN);

#ifdef DEBUG_DUMP_CODE
    if (parser->had_error == false) {
        RavString *name = function->name;
        disassemble_chunk(
            parser_chunk(parser),
            parser->lexer->file,
            name ? name->chars : "top-level"
        );
        putchar('\n');
    }
#endif

    // Pop the current scope.
    parser->context = parser->context->enclosing;
    return function;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %dl
movl $0x34, %eax
movl $0x35, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movzbl %al, %esi
callq 0x9000
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq