LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/lexer/pos.c
// Function: pos_check_keyword
int pos_check_keyword(const struct POS*pos, const char*keyword, size_t keyword_len)
{
    size_t i = 0;

    struct POS p = (*pos);

    while (i != keyword_len) {
        if (keyword[i] != pos_get_code(&p)) {
            return 0;
        }
        p = pos_next(&p);
        i++;
    }

    if (!pos_is_letter(&p) && !pos_is_digit(&p)) {
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbx
movq (%rdi), %rcx
movq 0x20(%rdi), %r8
testq %rdx, %rdx
je 0x55a9
movq 0x8(%rdi), %rdi
leaq -0x1(%rdi), %r9
xorl %eax, %eax
xorl %r10d, %r10d
movb (%rcx,%r8), %r11b
cmpb (%rsi,%r10), %r11b
jne 0x55be
testq %rdi, %rdi
setne %r11b
cmpq %r9, %r8
setne %bl
andb %r11b, %bl
movzbl %bl, %r11d
addq %r11, %r8
incq %r10
cmpq %r10, %rdx
jne 0x5580
movb (%rcx,%r8), %cl
cmpb $0x61, %cl
jl 0x55c0
movl $0x1, %eax
cmpb $0x7b, %cl
jae 0x55be
xorl %eax, %eax
popq %rbx
retq
cmpb $0x41, %cl
jl 0x55d1
movl $0x1, %eax
cmpb $0x5a, %cl
jbe 0x55bc
jmp 0x55be
addb $-0x3a, %cl
movl $0x1, %eax
cmpb $-0xa, %cl
jae 0x55bc
jmp 0x55be
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: set_parser_error
static void set_parser_error(struct PARSER*parser, size_t n, ...)
{
    size_t i;
    
    va_list args;
    va_start(args, n);
    for (i = 0; i < n; i++) {
        parser->err.exp_toks[i] = va_arg(args, enum TOKEN_TYPE);
    }
    va_end(args);
    parser->err.exp_toks[n] = TOKEN_TYPE_EOF;
    parser->err.get_tok = (parser->tok)->token_type;
    parser->err.line = (parser->tok)->frag.starting.line;
    parser->err.pos = (parser->tok)->frag.starting.pos;
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x5bdb
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
testq %rsi, %rsi
je 0x5c41
movl -0x80(%rsp), %eax
movq -0x70(%rsp), %rcx
movq -0x78(%rsp), %r8
xorl %edx, %edx
cmpl $0x28, %eax
ja 0x5c25
movq %r8, %r9
movl %eax, %r8d
addq %rcx, %r8
addl $0x8, %eax
movl %eax, -0x80(%rsp)
jmp 0x5c2e
leaq 0x8(%r8), %r9
movq %r9, -0x78(%rsp)
movl (%r8), %r8d
movl %r8d, 0x10(%rdi,%rdx,4)
incq %rdx
movq %r9, %r8
cmpq %rdx, %rsi
jne 0x5c0e
movl $0x26, 0x10(%rdi,%rsi,4)
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl %ecx, 0x50(%rdi)
movups 0x18(%rax), %xmm0
movups %xmm0, 0x58(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: ident_ast_read
static enum PARSER_CODES ident_ast_read(struct PARSER*parser, struct IDENT_AST**ident)
{
    enum PARSER_CODES r;
    
    if ((parser->tok)->token_type != TOKEN_TYPE_IDENT) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_IDENT);
        goto err0;
    }
    
    (*ident) = create_ident_ast((parser->tok)->str_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:
    (*ident) = NULL;
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0xc, (%rax)
jne 0x5ca3
leaq 0x8(%rbx), %r15
leaq 0x58(%rax), %rdi
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
callq 0xa96f
movq %rax, (%r14)
movq 0x8(%rbx), %rdi
callq 0x53ac
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x45d6
xorl %eax, %eax
jmp 0x5cc3
movl $0x1, %esi
movq %rbx, %rdi
movl $0xc, %edx
xorl %eax, %eax
callq 0x5b97
movq $0x0, (%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: function_call_ast_read
static enum PARSER_CODES function_call_ast_read(struct PARSER*parser, struct FUNCTION_CALL_AST**function_call, struct IDENT_AST*function_name)
{
    enum PARSER_CODES r;

    struct ARGS_LIST_AST*args_list = NULL;

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

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

    if ((parser->tok)->token_type != TOKEN_TYPE_RPAREN) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_RPAREN);
        goto err1;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));    
    
    (*function_call) = create_function_call_ast(function_name, 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:
    (*function_call) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq 0x8(%rdi), %rdi
cmpl $0x1b, (%rdi)
jne 0x66f5
movq %rdx, %r15
leaq 0x8(%r14), %r12
callq 0x53ac
movq (%r14), %rdi
movq %r12, %rsi
callq 0x45d6
movq 0x8(%r14), %rdi
cmpl $0x1c, (%rdi)
jne 0x6713
callq 0x53ac
movq (%r14), %rdi
movq %r12, %rsi
callq 0x45d6
movq 0x8(%rsp), %rsi
movq 0x8(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq %r15, %rdi
callq 0xa7a3
movq %rax, %r15
xorl %ebp, %ebp
jmp 0x6729
xorl %r15d, %r15d
movl $0x1, %esi
movq %r14, %rdi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x5b97
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x6729
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6e64
testl %eax, %eax
je 0x673b
movl %eax, %ebp
xorl %r15d, %r15d
movq %r15, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdi
cmpl $0x1c, (%rdi)
je 0x66c5
xorl %r15d, %r15d
movl $0x1, %esi
movq %r14, %rdi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x5b97
movq 0x8(%rsp), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x6729
callq 0x98e7
jmp 0x6726
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: variable_ast_read
static enum PARSER_CODES variable_ast_read(struct PARSER*parser, struct VARIABLE_AST**variable, struct IDENT_AST*ident)
{
    enum PARSER_CODES r;
    
    struct VARIABLE_PART_AST**parts = NULL;
    size_t parts_len = 0;
    size_t parts_cap = 0;

    while (((parser->tok)->token_type == TOKEN_TYPE_DOT) ||
           ((parser->tok)->token_type == TOKEN_TYPE_LBRACKET)) {
        struct VARIABLE_PART_AST*part;
        r = variable_part_ast_read(parser, &part);
        if (r != PARSER_OK) {
            goto err0;
        }

        PUSH_BACK(parts, part);
    }

    (*variable) = create_variable_ast(ident, parts, parts_len,
                                      (parser->tok)->frag.starting.line,
                                      (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err0:
    {
        size_t i;
        for (i = 0; i < parts_len; i++) {
            variable_part_ast_free(parts[i]);
        }
        SAFE_FREE(parts);
    }
    (*variable) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
leaq 0x8(%rdi), %rbp
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%rbp), %rdi
movl (%rdi), %eax
cmpl $0x1e, %eax
je 0x67d9
cmpl $0x24, %eax
jne 0x6886
callq 0x53ac
movq (%r12), %rdi
movq %rbp, %rsi
callq 0x45d6
movq %r12, %rdi
movq %rsp, %rsi
callq 0x5c5f
testl %eax, %eax
jne 0x68c8
movq (%rsp), %rdi
xorl %esi, %esi
jmp 0x6824
callq 0x53ac
movq (%r12), %rdi
movq %rbp, %rsi
callq 0x45d6
movq %r12, %rdi
movq %rsp, %rsi
callq 0x6fc5
testl %eax, %eax
jne 0x68a7
movq (%rbp), %rdi
cmpl $0x1f, (%rdi)
jne 0x68ab
callq 0x53ac
movq (%r12), %rdi
movq %rbp, %rsi
callq 0x45d6
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x9107
movq %rax, %rbx
cmpq %r14, %r13
jne 0x687a
testq %r13, %r13
je 0x685e
movq %r13, %r14
shlq $0x4, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1160
testq %rax, %rax
je 0x690a
movq %rax, %r15
leaq (,%r13,2), %r14
jmp 0x687a
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x6912
movq %rax, %r15
movl $0x1, %r14d
movq %rbx, (%r15,%r13,8)
incq %r13
jmp 0x6799
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x9295
xorl %ebx, %ebx
movq 0x8(%rsp), %r12
jmp 0x68f5
movl %eax, %ebx
jmp 0x68cd
movq (%rsp), %rdi
callq 0x8bdc
movl $0x1, %esi
movq %r12, %rdi
movl $0x1f, %edx
xorl %eax, %eax
callq 0x5b97
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r12
testq %r13, %r13
je 0x68eb
xorl %r14d, %r14d
movq (%r15,%r14,8), %rdi
callq 0x9265
incq %r14
cmpq %r14, %r13
jne 0x68da
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
movq %rax, (%r12)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x178b
callq 0x17bb
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: args_list_ast_read
static enum PARSER_CODES args_list_ast_read(struct PARSER*parser, struct ARGS_LIST_AST**args_list)
{
    enum PARSER_CODES r;
    struct ASSIGNMENT_EXPR_AST**assignment_exprs = NULL;
    size_t assignment_exprs_len = 0;
    size_t assignment_exprs_cap = 0;

    struct ASSIGNMENT_EXPR_AST*assignment_expr;

    r = assignment_expr_ast_read(parser, &assignment_expr);
    if (r != PARSER_OK) {
        goto err0;
    }
    
    PUSH_BACK(assignment_exprs, assignment_expr);    
    
    while ((parser->tok)->token_type == TOKEN_TYPE_COMMA) {
        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;
        }
        
        PUSH_BACK(assignment_exprs, assignment_expr);    
    }

    (*args_list) = create_args_list_ast(assignment_exprs, assignment_exprs_len,
                                        (parser->tok)->frag.starting.line,
                                        (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    {
        size_t i;
        for (i = 0; i < assignment_exprs_len; i++) {
            assignment_expr_ast_free(assignment_exprs[i]);
        }
        SAFE_FREE(assignment_exprs);
    }
 err0:
    (*args_list) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rsi
callq 0x6917
testl %eax, %eax
je 0x6e8f
movl %eax, %ebx
xorl %eax, %eax
jmp 0x6f71
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x6fc0
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movq 0x8(%r12), %rdi
movl $0x1, %r15d
cmpl $0x22, (%rdi)
jne 0x6f57
leaq 0x8(%r12), %r13
movl $0x1, %ebp
callq 0x53ac
movq (%r12), %rdi
movq %r13, %rsi
callq 0x45d6
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x6917
testl %eax, %eax
jne 0x6f86
cmpq %rbp, %r15
jne 0x6f3e
testq %rbp, %rbp
je 0x6f23
movq %rbp, %rbx
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
testq %rax, %rax
je 0x6fb3
movq %rax, %r14
addq %rbp, %rbp
jmp 0x6f3e
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x6fbb
movq %rax, %r14
movl $0x1, %ebp
movq 0x8(%rsp), %rax
movq %rax, (%r14,%r15,8)
incq %r15
movq (%r13), %rdi
cmpl $0x22, (%rdi)
je 0x6ed0
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xa925
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movq %rax, (%r13)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0x6fa6
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x871f
incq %r12
cmpq %r12, %r15
jne 0x6f95
movq %r14, %rdi
callq 0x1030
jmp 0x6e88
movq %rbx, %rdi
callq 0x187e
callq 0x18ae
callq 0x18df
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: logical_or_expr_ast_read
static enum PARSER_CODES logical_or_expr_ast_read(struct PARSER*parser, struct LOGICAL_OR_EXPR_AST**logical_or_expr)
{
    enum PARSER_CODES r;

    struct LOGICAL_AND_EXPR_AST**logical_and_exprs = NULL;
    size_t logical_and_exprs_len = 0;
    size_t logical_and_exprs_cap = 0;
    
    struct LOGICAL_AND_EXPR_AST*logical_and_expr;


    r = logical_and_expr_ast_read(parser, &logical_and_expr);
    if (r != PARSER_OK) {
        goto err0;
    }

    PUSH_BACK(logical_and_exprs, logical_and_expr);

    while ((parser->tok)->token_type == TOKEN_TYPE_OR) {
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));

        r = logical_and_expr_ast_read(parser, &logical_and_expr);
        if (r != PARSER_OK) {
            goto err1;
        }

        PUSH_BACK(logical_and_exprs, logical_and_expr);
    }

    (*logical_or_expr) = create_logical_or_expr_ast(logical_and_exprs, logical_and_exprs_len,
                                                    (parser->tok)->frag.starting.line,
                                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    {
        size_t i;
        for (i = 0; i < logical_and_exprs_len; i++) {
            logical_and_expr_ast_free(logical_and_exprs[i]);
        }
        SAFE_FREE(logical_and_exprs);
    }
 err0:
    (*logical_or_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rsi
callq 0x7126
testl %eax, %eax
je 0x6ff0
movl %eax, %ebx
xorl %eax, %eax
jmp 0x70d2
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x7121
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movq 0x8(%r12), %rdi
movl $0x1, %r15d
cmpl $0xd, (%rdi)
jne 0x70b8
leaq 0x8(%r12), %r13
movl $0x1, %ebp
callq 0x53ac
movq (%r12), %rdi
movq %r13, %rsi
callq 0x45d6
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7126
testl %eax, %eax
jne 0x70e7
cmpq %rbp, %r15
jne 0x709f
testq %rbp, %rbp
je 0x7084
movq %rbp, %rbx
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
testq %rax, %rax
je 0x7114
movq %rax, %r14
addq %rbp, %rbp
jmp 0x709f
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x711c
movq %rax, %r14
movl $0x1, %ebp
movq 0x8(%rsp), %rax
movq %rax, (%r14,%r15,8)
incq %r15
movq (%r13), %rdi
cmpl $0xd, (%rdi)
je 0x7031
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9924
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movq %rax, (%r13)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0x7107
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x9a97
incq %r12
cmpq %r12, %r15
jne 0x70f6
movq %r14, %rdi
callq 0x1030
jmp 0x6fe9
movq %rbx, %rdi
callq 0x1910
callq 0x1940
callq 0x1971
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: logical_and_expr_ast_read
static enum PARSER_CODES logical_and_expr_ast_read(struct PARSER*parser, struct LOGICAL_AND_EXPR_AST**logical_and_expr)
{
    enum PARSER_CODES r;

    struct EQ_EXPR_AST**eq_exprs = NULL;
    size_t eq_exprs_len = 0;
    size_t eq_exprs_cap = 0;
    
    struct EQ_EXPR_AST*eq_expr;


    r = eq_expr_ast_read(parser, &eq_expr);
    if (r != PARSER_OK) {
        goto err0;
    }

    PUSH_BACK(eq_exprs, eq_expr);

    while ((parser->tok)->token_type == TOKEN_TYPE_AND) {
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));

        r = eq_expr_ast_read(parser, &eq_expr);
        if (r != PARSER_OK) {
            goto err1;
        }

        PUSH_BACK(eq_exprs, eq_expr);
    }

    (*logical_and_expr) = create_logical_and_expr_ast(eq_exprs, eq_exprs_len,
                                                      (parser->tok)->frag.starting.line,
                                                      (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    {
        size_t i;
        for (i = 0; i < eq_exprs_len; i++) {
            eq_expr_ast_free(eq_exprs[i]);
        }
        SAFE_FREE(eq_exprs);
    }
 err0:
    (*logical_and_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rsi
callq 0x7287
testl %eax, %eax
je 0x7151
movl %eax, %ebx
xorl %eax, %eax
jmp 0x7233
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x7282
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movq 0x8(%r12), %rdi
movl $0x1, %r15d
cmpl $0xe, (%rdi)
jne 0x7219
leaq 0x8(%r12), %r13
movl $0x1, %ebp
callq 0x53ac
movq (%r12), %rdi
movq %r13, %rsi
callq 0x45d6
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7287
testl %eax, %eax
jne 0x7248
cmpq %rbp, %r15
jne 0x7200
testq %rbp, %rbp
je 0x71e5
movq %rbp, %rbx
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
testq %rax, %rax
je 0x7275
movq %rax, %r14
addq %rbp, %rbp
jmp 0x7200
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x727d
movq %rax, %r14
movl $0x1, %ebp
movq 0x8(%rsp), %rax
movq %rax, (%r14,%r15,8)
incq %r15
movq (%r13), %rdi
cmpl $0xe, (%rdi)
je 0x7192
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9ad4
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movq %rax, (%r13)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0x7268
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x9c47
incq %r12
cmpq %r12, %r15
jne 0x7257
movq %r14, %rdi
callq 0x1030
jmp 0x714a
movq %rbx, %rdi
callq 0x19a2
callq 0x19d2
callq 0x1a03
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq %r14, 0x8(%rsp)
callq 0x7345
movl %eax, %ebp
testl %eax, %eax
jne 0x7331
movq 0x8(%r15), %rdi
movl (%rdi), %r13d
leal -0xf(%r13), %eax
cmpl $0x1, %eax
ja 0x72fc
leaq 0x8(%r15), %r12
callq 0x53ac
movq (%r15), %rdi
movq %r12, %rsi
callq 0x45d6
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x7345
testl %eax, %eax
je 0x7300
movl %eax, %ebp
movq 0x10(%rsp), %rdi
callq 0x9de5
xorl %r14d, %r14d
jmp 0x7331
xorl %edx, %edx
jmp 0x7314
xorl %r14d, %r14d
cmpl $0x10, %r13d
sete %r14b
movq 0x8(%rsp), %rdx
movq (%r12), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movq %rax, %rdi
movl %r14d, %esi
callq 0x9c6a
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/parser.c
// Function: relational_expr_ast_read
static enum PARSER_CODES relational_expr_ast_read(struct PARSER*parser, struct RELATIONAL_EXPR_AST**relational_expr)
{
    enum PARSER_CODES r;

    struct ADDITIVE_EXPR_AST*left = NULL;
    enum AST_REL_OP rel_op = AST_REL_OP_LT;
    struct ADDITIVE_EXPR_AST*right = NULL;

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

    if (((parser->tok)->token_type == TOKEN_TYPE_LT) || ((parser->tok)->token_type == TOKEN_TYPE_GT) ||
        ((parser->tok)->token_type == TOKEN_TYPE_LE) || ((parser->tok)->token_type == TOKEN_TYPE_GE)) {
        if ((parser->tok)->token_type == TOKEN_TYPE_LT) {
            rel_op = AST_REL_OP_LT;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_GT) {
            rel_op = AST_REL_OP_GT;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_LE) {
            rel_op = AST_REL_OP_LE;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_GE) {
            rel_op = AST_REL_OP_GE;
        }

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

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

    (*relational_expr) = create_relational_expr_ast(left, rel_op, right,
                                                    (parser->tok)->frag.starting.line,
                                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    additive_expr_ast_free(left);
 err0:
    (*relational_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq %r14, 0x8(%rsp)
callq 0x740f
movl %eax, %ebp
testl %eax, %eax
jne 0x73fb
movq 0x8(%r15), %rdi
movl (%rdi), %r12d
leal -0x11(%r12), %r13d
cmpl $0x3, %r13d
ja 0x73c0
leaq 0x8(%r15), %r14
callq 0x53ac
movq (%r15), %rdi
movq %r14, %rsi
callq 0x45d6
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x740f
testl %eax, %eax
je 0x73c4
movl %eax, %ebp
movq 0x10(%rsp), %rdi
callq 0x9f62
xorl %r14d, %r14d
jmp 0x73fb
xorl %edx, %edx
jmp 0x73de
addl $-0x12, %r12d
movq %r14, %rax
xorl %r14d, %r14d
cmpl $0x3, %r12d
cmovbl %r13d, %r14d
movq 0x8(%rsp), %rdx
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movq %rax, %rdi
movl %r14d, %esi
callq 0x9e08
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x7ec3
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7eda
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x7eae
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7ef4
callq 0x80a2
movq 0x10(%rbx), %rdi
callq 0x80df
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7ae4(%rip), %rbp      # 0xfa52
leaq 0x7291(%rip), %r13      # 0xf206
movq %rbp, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x7b31(%rip), %rsi      # 0xfac2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq %rbx, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq %r13, %rcx
movq %r13, %rbp
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x7b1c(%rip), %rsi      # 0xfae3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %r13
leal 0x4(%r14), %edx
movq %rbx, %rdi
leaq 0x7a70(%rip), %rsi      # 0xfa52
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x81d9(%rip), %rsi      # 0x101d4
movq %rbx, %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
leaq 0x7a40(%rip), %rsi      # 0xfa52
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7ae3(%rip), %rdi      # 0xfb09
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x804c
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8163
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x828c
leaq 0x79f0(%rip), %rsi      # 0xfa52
leaq 0x719d(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7a9e(%rip), %rdi      # 0xfb1b
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x80c8
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x80b3
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x8105
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8335
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x80f0
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x1130
testq %rax, %rax
je 0x815a
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1d9b
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x78d7(%rip), %rsi      # 0xfa52
leaq 0x7084(%rip), %rcx      # 0xf206
movq %rdx, (%rsp)
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x798c(%rip), %rsi      # 0xfb28
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x8202
movq (%rsp), %rax
leal 0x2(%rax), %ebp
leaq 0x8019(%rip), %r14      # 0x101d4
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %r12
movq %rbx, %rdi
leaq 0x7883(%rip), %rsi      # 0xfa52
movl %ebp, %edx
leaq 0x702e(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
incq %r13
cmpq 0x8(%r15), %r13
jb 0x81be
leaq 0x7849(%rip), %rsi      # 0xfa52
leaq 0x6ff6(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x7932(%rip), %rdi      # 0xfb57
movl $0x1a, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x77ad(%rip), %rsi      # 0xfa52
leaq 0x6f5a(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x78b0(%rip), %rsi      # 0xfb72
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x82f8
movq %r14, %r12
addq $0x2, %r12
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8402
incq %r13
cmpq 0x8(%r15), %r13
jb 0x82dd
leaq 0x7753(%rip), %rsi      # 0xfa52
leaq 0x6f00(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7875(%rip), %rdi      # 0xfb8f
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpq $0x9, %rdi
ja 0x83c2
leaq 0x75d0(%rip), %rax      # 0xf91c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rbx), %rdi
jmp 0x8386
movq (%rbx), %rdi
callq 0x85c1
jmp 0x83b3
movq (%rbx), %rdi
callq 0x855d
jmp 0x83b3
movq (%rbx), %rdi
callq 0x8585
jmp 0x83b3
movq (%rbx), %r14
movq (%r14), %rdi
callq 0x8983
movq %r14, %rdi
callq 0x1030
jmp 0x83b3
movq (%rbx), %rdi
callq 0x8531
jmp 0x83b3
movq (%rbx), %rdi
callq 0x84e0
jmp 0x83b3
movq (%rbx), %rdi
callq 0x84fe
jmp 0x83b3
movq (%rbx), %rdi
callq 0x85a3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
callq 0x1dfb
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_stmt_ast_to_file_inner
static void dump_stmt_ast_to_file_inner(FILE*f, const struct STMT_AST*ast, size_t spaces_num)
{
    switch (ast->type) {
    case AST_STMT_TYPE_DECL:
        dump_decl_stmt_ast_to_file_inner(f, ast->decl_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_ASSIGN:
        dump_assign_stmt_ast_to_file_inner(f, ast->assign_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_FUNCTION_CALL:
        dump_function_call_stmt_ast_to_file_inner(f, ast->function_call_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_IF:
        dump_if_stmt_ast_to_file_inner(f, ast->if_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_WHILE:
        dump_while_stmt_ast_to_file_inner(f, ast->while_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_BREAK:
        dump_break_stmt_ast_to_file_inner(f, ast->break_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_APPEND:
        dump_append_stmt_ast_to_file_inner(f, ast->append_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_CONTINUE:
        dump_continue_stmt_ast_to_file_inner(f, ast->continue_stmt, spaces_num);
        break;
    case AST_STMT_TYPE_DELETE:
        dump_delete_stmt_ast_to_file_inner(f, ast->delete_stmt, spaces_num);
        break;        
    case AST_STMT_TYPE_RETURN:
        dump_return_stmt_ast_to_file_inner(f, ast->return_stmt, spaces_num);
        break;
    default:
        fprintf(stderr, "Invalid STMT_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;        
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %edi
cmpq $0x9, %rdi
ja 0x84db
leaq 0x752a(%rip), %rax      # 0xf944
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8622
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8c60
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x907b
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x88f5
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x89f3
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8e69
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x87a5
leaq 0x75d4(%rip), %rsi      # 0xfa52
leaq 0x6d81(%rip), %rcx      # 0xf206
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x7860(%rip), %rdi      # 0xfcf6
movl $0x10, %esi
jmp 0x84c1
leaq 0x75ae(%rip), %rsi      # 0xfa52
leaq 0x6d5b(%rip), %rcx      # 0xf206
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x784b(%rip), %rdi      # 0xfd07
movl $0x16, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x1190
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8f7a
callq 0x1e72
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8bdc
movq 0x8(%rbx), %rdi
callq 0x80df
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x8554
callq 0x80df
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x7415(%rip), %r12      # 0xfa52
leaq 0x6bc2(%rip), %rcx      # 0xf206
movq %r12, %rsi
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x753b(%rip), %rsi      # 0xfb98
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %r15
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
leaq 0x6b85(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rcx
leaq 0x7b3d(%rip), %rsi      # 0x101d4
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
leaq 0x6b53(%rip), %r15      # 0xf206
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x74f6(%rip), %rdi      # 0xfbba
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x9407
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x74c8(%rip), %rdi      # 0xfbc7
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $0x2, %edi
je 0x8748
cmpl $0x1, %edi
je 0x873e
testl %edi, %edi
jne 0x8759
movq (%rbx), %rdi
callq 0x9438
jmp 0x8750
movq (%rbx), %rdi
callq 0x9475
jmp 0x8750
movq (%rbx), %rdi
callq 0x8bdc
movq %rbx, %rdi
popq %rbx
jmp 0x1030
callq 0x1ec6
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x7292(%rip), %r12      # 0xfa52
leaq 0x6a3f(%rip), %r15      # 0xf206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x73f2(%rip), %rsi      # 0xfbd5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x92e2
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x739e(%rip), %rdi      # 0xfbba
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x9407
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x73a2(%rip), %rdi      # 0xfbf9
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
cmpq $0x0, 0x10(%rbx)
je 0x88a6
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9265
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x8890
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0x88ec
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x1f1a
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x7144(%rip), %r12      # 0xfa52
leaq 0x68f1(%rip), %r15      # 0xf206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
leaq 0x72d8(%rip), %rsi      # 0xfc09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdx
addq $0x2, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0xa7ea
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x72cc(%rip), %rdi      # 0xfc34
movl $0x16, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x899d
callq 0x98e7
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_if_stmt_ast
struct IF_STMT_AST*create_if_stmt_ast(struct LOGICAL_OR_EXPR_AST*condition,
                                      struct BODY_AST*if_body,
                                      struct BODY_AST*else_body,
                                      size_t line, size_t pos)
{
    struct IF_STMT_AST*if_stmt;
    SAFE_MALLOC(if_stmt, 1);
    if_stmt->condition = condition;
    if_stmt->if_body = if_body;
    if_stmt->else_body = else_body;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x28, %edi
callq 0x1130
testq %rax, %rax
je 0x89ea
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1f4b
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: logical_or_expr_ast_free
void logical_or_expr_ast_free(struct LOGICAL_OR_EXPR_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->and_exprs_len; i++) {
        logical_and_expr_ast_free(ast->and_exprs[i]);
    }
    SAFE_FREE(ast->and_exprs);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x8c02
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9a97
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x8bed
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030