LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: eq_expr_ast_read
static enum PARSER_CODES eq_expr_ast_read(struct PARSER*parser, struct EQ_EXPR_AST**eq_expr)
{
    enum PARSER_CODES r;

    struct RELATIONAL_EXPR_AST*left = NULL;
    enum AST_EQ_OP eq_op = AST_EQ_OP_EQEQ;
    struct RELATIONAL_EXPR_AST*right = NULL;

    r = relational_expr_ast_read(parser, &left);
    if (r != PARSER_OK) {
        goto err0;
    }

    if (((parser->tok)->token_type == TOKEN_TYPE_EQEQ) || ((parser->tok)->token_type == TOKEN_TYPE_NEQ)) {
        if ((parser->tok)->token_type == TOKEN_TYPE_EQEQ) {
            eq_op = AST_EQ_OP_EQEQ;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_NEQ) {
            eq_op = AST_EQ_OP_NEQ;
        }

        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));

        r = relational_expr_ast_read(parser, &right);
        if (r != PARSER_OK) {
            goto err1;
        }
    }

    (*eq_expr) = create_eq_expr_ast(left, eq_op, right,
                                    (parser->tok)->frag.starting.line,
                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    relational_expr_ast_free(left);
 err0:
    (*eq_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6c10
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6b22
jmp 0x6be7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
je 0x6b3c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x10, (%rax)
jne 0x6ba3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xf, (%rax)
jne 0x6b52
movl $0x0, -0x2c(%rbp)
jmp 0x6b68
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x10, (%rax)
jne 0x6b66
movl $0x1, -0x2c(%rbp)
jmp 0x6b68
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6c10
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6ba1
jmp 0x6bde
jmp 0x6ba3
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %r8
callq 0xbdf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6bf8
movq -0x28(%rbp), %rdi
callq 0xc050
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: left_unary_expr_ast_read
static enum PARSER_CODES left_unary_expr_ast_read(struct PARSER*parser, struct LEFT_UNARY_EXPR_AST**left_unary_expr)
{
    enum PARSER_CODES r;

    enum AST_LEFT_UNARY_OP op = AST_LEFT_UNARY_OP_PLUS;

    struct PRIMARY_EXPR_AST*primary_expr;
    
    if ((parser->tok)->token_type == TOKEN_TYPE_PLUS) {
        op = AST_LEFT_UNARY_OP_PLUS;
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));
    } else if ((parser->tok)->token_type == TOKEN_TYPE_MINUS) {
        op = AST_LEFT_UNARY_OP_MINUS;
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));
    }

    r = primary_expr_ast_read(parser, &primary_expr);
    if (r != PARSER_OK) {
        goto err0;
    }

    (*left_unary_expr) = create_left_unary_expr_ast(op, primary_expr,
                                                    (parser->tok)->frag.starting.line,
                                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err0:
    (*left_unary_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x16, (%rax)
jne 0x799e
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
jmp 0x79d5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x17, (%rax)
jne 0x79d3
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
jmp 0x79d5
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7a40
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x79ed
jmp 0x7a24
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
callq 0xcaa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7a35
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: number_ast_read
static enum PARSER_CODES number_ast_read(struct PARSER*parser, struct NUMBER_AST**number)
{
    enum PARSER_CODES r;
    
    if ((parser->tok)->token_type != TOKEN_TYPE_NUMBER) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_NUMBER);
        goto err0;
    }    
    (*number) = create_number_ast((parser->tok)->int_val,
                                  (parser->tok)->frag.starting.line,
                                  (parser->tok)->frag.starting.pos);

    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    return PARSER_OK;

 err0:
    (*number) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1d, (%rax)
je 0x80fb
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1d, %edx
movb $0x0, %al
callq 0x4030
jmp 0x8158
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdx
callq 0xd7a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movl $0x0, -0x4(%rbp)
jmp 0x8169
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: array_literal_ast_read
static enum PARSER_CODES array_literal_ast_read(struct PARSER*parser, struct ARRAY_LITERAL_AST**array_literal)
{
    enum PARSER_CODES r;

    struct ARGS_LIST_AST*args_list = NULL;

    if ((parser->tok)->token_type != TOKEN_TYPE_LBRACKET) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_LBRACKET);
        goto err0;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    if ((parser->tok)->token_type != TOKEN_TYPE_RBRACKET) {
        r = args_list_ast_read(parser, &args_list);
        if (r != PARSER_OK) {
            goto err0;
        }
    }

    if ((parser->tok)->token_type != TOKEN_TYPE_RBRACKET) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_RBRACKET);
        goto err1;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));    
    
    (*array_literal) = create_array_literal_ast(args_list,
                                                (parser->tok)->frag.starting.line,
                                                (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    if (args_list != NULL) {
        args_list_ast_free(args_list);
    }
 err0:
    (*array_literal) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1e, (%rax)
je 0x8486
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1e, %edx
movb $0x0, %al
callq 0x4030
jmp 0x8563
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1f, (%rax)
je 0x84d1
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6030
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x84cf
jmp 0x8563
jmp 0x84d1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1f, (%rax)
je 0x84fc
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1f, %edx
movb $0x0, %al
callq 0x4030
jmp 0x8551
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdx
callq 0xb5c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8574
cmpq $0x0, -0x28(%rbp)
je 0x8561
movq -0x28(%rbp), %rdi
callq 0xb840
jmp 0x8563
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: property_ast_read
static enum PARSER_CODES property_ast_read(struct PARSER*parser, struct PROPERTY_AST**property)
{
    enum PARSER_CODES r;
    struct IDENT_AST*ident;
    struct ASSIGNMENT_EXPR_AST*assignment_expr;

    r = ident_ast_read(parser, &ident);
    if (r != PARSER_OK) {
        goto err0;
    }

    if ((parser->tok)->token_type != TOKEN_TYPE_COLON) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_COLON);
        goto err1;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    r = assignment_expr_ast_read(parser, &assignment_expr);
    if (r != PARSER_OK) {
        goto err1;
    }

    (*property) = create_property_ast(ident, assignment_expr,
                                      (parser->tok)->frag.starting.line,
                                      (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    ident_ast_free(ident);
 err0:
    (*property) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4190
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x85ab
jmp 0x8650
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x25, (%rax)
je 0x85d6
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x25, %edx
movb $0x0, %al
callq 0x4030
jmp 0x8647
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5190
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x860f
jmp 0x8647
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
callq 0xb320
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8661
movq -0x28(%rbp), %rdi
callq 0x8b30
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_unit_ast
struct UNIT_AST*create_unit_ast(struct FUNCTION_DECL_AST**functions, size_t functions_len,
                                size_t line, size_t pos)
{
    struct UNIT_AST*unit_ast;
    SAFE_MALLOC(unit_ast, 1);
    unit_ast->functions = functions;
    unit_ast->functions_len = functions_len;
    
    unit_ast->line = line;
    unit_ast->pos = pos;
    
    return unit_ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x86d0
movq 0x1694d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xff61(%rip), %rsi      # 0x1860e
leaq 0x103cc(%rip), %rdx     # 0x18a80
movl $0x1a, %ecx
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x86d2
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_unit_ast_to_xml_file_inner
static void dump_unit_ast_to_xml_file_inner(FILE*f, const struct UNIT_AST*ast, size_t spaces_num)
{
    size_t i;

    fprintf(f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");    
    fprintf(f, "<unit>\n");
    INC_SPACES_NUM();
    for (i = 0; i < ast->functions_len; i++) {
        dump_function_decl_ast_to_file_inner(f, ast->functions[i], spaces_num);
    }
    DEC_SPACES_NUM();
    fprintf(f, "</unit>\n");    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xff1d(%rip), %rsi      # 0x1867c
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0x10408(%rip), %rsi     # 0x18b79
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x87c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x89b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x878c
jmp 0x87c6
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x103a4(%rip), %rsi     # 0x18b81
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: unit_ast_free
void unit_ast_free(struct UNIT_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->functions_len; i++) {
        function_decl_ast_free(ast->functions[i]);
    }
    SAFE_FREE(ast->functions);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8834
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8870
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8804
jmp 0x8836
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x884f
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: function_decl_ast_free
void function_decl_ast_free(struct FUNCTION_DECL_AST*ast)
{
    ident_ast_free(ast->function_name);
    if (ast->formal_parameters_list != NULL) {
        formal_parameters_list_ast_free(ast->formal_parameters_list);
    }
    body_ast_free(ast->body);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8b30
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x88a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8b60
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8be0
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_function_decl_ast
struct FUNCTION_DECL_AST*create_function_decl_ast(struct IDENT_AST*function_name,
                                                  struct FORMAL_PARAMETERS_LIST_AST*formal_parameters_list,
                                                  struct BODY_AST*body,
                                                  size_t line, size_t pos)
{
    struct FUNCTION_DECL_AST*function_ast;
    SAFE_MALLOC(function_ast, 1);
    function_ast->function_name = function_name;
    function_ast->formal_parameters_list = formal_parameters_list;
    function_ast->body = body;

    function_ast->line = line;
    function_ast->pos = pos;
    
    return function_ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x28, %edi
callq 0x1130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x8934
movq 0x166e9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xfcfd(%rip), %rsi      # 0x1860e
leaq 0x10168(%rip), %rdx     # 0x18a80
movl $0x49, %ecx
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x8936
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_function_decl_ast_to_file_inner
static void dump_function_decl_ast_to_file_inner(FILE*f, const struct FUNCTION_DECL_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<function line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);

    INC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "<function_name line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_ident_ast_to_file_inner(f, ast->function_name, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</function_name>\n");
    if (ast->formal_parameters_list != NULL) {
        dump_formal_parameters_list_ast_to_file_inner(f, ast->formal_parameters_list, spaces_num);
    }
    dump_body_ast_to_file_inner(f, ast->body, spaces_num);
    DEC_SPACES_NUM();

    PUT_SPACES(); fprintf(f, "</function>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x10145(%rip), %rsi     # 0x18b1a
leaq 0x11113(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x1018c(%rip), %rsi     # 0x18b8a
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x8a13
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x100f6(%rip), %rsi     # 0x18b1a
leaq 0x110c4(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x1015e(%rip), %rsi     # 0x18bab
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd740
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x8a82
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x10087(%rip), %rsi     # 0x18b1a
leaq 0x11055(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0x10125(%rip), %rsi     # 0x18bd1
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8ad3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x8d30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x8ef0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x8af6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0x10013(%rip), %rsi     # 0x18b1a
leaq 0x10fe1(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0x100c3(%rip), %rsi     # 0x18be3
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: formal_parameters_list_ast_free
void formal_parameters_list_ast_free(struct FORMAL_PARAMETERS_LIST_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->params_len; i++) {
        ident_ast_free(ast->params[i]);
    }
    SAFE_FREE(ast->params);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8ba4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8b30
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8b74
jmp 0x8ba6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x8bbf
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: body_ast_free
void body_ast_free(struct BODY_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->stmts_len; i++) {
        stmt_ast_free(ast->stmts[i]);
    }
    SAFE_FREE(ast->stmts);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8c24
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8fe0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8bf4
jmp 0x8c26
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x8c3f
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_formal_parameters_list_ast
struct FORMAL_PARAMETERS_LIST_AST*create_formal_parameters_list_ast(struct IDENT_AST**params, size_t params_len,
                                                                    size_t line, size_t pos)
{
    struct FORMAL_PARAMETERS_LIST_AST*formal_parameters_list;
    SAFE_MALLOC(formal_parameters_list, 1);
    formal_parameters_list->params = params;
    formal_parameters_list->params_len = params_len;

    formal_parameters_list->line = line;
    formal_parameters_list->pos = pos;
    
    return formal_parameters_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8cc0
movq 0x1635d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xf971(%rip), %rsi      # 0x1860e
leaq 0xfddc(%rip), %rdx      # 0x18a80
movl $0x7e, %ecx
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x8cc2
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_formal_parameters_list_ast_to_file_inner
static void dump_formal_parameters_list_ast_to_file_inner(FILE*f, const struct FORMAL_PARAMETERS_LIST_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<formal_parameters_list line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    for (i = 0; i < ast->params_len; i++) {
        dump_ident_ast_to_file_inner(f, ast->params[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</formal_parameters_list>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xfdc5(%rip), %rsi      # 0x18b1a
leaq 0x10d93(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xfe72(%rip), %rsi      # 0x18bf0
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8dd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0xd740
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8d99
jmp 0x8dd3
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x8de1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xfd28(%rip), %rsi      # 0x18b1a
leaq 0x10cf6(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xfe14(%rip), %rsi      # 0x18c1f
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_body_ast
struct BODY_AST*create_body_ast(struct STMT_AST**stmts, size_t stmts_len,
                                size_t line, size_t pos)
{
    struct BODY_AST*body;
    SAFE_MALLOC(body, 1);
    body->stmts = stmts;
    body->stmts_len = stmts_len;

    body->line = line;
    body->pos = pos;
    
    return body;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8e80
movq 0x1619d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xf7b1(%rip), %rsi      # 0x1860e
leaq 0xfc1c(%rip), %rdx      # 0x18a80
movl $0xa8, %ecx
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x8e82
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_body_ast_to_file_inner
static void dump_body_ast_to_file_inner(FILE*f, const struct BODY_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<body line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    for (i = 0; i < ast->stmts_len; i++) {
        dump_stmt_ast_to_file_inner(f, ast->stmts[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</body>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xfc05(%rip), %rsi      # 0x18b1a
leaq 0x10bd3(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xfcfc(%rip), %rsi      # 0x18c3a
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8f91
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x9270
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8f59
jmp 0x8f93
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x8fa1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xfb68(%rip), %rsi      # 0x18b1a
leaq 0x10b36(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xfc8c(%rip), %rsi      # 0x18c57
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: stmt_ast_free
void stmt_ast_free(struct STMT_AST*ast)
{
    switch (ast->type) {
    case AST_STMT_TYPE_DECL:
        decl_stmt_ast_free(ast->decl_stmt);
        break;
    case AST_STMT_TYPE_ASSIGN:
        assign_stmt_ast_free(ast->assign_stmt);
        break;
    case AST_STMT_TYPE_FUNCTION_CALL:
        function_call_stmt_ast_free(ast->function_call_stmt);
        break;
    case AST_STMT_TYPE_IF:
        if_stmt_ast_free(ast->if_stmt);
        break;
    case AST_STMT_TYPE_WHILE:
        while_stmt_ast_free(ast->while_stmt);
        break;
    case AST_STMT_TYPE_BREAK:
        break_stmt_ast_free(ast->break_stmt);
        break;
    case AST_STMT_TYPE_CONTINUE:
        continue_stmt_ast_free(ast->continue_stmt);
        break;
    case AST_STMT_TYPE_APPEND:
        append_stmt_ast_free(ast->append_stmt);
        break;
    case AST_STMT_TYPE_DELETE:
        delete_stmt_ast_free(ast->delete_stmt);
        break;        
    case AST_STMT_TYPE_RETURN:
        return_stmt_ast_free(ast->return_stmt);
        break;
    default:
        fprintf(stderr, "Invalid STMT_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;        
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x9, %rax
ja 0x90aa
movq -0x10(%rbp), %rax
leaq 0xf9b4(%rip), %rcx      # 0x189c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x93d0
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9410
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9450
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9480
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x94e0
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9520
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9550
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9580
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x95c0
jmp 0x90d3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9600
jmp 0x90d3
movq 0x15f3f(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xf9cf(%rip), %rsi      # 0x18a91
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x90d5
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_stmt_ast
struct STMT_AST*create_stmt_ast(void*stmt_ptr, enum AST_STMT_TYPE stmt_type)
{
    struct STMT_AST*stmt;
    SAFE_MALLOC(stmt, 1);
    switch (stmt_type) {
    case AST_STMT_TYPE_DECL:
        stmt->decl_stmt = stmt_ptr;
        break;
    case AST_STMT_TYPE_ASSIGN:
        stmt->assign_stmt = stmt_ptr;
        break;
    case AST_STMT_TYPE_FUNCTION_CALL:
        stmt->function_call_stmt = stmt_ptr;
        break;
    case AST_STMT_TYPE_IF:
        stmt->if_stmt = stmt_ptr;
        break;
    case AST_STMT_TYPE_WHILE:
        stmt->while_stmt = stmt_ptr;
        break;
    case AST_STMT_TYPE_BREAK:
        stmt->break_stmt = stmt_ptr;
        break;   
    case AST_STMT_TYPE_CONTINUE:
        stmt->continue_stmt = stmt_ptr;
        break;
    case AST_STMT_TYPE_APPEND:
        stmt->delete_stmt = stmt_ptr;
        break;   
    case AST_STMT_TYPE_DELETE:
        stmt->append_stmt = stmt_ptr;
        break;        
    case AST_STMT_TYPE_RETURN:
        stmt->return_stmt = stmt_ptr;
        break;
    default:
        fprintf(stderr, "Invalid STMT_AST type: %d\n", stmt_type);
        exit(EXIT_FAILURE);
        break;
    }
    stmt->type = stmt_type;
    return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9147
movq 0x15ed6(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xf4ea(%rip), %rsi      # 0x1860e
leaq 0xf955(%rip), %rdx      # 0x18a80
movl $0xd3, %ecx
movl $0x10, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x9149
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x9, %rax
ja 0x91f9
movq -0x20(%rbp), %rax
leaq 0xf883(%rip), %rcx      # 0x189e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x921e
movq 0x15df0(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xf884(%rip), %rsi      # 0x18a91
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: if_stmt_ast_free
void if_stmt_ast_free(struct IF_STMT_AST*ast)
{
    logical_or_expr_ast_free(ast->condition);
    body_ast_free(ast->if_body);
    if (ast->else_body != NULL) {
        body_ast_free(ast->else_body);
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8be0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x94bd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8be0
jmp 0x94bf
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_decl_stmt_ast
struct DECL_STMT_AST*create_decl_stmt_ast(struct IDENT_AST*new_var_name,
                                          struct ASSIGNMENT_EXPR_AST*assignment,
                                          size_t line, size_t pos)
{
    struct DECL_STMT_AST*decl_stmt;
    SAFE_MALLOC(decl_stmt, 1);
    decl_stmt->new_var_name = new_var_name;
    decl_stmt->assignment = assignment;

    decl_stmt->line = line;
    decl_stmt->pos = pos;
    
    return decl_stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x96a0
movq 0x1597d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xef91(%rip), %rsi      # 0x1860e
leaq 0xf3fc(%rip), %rdx      # 0x18a80
movl $0x162, %ecx            # imm = 0x162
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x96a2
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_decl_stmt_ast_to_file_inner
static void dump_decl_stmt_ast_to_file_inner(FILE*f, const struct DECL_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<decl_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_ident_ast_to_file_inner(f, ast->new_var_name, spaces_num);
    PUT_SPACES(); fprintf(f, "<op>EQ</op>\n");
    dump_assignment_expr_ast_to_file_inner(f, ast->assignment, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</decl_stmt>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xf3e5(%rip), %rsi      # 0x18b1a
leaq 0x103b3(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xf502(%rip), %rsi      # 0x18c60
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd740
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xf384(%rip), %rsi      # 0x18b1a
leaq 0x10352(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xf4d3(%rip), %rsi      # 0x18c82
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xafb0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x97d9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xf330(%rip), %rsi      # 0x18b1a
leaq 0x102fe(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xf48c(%rip), %rsi      # 0x18c8f
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: assignment_expr_ast_free
void assignment_expr_ast_free(struct ASSIGNMENT_EXPR_AST*ast)
{
    switch (ast->type) {
    case AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL:
        object_literal_ast_free(ast->object_literal);
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL:
        array_literal_ast_free(ast->array_literal);
        break;        
    case AST_ASSIGNMENT_EXPR_TYPE_LOGICAL_OR_EXPR:
        logical_or_expr_ast_free(ast->logical_or_expr);
        break;
    default:
        fprintf(stderr, "Invalid ASSIGNMENT_EXPR_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);        
        break;
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x9840
jmp 0x982c
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x984e
jmp 0x9836
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x985c
jmp 0x986a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xb060
jmp 0x9893
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xb0e0
jmp 0x9893
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa030
jmp 0x9893
movq 0x1577f(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xf272(%rip), %rsi      # 0x18af4
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x9895
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_assign_stmt_ast
struct ASSIGN_STMT_AST*create_assign_stmt_ast(struct VARIABLE_AST*var_name,
                                              struct ASSIGNMENT_EXPR_AST*assignment,
                                              size_t line, size_t pos)
{
    struct ASSIGN_STMT_AST*assign_stmt;
    SAFE_MALLOC(assign_stmt, 1);
    assign_stmt->var_name = var_name;
    assign_stmt->assignment = assignment;

    assign_stmt->line = line;
    assign_stmt->pos = pos;
    
    return assign_stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x9910
movq 0x1570d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xed21(%rip), %rsi      # 0x1860e
leaq 0xf18c(%rip), %rdx      # 0x18a80
movl $0x18a, %ecx            # imm = 0x18A
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x9912
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_assign_stmt_ast_to_file_inner
static void dump_assign_stmt_ast_to_file_inner(FILE*f, const struct ASSIGN_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<assign_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->var_name, spaces_num);
    PUT_SPACES(); fprintf(f, "<op>EQ</op>\n");    
    dump_assignment_expr_ast_to_file_inner(f, ast->assignment, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</assign_stmt>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xf175(%rip), %rsi      # 0x18b1a
leaq 0x10143(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xf2cf(%rip), %rsi      # 0x18c9d
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xada0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xf114(%rip), %rsi      # 0x18b1a
leaq 0x100e2(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xf263(%rip), %rsi      # 0x18c82
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xafb0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x9a49
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xf0c0(%rip), %rsi      # 0x18b1a
leaq 0x1008e(%rip), %rcx     # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xf24e(%rip), %rsi      # 0x18cc1
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: variable_ast_free
void variable_ast_free(struct VARIABLE_AST*ast)
{
    size_t i;
    ident_ast_free(ast->ident);
    for (i = 0; i < ast->parts_len; i++) {
        variable_part_ast_free(ast->parts[i]);
    }
    SAFE_FREE(ast->parts);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8b30
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9ad1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xac30
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9aa0
jmp 0x9ad3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x9aee
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_function_call_stmt_ast
struct FUNCTION_CALL_STMT_AST*create_function_call_stmt_ast(struct FUNCTION_CALL_AST*function_call,
                                                            size_t line, size_t pos)
{
    struct FUNCTION_CALL_STMT_AST*function_call_stmt;
    SAFE_MALLOC(function_call_stmt, 1);
    function_call_stmt->function_call = function_call;

    function_call_stmt->line = line;
    function_call_stmt->pos = pos;
    
    return function_call_stmt;
}

// 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 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x9b6c
movq 0x154b1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xeac5(%rip), %rsi      # 0x1860e
leaq 0xef30(%rip), %rdx      # 0x18a80
movl $0x1b1, %ecx            # imm = 0x1B1
movl $0x18, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x9b6e
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_function_call_stmt_ast_to_file_inner
static void dump_function_call_stmt_ast_to_file_inner(FILE*f, const struct FUNCTION_CALL_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<function_call_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_function_call_ast_to_file_inner(f, ast->function_call, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</function_call_stmt>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xef25(%rip), %rsi      # 0x18b1a
leaq 0xfef3(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xf0b3(%rip), %rsi      # 0x18cd1
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd430
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x9c53
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xeeb6(%rip), %rsi      # 0x18b1a
leaq 0xfe84(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xf07f(%rip), %rsi      # 0x18cfc
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: function_call_ast_free
void function_call_ast_free(struct FUNCTION_CALL_AST*ast)
{
    ident_ast_free(ast->function_name);
    if (ast->args_list != NULL) {
        args_list_ast_free(ast->args_list);
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8b30
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9cc0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb840
jmp 0x9cc2
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)