LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
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
callq 0x56c1
movl $0xffffbde0, %eax       # imm = 0xFFFFBDE0
addl (%rbx), %eax
cmpl $0xa, %eax
ja 0x5e80
leaq 0x7ccd(%rip), %rcx      # 0xdab0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x5dfe
movq %rbx, %rdi
movl $0x6, %esi
callq 0x5abb
movq %rax, %rdi
callq 0x5616
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xbe53
testb %al, %al
je 0x5e82
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xc018
movq %rbx, %rdi
callq 0x5ccc
jmp 0x5e03
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %r14, %rdi
movq %rax, %rsi
callq 0x578e
movq %r14, %rdi
movq %rax, %rsi
callq 0x5545
testq %rax, %rax
je 0x5e82
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl $0xffffffde, %edx       # imm = 0xFFFFFFDE
callq 0x5696
jmp 0x5e0e
movq %rbx, %rdi
callq 0x5c12
jmp 0x5e03
jmp 0x5e0e
movq 0x8(%rbx), %r14
movl (%rbx), %edi
callq 0x50b4
leaq 0x7f72(%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_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 %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 0x5fe5
testb $0x2, (%rax)
jne 0x5fef
testb $0x2, %cl
je 0x600c
testb $0x8, (%rax)
je 0x600c
movq %r14, %rdi
callq 0xb937
movq 0x8(%rax), %rdi
movl $0x400, %esi            # imm = 0x400
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc018
movq 0x8(%rbx), %r14
movl (%rbx), %edi
callq 0x50b4
leaq 0x7dcb(%rip), %rsi      # 0xdde9
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_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
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 $0x20, %edx
callq 0x5696
movq %r14, %rdi
callq 0xb99b
movq %rax, %r14
movb 0x18(%rax), %bpl
movq 0x10(%rax), %r13
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x2825
movq %rax, %r15
movq (%r12), %rax
cmpq %r13, %rax
setae %al
je 0x609f
andb %al, %bpl
je 0x610b
testq %r13, %r13
je 0x60e0
xorl %r12d, %r12d
movq 0x20(%r14,%r12,8), %rdi
movq (%r15,%r12,8), %rsi
callq 0x578e
movq 0x20(%r14,%r12,8), %rdi
movq %rax, %rsi
callq 0x5545
testq %rax, %rax
je 0x60f3
movq 0x20(%r14,%r12,8), %rdi
movq %rax, %rsi
callq 0xbe53
testb %al, %al
je 0x60f3
incq %r12
cmpq %r12, %r13
jne 0x60a7
movq 0x8(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
incq %r12
leaq 0x7d5a(%rip), %rsi      # 0xde5b
movq %r12, %rdx
xorl %eax, %eax
callq 0x4fa1
movq 0x8(%rbx), %rdi
leaq 0x7d29(%rip), %rsi      # 0xde3f
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %rax, %r12
xorl %edi, %edi
movq %r14, %rsi
callq 0x578e
movq %rax, %r15
movq %r12, %rdi
callq 0x26f0
movq %rax, %r14
movl $0x3ff, %eax            # imm = 0x3FF
andl (%r15), %eax
cmpl $0x40, %eax
jne 0x61cd
movq %r15, %rdi
callq 0xb9cd
movq 0x10(%rax), %r12
movq %r15, %rdi
callq 0xb9cd
testq %r12, %r12
je 0x61a0
movq %rax, %r15
addq $0x28, %r15
movq -0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2100
testl %eax, %eax
je 0x61b5
addq $0x10, %r15
decq %r12
jne 0x6187
movq 0x8(%rbx), %rdi
leaq 0x7cdf(%rip), %rsi      # 0xde8a
movq %r14, %rdx
xorl %eax, %eax
callq 0x4fa1
movq (%r15), %rdi
movl $0x400, %esi            # imm = 0x400
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc018
movq 0x8(%rbx), %r14
movl (%rbx), %edi
callq 0x50b4
leaq 0x7c27(%rip), %rsi      # 0xde06
movq %r14, %rdi
movq %rax, %rdx
jmp 0x61ae
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x26f0
movq %rax, %rbx
leaq 0xdbae(%rip), %rax      # 0x13de0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xb09c
testq %rax, %rax
je 0x629e
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x6266
cmpl $0x1, %ecx
jne 0x62b3
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x629e
movl $0x400, %esi            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xc018
movq 0x10(%rax), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x79f9
movq %rax, %rbx
leaq 0xd022(%rip), %rdi      # 0x132a0
movq %rdx, %rsi
callq 0xaebf
leaq 0xd033(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdi
leaq 0x7bfc(%rip), %rsi      # 0xdea5
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4fa1
leaq 0x7c06(%rip), %rdi      # 0xdec0
leaq 0x7c25(%rip), %rsi      # 0xdee6
leaq 0x7c25(%rip), %rcx      # 0xdeed
movl $0x217, %edx            # imm = 0x217
xorl %eax, %eax
callq 0x4eac
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
movq %rax, %rbx
movq %rax, %rdi
callq 0x26f0
movq %rax, %r15
leaq 0xdade(%rip), %r12      # 0x13de0
movq (%r12), %rdi
movq %rax, %rsi
callq 0xb09c
testq %rax, %rax
je 0x6319
cmpq %r14, 0x8(%rax)
je 0x633b
movq %r14, %rdi
callq 0xb48c
movq %rax, %r14
movq %rax, %rdi
callq 0x4278
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb08b
xorl %edi, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6215
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_init_type
struct type *eval_init_type(struct type *t, struct ast *ast)
{
    size_t n_childs;
    struct ast **childs = ast_asts(ast, &n_childs);

    if (is_array_type(t)) {
        struct array_type *a_t = array_type(t);

        if (a_t->len < n_childs)
            fatal(ast->loc, "excess elements in array initializer");

        for (size_t i = 0; i < n_childs; i++) {
            struct type *got_type = eval_type(a_t->of, childs[i]);
            struct type *type = target_type(a_t->of, got_type);

            if (type == NULL || !type_equals(a_t->of, type))
                fatal(ast->loc, "invalid type in array initializer");
        }
    } else if (is_struct_type(t)) {
        struct struct_type *s_t = struct_type(t);

        if (s_t->n_fields < n_childs)
            fatal(ast->loc, "excess elements in struct initializer");

        for (size_t i = 0; i < n_childs; i++) {
            struct type *field_type = s_t->fields[i].type;
            struct type *got_type = eval_type(field_type, childs[i]);
            struct type *type = target_type(field_type, got_type);

            if (type == NULL || !type_equals(field_type, type))
                fatal(ast->loc, "invalid type in struct initializer");
        }
    } else {
        fatal(ast->loc, "invalid type");
    }

    return type_dup(t, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2825
movq %rax, %r15
movl (%r14), %eax
testb $0x10, %al
jne 0x63ed
testb $0x40, %al
je 0x6481
movq %r14, %rdi
callq 0xb9cd
movq %rax, %r12
movq (%rsp), %rax
cmpq %rax, 0x10(%r12)
jb 0x649b
testq %rax, %rax
je 0x6449
addq $0x28, %r12
xorl %ebp, %ebp
movq (%r12), %r13
movq (%r15,%rbp,8), %rsi
movq %r13, %rdi
callq 0x578e
movq %r13, %rdi
movq %rax, %rsi
callq 0x5545
testq %rax, %rax
je 0x646f
movq %r13, %rdi
movq %rax, %rsi
callq 0xbe53
testb %al, %al
je 0x646f
incq %rbp
addq $0x10, %r12
cmpq (%rsp), %rbp
jb 0x63a7
jmp 0x6449
movq %r14, %rdi
callq 0xb969
movq %rax, %r12
movq (%rsp), %rax
cmpq %rax, 0x10(%r12)
jb 0x648e
testq %rax, %rax
je 0x6449
xorl %r13d, %r13d
movq 0x8(%r12), %rdi
movq (%r15,%r13,8), %rsi
callq 0x578e
movq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0x5545
testq %rax, %rax
je 0x6462
movq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0xbe53
testb %al, %al
je 0x6462
incq %r13
cmpq (%rsp), %r13
jb 0x640f
movq %r14, %rdi
xorl %esi, %esi
callq 0xc018
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
leaq 0x7ab4(%rip), %rsi      # 0xdf21
jmp 0x647a
movq 0x8(%rbx), %rdi
leaq 0x7aef(%rip), %rsi      # 0xdf69
xorl %eax, %eax
callq 0x4fa1
movq 0x8(%rbx), %rdi
leaq 0x7b00(%rip), %rsi      # 0xdf8c
jmp 0x647a
movq 0x8(%rbx), %rdi
leaq 0x7a63(%rip), %rsi      # 0xdefc
jmp 0x647a
movq 0x8(%rbx), %rdi
leaq 0x7a9d(%rip), %rsi      # 0xdf43
jmp 0x647a
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: alignof_type
size_t alignof_type(struct loc *loc, struct type *type)
{
    switch (type_type(type->tag)) {
        case VOID_TYPE_FLAG:
            fatal(loc, "cannot compute the size of void");
            return 0;
        case FUNC_TYPE_FLAG:
            fatal(loc, "cannot compute the size of a function");
            return 0;
        case BOOL_TYPE_FLAG:
        case INT_TYPE_FLAG:
        case FLOAT_TYPE_FLAG:
            return sizeof_basic_type(type);
        case PTR_TYPE_FLAG:
            // This would not be portable on computers where size of function
            // pointers is different from regular pointers.
            return sizeof (void *);
        case ARRAY_TYPE_FLAG: {
            struct type *elem_type = array_type(type)->of;
            return alignof_type(loc, elem_type);
        }
        case STRUCT_TYPE_FLAG: {
            size_t n_fields = struct_type(type)->n_fields;
            struct field *fields = struct_type(type)->fields;
            size_t max_align = 1;

            for (size_t i = 0; i < n_fields; i++) {
                size_t align = alignof_type(loc, fields[i].type);
                if (align > max_align)
                    max_align = align;
            }

            return max_align;
        }
    }

    unreachable();
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3ff, %ebp            # imm = 0x3FF
movl (%r14), %eax
andl %ebp, %eax
cmpl $0x10, %eax
jne 0x64d3
movq %r14, %rdi
callq 0xb969
movq 0x8(%rax), %r14
jmp 0x64bb
cmpl $0x1f, %eax
jg 0x64fb
decl %eax
cmpl $0x7, %eax
ja 0x658b
leaq 0x75f2(%rip), %rcx      # 0xdadc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %r14d
jmp 0x6560
cmpl $0x40, %eax
je 0x6517
cmpl $0x80, %eax
jne 0x656c
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb4e8
movq %r14, %rdi
callq 0xb9cd
movq 0x10(%rax), %r12
movq %r14, %rdi
callq 0xb9cd
testq %r12, %r12
je 0x655a
movq %rax, %r15
addq $0x28, %r15
movl $0x1, %r14d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x64a8
cmpq %r14, %rax
cmovaq %rax, %r14
addq $0x10, %r15
decq %r12
jne 0x653d
jmp 0x6560
movl $0x1, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x20, %eax
jne 0x658b
leaq 0x7a71(%rip), %rsi      # 0xdfe9
jmp 0x6581
leaq 0x7a48(%rip), %rsi      # 0xdfc9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4fa1
leaq 0x792e(%rip), %rdi      # 0xdec0
leaq 0x794d(%rip), %rsi      # 0xdee6
leaq 0x7a6f(%rip), %rcx      # 0xe00f
movl $0x314, %edx            # imm = 0x314
xorl %eax, %eax
callq 0x4eac
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x26f0
movq %rax, %r14
leaq 0xd692(%rip), %rax      # 0x13de0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xb09c
testq %rax, %rax
je 0x6773
cmpl $0x2, (%rax)
jne 0x6788
movq 0x10(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x679a
movq 0x8(%rbx), %rdi
leaq 0x7727(%rip), %rsi      # 0xdea5
movq %r14, %rdx
xorl %eax, %eax
callq 0x4fa1
movq 0x8(%rbx), %rdi
leaq 0x7895(%rip), %rsi      # 0xe028
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
movl $0x1, %esi
movq %r13, %rdi
callq 0x27e8
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %rbx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movl (%r13), %r13d
movl %r13d, %edi
callq 0x5349
movl %eax, %ebp
movl (%r12), %edi
callq 0x5349
movl %eax, %r15d
movl (%r14), %edi
callq 0x5349
movl %eax, %r12d
cmpl %ebp, %r15d
jb 0x6e0a
jne 0x6e36
leal -0x4220(%r13), %eax
cmpl $0xb, %eax
jae 0x6e2d
leaq 0xc48f(%rip), %rdi      # 0x132a0
movq %rbx, %rsi
callq 0xaebf
leaq 0xc4a0(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
jmp 0x6e39
cmpl $0x4210, %r13d          # imm = 0x4210
je 0x6e0a
movq %rbx, %r14
cmpl %ebp, %r12d
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
jae 0x6e6b
leaq 0xc451(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xc462(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
jmp 0x6e7a
jne 0x6e7a
movl (%rbx), %eax
leal -0x4220(%rax), %ecx
cmpl $0xb, %ecx
jae 0x6eb3
leaq 0xc67f(%rip), %rsi      # 0x13500
movq %r14, %rdi
callq 0xaebf
movq %rax, %rdi
movq %r15, %rsi
callq 0xaebf
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x578e
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x4210, %eax           # imm = 0x4210
je 0x6e7a
jmp 0x6e48
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_binop_expr
struct expr eval_binop_expr(struct ast *ast, struct rope *c_op)
{
    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(NULL, 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, c_op);
    rope = rope_new_tree(rope, rhs_expr.rope);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
movq %rax, %r13
movl $0x1, %esi
movq %r14, %rdi
callq 0x27e8
movq %rax, %r12
xorl %edi, %edi
movq %r13, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %rbx
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl (%r14), %r14d
movl %r14d, %edi
callq 0x5349
movl %eax, %ebp
movl (%r13), %edi
callq 0x5349
movl %eax, %r15d
movl (%r12), %edi
callq 0x5349
movl %eax, %r13d
cmpl %ebp, %r15d
jb 0x6f48
jne 0x6f74
leal -0x4220(%r14), %eax
cmpl $0xb, %eax
jae 0x6f6b
leaq 0xc351(%rip), %rdi      # 0x132a0
movq %rbx, %rsi
callq 0xaebf
leaq 0xc362(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
jmp 0x6f77
cmpl $0x4210, %r14d          # imm = 0x4210
je 0x6f48
movq %rbx, %r14
cmpl %ebp, %r13d
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
jae 0x6fa9
leaq 0xc313(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xc324(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
jmp 0x6fb8
jne 0x6fb8
movl (%rbx), %eax
leal -0x4220(%rax), %ecx
cmpl $0xb, %ecx
jae 0x6fee
movq (%rsp), %rsi
movq %r14, %rdi
callq 0xaebf
movq %rax, %rdi
movq %r15, %rsi
callq 0xaebf
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x578e
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x4210, %eax           # imm = 0x4210
je 0x6fb8
jmp 0x6f86
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_preop_expr
struct expr eval_preop_expr(struct ast *ast, struct rope *c_op)
{
    struct ast *expr_ast = ast_ast(ast, 0);
    struct expr expr = eval_expr(NULL, expr_ast);
    if (get_c_prec(expr_ast->tag) < get_c_prec(ast->tag))
        expr.rope = add_paren(expr.rope);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r15
movl (%r12), %edi
callq 0x5349
movl %eax, %ebp
movl (%r14), %edi
callq 0x5349
cmpl %eax, %ebp
jae 0x7056
leaq 0xc264(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xc275(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x578e
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaebf
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_postop_expr
struct expr eval_postop_expr(struct ast *ast, struct rope *c_op)
{
    struct ast *expr_ast = ast_ast(ast, 0);
    struct expr expr = eval_expr(NULL, expr_ast);
    if (get_c_prec(expr_ast->tag) < get_c_prec(ast->tag))
        expr.rope = add_paren(expr.rope);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r15
movl (%r12), %edi
callq 0x5349
movl %eax, %ebp
movl (%r14), %edi
callq 0x5349
cmpl %eax, %ebp
jae 0x70dc
leaq 0xc1de(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xc1ef(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x578e
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0xaebf
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_cond_expr
struct expr eval_cond_expr(struct type *t, struct ast *ast)
{
    struct type *type = eval_type(NULL, ast);
    struct ast *cond_ast = ast_ast(ast, 0);
    struct ast *then_ast = ast_ast(ast, 1);
    struct ast *else_ast = ast_ast(ast, 2);
    struct expr cond_expr = eval_expr(NULL, cond_ast);
    struct expr then_expr = eval_expr(t, then_ast);
    struct expr else_expr = eval_expr(t, else_ast);

    int prec = get_c_prec(ast->tag);
    int cond_prec = get_c_prec(cond_ast->tag);
    int else_prec = get_c_prec(else_ast->tag);

    if (cond_prec <= prec)
        cond_expr.rope = add_paren(cond_expr.rope);

    if (else_prec < prec)
        else_expr.rope = add_paren(else_expr.rope);

    struct rope *rope = cond_expr.rope;
    rope = rope_new_tree(rope, rope_new_s(" ? "));
    rope = rope_new_tree(rope, then_expr.rope);
    rope = rope_new_tree(rope, rope_new_s(" : "));
    rope = rope_new_tree(rope, else_expr.rope);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r14
xorl %edi, %edi
callq 0x578e
movq %rax, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x27e8
movq %rax, %rbp
movl $0x1, %esi
movq %r13, %rdi
callq 0x27e8
movq %rax, %r15
movl $0x2, %esi
movq %r13, %rdi
callq 0x27e8
movq %rax, %rbx
xorl %edi, %edi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r14
movl (%r13), %edi
callq 0x5349
movl %eax, %r13d
movl (%rbp), %edi
callq 0x5349
movl %eax, %ebp
movl (%rbx), %edi
callq 0x5349
movl %eax, %ebx
cmpl %r13d, %ebp
ja 0x71c0
leaq 0xc0fa(%rip), %rdi      # 0x132a0
movq %r12, %rsi
callq 0xaebf
leaq 0xc10b(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r12
cmpl %r13d, %ebx
jae 0x71e6
leaq 0xc0d4(%rip), %rdi      # 0x132a0
movq %r14, %rsi
callq 0xaebf
leaq 0xc0e5(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
leaq 0x6f17(%rip), %rdi      # 0xe104
callq 0xaee6
movq %r12, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %rdi
movq %r15, %rsi
callq 0xaebf
movq %rax, %rbx
leaq 0x6ef6(%rip), %rdi      # 0xe108
callq 0xaee6
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %rdi
movq %r14, %rsi
callq 0xaebf
movq %rax, %rdx
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_cast_expr
struct expr eval_cast_expr(struct ast *ast)
{
    // TODO check if cast is legal
    struct expr expr = eval_expr(NULL, ast_ast(ast, 0));
    struct rope *rope = lparen_rope;
    struct type *type = type_from_ast(ast_ast(ast, 1));
    rope = rope_new_tree(rope, type_to_c(NULL, type));
    rope = rope_new_tree(rope, rparen_rope);
    rope = rope_new_tree(rope, lparen_rope);
    rope = rope_new_tree(rope, expr.rope);
    rope = rope_new_tree(rope, rparen_rope);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x27e8
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %rbx
movl $0x1, %esi
movq %r14, %rdi
callq 0x27e8
movq %rax, %rdi
callq 0xba08
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
callq 0x342a
leaq 0xbfe4(%rip), %r15      # 0x132a0
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
leaq 0xbff2(%rip), %r12      # 0x132c0
movq %rax, %rdi
movq %r12, %rsi
callq 0xaebf
movq %rax, %rdi
movq %r15, %rsi
callq 0xaebf
movq %rax, %rdi
movq %rbx, %rsi
callq 0xaebf
movq %rax, %rdi
movq %r12, %rsi
callq 0xaebf
movq %rax, %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_call_expr
struct expr eval_call_expr(struct ast *ast)
{
    struct type *type = eval_type(NULL, ast);
    struct ast *called_ast = ast_ast(ast, 0);
    struct expr called_expr = eval_expr(NULL, called_ast);
    if (get_c_prec(called_ast->tag) < get_c_prec(ast->tag))
        called_expr.rope = add_paren(called_expr.rope);

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

    rope = rope_new_tree(rope, rope_new_s("("));

    struct func_type *called_type = func_type(called_expr.type);

    for (size_t i = 0; i < n_arg_asts; i++) {
        struct expr arg_expr;
        if (i < called_type->n_params)
            arg_expr = eval_expr(called_type->params[i], arg_asts[i]);
        else
            arg_expr = eval_expr(NULL, arg_asts[i]);
        if (get_c_prec(arg_asts[i]->tag) <= get_c_prec(COMMA_EXPR))
            arg_expr.rope = add_paren(arg_expr.rope);

        rope = rope_new_tree(rope, arg_expr.rope);

        if (i != n_arg_asts - 1)
            rope = rope_new_tree(rope, rope_new_s(", "));
    }

    rope = rope_new_tree(rope, rope_new_s(")"));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x578e
movq %rax, 0x10(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rax, %rbx
movq %rdx, %r15
movl (%r12), %edi
callq 0x5349
movl %eax, %ebp
movl (%r14), %edi
callq 0x5349
cmpl %eax, %ebp
jae 0x7383
leaq 0xbf37(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xbf48(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x27e8
leaq 0x8(%rsp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x2825
movq %rax, %r14
leaq 0x7446(%rip), %rdi      # 0xe7f0
callq 0xaee6
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %r15
movq %rbx, %rdi
callq 0xb99b
cmpq $0x0, (%r13)
je 0x746d
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x645a(%rip), %rbx      # 0xd836
cmpq 0x10(%r12), %rbp
jae 0x73ea
movq 0x20(%r12,%rbp,8), %rdi
jmp 0x73ec
xorl %edi, %edi
movq (%r14,%rbp,8), %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r13
movq (%r14,%rbp,8), %rax
movl (%rax), %edi
callq 0x5349
testl %eax, %eax
jne 0x742a
leaq 0xbe90(%rip), %rdi      # 0x132a0
movq %r13, %rsi
callq 0xaebf
movq %rax, %rdi
leaq 0xbe9e(%rip), %rsi      # 0x132c0
callq 0xaebf
movq %rax, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0xaebf
movq %rax, %r15
movq 0x8(%rsp), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %rbp
je 0x7461
movq %rbx, %rdi
callq 0xaee6
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %r15
movq 0x8(%rsp), %rax
incq %rbp
cmpq %rax, %rbp
jb 0x73dc
leaq 0x5dc8(%rip), %rdi      # 0xd23c
callq 0xaee6
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %rdx
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_subscr_expr
struct expr eval_subscr_expr(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(NULL, rhs_ast);

    if (get_c_prec(lhs_ast->tag) < get_c_prec(ast->tag))
        lhs_expr.rope = add_paren(lhs_expr.rope);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r15
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r14
movl (%r12), %edi
callq 0x5349
movl %eax, %ebp
movl (%rbx), %edi
callq 0x5349
cmpl %eax, %ebp
jae 0x7515
leaq 0xbda5(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xbdb6(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
leaq 0xbe04(%rip), %rsi      # 0x13320
movq %r15, %rdi
callq 0xaebf
movq %rax, %rdi
movq %r14, %rsi
callq 0xaebf
leaq 0xbe0a(%rip), %rsi      # 0x13340
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x578e
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_member_expr
struct expr eval_member_expr(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);
    const char *member_id = ast_s(rhs_ast);

    int prec = get_c_prec(MEMBER_EXPR);
    int lhs_prec = get_c_prec(lhs_ast->tag);

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

    struct rope *rope = lhs_expr.rope;
    rope = rope_new_tree(rope, dot_rope);
    rope = rope_new_tree(rope, rope_new_s(member_id));

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27e8
movq %rax, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27e8
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x79f9
movq %rdx, %r15
movq %r14, %rdi
callq 0x26f0
movq %rax, %r14
movl (%r12), %edi
callq 0x5349
cmpl $0xf, %eax
jne 0x75b1
movl (%rbx), %eax
leal -0x4220(%rax), %ecx
cmpl $0xb, %ecx
jae 0x7613
leaq 0xbce8(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xaebf
leaq 0xbcf9(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq %rax, %r15
leaq 0xc147(%rip), %rsi      # 0x13720
movq %r15, %rdi
callq 0xaebf
movq %rax, %r15
movq %r14, %rdi
callq 0xaee6
movq %r15, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x578e
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x4210, %eax           # imm = 0x4210
je 0x75b1
jmp 0x75d2
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_name_expr
struct expr eval_name_expr(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);

    switch (sym->tag) {
        case DECL_SYM:
            return (struct expr) {
                .rope = rope_new_s(((struct decl_sym *)sym)->c_name),
                .type = ((struct decl_sym *)sym)->type
            };
        case ALIAS_SYM:
            return eval_expr(t, ((struct alias_sym *)sym)->ast);
    }
    abort();
    return (struct expr){ 0 };
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x26f0
movq %rax, %r14
leaq 0xc7a7(%rip), %rax      # 0x13de0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xb09c
testq %rax, %rax
je 0x7681
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x7667
cmpl $0x1, %ecx
jne 0x7696
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rbx
callq 0xaee6
movq %rax, %rdx
jmp 0x7678
movq 0x10(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x79f9
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rdi
leaq 0x6819(%rip), %rsi      # 0xdea5
movq %r14, %rdx
xorl %eax, %eax
callq 0x4fa1
callq 0x2040
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/eval.c
// Function: eval_str_lit_expr
struct expr eval_str_lit_expr(struct ast *ast)
{
    size_t n_cstr = 0;
    char *cstr = malloc(n_cstr);

    size_t n_chars;
    const char *chars = ast_chars(ast, &n_chars);

    // Build a C string
    for (size_t i = 0; i < n_chars; i++) {
        char buf[8];

        if (chars[i] == '\\')
            snprintf(buf, sizeof buf, "\\\\");
        else if (chars[i] == '"')
            snprintf(buf, sizeof buf, "\\\"");
        else if (isgraph(chars[i]) || chars[i] == ' ')
            snprintf(buf, sizeof buf, "%c", chars[i]);
        else
            snprintf(buf, sizeof buf, "\\x%02X", chars[i]);

        appends(&cstr, &n_cstr, buf);
    }
    appendc(&cstr, &n_cstr, '\0');

    return (struct expr) {
        .type = eval_type(NULL, ast),
        .rope = rope_new_fmt("\"%s\"", cstr)
    };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x2160
movq %rax, %r14
leaq 0x20(%rsp), %r12
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x272c
movq %rax, 0x18(%rsp)
cmpq $0x0, (%r12)
je 0x77fe
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x18(%rsp), %rax
movzbl (%rax,%r13), %r12d
cmpl $0x22, %r12d
je 0x7761
cmpl $0x5c, %r12d
jne 0x7772
movb $0x0, 0xa(%rsp)
movw $0x5c5c, 0x8(%rsp)      # imm = 0x5C5C
jmp 0x776d
movb $0x0, 0xa(%rsp)
movw $0x225c, 0x8(%rsp)      # imm = 0x225C
movb $0x5c, %r12b
jmp 0x77bd
callq 0x2260
cmpb $0x20, %r12b
je 0x77ae
movsbq %r12b, %rcx
movq (%rax), %rax
cmpw $0x0, (%rax,%rcx,2)
js 0x77ae
movsbl %r12b, %ecx
movl $0x8, %esi
leaq 0x8(%rsp), %rdi
leaq 0x697a(%rip), %rdx      # 0xe11a
xorl %eax, %eax
callq 0x20c0
movb 0x8(%rsp), %r12b
jmp 0x77b8
movb %r12b, 0x8(%rsp)
movb $0x0, 0x9(%rsp)
testb %r12b, %r12b
je 0x77f9
leaq 0x9(%rsp), %r15
leaq 0x1(%rbx), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2190
movq %rax, %r14
movb %r12b, (%rax,%rbx)
movb (%r15), %r12b
incq %r15
movq %rbp, %rbx
testb %r12b, %r12b
jne 0x77c2
incq %r13
movq %rbp, %rbx
cmpq 0x20(%rsp), %r13
jb 0x773d
jmp 0x77fe
movq %rbx, %rbp
jmp 0x77e6
leaq 0x1(%rbp), %rsi
movq %r14, %rdi
callq 0x2190
movq %rax, %r14
movb $0x0, (%rax,%rbp)
xorl %edi, %edi
movq 0x10(%rsp), %rsi
callq 0x578e
movq %rax, %rbx
leaq 0x68fa(%rip), %rdi      # 0xe121
movq %r14, %rsi
xorl %eax, %eax
callq 0xaef7
movq %rax, %rdx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/lex.c
// Function: hexdigit
int hexdigit(int *val, int c)
{
    if (c >= '0' && c <= '9') {
        return *val = *val * 16 + c - '0';
    } else if (c >= 'a' && c <= 'f') {
        return *val = *val * 16 + c - 'a' + 10;
    } else if (c >= 'A' && c <= 'F') {
        return *val = *val * 16 + c - 'A' + 10;
    }
    return -1;
}

// Assembly:
leal -0x30(%rsi), %eax
cmpl $0x9, %eax
ja 0x80aa
movl (%rdi), %ecx
shll $0x4, %ecx
orl %ecx, %eax
jmp 0x80d5
leal -0x61(%rsi), %eax
cmpl $0x5, %eax
ja 0x80be
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x57, %eax
jmp 0x80d5
leal -0x41(%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x5, %ecx
ja 0x80d7
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x37, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/lex.c
// Function: lex_getc
int lex_getc() {
    int c = getc(yyin);
    if (c == '\n')
        linenr++;
    return c;
}

// Assembly:
pushq %rax
movq 0xbcae(%rip), %rdi      # 0x13da8
callq 0x2240
cmpl $0xa, %eax
jne 0x810a
incl 0xbc96(%rip)            # 0x13da0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/lex.c
// Function: skip_block_comment
void skip_block_comment(void)
{
    int prev_c = '\0';
    int c;
    while ((c = lex_getc()) != EOF) {
        if (c == '/' && prev_c == '*') {
            return;
        }
        prev_c = c;
    }
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
movq 0xba23(%rip), %rdi      # 0x13da8
callq 0x2240
cmpl $0xa, %eax
je 0x8396
cmpl $-0x1, %eax
jne 0x839c
jmp 0x83aa
incl 0xba04(%rip)            # 0x13da0
movl %eax, %ecx
xorl $0x2f, %ecx
xorl $0x2a, %ebx
orl %ecx, %ebx
movl %eax, %ebx
jne 0x837e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/main.c
// Function: arg_list_del
void arg_list_del(struct arg_list *arg_list)
{
    if (arg_list == NULL)
        return;

    free(arg_list->arg);
    arg_list_del(arg_list->next);
    free(arg_list);
}

// Assembly:
testq %rdi, %rdi
je 0x8cef
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x8ccc
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/main.c
// Function: gen_c
void gen_c(struct arg_list *src_files, char *out)
{
    if (out) {
        FILE *fp;
        if ((fp = fopen(out, "w")) == NULL) {
            perror("fopen");
            exit(1);
        }

        gen_input_file(src_files->arg, fp);
        fclose(fp);
    }

    for (struct arg_list *i = src_files; i != NULL; i = i->next) {
        char *c_file_name = strdup(i->arg);
        char *c_file_ext = get_file_ext(c_file_name);
        c_file_ext[0] = 'c';
        c_file_ext[1] = '\0';

        FILE *fp;
        if ((fp = fopen(c_file_name, "w")) == NULL) {
            perror("fopen");
            exit(1);
        }
        
        gen_input_file(i->arg, fp);
        fclose(fp);
        free(c_file_name);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8d80
leaq 0x5877(%rip), %rax      # 0xe5c2
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21c0
testq %rax, %rax
je 0x8d7b
movq %rax, %r14
movq (%rbx), %rdi
callq 0x99d4
movq %rax, %rdi
movq %r14, %rsi
callq 0x4adc
movq %r14, %rdi
callq 0x2090
jmp 0x8d85
callq 0x22be
testq %rbx, %rbx
je 0x8ded
movq (%rbx), %rdi
callq 0x2220
movq %rax, %r14
movq %rax, %rdi
movl $0x2e, %esi
callq 0x20d0
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movw $0x63, (%rcx)
leaq 0x580e(%rip), %rsi      # 0xe5c2
movq %r14, %rdi
callq 0x21c0
testq %rax, %rax
je 0x8df3
movq %rax, %r15
movq (%rbx), %rdi
callq 0x99d4
movq %rax, %rdi
movq %r15, %rsi
callq 0x4adc
movq %r15, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2030
movq 0x8(%rbx), %rbx
jmp 0x8d80
popq %rbx
popq %r14
popq %r15
retq
callq 0x22d3
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/main.c
// Function: print_ast_files
void print_ast_files(struct arg_list *src_files)
{
    for (struct arg_list *i = src_files; i != NULL; i = i->next) {
        printf("--- FILE %s ---\n", i->arg);
        struct ast *ast = parse(i->arg);
        ast_print(ast, 0);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8e3a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x576e(%rip), %r14      # 0xe579
movq (%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20b0
movq (%rbx), %rdi
callq 0x99d4
movq %rax, %rdi
xorl %esi, %esi
callq 0x2d83
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x8e0b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/parse.c
// Function: parse_program
struct ast *parse_program(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    struct ast_list *extern_def_list = parse_list(parse, -1, parse_extern_def);

    if (peek_tok(parse)->type != EOF_TOK)
        syntax_error(parse);

    return ast_new_list(line, SOURCE_FILE, extern_def_list);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
movslq 0x14(%rdi), %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rbx
leaq 0xd4(%rip), %rdx        # 0x95ca
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9543
movq (%r14), %rcx
movslq 0x14(%r14), %rdx
shlq $0x5, %rdx
cmpl $0x0, (%rcx,%rdx)
jne 0x9528
movq %rbx, %rdi
movl $0x4502, %esi           # imm = 0x4502
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x263d
movq 0x8(%rcx,%rdx), %rdi
callq 0x8c83
leaq 0x5236(%rip), %rsi      # 0xe76f
movq %rax, %rdi
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/parse.c
// Function: parse_list
static struct ast_list *parse_list(struct parse *parse, enum tok delim,
        struct ast *(*parse_syntax)(struct parse *))
{
    size_t n_asts = 0;
    struct ast_list *head = NULL;
    struct ast_list **tailp = &head;

    for (;;) {
        int pos = parse->pos;
        struct ast *ast = parse_syntax(parse);
        if (ast == NULL) {
            parse->pos = pos;
            break;
        }

        *tailp = ast_list_new(ast);
        (*tailp)->ast = ast;

        n_asts++;
        tailp = &(*tailp)->next;

        if (delim != -1) {
            if (peek_tok(parse)->type != delim)
                break;
            parse->pos++;
        }
    }

    return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq $0x0, (%rsp)
movl 0x14(%rdi), %r13d
callq *%rdx
testq %rax, %rax
je 0x95b3
movq %rax, %r15
movq %rsp, %r12
movq %r15, %rdi
callq 0x26d4
movq %rax, (%r12)
movq %r15, (%rax)
movq (%r12), %r12
movl 0x14(%rbx), %r13d
cmpl $-0x1, %ebp
je 0x95a1
movslq %r13d, %rax
movq (%rbx), %rcx
shlq $0x5, %rax
cmpl %ebp, (%rcx,%rax)
jne 0x95b7
incl %r13d
movl %r13d, 0x14(%rbx)
addq $0x8, %r12
movq %rbx, %rdi
callq *%r14
movq %rax, %r15
testq %rax, %rax
jne 0x956f
movl %r13d, 0x14(%rbx)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/parse.c
// Function: parse_with_include_map
struct ast *parse_with_include_map(const char *path, struct strmap
        *included_files, int nest_include_lev)
{
    struct parse *parse = tokenize(path);
    parse->included_files = included_files;
    parse->nest_include_level = nest_include_lev;
    struct ast *ast = parse_program(parse);

    parse_del(parse);

    return ast;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x5126(%rip), %rsi      # 0xe9ab
callq 0x21c0
testq %rax, %rax
je 0x99cc
movq %rax, %r15
movq %rbx, %rdi
callq 0x2220
leaq 0xa50b(%rip), %rcx      # 0x13db0
movq %rax, (%rcx)
leaq 0xa4f1(%rip), %rax      # 0x13da0
movl $0x1, (%rax)
leaq 0xa4ec(%rip), %rax      # 0x13da8
movq %r15, (%rax)
movl $0x20, %edi
callq 0x2160
movq %rax, %rbx
movl $0x40000, %edi          # imm = 0x40000
callq 0x2160
movq %rax, %r12
movq %rax, (%rbx)
movl $0x0, 0x14(%rbx)
addq $0x8, %r12
movl $0x1, %r13d
xorl %ebp, %ebp
leaq 0xa4c2(%rip), %r14      # 0x13db8
cmpq $0x40000, %rbp          # imm = 0x40000
je 0x99c7
callq 0x83ac
movl %eax, -0x8(%r12,%rbp)
movups (%r14), %xmm0
movups %xmm0, (%r12,%rbp)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%r12,%rbp)
movl %r13d, 0x10(%rbx)
incl %r13d
addq $0x20, %rbp
testl %eax, %eax
jne 0x98f6
movq %r15, %rdi
callq 0x2090
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x94d8
movq %rax, %r14
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x9994
movl $0x10, %r15d
xorl %r12d, %r12d
movq (%rbx), %rcx
movl -0x10(%rcx,%r15), %edx
cmpl $0x120, %edx            # imm = 0x120
je 0x9979
cmpl $0x11e, %edx            # imm = 0x11E
jne 0x9985
movq (%rcx,%r15), %rdi
callq 0x2030
movl 0x10(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x20, %r15
cmpq %rcx, %r12
jb 0x9961
cmpl $0x0, 0x18(%rbx)
jne 0x99a5
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0xb2de
movq (%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x232f
movq %rbx, %rdi
callq 0x2354