LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x5c(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x54(%rbp), %eax
jl 0x92c8
movl -0x58(%rbp), %eax
cmpl -0x54(%rbp), %eax
jne 0x92d5
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6b20
testb $0x1, %al
jne 0x92c8
jmp 0x92d5
movq -0x38(%rbp), %rdi
callq 0x81f0
movq %rax, -0x38(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x54(%rbp), %eax
jl 0x92f4
movl -0x5c(%rbp), %eax
cmpl -0x54(%rbp), %eax
jne 0x9301
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6b20
testb $0x1, %al
jne 0x9301
movq -0x48(%rbp), %rdi
callq 0x81f0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x93c5
movq -0x30(%rbp), %rdi
callq 0x81f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x9465
movq -0x30(%rbp), %rdi
callq 0x81f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x2a40
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x81b0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x81b0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x74(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x78(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x7c(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x74(%rbp), %eax
jg 0x9577
movq -0x48(%rbp), %rdi
callq 0x81f0
movq %rax, -0x48(%rbp)
movl -0x7c(%rbp), %eax
cmpl -0x74(%rbp), %eax
jge 0x958c
movq -0x68(%rbp), %rdi
callq 0x81f0
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x9e28(%rip), %rdi      # 0x133d4
callq 0xf2f0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x9de5(%rip), %rdi      # 0x133d8
callq 0xf2f0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x58(%rbp)
callq 0x2a40
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x81b0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xfb98(%rip), %rax      # 0x19290
movq %rax, -0x48(%rbp)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rdi
callq 0x10600
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
callq 0x3ee0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xfb66(%rip), %rsi      # 0x192b0
movq %rsi, -0x40(%rbp)
callq 0xf2a0
movq -0x48(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xf2a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf2a0
movq -0x40(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xf2a0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x9a98
movq -0x30(%rbp), %rdi
callq 0x81f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq 0xf865(%rip), %rsi      # 0x19310
callq 0xf2a0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq 0xf860(%rip), %rsi      # 0x19330
callq 0xf2a0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x27f0
movq %rax, -0x40(%rbp)
movl $0x42f5, %edi           # imm = 0x42F5
callq 0x6a50
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x6a50
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jl 0x9b8d
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jne 0x9b9a
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6b20
testb $0x1, %al
jne 0x9b8d
jmp 0x9b9a
movq -0x30(%rbp), %rdi
callq 0x81f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq 0xfb63(%rip), %rsi      # 0x19710
callq 0xf2a0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
callq 0xf2f0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x27f0
movq %rax, -0x28(%rbp)
leaq 0x101b4(%rip), %rax     # 0x19dd8
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xf5b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9c55
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x9527(%rip), %rsi      # 0x13175
movb $0x0, %al
callq 0x6610
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x9c6f
jmp 0x9c65
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x9c8e
jmp 0x9ca9
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xf2f0
movq %rax, -0x8(%rbp)
jmp 0x9cae
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x81b0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x9cae
callq 0x2040
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/eval.c
// Function: eval_int_const_expr
struct expr eval_int_const_expr(struct ast *ast)
{
    long long int i = ast_i(ast);
    return (struct expr) {
        .rope = rope_new_fmt("%lld", i),
        .type = const_int_type
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2920
movq %rax, -0x20(%rbp)
leaq 0x10068(%rip), %rax     # 0x19d48
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x96ed(%rip), %rdi      # 0x133dc
xorl %eax, %eax
callq 0xf320
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2170
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2880
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x9ea6
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x9dd5
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
leaq 0x961b(%rip), %rdx      # 0x133e4
movb $0x0, %al
callq 0x20c0
jmp 0x9e84
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0x9e02
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
leaq 0x95f1(%rip), %rdx      # 0x133e7
movb $0x0, %al
callq 0x20c0
jmp 0x9e82
callq 0x2250
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
jne 0x9e38
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x9e5d
leaq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movl $0x8, %esi
leaq 0x9f5c(%rip), %rdx      # 0x13db0
movb $0x0, %al
callq 0x20c0
jmp 0x9e80
leaq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movl $0x8, %esi
leaq 0x9571(%rip), %rdx      # 0x133ea
movb $0x0, %al
callq 0x20c0
jmp 0x9e82
jmp 0x9e84
leaq -0x48(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9f00
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x9d9a
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
movl %edx, -0x4c(%rbp)
callq 0x9f60
movl -0x4c(%rbp), %eax
movq -0x18(%rbp), %rsi
movl %eax, %edi
callq 0x7130
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movq %rcx, -0x10(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x9516(%rip), %rdi      # 0x133f1
callq 0xf320
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x30, -0x14(%rbp)
jl 0xb031
cmpl $0x39, -0x14(%rbp)
jg 0xb031
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0x4, %eax
addl -0x14(%rbp), %eax
subl $0x30, %eax
movq -0x10(%rbp), %rcx
movl %eax, (%rcx)
movl %eax, -0x4(%rbp)
jmp 0xb08e
cmpl $0x61, -0x14(%rbp)
jl 0xb05a
cmpl $0x66, -0x14(%rbp)
jg 0xb05a
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0x4, %eax
addl -0x14(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movq -0x10(%rbp), %rcx
movl %eax, (%rcx)
movl %eax, -0x4(%rbp)
jmp 0xb08e
cmpl $0x41, -0x14(%rbp)
jl 0xb083
cmpl $0x46, -0x14(%rbp)
jg 0xb083
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0x4, %eax
addl -0x14(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movq -0x10(%rbp), %rcx
movl %eax, (%rcx)
movl %eax, -0x4(%rbp)
jmp 0xb08e
jmp 0xb085
jmp 0xb087
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/lex.c
// Function: lex_getc
int lex_getc() {
    int c = getc(yyin);
    if (c == '\n')
        linenr++;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xeca9(%rip), %rdi      # 0x19d98
callq 0x2230
movl %eax, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jne 0xb10c
movl 0xec8d(%rip), %eax      # 0x19d90
addl $0x1, %eax
movl %eax, 0xec84(%rip)      # 0x19d90
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/lex.c
// Function: skip_line_comment
void skip_line_comment(void)
{
    int c;
    while ((c = lex_getc()) != EOF) {
        if (c == '\n')
            return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0e0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0xb37f
cmpl $0xa, -0x4(%rbp)
jne 0xb37d
jmp 0xb37f
jmp 0xb368
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0xb0e0
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0xb3c2
cmpl $0x2f, -0x8(%rbp)
jne 0xb3ba
cmpl $0x2a, -0x4(%rbp)
jne 0xb3ba
jmp 0xb3c2
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb39f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x2170
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/main.c
// Function: get_file_ext
char *get_file_ext(const char *filename)
{
    char *ext = strrchr(filename, '.');
    if (ext == NULL)
        return NULL;

    return ext + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc03f
movq $0x0, -0x8(%rbp)
jmp 0xc04b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc075
jmp 0xc097
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc060
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc180
movq -0x10(%rbp), %rdi
leaq 0x7e36(%rip), %rsi      # 0x13f78
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xc167
leaq 0x7dd1(%rip), %rdi      # 0x13f29
callq 0x21d0
movl $0x1, %edi
callq 0x2200
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc0f0
movq -0x18(%rbp), %rdi
callq 0x2090
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc222
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc010
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb $0x63, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x28(%rbp), %rdi
leaq 0x7dae(%rip), %rsi      # 0x13f78
callq 0x21c0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xc1ef
leaq 0x7d49(%rip), %rdi      # 0x13f29
callq 0x21d0
movl $0x1, %edi
callq 0x2200
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0xc0f0
movq -0x38(%rbp), %rdi
callq 0x2090
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc188
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc289
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x7cd6(%rip), %rdi      # 0x13f2f
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xcff0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3620
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc244
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcb70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x147(%rip), %rdx       # 0xcc70
callq 0xcba0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcd10
cmpl $0x0, (%rax)
je 0xcb49
movq -0x8(%rbp), %rdi
callq 0xcd30
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4502, %esi           # imm = 0x4502
callq 0x2670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xcbf6
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xcc5c
movq -0x40(%rbp), %rdi
callq 0x27a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xcc57
movq -0x8(%rbp), %rdi
callq 0xcd10
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xcc4a
jmp 0xcc5c
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0xcbcb
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_extern_def
static struct ast *parse_extern_def(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    switch (peek_tok(parse)->type) {
        case IDENT_TOK:
            return parse_decl_or_def(parse);
	case TYPE_TOK:
	    return parse_type_def(parse);
	case DEFINE_TOK:
	    return parse_alias_def(parse);
        case INCLUDE_TOK:
            return parse_include(parse);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
movl (%rax), %eax
addl $0xfffffee0, %eax       # imm = 0xFFFFFEE0
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xe, %eax
ja 0xccf4
movq -0x20(%rbp), %rax
leaq 0x7361(%rip), %rcx      # 0x14010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0xd030
movq %rax, -0x8(%rbp)
jmp 0xccfc
movq -0x10(%rbp), %rdi
callq 0xd1c0
movq %rax, -0x8(%rbp)
jmp 0xccfc
movq -0x10(%rbp), %rdi
callq 0xd260
movq %rax, -0x8(%rbp)
jmp 0xccfc
movq -0x10(%rbp), %rdi
callq 0xd310
movq %rax, -0x8(%rbp)
jmp 0xccfc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcdd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0xcb00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xcf40
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: tokenize
static struct parse *tokenize(const char *filepath)
{
    FILE *fp = fopen(filepath, "r"); 
    if (!fp) {
        perror(filepath);
        exit(1);
    }

    lex_filepath = strdup(filepath);
    linenr = 1;
    yyin = fp;

    struct parse *parse = malloc(sizeof *parse);
    parse->tokens = malloc(MAX_N_TOKENS * sizeof *parse->tokens);
    parse->pos = 0;
    parse->n_tokens = 0;

    for (;;) {
        if (parse->n_tokens >= MAX_N_TOKENS) {
            fprintf(stderr, "error: too many tokens\n");
            exit(1);
        }
        parse->tokens[parse->n_tokens].type = yylex();
        parse->tokens[parse->n_tokens].val = yylval;
        if (parse->tokens[parse->n_tokens++].type == EOF_TOK) {
            break;
        }
    }
    fclose(fp);

    return parse;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7978(%rip), %rsi      # 0x1475f
callq 0x21c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xce0a
movq -0x8(%rbp), %rdi
callq 0x21d0
movl $0x1, %edi
callq 0x2200
movq -0x8(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
leaq 0xcf83(%rip), %rax      # 0x19da0
movq %rcx, (%rax)
leaq 0xcf69(%rip), %rax      # 0x19d90
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
leaq 0xcf60(%rip), %rax      # 0x19d98
movq %rcx, (%rax)
movl $0x20, %edi
callq 0x2170
movq %rax, -0x18(%rbp)
movl $0x40000, %edi          # imm = 0x40000
callq 0x2170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpl $0x2000, 0x10(%rax)     # imm = 0x2000
jl 0xcea2
movq 0xc171(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
leaq 0x7671(%rip), %rsi      # 0x14502
movb $0x0, %al
callq 0x2140
movl $0x1, %edi
callq 0x2200
callq 0xb3d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movslq 0x10(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x10(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
leaq 0xceca(%rip), %rcx      # 0x19da8
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movl 0x10(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rdx)
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0xcf1c
jmp 0xcf21
jmp 0xce73
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_del
static void parse_del(struct parse *parse)
{
    for (size_t i = 0; i < parse->n_tokens; ++i) {
        switch (parse->tokens[i].type) {
            case IDENT_TOK:
            case STR_TOK:
                free(parse->tokens[i].val.u.chars.s);
        }
    }
    if (parse->nest_include_level == 0)
        strmap_del(parse->included_files, NULL);
    free(parse->tokens);
    free(parse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
cmpq %rcx, %rax
jae 0xcfba
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
subl $0x11e, %eax            # imm = 0x11E
je 0xcf8f
jmp 0xcf83
movl -0x14(%rbp), %eax
subl $0x120, %eax            # imm = 0x120
jne 0xcfaa
jmp 0xcf8f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2030
jmp 0xcfac
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xcf54
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xcfd5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf950
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_decl_or_def
static struct ast *parse_decl_or_def(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    struct ast *name = ast_new_s(line, NAME, get_tok(parse)->val.u.s);

    bool is_func = peek_tok(parse)->type == '(';
    struct ast *type = parse_type(parse);
    if (type == NULL) {
        ast_unref(name);
        return NULL;
    }

    struct ast *decl = ast_new_ast(line, DECL, 2, name, type);

    if (is_func && peek_tok(parse)->type == '{')
        return ast_new_ast(line, FUNC_DEF, 2, decl, parse_block(parse));

    if (peek_tok(parse)->type == ';') {
        return term_semicolon(parse, decl);
    }

    // haven't decided if data definitions should have '=' or not
    if (peek_tok(parse)->type == '=')
        parse->pos++;

    struct ast *init = parse_init(parse);
    if (init == NULL)
        return NULL;

    return term_semicolon(parse, ast_new_ast(line, ASGN_EXPR, 2, decl, init));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd480
movq -0x48(%rbp), %rdi
movq 0x10(%rax), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x23a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x28, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd4b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd0ae
movq -0x20(%rbp), %rdi
callq 0x27e0
movq $0x0, -0x8(%rbp)
jmp 0xd1b0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x4000, %esi           # imm = 0x4000
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x38(%rbp)
testb $0x1, -0x21(%rbp)
je 0xd121
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x7b, (%rax)
jne 0xd121
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd6e0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq %rax, %r8
movl $0x4001, %esi           # imm = 0x4001
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
jmp 0xd1b0
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x3b, (%rax)
jne 0xd142
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xd720
movq %rax, -0x8(%rbp)
jmp 0xd1b0
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x3d, (%rax)
jne 0xd15d
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0xd780
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xd17b
movq $0x0, -0x8(%rbp)
jmp 0xd1b0
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x4220, %esi           # imm = 0x4220
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xd720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x123, %esi            # imm = 0x123
callq 0xda00
movq -0x10(%rbp), %rdi
callq 0xe660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd205
movq $0x0, -0x8(%rbp)
jmp 0xd247
movq -0x10(%rbp), %rdi
callq 0xd4b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x4002, %esi           # imm = 0x4002
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xd720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x127, %esi            # imm = 0x127
callq 0xda00
testb $0x1, %al
jne 0xd288
movq $0x0, -0x8(%rbp)
jmp 0xd306
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd2b3
movq $0x0, -0x8(%rbp)
jmp 0xd306
movq -0x10(%rbp), %rdi
callq 0xd870
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd2d1
movq $0x0, -0x8(%rbp)
jmp 0xd306
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x4003, %esi           # imm = 0x4003
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xd720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_include
static struct ast *parse_include(struct parse *parser)
{
    if (!expect(parser, INCLUDE_TOK))
        return NULL;

    if (peek_tok(parser)->type != STR_TOK)
        return NULL;;

    const char *path = get_tok(parser)->val.u.chars.s;

    if (!expect(parser, ';'))
        return NULL;

    // include file
    if (strmap_get(parser->included_files, path) == NULL) {
        FILE *fp = fopen(path, "r");
        if (fp == NULL) {
            struct loc *loc = loc_ref(get_linenr(parser));
            fatal(loc, "%s: %s", path, strerror(errno));
            loc_unref(loc);
        }

        struct ast *ast = parse_with_include_map(path, parser->included_files,
                parser->nest_include_level + 1);

        strmap_add(parser->included_files, path, (void *)0x1234);

        fclose(fp);
        return ast;
    }

    return ast_new(get_linenr(parser), ALREADY_INCLUDED);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x12e, %esi            # imm = 0x12E
callq 0xda00
testb $0x1, %al
jne 0xd33b
movq $0x0, -0x8(%rbp)
jmp 0xd46b
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x11e, (%rax)          # imm = 0x11E
je 0xd359
movq $0x0, -0x8(%rbp)
jmp 0xd46b
movq -0x10(%rbp), %rdi
callq 0xd480
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0xda00
testb $0x1, %al
jne 0xd389
movq $0x0, -0x8(%rbp)
jmp 0xd46b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf760
cmpq $0x0, %rax
jne 0xd451
movq -0x18(%rbp), %rdi
leaq 0x73b0(%rip), %rsi      # 0x1475f
callq 0x21c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd409
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, %rdi
callq 0xbf80
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x2220
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x70ea(%rip), %rsi      # 0x144ec
movb $0x0, %al
callq 0x6610
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
addl $0x1, %edx
callq 0xcd70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x1234, %edx           # imm = 0x1234
callq 0xf860
movq -0x20(%rbp), %rdi
callq 0x2090
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd46b
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, %rdi
movl $0x7, %esi
callq 0x2360
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd741
movq $0x0, -0x8(%rbp)
jmp 0xd76e
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0xda00
testb $0x1, %al
jne 0xd766
movq -0x18(%rbp), %rdi
callq 0x27e0
movq $0x0, -0x8(%rbp)
jmp 0xd76e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xda00
testb $0x1, %al
jne 0xd810
jmp 0xd84d
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd827
jmp 0xd84d
movq -0x10(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0xda00
testb $0x1, %al
jne 0xd843
movq -0x30(%rbp), %rdi
callq 0x27e0
jmp 0xd84d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd864
testb $0x1, -0x22(%rbp)
je 0xd85c
movq -0x10(%rbp), %rdi
callq 0xcd30
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop