LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7759(%rip), %rbp      # 0xfa46
leaq 0x6f15(%rip), %r13      # 0xf209
movq %rbp, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x77a6(%rip), %rsi      # 0xfab6
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 0x7791(%rip), %rsi      # 0xfad7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %r13
leal 0x4(%r14), %edx
movq %rbx, %rdi
leaq 0x76e5(%rip), %rsi      # 0xfa46
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x7e4e(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
leaq 0x76b5(%rip), %rsi      # 0xfa46
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7758(%rip), %rdi      # 0xfafd
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x83cb
movq %rbx, %rdi
movq %r12, %rdx
callq 0x84f0
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x861b
leaq 0x7665(%rip), %rsi      # 0xfa46
leaq 0x6e21(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7713(%rip), %rdi      # 0xfb0f
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_O1/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 0x8447
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x8432
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x848b
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x86c4
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x8476
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x84e7
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 0x1d7d
// File: /workspace/github_c_makefile_star2_O1/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 0x753e(%rip), %rsi      # 0xfa46
leaq 0x6cfa(%rip), %rcx      # 0xf209
movq %rdx, (%rsp)
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x75f3(%rip), %rsi      # 0xfb1c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x8591
movq (%rsp), %rax
movl %eax, %ebp
addl $0x2, %ebp
leaq 0x7c7e(%rip), %r14      # 0x101c8
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %r12
movq %rbx, %rdi
leaq 0x74e8(%rip), %rsi      # 0xfa46
movl %ebp, %edx
leaq 0x6ca2(%rip), %rcx      # 0xf209
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 0x854d
leaq 0x74ae(%rip), %rsi      # 0xfa46
leaq 0x6c6a(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x7597(%rip), %rdi      # 0xfb4b
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_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_body_ast
struct BODY_AST*create_body_ast(struct STMT_AST**stmts, size_t stmts_len,
                                size_t line, size_t pos)
{
    struct BODY_AST*body;
    SAFE_MALLOC(body, 1);
    body->stmts = stmts;
    body->stmts_len = stmts_len;

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

// Assembly:
pushq %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 0x8612
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 0x1dac
// File: /workspace/github_c_makefile_star2_O1/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 0x7412(%rip), %rsi      # 0xfa46
leaq 0x6bce(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x7515(%rip), %rsi      # 0xfb66
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x8687
movq %r14, %r12
addq $0x2, %r12
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8791
incq %r13
cmpq 0x8(%r15), %r13
jb 0x866c
leaq 0x73b8(%rip), %rsi      # 0xfa46
leaq 0x6b74(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x74da(%rip), %rdi      # 0xfb83
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_O1/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 0x8751
leaq 0x7241(%rip), %rax      # 0xf91c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rbx), %rdi
jmp 0x8715
movq (%rbx), %rdi
callq 0x8950
jmp 0x8742
movq (%rbx), %rdi
callq 0x88ec
jmp 0x8742
movq (%rbx), %rdi
callq 0x8914
jmp 0x8742
movq (%rbx), %r14
movq (%r14), %rdi
callq 0x8d1a
movq %r14, %rdi
callq 0x1030
jmp 0x8742
movq (%rbx), %rdi
callq 0x88c0
jmp 0x8742
movq (%rbx), %rdi
callq 0x886f
jmp 0x8742
movq (%rbx), %rdi
callq 0x888d
jmp 0x8742
movq (%rbx), %rdi
callq 0x8932
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
callq 0x1ddd
// File: /workspace/github_c_makefile_star2_O1/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 0x886a
leaq 0x719b(%rip), %rax      # 0xf944
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x89b1
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8ffe
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x9419
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8c8c
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8d8a
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x9207
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8b34
leaq 0x7239(%rip), %rsi      # 0xfa46
leaq 0x69f5(%rip), %rcx      # 0xf209
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x74c5(%rip), %rdi      # 0xfcea
movl $0x10, %esi
jmp 0x8850
leaq 0x7213(%rip), %rsi      # 0xfa46
leaq 0x69cf(%rip), %rcx      # 0xf209
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x74b0(%rip), %rdi      # 0xfcfb
movl $0x16, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x1190
movq (%rsi), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x9318
callq 0x1e54
// File: /workspace/github_c_makefile_star2_O1/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 0x8f73
movq 0x8(%rbx), %rdi
callq 0x8465
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x88e3
callq 0x8465
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x707a(%rip), %r12      # 0xfa46
leaq 0x6836(%rip), %rcx      # 0xf209
movq %r12, %rsi
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x71a0(%rip), %rsi      # 0xfb8c
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 0x67f9(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rcx
leaq 0x77a2(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
leaq 0x67c7(%rip), %r15      # 0xf209
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x715b(%rip), %rdi      # 0xfbae
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x97a5
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x712d(%rip), %rdi      # 0xfbbb
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_O1/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 0x8ad7
cmpl $0x1, %edi
je 0x8acd
testl %edi, %edi
jne 0x8ae8
movq (%rbx), %rdi
callq 0x97d6
jmp 0x8adf
movq (%rbx), %rdi
callq 0x981a
jmp 0x8adf
movq (%rbx), %rdi
callq 0x8f73
movq %rbx, %rdi
popq %rbx
jmp 0x1030
callq 0x1ea8
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_assign_stmt_ast
struct ASSIGN_STMT_AST*create_assign_stmt_ast(struct VARIABLE_AST*var_name,
                                              struct ASSIGNMENT_EXPR_AST*assignment,
                                              size_t line, size_t pos)
{
    struct ASSIGN_STMT_AST*assign_stmt;
    SAFE_MALLOC(assign_stmt, 1);
    assign_stmt->var_name = var_name;
    assign_stmt->assignment = assignment;

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

// Assembly:
pushq %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 0x8b2b
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 0x1ecb
// File: /workspace/github_c_makefile_star2_O1/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 0x6ef7(%rip), %r12      # 0xfa46
leaq 0x66b3(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x7057(%rip), %rsi      # 0xfbc9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x9680
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7003(%rip), %rdi      # 0xfbae
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x97a5
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7007(%rip), %rdi      # 0xfbed
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_O1/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 0x8c35
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9603
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x8c1f
movq 0x8(%rbx), %rdi
callq 0x1030
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x8c83
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x1efc
// File: /workspace/github_c_makefile_star2_O1/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 0x6da1(%rip), %r12      # 0xfa46
leaq 0x655d(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
leaq 0x6f35(%rip), %rsi      # 0xfbfd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdx
addq $0x2, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0xabba
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6f29(%rip), %rdi      # 0xfc28
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_O1/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 0x8d34
callq 0x9c8c
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x8d81
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 0x1f2d
// File: /workspace/github_c_makefile_star2_O1/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 0x8f99
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9e43
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x8f84
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x6a2d(%rip), %r12      # 0xfa46
leaq 0x61e9(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6c7c(%rip), %rsi      # 0xfcb8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x2(%r14), %rbp
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6bfc(%rip), %rdi      # 0xfc5f
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x4, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x9d17
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6bcb(%rip), %rdi      # 0xfc6c
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x861b
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6bff(%rip), %rdi      # 0xfcdb
movl $0xe, %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_O1/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
movl $0x10, %edi
callq 0x1130
testq %rax, %rax
je 0x9124
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f8f
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x1130
testq %rax, %rax
je 0x9186
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1fc0
// File: /workspace/github_c_makefile_star2_O1/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 0x6824(%rip), %r12      # 0xfa46
leaq 0x5fe0(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6acd(%rip), %rsi      # 0xfd12
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x9680
movq 0x8(%r13), %r13
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x6f3e(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6a85(%rip), %rdi      # 0xfd36
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_O1/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 0x6713(%rip), %r12      # 0xfa46
leaq 0x5ecf(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x69f0(%rip), %rsi      # 0xfd46
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x9680
movq 0x8(%r13), %r13
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x6e2d(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x69a8(%rip), %rdi      # 0xfd6a
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_O1/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
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0x9410
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x2053
// File: /workspace/github_c_makefile_star2_O1/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 0x6618(%rip), %rsi      # 0xfa46
leaq 0x5dd4(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
leaq 0x692f(%rip), %rsi      # 0xfd7a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %rsi
testq %rsi, %rsi
je 0x946c
movq %r14, %rdx
addq $0x2, %rdx
movq %rbx, %rdi
callq 0x97a5
leaq 0x65d3(%rip), %rsi      # 0xfa46
leaq 0x5d8f(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6911(%rip), %rdi      # 0xfd9f
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x1130
testq %rax, %rax
je 0x94d0
cmpl $0x2, %ebx
jae 0x94d5
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20a7
movl %ebx, %edi
callq 0x2084
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %edi
cmpl $0x1, %edi
je 0x9578
testl %edi, %edi
jne 0x95fe
leaq 0x653d(%rip), %r12      # 0xfa46
leaq 0x5cf9(%rip), %r13      # 0xf209
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6885(%rip), %rdi      # 0xfdaf
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq (%r15), %r15
leal 0x2(%r14), %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rcx
leaq 0x6c66(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
leaq 0x6842(%rip), %r15      # 0xfdb8
jmp 0x95c5
leaq 0x64c7(%rip), %rsi      # 0xfa46
leaq 0x5c83(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6828(%rip), %rdi      # 0xfdc2
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x2, %rdx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x9d17
leaq 0x6806(%rip), %r15      # 0xfdcb
leaq 0x647a(%rip), %rsi      # 0xfa46
leaq 0x5c36(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movl $0x9, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
callq 0x20d8
// File: /workspace/github_c_makefile_star2_O1/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), %edi
cmpl $0x1, %edi
je 0x961d
testl %edi, %edi
jne 0x962e
movq (%rbx), %rdi
callq 0x1030
jmp 0x9625
movq (%rbx), %rdi
callq 0x8f73
movq %rbx, %rdi
popq %rbx
jmp 0x1030
callq 0x20fb
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x63ab(%rip), %r13      # 0xfa46
leaq 0x5b67(%rip), %rcx      # 0xf209
movq %r13, %rsi
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x671a(%rip), %rsi      # 0xfdd5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rbp
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
leaq 0x5b2a(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x20(%rbp), %rdx
movq 0x28(%rbp), %rcx
leaq 0x6ad3(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %rbp, %r8
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x10(%r15)
je 0x9728
xorl %r13d, %r13d
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x94e0
incq %r13
cmpq 0x10(%r15), %r13
jb 0x970c
leaq 0x6317(%rip), %rsi      # 0xfa46
leaq 0x5ad3(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x66ac(%rip), %rdi      # 0xfdf6
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_O1/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
cmpq $0x0, 0x8(%rdi)
je 0x97fc
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9924
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x97e7
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x61b2(%rip), %rsi      # 0xfa46
leaq 0x596e(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6552(%rip), %rsi      # 0xfe03
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x98e7
movq %r14, %r12
addq $0x2, %r12
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9989
incq %r13
cmpq 0x8(%r15), %r13
jb 0x98cc
leaq 0x6158(%rip), %rsi      # 0xfa46
leaq 0x5914(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6521(%rip), %rdi      # 0xfe2a
movl $0x12, %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_O1/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 %rsi, %r13
movq %rdi, %rbx
leaq 0x60a5(%rip), %r14      # 0xfa46
leaq 0x5861(%rip), %r12      # 0xf209
movq %r14, %rsi
movq %rdx, %r15
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6476(%rip), %rsi      # 0xfe3d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leal 0x2(%r15), %ebp
movq %r15, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x646c(%rip), %rdi      # 0xfe5e
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %r15, %r14
addq $0x4, %r14
movq (%r13), %r12
movq %rbx, %rdi
leaq 0x602d(%rip), %r15      # 0xfa46
movq %r15, %rsi
movl %r14d, %edx
leaq 0x57e3(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
leaq 0x678a(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
leaq 0x57af(%rip), %r12      # 0xf209
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x63fa(%rip), %rdi      # 0xfe65
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x63d7(%rip), %rdi      # 0xfe6d
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x97a5
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x63a6(%rip), %rdi      # 0xfe76
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6383(%rip), %rdi      # 0xfe80
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_O1/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
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0x9b4b
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x2228
// File: /workspace/github_c_makefile_star2_O1/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 0x5ee1(%rip), %rsi      # 0xfa46
leaq 0x569d(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
leaq 0x5ec8(%rip), %rsi      # 0xfa4a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %rsi
testq %rsi, %rsi
je 0x9ba3
movq %r14, %rdx
addq $0x2, %rdx
movq %rbx, %rdi
callq 0x9bdc
leaq 0x5e9c(%rip), %rsi      # 0xfa46
leaq 0x5658(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x5eab(%rip), %rdi      # 0xfa70
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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 0x5e51(%rip), %rsi      # 0xfa46
leaq 0x560d(%rip), %rcx      # 0xf209
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6586(%rip), %rsi      # 0x10198
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x9c48
movq %r14, %r12
addq $0x2, %r12
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x97a5
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9c2d
leaq 0x5df7(%rip), %rsi      # 0xfa46
leaq 0x55b3(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6550(%rip), %rdi      # 0x101ba
movl $0xd, %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_O1/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
cmpq $0x0, 0x8(%rdi)
je 0x9cb2
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8aae
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x9c9d
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030