LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_cond_or_expr
static fin_ast_expr_t* fin_ast_parse_cond_or_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_cond_and_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_pipe_pipe))
        op = fin_ast_binary_type_or;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_cond_or_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1a, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x3f65
jmp 0x3f6e
movl $0x11, -0x24(%rbp)
jmp 0x3f78
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3fcb
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f30
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_cond_expr
static fin_ast_expr_t* fin_ast_parse_cond_expr(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* cond) {
    fin_ast_cond_expr_t* cond_expr = (fin_ast_cond_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_cond_expr_t));
    cond_expr->base.type = fin_ast_expr_type_cond;
    cond_expr->cond = cond;
    fin_ast_expect(lex, fin_lex_type_question);
    cond_expr->true_expr = fin_ast_parse_cond_or_expr(ctx, lex);
    fin_ast_expect(lex, fin_lex_type_colon);
    cond_expr->false_expr = fin_ast_parse_cond_or_expr(ctx, lex);
    return &cond_expr->base;
}

// 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
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x20, %esi
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x8, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_id_expr
static fin_ast_expr_t* fin_ast_parse_id_expr(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* primary) {
    fin_ast_id_expr_t* id_expr = (fin_ast_id_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_id_expr_t));
    id_expr->base.type = fin_ast_expr_type_id;
    id_expr->primary = primary;
    id_expr->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    if (fin_lex_match(lex, fin_lex_type_dot))
        return fin_ast_parse_id_expr(ctx, lex, &id_expr->base);
    return &id_expr->base;
}

// 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
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6e30
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl %edx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movl -0x30(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4104
jmp 0x411b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4080
movq %rax, -0x8(%rbp)
jmp 0x4123
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_invoke_expr
static fin_ast_expr_t* fin_ast_parse_invoke_expr(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* id) {
    fin_ast_invoke_expr_t* invoke_expr = (fin_ast_invoke_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_invoke_expr_t));
    invoke_expr->base.type = fin_ast_expr_type_invoke;
    invoke_expr->id = id;
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_arg_expr_t** tail = &invoke_expr->args;
    *tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_paren)) {
        if (invoke_expr->args)
            fin_ast_expect(lex, fin_lex_type_comma);
        *tail = fin_ast_parse_arg_expr(ctx, lex);
        tail = &(*tail)->next;
    }
    return &invoke_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3ae0
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x41a8
jmp 0x41e9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x41c1
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5060
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x4192
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_ast.c
// Function: fin_ast_parse_cond_and_expr
static fin_ast_expr_t* fin_ast_parse_cond_and_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_or_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_amp_amp))
        op = fin_ast_binary_type_and;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_cond_and_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1b, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4455
jmp 0x445e
movl $0x10, -0x24(%rbp)
jmp 0x4468
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44bb
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_or_expr
static fin_ast_expr_t* fin_ast_parse_or_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_xor_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_pipe))
        op = fin_ast_binary_type_bor;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_or_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4580
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x16, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4505
jmp 0x450e
movl $0xe, -0x24(%rbp)
jmp 0x4518
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x456b
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_xor_expr
static fin_ast_expr_t* fin_ast_parse_xor_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_and_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_caret))
        op = fin_ast_binary_type_bxor;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_xor_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4630
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xd, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x45b5
jmp 0x45be
movl $0xf, -0x24(%rbp)
jmp 0x45c8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x461b
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4580
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_and_expr
static fin_ast_expr_t* fin_ast_parse_and_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_equality_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_amp))
        op = fin_ast_binary_type_eq;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_and_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xf, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4665
jmp 0x466e
movl $0xb, -0x24(%rbp)
jmp 0x4678
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46cb
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4630
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_equality_expr
static fin_ast_expr_t* fin_ast_parse_equality_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_relational_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_eq_eq))
        op = fin_ast_binary_type_eq;
    else if (fin_lex_match(lex, fin_lex_type_bang_eq))
        op = fin_ast_binary_type_neq;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_equality_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x47b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1c, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4715
jmp 0x471e
movl $0xb, -0x24(%rbp)
jmp 0x4747
movq -0x18(%rbp), %rdi
movl $0x1d, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4732
jmp 0x473b
movl $0xc, -0x24(%rbp)
jmp 0x4745
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x479a
jmp 0x4747
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_relational_expr
static fin_ast_expr_t* fin_ast_parse_relational_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_shift_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_lt))
        op = fin_ast_binary_type_ls;
    else if (fin_lex_match(lex, fin_lex_type_gt))
        op = fin_ast_binary_type_gr;
    else if (fin_lex_match(lex, fin_lex_type_lt_eq))
        op = fin_ast_binary_type_leq;
    else if (fin_lex_match(lex, fin_lex_type_gt_eq))
        op = fin_ast_binary_type_geq;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_shift_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x26, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x47e5
jmp 0x47ee
movl $0x7, -0x24(%rbp)
jmp 0x4855
movq -0x18(%rbp), %rdi
movl $0x2a, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4802
jmp 0x480b
movl $0x9, -0x24(%rbp)
jmp 0x4853
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x481f
jmp 0x4828
movl $0x8, -0x24(%rbp)
jmp 0x4851
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x483c
jmp 0x4845
movl $0xa, -0x24(%rbp)
jmp 0x484f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48a8
jmp 0x4851
jmp 0x4853
jmp 0x4855
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_shift_expr
static fin_ast_expr_t* fin_ast_parse_shift_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_additive_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_lt_lt))
        op = fin_ast_binary_type_shl;
    else if (fin_lex_match(lex, fin_lex_type_gt_gt))
        op = fin_ast_binary_type_shr;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_shift_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4990
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x27, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x48f5
jmp 0x48fe
movl $0x5, -0x24(%rbp)
jmp 0x4927
movq -0x18(%rbp), %rdi
movl $0x2b, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4912
jmp 0x491b
movl $0x6, -0x24(%rbp)
jmp 0x4925
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x497a
jmp 0x4927
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_additive_expr
static fin_ast_expr_t* fin_ast_parse_additive_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_multiplicative_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_plus))
        op = fin_ast_binary_type_add;
    else if (fin_lex_match(lex, fin_lex_type_minus))
        op = fin_ast_binary_type_sub;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_additive_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x12, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x49c5
jmp 0x49ce
movl $0x0, -0x24(%rbp)
jmp 0x49f7
movq -0x18(%rbp), %rdi
movl $0x13, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x49e2
jmp 0x49eb
movl $0x1, -0x24(%rbp)
jmp 0x49f5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a4a
jmp 0x49f7
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4990
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_multiplicative_expr
static fin_ast_expr_t* fin_ast_parse_multiplicative_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_unary_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_star))
        op = fin_ast_binary_type_mul;
    else if (fin_lex_match(lex, fin_lex_type_slash))
        op = fin_ast_binary_type_div;
    else if (fin_lex_match(lex, fin_lex_type_percent))
        op = fin_ast_binary_type_mod;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_multiplicative_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4b50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x14, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4a95
jmp 0x4a9e
movl $0x2, -0x24(%rbp)
jmp 0x4ae6
movq -0x18(%rbp), %rdi
movl $0x15, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4ab2
jmp 0x4abb
movl $0x3, -0x24(%rbp)
jmp 0x4ae4
movq -0x18(%rbp), %rdi
movl $0x17, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4acf
jmp 0x4ad8
movl $0x4, -0x24(%rbp)
jmp 0x4ae2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b39
jmp 0x4ae4
jmp 0x4ae6
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a60
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_str_interp_expr
static fin_ast_expr_t* fin_ast_parse_str_interp_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_str_interp_expr_t* expr = NULL;
    fin_ast_str_interp_expr_t** tail = &expr;
    fin_ast_expect(lex, fin_lex_type_quot);
    while (!fin_lex_match(lex, fin_lex_type_quot)) {
        fin_ast_expr_t* next = NULL;
        if (fin_lex_get_type(lex) == fin_lex_type_string)
            next = fin_ast_parse_const_expr(ctx, lex);
        else if (fin_lex_match(lex, fin_lex_type_l_str_interp)) {
            next = fin_ast_parse_expr(ctx, lex, NULL);
            fin_ast_expect(lex, fin_lex_type_r_str_interp);
        }
        *tail = (fin_ast_str_interp_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_str_interp_expr_t));
        (*tail)->base.type = fin_ast_expr_type_str_interp;
        (*tail)->expr = next;
        (*tail)->next = NULL;
        tail = &(*tail)->next;
    }
    return &expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4f97
jmp 0x5051
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d10
cmpl $0x3, %eax
jne 0x4fc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4dc0
movq %rax, -0x28(%rbp)
jmp 0x4ff9
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x4fd4
jmp 0x4ff7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x3ae0
jmp 0x4ff9
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl $0x5, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x4f7e
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_arg_expr
static fin_ast_arg_expr_t* fin_ast_parse_arg_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* expr = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_arg_expr_t* arg_expr = (fin_ast_arg_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_arg_expr_t));
    arg_expr->base.type = fin_ast_expr_type_arg;
    arg_expr->expr = expr;
    arg_expr->next = NULL;
    return arg_expr;
}

// 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
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x9, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_block_stmt
static fin_ast_block_stmt_t* fin_ast_parse_block_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_block_stmt_t* block = (fin_ast_block_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_block_stmt_t));
    block->base.type = fin_ast_stmt_type_block;
    block->base.next = NULL;
    fin_ast_expect(lex, fin_lex_type_l_brace);
    fin_ast_stmt_t** tail = &block->stmts;
    *tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_brace)) {
        *tail = fin_ast_parse_stmt(ctx, lex);
        tail = &(*tail)->next;
    }
    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x33, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x51d4
jmp 0x51fc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5210
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x51be
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_stmt
static fin_ast_stmt_t* fin_ast_parse_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    switch (fin_lex_get_type(lex)) {
        case fin_lex_type_l_brace:
            return &fin_ast_parse_block_stmt(ctx, lex)->base;
        case fin_lex_type_if:
            return fin_ast_parse_if_stmt(ctx, lex);
        //case fin_lex_type_switch:
        //    return fin_ast_parse_switch_stmt(lex);
        case fin_lex_type_while:
            return fin_ast_parse_while_stmt(ctx, lex);
        case fin_lex_type_do:
            return fin_ast_parse_do_stmt(ctx, lex);
        case fin_lex_type_for:
            return fin_ast_parse_for_stmt(ctx, lex);
//        case fin_lex_type_break:
//            return fin_ast_parse_break_stmt(lex);
//        case fin_lex_type_continue:
//            return fin_ast_parse_continue_stmt(lex);
        case fin_lex_type_return:
            return fin_ast_parse_ret_stmt(ctx, lex);
        case fin_lex_type_name:
            return fin_ast_parse_expr_or_decl_stmt(ctx, lex);
        default:
            return fin_ast_parse_expr_stmt(ctx, lex, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6d10
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x39, %eax
ja 0x52d7
movq -0x20(%rbp), %rax
leaq 0x7e8a(%rip), %rcx      # 0xd0d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5160
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5300
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x53f0
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54a0
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5570
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5680
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5740
movq %rax, -0x8(%rbp)
jmp 0x52ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5910
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_if_stmt
static fin_ast_stmt_t* fin_ast_parse_if_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expect(lex, fin_lex_type_if);
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_expr_t* cond = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_r_paren);
    fin_ast_stmt_t* true_stmt = fin_ast_parse_stmt(ctx, lex);
    fin_ast_stmt_t* false_stmt = NULL;
    if (fin_lex_match(lex, fin_lex_type_else))
        false_stmt = fin_ast_parse_stmt(ctx, lex);
    fin_ast_if_stmt_t* stmt = (fin_ast_if_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_if_stmt_t));
    stmt->base.type = fin_ast_stmt_type_if;
    stmt->base.next = NULL;
    stmt->cond = cond;
    stmt->true_stmt = true_stmt;
    stmt->false_stmt = false_stmt;
    return &stmt->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x36, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5210
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x37, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x537c
jmp 0x538d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5210
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x28, %esi
callq *(%rax)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_while_stmt
static fin_ast_stmt_t* fin_ast_parse_while_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expect(lex, fin_lex_type_while);
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_expr_t* cond = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_r_paren);
    fin_ast_stmt_t* stmt = fin_ast_parse_stmt(ctx, lex);
    fin_ast_while_stmt_t* while_stmt = (fin_ast_while_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_while_stmt_t));
    while_stmt->base.type = fin_ast_stmt_type_while;
    while_stmt->base.next = NULL;
    while_stmt->cond = cond;
    while_stmt->stmt = stmt;
    return &while_stmt->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5210
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x20, %esi
callq *(%rax)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_do_stmt
static fin_ast_stmt_t* fin_ast_parse_do_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expect(lex, fin_lex_type_do);
    fin_ast_stmt_t* stmt = fin_ast_parse_stmt(ctx, lex);
    fin_ast_expect(lex, fin_lex_type_while);
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_expr_t* cond = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_r_paren);
    fin_ast_expect(lex, fin_lex_type_semicolon);
    fin_ast_do_stmt_t* do_stmt = (fin_ast_do_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_do_stmt_t));
    do_stmt->base.type = fin_ast_stmt_type_do;
    do_stmt->base.next = NULL;
    do_stmt->cond = cond;
    do_stmt->stmt = stmt;
    return &do_stmt->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x39, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5210
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x20, %esi
callq *(%rax)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x5, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_for_stmt
static fin_ast_stmt_t* fin_ast_parse_for_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expect(lex, fin_lex_type_for);
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_expr_t* init = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_semicolon);
    fin_ast_expr_t* cond = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_semicolon);
    fin_ast_expr_t* loop = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_r_paren);
    fin_ast_stmt_t* stmt = fin_ast_parse_stmt(ctx, lex);
    fin_ast_for_stmt_t* if_stmt = (fin_ast_for_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_for_stmt_t));
    if_stmt->base.type = fin_ast_stmt_type_for;
    if_stmt->base.next = NULL;
    if_stmt->init = init;
    if_stmt->cond = cond;
    if_stmt->loop = loop;
    if_stmt->stmt = stmt;
    return &if_stmt->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5210
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x30, %esi
callq *(%rax)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x3, (%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_ret_stmt
static fin_ast_stmt_t* fin_ast_parse_ret_stmt(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_ret_stmt_t* stmt = (fin_ast_ret_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_ret_stmt_t));
    stmt->base.type = fin_ast_stmt_type_ret;
    stmt->base.next = NULL;
    stmt->expr = NULL;
    fin_ast_expect(lex, fin_lex_type_return);
    if (fin_lex_get_type(lex) == fin_lex_type_l_brace)
        stmt->expr = fin_ast_parse_init_expr(ctx, lex);
    else if (fin_lex_get_type(lex) != fin_lex_type_semicolon)
        stmt->expr = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expect(lex, fin_lex_type_semicolon);
    return &stmt->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x3ae0
movq -0x10(%rbp), %rdi
callq 0x6d10
cmpl $0x32, %eax
jne 0x56fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5727
movq -0x10(%rbp), %rdi
callq 0x6d10
cmpl $0xc, %eax
je 0x5725
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5727
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_expr_stmt
static fin_ast_stmt_t* fin_ast_parse_expr_stmt(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* expr) {
    if (expr == NULL)
        expr = fin_ast_parse_expr(ctx, lex, NULL);
    fin_ast_expr_stmt_t* stmt = (fin_ast_expr_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_expr_stmt_t));
    stmt->base.type = fin_ast_stmt_type_expr;
    stmt->base.next = NULL;
    stmt->expr = expr;
    fin_ast_expect(lex, fin_lex_type_semicolon);
    return &stmt->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5940
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_init_expr
static fin_ast_expr_t* fin_ast_parse_init_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_init_expr_t* init_expr = (fin_ast_init_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_init_expr_t));
    init_expr->base.type = fin_ast_expr_type_init;
    fin_ast_expect(lex, fin_lex_type_l_brace);
    fin_ast_arg_expr_t** tail = &init_expr->args;
    *tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_brace)) {
        if (init_expr->args)
            fin_ast_expect(lex, fin_lex_type_comma);
        *tail = fin_ast_parse_arg_expr(ctx, lex);
        tail = &(*tail)->next;
    }
    return &init_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x10, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xb, (%rax)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x33, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x59f8
jmp 0x5a39
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5a11
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5060
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x59e2
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_decl_stmt
static fin_ast_stmt_t* fin_ast_parse_decl_stmt(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_type_ref_t* type) {
    fin_ast_decl_stmt_t* stmt = (fin_ast_decl_stmt_t*)ctx->alloc(NULL, sizeof(fin_ast_decl_stmt_t));
    stmt->base.type = fin_ast_stmt_type_decl;
    stmt->base.next = NULL;
    stmt->type = type;
    stmt->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    stmt->init = NULL;
    if (fin_lex_match(lex, fin_lex_type_eq)) {
        if (fin_lex_get_type(lex) == fin_lex_type_l_brace)
            stmt->init = fin_ast_parse_init_expr(ctx, lex);
        else
            stmt->init = fin_ast_parse_expr(ctx, lex, NULL);
    }
    fin_ast_expect(lex, fin_lex_type_semicolon);
    return &stmt->base;
}

// 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
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x28, %esi
callq *(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x5aec
jmp 0x5b32
movq -0x10(%rbp), %rdi
callq 0x6d10
cmpl $0x32, %eax
jne 0x5b14
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5990
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x5b30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x5b32
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_param_destroy
static void fin_ast_param_destroy(fin_ast_module_t* mod, fin_ast_param_t* param) {
    if (!param)
        return;
    fin_ast_param_destroy(mod, param->next);
    fin_ast_type_ref_destroy(mod, param->type);
    fin_str_destroy(mod->ctx, param->name);
    mod->ctx->alloc(param, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5b69
jmp 0x5bb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5b50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5db0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_type_ref_destroy
static void fin_ast_type_ref_destroy(fin_ast_module_t* mod, fin_ast_type_ref_t* type) {
    fin_str_destroy(mod->ctx, type->name);
    if (type->module)
        fin_str_destroy(mod->ctx, type->module);
    mod->ctx->alloc(type, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5df1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_enum_val_destroy
static void fin_ast_enum_val_destroy(fin_ast_module_t* mod, fin_ast_enum_val_t* val) {
    if (!val)
        return;
    fin_ast_enum_val_destroy(mod, val->next);
    fin_str_destroy(mod->ctx, val->name);
    fin_ast_expr_destroy(mod, val->expr);
    mod->ctx->alloc(val, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6059
jmp 0x60a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x6040
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5e10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_field_destroy
static void fin_ast_field_destroy(fin_ast_module_t* mod, fin_ast_field_t* field) {
    if (!field)
        return;
    fin_ast_field_destroy(mod, field->next);
    fin_str_destroy(mod->ctx, field->name);
    fin_ast_type_ref_destroy(mod, field->type);
    mod->ctx->alloc(field, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x60c9
jmp 0x6110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x60b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5db0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %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_create
fin_ctx_t* fin_ctx_create(fin_alloc alloc) {
    fin_ctx_t* ctx = (fin_ctx_t*)alloc(NULL, sizeof(fin_ctx_t));
    ctx->alloc = alloc;
    ctx->pool = fin_str_pool_create(alloc);
    ctx->mod = NULL;
    fin_io_register(ctx); // this should be optional
    fin_math_register(ctx); // this should be optional
    fin_time_register(ctx); // this should be optional
    fin_std_register(ctx); // this should be optional
    return ctx;
}

// 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 -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xad80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0xbb80
movq -0x10(%rbp), %rdi
callq 0xbcc0
movq -0x10(%rbp), %rdi
callq 0xcc80
movq -0x10(%rbp), %rdi
callq 0xc360
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)