LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ctx.c
// Function: fin_allocator
static void* fin_allocator(void* ptr, unsigned int size) {
    if (ptr) {
        if (size) {
            return realloc(ptr, size);
        }
        else {
            free(ptr);
            return NULL;
        }
    }
    else if (size) {
        return malloc(size);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6203
cmpl $0x0, -0x14(%rbp)
je 0x61f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
jmp 0x6223
movq -0x10(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x6223
cmpl $0x0, -0x14(%rbp)
je 0x6219
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x31e0
movq %rax, -0x8(%rbp)
jmp 0x6223
jmp 0x621b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ctx.c
// Function: fin_ctx_destroy
void fin_ctx_destroy(fin_ctx_t* ctx) {
    fin_mod_t* mod = ctx->mod;
    while (mod) {
        fin_mod_t* tmp = mod;
        mod = mod->next;
        fin_mod_destroy(ctx, tmp);
    }

    fin_str_pool_destroy(ctx->pool);
    ctx->alloc(ctx, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6272
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8340
jmp 0x6248
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xade0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ctx.c
// Function: fin_ctx_eval_str
void fin_ctx_eval_str(fin_ctx_t* ctx, const char* cstr) {
    fin_mod_t* mod = fin_mod_compile(ctx, cstr);
    if (mod && mod->entry) {
        fin_vm_t* vm = fin_vm_create(ctx);
        fin_vm_invoke(vm, mod->entry);
        fin_vm_destroy(vm);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7ae0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x62fa
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x62fa
movq -0x8(%rbp), %rdi
callq 0xba70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xbb10
movq -0x20(%rbp), %rdi
callq 0xbae0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ctx.c
// Function: fin_ctx_eval_file
void fin_ctx_eval_file(fin_ctx_t* ctx, const char* path) {
    FILE* fp = fopen(path, "rb");
    if (!fp)
        return;

    fseek(fp, 0, SEEK_END);
    int32_t file_size = (int32_t)ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char* buffer = (char*)ctx->alloc(NULL, file_size + 1);
    assert(buffer);
    int32_t read = (int32_t)fread(buffer, 1, file_size, fp);
    buffer[file_size] = '\0';
    assert(read == file_size);
    fclose(fp);

    fin_ctx_eval_str(ctx, buffer);

    ctx->alloc(buffer, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f7e(%rip), %rsi      # 0xd299
callq 0x3240
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6330
jmp 0x640f
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3210
movq -0x18(%rbp), %rdi
callq 0x31a0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %esi
addl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x637d
jmp 0x639c
leaq 0x6f18(%rip), %rdi      # 0xd29c
leaq 0x6f18(%rip), %rsi      # 0xd2a3
movl $0x51, %edx
leaq 0x6f1a(%rip), %rcx      # 0xd2b1
callq 0x3110
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x3090
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x63cb
jmp 0x63ea
leaq 0x6f11(%rip), %rdi      # 0xd2e3
leaq 0x6eca(%rip), %rsi      # 0xd2a3
movl $0x54, %edx
leaq 0x6ecc(%rip), %rcx      # 0xd2b1
callq 0x3110
movq -0x18(%rbp), %rdi
callq 0x30e0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_create
fin_lex_t* fin_lex_create(fin_alloc alloc, const char* cstr) {
    fin_lex_t* lex = (fin_lex_t*)alloc(NULL, sizeof(fin_lex_t));
    lex->cstr = cstr;
    lex->line = 1;
    lex->state_idx = 0;
    lex->states[0].type = fin_lex_state_type_global;
    lex->states[0].cstr = cstr;
    fin_lex_next(lex);
    return lex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x130, %esi            # imm = 0x130
callq *-0x8(%rbp)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x128(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdi
callq 0x6490
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_match
bool fin_lex_match(fin_lex_t* lex, fin_lex_type_t type) {
    if (lex->token.type == type) {
        fin_lex_next(lex);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6cfa
movq -0x10(%rbp), %rdi
callq 0x6490
movb $0x1, -0x1(%rbp)
jmp 0x6cfe
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_consume_string
fin_lex_str_t fin_lex_consume_string(fin_lex_t* lex) {
    fin_lex_str_t value;
    value.cstr = lex->token.cstr;
    value.len = lex->token.len;
    fin_lex_next(lex);
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6490
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_create_token
static fin_lex_token_t fin_lex_create_token(fin_lex_t* lex, fin_lex_type_t type) {
    fin_lex_token_t token;
    token.type = type;
    token.cstr = NULL;
    token.len = 0;
    token.line = lex->line;
    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x14(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_match_char
static bool fin_lex_match_char(fin_lex_t* lex, char c) {
    if (*lex->cstr == c) {
        lex->cstr++;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x70e4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x70e8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_skip_block_comment
static void fin_lex_skip_block_comment(fin_lex_t* lex) {
    while (lex->cstr[0] != '\0') {
        if (lex->cstr[0] == '*' && lex->cstr[1] == '/') {
            lex->cstr += 2;
            return;
        }
        if (lex->cstr[0] == '\n')
            lex->line++;
        lex->cstr++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x71b2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x7186
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x7186
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x71b2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x71a2
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x7148
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_create_name_token
static fin_lex_token_t fin_lex_create_name_token(fin_lex_t* lex) {
    fin_lex_token_t token;
    token.cstr = lex->cstr - 1;
    token.line = lex->line;

    while (fin_lex_is_name(*lex->cstr) || fin_lex_is_digit(*lex->cstr))
        lex->cstr++;
    token.len = (int32_t)(lex->cstr - token.cstr);

    for (int32_t i=0; i<FIN_COUNT_OF(fin_lex_keywords); i++) {
        const char* keyword = fin_lex_keywords[i].cstr;
        if (strncmp(keyword, token.cstr, token.len) == 0 && keyword[token.len] == '\0') {
            token.type = fin_lex_keywords[i].type;
            return token;
        }
    }

    token.type = fin_lex_type_name;
    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rdi)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rdi)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x7220
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x72dd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x73b0
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x72e6
jmp 0x72f6
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x72b0
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rax), %rdx
subq %rdx, %rcx
movl %ecx, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0xe, %rax
jae 0x738e
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0xa515(%rip), %rcx      # 0x11840
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
movslq 0x10(%rax), %rdx
callq 0x3080
cmpl $0x0, %eax
jne 0x7381
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x7381
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0xa4cd(%rip), %rcx      # 0x11840
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
movl %ecx, (%rax)
jmp 0x7398
jmp 0x7383
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7312
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_create_number_token
static fin_lex_token_t fin_lex_create_number_token(fin_lex_t* lex) {
    fin_lex_token_t token;
    token.cstr = lex->cstr - 1;
    token.line = lex->line;

    bool is_float = false;
    while (fin_lex_is_digit(*lex->cstr))
        lex->cstr++;
    if (fin_lex_match_char(lex, '.'))
        is_float = true;
    while (fin_lex_is_digit(*lex->cstr))
        lex->cstr++;

    token.type = is_float ? fin_lex_type_float : fin_lex_type_int;
    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rdi)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rdi)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x73b0
testb $0x1, %al
jne 0x7429
jmp 0x7439
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x7414
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x70b0
testb $0x1, %al
jne 0x744d
jmp 0x7451
movb $0x1, -0x9(%rbp)
jmp 0x7453
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x73b0
testb $0x1, %al
jne 0x7468
jmp 0x7478
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x7453
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb -0x9(%rbp), %dil
movl $0x1, %edx
movl $0x2, %esi
testb $0x1, %dil
cmovnel %esi, %edx
movl %edx, (%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_lex.c
// Function: fin_lex_error
static void fin_lex_error(fin_lex_t* lex, const char* format, ...) {
    char message[256];
    va_list args;
    va_start(args, format);
    vsprintf(message, format, args);
    va_end(args);
    printf("<file>:%d:%d error: %s\n", lex->line, 0, message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
testb %al, %al
je 0x74e7
movaps %xmm0, -0x1b0(%rbp)
movaps %xmm1, -0x1a0(%rbp)
movaps %xmm2, -0x190(%rbp)
movaps %xmm3, -0x180(%rbp)
movaps %xmm4, -0x170(%rbp)
movaps %xmm5, -0x160(%rbp)
movaps %xmm6, -0x150(%rbp)
movaps %xmm7, -0x140(%rbp)
movq %r9, -0x1b8(%rbp)
movq %r8, -0x1c0(%rbp)
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1e0(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movl $0x30, -0x12c(%rbp)
movl $0x10, -0x130(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
leaq -0x130(%rbp), %rdx
callq 0x3230
movq -0x1e8(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x6004(%rip), %rdi      # 0xd56f
xorl %edx, %edx
movb %dl, %al
callq 0x3100
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_register
static void fin_mod_register(fin_ctx_t* ctx, fin_mod_t* mod) {
    mod->next = ctx->mod;
    ctx->mod = mod;

    for (int32_t i=0; i<mod->binds_count; i++) {
        fin_mod_t* m = ctx->mod;
        while (m) {
            for (int32_t f=0; f<m->funcs_count; f++) {
                if (m->funcs[f].sign == mod->binds[i].sign) {
                    mod->binds[i].func = &m->funcs[f];
                    break;
                }
            }
            if (mod->binds[i].func)
                break;
            m = m->next;
        }
        if (!mod->binds[i].func) {
            printf("Unresolved function %s\n", fin_str_cstr(mod->binds[i].sign));
            assert(mod->binds[i].func);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jge 0x7ad5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7a42
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x7a15
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x7a08
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x24(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x7a15
jmp 0x7a0a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x79a1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x7a31
jmp 0x7a42
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x798f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x7ac5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0xb370
movq %rax, %rsi
leaq 0x5bf8(%rip), %rdi      # 0xd679
movb $0x0, %al
callq 0x3100
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x7aa4
jmp 0x7ac3
leaq 0x5be6(%rip), %rdi      # 0xd691
leaq 0x5bf2(%rip), %rsi      # 0xd6a4
movl $0x307, %edx            # imm = 0x307
leaq 0x5bf4(%rip), %rcx      # 0xd6b2
callq 0x3110
jmp 0x7ac5
jmp 0x7ac7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7973
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_compile_type
static void fin_mod_compile_type(fin_ctx_t* ctx, fin_ast_type_t* type, fin_mod_type_t* dest_type) {
    int32_t fields = 0;
    fin_ast_field_t* field = type->fields;
    while (field) {
        fields++;
        field = field->next;
    }
    dest_type->name = fin_str_clone(type->name);
    dest_type->fields_count = fields;
    dest_type->fields = (fin_mod_field_t*)ctx->alloc(NULL, sizeof(fin_mod_field_t) * fields);

    field = type->fields;
    fin_mod_field_t* f = dest_type->fields;
    while (field) {
        f->name = fin_str_clone(field->name);
        f->type = fin_str_clone(field->type->name);
        field = field->next;
        f++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7fa5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7f87
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
movl %ecx, %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8052
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0xb130
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xb130
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x7fff
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_find_func
static fin_mod_func_t* fin_mod_find_func(fin_ctx_t* ctx, fin_mod_t* mod, fin_str_t* sign) {
    for (int32_t i=0; i<mod->funcs_count; i++) {
        if (mod->funcs[i].sign == sign)
            return &mod->funcs[i];
    }
    fin_mod_t* m = ctx->mod;
    while (m) {
        for (int32_t i=0; i<m->funcs_count; i++) {
            if (m->funcs[i].sign == sign)
                return &m->funcs[i];
        }
        m = m->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x82b9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x82ac
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8338
jmp 0x82ae
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8267
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8330
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x8322
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x8315
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8338
jmp 0x8317
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x82d3
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x82c5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_compile_init_expr
static void fin_mod_compile_init_expr(fin_ctx_t* ctx, fin_mod_compiler_t* cmp, fin_ast_init_expr_t* expr, fin_str_t* type_name) {
    fin_mod_type_t* type = fin_mod_find_type(ctx, cmp->mod, type_name);
    assert(type);
    int32_t args_count = 0;
    for (fin_ast_arg_expr_t* e = expr->args; e; e = e->next)
        args_count++;
    assert(args_count == type->fields_count);
    int32_t idx = 0;
    for (fin_ast_arg_expr_t* e = expr->args; e; e = e->next) {
        fin_str_t* arg_type = fin_mod_resolve_type(ctx, cmp, e->expr);
        assert(arg_type == type->fields[idx].type);
        fin_str_destroy(ctx, arg_type);
        fin_mod_compile_expr(ctx, cmp, e->expr);
        idx++;
    }
    fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_new);
    fin_mod_code_emit_uint8(ctx, &cmp->code, type->fields_count);
    FIN_LOG("\tnew        %2d         // %s\n", type->fields_count, fin_str_cstr(type->name));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xa8b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x99a9
jmp 0x99c8
leaq 0x407c(%rip), %rdi      # 0xda2c
leaq 0x3ced(%rip), %rsi      # 0xd6a4
movl $0x213, %edx            # imm = 0x213
leaq 0x3fc4(%rip), %rcx      # 0xd987
callq 0x3110
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x99f9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x99db
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x9a07
jmp 0x9a26
leaq 0x3fdf(%rip), %rdi      # 0xd9ed
leaq 0x3c8f(%rip), %rsi      # 0xd6a4
movl $0x217, %edx            # imm = 0x217
leaq 0x3f66(%rip), %rcx      # 0xd987
callq 0x3110
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x9ad7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9cb0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jne 0x9a7c
jmp 0x9a9b
leaq 0x3f8b(%rip), %rdi      # 0xda0e
leaq 0x3c1a(%rip), %rsi      # 0xd6a4
movl $0x21b, %edx            # imm = 0x21B
leaq 0x3ef1(%rip), %rcx      # 0xd987
callq 0x3110
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x9a39
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0xd, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
movzbl %al, %edx
callq 0x8d90
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_resolve_local
static fin_mod_local_t* fin_mod_resolve_local(fin_mod_compiler_t* cmp, fin_str_t* id) {
    for (int32_t i=0; i<cmp->locals_count; i++)
        if (cmp->locals[i].name == id)
            return &cmp->locals[i];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1a30(%rcx), %ecx
cmpl %ecx, %eax
jge 0x9c9b
movq -0x10(%rbp), %rax
addq $0x130, %rax            # imm = 0x130
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x9c8e
movq -0x10(%rbp), %rax
addq $0x130, %rax            # imm = 0x130
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x9ca3
jmp 0x9c90
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9c43
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_resolve_field
static int32_t fin_mod_resolve_field(fin_ctx_t* ctx, fin_mod_t* mod, fin_str_t* type_name, fin_str_t* field_name) {
    fin_mod_type_t* type = fin_mod_find_type(ctx, mod, type_name);
    for (int32_t i=0; i<type->fields_count; i++) {
        if (type->fields[i].name == field_name)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa8b0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xa121
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0xa114
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa128
jmp 0xa116
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa0e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_const_idx
static int16_t fin_mod_const_idx(fin_mod_compiler_t* cmp, fin_val_t val) {
    fin_mod_t* mod = cmp->mod;
    for (int32_t i=0; i<mod->consts_count; i++) {
        if (val.i == mod->consts[i].i)
            return i;
    }
    mod->consts[mod->consts_count] = val;
    return mod->consts_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xa196
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x24(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0xa189
movl -0x24(%rbp), %eax
movw %ax, -0x2(%rbp)
jmp 0xa1c1
jmp 0xa18b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa15e
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rcx
movl 0x30(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x30(%rcx)
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_bind_idx
static int16_t fin_mod_bind_idx(fin_mod_compiler_t* cmp, fin_str_t* sign) {
    fin_mod_t* mod = cmp->mod;
    for (int32_t i=0; i<mod->binds_count; i++) {
        if (sign == mod->binds[i].sign)
            return i;
    }
    mod->binds[mod->binds_count].sign = fin_str_clone(sign);
    mod->binds[mod->binds_count].func = NULL;
    return mod->binds_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jge 0xa230
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0xa223
movl -0x24(%rbp), %eax
movw %ax, -0x2(%rbp)
jmp 0xa288
jmp 0xa225
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa1f2
movq -0x18(%rbp), %rdi
callq 0xb130
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rdx
movslq 0x34(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x34(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0x34(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x34(%rcx)
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_unary_get_signature
static fin_str_t* fin_mod_unary_get_signature(fin_ctx_t* ctx, fin_mod_compiler_t* cmp, fin_ast_unary_expr_t* unary_expr) {
    char sign[128];
    sign[0] = '\0';
    switch (unary_expr->op) {
        case fin_ast_unary_type_pos:  strcat(sign, "__op_pos"); break;
        case fin_ast_unary_type_neg:  strcat(sign, "__op_neg"); break;
        case fin_ast_unary_type_not:  strcat(sign, "__op_not"); break;
        case fin_ast_unary_type_bnot: strcat(sign, "__op_bnot"); break;
        case fin_ast_unary_type_inc:  strcat(sign, "__op_inc"); break;
        case fin_ast_unary_type_dec:  strcat(sign, "__op_dec"); break;
    }
    strcat(sign, "(");
    strcat(sign, fin_str_cstr(fin_mod_resolve_type(ctx, cmp, unary_expr->expr)));
    strcat(sign, ")");
    return fin_str_create(ctx, sign, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0xa8(%rbp)
subq $0x5, %rax
ja 0xa369
movq -0xa8(%rbp), %rax
leaq 0x332c(%rip), %rcx      # 0xd610
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xa0(%rbp), %rdi
leaq 0x35b5(%rip), %rsi      # 0xd8b0
callq 0x3270
jmp 0xa369
leaq -0xa0(%rbp), %rdi
leaq 0x35a9(%rip), %rsi      # 0xd8b9
callq 0x3270
jmp 0xa369
leaq -0xa0(%rbp), %rdi
leaq 0x359d(%rip), %rsi      # 0xd8c2
callq 0x3270
jmp 0xa369
leaq -0xa0(%rbp), %rdi
leaq 0x3591(%rip), %rsi      # 0xd8cb
callq 0x3270
jmp 0xa369
leaq -0xa0(%rbp), %rdi
leaq 0x3586(%rip), %rsi      # 0xd8d5
callq 0x3270
jmp 0xa369
leaq -0xa0(%rbp), %rdi
leaq 0x357a(%rip), %rsi      # 0xd8de
callq 0x3270
leaq -0xa0(%rbp), %rdi
leaq 0x3449(%rip), %rsi      # 0xd7c0
callq 0x3270
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9cb0
movq %rax, %rdi
callq 0xb370
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
leaq -0xa0(%rbp), %rdi
leaq 0x3d50(%rip), %rsi      # 0xe114
callq 0x3270
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xae20
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_invoke_get_signature
static fin_str_t* fin_mod_invoke_get_signature(fin_ctx_t* ctx, fin_mod_compiler_t* cmp, fin_ast_invoke_expr_t* expr) {
    char signature[128];
    signature[0] = '\0';
    if (expr->id->type == fin_ast_expr_type_id) {
        fin_ast_id_expr_t* id_expr = (fin_ast_id_expr_t*)expr->id;
        if (id_expr->primary && id_expr->primary->type == fin_ast_expr_type_id) {
            fin_ast_id_expr_t* prim_id_expr = (fin_ast_id_expr_t*)id_expr->primary;
            strcat(signature, fin_str_cstr(prim_id_expr->name));
            strcat(signature, ".");
        }
        strcat(signature, fin_str_cstr(id_expr->name));
    }
    strcat(signature, "(");
    for (fin_ast_arg_expr_t* e = expr->args; e; e = e->next) {
        if (e != expr->args)
            strcat(signature, ",");
        fin_str_t* arg_type = fin_mod_resolve_type(ctx, cmp, &e->base);
        strcat(signature, fin_str_cstr(arg_type));
        fin_str_destroy(ctx, arg_type);
    }
    strcat(signature, ")");
    return fin_str_create(ctx, signature, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0xa7bb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa78e
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0xa78e
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xb0(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb370
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
leaq -0xa0(%rbp), %rdi
leaq 0x2d96(%rip), %rsi      # 0xd51f
callq 0x3270
leaq -0xa0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb370
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
leaq -0xa0(%rbp), %rdi
leaq 0x2ff7(%rip), %rsi      # 0xd7c0
callq 0x3270
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
je 0xa87a
movq -0xb8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xa80f
leaq -0xa0(%rbp), %rdi
leaq 0x2e66(%rip), %rsi      # 0xd670
callq 0x3270
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x9cb0
movq %rax, -0xc0(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xc0(%rbp), %rdi
callq 0xb370
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
movq -0x8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0xb0b0
movq -0xb8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb8(%rbp)
jmp 0xa7dd
leaq -0xa0(%rbp), %rdi
leaq 0x388c(%rip), %rsi      # 0xe114
callq 0x3270
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xae20
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_find_type
static fin_mod_type_t* fin_mod_find_type(fin_ctx_t* ctx, fin_mod_t* mod, fin_str_t* name) {
    for (int32_t i=0; i<mod->types_count; i++) {
        if (mod->types[i].name == name)
            return &mod->types[i];
    }
    fin_mod_t* m = ctx->mod;
    while (m) {
        for (int32_t i=0; i<m->types_count; i++) {
            if (m->types[i].name == name)
                return &m->types[i];
        }
        m = m->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0xa918
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xa90b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xa996
jmp 0xa90d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa8c7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa98e
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0xa980
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xa973
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xa996
jmp 0xa975
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa932
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa924
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_code_ensure
static void fin_mod_code_ensure(fin_ctx_t* ctx, fin_mod_code_t* code, int32_t size) {
    if (code->top + size >= code->end) {
        int32_t length;
        uint8_t* buffer;
        if (code->begin == code->storage) {
            length = sizeof(code->storage) * 2;
            buffer = ctx->alloc(NULL, length);
            memcpy(buffer, code->begin, code->top - code->begin);
        }
        else {
            length = (int32_t)(code->end - code->begin) * 2;
            buffer = ctx->alloc(code->begin, length);
        }
        code->top   = buffer + (code->top - code->begin);
        code->begin = buffer;
        code->end   = buffer + length;
    }
}

// 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 (%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xaa93
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0xaa24
movl $0x200, -0x18(%rbp)     # imm = 0x200
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq %rax, %rdx
callq 0x31b0
jmp 0xaa54
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x18(%rbp), %esi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_obj.c
// Function: fin_obj_create
fin_obj_t* fin_obj_create(fin_alloc alloc, fin_val_t* fields, int32_t fields_count) {
    fin_obj_t* obj = (fin_obj_t*)alloc(NULL, sizeof(fin_obj_t*) + sizeof(fin_val_t) * fields_count);
    obj->ref = 1;
    for (int32_t i=0; i<fields_count; i++)
        obj->fields[i] = fields[i];
    return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq $0x8, %rcx
movl %ecx, %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xab0c
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq -0x24(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xaae0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_resize
void fin_str_resize(fin_str_pool_t* pool, int32_t capacity) {
    fin_str_pool_t new_pool;
    new_pool.entries = (fin_str_entry_t*)pool->alloc(NULL, sizeof(fin_str_entry_t) * capacity);
    new_pool.capacity = capacity;
    new_pool.count = 0;
    new_pool.alloc = pool->alloc;
    for (int32_t i=0; i<capacity; i++) {
        new_pool.entries[i].hash = 0;
        new_pool.entries[i].str = NULL;
    }
    for (int32_t i=0; i<pool->capacity; i++)
        if (pool->entries[i].str != 0)
            fin_str_insert(&new_pool, pool->entries[i].hash, pool->entries[i].str);
    pool->alloc(pool->entries, 0);
    *pool = new_pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
movl %ecx, %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xac3a
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xabfb
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xaca6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0xac99
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq -0x28(%rbp), %rdi
callq 0xace0
jmp 0xac9b
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xac41
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
xorl %esi, %esi
callq *%rax
movq -0x8(%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)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_insert
static void fin_str_insert(fin_str_pool_t* pool, int32_t hash, fin_str_t* str) {
    int32_t slot = (uint32_t)hash % pool->capacity;
    int32_t end_slot = slot;
    do {
        fin_str_entry_t* entry = &pool->entries[slot];
        if (entry->hash == 0 || entry->str == NULL) {
            entry->hash = hash;
            entry->str = str;
            str->slot = slot;
            pool->count++;
            break;
        }
        slot = (slot + 1) % pool->capacity;
    } while (slot != end_slot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0xad2e
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xad5c
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0xad75
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x8(%rcx)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0xad04
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_pool_create
fin_str_pool_t* fin_str_pool_create(fin_alloc alloc) {
    fin_str_pool_t* pool = (fin_str_pool_t*)alloc(NULL, sizeof(fin_str_pool_t));
    pool->entries = NULL;
    pool->capacity = 0;
    pool->count = 0;
    pool->alloc = alloc;
    return pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x18, %esi
callq *-0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_hash
static int32_t fin_str_hash(const char* cstr, int32_t* len) {
    const int32_t prime = 16777619;
    const int32_t basis = 2166136261;
    int32_t hash = basis;
    const char* iter = cstr;
    const char* term = iter + *len;
    while (*iter && iter != term) {
        hash ^= *iter++;
        hash *= prime;
    }
    *len = (int32_t)(iter - cstr);
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1000193, -0x14(%rbp) # imm = 0x1000193
movl $0x811c9dc5, -0x18(%rbp) # imm = 0x811C9DC5
movl $0x811c9dc5, -0x1c(%rbp) # imm = 0x811C9DC5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xb06a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb073
jmp 0xb097
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
imull $0x1000193, -0x1c(%rbp), %eax # imm = 0x1000193
movl %eax, -0x1c(%rbp)
jmp 0xb04b
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_destroy
void fin_str_destroy(fin_ctx_t* ctx, fin_str_t* str) {
    fin_str_pool_t* pool = ctx->pool;
    if (--str->ref == 0) {
        pool->entries[str->slot].str = NULL;
        pool->entries[str->slot].hash = 1;
        pool->alloc(str, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0xb126
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)