LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: expr_stmt_to_c
struct rope *expr_stmt_to_c(struct ast *ast)
{
    if (ast->tag == INIT_EXPR)
        return NULL;

    struct expr expr = eval_expr(NULL, ast);
    if (ast->tag == DECL)
        return NULL;
    return add_indent_nl(rope_new_tree(expr.rope, semi_rope));
}

// Assembly:
pushq %rbx
cmpl $0x42f6, (%rdi)         # imm = 0x42F6
je 0x371e
movq %rdi, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x62d4
cmpl $0x4000, (%rbx)         # imm = 0x4000
jne 0x3722
xorl %eax, %eax
popq %rbx
retq
leaq 0xfdb7(%rip), %rsi      # 0x134e0
movq %rdx, %rdi
callq 0xaebf
movq %rax, %rdi
popq %rbx
jmp 0x3397
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: if_stmt_to_c
struct rope *if_stmt_to_c(struct ast *ast)
{
    struct rope *rope = if_sp_lparen_rope;
    struct ast *expr_ast = ast_ast(ast, 0);
    struct ast *then_block_ast = ast_ast(ast, 1);
    struct ast *else_block_ast = ast_ast(ast, 2);

    push_scope();

    if (expr_ast != NULL) {
        struct expr expr = eval_expr(NULL, expr_ast);
        if (!is_bool_type(expr.type))
            fatal(ast->loc, "condition has to be of boolean type");
        rope = rope_new_tree(rope, expr.rope);
    } else {
        rope = rope_new_tree(rope, one_rope);
    }

    rope = rope_new_tree(rope, rparen_sp_rope);
    rope = rope_new_tree(rope, block_to_c(then_block_ast));

    if (else_block_ast) {
        rope = rope_new_tree(rope, sp_else_sp_rope);
        if (else_block_ast->tag == IF_STMT)
            rope = rope_new_tree(rope, if_stmt_to_c(else_block_ast));
        else 
            rope = rope_new_tree(rope, block_to_c(else_block_ast));
    }

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
movl $0x1, %esi
movq %r15, %rdi
callq 0x27e8
movq %rax, %r14
movl $0x2, %esi
movq %r15, %rdi
callq 0x27e8
movq %rax, %rbx
leaq 0x10669(%rip), %r13     # 0x13de0
movq (%r13), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
callq 0xb040
movq %rax, (%r13)
testq %r12, %r12
je 0x37b2
xorl %edi, %edi
movq %r12, %rsi
callq 0x62d4
testb $-0x80, (%rax)
je 0x3843
leaq 0xfdd3(%rip), %rdi      # 0x13580
movq %rdx, %rsi
jmp 0x37c0
leaq 0xfdc7(%rip), %rdi      # 0x13580
leaq 0xff80(%rip), %rsi      # 0x13740
callq 0xaebf
leaq 0xfb34(%rip), %rsi      # 0x13300
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
movq %r14, %rdi
callq 0x3855
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
testq %rbx, %rbx
je 0x3826
leaq 0xfe0a(%rip), %rsi      # 0x13600
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
cmpl $0x4101, (%rbx)         # imm = 0x4101
jne 0x3813
movq %rbx, %rdi
callq 0x373a
jmp 0x381b
movq %rbx, %rdi
callq 0x3855
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
movq (%r13), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%r13)
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3397
movq 0x8(%r15), %rdi
leaq 0x9e33(%rip), %rsi      # 0xd681
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: block_to_c
struct rope *block_to_c(struct ast *ast)
{
    struct rope *rope = lcurly_nl_rope;
    zc_indent_level++;

    rope = stmt_list_to_c(rope, ast, NULL);

    zc_indent_level--;
    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
leaq 0x10570(%rip), %r14     # 0x13dd4
incl (%r14)
leaq 0xfaf2(%rip), %rdi      # 0x13360
xorl %edx, %edx
callq 0x3a63
movq %rax, %rbx
movslq (%r14), %r15
decq %r15
movl %r15d, (%r14)
leaq 0xfb38(%rip), %rax      # 0x133c0
testl %r15d, %r15d
je 0x38a4
leaq 0xf9ec(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
decq %r15
jne 0x3894
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xaebf
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: stmt_list_to_c
struct rope *stmt_list_to_c(struct rope *rope, struct ast *ast,
        bool *fallthrough)
{
    size_t n_stmt_asts;
    struct ast **stmt_asts = ast_asts(ast, &n_stmt_asts);

    for (size_t i = 0; i < n_stmt_asts; ++i) {
        if (stmt_asts[i]->tag == FALLTHROUGH_STMT) {
            if (fallthrough == NULL || i != n_stmt_asts - 1)
                fatal(stmt_asts[i]->loc, "fallthrough not allowed here");

            *fallthrough = true;
            break;
        }

        struct rope *c_stmt = stmt_to_c(stmt_asts[i]);
        rope = rope_new_tree(rope, c_stmt);
    }

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x2825
movq %rax, %r15
movq (%r12), %rax
testq %rax, %rax
je 0x3ada
movq (%r15), %rdi
cmpl $0x5, (%rdi)
jne 0x3a98
xorl %r12d, %r12d
jmp 0x3ac9
movl $0x1, %r12d
callq 0x3f3e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %rbx
movq (%rsp), %rax
cmpq %rax, %r12
jae 0x3ada
movq (%r15,%r12,8), %rdi
incq %r12
cmpl $0x5, (%rdi)
jne 0x3a9e
decq %r12
testq %r14, %r14
je 0x3ae9
decq %rax
cmpq %rax, %r12
jne 0x3ae9
movb $0x1, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %rdi
leaq 0x9c83(%rip), %rsi      # 0xd777
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: switch_block_to_c
struct rope *switch_block_to_c(struct ast *ast)
{
    struct rope *rope = lcurly_nl_rope;

    size_t n_clause_asts;
    struct ast **clause_asts = ast_asts(ast, &n_clause_asts);

    for (size_t i = 0; i < n_clause_asts; ++i) {
        struct rope *c_clause = clause_to_c(clause_asts[i]);
	if (rope != NULL)
	    rope = rope_new_tree(rope, c_clause);
    }

    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x2825
cmpq $0x0, (%rbx)
je 0x3b50
movq %rax, %r14
leaq 0xf83f(%rip), %rbx      # 0x13360
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x38b4
testq %rbx, %rbx
je 0x3b42
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %rbx
jmp 0x3b44
xorl %ebx, %ebx
incq %r15
cmpq 0x8(%rsp), %r15
jb 0x3b24
jmp 0x3b57
leaq 0xf809(%rip), %rbx      # 0x13360
leaq 0x10276(%rip), %rax     # 0x13dd4
movslq (%rax), %r15
leaq 0xf858(%rip), %rax      # 0x133c0
testq %r15, %r15
je 0x3b84
leaq 0xf70c(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
decq %r15
jne 0x3b74
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaebf
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: switch_stmt_to_c
struct rope *switch_stmt_to_c(struct ast *ast)
{
    struct rope *rope = switch_sp_lparen_rope;
    struct ast *expr_ast = ast_ast(ast, 0);
    struct ast *block_ast = ast_ast(ast, 1);

    push_scope();

    struct expr expr = eval_expr(NULL, expr_ast);
    if (!is_bool_type(expr.type) && !is_int_type(expr.type))
        fatal(ast->loc, "expression has to be of boolean or integer type");

    rope = rope_new_tree(rope, expr.rope);
    rope = rope_new_tree(rope, rparen_sp_rope);

    rope = rope_new_tree(rope, switch_block_to_c(block_ast));

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x27e8
movq %rax, %rbx
leaq 0x1021b(%rip), %r12     # 0x13de0
movq (%r12), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
callq 0xb040
movq %rax, (%r12)
xorl %edi, %edi
movq %r15, %rsi
callq 0x62d4
testb $-0x7e, (%rax)
je 0x3c3e
leaq 0x1008e(%rip), %rdi     # 0x13c80
movq %rdx, %rsi
callq 0xaebf
leaq 0xf6ff(%rip), %rsi      # 0x13300
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
movq %rbx, %rdi
callq 0x3afb
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
movq (%r12), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%r12)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3397
movq 0x8(%r14), %rdi
leaq 0x9a5c(%rip), %rsi      # 0xd6a5
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: for_stmt_to_c
struct rope *for_stmt_to_c(struct ast *ast)
{
    struct rope *rope = for_sp_lparen_rope;
    struct ast *init_expr_ast = ast_ast(ast, 0);
    struct ast *cond_expr_ast = ast_ast(ast, 1);
    struct ast *update_expr_ast = ast_ast(ast, 2);
    struct ast *block_ast = ast_ast(ast, 3);

    push_scope();

    if (init_expr_ast != NULL) {
        struct expr init_expr = eval_expr(NULL, init_expr_ast);
        rope = rope_new_tree(rope, init_expr.rope);
    }
    rope = rope_new_tree(rope, semi_rope);

    if (cond_expr_ast != NULL) {
        rope = rope_new_tree(rope, sp_rope);

        struct expr cond_expr = eval_expr(NULL, cond_expr_ast);
        if (!is_bool_type(cond_expr.type))
            fatal(ast->loc, "condition has to be of boolean type");

        rope = rope_new_tree(rope, cond_expr.rope);
    }
    rope = rope_new_tree(rope, semi_rope);

    if (update_expr_ast != NULL) {
        rope = rope_new_tree(rope, sp_rope);

        struct expr update_expr = eval_expr(NULL, update_expr_ast);
        rope = rope_new_tree(rope, update_expr.rope);
    }
    rope = rope_new_tree(rope, rparen_sp_rope);

    zc_loop_level++;
    rope = rope_new_tree(rope, block_to_c(block_ast));
    zc_loop_level--;

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %esi, %esi
callq 0x27e8
movq %rax, %r13
movl $0x1, %esi
movq %r15, %rdi
callq 0x27e8
movq %rax, %r12
movl $0x2, %esi
movq %r15, %rdi
callq 0x27e8
movq %rax, %r14
movl $0x3, %esi
movq %r15, %rdi
callq 0x27e8
movq %rax, %rbx
leaq 0x10141(%rip), %rbp     # 0x13de0
movq (%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
callq 0xb040
movq %rax, (%rbp)
testq %r13, %r13
je 0x3cd9
xorl %edi, %edi
movq %r13, %rsi
callq 0x62d4
leaq 0xf8f4(%rip), %rdi      # 0x135c0
movq %rdx, %rsi
callq 0xaebf
movq %rax, %rdi
jmp 0x3ce0
leaq 0xf8e0(%rip), %rdi      # 0x135c0
leaq 0xf7f9(%rip), %rsi      # 0x134e0
callq 0xaebf
testq %r12, %r12
je 0x3d21
leaq 0xf988(%rip), %rsi      # 0x13680
movq %rax, %rdi
callq 0xaebf
movq %rax, %r13
xorl %edi, %edi
movq %r12, %rsi
callq 0x62d4
testb $-0x80, (%rax)
je 0x3db0
movq %r13, %rdi
movq %rdx, %rsi
callq 0xaebf
leaq 0xf7b8(%rip), %rsi      # 0x134e0
movq %rax, %rdi
callq 0xaebf
testq %r14, %r14
je 0x3d5c
leaq 0xf944(%rip), %rsi      # 0x13680
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x62d4
movq %r15, %rdi
movq %rdx, %rsi
callq 0xaebf
leaq 0xf59d(%rip), %rsi      # 0x13300
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
leaq 0x1005b(%rip), %r15     # 0x13dd0
incl (%r15)
movq %rbx, %rdi
callq 0x3855
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
decl (%r15)
movq (%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rbp)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3397
movq 0x8(%r15), %rdi
leaq 0x98c6(%rip), %rsi      # 0xd681
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: return_stmt_to_c
struct rope *return_stmt_to_c(struct ast *ast)
{
    struct ast *expr_ast = ast_ast(ast, 0);

    if (expr_ast == NULL) {
        if (zc_func_ret_type != void_type)
            fatal(ast->loc, "missing return value in non-void function");
        return return_semi_rope;
    }

    struct expr expr = eval_expr(zc_func_ret_type, expr_ast);

    if (zc_func_ret_type == void_type)
        fatal(ast->loc, "return with value in function returning void");
    if (common_type(zc_func_ret_type, expr.type) != zc_func_ret_type)
        fatal(ast->loc, "invalid type for return");

    struct rope *rope = rope_new_tree(return_sp_rope, expr.rope);
    rope = rope_new_tree(rope, semi_rope);
    return add_indent_nl(rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
leaq 0x10018(%rip), %r15     # 0x13df0
movq (%r15), %rdi
testq %rax, %rax
je 0x3e2f
movq %rax, %rsi
callq 0x62d4
movq (%r15), %rdi
cmpq 0xf1e6(%rip), %rdi      # 0x12fd8
je 0x3e45
movq %rdx, %r14
movq %rax, %rsi
callq 0x5496
cmpq (%r15), %rax
jne 0x3e52
leaq 0xf6b5(%rip), %rdi      # 0x134c0
movq %r14, %rsi
callq 0xaebf
leaq 0xf6c6(%rip), %rsi      # 0x134e0
movq %rax, %rdi
callq 0xaebf
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3397
cmpq 0xf1a2(%rip), %rdi      # 0x12fd8
jne 0x3e5f
leaq 0xf621(%rip), %rax      # 0x13460
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
leaq 0x98af(%rip), %rsi      # 0xd6ff
jmp 0x3e6a
movq 0x8(%rbx), %rdi
leaq 0x98cf(%rip), %rsi      # 0xd72c
jmp 0x3e6a
movq 0x8(%rbx), %rdi
leaq 0x986b(%rip), %rsi      # 0xd6d5
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: label_stmt_to_c
struct rope *label_stmt_to_c(struct ast *ast)
{
    struct ast *name_ast = ast_ast(ast, 0);
    const char *name = ast_s(name_ast);
    const char *c_name = define_label(name);

    struct ast *stmt_ast = ast_ast(ast, 1);

    struct rope *rope = rope_new_s(c_name);
    rope = rope_new_tree(rope, colon_nl_rope);

    if (stmt_ast)
        rope = rope_new_tree(rope, stmt_to_c(stmt_ast));
    else
        rope = rope_new_tree(rope, add_indent_nl(semi_rope));

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
movq %rax, %rdi
callq 0x26f0
movq %rax, %rdi
callq 0x32bf
movq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %rax, %r14
movq %r15, %rdi
callq 0xaee6
leaq 0xfdd8(%rip), %rsi      # 0x13ce0
movq %rax, %rdi
callq 0xaebf
movq %rax, %rbx
testq %r14, %r14
je 0x3f22
movq %r14, %rdi
callq 0x3f3e
jmp 0x3f2e
leaq 0xf5b7(%rip), %rdi      # 0x134e0
callq 0x3397
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xaebf
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: stmt_to_c
struct rope *stmt_to_c(struct ast *ast)
{
    switch (ast->tag) {
        default:
            return expr_stmt_to_c(ast);
        case TYPE_DEF:
	    handle_type_def(ast);
	    return NULL;
        case ALIAS_DEF:
	    handle_alias_def(ast);
	    return NULL;
        case IF_STMT:
            return if_stmt_to_c(ast);
        case SWITCH_STMT:
            return switch_stmt_to_c(ast);
        case FOR_STMT:
            return for_stmt_to_c(ast);
        case RETURN_STMT:
            return return_stmt_to_c(ast);
        case BREAK_STMT:
            return break_stmt_to_c(ast);
        case CONTINUE_STMT:
            return continue_stmt_to_c(ast);
        case GOTO_STMT:
            return goto_stmt_to_c(ast);
        case LABEL_STMT:
            return label_stmt_to_c(ast);
    }
}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpl $0x4002, %eax           # imm = 0x4002
jle 0x3f69
leal -0x4101(%rax), %ecx
cmpl $0xa, %ecx
ja 0x3f8d
leaq 0x96b2(%rip), %rax      # 0xd60c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rax
jmp 0x373a
cmpl $0x3, %eax
je 0x3f81
cmpl $0x4, %eax
je 0x3f87
cmpl $0x4002, %eax           # imm = 0x4002
jne 0x3f9d
callq 0x404a
jmp 0x3f99
popq %rax
jmp 0x3e71
popq %rax
jmp 0x3e9c
cmpl $0x4003, %eax           # imm = 0x4003
jne 0x3f9d
callq 0x4089
xorl %eax, %eax
popq %rcx
retq
popq %rax
jmp 0x3700
popq %rax
jmp 0x3dc2
popq %rax
jmp 0x3ec7
popq %rax
jmp 0x3c50
popq %rax
jmp 0x3b99
popq %rax
jmp 0x3fc1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: goto_stmt_to_c
struct rope *goto_stmt_to_c(struct ast *ast)
{
    struct ast *name_ast = ast_ast(ast, 0);
    const char *name = ast_s(name_ast);
    const char *c_name = goto_label(name, ast);

    struct rope *rope = goto_sp_rope;
    rope = rope_new_tree(rope, rope_new_s(c_name));
    rope = rope_new_tree(rope, semi_nl_rope);

    return add_indent(rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x27e8
movq %rax, %rdi
callq 0x26f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x3284
movq %rax, %rdi
callq 0xaee6
leaq 0xfd0c(%rip), %rdi      # 0x13d00
movq %rax, %rsi
callq 0xaebf
leaq 0xf6bd(%rip), %rsi      # 0x136c0
movq %rax, %rdi
callq 0xaebf
testq %rax, %rax
je 0x4041
leaq 0xfdbd(%rip), %rcx      # 0x13dd4
movslq (%rcx), %r15
testl %r15d, %r15d
je 0x403e
leaq 0xf25a(%rip), %r14      # 0x13280
movq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaebf
movq %rax, %rbx
decq %r15
jne 0x4029
jmp 0x4041
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: func_body_to_c
struct rope *func_body_to_c(struct ast *ast)
{
    zc_func_labels = strmap_new(32);
    lbl_list = NULL;

    struct rope *rope = lcurly_nl_rope;
    zc_func_decls_rope = NULL;

    zc_indent_level++;

    struct rope *stmts_rope = NULL;
    stmts_rope = stmt_list_to_c(stmts_rope, ast, NULL);

    rope = rope_new_tree(rope, zc_func_decls_rope);
    rope = rope_new_tree(rope, stmts_rope);

    zc_indent_level--;
    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    strmap_del(zc_func_labels, NULL);
    check_lbl_list(lbl_list);

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0xb158
leaq 0xfd3b(%rip), %r15      # 0x13e20
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0xfc9f(%rip)      # 0x13d90
leaq 0xfd20(%rip), %r14      # 0x13e18
movq %rax, (%r14)
leaq 0xfcd2(%rip), %r13      # 0x13dd4
incl (%r13)
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3a63
movq %rax, %rbx
movq (%r14), %rsi
leaq 0xf241(%rip), %rdi      # 0x13360
callq 0xaebf
movq %rax, %rdi
movq %rbx, %rsi
callq 0xaebf
movq %rax, %rbx
movslq (%r13), %r12
decq %r12
movl %r12d, (%r13)
leaq 0xf27c(%rip), %rax      # 0x133c0
testl %r12d, %r12d
je 0x4160
leaq 0xf130(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
decq %r12
jne 0x4150
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %rbx
movq (%r15), %rdi
xorl %esi, %esi
callq 0xb2de
movq 0xfc11(%rip), %rdi      # 0x13d90
callq 0x3237
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: add_global_decl
void add_global_decl(struct decl_sym *decl)
{
    if (is_void_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a variable of void type");

    if (is_extern_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a variable of incomplete type");

    add_type_decl(decl->type);
    struct rope *rope = decl_to_c(decl);
    rope = rope_new_tree(extern_sp_rope, rope);
    rope = rope_new_tree(rope, semi_nl_rope);
    zc_prog_decls_rope = rope_new_tree(zc_prog_decls_rope, rope);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl (%rdi), %eax
testb $0x1, %al
jne 0x41f4
btl $0x9, %eax
jb 0x4205
callq 0x421b
movq 0x10(%rbx), %rdi
callq 0xaee6
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x342a
leaq 0xf51a(%rip), %rdi      # 0x136e0
movq %rax, %rsi
callq 0xaebf
leaq 0xf4eb(%rip), %rsi      # 0x136c0
movq %rax, %rdi
callq 0xaebf
leaq 0xfc24(%rip), %rbx      # 0x13e08
movq (%rbx), %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, (%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x9591(%rip), %rsi      # 0xd794
jmp 0x4214
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x95a7(%rip), %rsi      # 0xd7bb
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: add_type_decl
void add_type_decl(struct type *type)
{
    switch (type_type(type->tag)) {
	case PTR_TYPE_FLAG:
            add_type_decl(ptr_type(type)->to);
            break;
	case ARRAY_TYPE_FLAG:
            add_type_decl(array_type(type)->of);
            break;
	case FUNC_TYPE_FLAG:
            add_type_decl(func_type(type)->ret);
            break;
	case STRUCT_TYPE_FLAG:
            add_struct_def(struct_type(type));
            break;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x3ff, %ebx            # imm = 0x3FF
leaq 0x940d(%rip), %r14      # 0xd638
movl (%rdi), %eax
andl %ebx, %eax
addl $-0x8, %eax
roll $0x1d, %eax
cmpl $0x7, %eax
ja 0x4270
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
callq 0xb937
jmp 0x4256
callq 0xb969
jmp 0x4256
callq 0xb99b
movq 0x8(%rax), %rdi
jmp 0x422b
callq 0xb9cd
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x433c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: add_local_decl
void add_local_decl(struct decl_sym *decl)
{
    if (is_void_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a variable of void type");

    if (is_extern_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a variable of incomplete type");

    if (is_func_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a function here");

    add_type_decl(decl->type);
    struct rope *rope = NULL;

    rope = rope_new_tree(rope, decl_to_c(decl));
    rope = rope_new_tree(rope, semi_nl_rope);
    rope = add_indent_lev(rope, 1);

    zc_func_decls_rope = rope_new_tree(zc_func_decls_rope, rope);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl (%rdi), %eax
testb $0x1, %al
jne 0x4304
btl $0x9, %eax
jb 0x4315
testb $0x20, %al
jne 0x4326
callq 0x421b
movq 0x10(%rbx), %rdi
callq 0xaee6
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x342a
xorl %ebx, %ebx
xorl %edi, %edi
movq %rax, %rsi
callq 0xaebf
leaq 0xf3f8(%rip), %rsi      # 0x136c0
movq %rax, %rdi
callq 0xaebf
testq %rax, %rax
je 0x42e7
leaq 0xefa4(%rip), %rdi      # 0x13280
movq %rax, %rsi
callq 0xaebf
movq %rax, %rbx
leaq 0xfb2a(%rip), %r14      # 0x13e18
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xaebf
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x9481(%rip), %rsi      # 0xd794
jmp 0x4335
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x9497(%rip), %rsi      # 0xd7bb
jmp 0x4335
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x94b3(%rip), %rsi      # 0xd7e8
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: add_struct_def
void add_struct_def(struct struct_type *type)
{
    if (type->is_defined)
        return;
    type->is_defined = true;
    
    for (size_t i = 0; i < type->n_fields; i++)
        add_type_decl(type->fields[i].type);

    struct rope *rope = NULL;
    rope = struct_def_to_c(type);
    rope = rope_new_tree(rope, semi_nl_rope);
    zc_type_defs_rope = rope_new_tree(zc_type_defs_rope, rope);

    rope = struct_type_to_c(NULL, type);
    rope = rope_new_tree(rope, semi_nl_rope);
    zc_type_decls_rope = rope_new_tree(zc_type_decls_rope, rope);
}

// Assembly:
cmpb $0x0, 0x18(%rdi)
jne 0x43e1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x18(%rdi)
cmpq $0x0, 0x10(%rdi)
je 0x4375
leaq 0x28(%rbx), %r14
xorl %r15d, %r15d
movq (%r14), %rdi
callq 0x421b
incq %r15
addq $0x10, %r14
cmpq 0x10(%rbx), %r15
jb 0x4360
movq %rbx, %rdi
callq 0x35d4
leaq 0xf33c(%rip), %r14      # 0x136c0
movq %rax, %rdi
movq %r14, %rsi
callq 0xaebf
leaq 0xfa6a(%rip), %r15      # 0x13e00
movq (%r15), %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, (%r15)
movq 0x8(%rbx), %rdi
callq 0xaee6
leaq 0xf34c(%rip), %rdi      # 0x13700
movq %rax, %rsi
callq 0xaebf
movq %rax, %rdi
movq %r14, %rsi
callq 0xaebf
leaq 0xfa2a(%rip), %rbx      # 0x13df8
movq (%rbx), %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: init_ast_to_c
struct rope *init_ast_to_c(struct type *type, struct ast *init_ast, size_t nest_level)
{
    struct expr expr = eval_expr_global(type, init_ast);

    // In C ',' and '?:' operators have lower precedence than '='.  Should
    // probably be solved in a cleaner way in the future, until then this
    // works.
    if (init_ast->tag == COMMA_EXPR || init_ast->tag == COND_EXPR)
        expr.rope = add_paren(expr.rope);

    struct type *got_type = target_type(type, expr.type);

    if (got_type == NULL)
        fatal(init_ast->loc, "invalid type for initializer");

    if (!type_equals(got_type, type))
        fatal(init_ast->loc, "invalid type for initializer");

    return expr.rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7eb8
movq %rax, %r12
movq %rdx, %r15
movl (%rbx), %eax
orl $0x10, %eax
cmpl $0x4210, %eax           # imm = 0x4210
jne 0x4699
leaq 0xec21(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xec32(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x5545
testq %rax, %rax
je 0x46c7
movq %rax, %rdi
movq %r14, %rsi
callq 0xbe53
testb %al, %al
je 0x46c7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
leaq 0x9167(%rip), %rsi      # 0xd839
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: data_def_to_c
struct rope *data_def_to_c(struct ast *ast)
{
    struct ast *decl_ast = ast_ast(ast, 0);

    struct ast *init_ast = ast_ast(ast, 1);
    const char *name = ast_s(ast_ast(decl_ast, 0));

    struct sym *sym = scope_get_sym(global_scope, name);
    assert(sym->tag == DECL_SYM);
    struct decl_sym *decl = (struct decl_sym *)sym;

    struct rope *rope = decl_to_c(decl);

    rope = rope_new_tree(rope, asgn_binop_rope);
    rope = rope_new_tree(rope, init_ast_to_c(decl->type, init_ast, 0));
    rope = rope_new_tree(rope, semi_nl_rope);
    rope = rope_new_tree(nl_rope, rope);

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x27e8
movq %rax, %rdi
callq 0x26f0
leaq 0xf6d4(%rip), %rcx      # 0x13de8
movq (%rcx), %rdi
movq %rax, %rsi
callq 0xb09c
cmpl $0x1, (%rax)
jne 0x4788
movq %rax, %r14
movq 0x10(%rax), %rdi
callq 0xaee6
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x342a
leaq 0xf09d(%rip), %rsi      # 0x137e0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x4653
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
leaq 0xef54(%rip), %rsi      # 0x136c0
movq %rax, %rdi
callq 0xaebf
leaq 0xef25(%rip), %rdi      # 0x136a0
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xaebf
leaq 0x8a1d(%rip), %rdi      # 0xd1ac
leaq 0x9071(%rip), %rsi      # 0xd807
leaq 0x9074(%rip), %rcx      # 0xd811
leaq 0x90b2(%rip), %r8       # 0xd856
movl $0x2d0, %edx            # imm = 0x2D0
xorl %eax, %eax
callq 0x4eac
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: codegen_pass
void codegen_pass(struct ast *ast)
{
    size_t n_extern_defs;
    struct ast **extern_defs = ast_asts(ast, &n_extern_defs);

    for (size_t i = 0; i < n_extern_defs; ++i) {
        struct ast *extern_def = extern_defs[i];

        switch (extern_def->tag) {
            case ASGN_EXPR:
                append_def(data_def_to_c(extern_def));
                break;
            case FUNC_DEF:
                append_def(func_def_to_c(extern_def));
                break;
            case TYPE_DEF: {
                scope_get_type(current_scope, ast_s(ast_ast(extern_def, 0)));
                continue;
            }
            case SOURCE_FILE:
                codegen_pass(extern_def);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2825
cmpq $0x0, (%r14)
je 0x4ace
movq %rax, %rbx
xorl %r15d, %r15d
leaq 0xf3bf(%rip), %r12      # 0x13e10
leaq 0xf388(%rip), %r13      # 0x13de0
movq (%rbx,%r15,8), %rdi
movl (%rdi), %eax
cmpl $0x421f, %eax           # imm = 0x421F
jg 0x4a93
cmpl $0x4001, %eax           # imm = 0x4001
je 0x4aa8
cmpl $0x4002, %eax           # imm = 0x4002
jne 0x4ac4
movq (%r13), %r14
xorl %esi, %esi
callq 0x27e8
movq %rax, %rdi
callq 0x26f0
movq %r14, %rdi
movq %rax, %rsi
callq 0xb113
jmp 0x4ac4
cmpl $0x4502, %eax           # imm = 0x4502
je 0x4abf
cmpl $0x4220, %eax           # imm = 0x4220
jne 0x4ac4
callq 0x46d9
jmp 0x4aad
callq 0x43e2
movq (%r12), %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, (%r12)
jmp 0x4ac4
callq 0x4a20
incq %r15
cmpq 0x8(%rsp), %r15
jb 0x4a58
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/error.c
// Function: error
void error(struct loc *loc, const char *fmt, ...) {
	assert(fmt);

	va_list va;
	va_start(va, fmt);

        if (loc != NULL)
            fprintf(stderr, "%s:%d: error: ", loc->file, loc->line);
        else
            fprintf(stderr, "error: ");

	vfprintf(stderr, fmt, va);
        putc('\n', stderr);

	va_end(va);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4e01
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x4e84
movq %rsi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movq 0xe1c3(%rip), %r14      # 0x12ff8
movq (%r14), %rax
testq %rdi, %rdi
jne 0x4e47
movq %rax, %rdi
callq 0x2280
jmp 0x4e5e
movq (%rdi), %rdx
movl 0x8(%rdi), %ecx
leaq 0x8aca(%rip), %rsi      # 0xd91e
movq %rax, %rdi
xorl %eax, %eax
callq 0x2130
movq (%r14), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x21e0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x2110
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8321(%rip), %rdi      # 0xd1ac
leaq 0x8a7a(%rip), %rsi      # 0xd90c
leaq 0x8a7b(%rip), %rcx      # 0xd914
leaq 0x8a78(%rip), %r8       # 0xd918
movl $0x4, %edx
xorl %eax, %eax
callq 0x4eac
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/error.c
// Function: bug
void bug(const char *fmt, ...) {
	assert(fmt); /* catching bugs within bugs */

	va_list va;
	va_start(va, fmt);

        fprintf(stderr, "internal error: ");
	vfprintf(stderr, fmt, va);
        putc('\n', stderr);

	va_end(va);
	abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4f0c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
jne 0x4f39
leaq 0x8294(%rip), %rdi      # 0xd1ac
leaq 0x89ed(%rip), %rsi      # 0xd90c
leaq 0x89ee(%rip), %rcx      # 0xd914
leaq 0x8a06(%rip), %r8       # 0xd933
movl $0x28, %edx
xorl %eax, %eax
callq 0x4eac
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xe090(%rip), %r15      # 0x12ff8
movq (%r15), %rcx
leaq 0x89c5(%rip), %rdi      # 0xd937
movl $0x10, %esi
movl $0x1, %edx
callq 0x2210
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21e0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x2110
callq 0x2040
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/error.c
// Function: fatal
void fatal(struct loc *loc, const char *fmt, ...) {
	assert(fmt);

	va_list va;
	va_start(va, fmt);

        if (loc != NULL)
            fprintf(stderr, "%s:%d: error: ", loc->file, loc->line);
        else
            fprintf(stderr, "error: ");

	vfprintf(stderr, fmt, va);
        putc('\n', stderr);

	va_end(va);

        exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4ffa
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
jne 0x5027
leaq 0x81a6(%rip), %rdi      # 0xd1ac
leaq 0x88ff(%rip), %rsi      # 0xd90c
leaq 0x8900(%rip), %rcx      # 0xd914
leaq 0x8912(%rip), %r8       # 0xd92d
movl $0x15, %edx
xorl %eax, %eax
callq 0x4eac
movq %rsi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movq 0xdfa2(%rip), %r14      # 0x12ff8
movq (%r14), %rcx
testq %rdi, %rdi
jne 0x5076
leaq 0x88c0(%rip), %rdi      # 0xd925
movl $0x7, %esi
movl $0x1, %edx
callq 0x2210
jmp 0x508f
movq (%rdi), %rdx
movl 0x8(%rdi), %eax
leaq 0x889b(%rip), %rsi      # 0xd91e
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x2130
movq (%r14), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x21e0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x2110
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: get_c_prec
int get_c_prec(enum ast_tag tag)
{
    switch (tag) {
        case COMMA_EXPR:
            return 0;
        case COND_EXPR:
            return 1;
        case ASGN_EXPR:
        case ADD_ASGN_EXPR:
        case SUB_ASGN_EXPR:
        case MUL_ASGN_EXPR:
        case DIV_ASGN_EXPR:
        case REM_ASGN_EXPR:
        case OR_ASGN_EXPR:
        case XOR_ASGN_EXPR:
        case AND_ASGN_EXPR:
        case SHL_ASGN_EXPR:
        case SHR_ASGN_EXPR:
            return 2;
        case LOR_EXPR:
            return 3;
        case LAND_EXPR:
            return 4;
        case OR_EXPR:
            return 5;
        case XOR_EXPR:
            return 6;
        case AND_EXPR:
            return 7;
        case EQ_EXPR:
        case NE_EXPR:
            return 8;
        case LT_EXPR:
        case GT_EXPR:
        case LE_EXPR:
        case GE_EXPR:
            return 9;
        case SHL_EXPR:
        case SHR_EXPR:
            return 10;
        case ADD_EXPR:
        case SUB_EXPR:
            return 11;
        case MUL_EXPR:
        case DIV_EXPR:
        case REM_EXPR:
            return 12;
        case CAST_EXPR:
            return 13;
        case NOT_EXPR:
        case COMPL_EXPR:
        case UPLUS_EXPR:
        case NEG_EXPR:
        case REF_EXPR:
        case PRE_INC_EXPR:
        case PRE_DEC_EXPR:
        case SIZEOF_EXPR:
        case DEREF_EXPR:
            return 14;
    }
    return 15;
}

// Assembly:
cmpl $0x426f, %edi           # imm = 0x426F
jg 0x536e
cmpl $0x422f, %edi           # imm = 0x422F
jg 0x539b
leal -0x4220(%rdi), %eax
cmpl $0xb, %eax
jae 0x542d
movl $0x2, %eax
retq
cmpl $0x42af, %edi           # imm = 0x42AF
jle 0x53d0
leal -0x42c0(%rdi), %eax
cmpl $0x30, %eax
ja 0x5469
movabsq $0x1000000ff0000, %rcx  # imm = 0x1000000FF0000
btq %rax, %rcx
jae 0x540b
movl $0xe, %eax
retq
cmpl $0x425f, %edi           # imm = 0x425F
jg 0x53fa
leal -0x4250(%rdi), %eax
cmpl $0x2, %eax
jb 0x5445
cmpl $0x4230, %edi           # imm = 0x4230
je 0x5457
cmpl $0x4240, %edi           # imm = 0x4240
jne 0x547a
movl $0x4, %eax
retq
cmpl $0x429f, %edi           # imm = 0x429F
jg 0x541c
cmpl $0x4270, %edi           # imm = 0x4270
je 0x5451
cmpl $0x4280, %edi           # imm = 0x4280
je 0x544b
cmpl $0x4290, %edi           # imm = 0x4290
jne 0x547a
movl $0x7, %eax
retq
addl $0xffffbda0, %edi       # imm = 0xFFFFBDA0
cmpl $0x4, %edi
jae 0x547a
movl $0x9, %eax
retq
movl $0x7, %ecx
btq %rax, %rcx
jae 0x545d
movl $0xc, %eax
retq
addl $0xffffbd60, %edi       # imm = 0xFFFFBD60
cmpl $0x2, %edi
jae 0x547a
movl $0xa, %eax
retq
xorl %eax, %eax
cmpl $0x4200, %edi           # imm = 0x4200
je 0x547f
cmpl $0x4210, %edi           # imm = 0x4210
jne 0x547a
movl $0x1, %eax
retq
movl $0x8, %eax
retq
movl $0x6, %eax
retq
movl $0x5, %eax
retq
movl $0x3, %eax
retq
cmpq $0x20, %rax
jne 0x5469
movl $0xd, %eax
retq
addl $0xffffbd50, %edi       # imm = 0xFFFFBD50
cmpl $0x2, %edi
jae 0x547a
movl $0xb, %eax
retq
movl $0xf, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: common_type
struct type *common_type(struct type *a, struct type *b)
{
    if ((is_int_type(a) && b->tag == INT_CONST_TYPE) ||
            (is_float_type(a) && b->tag == FLOAT_CONST_TYPE))
        return a;

    if (is_ptr_type(a) && is_ptr_type(b) && (is_void_type(ptr_type(b)->to)))
        return a;

    if ((is_int_type(b) && a->tag == INT_CONST_TYPE) ||
            (is_float_type(b) && a->tag == FLOAT_CONST_TYPE))
        return b;

    if (is_ptr_type(b) && is_ptr_type(a) && (is_void_type(ptr_type(a)->to)))
        return b;

    if (type_equals(a, b))
        return a;

    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ecx
movl %ecx, %edx
shrb %dl
movl (%rsi), %eax
cmpl $0xf002, %eax           # imm = 0xF002
sete %sil
testb %sil, %dl
jne 0x553a
movl %ecx, %edx
shrb $0x2, %dl
cmpl $0x3004, %eax           # imm = 0x3004
sete %sil
testb %sil, %dl
jne 0x553a
testb $0x8, %cl
sete %cl
testb $0x8, %al
sete %dl
orb %cl, %dl
jne 0x54f0
movq %r14, %rdi
callq 0xb937
movq 0x8(%rax), %rax
testb $0x1, (%rax)
jne 0x553a
movl (%r14), %eax
testb $0x2, %al
je 0x54fc
cmpl $0xf002, (%rbx)         # imm = 0xF002
je 0x5537
testb $0x4, %al
je 0x5508
cmpl $0x3004, (%rbx)         # imm = 0x3004
je 0x5537
testb $0x8, %al
je 0x5522
testb $0x8, (%rbx)
je 0x5522
movq %rbx, %rdi
callq 0xb937
movq 0x8(%rax), %rax
testb $0x1, (%rax)
jne 0x5537
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbe53
xorl %ecx, %ecx
testb %al, %al
cmoveq %rcx, %rbx
jmp 0x553a
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: target_type
struct type *target_type(struct type *want, struct type *b)
{
    if ((is_int_type(want) && b->tag == INT_CONST_TYPE) ||
            (is_float_type(want) && b->tag == FLOAT_CONST_TYPE))
        return want;

    if (is_ptr_type(want) && is_ptr_type(b) && (is_void_type(ptr_type(b)->to)))
        return want;

    // TODO: Is this neccessary?
    //if ((is_int_type(b) && want->tag == INT_CONST_TYPE) ||
    //        (is_float_type(b) && want->tag == FLOAT_CONST_TYPE))
    //    return b;

    if (is_ptr_type(b) && is_ptr_type(want) && (is_void_type(ptr_type(want)->to)))
        return want;

    // pointer decay
    if (is_ptr_type(want) && is_array_type(b) &&
            type_equals(ptr_type(want)->to, array_type(b)->of))
        return want;

    if (type_equals(want, b))
        return want;

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %edx
shrb %dl
movl (%rsi), %ecx
cmpl $0xf002, %ecx           # imm = 0xF002
sete %sil
testb %sil, %dl
jne 0x560d
movl %eax, %edx
shrb $0x2, %dl
cmpl $0x3004, %ecx           # imm = 0x3004
sete %sil
testb %sil, %dl
jne 0x560d
testb $0x8, %al
sete %dl
testb $0x8, %cl
sete %sil
orb %dl, %sil
jne 0x55aa
movq %r14, %rdi
callq 0xb937
movq 0x8(%rax), %rax
testb $0x1, (%rax)
jne 0x560d
movl (%r14), %ecx
movl (%rbx), %eax
testb $0x8, %cl
sete %cl
testb $0x8, %al
sete %dl
orb %cl, %dl
jne 0x55cc
movq %rbx, %rdi
callq 0xb937
movq 0x8(%rax), %rax
testb $0x1, (%rax)
jne 0x560d
movl (%rbx), %eax
testb $0x8, %al
je 0x55fa
testb $0x10, (%r14)
je 0x55fa
movq %rbx, %rdi
callq 0xb937
movq 0x8(%rax), %r15
movq %r14, %rdi
callq 0xb969
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0xbe53
testb %al, %al
jne 0x560d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbe53
xorl %ecx, %ecx
testb %al, %al
cmoveq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_cond_type
struct type *eval_cond_type(struct type *t, struct ast *ast)
{
    struct type *cond_type = eval_type(NULL, ast_ast(ast, 0));
    struct type *then_type = eval_type(t, ast_ast(ast, 1));
    struct type *else_type = eval_type(t, ast_ast(ast, 2));

    require_type(ast, cond_type, BOOL_TYPE);

    struct type *type = common_type(then_type, else_type);
    if (type == NULL)
        incompatible_type(ast);

    return type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %r14, %rdi
movq %rax, %rsi
callq 0x578e
movq %rax, %r12
movl $0x2, %esi
movq %rbx, %rdi
callq 0x27e8
movq %r14, %rdi
movq %rax, %rsi
callq 0x578e
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movl $0x80, %edx
callq 0x5696
movq %r12, %rdi
movq %r14, %rsi
callq 0x5496
testq %rax, %rax
je 0x576f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %r14
movl (%rbx), %edi
callq 0x50b4
leaq 0x8685(%rip), %rsi      # 0xde06
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_binop_type
struct type *eval_binop_type(struct ast *ast, enum ast_tag accept)
{
    struct type *lhs_type = eval_type(NULL, ast_ast(ast, 0));
    struct type *rhs_type = eval_type(NULL, ast_ast(ast, 1));
    struct type *type = common_type(lhs_type, rhs_type);
    if (type == NULL)
        incompatible_type(ast);

    require_type(ast, type, accept);
    return type_dup(type, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %r15, %rdi
movq %rax, %rsi
callq 0x5496
testq %rax, %rax
je 0x5b1f
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x5696
movq %r15, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xc018
movq 0x8(%r14), %rbx
movl (%r14), %edi
callq 0x50b4
leaq 0x82d4(%rip), %rsi      # 0xde06
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_relop_type
struct type *eval_relop_type(struct ast *ast, enum ast_tag accept)
{
    struct type *lhs_type = eval_type(NULL, ast_ast(ast, 0));
    struct type *rhs_type = eval_type(NULL, ast_ast(ast, 1));
    struct type *type = common_type(lhs_type, rhs_type);
    if (type == NULL)
        incompatible_type(ast);

    require_type(ast, type, accept);
    return bool_type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %r15, %rdi
movq %rax, %rsi
callq 0x5496
testq %rax, %rax
je 0x5b9e
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x5696
leaq 0xe1c8(%rip), %rax      # 0x13d60
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rbx
movl (%r14), %edi
callq 0x50b4
leaq 0x8255(%rip), %rsi      # 0xde06
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_unop_type
struct type *eval_unop_type(struct ast *ast, enum ast_tag accept, bool lval_op)
{
    struct type *type = eval_type(NULL, ast_ast(ast, 0));

    require_type(ast, type, accept);
    if (lval_op)
        require_lval(ast, type);
    return type_dup(type, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x5696
testl %ebp, %ebp
je 0x5bfe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56c1
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc018
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_add_type
struct type *eval_add_type(struct ast *ast)
{
    struct type *lhs_type = ptr_decay(eval_type(NULL, ast_ast(ast, 0)));
    struct type *rhs_type = ptr_decay(eval_type(NULL, ast_ast(ast, 1)));

    if (is_ptr_type(lhs_type) && is_int_type(rhs_type))
        return lhs_type;

    if (is_int_type(lhs_type) && is_ptr_type(rhs_type))
        return rhs_type;

    struct type *type = common_type(lhs_type, rhs_type);
    if (type == NULL)
        incompatible_type(ast);

    require_type(ast, type, INT_TYPE | FLOAT_TYPE);
    return type_dup(type, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %rdi
callq 0x5616
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %rdi
callq 0x5616
movl (%r14), %ecx
testb $0x8, %cl
je 0x5c61
testb $0x2, (%rax)
jne 0x5ca2
testb $0x2, %cl
je 0x5c6b
testb $0x8, (%rax)
jne 0x5c9f
movq %r14, %rdi
movq %rax, %rsi
callq 0x5496
testq %rax, %rax
je 0x5cad
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1006, %edx           # imm = 0x1006
callq 0x5696
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc018
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %r14
movl (%rbx), %edi
callq 0x50b4
leaq 0x8147(%rip), %rsi      # 0xde06
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_sub_type
struct type *eval_sub_type(struct ast *ast)
{
    struct type *lhs_type = ptr_decay(eval_type(NULL, ast_ast(ast, 0)));
    struct type *rhs_type = ptr_decay(eval_type(NULL, ast_ast(ast, 1)));

    if (is_ptr_type(lhs_type) && is_int_type(rhs_type))
        return type_dup(lhs_type, 0);

    if (is_int_type(lhs_type) && is_ptr_type(rhs_type))
        return type_dup(rhs_type, 0);

    if (is_ptr_type(lhs_type) && is_ptr_type(rhs_type) &&
            type_equals(lhs_type, rhs_type))
        return const_int_type;

    struct type *type = common_type(lhs_type, rhs_type);
    if (type == NULL)
        incompatible_type(ast);

    require_type(ast, type, PTR_TYPE | INT_TYPE | FLOAT_TYPE);
    return type_dup(type, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %rdi
callq 0x5616
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x578e
movq %rax, %rdi
callq 0x5616
movq %rax, %r15
movl (%r14), %eax
testb $0x8, %al
je 0x5d1f
testb $0x2, (%r15)
jne 0x5d77
testb $0x2, %al
je 0x5d29
testb $0x8, (%r15)
jne 0x5d74
testb $0x8, %al
je 0x5d4f
testb $0x8, (%r15)
je 0x5d4f
movq %r14, %rdi
movq %r15, %rsi
callq 0xbe53
testb %al, %al
je 0x5d4f
leaq 0xe00f(%rip), %rax      # 0x13d58
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0x5496
testq %rax, %rax
je 0x5d86
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x100e, %edx           # imm = 0x100E
callq 0x5696
jmp 0x5d77
movq %r15, %r14
movq %r14, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xc018
movq 0x8(%rbx), %r14
movl (%rbx), %edi
callq 0x50b4
leaq 0x806e(%rip), %rsi      # 0xde06
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4fa1