LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x2805
movq %rax, %r15
movl (%r14), %eax
testb $0x10, %al
jne 0x6458
testb $0x40, %al
je 0x64ed
movq %r14, %rdi
callq 0xbc3d
movq %rax, %r12
movq 0x10(%rax), %rax
cmpq (%rsp), %rax
jb 0x6507
cmpq $0x0, (%rsp)
je 0x64b5
addq $0x28, %r12
xorl %ebp, %ebp
movq (%r12), %r13
movq (%r15,%rbp,8), %rsi
movq %r13, %rdi
callq 0x57c4
movq %r13, %rdi
movq %rax, %rsi
callq 0x559f
testq %rax, %rax
je 0x64db
movq %r13, %rdi
movq %rax, %rsi
callq 0xc0c3
testb %al, %al
je 0x64db
incq %rbp
addq $0x10, %r12
cmpq (%rsp), %rbp
jb 0x6412
jmp 0x64b5
movq %r14, %rdi
callq 0xbbd9
movq %rax, %r12
movq 0x10(%rax), %rax
cmpq (%rsp), %rax
jb 0x64fa
cmpq $0x0, (%rsp)
je 0x64b5
xorl %r13d, %r13d
movq 0x8(%r12), %rdi
movq (%r15,%r13,8), %rsi
callq 0x57c4
movq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0x559f
testq %rax, %rax
je 0x64ce
movq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0xc0c3
testb %al, %al
je 0x64ce
incq %r13
cmpq (%rsp), %r13
jb 0x647b
movq %r14, %rdi
xorl %esi, %esi
callq 0xc27b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
leaq 0x7a48(%rip), %rsi      # 0xdf21
jmp 0x64e6
movq 0x8(%rbx), %rdi
leaq 0x7a83(%rip), %rsi      # 0xdf69
xorl %eax, %eax
callq 0x5011
movq 0x8(%rbx), %rdi
leaq 0x7a94(%rip), %rsi      # 0xdf8c
jmp 0x64e6
movq 0x8(%rbx), %rdi
leaq 0x79f7(%rip), %rsi      # 0xdefc
jmp 0x64e6
movq 0x8(%rbx), %rdi
leaq 0x7a31(%rip), %rsi      # 0xdf43
jmp 0x64e6
// File: /workspace/github_c_makefile_star2_O1/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 0x653f
movq %r14, %rdi
callq 0xbbd9
movq 0x8(%rax), %r14
jmp 0x6527
cmpl $0x1f, %eax
jg 0x6567
decl %eax
cmpl $0x7, %eax
ja 0x65f7
leaq 0x7586(%rip), %rcx      # 0xdadc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %r14d
jmp 0x65cc
cmpl $0x40, %eax
je 0x6583
cmpl $0x80, %eax
jne 0x65d8
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb758
movq %r14, %rdi
callq 0xbc3d
movq 0x10(%rax), %r12
movq %r14, %rdi
callq 0xbc3d
testq %r12, %r12
je 0x65c6
movq %rax, %r15
addq $0x28, %r15
movl $0x1, %r14d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6514
cmpq %r14, %rax
cmovaq %rax, %r14
addq $0x10, %r15
decq %r12
jne 0x65a9
jmp 0x65cc
movl $0x1, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x20, %eax
jne 0x65f7
leaq 0x7a05(%rip), %rsi      # 0xdfe9
jmp 0x65ed
leaq 0x79dc(%rip), %rsi      # 0xdfc9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5011
leaq 0x78c2(%rip), %rdi      # 0xdec0
leaq 0x78e1(%rip), %rsi      # 0xdee6
leaq 0x7a03(%rip), %rcx      # 0xe00f
movl $0x314, %edx            # imm = 0x314
xorl %eax, %eax
callq 0x4f1c
// File: /workspace/github_c_makefile_star2_O1/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 0x26d0
movq %rax, %r14
leaq 0xd626(%rip), %rax      # 0x13de0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xb310
testq %rax, %rax
je 0x67df
cmpl $0x2, (%rax)
jne 0x67f4
movq 0x10(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6806
movq 0x8(%rbx), %rdi
leaq 0x76bb(%rip), %rsi      # 0xdea5
movq %r14, %rdx
xorl %eax, %eax
callq 0x5011
movq 0x8(%rbx), %rdi
leaq 0x7829(%rip), %rsi      # 0xe028
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/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 0x27c8
movq %rax, %r12
movl $0x1, %esi
movq %r13, %rdi
callq 0x27c8
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %rbx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movl (%r13), %r13d
movl %r13d, %edi
callq 0x53b9
movl %eax, %ebp
movl (%r12), %edi
callq 0x53b9
movl %eax, %r15d
movl (%r14), %edi
callq 0x53b9
movl %eax, %r12d
cmpl %ebp, %r15d
jb 0x6e66
jne 0x6e92
leal -0x4220(%r13), %eax
cmpl $0xb, %eax
jae 0x6e89
leaq 0xc433(%rip), %rdi      # 0x132a0
movq %rbx, %rsi
callq 0xb136
leaq 0xc444(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
jmp 0x6e95
cmpl $0x4210, %r13d          # imm = 0x4210
je 0x6e66
movq %rbx, %r14
cmpl %ebp, %r12d
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
jae 0x6ec7
leaq 0xc3f5(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xc406(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
jmp 0x6ed6
jne 0x6ed6
movl (%rbx), %eax
leal -0x4220(%rax), %ecx
cmpl $0xb, %ecx
jae 0x6f0f
leaq 0xc623(%rip), %rsi      # 0x13500
movq %r14, %rdi
callq 0xb136
movq %rax, %rdi
movq %r15, %rsi
callq 0xb136
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x57c4
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 0x6ed6
jmp 0x6ea4
// File: /workspace/github_c_makefile_star2_O1/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 0x27c8
movq %rax, %r13
movl $0x1, %esi
movq %r14, %rdi
callq 0x27c8
movq %rax, %r12
xorl %edi, %edi
movq %r13, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %rbx
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl (%r14), %r14d
movl %r14d, %edi
callq 0x53b9
movl %eax, %ebp
movl (%r13), %edi
callq 0x53b9
movl %eax, %r15d
movl (%r12), %edi
callq 0x53b9
movl %eax, %r13d
cmpl %ebp, %r15d
jb 0x6fa4
jne 0x6fd0
leal -0x4220(%r14), %eax
cmpl $0xb, %eax
jae 0x6fc7
leaq 0xc2f5(%rip), %rdi      # 0x132a0
movq %rbx, %rsi
callq 0xb136
leaq 0xc306(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
jmp 0x6fd3
cmpl $0x4210, %r14d          # imm = 0x4210
je 0x6fa4
movq %rbx, %r14
cmpl %ebp, %r13d
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
jae 0x7005
leaq 0xc2b7(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xc2c8(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
jmp 0x7014
jne 0x7014
movl (%rbx), %eax
leal -0x4220(%rax), %ecx
cmpl $0xb, %ecx
jae 0x704a
movq (%rsp), %rsi
movq %r14, %rdi
callq 0xb136
movq %rax, %rdi
movq %r15, %rsi
callq 0xb136
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x57c4
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 0x7014
jmp 0x6fe2
// File: /workspace/github_c_makefile_star2_O1/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 0x27c8
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r15
movl (%r12), %edi
callq 0x53b9
movl %eax, %ebp
movl (%r14), %edi
callq 0x53b9
cmpl %eax, %ebp
jae 0x70b2
leaq 0xc208(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xc219(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x57c4
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb136
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27c8
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r15
movl (%r12), %edi
callq 0x53b9
movl %eax, %ebp
movl (%r14), %edi
callq 0x53b9
cmpl %eax, %ebp
jae 0x7138
leaq 0xc182(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xc193(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x57c4
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb136
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x57c4
movq %rax, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x27c8
movq %rax, %rbp
movl $0x1, %esi
movq %r13, %rdi
callq 0x27c8
movq %rax, %r15
movl $0x2, %esi
movq %r13, %rdi
callq 0x27c8
movq %rax, %rbx
xorl %edi, %edi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r14
movl (%r13), %edi
callq 0x53b9
movl %eax, %r13d
movl (%rbp), %edi
callq 0x53b9
movl %eax, %ebp
movl (%rbx), %edi
callq 0x53b9
movl %eax, %ebx
cmpl %r13d, %ebp
ja 0x721c
leaq 0xc09e(%rip), %rdi      # 0x132a0
movq %r12, %rsi
callq 0xb136
leaq 0xc0af(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r12
cmpl %r13d, %ebx
jae 0x7242
leaq 0xc078(%rip), %rdi      # 0x132a0
movq %r14, %rsi
callq 0xb136
leaq 0xc089(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
leaq 0x6ebb(%rip), %rdi      # 0xe104
callq 0xb15d
movq %r12, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %rdi
movq %r15, %rsi
callq 0xb136
movq %rax, %rbx
leaq 0x6e9a(%rip), %rdi      # 0xe108
callq 0xb15d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %rdi
movq %r14, %rsi
callq 0xb136
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_O1/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 0x27c8
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %rbx
movl $0x1, %esi
movq %r14, %rdi
callq 0x27c8
movq %rax, %rdi
callq 0xbc78
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
callq 0x348a
leaq 0xbf88(%rip), %r15      # 0x132a0
movq %r15, %rdi
movq %rax, %rsi
callq 0xb136
leaq 0xbf96(%rip), %r12      # 0x132c0
movq %rax, %rdi
movq %r12, %rsi
callq 0xb136
movq %rax, %rdi
movq %r15, %rsi
callq 0xb136
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb136
movq %rax, %rdi
movq %r12, %rsi
callq 0xb136
movq %rax, %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x57c4
movq %rax, 0x10(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x27c8
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rax, %rbx
movq %rdx, %r15
movl (%r12), %edi
callq 0x53b9
movl %eax, %ebp
movl (%r14), %edi
callq 0x53b9
cmpl %eax, %ebp
jae 0x73df
leaq 0xbedb(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xbeec(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x27c8
leaq 0x8(%rsp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x2805
movq %rax, %r14
leaq 0x73fa(%rip), %rdi      # 0xe800
callq 0xb15d
movq %r15, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %r15
movq %rbx, %rdi
callq 0xbc0b
cmpq $0x0, (%r13)
je 0x74c5
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x63fe(%rip), %rbx      # 0xd836
cmpq 0x10(%r12), %rbp
jae 0x7446
movq 0x20(%r12,%rbp,8), %rdi
jmp 0x7448
xorl %edi, %edi
movq (%r14,%rbp,8), %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r13
movq (%r14,%rbp,8), %rax
movl (%rax), %edi
callq 0x53b9
testl %eax, %eax
jne 0x7486
leaq 0xbe34(%rip), %rdi      # 0x132a0
movq %r13, %rsi
callq 0xb136
movq %rax, %rdi
leaq 0xbe42(%rip), %rsi      # 0x132c0
callq 0xb136
movq %rax, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0xb136
movq %rax, %r15
movq 0x8(%rsp), %rax
decq %rax
cmpq %rax, %rbp
je 0x74b7
movq %rbx, %rdi
callq 0xb15d
movq %r15, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %r15
incq %rbp
cmpq 0x8(%rsp), %rbp
jb 0x7438
leaq 0x5d70(%rip), %rdi      # 0xd23c
callq 0xb15d
movq %r15, %rdi
movq %rax, %rsi
callq 0xb136
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_O1/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 0x27c8
movq %rax, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27c8
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r15
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r14
movl (%r12), %edi
callq 0x53b9
movl %eax, %ebp
movl (%rbx), %edi
callq 0x53b9
cmpl %eax, %ebp
jae 0x756d
leaq 0xbd4d(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xbd5e(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
leaq 0xbdac(%rip), %rsi      # 0x13320
movq %r15, %rdi
callq 0xb136
movq %rax, %rdi
movq %r14, %rsi
callq 0xb136
leaq 0xbdb2(%rip), %rsi      # 0x13340
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x57c4
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27c8
movq %rax, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x27c8
movq %rax, %r14
xorl %edi, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x7a4c
movq %rdx, %r15
movq %r14, %rdi
callq 0x26d0
movq %rax, %r14
movl (%r12), %edi
callq 0x53b9
cmpl $0xf, %eax
jne 0x7609
movl (%rbx), %eax
leal -0x4220(%rax), %ecx
cmpl $0xb, %ecx
jae 0x766b
leaq 0xbc90(%rip), %rdi      # 0x132a0
movq %r15, %rsi
callq 0xb136
leaq 0xbca1(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
leaq 0xc0ef(%rip), %rsi      # 0x13720
movq %r15, %rdi
callq 0xb136
movq %rax, %r15
movq %r14, %rdi
callq 0xb15d
movq %r15, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
callq 0x57c4
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x4210, %eax           # imm = 0x4210
je 0x7609
jmp 0x762a
// File: /workspace/github_c_makefile_star2_O1/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 0x26d0
movq %rax, %r14
leaq 0xc74f(%rip), %rax      # 0x13de0
movq (%rax), %rdi
movq %r14, %rsi
callq 0xb310
testq %rax, %rax
je 0x76d9
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x76bf
cmpl $0x1, %ecx
jne 0x76ee
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rbx
callq 0xb15d
movq %rax, %rdx
jmp 0x76d0
movq 0x10(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7a4c
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rdi
leaq 0x67c1(%rip), %rsi      # 0xdea5
movq %r14, %rdx
xorl %eax, %eax
callq 0x5011
callq 0x2040
// File: /workspace/github_c_makefile_star2_O1/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 0x270c
movq %rax, 0x18(%rsp)
cmpq $0x0, (%r12)
je 0x7851
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x18(%rsp), %rax
movzbl (%rax,%r13), %r15d
cmpl $0x22, %r15d
je 0x77b9
cmpl $0x5c, %r15d
jne 0x77c7
movb $0x0, 0xa(%rsp)
movw $0x5c5c, 0x8(%rsp)      # imm = 0x5C5C
jmp 0x7808
movb $0x0, 0xa(%rsp)
movw $0x225c, 0x8(%rsp)      # imm = 0x225C
jmp 0x7808
callq 0x2260
cmpb $0x20, %r15b
je 0x77fe
movsbq %r15b, %rcx
movq (%rax), %rax
cmpw $0x0, (%rax,%rcx,2)
js 0x77fe
movsbl %r15b, %ecx
movl $0x8, %esi
leaq 0x8(%rsp), %rdi
leaq 0x6925(%rip), %rdx      # 0xe11a
xorl %eax, %eax
callq 0x20c0
jmp 0x7808
movb %r15b, 0x8(%rsp)
movb $0x0, 0x9(%rsp)
movb 0x8(%rsp), %r12b
testb %r12b, %r12b
je 0x783d
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 0x7817
jmp 0x7840
movq %rbx, %rbp
incq %r13
movq %rbp, %rbx
cmpq 0x20(%rsp), %r13
jb 0x7795
leaq 0x1(%rbp), %rsi
movq %r14, %rdi
callq 0x2190
movq %rax, %r14
movb $0x0, (%rax,%rbp)
xorl %edi, %edi
movq 0x10(%rsp), %rsi
callq 0x57c4
movq %rax, %rbx
leaq 0x68a7(%rip), %rdi      # 0xe121
movq %r14, %rsi
xorl %eax, %eax
callq 0xb16e
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_O1/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 0x8101
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x30, %eax
jmp 0x812c
leal -0x61(%rsi), %eax
cmpl $0x5, %eax
ja 0x8115
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x57, %eax
jmp 0x812c
leal -0x41(%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x5, %ecx
ja 0x812e
movl (%rdi), %eax
shll $0x4, %eax
addl %esi, %eax
addl $-0x37, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbc57(%rip), %rdi      # 0x13da8
callq 0x2240
cmpl $0xa, %eax
jne 0x8161
incl 0xbc3f(%rip)            # 0x13da0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb9c1(%rip), %rdi      # 0x13da8
callq 0x2240
cmpl $0xa, %eax
je 0x83f8
cmpl $-0x1, %eax
jne 0x83fe
jmp 0x840c
incl 0xb9a2(%rip)            # 0x13da0
movl %eax, %ecx
xorl $0x2f, %ecx
xorl $0x2a, %ebx
orl %ecx, %ebx
movl %eax, %ebx
jne 0x83e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
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_O1/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 0x8e6b
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x8e48
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x2160
movq %rax, %r14
movq %rbx, %rdi
callq 0x2220
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8efc
leaq 0x56f8(%rip), %rax      # 0xe5c2
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21c0
testq %rax, %rax
je 0x8f80
movq %rax, %r14
movq (%rbx), %rdi
callq 0x9bec
movq %rax, %rdi
movq %r14, %rsi
callq 0x4b49
movq %r14, %rdi
callq 0x2090
testq %rbx, %rbx
je 0x8f6f
leaq 0x56ba(%rip), %r14      # 0xe5c2
movq (%rbx), %rdi
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
movl $0x2e, %esi
callq 0x20d0
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movw $0x63, (%rcx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
testq %rax, %rax
je 0x8f7b
movq %rax, %r12
movq (%rbx), %rdi
callq 0x9bec
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b49
movq %r12, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2030
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x8f08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x22cc
callq 0x22b7
// File: /workspace/github_c_makefile_star2_O1/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 0x8fc7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x55e1(%rip), %r14      # 0xe579
movq (%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20b0
movq (%rbx), %rdi
callq 0x9bec
movq %rax, %rdi
xorl %esi, %esi
callq 0x2d63
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x8f98
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe1(%rip), %rdx        # 0x97d3
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x973f
movq (%r14), %rcx
movslq 0x14(%r14), %rdx
shlq $0x5, %rdx
cmpl $0x0, (%rcx,%rdx)
jne 0x9724
movq %rbx, %rdi
movl $0x4502, %esi           # imm = 0x4502
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x261d
movq 0x8(%rcx,%rdx), %rdi
callq 0x8dff
leaq 0x504a(%rip), %rsi      # 0xe77f
movq %rax, %rdi
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movl 0x14(%r14), %ebx
movq %r14, %rdi
callq *0x8(%rsp)
testq %rax, %rax
setne %r13b
je 0x97ac
movq %rax, %r15
movq %rax, %rdi
callq 0x26b4
movq %rax, (%r12)
movq %r15, (%rax)
movq (%r12), %r12
addq $0x8, %r12
cmpl $-0x1, %ebp
je 0x97b2
movq (%r14), %rax
movslq 0x14(%r14), %rbx
movq %rbx, %rcx
shlq $0x5, %rcx
cmpl %ebp, (%rax,%rcx)
jne 0x97b7
incl %ebx
movl %ebx, 0x14(%r14)
jmp 0x97ba
movb $0x1, %r13b
jmp 0x97ba
xorl %r13d, %r13d
testb %r13b, %r13b
jne 0x9764
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_O1/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 0x4f1c(%rip), %rsi      # 0xe9bb
callq 0x21c0
testq %rax, %rax
je 0x9be4
movq %rax, %r12
movq %rbx, %rdi
callq 0x2220
leaq 0xa2f1(%rip), %rcx      # 0x13db0
movq %rax, (%rcx)
leaq 0xa2d7(%rip), %rax      # 0x13da0
movl $0x1, (%rax)
leaq 0xa2d2(%rip), %rax      # 0x13da8
movq %r12, (%rax)
movl $0x20, %edi
callq 0x2160
movq %rax, %rbx
movl $0x40000, %edi          # imm = 0x40000
callq 0x2160
movq %rax, %r13
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %r14
addq $0x10, %r14
addq $0x8, %r13
xorl %ebp, %ebp
leaq 0xa2a6(%rip), %r15      # 0x13db8
cmpq $0x2000, %rbp           # imm = 0x2000
je 0x9bdc
callq 0x840e
movl %eax, -0x8(%r13)
movups (%r15), %xmm0
movups %xmm0, (%r13)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%r13)
incq %rbp
addq $0x20, %r13
testl %eax, %eax
jne 0x9b12
movl %ebp, 0x10(%rbx)
movq %r12, %rdi
callq 0x2090
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x96d4
movq %rax, %r15
cmpl $0x0, 0x10(%rbx)
je 0x9ba9
movl $0x10, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
movl -0x10(%rax,%r12), %ecx
cmpl $0x120, %ecx            # imm = 0x120
je 0x9b91
cmpl $0x11e, %ecx            # imm = 0x11E
jne 0x9b9a
movq (%rax,%r12), %rdi
callq 0x2030
incq %r13
movslq (%r14), %rax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x9b79
cmpl $0x0, 0x18(%rbx)
jne 0x9bba
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0xb552
movq (%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x230b
movq %rbx, %rdi
callq 0x2336
// File: /workspace/github_c_makefile_star2_O1/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 0x9c31
incl %eax
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
callq 0xa903
testq %rax, %rax
je 0x9c8b
movq %rax, %r15
movq %rbx, %rdi
callq 0x9d3a
movl $0x2, %edx
movq %r14, %rdi
movl $0x4002, %esi           # imm = 0x4002
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2532
testq %rax, %rax
je 0x9c8b
movq (%rbx), %rdx
movslq 0x14(%rbx), %rcx
movq %rcx, %rsi
shlq $0x5, %rsi
cmpl $0x3b, (%rdx,%rsi)
jne 0x9c83
incl %ecx
movl %ecx, 0x14(%rbx)
jmp 0x9c8d
movq %rax, %rdi
callq 0x26cf
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movslq 0x14(%rdi), %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
cmpl $0x127, (%rax,%rdx)     # imm = 0x127
jne 0x9d28
movq %rdi, %rbx
incq %rcx
movl %ecx, 0x14(%rdi)
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r15
callq 0xa903
testq %rax, %rax
je 0x9d28
movq %rax, %r12
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa102
testq %rax, %rax
je 0x9d2b
movl $0x2, %edx
movq %r15, %rdi
movl $0x4003, %esi           # imm = 0x4003
movq %r12, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2532
testq %rax, %rax
je 0x9d28
movq %rax, %r14
movq (%rbx), %rcx
movslq 0x14(%rbx), %rax
movq %rax, %rdx
shlq $0x5, %rdx
cmpl $0x3b, (%rcx,%rdx)
jne 0x9d20
incl %eax
movl %eax, 0x14(%rbx)
jmp 0x9d2b
movq %r14, %rdi
callq 0x26cf
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ryvnf[P]czc/parse.c
// Function: parse_init
static struct ast *parse_init(struct parse *parse)
{
    struct ast *expr;
    if (peek_tok(parse)->type == '{') 
        return parse_enclosed(parse, '{', parse_init_list, '}', true);
    else
        return parse_asgn_expr(parse);
}

// Assembly:
movq (%rdi), %rax
movslq 0x14(%rdi), %rcx
shlq $0x5, %rcx
cmpl $0x7b, (%rax,%rcx)
jne 0x9ef4
leaq 0x1148(%rip), %rdx      # 0xb02a
movl $0x7b, %esi
movl $0x7d, %ecx
movl $0x1, %r8d
jmp 0x9efe
movl $0x1, %esi
jmp 0xa102
// File: /workspace/github_c_makefile_star2_O1/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 0x9f53
incl %eax
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
callq *%rdx
testq %rax, %rax
je 0x9f53
movzbl %r14b, %edx
movq (%rbx), %rsi
movslq 0x14(%rbx), %rcx
movq %rcx, %rdi
shlq $0x5, %rdi
cmpl %edx, (%rsi,%rdi)
jne 0x9f4b
incl %ecx
movl %ecx, 0x14(%rbx)
jmp 0x9f5a
movq %rax, %rdi
callq 0x26cf
testb %bpl, %bpl
jne 0x9f5f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movslq 0x14(%rbx), %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
callq 0x8dff
leaq 0x4804(%rip), %rsi      # 0xe77f
movq %rax, %rdi
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdi, %rbx
movq %rsp, %r12
movq $0x0, (%r12)
movslq 0x14(%rbx), %r13
movq (%rbx), %rax
movq %r13, %rcx
shlq $0x5, %rcx
cmpl $0x120, (%rax,%rcx)     # imm = 0x120
jne 0xa00d
leaq (%rax,%rcx), %rdx
movq 0x8(%rax,%rcx), %r15
leal 0x1(%r13), %eax
movl %eax, 0x14(%rbx)
movq 0x10(%rdx), %rdi
callq 0x2220
movq %r15, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdx
callq 0x245d
movq %rax, %r14
movl 0x14(%rbx), %ebp
movq %rbx, %rdi
callq 0x9d3a
testq %rax, %rax
je 0xa062
movl $0x2, %edx
movq %r15, %rdi
movl $0x4000, %esi           # imm = 0x4000
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2532
jmp 0xa015
movq %rbx, %rdi
callq 0x9d3a
movq %rax, %r14
testq %r14, %r14
setne %bpl
je 0xa04f
movq %r14, %rdi
callq 0x26b4
movq %rax, (%r12)
movq %r14, (%rax)
movq (%r12), %r12
addq $0x8, %r12
movq (%rbx), %rax
movslq 0x14(%rbx), %r13
movq %r13, %rcx
shlq $0x5, %rcx
cmpl $0x2c, (%rax,%rcx)
jne 0xa055
incl %r13d
movl %r13d, 0x14(%rbx)
jmp 0xa057
xorl %ebp, %ebp
testb %bpl, %bpl
jne 0x9f9e
jmp 0xa067
movl %ebp, 0x14(%rbx)
jmp 0xa018
movq (%rbx), %rax
movslq 0x14(%rbx), %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r14
cmpl $0x122, (%rax,%rcx)     # imm = 0x122
jne 0xa0b0
movq %r14, %rdi
movl $0x6, %esi
callq 0x243c
movq %rax, %rdi
callq 0x26b4
movq %rax, (%r12)
movq %r14, %rdi
movl $0x6, %esi
callq 0x243c
movq (%r12), %rcx
movq %rax, (%rcx)
incl 0x14(%rbx)
movq (%rsp), %rdx
movq %r14, %rdi
movl $0x4400, %esi           # imm = 0x4400
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x261d
// File: /workspace/github_c_makefile_star2_O1/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 0xa943
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 0x245d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa903
testq %rax, %rax
je 0xa989
movq %rax, %rbx
movq %r14, %rdi
callq 0x9d3a
testq %rax, %rax
je 0xa989
movq 0x8(%rbx), %rdi
movl $0x2, %edx
movl $0x4000, %esi           # imm = 0x4000
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2532
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq