LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x4340
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
subl $0x8, %eax
je 0x53f1
jmp 0x53d3
movl -0xc(%rbp), %eax
subl $0x10, %eax
je 0x5405
jmp 0x53dd
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x5419
jmp 0x53e7
movl -0xc(%rbp), %eax
subl $0x40, %eax
je 0x542d
jmp 0x543e
movq -0x8(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
callq 0x53b0
jmp 0x543e
movq -0x8(%rbp), %rdi
callq 0x10490
movq 0x8(%rax), %rdi
callq 0x53b0
jmp 0x543e
movq -0x8(%rbp), %rdi
callq 0x10500
movq 0x8(%rax), %rdi
callq 0x53b0
jmp 0x543e
movq -0x8(%rbp), %rdi
callq 0x10570
movq %rax, %rdi
callq 0x5570
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5370
testb $0x1, %al
jne 0x546f
jmp 0x5489
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd0f8(%rip), %rsi      # 0x1257a
movb $0x0, %al
callq 0x6610
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5390
testb $0x1, %al
jne 0x549c
jmp 0x54b6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd0f2(%rip), %rsi      # 0x125a1
movb $0x0, %al
callq 0x6610
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3e60
testb $0x1, %al
jne 0x54c9
jmp 0x54e3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd0f2(%rip), %rsi      # 0x125ce
movb $0x0, %al
callq 0x6610
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x53b0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4360
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1418c(%rip), %rsi     # 0x196b0
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3d10
movq %rax, -0x10(%rbp)
leaq 0x148ca(%rip), %rax     # 0x19e10
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf2a0
movq %rax, %rcx
leaq 0x148b4(%rip), %rax     # 0x19e10
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x558b
jmp 0x5661
movq -0x8(%rbp), %rax
movb $0x1, 0x18(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x55d3
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x53b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x559b
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x140bd(%rip), %rsi     # 0x196b0
callq 0xf2a0
movq %rax, -0x18(%rbp)
leaq 0x147f5(%rip), %rax     # 0x19df8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2a0
movq %rax, %rcx
leaq 0x147df(%rip), %rax     # 0x19df8
movq %rcx, (%rax)
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x4280
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x14078(%rip), %rsi     # 0x196b0
callq 0xf2a0
movq %rax, -0x18(%rbp)
leaq 0x147a8(%rip), %rax     # 0x19df0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2a0
movq %rax, %rcx
leaq 0x14792(%rip), %rax     # 0x19df0
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xac40
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4200, (%rax)         # imm = 0x4200
je 0x59d1
movq -0x10(%rbp), %rax
cmpl $0x4210, (%rax)         # imm = 0x4210
jne 0x59de
movq -0x20(%rbp), %rdi
callq 0x3ea0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6d30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5a0c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xcc1a(%rip), %rsi      # 0x1261f
movb $0x0, %al
callq 0x6610
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x5a33
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xcbf3(%rip), %rsi      # 0x1261f
movb $0x0, %al
callq 0x6610
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rdi
callq 0x27f0
movq %rax, -0x20(%rbp)
leaq 0x14351(%rip), %rax     # 0x19de0
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xf5b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
je 0x5ad0
leaq 0xc555(%rip), %rdi      # 0x12004
leaq 0xcb37(%rip), %rsi      # 0x125ed
movl $0x2d0, %edx            # imm = 0x2D0
leaq 0xcb35(%rip), %rcx      # 0x125f7
leaq 0xcb73(%rip), %r8       # 0x1263c
movb $0x0, %al
callq 0x6510
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4360
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x13ce0(%rip), %rsi     # 0x197d0
callq 0xf2a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5990
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x13b7f(%rip), %rsi     # 0x196b0
callq 0xf2a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq 0x13b4b(%rip), %rdi     # 0x19690
callq 0xf2a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2ad0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5fec
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x4001, %eax           # imm = 0x4001
je 0x5f8c
jmp 0x5f55
movl -0x2c(%rbp), %eax
subl $0x4002, %eax           # imm = 0x4002
je 0x5f9f
jmp 0x5f61
movl -0x2c(%rbp), %eax
subl $0x4220, %eax           # imm = 0x4220
je 0x5f79
jmp 0x5f6d
movl -0x2c(%rbp), %eax
subl $0x4502, %eax           # imm = 0x4502
je 0x5fd0
jmp 0x5fd9
movq -0x28(%rbp), %rdi
callq 0x5a40
movq %rax, %rdi
callq 0x5b60
jmp 0x5fd9
movq -0x28(%rbp), %rdi
callq 0x5670
movq %rax, %rdi
callq 0x5b60
jmp 0x5fd9
leaq 0x13e32(%rip), %rax     # 0x19dd8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rdi
callq 0x27f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf690
jmp 0x5fdb
movq -0x28(%rbp), %rdi
callq 0x5f00
jmp 0x5fdb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5f25
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x6408
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x645b
leaq 0xbbca(%rip), %rdi      # 0x12004
leaq 0xc2b1(%rip), %rsi      # 0x126f2
movl $0x4, %edx
leaq 0xc2ad(%rip), %rcx      # 0x126fa
leaq 0xc2aa(%rip), %r8       # 0x126fe
movb $0x0, %al
callq 0x6510
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x64ae
movq 0x12b6b(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0xc25f(%rip), %rsi      # 0x12704
movb $0x0, %al
callq 0x2140
jmp 0x64c6
movq 0x12b43(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
leaq 0xc24c(%rip), %rsi      # 0x1270b
movb $0x0, %al
callq 0x2140
movq 0x12b2b(%rip), %rax     # 0x18ff8
movq %rax, -0xe8(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x21e0
movq -0xe8(%rbp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2120
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x6545
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x659b
leaq 0xba8a(%rip), %rdi      # 0x12004
leaq 0xc171(%rip), %rsi      # 0x126f2
movl $0x28, %edx
leaq 0xc16d(%rip), %rcx      # 0x126fa
leaq 0xc185(%rip), %r8       # 0x12719
movb $0x0, %al
callq 0x6510
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x12a32(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
leaq 0xc14d(%rip), %rsi      # 0x1271d
movb $0x0, %al
callq 0x2140
movq 0x12a1a(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x21e0
movq 0x12a03(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2120
leaq -0x20(%rbp), %rax
callq 0x2040
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x6648
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x669b
leaq 0xb98a(%rip), %rdi      # 0x12004
leaq 0xc071(%rip), %rsi      # 0x126f2
movl $0x15, %edx
leaq 0xc06d(%rip), %rcx      # 0x126fa
leaq 0xc07f(%rip), %r8       # 0x12713
movb $0x0, %al
callq 0x6510
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x66ee
movq 0x1292b(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0xc01f(%rip), %rsi      # 0x12704
movb $0x0, %al
callq 0x2140
jmp 0x6706
movq 0x12903(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
leaq 0xc00c(%rip), %rsi      # 0x1270b
movb $0x0, %al
callq 0x2140
movq 0x128eb(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x21e0
movq 0x128d4(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2120
leaq -0x30(%rbp), %rax
movl $0x1, %edi
callq 0x2200
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: is_rassoc
bool is_rassoc(enum ast_tag tag)
{
    switch (tag) {
        case COND_EXPR:
        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 true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x4210, %eax           # imm = 0x4210
je 0x6b45
jmp 0x6b36
movl -0xc(%rbp), %eax
addl $0xffffbde0, %eax       # imm = 0xFFFFBDE0
subl $0xa, %eax
ja 0x6b4b
jmp 0x6b45
movb $0x1, -0x1(%rbp)
jmp 0x6b4f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x6b7f
jmp 0x6b8b
movq -0x18(%rbp), %rax
cmpl $0xf002, (%rax)         # imm = 0xF002
je 0x6ba6
movq -0x10(%rbp), %rdi
callq 0x6cd0
testb $0x1, %al
jne 0x6b9a
jmp 0x6bb3
movq -0x18(%rbp), %rax
cmpl $0x3004, (%rax)         # imm = 0x3004
jne 0x6bb3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c9b
movq -0x10(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6bc2
jmp 0x6bf6
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6bd1
jmp 0x6bf6
movq -0x18(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
callq 0x6d10
testb $0x1, %al
jne 0x6be9
jmp 0x6bf6
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c9b
movq -0x18(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x6c05
jmp 0x6c11
movq -0x10(%rbp), %rax
cmpl $0xf002, (%rax)         # imm = 0xF002
je 0x6c2c
movq -0x18(%rbp), %rdi
callq 0x6cd0
testb $0x1, %al
jne 0x6c20
jmp 0x6c36
movq -0x10(%rbp), %rax
cmpl $0x3004, (%rax)         # imm = 0x3004
jne 0x6c36
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c9b
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6c45
jmp 0x6c76
movq -0x10(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6c54
jmp 0x6c76
movq -0x10(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
callq 0x6d10
testb $0x1, %al
jne 0x6c6c
jmp 0x6c76
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c9b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x6c89
jmp 0x6c93
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c9b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x6d4f
jmp 0x6d5b
movq -0x18(%rbp), %rax
cmpl $0xf002, (%rax)         # imm = 0xF002
je 0x6d76
movq -0x10(%rbp), %rdi
callq 0x6cd0
testb $0x1, %al
jne 0x6d6a
jmp 0x6d83
movq -0x18(%rbp), %rax
cmpl $0x3004, (%rax)         # imm = 0x3004
jne 0x6d83
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e80
movq -0x10(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6d92
jmp 0x6dc6
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6da1
jmp 0x6dc6
movq -0x18(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
callq 0x6d10
testb $0x1, %al
jne 0x6db9
jmp 0x6dc6
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e80
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6dd5
jmp 0x6e06
movq -0x10(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6de4
jmp 0x6e06
movq -0x10(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
callq 0x6d10
testb $0x1, %al
jne 0x6dfc
jmp 0x6e06
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e80
movq -0x10(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x6e15
jmp 0x6e5b
movq -0x18(%rbp), %rdi
callq 0x6e90
testb $0x1, %al
jne 0x6e24
jmp 0x6e5b
movq -0x10(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10490
movq -0x20(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x6e51
jmp 0x6e5b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x6e6e
jmp 0x6e78
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e80
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x7130
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x2a40
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7130
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x80, %edx
callq 0x6fe0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6b60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x711c
movq -0x10(%rbp), %rdi
callq 0x6f60
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x76bb
movq -0x8(%rbp), %rdi
callq 0x6f60
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x6fe0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x10f60
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x774b
movq -0x8(%rbp), %rdi
callq 0x6f60
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x6fe0
leaq 0x125ee(%rip), %rax     # 0x19d50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x6fe0
testb $0x1, -0xd(%rbp)
je 0x77c6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7020
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x10f60
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x7846
jmp 0x785f
movq -0x20(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x7855
jmp 0x785f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x78c9
movq -0x18(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x786e
jmp 0x7887
movq -0x20(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x787d
jmp 0x7887
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x78c9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x78a8
movq -0x10(%rbp), %rdi
callq 0x6f60
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1006, %edx           # imm = 0x1006
callq 0x6fe0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x10f60
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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x7946
jmp 0x7969
movq -0x20(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x7955
jmp 0x7969
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x10f60
movq %rax, -0x8(%rbp)
jmp 0x7a1b
movq -0x18(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x7978
jmp 0x799b
movq -0x20(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x7987
jmp 0x799b
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x10f60
movq %rax, -0x8(%rbp)
jmp 0x7a1b
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x79aa
jmp 0x79d9
movq -0x20(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x79b9
jmp 0x79d9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x79cc
jmp 0x79d9
leaq 0x12375(%rip), %rax     # 0x19d48
movq %rax, -0x8(%rbp)
jmp 0x7a1b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x79fa
movq -0x10(%rbp), %rdi
callq 0x6f60
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x100e, %edx           # imm = 0x100E
callq 0x6fe0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x10f60
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/ryvnf[P]czc/eval.c
// Function: eval_asgn_type
struct type *eval_asgn_type(struct ast *ast)
{
    struct type *lhs_type = eval_type(NULL, ast_ast(ast, 0));
    require_lval(ast, lhs_type);

    struct type *type;
    switch (ast->tag) {
        case ASGN_EXPR:
            type = target_type(lhs_type, eval_type(lhs_type, ast_ast(ast, 1)));
            if (type == NULL)
                incompatible_type(ast);

            require_type(ast, type, ~(VOID_TYPE_FLAG | FUNC_TYPE_FLAG));
            break;
        case ADD_ASGN_EXPR:
            type = ptr_decay(eval_add_type(ast));
            break;
        case SUB_ASGN_EXPR:
            type = ptr_decay(eval_sub_type(ast));
            break;
        case MUL_ASGN_EXPR:
        case DIV_ASGN_EXPR:
            type = ptr_decay(eval_binop_type(ast, INT_TYPE_FLAG | FLOAT_TYPE_FLAG));
            break;
        case REM_ASGN_EXPR:
        case OR_ASGN_EXPR:
        case XOR_ASGN_EXPR:
        case AND_ASGN_EXPR:
        case SHL_ASGN_EXPR:
        case SHR_ASGN_EXPR:
            type = ptr_decay(eval_binop_type(ast, INT_TYPE_FLAG));
            break;
    }

    if (!type_equals(lhs_type, type))
        incompatible_type(ast);

    return type_dup(type, LVAL_TYPE_FLAG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x28(%rbp)
callq 0x2a40
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7020
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0xffffbde0, %eax       # imm = 0xFFFFBDE0
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xa, %eax
ja 0x7b5a
movq -0x20(%rbp), %rax
leaq 0xb43d(%rip), %rcx      # 0x12ecc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7130
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x6d30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7ae2
movq -0x8(%rbp), %rdi
callq 0x6f60
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffde, %edx       # imm = 0xFFFFFFDE
callq 0x6fe0
jmp 0x7b5a
movq -0x8(%rbp), %rdi
callq 0x77e0
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
jmp 0x7b5a
movq -0x8(%rbp), %rdi
callq 0x78e0
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
jmp 0x7b5a
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x7650
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
jmp 0x7b5a
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x7650
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x7b74
movq -0x8(%rbp), %rdi
callq 0x6f60
movq -0x18(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x10f60
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_subscr_type
struct type *eval_subscr_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(ptr_type(lhs_type)->to, LVAL_TYPE_FLAG);

    if (is_int_type(lhs_type) && is_ptr_type(rhs_type))
        return type_dup(ptr_type(lhs_type)->to, LVAL_TYPE_FLAG);

    invalid_type(ast);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x7d56
jmp 0x7d82
movq -0x20(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x7d65
jmp 0x7d82
movq -0x18(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x10f60
movq %rax, -0x8(%rbp)
jmp 0x7dce
movq -0x18(%rbp), %rdi
callq 0x6cb0
testb $0x1, %al
jne 0x7d91
jmp 0x7dbd
movq -0x20(%rbp), %rdi
callq 0x6cf0
testb $0x1, %al
jne 0x7da0
jmp 0x7dbd
movq -0x18(%rbp), %rdi
callq 0x10420
movq 0x8(%rax), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x10f60
movq %rax, -0x8(%rbp)
jmp 0x7dce
movq -0x10(%rbp), %rdi
callq 0x6f20
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_call_type
struct type *eval_call_type(struct ast *ast)
{
    struct type *called_type = eval_type(NULL, ast_ast(ast, 0));
    require_type(ast, called_type, FUNC_TYPE_FLAG);

    struct func_type *called_func_type = func_type(called_type);

    bool has_vararg = called_func_type->has_vararg;
    size_t n_param_types = called_func_type->n_params;
    struct type **param_types = called_func_type->params;

    size_t n_arg_asts;
    struct ast **arg_asts = ast_asts(ast_ast(ast, 1), &n_arg_asts);

    if ((n_arg_asts != n_param_types && !has_vararg) || n_arg_asts <
            n_param_types)
        fatal(ast->loc, "invalid number of arguments");

    for (size_t i = 0; i < n_param_types; i++) {
        struct type *got_type = eval_type(param_types[i], arg_asts[i]);
        struct type *type = target_type(param_types[i], got_type);

        if (type == NULL || !type_equals(param_types[i], type))
            fatal(ast->loc, "invalid type for argument %zu in function call", i + 1);
    }

    return called_func_type->ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x6fe0
movq -0x10(%rbp), %rdi
callq 0x10500
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ad0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x7e7a
testb $0x1, -0x19(%rbp)
je 0x7e84
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7e9a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xb27c(%rip), %rsi      # 0x1310f
movb $0x0, %al
callq 0x6610
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7f3b
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7130
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x50(%rbp), %rsi
callq 0x6d30
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x7f0a
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x58(%rbp), %rsi
callq 0x10c90
testb $0x1, %al
jne 0x7f28
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x48(%rbp), %rdx
addq $0x1, %rdx
leaq 0xb20a(%rip), %rsi      # 0x1312b
movb $0x0, %al
callq 0x6610
jmp 0x7f2a
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x7ea2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_member_type
struct type *eval_member_type(struct ast *ast)
{
    struct ast *lhs_ast = ast_ast(ast, 0);
    struct ast *rhs_ast = ast_ast(ast, 1);
    struct type *lhs_type = eval_type(NULL, lhs_ast);
    const char *member_id = ast_s(rhs_ast);

    if (type_type(lhs_type->tag) != STRUCT_TYPE_FLAG)
        incompatible_type(ast);

    size_t n_fields = struct_type(lhs_type)->n_fields;
    struct field *fields = struct_type(lhs_type)->fields;

    for (size_t i = 0; i < n_fields; i++) {
        if (strcmp(member_id, fields[i].name) == 0)
            return type_dup(fields[i].type, LVAL_TYPE_FLAG);
    }

    fatal(ast->loc, "structure has no member %s", member_id);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6f00
cmpl $0x40, %eax
je 0x7fb6
movq -0x8(%rbp), %rdi
callq 0x6f60
movq -0x20(%rbp), %rdi
callq 0x10570
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10570
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x803d
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x2110
cmpl $0x0, %eax
jne 0x802d
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x10f60
addq $0x40, %rsp
popq %rbp
retq
jmp 0x802f
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x7fe0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0xb10a(%rip), %rsi      # 0x1315a
movb $0x0, %al
callq 0x6610
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_name_type
struct type *eval_name_type(struct type *t, struct ast *ast)
{
    const char *name = ast_s(ast);

    struct sym *sym = scope_get_sym(current_scope, name);

    if (sym == NULL)
        fatal(ast->loc, "undeclared identifier '%s'", name);

    if (sym->tag == DECL_SYM) {
        struct type *type = ((struct decl_sym *)sym)->type;
        if (type == NULL)
            fatal(ast->loc, "undeclared identifier '%s'", name);
        return type_dup(type, LVAL_TYPE_FLAG);
    } else if (sym->tag == ALIAS_SYM) {
        struct expr expr = eval_expr(t, ((struct alias_sym *)sym)->ast);
        expr.rope = add_paren(expr.rope);
        return expr.type;
    }

    unreachable();
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27f0
movq %rax, -0x20(%rbp)
leaq 0x11d14(%rip), %rax     # 0x19dd8
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xf5b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x80f5
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb087(%rip), %rsi      # 0x13175
movb $0x0, %al
callq 0x6610
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x813f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x812b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb051(%rip), %rsi      # 0x13175
movb $0x0, %al
callq 0x6610
movq -0x30(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x10f60
movq %rax, -0x8(%rbp)
jmp 0x819b
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x8178
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x81b0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x81f0
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x819b
jmp 0x817a
leaq 0xb00f(%rip), %rdi      # 0x13190
leaq 0xb02e(%rip), %rsi      # 0x131b6
movl $0x217, %edx            # imm = 0x217
leaq 0xb029(%rip), %rcx      # 0x131bd
movb $0x0, %al
callq 0x6510
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_decl_type
struct type *eval_decl_type(struct ast *ast)
{
    struct ast *name_ast = ast_ast(ast, 0);
    const char *name = ast_s(name_ast);

    struct sym *sym = scope_get_sym(current_scope, name);

    if (!sym || sym->loc != ast) {
        sym = sym_from_ast(ast);
        add_local_decl((struct decl_sym *)sym);
        scope_add_sym(current_scope, name, sym);
    }

    return eval_name_type(NULL, name_ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27f0
movq %rax, -0x18(%rbp)
leaq 0x11b77(%rip), %rax     # 0x19dd8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf5b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8286
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x82b3
movq -0x8(%rbp), %rdi
callq 0xfc50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5450
leaq 0x11b35(%rip), %rax     # 0x19dd8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf550
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x80a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_name_size
size_t eval_name_size(struct ast *ast)
{
    const char *name = ast_s(ast);

    struct sym *sym = scope_get_sym(current_scope, name);
    if (sym == NULL)
        fatal(ast->loc, "undeclared identifier '%s'", name);

    if (sym->tag != ALIAS_SYM) {
        fatal(ast->loc, "accessing variables or functions is allowed in "
                "constant context");
        unreachable();
    }

    return eval_size(((struct alias_sym *)sym)->ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27f0
movq %rax, -0x10(%rbp)
leaq 0x114e8(%rip), %rax     # 0x19dd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf5b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8921
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa85b(%rip), %rsi      # 0x13175
movb $0x0, %al
callq 0x6610
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x8940
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa9bf(%rip), %rsi      # 0x132f8
movb $0x0, %al
callq 0x6610
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8960
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_comma_expr
struct expr eval_comma_expr(struct type *t, struct ast *ast)
{
    struct ast *lhs_ast = ast_ast(ast, 0);
    struct ast *rhs_ast = ast_ast(ast, 1);
    struct expr lhs_expr = eval_expr(NULL, lhs_ast);
    struct expr rhs_expr = eval_expr(t, rhs_ast);

    int prec = get_c_prec(ast->tag);
    int lhs_prec = get_c_prec(lhs_ast->tag);
    int rhs_prec = get_c_prec(rhs_ast->tag);

    if (lhs_prec < prec || (lhs_prec == prec && is_rassoc(ast->tag)))
        lhs_expr.rope = add_paren(lhs_expr.rope);

    if (rhs_prec < prec || (rhs_prec == prec && !is_rassoc(ast->tag)))
        rhs_expr.rope = add_paren(rhs_expr.rope);

    struct rope *rope = lhs_expr.rope;
    rope = rope_new_tree(rope, comma_sp_rope);
    rope = rope_new_tree(rope, rhs_expr.rope);

    return (struct expr) {
        .rope = rope,
        .type = eval_type(NULL, ast)
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x81b0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x5c(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x54(%rbp), %eax
jl 0x9188
movl -0x58(%rbp), %eax
cmpl -0x54(%rbp), %eax
jne 0x9195
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6b20
testb $0x1, %al
jne 0x9188
jmp 0x9195
movq -0x38(%rbp), %rdi
callq 0x81f0
movq %rax, -0x38(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x54(%rbp), %eax
jl 0x91b4
movl -0x5c(%rbp), %eax
cmpl -0x54(%rbp), %eax
jne 0x91c1
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6b20
testb $0x1, %al
jne 0x91c1
movq -0x48(%rbp), %rdi
callq 0x81f0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
leaq 0x1031c(%rip), %rsi     # 0x194f0
callq 0xf2a0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)