LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_stmt_compound
ParserResult parse_stmt_compound(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = assume_token(parser, TOK_KIND_LBRACE); ErrProp;
    forward_token(parser);

    res = combinator_more1(parser, parse_block_item); ErrProp;
    Vector* nodes = res.value.nodes;

    res = assume_token(parser, TOK_KIND_RBRACE); ErrProp;
    forward_token(parser);

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_STMT_COMPOUND;
    node->value.stmt_compound.stmts = nodes;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x8, %edx
callq 0x2cc0
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x25c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x26c6
movq -0x8(%rbp), %rdi
callq 0x2750
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq 0x98f(%rip), %rdx       # 0x2f70
callq 0x2080
movq -0x88(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x2623
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x26c6
movq -0x88(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x9, %edx
callq 0x2cc0
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x267e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x26c6
movq -0x8(%rbp), %rdi
callq 0x2750
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq -0x80(%rbp), %rcx
movl $0x2, (%rcx)
movq -0x58(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: current_token
ParserResult current_token(Parser *parser) {
    ParserResult res;

    Token* t = (Token*)vector_at(parser->tokens, parser->position);
    if (!t) {
        res.result = PARSER_ERROR;
        res.error.kind = PARSER_ERROR_KIND_EOF;

        // This function does not consume any tokens, not rewind

        return res;
    }

    res.result = PARSER_OK;
    res.value.token = t;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4530
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2726
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x8(%rax)
jmp 0x2738
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: debug_print_current_token
void debug_print_current_token(Parser *parser) {
    fprintf(DEBUGOUT, "DEBUG_PRINT: CURRENT_TOKEN ");

    ParserResult res = current_token(parser);
    if (res.result == PARSER_ERROR) {
        fprintf(DEBUGOUT, "ERR!\n");
        return;
    }

    fprintf(DEBUGOUT, "OK! -> ");
    token_fprint_buf(DEBUGOUT, res.value.token);
    fprintf(DEBUGOUT, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc855(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8bea(%rip), %rsi      # 0xb377
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x26e0
cmpl $0x1, -0x28(%rbp)
jne 0x27c1
movq 0xc82a(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8bdb(%rip), %rsi      # 0xb393
movb $0x0, %al
callq 0x10e0
jmp 0x2804
movq 0xc810(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8bc7(%rip), %rsi      # 0xb399
movb $0x0, %al
callq 0x10e0
movq 0xc7f8(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d60
movq 0xc7e5(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x9873(%rip), %rsi      # 0xc070
movb $0x0, %al
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: assume_token
ParserResult assume_token(Parser *parser, TokenKind kind) {
    ParserResult res = current_token(parser);
    if (res.result == PARSER_ERROR) {
        return res;
    }

    Token* t = res.value.token;

    if (t->kind != kind) {
        res.result = PARSER_ERROR;
        res.error.kind = PARSER_ERROR_KIND_UNEXPECTED;
        res.error.value.unexpected.token = t;

        // This function does not consume any tokens, not rewind

        return res;
    }

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rsi
callq 0x26e0
movq -0x20(%rbp), %rdi
cmpl $0x1, (%rdi)
jne 0x2cee
jmp 0x2d22
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x2d20
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2d22
jmp 0x2d22
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_parameter_list
ParserResult parse_parameter_list(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = combinator_more1_sep(parser, TOK_KIND_COMMA, parse_parameter_declaration); ErrProp;

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_PARAM_LIST;
    node->value.param_list.params = res.value.nodes;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0xd, %edx
leaq 0x8b(%rip), %rcx        # 0x2e20
callq 0x20e0
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x2dd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2e0d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movl $0xf, (%rcx)
movq 0x18(%rax), %rdx
movq -0x38(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_parameter_declaration
ParserResult parse_parameter_declaration(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = parse_declaration_specifiers(parser); ErrProp;
    Node* spec = res.value.node;

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_PARAM_DECL;
    node->value.param_decl.spec = spec;

    res = parse_declarator(parser);
    if (res.result == PARSER_ERROR) {
        goto next_phase;
    }
    node->value.param_decl.decl = res.value.node;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;

next_phase:
    // TODO: support 'abstract-declarator opt'
    node->value.param_decl.decl = NULL;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2f40
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x2e88
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2f30
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl $0xe, (%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x24a0
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x2ef2
jmp 0x2f12
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x40(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movl $0x0, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x2f30
movq -0x68(%rbp), %rax
movq -0x40(%rbp), %rcx
movq $0x0, 0x10(%rcx)
movl $0x0, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_block_item
ParserResult parse_block_item(Parser *parser) {
    ParserResult res;

    res = parse_stmt(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    // Not matched...
    res.result = PARSER_ERROR;
    res.error.kind = PARSER_ERROR_KIND_UNEXPECTED; // TODO: fix

finish:
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2fe0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x0, (%rdi)
jne 0x2fbb
jmp 0x2fcc
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_stmt
ParserResult parse_stmt(Parser *parser) {
    ParserResult res;

    res = parse_stmt_compound(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    res = parse_stmt_expr(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    res = parse_stmt_selection(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    res = parse_stmt_jump(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    // Not matched...
    res.result = PARSER_ERROR;
    res.error.kind = PARSER_ERROR_KIND_UNEXPECTED; // TODO: fix
    fprintf(DEBUGOUT, "failed: parse stmt\n");

finish:
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, -0x98(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2550
movq -0x90(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x0, (%rdi)
jne 0x303a
jmp 0x311d
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, (%rax)
jne 0x3077
jmp 0x311d
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3290
movq -0x90(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, (%rax)
jne 0x30b1
jmp 0x311d
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3650
movq -0x90(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, (%rax)
jne 0x30f1
jmp 0x311d
movq -0x90(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x8(%rax)
movq 0xbecc(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x82c3(%rip), %rsi      # 0xb3d9
movb $0x0, %al
callq 0x10e0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_stmt_expr
ParserResult parse_stmt_expr(Parser *parser) {
    fprintf(DEBUGOUT, "parse_stmt_expr: START!\n");
    ParserResult res;
    state_t _parser_state = save_state(parser);

    Node* expr = NULL;
    res = parse_expr(parser); // Optional
    if (res.result == PARSER_OK) {
        fprintf(DEBUGOUT, "parse_stmt_expr: EXPR OK!\n");
        expr = res.value.node;
    }

    fprintf(DEBUGOUT, "parse_stmt_expr: EXPR!\n");
    debug_print_current_token(parser);

    res = assume_token(parser, TOK_KIND_SEMICOLON); ErrProp;
    forward_token(parser);

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_STMT_EXPR;
    node->value.stmt_expr.expr = expr;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movq 0xbe8d(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8298(%rip), %rsi      # 0xb3ed
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3840
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, (%rdi)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x0, (%rdi)
jne 0x31ca
movq 0xbe2b(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x824f(%rip), %rsi      # 0xb406
movb $0x0, %al
callq 0x10e0
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0xbe07(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x8246(%rip), %rsi      # 0xb421
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x2770
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0xa, %edx
callq 0x2cc0
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x3234
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x3279
movq -0x8(%rbp), %rdi
callq 0x2750
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movl $0x3, (%rcx)
movq -0x18(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_expr_primary
ParserResult parse_expr_primary(Parser *parser) {
    ParserResult res;

    res = parse_id(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    res = parse_constant(parser);
    if (res.result == PARSER_OK) {
        goto finish;
    }

    // Not matched...
    res.result = PARSER_ERROR;
    res.error.kind = PARSER_ERROR_KIND_UNEXPECTED; // TODO: fix

finish:
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2390
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x0, (%rdi)
jne 0x3d8b
jmp 0x3dd3
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3ea0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, (%rax)
jne 0x3dc2
jmp 0x3dd3
movq -0x50(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x8(%rax)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_argument_expr_list
ParserResult parse_argument_expr_list(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = combinator_more1_sep(parser, TOK_KIND_COMMA, parse_expr_assign); ErrProp;

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_ARGS_LIST;
    node->value.args_list.args = res.value.nodes;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0xd, %edx
leaq -0x5a5(%rip), %rcx      # 0x3870
callq 0x20e0
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x3e51
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x3e8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movl $0xb, (%rcx)
movq 0x18(%rax), %rdx
movq -0x38(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_constant
ParserResult parse_constant(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = current_token(parser); ErrProp;
    forward_token(parser);

    Token* t = res.value.token;
    switch (t->kind) {
    case TOK_KIND_INT_LIT:
    {
        char* const tok_buf = token_to_string(t);
        long int n = strtol(tok_buf, NULL, 10); // TODO: fix type
        free(tok_buf);

        Node* node = node_arena_malloc(parser->arena);
        node->kind = NODE_LIT_INT;
        node->value.lit_int.v = n;

        res.result = PARSER_OK;
        res.value.node = node;

        return res;
    }

    case TOK_KIND_STRING_LIT:
    {
        char* const tok_buf = token_to_string(t);

        Node* node = node_arena_malloc(parser->arena);
        node->kind = NODE_LIT_STRING;
        node->value.lit_string.v = tok_buf;

        res.result = PARSER_OK;
        res.value.node = node;

        return res;
    }

    default:
        res.result = PARSER_ERROR;
        res.error.kind = PARSER_ERROR_KIND_UNEXPECTED;
        res.error.value.unexpected.token = t;

        rewind_state(parser, _parser_state);
        return res;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x26e0
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x3f0b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x4019
movq -0x8(%rbp), %rdi
callq 0x2750
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x74(%rbp)
subl $0x1c, %eax
je 0x3f3d
jmp 0x3f30
movl -0x74(%rbp), %eax
subl $0x1e, %eax
je 0x3fa8
jmp 0x3ff3
movq -0x38(%rbp), %rdi
callq 0x1bd0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1100
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movl $0x8, (%rcx)
movq -0x48(%rbp), %rcx
movl %ecx, %edx
movq -0x50(%rbp), %rcx
movl %edx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x4019
movq -0x38(%rbp), %rdi
callq 0x1bd0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movl $0x9, (%rcx)
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x4019
movq -0x68(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/arena.c
// Function: arena_new
Arena* arena_new(size_t elem_size, void (*dtor)(void*)) {
    Arena* v = (Arena*)malloc(sizeof(Arena));
    if (!v) {
        return 0;
    }
    v->current = vector_new_with_cap(elem_size, 128);
    v->chain = vector_new(sizeof(Vector*));
    v->elem_size = elem_size;
    v->dtor = dtor;

    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x20, %edi
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x405f
movq $0x0, -0x8(%rbp)
jmp 0x40ac
movq -0x10(%rbp), %rdi
movl $0x80, %esi
callq 0x4330
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x42c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %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/yutopp[P]cc/arena.c
// Function: arena_malloc
void* arena_malloc(Arena *arena) {
    if (vector_len(arena->current) == vector_cap(arena->current)) {
        // Move an ownership of current into chain
        Vector** c = (Vector**)vector_append(arena->chain);
        (*c) = arena->current;

        // Allocate a new space
        arena->current = vector_new_with_cap(arena->elem_size, vector_cap(arena->current) * 2);

        return arena_malloc(arena);
    }

    return vector_append(arena->current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4580
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x45a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x4153
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4480
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x45a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
callq 0x4330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x40c0
movq %rax, -0x8(%rbp)
jmp 0x4163
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4480
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/arena.c
// Function: arena_drop
void arena_drop(Arena *arena) {
    if (!arena) {
        return;
    }

    for(size_t i=0; i<vector_len(arena->current); ++i) {
        void* e = vector_at(arena->current, i);
        arena->dtor(e);
    }
    vector_drop(arena->current);

    for(size_t i=0; i<vector_len(arena->chain); ++i) {
        Vector** c = (Vector**)vector_at(arena->chain, i);
        for(size_t j=0; j<vector_len(*c); ++j) {
            void* e = vector_at(*c, j);
            arena->dtor(e);
        }
        vector_drop(*c);
    }
    vector_drop(arena->chain);

    free(arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4188
jmp 0x42b9
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x41e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4530
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4190
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4440
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x42a3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4530
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x4286
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x4530
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4236
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x4440
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x41f4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4440
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/vector.c
// Function: vector_new
Vector* vector_new(size_t elem_size) {
    Vector* v = (Vector*)malloc(sizeof(Vector));
    if (!v) {
        return 0;
    }
    v->elem_size = elem_size;
    v->len = 0;
    v->cap = 0;
    v->buffer = 0;

    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x42eb
movq $0x0, -0x8(%rbp)
jmp 0x4322
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/vector.c
// Function: vector_new_with_cap
Vector* vector_new_with_cap(size_t elem_size, size_t cap) {
    Vector* v = vector_new(elem_size);
    bool res = extend(v, cap);
    assert(res);

    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4390
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x4367
jmp 0x4386
leaq 0x7113(%rip), %rdi      # 0xb481
leaq 0x7110(%rip), %rsi      # 0xb485
movl $0x20, %edx
leaq 0x710d(%rip), %rcx      # 0xb48e
callq 0x10b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/vector.c
// Function: extend
static bool extend(Vector *v, size_t ext_size) {
    size_t new_cap = v->cap + ext_size;
    char* new_buffer = (char*)malloc(v->elem_size * new_cap);
    if (!new_buffer) {
        return false;
    }

    if (v->buffer) {
        memcpy(new_buffer, v->buffer, v->elem_size * v->len);
        free(v->buffer);
    }

    v->cap = new_cap;
    v->buffer = new_buffer;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
imulq -0x20(%rbp), %rdi
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x43d2
movb $0x0, -0x1(%rbp)
jmp 0x4427
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x440b
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
imulq 0x8(%rax), %rdx
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/vector.c
// Function: vector_drop
void vector_drop(Vector *v) {
    if (!v) {
        return;
    }

    if (v->buffer) {
        free(v->buffer);
    }

    free(v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4455
jmp 0x4476
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x446d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/vector.c
// Function: vector_append
void* vector_append(Vector *v) {
    if (v->len == v->cap) {
        size_t ext_size = v->cap == 0 ? 24 : v->cap * 2; //
        if (!extend(v, ext_size)) {
            return 0;
        }
    }

    // TODO: Consider alignment
    char* p = &v->buffer[v->elem_size * v->len];
    v->len++;

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x44e8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x44b4
movl $0x18, %eax
movq %rax, -0x28(%rbp)
jmp 0x44c3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4390
testb $0x1, %al
jne 0x44e6
movq $0x0, -0x8(%rbp)
jmp 0x451f
jmp 0x44e8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/node.c
// Function: node_destruct
void node_destruct(Node* node) {
    switch(node->kind) {
    case NODE_TRANS_UNIT:
        vector_drop(node->value.trans_unit.decls);
        break;

    case NODE_STMT_COMPOUND:
        vector_drop(node->value.stmt_compound.stmts);
        break;

    case NODE_LIT_STRING:
        free((char*)node->value.lit_string.v);
        break;

    case NODE_ARGS_LIST:
        vector_drop(node->value.args_list.args);
        break;

    case NODE_PARAM_LIST:
        vector_drop(node->value.param_list.params);
        break;

    default:
        // DO NOTHING
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0xf, %rax
ja 0x463b
movq -0x10(%rbp), %rax
leaq 0x6ed5(%rip), %rcx      # 0xb4bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4440
jmp 0x463d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4440
jmp 0x463d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
jmp 0x463d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4440
jmp 0x463d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4440
jmp 0x463d
jmp 0x463d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/node.c
// Function: node_declarator_extract_id_token
Token* node_declarator_extract_id_token(Node* node) {
    switch(node->kind) {
    case NODE_DECLARATOR:
        return node_declarator_extract_id_token(node->value.declarator.node);
    case NODE_DIRECT_DECLARATOR:
        return node_declarator_extract_id_token(node->value.direct_declarator.base);
    case NODE_ID:
        return node->value.id.tok;
    default:
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xa, %eax
je 0x4d46
jmp 0x4d0c
movl -0x14(%rbp), %eax
subl $0xc, %eax
je 0x4d20
jmp 0x4d16
movl -0x14(%rbp), %eax
subl $0xd, %eax
je 0x4d33
jmp 0x4d54
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4cf0
movq %rax, -0x8(%rbp)
jmp 0x4d5c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4cf0
movq %rax, -0x8(%rbp)
jmp 0x4d5c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d5c
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/yutopp[P]cc/ir.c
// Function: ir_function_set_local
void ir_function_set_local(IRFunction* f, IRSymbolID id, size_t size) {
    while(vector_len(f->locals) <= id) {
        void* e = vector_append(f->locals);
        assert(e);
    }

    size_t* s = vector_at(f->locals, id);
    *s = size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4580
cmpq -0x10(%rbp), %rax
ja 0x4e82
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4480
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4e61
jmp 0x4e80
leaq 0x61e8(%rip), %rdi      # 0xb050
leaq 0x6781(%rip), %rsi      # 0xb5f0
movl $0x2b, %edx
leaq 0x677a(%rip), %rcx      # 0xb5f5
callq 0x10b0
jmp 0x4e34
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4530
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_module_new
IRModule* ir_module_new() {
    IRModule* m = (IRModule*)malloc(sizeof(IRModule));
    m->definitions = vector_new(sizeof(IRInst));
    m->functions = vector_new(sizeof(IRFunction));
    m->defs_sym_id = 0;

    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1120
movq %rax, -0x8(%rbp)
movl $0x30, %edi
callq 0x42c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x38, %edi
callq 0x42c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_module_drop
void ir_module_drop(IRModule *m) {
    for(size_t i=0; i<vector_len(m->definitions); ++i) {
        IRInst* inst = vector_at(m->definitions, i);
        ir_inst_destruct(inst);
    }
    vector_drop(m->definitions);

    for(size_t i=0; i<vector_len(m->functions); ++i) {
        IRFunction* f = vector_at(m->functions, i);
        ir_function_destruct(f);
    }
    vector_drop(m->functions);

    free(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x4faf
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4530
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x94a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4f64
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4440
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5010
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4530
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5030
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4fc3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4440
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_builder_new
IRBuilder* ir_builder_new() {
    IRBuilder* builder = (IRBuilder*)malloc(sizeof(IRBuilder));
    builder->current_func = NULL;
    builder->current_bb = NULL;

    return builder;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1120
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: build_trans_unit
void build_trans_unit(IRBuilder* builder, Node* node, IRModule* m) {
    switch(node->kind) {
    case NODE_TRANS_UNIT:
    {
        printf("LOG: transition unit\n");

        Vector* decls = node->value.trans_unit.decls;

        for(size_t i=0; i<vector_len(decls); ++i) {
            Node** n = (Node**)vector_at(decls, i);
            build_top_level(builder, *n, m);
        }

        break;
    }

    default:
        fprintf(stderr, "Kind = %d\n", node->kind);
        assert(0); // TODO: error handling
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x51a4
jmp 0x5130
leaq 0x65af(%rip), %rdi      # 0xb6e6
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x51a2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4530
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x5780
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5152
jmp 0x51e1
movq 0x9e4d(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x6541(%rip), %rsi      # 0xb6fc
movb $0x0, %al
callq 0x10e0
leaq 0x679d(%rip), %rdi      # 0xb966
leaq 0x6420(%rip), %rsi      # 0xb5f0
movl $0xb4, %edx
leaq 0x652b(%rip), %rcx      # 0xb707
callq 0x10b0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_module_fprint
void ir_module_fprint(FILE* fp, IRModule* m) {
    for(size_t i=0; i<vector_len(m->definitions); ++i) {
        IRInst* inst = vector_at(m->definitions, i);
        ir_inst_fprint(fp, inst);
    }

    for(size_t i=0; i<vector_len(m->functions); ++i) {
        IRFunction* f = vector_at(m->functions, i);
        ir_function_fprint(fp, f);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5257
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4530
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5208
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x52b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4530
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x55b0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x525f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_bb_fprint
void ir_bb_fprint(FILE* fp, IRBB* bb) {
    fprint_indent(fp, 1); fprintf(fp, "%ld:\n", bb->id);

    for(size_t i=0; i<vector_len(bb->insts); ++i) {
        IRInst* inst = vector_at(bb->insts, i);
        fprint_indent(fp, 2); ir_inst_fprint(fp, inst);
    }

    if (bb->term != NULL) {
        fprint_indent(fp, 2); ir_inst_fprint(fp, bb->term);
    } else {
        fprint_indent(fp, 2); fprintf(fp, "NOT TERMINATED\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5610
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x5f77(%rip), %rsi      # 0xb637
movb $0x0, %al
callq 0x10e0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x572e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4530
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5610
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x56cf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x575a
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5610
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x52c0
jmp 0x577a
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5610
movq -0x8(%rbp), %rdi
leaq 0x5eca(%rip), %rsi      # 0xb63d
movb $0x0, %al
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: build_top_level
void build_top_level(IRBuilder* builder, Node* node, IRModule* m) {
    switch(node->kind) {
    case NODE_FUNC_DEF:
    {
        printf("LOG: function def\n");

        Token* id_tok = node_declarator_extract_id_token(node->value.func_def.decl);
        assert(id_tok);

        IRInstValue fval = {
            .kind = IR_INST_VALUE_KIND_SYMBOL,
            .value = {
                .symbol = token_to_string(id_tok),
            },
        };
        insert_definition(m, fval);

        IRFunction* f = ir_builder_build_function(builder, token_to_string(id_tok), m);
        ir_builder_set_current_func(builder, f);
        build_statement(builder, node->value.func_def.block, f);

        break;
    }

    default:
        fprintf(stderr, "Kind = %d\n", node->kind);
        assert(0); // TODO: error handling
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
jne 0x5878
jmp 0x57a5
leaq 0x5f92(%rip), %rdi      # 0xb73e
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4cf0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x57cd
jmp 0x57ec
leaq 0x5f7d(%rip), %rdi      # 0xb751
leaq 0x5e15(%rip), %rsi      # 0xb5f0
movl $0xbf, %edx
leaq 0x5f71(%rip), %rcx      # 0xb758
callq 0x10b0
movl $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bd0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x58c0
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bd0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x5950
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x5990
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x48(%rbp), %rdx
callq 0x59c0
jmp 0x58b5
movq 0x9779(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x5e6d(%rip), %rsi      # 0xb6fc
movb $0x0, %al
callq 0x10e0
leaq 0x60c9(%rip), %rdi      # 0xb966
leaq 0x5d4c(%rip), %rsi      # 0xb5f0
movl $0xd2, %edx
leaq 0x5ea8(%rip), %rcx      # 0xb758
callq 0x10b0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: insert_definition
static IRSymbolID insert_definition(IRModule* m, IRInstValue v) {
    IRSymbolID sym_id = m->defs_sym_id;
    m->defs_sym_id++;

    IRInst inst = {
        .kind = IR_INST_KIND_LET,
        .value = {
            .let = {
                .id = sym_id,
                .rhs = v,
            },
        },
    };
    IRInst* i = vector_append(m->definitions);
    *i = inst;

    return sym_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movl $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4480
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x1110
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_function_coustruct
static void ir_function_coustruct(IRFunction* f, char const* name, IRModule* m) {
    f->name = name;
    f->mod = m;
    f->bb_arena = ir_bb_arena_new();
    f->entry = ir_bb_arena_malloc(f->bb_arena);
    f->bb_id = 0;
    f->locals = vector_new(sizeof(size_t));
    f->locals_id = 0;

    ir_bb_construct(f->entry, f->bb_id);
    f->bb_id++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, %al
callq 0x93e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9420
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x8, %edi
callq 0x42c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x90d0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/ir.c
// Function: ir_builder_build_bb
static IRBB* ir_builder_build_bb(IRBuilder* builder) {
    IRFunction* f = builder->current_func;
    IRBB* bb = ir_bb_arena_malloc(f->bb_arena);
    ir_bb_construct(bb, f->bb_id);
    f->bb_id++;

    return bb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9420
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x90d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)