LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/qst.c
// Function: chunk_to_bin
void chunk_to_bin(Chunk* chunk, QstBin* bin) {
    bin->object_code_len = chunk->count;
    bin->object_code = malloc(bin->object_code_len);
    memcpy(bin->object_code, chunk->code, bin->object_code_len);

    bin->function_offset_table_len = chunk->labels_count;
    bin->function_offset_table = malloc(bin->function_offset_table_len * 4);
    memcpy(bin->function_offset_table, chunk->labels, bin->function_offset_table_len * 4);

    bin->bin_size = (uint32_t) (BIN_MINIMUM_SIZE + bin->object_code_len + bin->function_offset_table_len * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1230(%rax)
movq -0x10(%rbp), %rax
movq 0x1230(%rax), %rdi
callq 0x4120
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1238(%rax)
movq -0x10(%rbp), %rax
movq 0x1238(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x1230(%rax), %rdx
callq 0x4110
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1240(%rax)
movq -0x10(%rbp), %rax
movq 0x1240(%rax), %rdi
shlq $0x2, %rdi
callq 0x4120
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1248(%rax)
movq -0x10(%rbp), %rax
movq 0x1248(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x1240(%rax), %rdx
shlq $0x2, %rdx
callq 0x4110
movq -0x10(%rbp), %rax
movq 0x1230(%rax), %rax
addq $0x122c, %rax           # imm = 0x122C
movq -0x10(%rbp), %rcx
movq 0x1240(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/qst.c
// Function: bin_to_chunk
void bin_to_chunk(QstBin* bin, Chunk* chunk) {
    chunk->count = bin->object_code_len;
    chunk->code = malloc(chunk->count);
    memcpy(chunk->code, bin->object_code, chunk->count);

    chunk->labels_count = bin->function_offset_table_len;
    chunk->labels = malloc(chunk->labels_count * 4);
    memcpy(chunk->labels, bin->function_offset_table, chunk->labels_count * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1230(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4120
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x1238(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x4110
movq -0x8(%rbp), %rax
movq 0x1240(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
shlq $0x2, %rdi
callq 0x4120
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x1248(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
shlq $0x2, %rdx
callq 0x4110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: init_scanner
void init_scanner(const char* source) {
    scanner.start = source;
    scanner.current = source;
    scanner.line = 1;
    scanner.column = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x10c85(%rip)     # 0x19758
movq -0x8(%rbp), %rax
movq %rax, 0x10c82(%rip)     # 0x19760
movq $0x1, 0x10c7f(%rip) # 0x19768
movq $0x1, 0x10c7c(%rip) # 0x19770
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: skip_whitespace
static void skip_whitespace(void) {
    while (true) {
        char c = peek();

        switch (c) {
            case ' ':
            case '\r':
            case '\t':
                advance();
                break;
            case '\n':
                scanner.line++;
                advance();
                break;
            case '/':
                // Treat comments as whitespace
                if (peek_next() == '/') {
                    while (peek() != '\n' && !is_at_end()) {
                        advance();
                    }
                } else {
                    return;
                }
                break;
            default:
                return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9250
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x26, %eax
ja 0x8ea7
movq -0x10(%rbp), %rax
leaq 0x5273(%rip), %rcx      # 0xe0b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x8f30
jmp 0x8ea9
movq 0x10914(%rip), %rax     # 0x19768
addq $0x1, %rax
movq %rax, 0x10909(%rip)     # 0x19768
callq 0x8f30
jmp 0x8ea9
callq 0x9260
movsbl %al, %eax
cmpl $0x2f, %eax
jne 0x8ea3
jmp 0x8e75
callq 0x9250
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x11(%rbp)
je 0x8e91
callq 0x8ec0
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8e9a
jmp 0x8ea1
callq 0x8f30
jmp 0x8e75
jmp 0x8ea5
jmp 0x8eae
jmp 0x8ea9
jmp 0x8eae
jmp 0x8e18
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: make_token
static Token make_token(TokenType type) {
    Token token;

    token.type = type;
    token.start = scanner.start;
    token.length = (size_t) (scanner.current - scanner.start);
    token.line = scanner.line;
    token.column = scanner.column;

    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movq 0x10862(%rip), %rcx     # 0x19758
movq %rcx, 0x8(%rdi)
movq 0x1085f(%rip), %rcx     # 0x19760
movq 0x10850(%rip), %rdx     # 0x19758
subq %rdx, %rcx
movq %rcx, 0x10(%rdi)
movq 0x10852(%rip), %rcx     # 0x19768
movq %rcx, 0x18(%rdi)
movq 0x1084f(%rip), %rcx     # 0x19770
movq %rcx, 0x20(%rdi)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: number
static Token number(void) {
    while (is_digit(peek())) {
        advance();
    }

    if (peek() == '.' && is_digit(peek_next())) {
        advance();

        while (is_digit(peek())) {
            advance();
        }

        return make_token(TOKEN_FLOAT);
    }

    return make_token(TOKEN_INTEGER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x9062
callq 0x9250
movsbl %al, %edi
callq 0x9020
testb $0x1, %al
jne 0x9075
jmp 0x907c
callq 0x8f30
jmp 0x9062
callq 0x9250
movsbl %al, %eax
cmpl $0x2e, %eax
jne 0x90cb
callq 0x9260
movsbl %al, %edi
callq 0x9020
testb $0x1, %al
jne 0x909c
jmp 0x90cb
callq 0x8f30
callq 0x9250
movsbl %al, %edi
callq 0x9020
testb $0x1, %al
jne 0x90b4
jmp 0x90bb
callq 0x8f30
jmp 0x90a1
movq -0x10(%rbp), %rdi
movl $0x1d, %esi
callq 0x8ee0
jmp 0x90d9
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x8ee0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: match
static bool match(char expected) {
    if (is_at_end()) {
        return false;
    }

    if (*scanner.current != expected) {
        return false;
    }

    scanner.current++;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
callq 0x8ec0
testb $0x1, %al
jne 0x9109
jmp 0x910f
movb $0x0, -0x1(%rbp)
jmp 0x913d
movq 0x1064a(%rip), %rax     # 0x19760
movsbl (%rax), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
je 0x9127
movb $0x0, -0x1(%rbp)
jmp 0x913d
movq 0x10632(%rip), %rax     # 0x19760
addq $0x1, %rax
movq %rax, 0x10627(%rip)     # 0x19760
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: string
static Token string(void) {
    while (peek() != '"' && !is_at_end()) {
        if (peek() == '\n') {
            scanner.line++;
        }

        advance();
    }

    if (is_at_end()) {
        return error_token("Unterminated string");
    }

    advance();
    return make_token(TOKEN_STRING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x9162
callq 0x9250
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x22, %ecx
movb %al, -0x11(%rbp)
je 0x917e
callq 0x8ec0
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9187
jmp 0x91ad
callq 0x9250
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x91a6
movq 0x105cd(%rip), %rax     # 0x19768
addq $0x1, %rax
movq %rax, 0x105c2(%rip)     # 0x19768
callq 0x8f30
jmp 0x9162
callq 0x8ec0
testb $0x1, %al
jne 0x91b8
jmp 0x91ca
movq -0x10(%rbp), %rdi
leaq 0x4ffa(%rip), %rsi      # 0xe1bd
callq 0x91f0
jmp 0x91dd
callq 0x8f30
movq -0x10(%rbp), %rdi
movl $0x1b, %esi
callq 0x8ee0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: error_token
static Token error_token(const char* message) {
    Token token;

    token.type = TOKEN_ERROR;
    token.start = message;
    token.length = strlen(message);
    token.line = scanner.line;
    token.column = scanner.column;

    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x29, (%rdi)
movq -0x8(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x8(%rbp), %rdi
callq 0x4080
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rdi)
movq 0x10534(%rip), %rcx     # 0x19768
movq %rcx, 0x18(%rdi)
movq 0x10531(%rip), %rcx     # 0x19770
movq %rcx, 0x20(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/scanner.c
// Function: check_keyword
static TokenType check_keyword(size_t start, size_t length, const char* rest, TokenType type) {
    if ((size_t) (scanner.current - scanner.start) == start + length &&
           memcmp(scanner.start + start, rest, length) == 0) {
        return type;
    }

    return TOKEN_IDENTIFIER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq 0x102a2(%rip), %rax     # 0x19760
movq 0x10293(%rip), %rcx     # 0x19758
subq %rcx, %rax
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x94fa
movq 0x1027c(%rip), %rdi     # 0x19758
addq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x40c0
cmpl $0x0, %eax
jne 0x94fa
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9501
movl $0x1a, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/table.c
// Function: table_get
bool table_get(Table* table, ObjString* key, Value* value) {
    if (table->count == 0) {
        return false;
    }

    Entry* entry = find_entry(table->entries, table->capacity, key);
    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
cmpq $0x0, (%rax)
jne 0x95a4
movb $0x0, -0x1(%rbp)
jmp 0x95ec
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x9600
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x95d1
movb $0x0, -0x1(%rbp)
jmp 0x95ec
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/table.c
// Function: find_entry
static Entry* find_entry(Entry* entries, size_t capacity, ObjString* key) {
    uint32_t index = key->hash % (uint32_t) capacity;
    Entry* tombstone = NULL;

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

        if (entry->key == NULL) {
            if (IS_NULL(entry->value)) {
                return tombstone != NULL ? tombstone : entry;
            } else {
                if (tombstone == NULL) {
                    tombstone = entry;
                }
            }
        } else if (strcmp(entry->key->chars, key->chars) == 0) {
            return entry;
        }

        index = (index + 1) % (uint32_t) capacity;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
xorl %edx, %edx
divl %ecx
movl %edx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x968a
movq -0x38(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x9677
cmpq $0x0, -0x30(%rbp)
je 0x9665
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x966d
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x96c9
cmpq $0x0, -0x30(%rbp)
jne 0x9686
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9688
jmp 0x96b3
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x40e0
cmpl $0x0, %eax
jne 0x96b1
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x96c9
jmp 0x96b3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
xorl %edx, %edx
divl %ecx
movl %edx, -0x24(%rbp)
jmp 0x962e
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/table.c
// Function: table_set
bool table_set(Table* table, ObjString* key, Value value) {
    if (table->count + 1 > (double) table->capacity * TABLE_MAX_LOAD) {
        size_t capacity = GROW_CAPACITY(table->capacity);
        adjust_capacity(table, capacity);
    }

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

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

    entry->key = key;
    entry->value = value;

    return is_new_key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, %xmm0
movaps 0x4ad3(%rip), %xmm3     # 0xe1e0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x4ad7(%rip), %xmm2     # 0xe1f0
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x8(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
movsd 0x4a90(%rip), %xmm2     # 0xe1d8
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x978c
movq -0x18(%rbp), %rax
cmpq $0x8, 0x8(%rax)
jae 0x9768
movl $0x8, %eax
movq %rax, -0x40(%rbp)
jmp 0x9777
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9810
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x9600
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x97d7
movq -0x30(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x97d7
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/table.c
// Function: adjust_capacity
static void adjust_capacity(Table* table, size_t capacity) {
    Entry* entries = ALLOCATE(Entry, capacity);

    for (size_t i = 0; i < capacity; i++) {
        entries[i].key = NULL;
        entries[i].value = NULL_VAL;
    }

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

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

    FREE_ARRAY(Entry, table->entries, table->capacity);
    table->entries = entries;
    table->capacity = capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
imulq $0x18, -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x79e0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x9892
movq -0x18(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movl $0x5, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x983d
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x9930
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x98d3
jmp 0x991f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rax
movq (%rax), %rdx
callq 0x9600
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x98a5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x18, 0x8(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x79e0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/table.c
// Function: table_delete
bool table_delete(Table* table, ObjString* key) {
    if (table->count == 0) {
        return false;
    }

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

    entry->key = NULL;
    entry->value = NULL_VAL;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9990
movb $0x0, -0x1(%rbp)
jmp 0x99ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x9600
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x99bd
movb $0x0, -0x1(%rbp)
jmp 0x99ee
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x5, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
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/jtuu[P]quesler/src/table.c
// Function: table_add_all
void table_add_all(Table* from, Table* to) {
    for (size_t i = 0; i < from->capacity; i++) {
        Entry* entry = &from->entries[i];
        if (entry->key != NULL) {
            table_set(to, entry->key, entry->value);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x9a6f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9a5f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq 0x10(%rax), %rcx
callq 0x96e0
jmp 0x9a61
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9a18
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/value.c
// Function: write_value_array
void write_value_array(ValueArray* array, Value value) {
    if (array->capacity < array->count + 1) {
        size_t old_capacity = array->capacity;
        array->capacity = GROW_CAPACITY(old_capacity);
        array->values = GROW_ARRAY(Value, array->values,
            old_capacity, array->capacity);
    }

    array->values[array->count] = value;
    array->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x9b39
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x9af8
movl $0x8, %eax
movq %rax, -0x28(%rbp)
jmp 0x9b03
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x4, %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
shlq $0x4, %rdx
callq 0x79e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/value.c
// Function: print_value
void print_value(Value value) {
    switch (value.type) {
        case VAL_BOOLEAN:
            printf(AS_BOOLEAN(value) ? "true" : "false");
            break;
        case VAL_DWORD:
            printf("%d", AS_DWORD(value));
            break;
        case VAL_WORD:
            printf("%hd", AS_WORD(value));
            break;
        case VAL_BYTE:
            printf("%hhd", AS_BYTE(value));
            break;
        case VAL_FLOAT:
            printf("%f", AS_FLOAT(value));
            break;
        case VAL_NULL:
            printf("null");
            break;
        case VAL_STRING: {
            uint16_t* str = AS_STRING(value);
            while (*str != 0) {
                printf("%lc", (wchar_t) *str);
                str++;
            }
            break;
        }
        default:
            printf("Unknown value");
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x6, %rax
ja 0x9cbb
movq -0x20(%rbp), %rax
leaq 0x4615(%rip), %rcx      # 0xe200
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %ecx
leaq 0x4623(%rip), %rdi      # 0xe221
leaq 0x4617(%rip), %rax      # 0xe21c
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movb $0x0, %al
callq 0x4090
jmp 0x9cc9
movl -0x8(%rbp), %esi
leaq 0x266c(%rip), %rdi      # 0xc28e
movb $0x0, %al
callq 0x4090
jmp 0x9cc9
movswl -0x8(%rbp), %esi
leaq 0x45ee(%rip), %rdi      # 0xe227
movb $0x0, %al
callq 0x4090
jmp 0x9cc9
movzbl -0x8(%rbp), %esi
leaq 0x45db(%rip), %rdi      # 0xe22b
movb $0x0, %al
callq 0x4090
jmp 0x9cc9
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x45c7(%rip), %rdi      # 0xe230
movb $0x1, %al
callq 0x4090
jmp 0x9cc9
leaq 0x45ba(%rip), %rdi      # 0xe233
movb $0x0, %al
callq 0x4090
jmp 0x9cc9
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
je 0x9cb9
movq -0x18(%rbp), %rax
movzwl (%rax), %esi
leaq 0x2a28(%rip), %rdi      # 0xc6cc
movb $0x0, %al
callq 0x4090
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x9c8a
jmp 0x9cc9
leaq 0x4576(%rip), %rdi      # 0xe238
movb $0x0, %al
callq 0x4090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: stack_push
void stack_push(Value value) {
    if (vm.stack_top - vm.stack >= STACK_SIZE) {
        fprintf(stderr, "VM: Stack overflow\n");
        return;
    }

    *vm.stack_top = value;
    vm.stack_top++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq 0x10dd2(%rip), %rax     # 0x1ab88
leaq 0xf9bb(%rip), %rcx      # 0x19778
addq $0x1010, %rcx           # imm = 0x1010
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x100, %rax            # imm = 0x100
jl 0x9ded
movq 0xf216(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x44b4(%rip), %rsi      # 0xe298
movb $0x0, %al
callq 0x40f0
jmp 0x9e15
movq 0x10d94(%rip), %rax     # 0x1ab88
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10d7e(%rip), %rax     # 0x1ab88
addq $0x10, %rax
movq %rax, 0x10d73(%rip)     # 0x1ab88
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: stack_pop
Value stack_pop() {
    if (--vm.stack_top < vm.stack) {
        fprintf(stderr, "VM: Stack underflow\n");
        vm.stack_top = vm.stack;
    }

    return *vm.stack_top;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x10d59(%rip), %rax     # 0x1ab88
addq $-0x10, %rax
movq %rax, 0x10d4e(%rip)     # 0x1ab88
leaq 0xf937(%rip), %rcx      # 0x19778
addq $0x1010, %rcx           # imm = 0x1010
cmpq %rcx, %rax
jae 0x9e79
movq 0xf19c(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x444e(%rip), %rsi      # 0xe2ac
movb $0x0, %al
callq 0x40f0
leaq 0xf90c(%rip), %rax      # 0x19778
addq $0x1010, %rax           # imm = 0x1010
movq %rax, 0x10d0f(%rip)     # 0x1ab88
movq 0x10d08(%rip), %rax     # 0x1ab88
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: interpret_bytecode
InterpretResult interpret_bytecode(Chunk* chunk) {
    vm.chunk = chunk;
    vm.ip = vm.chunk->code + vm.chunk->labels[entry_point_label];

    InterpretResult result = run();

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0xf8c1(%rip)      # 0x19778
movq 0xf8ba(%rip), %rax      # 0x19778
movq 0x10(%rax), %rax
movq 0xf8af(%rip), %rcx      # 0x19778
movq 0x38(%rcx), %rcx
leaq 0xf6bc(%rip), %rdx      # 0x19590
movq (%rdx), %rdx
movslq (%rcx,%rdx,4), %rcx
addq %rcx, %rax
movq %rax, 0xf89b(%rip)      # 0x19780
callq 0x9f00
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: interpret_source
InterpretResult interpret_source(const char* source) {
    Chunk chunk;
    init_chunk(&chunk);

    if (!compile(source, &chunk)) {
        free_chunk(&chunk);
        return INTERPRET_COMPILE_ERROR;
    }

    InterpretResult result = interpret_bytecode(&chunk);
    free_chunk(&chunk);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4280
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5450
testb $0x1, %al
jne 0xb0a8
leaq -0x60(%rbp), %rdi
callq 0x4430
movl $0x1, -0x4(%rbp)
jmp 0xb0c3
leaq -0x60(%rbp), %rdi
callq 0x9ea0
movl %eax, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4430
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: take_stack_args
static void take_stack_args(Value* dst) {
    for (size_t i = 0; i < ARG_STACK_LEN; i++) {
        vm.arg_stack_top--;
        *dst = *vm.arg_stack_top;
        dst++;
    }

    reset_arg_stack();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x8, -0x10(%rbp)
jae 0xb130
movq 0xfb1e(%rip), %rax      # 0x1ac10
addq $-0x10, %rax
movq %rax, 0xfb13(%rip)      # 0x1ac10
movq -0x8(%rbp), %rax
movq 0xfb08(%rip), %rcx      # 0x1ac10
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb0e4
callq 0x9d10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: do_jump
static void do_jump(size_t label) {
    int32_t offset = vm.chunk->labels[label];

    if (offset < 0) {
        fprintf(stderr, "VM: Invalid jump target\n");
        return;
    }

    vm.ip = vm.chunk->code + offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xe5c5(%rip), %rax      # 0x19778
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xb1e1
movq 0xde22(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x313a(%rip), %rsi      # 0xe312
movb $0x0, %al
callq 0x40f0
jmp 0xb1fa
movq 0xe590(%rip), %rax      # 0x19778
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, 0xe586(%rip)      # 0x19780
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/vm.c
// Function: compare
static bool compare(uint16_t opcode, int32_t val1, int32_t val2) {
    switch (opcode) {
        case OP_JMP_EQ: __attribute__ ((fallthrough));
        case OP_JMPI_EQ:
            return val1 == val2;
        case OP_JMP_NEQ: __attribute__ ((fallthrough));
        case OP_JMPI_NEQ:
            return val1 != val2;
        case OP_JMP_GT: __attribute__ ((fallthrough));
        case OP_JMPI_GT:
            return val1 > val2;
        case OP_JMP_LT: __attribute__ ((fallthrough));
        case OP_JMPI_LT:
            return val1 < val2;
        case OP_JMP_GTE: __attribute__ ((fallthrough));
        case OP_JMPI_GTE:
            return val1 >= val2;
        case OP_JMP_LTE: __attribute__ ((fallthrough));
        case OP_JMPI_LTE:
            return val1 <= val2;
        default:
            fprintf(stderr, "VM: Invalid comparison opcode\n");
            break;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movzwl -0x4(%rbp), %eax
addl $-0x2c, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x13, %eax
ja 0xb2ab
movq -0x18(%rbp), %rax
leaq 0x3012(%rip), %rcx      # 0xe248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xb241
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb2c7
jmp 0xb253
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb2c7
jmp 0xb265
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb2c7
jmp 0xb277
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb2c7
jmp 0xb289
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb2c7
jmp 0xb29b
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setle %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb2c7
movq 0xdd3e(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x306f(%rip), %rsi      # 0xe32b
movb $0x0, %al
callq 0x40f0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegC
static void
RegC(
Hax_Interp *interp,
char b)
{
	Interp *iPtr = (Interp *) interp;

	if (iPtr->regcode != &iPtr->regdummy)
		*iPtr->regcode++ = b;
	else
		iPtr->regsize++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x2a4, %rcx            # imm = 0x2A4
cmpq %rcx, %rax
je 0x4a81
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rdx
movq 0x2a8(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x2a8(%rdx)
movb %cl, (%rax)
jmp 0x4a97
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2b0(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegNext
static char *
RegNext(
Hax_Interp *interp,
char *p)
{
	Interp *iPtr = (Interp *) interp;
	int offset;

	if (p == &iPtr->regdummy)
		return(NULL);

	offset = NEXT(p);
	if (offset == 0)
		return(NULL);

	if (OP(p) == BACK)
		return(p-offset);
	else
		return(p+offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x2a4, %rcx            # imm = 0x2A4
cmpq %rcx, %rax
jne 0x4da2
movq $0x0, -0x8(%rbp)
jmp 0x4e06
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
andl $0xff, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4dd5
movq $0x0, -0x8(%rbp)
jmp 0x4e06
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7, %eax
jne 0x4df7
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4e06
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegTry
static int			/* 0 failure, 1 success */
RegTry(
Hax_Interp *interp,
regexp *prog,
char *string)
{
	Interp *iPtr = (Interp *) interp;
	int i;
	char **sp;
	char **ep;

	iPtr->reginput = string;
	iPtr->regstartp = prog->startp;
	iPtr->regendp = prog->endp;

	sp = prog->startp;
	ep = prog->endp;
	for (i = NSUBEXP; i > 0; i--) {
		*sp++ = NULL;
		*ep++ = NULL;
	}
	if (RegMatch(interp, prog->program + 1)) {
		prog->startp[0] = string;
		prog->endp[0] = iPtr->reginput;
		return(1);
	} else
		return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x2b8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x2c8(%rax)
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x2d0(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x40(%rbp)
movl $0xa, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x5095
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq $0x0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movq $0x0, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5058
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xb4, %rsi
addq $0x1, %rsi
callq 0x5e50
cmpl $0x0, %eax
je 0x50d9
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x2b8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x50e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegNode
static char *			/* Location. */
RegNode(
Hax_Interp *interp,
char op)
{
	Interp *iPtr = (Interp *) interp;
	char *ret;
	char *ptr;

	ret = iPtr->regcode;
	if (ret == &iPtr->regdummy) {
		iPtr->regsize += 3;
		return(ret);
	}

	ptr = ret;
	*ptr++ = op;
	*ptr++ = '\0';		/* Null "next" pointer. */
	*ptr++ = '\0';
	iPtr->regcode = ptr;

	return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x2a8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x2a4, %rcx            # imm = 0x2A4
cmpq %rcx, %rax
jne 0x5149
movq -0x20(%rbp), %rax
movq 0x2b0(%rax), %rcx
addq $0x3, %rcx
movq %rcx, 0x2b0(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51a0
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x11(%rbp), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x2a8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegBranch
static char *
RegBranch(
Hax_Interp *interp,
int *flagp)
{
	Interp *iPtr = (Interp *) interp;
	char *ret;
	char *chain;
	char *latest;
	int flags;

	*flagp = WORST;		/* Tentatively. */

	ret = RegNode(interp, BRANCH);
	chain = NULL;
	while (*iPtr->regparse != '\0' && *iPtr->regparse != '|' && *iPtr->regparse != ')') {
		latest = RegPiece(interp, &flags);
		if (latest == NULL)
			return(NULL);
		*flagp |= flags&HASWIDTH;
		if (chain == NULL)	/* First piece. */
			*flagp |= flags&SPSTART;
		else
			RegTail(interp, chain, latest);
		chain = latest;
	}
	if (chain == NULL)	/* Loop ran zero times. */
		(void) RegNode(interp, NOTHING);

	return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x50f0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x298(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3d(%rbp)
je 0x5233
movq -0x20(%rbp), %rax
movq 0x298(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x7c, %ecx
movb %al, -0x3d(%rbp)
je 0x5233
movq -0x20(%rbp), %rax
movq 0x298(%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x523c
jmp 0x52a1
movq -0x10(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x53f0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x525e
movq $0x0, -0x8(%rbp)
jmp 0x52be
movl -0x3c(%rbp), %ecx
andl $0x1, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x5283
movl -0x3c(%rbp), %ecx
andl $0x4, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x5294
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x52d0
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x51ec
cmpq $0x0, -0x30(%rbp)
jne 0x52b6
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x50f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegTail
static void
RegTail(
Hax_Interp *interp,
char *p,
char *val)
{
	Interp *iPtr = (Interp *) interp;
	char *scan;
	char *temp;
	int offset;

	if (p == &iPtr->regdummy)
		return;

	/* Find last node. */
	scan = p;
	for (;;) {
		temp = RegNext(interp, scan);
		if (temp == NULL)
			break;
		scan = temp;
	}

	if (OP(scan) == BACK)
		offset = scan - val;
	else
		offset = val - scan;
	*(scan+1) = (offset>>8)&0377;
	*(scan+2) = offset&0377;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x2a4, %rcx            # imm = 0x2A4
cmpq %rcx, %rax
jne 0x5302
jmp 0x537d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4d70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5324
jmp 0x532e
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x530a
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7, %eax
jne 0x534a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x5358
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x34(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x2(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegOpTail
static void
RegOpTail(
Hax_Interp *interp,
char *p,
char *val)
{
	Interp *iPtr = (Interp *) interp;

	/* "Operandless" and "op != BRANCH" are synonymous in practice. */
	if (p == NULL || p == &iPtr->regdummy || OP(p) != BRANCH)
		return;
	RegTail(interp, OPERAND(p), val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x53d3
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x2a4, %rcx            # imm = 0x2A4
cmpq %rcx, %rax
je 0x53d3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6, %eax
je 0x53d5
jmp 0x53ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x3, %rsi
movq -0x18(%rbp), %rdx
callq 0x52d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegInsert
static void
RegInsert(
Hax_Interp *interp,
char op,
char *opnd)
{
	Interp *iPtr = (Interp *) interp;
	char *src;
	char *dst;
	char *place;

	if (iPtr->regcode == &iPtr->regdummy) {
		iPtr->regsize += 3;
		return;
	}

	src = iPtr->regcode;
	iPtr->regcode += 3;
	dst = iPtr->regcode;
	while (src > opnd)
		*--dst = *--src;

	place = opnd;		/* Op node, where operand used to be. */
	*place++ = op;
	*place++ = '\0';
	*place++ = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x20(%rbp), %rcx
addq $0x2a4, %rcx            # imm = 0x2A4
cmpq %rcx, %rax
jne 0x5da0
movq -0x20(%rbp), %rax
movq 0x2b0(%rax), %rcx
addq $0x3, %rcx
movq %rcx, 0x2b0(%rax)
jmp 0x5e44
movq -0x20(%rbp), %rax
movq 0x2a8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x2a8(%rax), %rcx
addq $0x3, %rcx
movq %rcx, 0x2a8(%rax)
movq -0x20(%rbp), %rax
movq 0x2a8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5e04
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
movb -0x1(%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, -0x1(%rax)
jmp 0x5dd4
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x9(%rbp), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxRegexp.c
// Function: RegRepeat
static int
RegRepeat(
Hax_Interp *interp,
char *p)
{
	Interp *iPtr = (Interp *) interp;
	int count = 0;
	char *scan;
	char *opnd;

	scan = iPtr->reginput;
	opnd = OPERAND(p);
	switch (OP(p)) {
	case ANY:
		count = strlen(scan);
		scan += count;
		break;
	case EXACTLY:
		while (*opnd == *scan) {
			count++;
			scan++;
		}
		break;
	case ANYOF:
		while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
			count++;
			scan++;
		}
		break;
	case ANYBUT:
		while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
			count++;
			scan++;
		}
		break;
	default:		/* Oh dear.  Called inappropriately. */
		RegError(interp, (char *) "internal foulup");
		count = 0;	/* Best compromise. */
		break;
	}
	iPtr->reginput = scan;

	return(count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x5, %eax
ja 0x6497
movq -0x38(%rbp), %rax
leaq 0x16d02(%rip), %rcx     # 0x1d0a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
callq 0x41b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x64ae
jmp 0x63cb
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x63f4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x63cb
jmp 0x64ae
jmp 0x63fb
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x6426
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movsbl (%rax), %esi
callq 0x4230
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x642f
jmp 0x6446
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x63fb
jmp 0x64ae
jmp 0x644a
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x6475
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movsbl (%rax), %esi
callq 0x4230
cmpq $0x0, %rax
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x647e
jmp 0x6495
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x644a
jmp 0x64ae
movq -0x8(%rbp), %rdi
leaq 0x16d44(%rip), %rsi     # 0x1d1e6
callq 0x4200
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x2b8(%rax)
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxAssem.c
// Function: Hax_CreateCmdBuf
Hax_CmdBuf
Hax_CreateCmdBuf(
    Hax_Interp *interp)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    CmdBuf *cbPtr;

    cbPtr = (CmdBuf *) ckalloc(memoryp, sizeof(CmdBuf));
    cbPtr->buffer = (char *) ckalloc(memoryp, CMD_BUF_SIZE);
    cbPtr->buffer[0] = '\0';
    cbPtr->bufSize = CMD_BUF_SIZE;
    cbPtr->bytesUsed = 0;
    return (Hax_CmdBuf) cbPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x10, %esi
leaq 0x16cf3(%rip), %rdx     # 0x1d1f6
movl $0x49, %ecx
callq 0x44c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x64, %esi
leaq 0x16cd5(%rip), %rdx     # 0x1d1f6
movl $0x4a, %ecx
callq 0x44c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x64, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop