LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x26ce
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x26ce
movq %rax, %r12
xorl %edi, %edi
movq %r14, %rsi
callq 0x5137
movq %rax, %r15
movq %r12, %rdi
callq 0x25da
movq %rax, %r14
movl $0x3ff, %eax            # imm = 0x3FF
andl (%r15), %eax
cmpl $0x40, %eax
jne 0x5a48
movq %r15, %rdi
callq 0xa80e
movq 0x10(%rax), %r12
movq %r15, %rdi
callq 0xa80e
movq %rax, %r15
addq $0x20, %r15
incq %r12
decq %r12
je 0x5a33
movq (%r15), %rsi
addq $0x10, %r15
movq %r14, %rdi
callq 0x2100
testl %eax, %eax
jne 0x5a02
movq -0x8(%r15), %rdi
movl $0x400, %esi            # imm = 0x400
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xad4f
movq 0x8(%rbx), %rdi
leaq 0x644c(%rip), %rsi      # 0xbe8a
movq %r14, %rdx
xorl %eax, %eax
callq 0x4a05
movq %rbx, %rdi
callq 0x504f
// File: /workspace/github_c_makefile_star2_O2/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 0x25da
movq %rax, %rbx
leaq 0xd348(%rip), %rax      # 0x12de0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xa01a
testq %rax, %rax
je 0x5aec
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x5acc
cmpl $0x1, %ecx
jne 0x5b01
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x5aec
movl $0x400, %esi            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xad4f
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x5b22
movq %rax, %rbx
movq %rdx, %rdi
callq 0x5b29
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdi
leaq 0x63ae(%rip), %rsi      # 0xbea5
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4a05
leaq 0x63b8(%rip), %rdi      # 0xbec0
leaq 0x63d7(%rip), %rsi      # 0xbee6
leaq 0x63d7(%rip), %rcx      # 0xbeed
movl $0x217, %edx            # imm = 0x217
xorl %eax, %eax
callq 0x4918
// File: /workspace/github_c_makefile_star2_O2/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 0x26ce
movq %rax, %rbx
movq %rax, %rdi
callq 0x25da
movq %rax, %r15
leaq 0xd270(%rip), %r12      # 0x12de0
movq (%r12), %rdi
movq %rax, %rsi
callq 0xa01a
testq %rax, %rax
je 0x5b87
cmpq %r14, 0x8(%rax)
je 0x5ba9
movq %r14, %rdi
callq 0xa3af
movq %rax, %r14
movq %rax, %rdi
callq 0x3d9e
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa009
xorl %edi, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5a7b
// File: /workspace/github_c_makefile_star2_O2/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 0x270b
movq %rax, %r15
movl (%r14), %eax
testb $0x10, %al
jne 0x5c58
testb $0x40, %al
je 0x5cd5
movq %r14, %rdi
callq 0xa80e
movq %rax, %r12
movq 0x10(%rax), %rax
cmpq (%rsp), %rax
jb 0x5cef
addq $0x28, %r12
xorl %ebp, %ebp
cmpq (%rsp), %rbp
jae 0x5cbc
movq (%r12), %r13
movq (%r15,%rbp,8), %rsi
movq %r13, %rdi
callq 0x5137
movq %r13, %rdi
movq %rax, %rsi
callq 0x4f3e
testq %rax, %rax
je 0x5c4b
movq %r13, %rdi
movq %rax, %rsi
callq 0xac35
incq %rbp
addq $0x10, %r12
testb %al, %al
jne 0x5c0b
movq 0x8(%rbx), %rdi
leaq 0x6313(%rip), %rsi      # 0xbf69
jmp 0x5cb5
movq %r14, %rdi
callq 0xa7aa
movq %rax, %r12
movq 0x10(%rax), %rax
cmpq (%rsp), %rax
jb 0x5ce2
xorl %r13d, %r13d
cmpq (%rsp), %r13
jae 0x5cbc
movq 0x8(%r12), %rdi
movq (%r15,%r13,8), %rsi
callq 0x5137
movq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0x4f3e
testq %rax, %rax
je 0x5caa
movq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0xac35
incq %r13
testb %al, %al
jne 0x5c70
movq 0x8(%rbx), %rdi
leaq 0x626c(%rip), %rsi      # 0xbf21
xorl %eax, %eax
callq 0x4a05
movq %r14, %rdi
xorl %esi, %esi
callq 0xad4f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
leaq 0x62ac(%rip), %rsi      # 0xbf8c
jmp 0x5cb5
movq 0x8(%rbx), %rdi
leaq 0x620f(%rip), %rsi      # 0xbefc
jmp 0x5cb5
movq 0x8(%rbx), %rdi
leaq 0x6249(%rip), %rsi      # 0xbf43
jmp 0x5cb5
// File: /workspace/github_c_makefile_star2_O2/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 0x5d27
movq %r14, %rdi
callq 0xa7aa
movq 0x8(%rax), %r14
jmp 0x5d0f
leal -0x1(%rax), %ecx
cmpl $0x7, %ecx
ja 0x5d4f
leaq 0x5da6(%rip), %rax      # 0xbadc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0x8
popq %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x40, %eax
je 0x5d6b
cmpl $0x80, %eax
jne 0x5da8
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa404
movq %r14, %rdi
callq 0xa80e
movq 0x10(%rax), %r12
movq %r14, %rdi
callq 0xa80e
movq %rax, %r15
addq $0x28, %r15
pushq $0x1
popq %r14
subq $0x1, %r12
jb 0x5d43
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x5cfc
cmpq %r14, %rax
cmovaq %rax, %r14
addq $0x10, %r15
jmp 0x5d8a
cmpl $0x20, %eax
jne 0x5db6
leaq 0x6235(%rip), %rsi      # 0xbfe9
jmp 0x5dde
leaq 0x6103(%rip), %rdi      # 0xbec0
leaq 0x6122(%rip), %rsi      # 0xbee6
leaq 0x6244(%rip), %rcx      # 0xc00f
movl $0x314, %edx            # imm = 0x314
xorl %eax, %eax
callq 0x4918
leaq 0x61eb(%rip), %rsi      # 0xbfc9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a05
// File: /workspace/github_c_makefile_star2_O2/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 0x25da
movq %rax, %r14
leaq 0xce6f(%rip), %rax      # 0x12de0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xa01a
testq %rax, %rax
je 0x5f96
cmpl $0x2, (%rax)
jne 0x5fab
movq 0x10(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5fbd
movq 0x8(%rbx), %rdi
leaq 0x5f04(%rip), %rsi      # 0xbea5
movq %r14, %rdx
xorl %eax, %eax
callq 0x4a05
movq 0x8(%rbx), %rdi
leaq 0x6072(%rip), %rsi      # 0xc028
xorl %eax, %eax
callq 0x4a05
// File: /workspace/github_c_makefile_star2_O2/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 0x26ce
movq %rax, %r12
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x26ce
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
callq 0x5b22
movq %rdx, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b22
movq %rdx, %rbx
movq %r13, 0x10(%rsp)
movl (%r13), %r13d
movl %r13d, %edi
callq 0x4d85
movl %eax, %ebp
movl (%r12), %edi
callq 0x4d85
movl %eax, %r15d
movl (%r14), %edi
callq 0x4d85
movq 0x8(%rsp), %r14
movl %eax, %r12d
cmpl %ebp, %r15d
movq %rbx, %r15
jb 0x65b6
jne 0x65c1
addl $0xffffbdf0, %r13d      # imm = 0xFFFFBDF0
cmpl $0x1a, %r13d
ja 0x65c1
movl $0x7ff0001, %eax        # imm = 0x7FF0001
btl %r13d, %eax
jae 0x65c1
movq %r14, %rdi
callq 0x5b29
movq %rax, %r14
cmpl %ebp, %r12d
movq 0x10(%rsp), %rbx
jae 0x65d8
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
jmp 0x65f0
jne 0x65f0
movl $0xffffbdf0, %eax       # imm = 0xFFFFBDF0
addl (%rbx), %eax
cmpl $0x1a, %eax
ja 0x65cb
movl $0x7ff0001, %ecx        # imm = 0x7FF0001
btl %eax, %ecx
jae 0x65cb
leaq 0xbf09(%rip), %rsi      # 0x12500
movq %r14, %rdi
callq 0x9e47
movq %rax, %rdi
movq %r15, %rsi
callq 0x9e47
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x5137
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10(%rsp)
movq %rdi, %r14
xorl %esi, %esi
callq 0x26ce
movq %rax, %r13
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x26ce
movq %rax, %r12
xorl %edi, %edi
movq %r13, %rsi
callq 0x5b22
movq %rdx, (%rsp)
xorl %edi, %edi
movq %r12, %rsi
callq 0x5b22
movq %rdx, %rbx
movq %r14, 0x8(%rsp)
movl (%r14), %r14d
movl %r14d, %edi
callq 0x4d85
movl %eax, %ebp
movl (%r13), %edi
callq 0x4d85
movl %eax, %r15d
movl (%r12), %edi
callq 0x4d85
movq (%rsp), %rdi
movl %eax, %r13d
cmpl %ebp, %r15d
movq %rbx, %r15
jb 0x66c8
movq %rdi, %rbx
jne 0x66d2
addl $0xffffbdf0, %r14d      # imm = 0xFFFFBDF0
cmpl $0x1a, %r14d
ja 0x66d2
movl $0x7ff0001, %eax        # imm = 0x7FF0001
btl %r14d, %eax
movq %rbx, %rdi
jae 0x673b
callq 0x5b29
movq %rax, %r14
jmp 0x66d5
movq %rbx, %r14
cmpl %ebp, %r13d
movq 0x8(%rsp), %rbx
jae 0x66ec
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
jmp 0x6704
jne 0x6704
movl $0xffffbdf0, %eax       # imm = 0xFFFFBDF0
addl (%rbx), %eax
cmpl $0x1a, %eax
ja 0x66df
movl $0x7ff0001, %ecx        # imm = 0x7FF0001
btl %eax, %ecx
jae 0x66df
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x9e47
movq %rax, %rdi
movq %r15, %rsi
callq 0x9e47
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x5137
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
jmp 0x66d5
// File: /workspace/github_c_makefile_star2_O2/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 0x26ce
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
callq 0x5b22
movq %rdx, %r15
movl (%r12), %edi
callq 0x4d85
movl %eax, %ebp
movl (%r14), %edi
callq 0x4d85
cmpl %eax, %ebp
jae 0x6787
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x5137
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9e47
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26ce
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
callq 0x5b22
movq %rdx, %r15
movl (%r12), %edi
callq 0x4d85
movl %eax, %ebp
movl (%r14), %edi
callq 0x4d85
cmpl %eax, %ebp
jae 0x67f5
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x5137
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9e47
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5137
movq %rax, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x26ce
movq %rax, %rbp
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x26ce
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r13, %rdi
callq 0x26ce
movq %rax, %rbx
xorl %edi, %edi
movq %rbp, %rsi
callq 0x5b22
movq %rdx, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5b22
movq %rdx, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5b22
movq %rdx, %r14
movl (%r13), %edi
callq 0x4d85
movl %eax, %r13d
movl (%rbp), %edi
callq 0x4d85
movl %eax, %ebp
movl (%rbx), %edi
callq 0x4d85
movl %eax, %ebx
cmpl %r13d, %ebp
ja 0x68b9
movq %r12, %rdi
callq 0x5b29
movq %rax, %r12
cmpl %r13d, %ebx
jae 0x68c9
movq %r14, %rdi
callq 0x5b29
movq %rax, %r14
leaq 0x5834(%rip), %rdi      # 0xc104
callq 0x9e6c
movq %r12, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %rdi
movq %r15, %rsi
callq 0x9e47
movq %rax, %rbx
leaq 0x5813(%rip), %rdi      # 0xc108
callq 0x9e6c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %rdi
movq %r14, %rsi
callq 0x9e47
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_O2/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 0x26ce
xorl %edi, %edi
movq %rax, %rsi
callq 0x5b22
movq %rdx, %rbx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x26ce
movq %rax, %rdi
callq 0xa849
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
callq 0x30e4
leaq 0xb907(%rip), %r15      # 0x122a0
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e47
leaq 0xb915(%rip), %r12      # 0x122c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x9e47
movq %rax, %rdi
movq %r15, %rsi
callq 0x9e47
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9e47
movq %rax, %rdi
movq %r12, %rsi
callq 0x9e47
movq %rax, %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5137
movq %rax, 0x10(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x26ce
movq %rax, %r13
xorl %edi, %edi
movq %rax, %rsi
callq 0x5b22
movq %rax, %r12
movq %rdx, %r15
movl (%r13), %edi
callq 0x4d85
movl %eax, %ebp
movl (%r14), %edi
callq 0x4d85
cmpl %eax, %ebp
jae 0x6a48
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x26ce
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x270b
movq %rax, %r14
leaq 0x5d86(%rip), %rdi      # 0xc7f0
callq 0x9e6c
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %r15
movq %r12, %rdi
callq 0xa7dc
movq %rax, %r12
xorl %ebx, %ebx
leaq 0x4da5(%rip), %r13      # 0xb836
cmpq 0x8(%rsp), %rbx
jae 0x6b04
cmpq 0x10(%r12), %rbx
jae 0x6aa6
movq 0x20(%r12,%rbx,8), %rdi
jmp 0x6aa8
xorl %edi, %edi
movq (%r14,%rbx,8), %rsi
callq 0x5b22
movq %rdx, %rbp
movq (%r14,%rbx,8), %rax
movl (%rax), %edi
callq 0x4d85
testl %eax, %eax
jne 0x6ace
movq %rbp, %rdi
callq 0x5b29
movq %rax, %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9e47
movq %rax, %r15
movq 0x8(%rsp), %rax
decq %rax
cmpq %rax, %rbx
je 0x6aff
movq %r13, %rdi
callq 0x9e6c
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %r15
incq %rbx
jmp 0x6a91
leaq 0x4731(%rip), %rdi      # 0xb23c
callq 0x9e6c
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e47
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_O2/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 0x26ce
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x26ce
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
callq 0x5b22
movq %rdx, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x5b22
movq %rdx, %r14
movl (%r12), %edi
callq 0x4d85
movl %eax, %ebp
movl (%rbx), %edi
callq 0x4d85
cmpl %eax, %ebp
jae 0x6b90
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
leaq 0xb789(%rip), %rsi      # 0x12320
movq %r15, %rdi
callq 0x9e47
movq %rax, %rdi
movq %r14, %rsi
callq 0x9e47
leaq 0xb78f(%rip), %rsi      # 0x12340
movq %rax, %rdi
callq 0x9e47
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x5137
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26ce
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x26ce
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
callq 0x5b22
movq %rdx, %r15
movq %r14, %rdi
callq 0x25da
movq %rax, %r14
movl (%r12), %edi
callq 0x4d85
cmpl $0xf, %eax
jne 0x6c31
movl $0xffffbdf0, %eax       # imm = 0xFFFFBDF0
addl (%rbx), %eax
cmpl $0x1a, %eax
ja 0x6c3c
movl $0x7ff0001, %ecx        # imm = 0x7FF0001
btl %eax, %ecx
jae 0x6c3c
movq %r15, %rdi
callq 0x5b29
movq %rax, %r15
leaq 0xbadd(%rip), %rsi      # 0x12720
movq %r15, %rdi
callq 0x9e47
movq %rax, %r15
movq %r14, %rdi
callq 0x9e6c
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x5137
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25da
movq %rax, %r14
leaq 0xc146(%rip), %rax      # 0x12de0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xa01a
testq %rax, %rax
je 0x6ce0
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x6cc8
cmpl $0x1, %ecx
jne 0x6cf5
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rbx
callq 0x9e6c
movq %rax, %rdx
jmp 0x6cd7
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x5b22
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rdi
leaq 0x51ba(%rip), %rsi      # 0xbea5
movq %r14, %rdx
xorl %eax, %eax
callq 0x4a05
callq 0x2040
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
xorl %edi, %edi
callq 0x2160
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
leaq 0x10(%rsp), %rsi
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2614
movq %rax, %r12
movq %rsp, %r13
xorl %ebp, %ebp
cmpq 0x10(%rsp), %rbp
jae 0x6e27
movzbl (%r12,%rbp), %ebx
cmpl $0x22, %ebx
je 0x6dbf
cmpl $0x5c, %ebx
jne 0x6dcc
movb $0x0, 0x2(%rsp)
movw $0x5c5c, (%rsp)         # imm = 0x5C5C
jmp 0x6e05
movb $0x0, 0x2(%rsp)
movw $0x225c, (%rsp)         # imm = 0x225C
jmp 0x6e05
callq 0x2260
cmpb $0x20, %bl
je 0x6dfd
movsbq %bl, %rcx
movq (%rax), %rax
cmpw $0x0, (%rax,%rcx,2)
js 0x6dfd
movsbl %bl, %ecx
movq %r13, %rdi
pushq $0x8
popq %rsi
leaq 0x5326(%rip), %rdx      # 0xc11a
xorl %eax, %eax
callq 0x20c0
jmp 0x6e05
movb %bl, (%rsp)
movb $0x0, 0x1(%rsp)
movq %r13, %rbx
movsbl (%rbx), %edx
testl %edx, %edx
je 0x6e1f
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e70
incq %rbx
jmp 0x6e08
incq %rbp
jmp 0x6d98
leaq 0x18(%rsp), %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6e70
xorl %edi, %edi
movq 0x8(%rsp), %rsi
callq 0x5137
movq %rax, %r14
movq (%rbx), %rsi
leaq 0x52cd(%rip), %rdi      # 0xc121
xorl %eax, %eax
callq 0x9e7d
movq %rax, %rdx
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7652
movl (%rdi), %ecx
shll $0x4, %ecx
orl %ecx, %eax
jmp 0x7678
leal -0x61(%rsi), %eax
cmpl $0x5, %eax
ja 0x7666
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x57, %eax
jmp 0x7678
leal -0x41(%rsi), %eax
cmpl $0x5, %eax
ja 0x767b
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x37, %eax
movl %eax, (%rdi)
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb708(%rip), %rdi      # 0x12da8
callq 0x2240
cmpl $0xa, %eax
jne 0x76b0
incl 0xb6f0(%rip)            # 0x12da0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/loc.c
// Function: loc_new
struct loc *loc_new(const char *file, int line)
{
    struct loc *l = malloc(sizeof *l);
    l->line = line;
    l->file = strdup(file);
    l->nref = 1;
    return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x2160
movq %rax, %r15
movl %ebx, 0x8(%rax)
movq %r14, %rdi
callq 0x2220
movq %rax, (%r15)
movl $0x1, 0xc(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x80cd
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x80aa
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/main.c
// Function: arg_list_new
struct arg_list *arg_list_new(const char *arg)
{
    struct arg_list *arg_list = malloc(sizeof *arg_list);
    arg_list->arg = strdup(arg);
    arg_list->next = NULL;

    return arg_list;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x2160
movq %rax, %r14
movq %rbx, %rdi
callq 0x2220
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x814d
leaq 0x449b(%rip), %rax      # 0xc5c2
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21c0
testq %rax, %rax
je 0x81b1
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x80fb
movq %r14, %rdi
callq 0x2090
leaq 0x446e(%rip), %r14      # 0xc5c2
testq %rbx, %rbx
je 0x81a5
movq (%rbx), %rdi
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
callq 0x8094
movw $0x63, (%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
testq %rax, %rax
je 0x81b1
movq %rax, %r12
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x80fb
movq %r12, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2030
movq 0x8(%rbx), %rbx
jmp 0x8154
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x43bb(%rip), %rdi      # 0xc573
callq 0x21d0
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x43a6(%rip), %r14      # 0xc579
testq %rbx, %rbx
je 0x81fd
movq (%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20b0
movq (%rbx), %rdi
callq 0x8bc4
movq %rax, %rdi
xorl %esi, %esi
callq 0x2c05
movq 0x8(%rbx), %rbx
jmp 0x81d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq (%rdi), %rax
movslq 0x14(%rdi), %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r14
leaq 0xb2(%rip), %rdx        # 0x87bc
pushq $-0x1
popq %rsi
callq 0x8742
movq (%rbx), %rcx
movslq 0x14(%rbx), %rdx
shlq $0x5, %rdx
cmpl $0x0, (%rcx,%rdx)
jne 0x873a
movq %r14, %rdi
movl $0x4502, %esi           # imm = 0x4502
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2536
movq %rbx, %rdi
callq 0x8a1c
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r12
andq $0x0, (%r12)
movl 0x14(%r14), %r13d
movq %r14, %rdi
callq *%rbx
testq %rax, %rax
je 0x87a5
movq %rax, %r15
movq %rax, %rdi
callq 0x25c3
movq %rax, (%r12)
movq %r15, (%rax)
movq (%r12), %r12
addq $0x8, %r12
cmpl $-0x1, %ebp
je 0x875d
movq (%r14), %rcx
movslq 0x14(%r14), %rax
movq %rax, %rdx
shlq $0x5, %rdx
cmpl %ebp, (%rcx,%rdx)
jne 0x87a9
incl %eax
movl %eax, 0x14(%r14)
jmp 0x875d
movl %r13d, 0x14(%r14)
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_O2/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 0x3f47(%rip), %rsi      # 0xc9ab
callq 0x21c0
testq %rax, %rax
je 0x8bba
movq %rax, %r15
movq %rbx, %rdi
callq 0x2220
leaq 0xa32c(%rip), %rcx      # 0x12db0
movq %rax, (%rcx)
leaq 0xa312(%rip), %rax      # 0x12da0
movl $0x1, (%rax)
leaq 0xa30d(%rip), %rax      # 0x12da8
movq %r15, (%rax)
pushq $0x20
popq %rdi
callq 0x2160
movq %rax, %rbx
movl $0x40000, %edi          # imm = 0x40000
callq 0x2160
movq %rax, %r12
movq %rax, (%rbx)
andl $0x0, 0x14(%rbx)
addq $0x8, %r12
pushq $0x1
popq %r13
xorl %ebp, %ebp
leaq 0xa2ea(%rip), %r14      # 0x12db8
cmpq $0x40000, %rbp          # imm = 0x40000
je 0x8b96
callq 0x7881
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 0x8ace
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 0x86ec
movq %rax, %r14
pushq $0x10
popq %r15
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jae 0x8b63
movq (%rbx), %rax
movl -0x10(%rax,%r15), %ecx
cmpl $0x120, %ecx            # imm = 0x120
je 0x8b51
cmpl $0x11e, %ecx            # imm = 0x11E
jne 0x8b5a
movq (%rax,%r15), %rdi
callq 0x2030
incq %r12
addq $0x20, %r15
jmp 0x8b30
cmpl $0x0, 0x18(%rbx)
jne 0x8b74
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0xa21d
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
movq 0x945b(%rip), %rax      # 0x11ff8
movq (%rax), %rcx
leaq 0x3bd7(%rip), %rdi      # 0xc77e
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x21d0
jmp 0x8bb2
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: parse_type_def
static struct ast *parse_type_def(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    expect(parse, TYPE_TOK);

    struct ast *name = parse_name(parse);
    if (name == NULL)
	return NULL;

    struct ast *type = parse_type(parse);
    // If we cannot parse the type (and type becomes NULL), then it is a type
    // declaration to an incomplete type.

    return term_semicolon(parse, ast_new_ast(line, TYPE_DEF, 2, name, type));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movslq 0x14(%rdi), %rax
movq %rax, %rdx
shlq $0x5, %rdx
movq 0x8(%rcx,%rdx), %r14
cmpl $0x123, (%rcx,%rdx)     # imm = 0x123
jne 0x8c09
incl %eax
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
callq 0x9720
testq %rax, %rax
je 0x8c49
movq %rax, %r15
movq %rbx, %rdi
callq 0x8cc9
pushq $0x2
popq %rdx
movq %r14, %rdi
movl $0x4002, %esi           # imm = 0x4002
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2458
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8e2e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: parse_alias_def
static struct ast *parse_alias_def(struct parse *parse)
{
    if (!expect(parse, DEFINE_TOK))
        return NULL;

    struct loc *line = get_linenr(parse);
    struct ast *name = parse_name(parse);
    if (name == NULL)
        return NULL;

    struct ast *expr = parse_expr(parse);
    if (expr == NULL)
        return NULL;

    return term_semicolon(parse, ast_new_ast(line, ALIAS_DEF, 2, name, expr));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movslq 0x14(%rdi), %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
cmpl $0x127, (%rax,%rdx)     # imm = 0x127
jne 0x8cc1
movq %rdi, %rbx
incq %rcx
movl %ecx, 0x14(%rdi)
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r14
callq 0x9720
testq %rax, %rax
je 0x8cc1
movq %rax, %r15
movq %rbx, %rdi
callq 0x8ef4
testq %rax, %rax
je 0x8cc1
pushq $0x2
popq %rdx
movq %r14, %rdi
movl $0x4003, %esi           # imm = 0x4003
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2458
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8e2e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: term_semicolon
static struct ast *term_semicolon(struct parse *parse, struct ast *ast)
{
    if (ast == NULL)
        return NULL;
    if (!expect(parse, ';')) {
        ast_unref(ast);
        return NULL;
    }
    return ast;
}

// Assembly:
testq %rsi, %rsi
je 0x8e50
movq %rsi, %rax
movq (%rdi), %rdx
movslq 0x14(%rdi), %rcx
movq %rcx, %rsi
shlq $0x5, %rsi
cmpl $0x3b, (%rdx,%rsi)
jne 0x8e53
incl %ecx
movl %ecx, 0x14(%rdi)
retq
xorl %eax, %eax
retq
pushq %rax
movq %rax, %rdi
callq 0x25d9
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: parse_enclosed
static struct ast *parse_enclosed(struct parse *parse, enum tok open_delim, 
        struct ast *(*parse_syntax)(struct parse *), char close_delim,
        bool report_err)
{
    if (!expect(parse, open_delim))
        goto err;

    struct ast *ast = parse_syntax(parse);
    if (ast == NULL)
        goto err;

    if (!expect(parse, close_delim)) {
        ast_unref(ast);
        goto err;
    }

    return ast;

err:
    if (report_err)
        syntax_error(parse);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %rbx
movq (%rdi), %rcx
movslq 0x14(%rdi), %rax
movq %rax, %rdi
shlq $0x5, %rdi
cmpl %esi, (%rcx,%rdi)
jne 0x8ee0
incl %eax
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
callq *%rdx
testq %rax, %rax
je 0x8ee0
movzbl %r14b, %edx
movq (%rbx), %rsi
movslq 0x14(%rbx), %rcx
movq %rcx, %rdi
shlq $0x5, %rdi
cmpl %edx, (%rsi,%rdi)
jne 0x8ed8
incl %ecx
movl %ecx, 0x14(%rbx)
jmp 0x8ee7
movq %rax, %rdi
callq 0x25d9
testb %bpl, %bpl
jne 0x8eec
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x8a1c
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: parse_param_list
static struct ast *parse_param_list(struct parse *parse)
{
    struct ast_list *head = NULL, **tailp = &head;

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

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

        tailp = &(*tailp)->next;

        if (peek_tok(parse)->type != ',')
            break;

        parse->pos++;
    }

    struct loc *line = get_linenr(parse);

    if (peek_tok(parse)->type == ELLIPSIS_TOK) {
        *tailp = ast_list_new(ast_new(get_linenr(parse), VARARG_TYPE));
        (*tailp)->ast = ast_new(line, VARARG_TYPE);
        parse->pos++;
    }

    return ast_new_list(line, PARAM_LIST, head);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %r13
andq $0x0, (%r13)
movq %rdi, %rbx
movl 0x14(%rdi), %ebp
movq (%rdi), %rax
movslq %ebp, %r12
movq %r12, %r14
shlq $0x5, %r14
cmpl $0x120, (%rax,%r14)     # imm = 0x120
jne 0x8f90
movq %r12, 0x8(%rsp)
movq 0x8(%rax,%r14), %r12
addq %r14, %rax
leal 0x1(%rbp), %ecx
movl %ecx, 0x14(%rbx)
movq 0x10(%rax), %rdi
callq 0x2220
movq %r12, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdx
callq 0x238b
movq %rax, %r15
movl 0x14(%rbx), %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
callq 0x8cc9
testq %rax, %rax
je 0x8f9d
movq %r12, %rdi
movl $0x4000, %esi           # imm = 0x4000
pushq $0x2
popq %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2458
movq %rax, %r15
jmp 0x8fa4
movq %rbx, %rdi
callq 0x8cc9
movq %rax, %r15
jmp 0x8fa9
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rbx)
movq 0x8(%rsp), %r12
testq %r15, %r15
je 0x8fe5
movq %r15, %rdi
callq 0x25c3
movq %rax, (%r13)
movq %r15, (%rax)
movq (%r13), %r13
addq $0x8, %r13
movq (%rbx), %rax
movslq 0x14(%rbx), %rbp
movq %rbp, %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %ecx
cmpl $0x2c, %ecx
jne 0x8ff1
incl %ebp
movl %ebp, 0x14(%rbx)
jmp 0x8f1c
movl %ebp, 0x14(%rbx)
movq (%rbx), %rax
movl (%rax,%r14), %ecx
jmp 0x8ff4
movq %rbp, %r12
shlq $0x5, %r12
movq 0x8(%rax,%r12), %r14
cmpl $0x122, %ecx            # imm = 0x122
jne 0x9032
pushq $0x6
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x236c
movq %rax, %rdi
callq 0x25c3
movq %rax, (%r13)
movq %r14, %rdi
movl %ebp, %esi
callq 0x236c
movq (%r13), %rcx
movq %rax, (%rcx)
incl 0x14(%rbx)
movq 0x10(%rsp), %rdx
movq %r14, %rdi
movl $0x4400, %esi           # imm = 0x4400
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2536
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: parse_name
static struct ast *parse_name(struct parse *parse)
{
    if (peek_tok(parse)->type != IDENT_TOK)
	return NULL;

    struct loc *line = get_linenr(parse);
    return ast_new_s(line, NAME, strdup(get_tok(parse)->val.u.s));
}

// Assembly:
movq (%rdi), %rcx
movslq 0x14(%rdi), %rax
movq %rax, %rdx
shlq $0x5, %rdx
cmpl $0x120, (%rcx,%rdx)     # imm = 0x120
jne 0x9760
pushq %rbx
leaq (%rcx,%rdx), %rsi
movq 0x8(%rcx,%rdx), %rbx
incl %eax
movl %eax, 0x14(%rdi)
movq 0x10(%rsi), %rdi
callq 0x2220
movq %rbx, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdx
popq %rbx
jmp 0x238b
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/parse.c
// Function: parse_decl
static struct ast *parse_decl(struct parse *parse)
{
    struct ast *name = parse_name(parse);
    if (name == NULL)
        return NULL;

    struct ast *type = parse_type(parse);
    if (type == NULL)
        return NULL;

    return ast_new_ast(name->loc, DECL, 2, name, type);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x9720
testq %rax, %rax
je 0x97ac
movq %rax, %rbx
movq %r14, %rdi
callq 0x8cc9
testq %rax, %rax
je 0x97ac
movq 0x8(%rbx), %rdi
pushq $0x2
popq %rdx
movl $0x4000, %esi           # imm = 0x4000
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2458
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq