LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x6dd7(%rip), %r12      # 0xfa52
leaq 0x6584(%rip), %r15      # 0xf206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x7026(%rip), %rsi      # 0xfcc4
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 0x6fa6(%rip), %rdi      # 0xfc6b
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x4, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x996b
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6f75(%rip), %rdi      # 0xfc78
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x828c
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6fa9(%rip), %rdi      # 0xfce7
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_O3/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 0x8d86
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1fad
// File: /workspace/github_c_makefile_star2_O3/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 0x8de8
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1fde
// File: /workspace/github_c_makefile_star2_O3/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 0x6bce(%rip), %r12      # 0xfa52
leaq 0x637b(%rip), %r15      # 0xf206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6e77(%rip), %rsi      # 0xfd1e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x92e2
movq 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 0x72e8(%rip), %rsi      # 0x101d4
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 0x6e2f(%rip), %rdi      # 0xfd42
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0x6abd(%rip), %r12      # 0xfa52
leaq 0x626a(%rip), %r15      # 0xf206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6d9a(%rip), %rsi      # 0xfd52
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x92e2
movq 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 0x71d7(%rip), %rsi      # 0x101d4
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 0x6d52(%rip), %rdi      # 0xfd76
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0x9072
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x2071
// File: /workspace/github_c_makefile_star2_O3/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 0x69c2(%rip), %rsi      # 0xfa52
leaq 0x616f(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
leaq 0x6cd9(%rip), %rsi      # 0xfd86
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %rsi
testq %rsi, %rsi
je 0x90ce
movq %r14, %rdx
addq $0x2, %rdx
movq %rbx, %rdi
callq 0x9407
leaq 0x697d(%rip), %rsi      # 0xfa52
leaq 0x612a(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6cbb(%rip), %rdi      # 0xfdab
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 0x9132
cmpl $0x2, %ebx
jae 0x9137
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20c5
movl %ebx, %edi
callq 0x20a2
// File: /workspace/github_c_makefile_star2_O3/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 0x91da
testl %edi, %edi
jne 0x9260
leaq 0x68e7(%rip), %r12      # 0xfa52
leaq 0x6094(%rip), %r13      # 0xf206
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6c2f(%rip), %rdi      # 0xfdbb
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 0x7010(%rip), %rsi      # 0x101d4
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
leaq 0x6bec(%rip), %r15      # 0xfdc4
jmp 0x9227
leaq 0x6871(%rip), %rsi      # 0xfa52
leaq 0x601e(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6bd2(%rip), %rdi      # 0xfdce
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdx
addq $0x2, %rdx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x996b
leaq 0x6bb0(%rip), %r15      # 0xfdd7
leaq 0x6824(%rip), %rsi      # 0xfa52
leaq 0x5fd1(%rip), %rcx      # 0xf206
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 0x20f6
// File: /workspace/github_c_makefile_star2_O3/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 0x927f
testl %edi, %edi
jne 0x9290
movq (%rbx), %rdi
callq 0x1030
jmp 0x9287
movq (%rbx), %rdi
callq 0x8bdc
movq %rbx, %rdi
popq %rbx
jmp 0x1030
callq 0x2119
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x28, %edi
callq 0x1130
testq %rax, %rax
je 0x92d9
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 0x213c
// File: /workspace/github_c_makefile_star2_O3/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 0x6755(%rip), %r13      # 0xfa52
leaq 0x5f02(%rip), %rcx      # 0xf206
movq %r13, %rsi
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x6ac4(%rip), %rsi      # 0xfde1
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 0x5ec5(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x20(%rbp), %rdx
movq 0x28(%rbp), %rcx
leaq 0x6e7d(%rip), %rsi      # 0x101d4
movq %rbx, %rdi
movq %rbp, %r8
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x10(%r15)
je 0x938a
xorl %r13d, %r13d
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9142
incq %r13
cmpq 0x10(%r15), %r13
jb 0x936e
leaq 0x66c1(%rip), %rsi      # 0xfa52
leaq 0x5e6e(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6a56(%rip), %rdi      # 0xfe02
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0x945e
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x957f
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x9449
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0x6563(%rip), %rsi      # 0xfa52
leaq 0x5d10(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6903(%rip), %rsi      # 0xfe0f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x9542
movq %r14, %r12
addq $0x2, %r12
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x95e4
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9527
leaq 0x6509(%rip), %rsi      # 0xfa52
leaq 0x5cb6(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x68d2(%rip), %rdi      # 0xfe36
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_O3/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 0x6456(%rip), %r14      # 0xfa52
leaq 0x5c03(%rip), %r12      # 0xf206
movq %r14, %rsi
movq %rdx, %r15
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6827(%rip), %rsi      # 0xfe49
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 0x681d(%rip), %rdi      # 0xfe6a
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq %r15, %r14
addq $0x4, %r14
movq (%r13), %r12
movq %rbx, %rdi
leaq 0x63de(%rip), %r15      # 0xfa52
movq %r15, %rsi
movl %r14d, %edx
leaq 0x5b85(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
leaq 0x6b3b(%rip), %rsi      # 0x101d4
movq %rbx, %rdi
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
leaq 0x5b51(%rip), %r12      # 0xf206
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x67ab(%rip), %rdi      # 0xfe71
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 0x6788(%rip), %rdi      # 0xfe79
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9407
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6757(%rip), %rdi      # 0xfe82
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 0x6734(%rip), %rdi      # 0xfe8c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0x97a6
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x2246
// File: /workspace/github_c_makefile_star2_O3/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 0x6292(%rip), %rsi      # 0xfa52
leaq 0x5a3f(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
leaq 0x6279(%rip), %rsi      # 0xfa56
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %rsi
testq %rsi, %rsi
je 0x97fe
movq %r14, %rdx
addq $0x2, %rdx
movq %rbx, %rdi
callq 0x9837
leaq 0x624d(%rip), %rsi      # 0xfa52
leaq 0x59fa(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x625c(%rip), %rdi      # 0xfa7c
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/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 0x6202(%rip), %rsi      # 0xfa52
leaq 0x59af(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6937(%rip), %rsi      # 0x101a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
cmpq $0x0, 0x8(%r15)
je 0x98a3
movq %r14, %r12
addq $0x2, %r12
xorl %r13d, %r13d
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9407
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9888
leaq 0x61a8(%rip), %rsi      # 0xfa52
leaq 0x5955(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6901(%rip), %rdi      # 0x101c6
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_O3/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 0x990d
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x871f
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x98f8
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_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
movl $0x20, %edi
callq 0x1130
testq %rax, %rax
je 0x9962
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 0x2277
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x8(%rsi)
jne 0x99a5
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9b1b
leaq 0x60a6(%rip), %rsi      # 0xfa52
leaq 0x5853(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x64ca(%rip), %rsi      # 0xfe99
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r12, (%rsp)
addq $0x2, %r12
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9b1b
cmpq $0x2, 0x8(%r15)
jb 0x9a54
movl $0x1, %r13d
leaq 0x5800(%rip), %rbp      # 0xf206
leaq 0x64b4(%rip), %r14      # 0xfec1
movq %rbx, %rdi
leaq 0x603b(%rip), %rsi      # 0xfa52
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movl $0xc, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9b1b
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9a0d
leaq 0x5ff7(%rip), %rsi      # 0xfa52
leaq 0x57a4(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x6457(%rip), %rdi      # 0xfece
movl $0x13, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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
cmpq $0x0, 0x8(%rdi)
je 0x9abd
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9c47
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x9aa8
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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, %r12
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x8(%rsi)
jne 0x9b55
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9cb3
leaq 0x5ef6(%rip), %rsi      # 0xfa52
leaq 0x56a3(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6363(%rip), %rsi      # 0xfee2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r12, (%rsp)
addq $0x2, %r12
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9cb3
cmpq $0x2, 0x8(%r15)
jb 0x9c04
movl $0x1, %r13d
leaq 0x5650(%rip), %rbp      # 0xf206
leaq 0x634e(%rip), %r14      # 0xff0b
movq %rbx, %rdi
leaq 0x5e8b(%rip), %rsi      # 0xfa52
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movl $0xd, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9cb3
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9bbd
leaq 0x5e47(%rip), %rsi      # 0xfa52
leaq 0x55f4(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x62f2(%rip), %rdi      # 0xff19
movl $0x14, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0x9de5
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9c61
callq 0x9de5
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x28, %edi
callq 0x1130
testq %rax, %rax
je 0x9caa
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
callq 0x22d9
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_eq_expr_ast_to_file_inner
static void dump_eq_expr_ast_to_file_inner(FILE*f, const struct EQ_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->right == NULL) {
        dump_relational_expr_ast_to_file_inner(f, ast->left, spaces_num);
    } else {
        PUT_SPACES(); fprintf(f, "<eq_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        dump_relational_expr_ast_to_file_inner(f, ast->left, spaces_num);
        if (ast->eq_op == AST_EQ_OP_EQEQ) {
            PUT_SPACES(); fprintf(f, "<op>EQEQ</op>\n");
        } else if (ast->eq_op == AST_EQ_OP_NEQ) {
            PUT_SPACES(); fprintf(f, "<op>NEQ</op>\n");
        }
        dump_relational_expr_ast_to_file_inner(f, ast->right, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</eq_expr>\n");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0x9d4a
leaq 0x5d80(%rip), %rsi      # 0xfa52
leaq 0x552d(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x6239(%rip), %rsi      # 0xff2e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9e51
movl 0x8(%r15), %eax
cmpl $0x1, %eax
je 0x9d63
testl %eax, %eax
jne 0x9d97
leaq 0x5d2a(%rip), %rsi      # 0xfa52
leaq 0x54d7(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x620b(%rip), %rdi      # 0xff4e
movl $0xe, %esi
jmp 0x9d8a
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9e51
leaq 0x5ce8(%rip), %rsi      # 0xfa52
leaq 0x5495(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x61d8(%rip), %rdi      # 0xff5d
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9e51
leaq 0x5ca5(%rip), %rsi      # 0xfa52
leaq 0x5452(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x61a3(%rip), %rdi      # 0xff6b
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: relational_expr_ast_free
void relational_expr_ast_free(struct RELATIONAL_EXPR_AST*ast)
{
    additive_expr_ast_free(ast->left);
    if (ast->right != NULL) {
        additive_expr_ast_free(ast->right);
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9f62
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9dff
callq 0x9f62
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_relational_expr_ast
struct RELATIONAL_EXPR_AST*create_relational_expr_ast(struct ADDITIVE_EXPR_AST*left,
                                                      enum AST_REL_OP rel_op,
                                                      struct ADDITIVE_EXPR_AST*right,
                                                      size_t line, size_t pos)
{
    struct RELATIONAL_EXPR_AST*relational_expr;
    SAFE_MALLOC(relational_expr, 1);
    relational_expr->left = left;
    relational_expr->rel_op = rel_op;
    relational_expr->right = right;

    relational_expr->line = line;
    relational_expr->pos = pos;
    
    return relational_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
movl $0x28, %edi
callq 0x1130
testq %rax, %rax
je 0x9e48
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
callq 0x230a
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_relational_expr_ast_to_file_inner
static void dump_relational_expr_ast_to_file_inner(FILE*f, const struct RELATIONAL_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->right == NULL) {
        dump_additive_expr_ast_to_file_inner(f, ast->left, spaces_num);
    } else {
        PUT_SPACES(); fprintf(f, "<relational_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        dump_additive_expr_ast_to_file_inner(f, ast->left, spaces_num);
        if (ast->rel_op == AST_REL_OP_LT) {
            PUT_SPACES(); fprintf(f, "<op>LT</op>\n");
        } else if (ast->rel_op == AST_REL_OP_GT) {
            PUT_SPACES(); fprintf(f, "<op>GT</op>\n");
        } else if (ast->rel_op == AST_REL_OP_LE) {
            PUT_SPACES(); fprintf(f, "<op>LE</op>\n");
        } else if (ast->rel_op == AST_REL_OP_GE) {
            PUT_SPACES(); fprintf(f, "<op>GE</op>\n");
        }
        dump_additive_expr_ast_to_file_inner(f, ast->right, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</relational_expr>\n");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0x9f4b
leaq 0x5bdd(%rip), %rsi      # 0xfa52
leaq 0x538a(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x60df(%rip), %rsi      # 0xff77
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9ffc
movl 0x8(%r15), %eax
cmpq $0x3, %rax
ja 0x9eff
leaq 0x5ad4(%rip), %rcx      # 0xf99c
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
leaq 0x5b7c(%rip), %rsi      # 0xfa52
leaq 0x5329(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movl $0xc, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x1190
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9ffc
leaq 0x5b3d(%rip), %rsi      # 0xfa52
leaq 0x52ea(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x60a3(%rip), %rdi      # 0xffd3
movl $0x13, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9ffc
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: additive_expr_ast_free
void additive_expr_ast_free(struct ADDITIVE_EXPR_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->muls_len; i++) {
        multiplicative_expr_ast_free(ast->muls[i]);
    }
    SAFE_FREE(ast->muls);
    SAFE_FREE(ast->ops);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x9f88
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xa164
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x9f73
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_additive_expr_ast_to_file_inner
static void dump_additive_expr_ast_to_file_inner(FILE*f, const struct ADDITIVE_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->muls_len == 1) {
        dump_multiplicative_expr_ast_to_file_inner(f, ast->muls[0], spaces_num);
    } else {
        size_t i;
        
        PUT_SPACES(); fprintf(f, "<additive_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        dump_multiplicative_expr_ast_to_file_inner(f, ast->muls[0], spaces_num);
        for (i = 1; i < ast->muls_len; i++) {
            if (ast->ops[i - 1] == AST_ADDITIVE_OP_PLUS) {
                PUT_SPACES(); fprintf(f, "<op>PLUS</op>\n");
            } else if (ast->ops[i - 1] == AST_ADDITIVE_OP_MINUS) {
                PUT_SPACES(); fprintf(f, "<op>MINUS</op>\n");
            }
            dump_multiplicative_expr_ast_to_file_inner(f, ast->muls[i], spaces_num);
        }
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</additive_expr>\n");        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x10(%rsi)
jne 0xa036
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa209
leaq 0x5a15(%rip), %rsi      # 0xfa52
leaq 0x51c2(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x5f87(%rip), %rsi      # 0xffe7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r12, (%rsp)
addq $0x2, %r12
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa209
cmpq $0x2, 0x10(%r15)
jb 0xa121
movl $0x1, %r14d
leaq 0x59b7(%rip), %r13      # 0xfa52
leaq 0x5164(%rip), %rbp      # 0xf206
movq 0x8(%r15), %rax
movl -0x4(%rax,%r14,4), %eax
cmpl $0x1, %eax
je 0xa0da
testl %eax, %eax
jne 0xa106
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movl $0xe, %esi
movl $0x1, %edx
leaq 0x5f35(%rip), %rdi      # 0x1000d
jmp 0xa0fe
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movl $0xf, %esi
movl $0x1, %edx
leaq 0x5f1e(%rip), %rdi      # 0x1001c
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa209
incq %r14
cmpq 0x10(%r15), %r14
jb 0xa0a2
leaq 0x592a(%rip), %rsi      # 0xfa52
leaq 0x50d7(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x5ee8(%rip), %rdi      # 0x1002c
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: multiplicative_expr_ast_free
void multiplicative_expr_ast_free(struct MULTIPLICATIVE_EXPR_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->lues_len; i++) {
        left_unary_expr_ast_free(ast->lues[i]);
    }
    SAFE_FREE(ast->lues);
    SAFE_FREE(ast->ops);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0xa197
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %r14
movq 0x8(%r14), %rdi
callq 0xa495
movq %r14, %rdi
callq 0x1030
incq %r15
cmpq 0x10(%rbx), %r15
jb 0xa176
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_multiplicative_expr_ast
struct MULTIPLICATIVE_EXPR_AST*create_multiplicative_expr_ast(struct LEFT_UNARY_EXPR_AST**lues,
                                                              enum AST_MULTIPLICATIVE_OP*ops,
                                                              size_t lues_len,
                                                              size_t line, size_t pos)
{
    struct MULTIPLICATIVE_EXPR_AST*mul_expr;
    SAFE_MALLOC(mul_expr, 1);
    mul_expr->lues = lues;
    mul_expr->ops = ops;
    mul_expr->lues_len = lues_len;

    mul_expr->line = line;
    mul_expr->pos = pos;

    return mul_expr;
}

// 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 0xa200
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 0x236c
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_multiplicative_expr_ast_to_file_inner
static void dump_multiplicative_expr_ast_to_file_inner(FILE*f, const struct MULTIPLICATIVE_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->lues_len == 1) {
        dump_left_unary_expr_ast_to_file_inner(f, ast->lues[0], spaces_num);
    } else {
        size_t i;
        
        PUT_SPACES(); fprintf(f, "<multiplicative_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        dump_left_unary_expr_ast_to_file_inner(f, ast->lues[0], spaces_num);
        for (i = 1; i < ast->lues_len; i++) {
            if (ast->ops[i - 1] == AST_MULTIPLICATIVE_OP_MUL) {
                PUT_SPACES(); fprintf(f, "<op>MUL</op>\n");
            } else if (ast->ops[i - 1] == AST_MULTIPLICATIVE_OP_DIV) {
                PUT_SPACES(); fprintf(f, "<op>DIV</op>\n");
            } else if (ast->ops[i - 1] == AST_MULTIPLICATIVE_OP_MOD) {
                PUT_SPACES(); fprintf(f, "<op>MOD</op>\n");
            }
            dump_left_unary_expr_ast_to_file_inner(f, ast->lues[i], spaces_num);
        }
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</multiplicative_expr>\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x10(%rsi)
jne 0xa243
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa3a2
leaq 0x5808(%rip), %rsi      # 0xfa52
leaq 0x4fb5(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x5dd1(%rip), %rsi      # 0x1003e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r12, (%rsp)
addq $0x2, %r12
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa3a2
cmpq $0x2, 0x10(%r15)
jb 0xa306
movl $0x1, %r13d
leaq 0x5708(%rip), %rbp      # 0xf9ac
movq 0x8(%r15), %rax
movl -0x4(%rax,%r13,4), %eax
cmpq $0x2, %rax
ja 0xa2eb
movslq (%rbp,%rax,4), %r14
addq %rbp, %r14
movq %rbx, %rdi
leaq 0x578d(%rip), %rsi      # 0xfa52
movl %r12d, %edx
leaq 0x4f37(%rip), %rcx      # 0xf206
xorl %eax, %eax
callq 0x1100
movl $0xd, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa3a2
incq %r13
cmpq 0x10(%r15), %r13
jb 0xa2a4
leaq 0x5745(%rip), %rsi      # 0xfa52
leaq 0x4ef2(%rip), %rcx      # 0xf206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x5d6b(%rip), %rdi      # 0x10094
movl $0x17, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_left_unary_expr_ast
struct LEFT_UNARY_EXPR_AST*create_left_unary_expr_ast(enum AST_LEFT_UNARY_OP op, struct PRIMARY_EXPR_AST*expr,
                                                      size_t line, size_t pos)
{
    struct LEFT_UNARY_EXPR_AST*lue;
    SAFE_MALLOC(lue, 1);
    lue->op = op;
    lue->expr = expr;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x20, %edi
callq 0x1130
testq %rax, %rax
je 0xa399
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x239d