LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %r14
jae 0x60bd
movq (%rdi,%r14,8), %rdi
callq 0x6b6b
incq %r14
jmp 0x60a5
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x60fd
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xfeec(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x84b0(%rip), %rsi      # 0xe5be
leaq 0x88a3(%rip), %rdx      # 0xe9b8
pushq $0x18
popq %r8
movl $0x1b1, %ecx            # imm = 0x1B1
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/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 0x8908(%rip), %r12      # 0xea52
leaq 0x80b5(%rip), %r15      # 0xe206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
leaq 0x8a9c(%rip), %rsi      # 0xec09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdx
addq $0x2, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x82c4
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x8a90(%rip), %rdi      # 0xec34
pushq $0x16
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/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 0x61d5
callq 0x7281
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6220
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
movq 0xfdc9(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x838d(%rip), %rsi      # 0xe5be
leaq 0x8780(%rip), %rdx      # 0xe9b8
pushq $0x28
popq %r8
movl $0x1d6, %ecx            # imm = 0x1D6
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r14
jae 0x6445
movq (%rdi,%r14,8), %rdi
callq 0x7442
incq %r14
jmp 0x642e
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_while_stmt_ast
struct WHILE_STMT_AST*create_while_stmt_ast(struct LOGICAL_OR_EXPR_AST*condition,
                                            struct BODY_AST*body,
                                            size_t line, size_t pos)
{
    struct WHILE_STMT_AST*while_stmt;
    SAFE_MALLOC(while_stmt, 1);
    while_stmt->condition = condition;
    while_stmt->body = body;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6495
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
movq 0xfb54(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x8118(%rip), %rsi      # 0xe5be
leaq 0x850b(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x214, %ecx            # imm = 0x214
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_while_stmt_ast_to_file_inner
static void dump_while_stmt_ast_to_file_inner(FILE*f, const struct WHILE_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<while_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "<condition>\n");
    INC_SPACES_NUM();
    dump_logical_or_expr_ast_to_file_inner(f, ast->condition, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</condition>\n");

    dump_body_ast_to_file_inner(f, ast->body, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</while_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 0x856e(%rip), %r12      # 0xea52
leaq 0x7d1b(%rip), %rbp      # 0xe206
movq %r12, %rsi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x87bd(%rip), %rsi      # 0xecc4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x2(%r14), %r15
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x873c(%rip), %rdi      # 0xec6b
pushq $0xc
popq %rsi
pushq $0x1
popq %r12
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x4, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x7326
movq %rbx, %rdi
leaq 0x84f4(%rip), %rsi      # 0xea52
movl %r15d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x8706(%rip), %rdi      # 0xec78
pushq $0xd
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5a77
movq %rbx, %rdi
leaq 0x84b9(%rip), %rsi      # 0xea52
movl %r14d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x873a(%rip), %rdi      # 0xece7
pushq $0xe
popq %rsi
movq %r12, %rdx
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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_break_stmt_ast
struct BREAK_STMT_AST*create_break_stmt_ast(size_t line, size_t pos) {
    struct BREAK_STMT_AST*break_stmt;
    SAFE_MALLOC(break_stmt, 1);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x65ef
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf9fa(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7fbe(%rip), %rsi      # 0xe5be
leaq 0x83b1(%rip), %rdx      # 0xe9b8
pushq $0x10
popq %r8
movl $0x23b, %ecx            # imm = 0x23B
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_continue_stmt_ast
struct CONTINUE_STMT_AST*create_continue_stmt_ast(size_t line, size_t pos) {
    struct CONTINUE_STMT_AST*continue_stmt;
    SAFE_MALLOC(continue_stmt, 1);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x667b
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf96e(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7f32(%rip), %rsi      # 0xe5be
leaq 0x8325(%rip), %rdx      # 0xe9b8
pushq $0x10
popq %r8
movl $0x255, %ecx            # imm = 0x255
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_append_stmt_ast
struct APPEND_STMT_AST*create_append_stmt_ast(struct VARIABLE_AST*arr, struct IDENT_AST*ident,
                                              size_t line, size_t pos)
{
    struct APPEND_STMT_AST*append_stmt;
    SAFE_MALLOC(append_stmt, 1);

    append_stmt->arr = arr;
    append_stmt->ident = ident;

    append_stmt->line = line;
    append_stmt->pos = pos;

    return append_stmt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x671d
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
movq 0xf8cc(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7e90(%rip), %rsi      # 0xe5be
leaq 0x8283(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x271, %ecx            # imm = 0x271
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_append_stmt_ast_to_file_inner
void dump_append_stmt_ast_to_file_inner(FILE*f, const struct APPEND_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<append_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->arr, spaces_num);
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</append_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 0x82e6(%rip), %r12      # 0xea52
leaq 0x7a93(%rip), %r15      # 0xe206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x858f(%rip), %rsi      # 0xed1e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x6c2c
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x84b7
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x856a(%rip), %rdi      # 0xed42
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_delete_stmt_ast
struct DELETE_STMT_AST*create_delete_stmt_ast(struct VARIABLE_AST*var, struct IDENT_AST*ident,
                                              size_t line, size_t pos)
{
    struct DELETE_STMT_AST*delete_stmt;
    SAFE_MALLOC(delete_stmt, 1);

    delete_stmt->var = var;
    delete_stmt->ident = ident;

    delete_stmt->line = line;
    delete_stmt->pos = pos;

    return delete_stmt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6830
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
movq 0xf7b9(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7d7d(%rip), %rsi      # 0xe5be
leaq 0x8170(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x297, %ecx            # imm = 0x297
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_delete_stmt_ast_to_file_inner
void dump_delete_stmt_ast_to_file_inner(FILE*f, const struct DELETE_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<delete_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->var, spaces_num);
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</delete_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 0x81d3(%rip), %r12      # 0xea52
leaq 0x7980(%rip), %r15      # 0xe206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x84b0(%rip), %rsi      # 0xed52
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x6c2c
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x84b7
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x848b(%rip), %rdi      # 0xed76
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_return_stmt_ast
struct RETURN_STMT_AST*create_return_stmt_ast(struct ASSIGNMENT_EXPR_AST*result,
                                              size_t line, size_t pos)
{
    struct RETURN_STMT_AST*return_stmt;
    SAFE_MALLOC(return_stmt, 1);
    return_stmt->result = result;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6933
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xf6b6(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7c7a(%rip), %rsi      # 0xe5be
leaq 0x806d(%rip), %rdx      # 0xe9b8
pushq $0x18
popq %r8
movl $0x2bd, %ecx            # imm = 0x2BD
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_return_stmt_ast_to_file_inner
static void dump_return_stmt_ast_to_file_inner(FILE*f, const struct RETURN_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<return_stmt> line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    if (ast->result != NULL) {
        INC_SPACES_NUM();
        dump_assignment_expr_ast_to_file_inner(f, ast->result, spaces_num);
        DEC_SPACES_NUM();
    }
    PUT_SPACES(); fprintf(f, "</return_stmt>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x80d6(%rip), %rsi      # 0xea52
leaq 0x7883(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
leaq 0x83ed(%rip), %rsi      # 0xed86
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %rsi
testq %rsi, %rsi
je 0x69ba
movq %r14, %rdx
addq $0x2, %rdx
movq %rbx, %rdi
callq 0x6d54
leaq 0x8091(%rip), %rsi      # 0xea52
leaq 0x783e(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x83cf(%rip), %rdi      # 0xedab
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_variable_part_ast
struct VARIABLE_PART_AST*create_variable_part_ast(void*variable_part_ptr, enum AST_VARIABLE_PART_TYPE type)
{
    struct VARIABLE_PART_AST*variable_part;
    SAFE_MALLOC(variable_part, 1);
    switch (type) {
    case AST_VARIABLE_PART_TYPE_FIELD:
        variable_part->field = variable_part_ptr;
        break;
    case AST_VARIABLE_PART_TYPE_INDEX:
        variable_part->index = variable_part_ptr;
        break;
    default:
        fprintf(stderr, "Invalid VARIABLE_EXPR_AST type: %d\n", type);
        exit(EXIT_FAILURE);
        break;        
    }
    variable_part->type = type;
    return variable_part;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6a18
cmpl $0x2, %ebx
jae 0x6a42
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf5d1(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7b95(%rip), %rsi      # 0xe5be
leaq 0x7f88(%rip), %rdx      # 0xe9b8
pushq $0x10
popq %r8
movl $0x2e1, %ecx            # imm = 0x2E1
xorl %eax, %eax
callq 0x1100
jmp 0x6a5c
movq 0xf5a7(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7f91(%rip), %rsi      # 0xe9e4
movl %ebx, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_variable_part_ast_to_file_inner
static void dump_variable_part_ast_to_file_inner(FILE*f, const struct VARIABLE_PART_AST*ast, size_t spaces_num)
{
    switch (ast->type) {
    case AST_VARIABLE_PART_TYPE_FIELD:
        PUT_SPACES(); fprintf(f, "<field>\n");
        INC_SPACES_NUM();
        dump_ident_ast_to_file_inner(f, ast->field, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</field>\n");
        break;
    case AST_VARIABLE_PART_TYPE_INDEX:
        PUT_SPACES(); fprintf(f, "<index>\n");
        INC_SPACES_NUM();
        dump_logical_or_expr_ast_to_file_inner(f, ast->index, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</index>\n");
        break;
    default:
        fprintf(stderr, "Invalid VARIABLE_PART_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;        
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %edx
cmpl $0x1, %edx
je 0x6ad1
testl %edx, %edx
jne 0x6b4b
leaq 0x7fc5(%rip), %rsi      # 0xea52
leaq 0x7772(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x8313(%rip), %rdi      # 0xedbb
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x2, %rdx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x84b7
leaq 0x82f5(%rip), %r15      # 0xedc4
jmp 0x6b1a
leaq 0x7f7a(%rip), %rsi      # 0xea52
leaq 0x7727(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x82db(%rip), %rdi      # 0xedce
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x2, %rdx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7326
leaq 0x82bd(%rip), %r15      # 0xedd7
leaq 0x7f31(%rip), %rsi      # 0xea52
leaq 0x76de(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
movq 0xf49e(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7eac(%rip), %rsi      # 0xea08
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: variable_part_ast_free
void variable_part_ast_free(struct VARIABLE_PART_AST*ast)
{
    switch (ast->type) {
    case AST_VARIABLE_PART_TYPE_FIELD:
        ident_ast_free(ast->field);
        break;
    case AST_VARIABLE_PART_TYPE_INDEX:
        logical_or_expr_ast_free(ast->index);
        break;
    default:
        fprintf(stderr, "Invalid VARIABLE_PART_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl $0x1, %edx
je 0x6b85
testl %edx, %edx
jne 0x6b96
movq (%rbx), %rdi
callq 0x1030
jmp 0x6b8d
movq (%rbx), %rdi
callq 0x6424
movq %rbx, %rdi
popq %rbx
jmp 0x1030
movq 0xf453(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7e61(%rip), %rsi      # 0xea08
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_variable_ast
struct VARIABLE_AST*create_variable_ast(struct IDENT_AST*ident, struct VARIABLE_PART_AST**parts, size_t parts_len,
                                        size_t line, size_t pos)
{
    struct VARIABLE_AST*variable;
    SAFE_MALLOC(variable, 1);
    variable->ident = ident;
    variable->parts = parts;
    variable->parts_len = parts_len;

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

// 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
pushq $0x28
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6bf8
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
movq 0xf3f1(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x79b5(%rip), %rsi      # 0xe5be
leaq 0x7da8(%rip), %rdx      # 0xe9b8
pushq $0x28
popq %r8
movl $0x324, %ecx            # imm = 0x324
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_variable_ast_to_file_inner
static void dump_variable_ast_to_file_inner(FILE*f, const struct VARIABLE_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<variable line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    for (i = 0; i < ast->parts_len; i++) {
        dump_variable_part_ast_to_file_inner(f, ast->parts[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</variable>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7e0d(%rip), %rsi      # 0xea52
leaq 0x75ba(%rip), %rcx      # 0xe206
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x817c(%rip), %rsi      # 0xede1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x84b7
cmpq 0x10(%r15), %r13
jae 0x6ca2
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x6a68
incq %r13
jmp 0x6c84
leaq 0x7da9(%rip), %rsi      # 0xea52
leaq 0x7556(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x813e(%rip), %rdi      # 0xee02
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_assignment_expr_ast
struct ASSIGNMENT_EXPR_AST*create_assignment_expr_ast(void*assignment_ptr, enum AST_ASSIGNMENT_EXPR_TYPE type)
{
    struct ASSIGNMENT_EXPR_AST*assignment_expr;
    SAFE_MALLOC(assignment_expr, 1);
    switch (type) {
    case AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL:
        assignment_expr->object_literal = assignment_ptr;
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL:
        assignment_expr->array_literal = assignment_ptr;
        break;        
    case AST_ASSIGNMENT_EXPR_TYPE_LOGICAL_OR_EXPR:
        assignment_expr->logical_or_expr = assignment_ptr;
        break;
    default:
        fprintf(stderr, "Invalid ASSIGNMENT_EXPR_AST type: %d\n", type);
        exit(EXIT_FAILURE);
        break;
    }
    assignment_expr->type = type;
    return assignment_expr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6d04
cmpl $0x3, %ebx
jae 0x6d2e
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf2e5(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x78a9(%rip), %rsi      # 0xe5be
leaq 0x7c9c(%rip), %rdx      # 0xe9b8
pushq $0x10
popq %r8
movl $0x350, %ecx            # imm = 0x350
xorl %eax, %eax
callq 0x1100
jmp 0x6d48
movq 0xf2bb(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7ced(%rip), %rsi      # 0xea2c
movl %ebx, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_assignment_expr_ast_to_file_inner
static void dump_assignment_expr_ast_to_file_inner(FILE*f, const struct ASSIGNMENT_EXPR_AST*ast, size_t spaces_num)
{
    switch (ast->type) {
    case AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL:
        dump_object_literal_ast_to_file_inner(f, ast->object_literal, spaces_num);
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL:
        dump_array_literal_ast_to_file_inner(f, ast->array_literal, spaces_num);
        break;        
    case AST_ASSIGNMENT_EXPR_TYPE_LOGICAL_OR_EXPR:
        dump_logical_or_expr_ast_to_file_inner(f, ast->logical_or_expr, spaces_num);
        break;
    default:
        fprintf(stderr, "Invalid ASSIGNMENT_EXPR_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);        
        break;
    }
}

// Assembly:
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
je 0x6d75
cmpl $0x1, %eax
je 0x6d6d
testl %eax, %eax
jne 0x6d7d
movq (%rsi), %rsi
jmp 0x6e5f
movq (%rsi), %rsi
jmp 0x7152
movq (%rsi), %rsi
jmp 0x7326
pushq %rax
movq 0xf26b(%rip), %rcx      # 0x15ff0
movq (%rcx), %rdi
leaq 0x7c9d(%rip), %rsi      # 0xea2c
movl %eax, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: object_literal_ast_free
void object_literal_ast_free(struct OBJECT_LITERAL_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->properties_len; i++) {
        property_ast_free(ast->properties[i]);
    }
    SAFE_FREE(ast->properties);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r14
jae 0x6dc1
movq (%rdi,%r14,8), %rdi
callq 0x6eff
incq %r14
jmp 0x6daa
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_object_literal_ast
struct OBJECT_LITERAL_AST*create_object_literal_ast(struct PROPERTY_AST**properties, size_t properties_len,
                                                    size_t line, size_t pos)
{
    struct OBJECT_LITERAL_AST*object_literal;
    SAFE_MALLOC(object_literal, 1);
    object_literal->properties = properties;
    object_literal->properties_len = properties_len;

    object_literal->line = line;
    object_literal->pos = pos;

    return object_literal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6e2b
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
movq 0xf1be(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7782(%rip), %rsi      # 0xe5be
leaq 0x7b75(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x398, %ecx            # imm = 0x398
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_object_literal_ast_to_file_inner
static void dump_object_literal_ast_to_file_inner(FILE*f, const struct OBJECT_LITERAL_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<object_literal line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    for (i = 0; i < ast->properties_len; i++) {
        dump_property_ast_to_file_inner(f, ast->properties[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</object_literal>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7bda(%rip), %rsi      # 0xea52
leaq 0x7387(%rip), %rcx      # 0xe206
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x7f77(%rip), %rsi      # 0xee0f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
cmpq 0x8(%r15), %r13
jae 0x6ec6
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x6f8d
incq %r13
jmp 0x6ea9
leaq 0x7b85(%rip), %rsi      # 0xea52
leaq 0x7332(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7f4e(%rip), %rdi      # 0xee36
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_property_ast
struct PROPERTY_AST*create_property_ast(struct IDENT_AST*key, struct ASSIGNMENT_EXPR_AST*value,
                                        size_t line, size_t pos)
{
    struct PROPERTY_AST*property;
    SAFE_MALLOC(property, 1);
    property->key = key;
    property->value = value;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x6f59
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
movq 0xf090(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7654(%rip), %rsi      # 0xe5be
leaq 0x7a47(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x3c4, %ecx            # imm = 0x3C4
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_property_ast_to_file_inner
static void dump_property_ast_to_file_inner(FILE*f, const struct PROPERTY_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<property line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "<key>\n");
    INC_SPACES_NUM();
    dump_ident_ast_to_file_inner(f, ast->key, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</key>\n");

    PUT_SPACES(); fprintf(f, "<value>\n");
    INC_SPACES_NUM();
    dump_assignment_expr_ast_to_file_inner(f, ast->value, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</value>\n");
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</property>\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x7aaa(%rip), %r14      # 0xea52
leaq 0x7257(%rip), %rbp      # 0xe206
movq %r14, %rsi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x7e7e(%rip), %rsi      # 0xee49
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leal 0x2(%r12), %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7e76(%rip), %rdi      # 0xee6a
pushq $0x6
popq %rsi
pushq $0x1
popq %rbp
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1190
movq %r12, %r14
addq $0x4, %r14
movq (%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x84b7
movq %rbx, %rdi
leaq 0x7a2d(%rip), %rsi      # 0xea52
movl %r15d, %edx
leaq 0x71d7(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
leaq 0x7e34(%rip), %rdi      # 0xee71
pushq $0x7
popq %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
leaq 0x79fd(%rip), %rsi      # 0xea52
movl %r15d, %edx
leaq 0x71a7(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
leaq 0x7e0c(%rip), %rdi      # 0xee79
pushq $0x8
popq %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6d54
movq %rbx, %rdi
leaq 0x79be(%rip), %r13      # 0xea52
movq %r13, %rsi
movl %r15d, %edx
leaq 0x7165(%rip), %r14      # 0xe206
movq %r14, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7dd0(%rip), %rdi      # 0xee82
pushq $0x9
popq %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7db2(%rip), %rdi      # 0xee8c
pushq $0xc
popq %rsi
movq %rbp, %rdx
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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_array_literal_ast
struct ARRAY_LITERAL_AST*create_array_literal_ast(struct ARGS_LIST_AST*args_list,
                                                  size_t line, size_t pos)
{
    struct ARRAY_LITERAL_AST*array_literal;
    SAFE_MALLOC(array_literal, 1);
    array_literal->args_list = args_list;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x7122
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xeec7(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x748b(%rip), %rsi      # 0xe5be
leaq 0x787e(%rip), %rdx      # 0xe9b8
pushq $0x18
popq %r8
movl $0x3f1, %ecx            # imm = 0x3F1
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_array_literal_ast_to_file_inner
void dump_array_literal_ast_to_file_inner(FILE*f, const struct ARRAY_LITERAL_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<array_literal line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    if (ast->args_list != NULL) {
        dump_args_list_ast_to_file_inner(f, ast->args_list, spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</array_literal>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x78eb(%rip), %rsi      # 0xea52
leaq 0x7098(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
leaq 0x78d2(%rip), %rsi      # 0xea56
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %rsi
testq %rsi, %rsi
je 0x71a5
movq %r14, %rdx
addq $0x2, %rdx
movq %rbx, %rdi
callq 0x71da
leaq 0x78a6(%rip), %rsi      # 0xea52
leaq 0x7053(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x78b5(%rip), %rdi      # 0xea7c
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_args_list_ast_to_file_inner
static void dump_args_list_ast_to_file_inner(FILE*f, const struct ARGS_LIST_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<args_list line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    for (i = 0; i < ast->assignment_exprs_len; i++) {
        dump_assignment_expr_ast_to_file_inner(f, ast->assignment_exprs[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</args_list>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x785f(%rip), %rsi      # 0xea52
leaq 0x700c(%rip), %rcx      # 0xe206
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x7f91(%rip), %rsi      # 0xf1a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
cmpq 0x8(%r15), %r13
jae 0x7241
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x6d54
incq %r13
jmp 0x7224
leaq 0x780a(%rip), %rsi      # 0xea52
leaq 0x6fb7(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7f63(%rip), %rdi      # 0xf1c6
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: args_list_ast_free
void args_list_ast_free(struct ARGS_LIST_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->assignment_exprs_len; i++) {
        assignment_expr_ast_free(ast->assignment_exprs[i]);
    }
    SAFE_FREE(ast->assignment_exprs);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r14
jae 0x72a2
movq (%rdi,%r14,8), %rdi
callq 0x5ef7
incq %r14
jmp 0x728b
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_logical_or_expr_ast
struct LOGICAL_OR_EXPR_AST*create_logical_or_expr_ast(struct LOGICAL_AND_EXPR_AST**and_exprs, size_t and_exprs_len,
                                                      size_t line, size_t pos)
{
    struct LOGICAL_OR_EXPR_AST*logical_or_expr;
    SAFE_MALLOC(logical_or_expr, 1);
    logical_or_expr->and_exprs = and_exprs;
    logical_or_expr->and_exprs_len = and_exprs_len;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x72f2
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
movq 0xecf7(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x72bb(%rip), %rsi      # 0xe5be
leaq 0x76ae(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x418, %ecx            # imm = 0x418
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_logical_or_expr_ast_to_file_inner
static void dump_logical_or_expr_ast_to_file_inner(FILE*f, const struct LOGICAL_OR_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->and_exprs_len == 1) {
        dump_logical_and_expr_ast_to_file_inner(f, ast->and_exprs[0], spaces_num);
    } else {
        size_t i;
        
        PUT_SPACES(); fprintf(f, "<logical_or_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        dump_logical_and_expr_ast_to_file_inner(f, ast->and_exprs[0], spaces_num);
        for (i = 1; i < ast->and_exprs_len; i++) {
            PUT_SPACES(); fprintf(f, "<op>OR</op>\n");
            dump_logical_and_expr_ast_to_file_inner(f, ast->and_exprs[i], spaces_num);
        }
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</logical_or_expr>\n");        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x8(%rsi)
jne 0x7360
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74e7
leaq 0x76eb(%rip), %rsi      # 0xea52
leaq 0x6e98(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x7b10(%rip), %rsi      # 0xee99
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %rbp, (%rsp)
addq $0x2, %rbp
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x74e7
pushq $0x1
popq %r12
pushq $0xc
popq %r13
movq %r12, %r14
cmpq 0x8(%r15), %r14
jae 0x7403
movq %rbx, %rdi
leaq 0x768b(%rip), %rsi      # 0xea52
movl %ebp, %edx
leaq 0x6e36(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
leaq 0x7ae3(%rip), %rdi      # 0xeec1
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x74e7
incq %r14
jmp 0x73b7
leaq 0x7648(%rip), %rsi      # 0xea52
leaq 0x6df5(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x7aa8(%rip), %rdi      # 0xeece
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: logical_and_expr_ast_free
void logical_and_expr_ast_free(struct LOGICAL_AND_EXPR_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->eq_exprs_len; i++) {
        eq_expr_ast_free(ast->eq_exprs[i]);
    }
    SAFE_FREE(ast->eq_exprs);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r14
jae 0x7463
movq (%rdi,%r14,8), %rdi
callq 0x7603
incq %r14
jmp 0x744c
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_logical_and_expr_ast
struct LOGICAL_AND_EXPR_AST*create_logical_and_expr_ast(struct EQ_EXPR_AST**eq_exprs, size_t eq_exprs_len,
                                                        size_t line, size_t pos)
{
    struct LOGICAL_AND_EXPR_AST*logical_and_expr;
    SAFE_MALLOC(logical_and_expr, 1);
    logical_and_expr->eq_exprs = eq_exprs;
    logical_and_expr->eq_exprs_len = eq_exprs_len;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x74b3
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
movq 0xeb36(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x70fa(%rip), %rsi      # 0xe5be
leaq 0x74ed(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x44a, %ecx            # imm = 0x44A
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_logical_and_expr_ast_to_file_inner
static void dump_logical_and_expr_ast_to_file_inner(FILE*f, const struct LOGICAL_AND_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->eq_exprs_len == 1) {
        dump_eq_expr_ast_to_file_inner(f, ast->eq_exprs[0], spaces_num);
    } else {
        size_t i;
        
        PUT_SPACES(); fprintf(f, "<logical_and_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        dump_eq_expr_ast_to_file_inner(f, ast->eq_exprs[0], spaces_num);
        for (i = 1; i < ast->eq_exprs_len; i++) {
            PUT_SPACES(); fprintf(f, "<op>AND</op>\n");
            dump_eq_expr_ast_to_file_inner(f, ast->eq_exprs[i], spaces_num);
        }
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</logical_and_expr>\n");        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x8(%rsi)
jne 0x7521
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7698
leaq 0x752a(%rip), %rsi      # 0xea52
leaq 0x6cd7(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x7998(%rip), %rsi      # 0xeee2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %rbp, (%rsp)
addq $0x2, %rbp
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7698
pushq $0x1
popq %r12
pushq $0xd
popq %r13
movq %r12, %r14
cmpq 0x8(%r15), %r14
jae 0x75c4
movq %rbx, %rdi
leaq 0x74ca(%rip), %rsi      # 0xea52
movl %ebp, %edx
leaq 0x6c75(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
leaq 0x796c(%rip), %rdi      # 0xef0b
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7698
incq %r14
jmp 0x7578
leaq 0x7487(%rip), %rsi      # 0xea52
leaq 0x6c34(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x7932(%rip), %rdi      # 0xef19
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: eq_expr_ast_free
void eq_expr_ast_free(struct EQ_EXPR_AST*ast)
{
    relational_expr_ast_free(ast->left);
    if (ast->right != NULL) {
        relational_expr_ast_free(ast->right);
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x77bf
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x761d
callq 0x77bf
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_eq_expr_ast
struct EQ_EXPR_AST*create_eq_expr_ast(struct RELATIONAL_EXPR_AST*left,
                                      enum AST_EQ_OP eq_op,
                                      struct RELATIONAL_EXPR_AST*right,
                                      size_t line, size_t pos)
{
    struct EQ_EXPR_AST*eq_expr;
    SAFE_MALLOC(eq_expr, 1);
    eq_expr->left = left;
    eq_expr->eq_op = eq_op;
    eq_expr->right = right;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
pushq $0x28
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x7664
movq %r12, (%rax)
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xe985(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6f49(%rip), %rsi      # 0xe5be
leaq 0x733c(%rip), %rdx      # 0xe9b8
pushq $0x28
popq %r8
movl $0x47e, %ecx            # imm = 0x47E
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180