LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe6f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd8d6
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xd925
movq -0x28(%rbp), %rdi
callq 0x27a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcd10
cmpl $0x2c, (%rax)
je 0xd916
jmp 0xd925
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0xd8ac
movq -0x8(%rbp), %rdi
callq 0xcb70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcd10
cmpl $0x122, (%rax)          # imm = 0x122
jne 0xd993
movq -0x8(%rbp), %rdi
callq 0xcb70
movq %rax, %rdi
movl $0x6, %esi
callq 0x2360
movq %rax, %rdi
callq 0x27a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movl $0x6, %esi
callq 0x2360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x4400, %esi           # imm = 0x4400
callq 0x2670
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: expect
static bool expect(struct parse *parse, enum tok tok)
{
    if (peek_tok(parse)->type == tok) {
        parse->pos++;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xda32
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xda36
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_cast_expr
static struct ast *parse_cast_expr(struct parse *parse)
{
    struct ast *expr = parse_unary_expr(parse);
    if (expr == NULL)
        goto err0;

    struct loc *line = get_linenr(parse);
    if (peek_tok(parse)->type == AS_TOK) {
        parse->pos++;
        struct ast *type = parse_type(parse);
        if (type == NULL)
            goto err1;

        expr = ast_new_ast(line, CAST_EXPR, 2, expr, type); 
    }

    return expr;

err1:
    ast_unref(expr);
err0:
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdfd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdf42
jmp 0xdfb7
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x101, (%rax)          # imm = 0x101
jne 0xdfa4
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0xd4b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xdf83
jmp 0xdfae
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x42e0, %esi           # imm = 0x42E0
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdfbf
movq -0x18(%rbp), %rdi
callq 0x27e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_unary_expr
static struct ast *parse_unary_expr(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    enum ast_tag op = INVALID_AST_TAG;

    switch (peek_tok(parse)->type) {
        case '+':
            op = UPLUS_EXPR;
            break;

        case '-':
            op = NEG_EXPR;
            break;

        case '~':
            op = COMPL_EXPR;
            break;

        case '!':
            op = NOT_EXPR;
            break;

        case '^':
            op = REF_EXPR;
            break;

        case DEC_TOK:
            op = PRE_DEC_EXPR;
            break;

        case INC_TOK:
            op = PRE_INC_EXPR;
            break;

        case SIZEOF_TOK:
            op = SIZEOF_EXPR;
            break;

        default:
            return parse_postfix_expr(parse);
    }

    parse->pos++;
    struct ast *ast = parse_unary_expr(parse);
    if (ast == NULL)
        return NULL;

    return ast_new_ast(get_linenr(parse), op, 1, ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
movq -0x10(%rbp), %rdi
callq 0xcd10
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x21, %eax
je 0xe06c
jmp 0xe005
movl -0x2c(%rbp), %eax
subl $0x2b, %eax
je 0xe051
jmp 0xe00f
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0xe05a
jmp 0xe019
movl -0x2c(%rbp), %eax
subl $0x5e, %eax
je 0xe075
jmp 0xe023
movl -0x2c(%rbp), %eax
subl $0x7e, %eax
je 0xe063
jmp 0xe02d
movl -0x2c(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0xe090
jmp 0xe039
movl -0x2c(%rbp), %eax
subl $0x11c, %eax            # imm = 0x11C
je 0xe07e
jmp 0xe045
movl -0x2c(%rbp), %eax
subl $0x11d, %eax            # imm = 0x11D
je 0xe087
jmp 0xe099
movl $0x42d2, -0x1c(%rbp)    # imm = 0x42D2
jmp 0xe0a8
movl $0x42d3, -0x1c(%rbp)    # imm = 0x42D3
jmp 0xe0a8
movl $0x42d1, -0x1c(%rbp)    # imm = 0x42D1
jmp 0xe0a8
movl $0x42d0, -0x1c(%rbp)    # imm = 0x42D0
jmp 0xe0a8
movl $0x42d4, -0x1c(%rbp)    # imm = 0x42D4
jmp 0xe0a8
movl $0x42d6, -0x1c(%rbp)    # imm = 0x42D6
jmp 0xe0a8
movl $0x42d5, -0x1c(%rbp)    # imm = 0x42D5
jmp 0xe0a8
movl $0x42d7, -0x1c(%rbp)    # imm = 0x42D7
jmp 0xe0a8
movq -0x10(%rbp), %rdi
callq 0xe100
movq %rax, -0x8(%rbp)
jmp 0xe0f6
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0xdfd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe0d3
movq $0x0, -0x8(%rbp)
jmp 0xe0f6
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rcx
movl $0x1, %edx
movb $0x0, %al
callq 0x2510
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_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x120, (%rax)          # imm = 0x120
je 0xe687
movq $0x0, -0x8(%rbp)
jmp 0xe6c3
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd480
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x23a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_param
static struct ast *parse_param(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    if (peek_tok(parse)->type == IDENT_TOK) {
        struct ast *name = ast_new_s(line, NAME, strdup(get_tok(parse)->val.u.s));

        int pos = parse->pos;
        struct ast *type = parse_type(parse);
        if (type == NULL) {
            parse->pos = pos;
            return name;
        }

        return ast_new_ast(line, DECL, 2, name, type);
    }

    return parse_type(parse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x120, (%rax)          # imm = 0x120
jne 0xe7a2
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd480
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x23a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd4b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xe77f
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7af
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, -0x8(%rbp)
jmp 0xe7af
movq -0x10(%rbp), %rdi
callq 0xd4b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe7ea
movq $0x0, -0x8(%rbp)
jmp 0xe82d
movq -0x10(%rbp), %rdi
callq 0xd4b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe808
movq $0x0, -0x8(%rbp)
jmp 0xe82d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x4000, %esi           # imm = 0x4000
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_if_stmt
static struct ast *parse_if_stmt(struct parse *parse)
{
    if (!expect(parse, IF_TOK))
        goto err0;

    struct loc *line = get_linenr(parse);

    struct ast *expr = NULL;
    if (peek_tok(parse)->type != '{') {
        expr = parse_expr(parse);
        if (expr == NULL)
            goto err0;
    }

    struct ast *then_block = parse_block(parse);
    if (then_block == NULL)
        goto err1;

    struct ast *else_block = NULL;
    if (peek_tok(parse)->type == ELSE_TOK) {
	parse->pos++;

        else_block = peek_tok(parse)->type == IF_TOK ?
                parse_if_stmt(parse) : parse_block(parse);

        if (else_block == NULL)
            goto err2;
    }

    return ast_new_ast(line, IF_STMT, 3, expr, then_block, else_block);

err2:
    ast_unref(then_block);
err1:
    ast_unref(expr);
err0:
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0xda00
testb $0x1, %al
jne 0xeae3
jmp 0xebd9
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x7b, (%rax)
je 0xeb21
movq -0x10(%rbp), %rdi
callq 0xd870
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xeb1f
jmp 0xebd9
jmp 0xeb21
movq -0x10(%rbp), %rdi
callq 0xd6e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xeb3a
jmp 0xebd0
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x121, (%rax)          # imm = 0x121
jne 0xeba0
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x102, (%rax)          # imm = 0x102
jne 0xeb80
movq -0x10(%rbp), %rdi
callq 0xeac0
movq %rax, -0x38(%rbp)
jmp 0xeb8d
movq -0x10(%rbp), %rdi
callq 0xd6e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xeb9e
jmp 0xebc7
jmp 0xeba0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x4101, %esi           # imm = 0x4101
movl $0x3, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
jmp 0xebe1
movq -0x28(%rbp), %rdi
callq 0x27e0
movq -0x20(%rbp), %rdi
callq 0x27e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_for_stmt
static struct ast *parse_for_stmt(struct parse *parse)
{
    if (!expect(parse, FOR_TOK))
        return NULL;

    struct loc *line = get_linenr(parse);

    struct ast *expr0 = NULL;
    struct ast *expr1 = NULL;
    struct ast *expr2 = NULL;

    if (peek_tok(parse)->type != '{') {
        expr0 = parse_expr(parse);

        if (peek_tok(parse)->type == ';') {
            parse->pos++;
            expr1 = parse_expr(parse);

            if (!expect(parse, ';')) {
                ast_unref(expr0);
                goto err;
            }

            if (peek_tok(parse)->type != '{')
                expr2 = parse_expr(parse);
        } else {
            // swap expr0 and expr1 so the condition is always in expr1
            expr1 = expr0;
            expr0 = NULL;
        }
    }

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

    return ast_new_ast(line, FOR_STMT, 4, expr0, expr1, expr2, block);

err:
    ast_unref(expr2);
    ast_unref(expr1);
    ast_unref(expr0);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x105, %esi            # imm = 0x105
callq 0xda00
testb $0x1, %al
jne 0xec1b
movq $0x0, -0x8(%rbp)
jmp 0xed3b
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x7b, (%rax)
je 0xecd3
movq -0x10(%rbp), %rdi
callq 0xd870
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x3b, (%rax)
jne 0xecc1
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0xd870
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0xda00
testb $0x1, %al
jne 0xeca4
movq -0x20(%rbp), %rdi
callq 0x27e0
jmp 0xed18
movq -0x10(%rbp), %rdi
callq 0xcd10
cmpl $0x7b, (%rax)
je 0xecbf
movq -0x10(%rbp), %rdi
callq 0xd870
movq %rax, -0x30(%rbp)
jmp 0xecd1
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
jmp 0xecd3
movq -0x10(%rbp), %rdi
callq 0xd6e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xece9
jmp 0xed18
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rax
movl $0x4104, %esi           # imm = 0x4104
movl $0x4, %edx
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
jmp 0xed3b
movq -0x30(%rbp), %rdi
callq 0x27e0
movq -0x28(%rbp), %rdi
callq 0x27e0
movq -0x20(%rbp), %rdi
callq 0x27e0
movq $0x0, -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: parse_switch_stmt
static struct ast *parse_switch_stmt(struct parse *parse)
{
    if (!expect(parse, SWITCH_TOK))
        goto err0;

    struct loc *line = get_linenr(parse);
    struct ast *expr = parse_expr(parse);
    if (expr == NULL)
        goto err0;

    if (!expect(parse, '{'))
        goto err1;


    // TODO: parse cases
    struct ast *block = parse_case_list(parse);
    
    if (!expect(parse, '}'))
        goto err2;

    return ast_new_ast(line, SWITCH_STMT, 2, expr, block);

err2:
    free(block);
err1:
    free(expr);
err0:        
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x12d, %esi            # imm = 0x12D
callq 0xda00
testb $0x1, %al
jne 0xed73
jmp 0xee00
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd870
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xed96
jmp 0xee00
movq -0x10(%rbp), %rdi
movl $0x7b, %esi
callq 0xda00
testb $0x1, %al
jne 0xedaa
jmp 0xedf7
movq -0x10(%rbp), %rdi
callq 0xef40
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7d, %esi
callq 0xda00
testb $0x1, %al
jne 0xedcb
jmp 0xedee
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x4108, %esi           # imm = 0x4108
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
jmp 0xee08
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x2030
movq $0x0, -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_goto_stmt
static struct ast *parse_goto_stmt(struct parse *parse)
{
    if (!expect(parse, GOTO_TOK))
        return NULL;

    struct loc *line = get_linenr(parse);

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

    return ast_new_ast(line, GOTO_STMT, 1, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x107, %esi            # imm = 0x107
callq 0xda00
testb $0x1, %al
jne 0xee48
movq $0x0, -0x8(%rbp)
jmp 0xee90
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 0xee73
movq $0x0, -0x8(%rbp)
jmp 0xee90
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x4106, %esi           # imm = 0x4106
movl $0x1, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_label_stmt
static struct ast *parse_label_stmt(struct parse *parse)
{
    struct loc *line = get_linenr(parse);
    struct ast *name = parse_name(parse);
    if (name == NULL)
        return NULL;

    if (!expect(parse, ':')) {
        ast_unref(name);
        return NULL;
    }
    struct ast *stmt = parse_stmt(parse);

    return ast_new_ast(line, LABEL_STMT, 2, name, stmt);
}

// 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
callq 0xe660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xeed7
movq $0x0, -0x8(%rbp)
jmp 0xef2a
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0xda00
testb $0x1, %al
jne 0xeefc
movq -0x20(%rbp), %rdi
callq 0x27e0
movq $0x0, -0x8(%rbp)
jmp 0xef2a
movq -0x10(%rbp), %rdi
callq 0xe890
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x410b, %esi           # imm = 0x410B
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
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_case_list
static struct ast *parse_case_list(struct parse *parse)
{
    size_t n_asts = 0;
    struct ast_list *head = NULL;
    struct ast_list **tailp = &head;

    struct loc *linenr = get_linenr(parse);

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

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

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

    return ast_new_list(linenr, CASE_LIST, head);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcb70
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf000
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xef9b
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xefd9
movq -0x38(%rbp), %rdi
callq 0x27a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0xef71
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4403, %esi           # imm = 0x4403
callq 0x2670
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/parse.c
// Function: parse_case
static struct ast *parse_case(struct parse *parse)
{
    struct loc *linenr = get_linenr(parse);

    switch (peek_tok(parse)->type) {
        case CASE_TOK: {
            parse->pos++;
            struct ast *expr = parse_expr_list(parse);

            size_t n_childs;
            ast_asts(expr, &n_childs);

            if (n_childs == 0)
                syntax_error(parse);

            if (!expect(parse, ':'))
                return NULL;

            struct ast *stmt_list = parse_stmt_list(parse);
            return ast_new_ast(linenr, CASE_CLAUSE, 2, expr, stmt_list);
        }
        case DEFAULT_TOK: {
            parse->pos++;

            if (!expect(parse, ':'))
                return NULL;

            struct ast *stmt_list = parse_stmt_list(parse);
            return ast_new_ast(linenr, DEFAULT_CLAUSE, 1, stmt_list);
        }
        default:
            return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd10
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x12a, %eax            # imm = 0x12A
je 0xf043
jmp 0xf030
movl -0x3c(%rbp), %eax
subl $0x12b, %eax            # imm = 0x12B
je 0xf0c9
jmp 0xf11e
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0xe610
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2ad0
cmpq $0x0, -0x28(%rbp)
jne 0xf07a
movq -0x10(%rbp), %rdi
callq 0xcd30
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0xda00
testb $0x1, %al
jne 0xf099
movq $0x0, -0x8(%rbp)
jmp 0xf126
movq -0x10(%rbp), %rdi
callq 0xe840
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x4109, %esi           # imm = 0x4109
movl $0x2, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
jmp 0xf126
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0xda00
testb $0x1, %al
jne 0xf0f2
movq $0x0, -0x8(%rbp)
jmp 0xf126
movq -0x10(%rbp), %rdi
callq 0xe840
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rcx
movl $0x410a, %esi           # imm = 0x410A
movl $0x1, %edx
movb $0x0, %al
callq 0x2510
movq %rax, -0x8(%rbp)
jmp 0xf126
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/rope.c
// Function: rope_indent
struct rope *rope_indent(void)
{
    struct rope *rope = malloc(sizeof *rope);
    rope->leaf = true;
    rope->val.s = rope_buf.data + rope_buf.n;
    
    size_t i = 0;
    while (i < zc_indent_level) {
        for (size_t j = 0; j < 4; ++j) {
            rope->val.s[i++] = ' ';
            rope_buf.n += 4;
        }
    }
    rope->val.s[i] = '\0';
    rope_buf.n++;

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x18, %edi
callq 0x2170
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
leaq 0xac7c(%rip), %rcx      # 0x19e20
addq 0x10ac75(%rip), %rcx    # 0x119e20
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xac06(%rip), %rcx      # 0x19dcc
movslq (%rcx), %rcx
cmpq %rcx, %rax
jae 0xf21a
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0xf218
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb $0x20, (%rax,%rcx)
movq 0x10ac21(%rip), %rax    # 0x119e20
addq $0x4, %rax
movq %rax, 0x10ac16(%rip)    # 0x119e20
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf1d6
jmp 0xf1bb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10abef(%rip), %rax    # 0x119e20
addq $0x1, %rax
movq %rax, 0x10abe4(%rip)    # 0x119e20
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/rope.c
// Function: rope_new_tree
struct rope *rope_new_tree(struct rope *left, struct rope *right)
{
    struct rope *rope = malloc(sizeof *rope);
    rope->leaf = false;
    rope->val.childs[0] = left;
    rope->val.childs[1] = right;

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/rope.c
// Function: rope_new_fmt
struct rope *rope_new_fmt(const char *fmt, ...)
{
    struct rope *rope = malloc(sizeof *rope);
    rope->leaf = true;
    rope->val.s = rope_buf.data + rope_buf.n;

    va_list va;
    va_start(va, fmt);

    char *data = rope_buf.data + rope_buf.n;
    size_t n_left = sizeof rope_buf.data - rope_buf.n;

    size_t n_written = vsnprintf(data, n_left, fmt, va) + 1;
    if (n_written > n_left)
        fatal(NULL, "not enough space in rope buffer");

    rope_buf.n += n_written;

    va_end(va);

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xf35e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
leaq 0xaa7f(%rip), %rcx      # 0x19e20
addq 0x10aa78(%rip), %rcx    # 0x119e20
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq 0xaa45(%rip), %rax      # 0x19e20
addq 0x10aa3e(%rip), %rax    # 0x119e20
movq %rax, -0x38(%rbp)
movl $0x100000, %eax         # imm = 0x100000
subq 0x10aa2e(%rip), %rax    # 0x119e20
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2080
addl $0x1, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0xf430
xorl %eax, %eax
movl %eax, %edi
leaq 0x5228(%rip), %rsi      # 0x14651
movb $0x0, %al
callq 0x6610
movq -0x48(%rbp), %rcx
movq 0x10a9e5(%rip), %rax    # 0x119e20
addq %rcx, %rax
movq %rax, 0x10a9db(%rip)    # 0x119e20
movq -0x10(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/rope.c
// Function: rope_print_to_file
void rope_print_to_file(struct rope *rope, FILE *fp)
{
    if (!rope)
        return;

    if (rope->leaf) {
        fputs(rope->val.s, fp);
        return;
    }

    rope_print_to_file(rope->val.childs[0], fp);
    rope_print_to_file(rope->val.childs[1], fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf479
jmp 0xf4b7
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0xf495
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20e0
jmp 0xf4b7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf460
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/scope.c
// Function: scope_new
struct scope *scope_new(struct scope *parent, size_t n_syms, size_t n_types)
{
    struct scope *scope = malloc(sizeof *scope);
    scope->symtbl = strmap_new(n_syms);
    scope->typetbl = strmap_new(n_types);
    scope->parent = parent;
    return scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf710
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0xf710
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/scope.c
// Function: scope_get_sym
struct sym *scope_get_sym(struct scope *scope, const char *name)
{
    struct sym *sym = strmap_get(scope->symtbl, name);
    if (sym == NULL) {
        if (scope->parent == NULL)
            return NULL;
        return scope_get_sym(scope->parent, name);
    }
    return sym_res(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf607
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xf5f0
movq $0x0, -0x8(%rbp)
jmp 0xf614
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf5b0
movq %rax, -0x8(%rbp)
jmp 0xf614
movq -0x20(%rbp), %rdi
callq 0xfa40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/scope.c
// Function: sym_type
struct type *sym_type(struct sym * sym)
{
    if (sym == NULL)
        return NULL;

    assert(sym->tag == TYPE_SYM);
    return ((struct type_sym *)sym)->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf63d
movq $0x0, -0x8(%rbp)
jmp 0xf67a
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
je 0xf66e
leaq 0x29b7(%rip), %rdi      # 0x12004
leaq 0x501d(%rip), %rsi      # 0x14671
movl $0x26, %edx
leaq 0x5019(%rip), %rcx      # 0x14679
leaq 0x5027(%rip), %r8       # 0x1468e
movb $0x0, %al
callq 0x6510
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/scope.c
// Function: scope_get_type
struct type *scope_get_type(struct scope *scope, const char *name)
{
    struct sym *sym = strmap_get(scope->typetbl, name);
    if (sym == NULL) {
        if (scope->parent == NULL)
            return NULL;
        return scope_get_type(scope->parent, name);
    }
    return sym_type(sym_res(sym));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf6e8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xf6d1
movq $0x0, -0x8(%rbp)
jmp 0xf6fd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf690
movq %rax, -0x8(%rbp)
jmp 0xf6fd
movq -0x20(%rbp), %rdi
callq 0xfa40
movq %rax, %rdi
callq 0xf620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/strmap.c
// Function: strmap_new
struct strmap *strmap_new(size_t n)
{
    struct strmap *map = malloc(sizeof *map);
    map->n = n;
    map->map = calloc(n, sizeof *map->map);

    return map;
}

// 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), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x2100
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/strmap.c
// Function: strmap_get
void *strmap_get(struct strmap *map, const char *key)
{
    size_t h = strhash64(key) % map->n;
    for (struct strmap_e *e = map->map[h]; e != NULL; e = e->next) {
        if (strcmp(key, e->key) == 0)
            return e->val;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf7f0
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xf7d4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x2110
cmpl $0x0, %eax
jne 0xf7c4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xf7dc
jmp 0xf7c6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xf79a
movq $0x0, -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/strmap.c
// Function: strhash64
static uint64_t strhash64(const char *s)
{
	uint64_t h = 14695981039346656037ULL;
	for (int i = 0; s[i] != '\0'; ++i) {
		h ^= s[i];
		h *= 1099511628211;
	}
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xf851
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbq (%rax,%rcx), %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf80d
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/strmap.c
// Function: strmap_add
void strmap_add(struct strmap *map, const char *key, void *val)
{
    int n = strhash64(key) % map->n;
    struct strmap_e *e = malloc(sizeof *e);

    e->key = strdup(key);
    e->val = val;
    e->next = map->map[n];

    map->map[n] = e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf7f0
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movl %edx, %eax
movl %eax, -0x1c(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/strmap.c
// Function: del_strmap_e
void del_strmap_e(struct strmap_e *e, void (*val_free)(void *))
{
    if (e == NULL)
        return;

    del_strmap_e(e->next, val_free);
    free(e->key);

    if (val_free != NULL)
        val_free(e->val);

    free(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf909
jmp 0xf944
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf8f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
cmpq $0x0, -0x10(%rbp)
je 0xf93b
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/sym.c
// Function: sym_new
struct sym *sym_new(struct ast *ast)
{
    struct sym *sym = malloc(sizeof (struct decl_sym));

    sym->loc = ast;
    sym->tag = UNRES_SYM;

    return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/sym.c
// Function: sym_from_ast
struct sym *sym_from_ast(struct ast *ast)
{
    if (ast->tag == DECL) {
        struct decl_sym *decl_sym = (struct decl_sym *)sym_new(ast);
        decl_sym->sym.loc = ast;
        decl_sym->sym.tag = DECL_SYM;
        decl_sym->type = type_from_ast(ast_ast(decl_sym->sym.loc, 1));
	decl_sym->type->tag |= LVAL_TYPE_FLAG;
        decl_sym->c_name = gen_c_ident();

        return (struct sym *)decl_sym;
    }
    abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4000, (%rax)         # imm = 0x4000
jne 0xfcdc
movq -0x8(%rbp), %rdi
callq 0xf9b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, %rdi
callq 0x10600
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, (%rax)
callq 0x3b10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
callq 0x2040
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/type.c
// Function: sizeof_basic_type
size_t sizeof_basic_type(struct type *type)
{
    switch (type->tag & ~LVAL_TYPE_FLAG) {
        case INT8_TYPE:
        case UINT8_TYPE:
        case CHAR_TYPE:
        case BOOL_TYPE:
            return 1;

        case INT16_TYPE:
        case UINT16_TYPE:
            return 2;

        case UINT_TYPE:
        case INT_TYPE:
            return sizeof (int);

        case UINT32_TYPE:
        case INT32_TYPE:
            return 4;

        case SSIZE_TYPE:
        case SIZE_TYPE:
            return sizeof (size_t);

        case INT64_TYPE:
        case UINT64_TYPE:
            return 8;

        case INTPTR_TYPE:
        case UINTPTR_TYPE:
            return sizeof (intptr_t);

        case FLOAT_TYPE:
            return sizeof (float);

        case DOUBLE_TYPE:
            return sizeof (double);

        default:
            bug("Invalid argument to sizeof_basic_type: %x", type->tag);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xfffffbff, %eax       # imm = 0xFFFFFBFF
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0xfe19
jmp 0xfd15
movl -0x14(%rbp), %eax
subl $0x80, %eax
je 0xfe05
jmp 0xfd25
movl -0x14(%rbp), %eax
subl $0x1002, %eax           # imm = 0x1002
je 0xfe05
jmp 0xfd35
movl -0x14(%rbp), %eax
subl $0x1004, %eax           # imm = 0x1004
je 0xfe4b
jmp 0xfd45
movl -0x14(%rbp), %eax
subl $0x2002, %eax           # imm = 0x2002
je 0xfe0f
jmp 0xfd55
movl -0x14(%rbp), %eax
subl $0x2004, %eax           # imm = 0x2004
je 0xfe55
jmp 0xfd65
movl -0x14(%rbp), %eax
subl $0x3002, %eax           # imm = 0x3002
je 0xfe23
jmp 0xfd75
movl -0x14(%rbp), %eax
subl $0x4002, %eax           # imm = 0x4002
je 0xfe37
jmp 0xfd85
movl -0x14(%rbp), %eax
subl $0x5002, %eax           # imm = 0x5002
je 0xfe41
jmp 0xfd95
movl -0x14(%rbp), %eax
subl $0x6002, %eax           # imm = 0x6002
je 0xfe2d
jmp 0xfda5
movl -0x14(%rbp), %eax
subl $0x7002, %eax           # imm = 0x7002
je 0xfe19
jmp 0xfdb1
movl -0x14(%rbp), %eax
subl $0x8002, %eax           # imm = 0x8002
je 0xfe05
jmp 0xfdbd
movl -0x14(%rbp), %eax
subl $0x9002, %eax           # imm = 0x9002
je 0xfe0f
jmp 0xfdc9
movl -0x14(%rbp), %eax
subl $0xa002, %eax           # imm = 0xA002
je 0xfe23
jmp 0xfdd5
movl -0x14(%rbp), %eax
subl $0xb002, %eax           # imm = 0xB002
je 0xfe37
jmp 0xfde1
movl -0x14(%rbp), %eax
subl $0xc002, %eax           # imm = 0xC002
je 0xfe41
jmp 0xfded
movl -0x14(%rbp), %eax
subl $0xd002, %eax           # imm = 0xD002
je 0xfe2d
jmp 0xfdf9
movl -0x14(%rbp), %eax
subl $0xe002, %eax           # imm = 0xE002
jne 0xfe5f
jmp 0xfe05
movq $0x1, -0x8(%rbp)
jmp 0xfe73
movq $0x2, -0x8(%rbp)
jmp 0xfe73
movq $0x4, -0x8(%rbp)
jmp 0xfe73
movq $0x4, -0x8(%rbp)
jmp 0xfe73
movq $0x8, -0x8(%rbp)
jmp 0xfe73
movq $0x8, -0x8(%rbp)
jmp 0xfe73
movq $0x8, -0x8(%rbp)
jmp 0xfe73
movq $0x4, -0x8(%rbp)
jmp 0xfe73
movq $0x8, -0x8(%rbp)
jmp 0xfe73
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x48a8(%rip), %rdi      # 0x14714
movb $0x0, %al
callq 0x6510
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/type.c
// Function: int_to_c_type
const char *int_to_c_type(bool is_signed, size_t size)
{
    assert(1 == sizeof (char));
    assert(2 == sizeof (short));
    assert(4 == sizeof (int));
    assert(8 == sizeof (long long));

    if (is_signed) {
        switch (size) {
            case 1:
                return "signed char";
            case 2:
                return "short";
            case 4:
                return "int";
            case 8:
                return "long long";
            default:
                unreachable();
        }
    } else {
        switch (size) {
            case 1:
                return "unsigned char";
            case 2:
                return "unsigned short";
            case 4:
                return "unsigned int";
            case 8:
                return "unsigned long long";
            default:
                unreachable();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0xff24
movq -0x18(%rbp), %rax
decq %rax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xff03
movq -0x20(%rbp), %rax
leaq 0x483a(%rip), %rcx      # 0x146f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x488b(%rip), %rax      # 0x14755
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x4890(%rip), %rax      # 0x1476a
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x488f(%rip), %rax      # 0x14779
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x488c(%rip), %rax      # 0x14786
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x3286(%rip), %rdi      # 0x13190
leaq 0x482d(%rip), %rsi      # 0x1473e
movl $0x5b, %edx
leaq 0x4828(%rip), %rcx      # 0x14745
movb $0x0, %al
callq 0x6510
movq -0x18(%rbp), %rax
decq %rax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0xff7d
movq -0x28(%rbp), %rax
leaq 0x4794(%rip), %rcx      # 0x146d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4803(%rip), %rax      # 0x14753
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x4804(%rip), %rax      # 0x14761
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x4806(%rip), %rax      # 0x14770
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x4806(%rip), %rax      # 0x1477d
movq %rax, -0x8(%rbp)
jmp 0xff9e
leaq 0x320c(%rip), %rdi      # 0x13190
leaq 0x47b3(%rip), %rsi      # 0x1473e
movl $0x68, %edx
leaq 0x47ae(%rip), %rcx      # 0x14745
movb $0x0, %al
callq 0x6510
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/type.c
// Function: new_selfref_type
struct type *new_selfref_type(struct type_sym *sym)
{
    struct selfref_type *type = malloc(sizeof *type);
    type->type.tag = SELFREF_TYPE_FLAG;
    type->sym = sym;

    return (struct type *)type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x100, (%rax)          # imm = 0x100
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/type.c
// Function: new_ptr_type
struct type *new_ptr_type(struct type *to)
{
    struct ptr_type *type = malloc(sizeof *type);
    type->type.tag = PTR_TYPE;
    type->to = to;

    return (struct type *)type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1008, (%rax)         # imm = 0x1008
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/type.c
// Function: new_array_type
struct type *new_array_type(struct type *of, size_t len)
{
    struct array_type *type = malloc(sizeof *type);
    type->type.tag = ARRAY_TYPE_FLAG;
    type->of = of;
    type->len = len;

    return (struct type *)type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x10, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/type.c
// Function: new_func_type
struct type *new_func_type(struct type *ret, size_t n_params,
        struct type *params[], bool has_vararg)
{
    struct func_type *type = malloc(sizeof *type +
            n_params * sizeof *type->params);
    type->type.tag = FUNC_TYPE_FLAG;
    type->ret = ret;
    type->n_params = n_params;
    type->has_vararg = has_vararg;
    
    for (size_t i = 0; i < n_params; i++) {
        type->params[i] = params[i];
    }

    return (struct type *)type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
addq $0x20, %rdi
callq 0x2170
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x20, (%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x102e8
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x102b7
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)