LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x772c
leaq 0x739b(%rip), %rsi      # 0xea52
leaq 0x6b48(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x7854(%rip), %rsi      # 0xef2e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7854
movl 0x8(%r15), %eax
cmpl $0x1, %eax
je 0x7745
testl %eax, %eax
jne 0x7775
leaq 0x7345(%rip), %rsi      # 0xea52
leaq 0x6af2(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7826(%rip), %rdi      # 0xef4e
pushq $0xe
jmp 0x7769
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7854
leaq 0x7306(%rip), %rsi      # 0xea52
leaq 0x6ab3(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x77f6(%rip), %rdi      # 0xef5d
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1190
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7854
leaq 0x72c7(%rip), %rsi      # 0xea52
leaq 0x6a74(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x77c5(%rip), %rdi      # 0xef6b
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/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 0x795d
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x77d9
callq 0x795d
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x7820
movq %r12, (%rax)
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xe7c9(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6d8d(%rip), %rsi      # 0xe5be
leaq 0x7180(%rip), %rdx      # 0xe9b8
pushq $0x28
popq %r8
movl $0x4b2, %ecx            # imm = 0x4B2
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_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 0x7946
leaq 0x71da(%rip), %rsi      # 0xea52
leaq 0x6987(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x76dc(%rip), %rsi      # 0xef77
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7a15
movl 0x8(%r15), %eax
cmpq $0x3, %rax
ja 0x78fe
leaq 0x70d1(%rip), %rcx      # 0xe99c
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
leaq 0x7179(%rip), %rsi      # 0xea52
leaq 0x6926(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x1190
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7a15
leaq 0x713e(%rip), %rsi      # 0xea52
leaq 0x68eb(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x76a4(%rip), %rdi      # 0xefd3
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
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 0x7a15
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x10(%rbx), %r14
jae 0x797e
movq (%rdi,%r14,8), %rdi
callq 0x7b5f
incq %r14
jmp 0x7967
callq 0x1030
andq $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_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_additive_expr_ast
struct ADDITIVE_EXPR_AST*create_additive_expr_ast(struct MULTIPLICATIVE_EXPR_AST**muls,
                                                  enum AST_ADDITIVE_OP*ops,
                                                  size_t muls_len,
                                                  size_t line, size_t pos)
{
    struct ADDITIVE_EXPR_AST*additive_expr;
    SAFE_MALLOC(additive_expr, 1);
    additive_expr->muls = muls;
    additive_expr->ops = ops;
    additive_expr->muls_len = muls_len;

    additive_expr->line = line;
    additive_expr->pos = pos;
    
    return additive_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
pushq $0x28
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x79e1
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xe608(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6bcc(%rip), %rsi      # 0xe5be
leaq 0x6fbf(%rip), %rdx      # 0xe9b8
pushq $0x28
popq %r8
movl $0x4ea, %ecx            # imm = 0x4EA
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_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, %rbp
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x10(%rsi)
jne 0x7a4f
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7c17
leaq 0x6ffc(%rip), %rsi      # 0xea52
leaq 0x67a9(%rip), %r13      # 0xe206
movq %rbx, %rdi
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x756c(%rip), %rsi      # 0xefe7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %rbp, (%rsp)
addq $0x2, %rbp
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7c17
pushq $0x1
popq %r12
movq %r12, %r14
cmpq 0x10(%r15), %r14
jae 0x7b20
movq 0x8(%r15), %rax
movl -0x4(%rax,%r14,4), %eax
cmpl $0x1, %eax
je 0x7ade
testl %eax, %eax
jne 0x7b09
movq %rbx, %rdi
leaq 0x6f8b(%rip), %rsi      # 0xea52
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7533(%rip), %rdi      # 0xf00d
pushq $0xe
jmp 0x7afd
movq %rbx, %rdi
leaq 0x6f6a(%rip), %rsi      # 0xea52
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7521(%rip), %rdi      # 0xf01c
pushq $0xf
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7c17
incq %r14
jmp 0x7aa5
leaq 0x6f2b(%rip), %rsi      # 0xea52
leaq 0x66d8(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x74e9(%rip), %rdi      # 0xf02c
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x10(%rbx), %r14
jae 0x7b80
movq (%rdi,%r14,8), %rdi
callq 0x7d45
incq %r14
jmp 0x7b69
callq 0x1030
andq $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_O2/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
pushq $0x28
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x7be3
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xe406(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x69ca(%rip), %rsi      # 0xe5be
leaq 0x6dbd(%rip), %rdx      # 0xe9b8
pushq $0x28
popq %r8
movl $0x524, %ecx            # imm = 0x524
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_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, %rbp
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x1, 0x10(%rsi)
jne 0x7c51
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7dc7
leaq 0x6dfa(%rip), %rsi      # 0xea52
leaq 0x65a7(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x73c4(%rip), %rsi      # 0xf03e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %rbp, (%rsp)
addq $0x2, %rbp
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7dc7
pushq $0x1
popq %r14
leaq 0x6d04(%rip), %r12      # 0xe9ac
cmpq 0x10(%r15), %r14
jae 0x7d06
movq 0x8(%r15), %rax
movl -0x4(%rax,%r14,4), %eax
cmpq $0x2, %rax
ja 0x7cef
movslq (%r12,%rax,4), %r13
addq %r12, %r13
movq %rbx, %rdi
leaq 0x6d84(%rip), %rsi      # 0xea52
movl %ebp, %edx
leaq 0x652f(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
movq %r13, %rdi
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7dc7
incq %r14
jmp 0x7ca8
leaq 0x6d45(%rip), %rsi      # 0xea52
leaq 0x64f2(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x736b(%rip), %rdi      # 0xf094
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_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
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x7d93
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
movq 0xe256(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x681a(%rip), %rsi      # 0xe5be
leaq 0x6c0d(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x55e, %ecx            # imm = 0x55E
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_left_unary_expr_ast_to_file_inner
static void dump_left_unary_expr_ast_to_file_inner(FILE*f, const struct LEFT_UNARY_EXPR_AST*ast, size_t spaces_num)
{
    if (ast->op != AST_LEFT_UNARY_OP_PLUS) {
        PUT_SPACES(); fprintf(f, "<left_unary_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
        INC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "<op>UNARY_MINUS</op>\n");
        dump_primary_expr_ast_to_file_inner(f, ast->expr, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</left_unary_expr>\n");
    } else {
        dump_primary_expr_ast_to_file_inner(f, ast->expr, spaces_num);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x7e9c
leaq 0x6c67(%rip), %r13      # 0xea52
leaq 0x6414(%rip), %r15      # 0xe206
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
leaq 0x7296(%rip), %rsi      # 0xf0ac
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x7294(%rip), %rdi      # 0xf0d4
pushq $0x15
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r12), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x7fb3
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
leaq 0x6394(%rip), %rcx      # 0xe206
xorl %eax, %eax
callq 0x1100
leaq 0x726a(%rip), %rdi      # 0xf0ea
pushq $0x13
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
movq 0x8(%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7fb3
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: primary_expr_ast_free
void primary_expr_ast_free(struct PRIMARY_EXPR_AST*ast)
{
    switch (ast->type) {
    case AST_PRIMARY_EXPR_TYPE_HAS_PROPERTY:
        has_property_expr_ast_free(ast->has_property_expr);
        break;
    case AST_PRIMARY_EXPR_TYPE_LEN:
        len_expr_ast_free(ast->len_expr);
        break;
    case AST_PRIMARY_EXPR_TYPE_FUNCTION_CALL:
        function_call_ast_free(ast->function_call);
        break;
    case AST_PRIMARY_EXPR_TYPE_VARIABLE:
        variable_ast_free(ast->var_name);
        break;
    case AST_PRIMARY_EXPR_TYPE_NUMBER:
        number_ast_free(ast->number);
        break;
    case AST_PRIMARY_EXPR_TYPE_LOGICAL_OR_EXPR:
        logical_or_expr_ast_free(ast->logical_or_expr);
        break;
    default:
        fprintf(stderr, "Invalid PRIMARY_EXPR_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);                
        break;
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbx
movl 0x8(%rdi), %edx
cmpq $0x5, %rdx
ja 0x7f1a
movq %rdi, %rbx
leaq 0x6a9e(%rip), %rax      # 0xe96c
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rbx), %rdi
callq 0x801f
jmp 0x7f11
movq (%rbx), %rdi
callq 0x1030
jmp 0x7f11
movq (%rbx), %rdi
callq 0x61bb
jmp 0x7f11
movq (%rbx), %rdi
callq 0x6093
jmp 0x7f11
movq (%rbx), %rdi
callq 0x803d
jmp 0x7f11
movq (%rbx), %rdi
callq 0x6424
movq %rbx, %rdi
popq %rbx
jmp 0x1030
movq 0xe0cf(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6b63(%rip), %rsi      # 0xea8e
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_primary_expr_ast
struct PRIMARY_EXPR_AST*create_primary_expr_ast(void*primary_expr_ptr, enum AST_PRIMARY_EXPR_TYPE type)
{
    struct PRIMARY_EXPR_AST*primary_expr;
    SAFE_MALLOC(primary_expr, 1);
    switch (type) {
    case AST_PRIMARY_EXPR_TYPE_HAS_PROPERTY:
        primary_expr->has_property_expr = primary_expr_ptr;
        break;
    case AST_PRIMARY_EXPR_TYPE_LEN:
        primary_expr->len_expr = primary_expr_ptr;
        break;
    case AST_PRIMARY_EXPR_TYPE_FUNCTION_CALL:
        primary_expr->function_call = primary_expr_ptr;
        break;
    case AST_PRIMARY_EXPR_TYPE_VARIABLE:
        primary_expr->var_name = primary_expr_ptr;
        break;
    case AST_PRIMARY_EXPR_TYPE_NUMBER:
        primary_expr->number = primary_expr_ptr;
        break;
    case AST_PRIMARY_EXPR_TYPE_LOGICAL_OR_EXPR:
        primary_expr->logical_or_expr = primary_expr_ptr;
        break;
    default:
        fprintf(stderr, "Invalid PRIMARY_EXPR_AST type: %d\n", type);
        exit(EXIT_FAILURE);
        break;
    }
    primary_expr->type = type;
    return primary_expr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x7f63
cmpl $0x6, %ebx
jae 0x7f8d
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xe086(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x664a(%rip), %rsi      # 0xe5be
leaq 0x6a3d(%rip), %rdx      # 0xe9b8
pushq $0x10
popq %r8
movl $0x586, %ecx            # imm = 0x586
xorl %eax, %eax
callq 0x1100
jmp 0x7fa7
movq 0xe05c(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6af0(%rip), %rsi      # 0xea8e
movl %ebx, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_primary_expr_ast_to_file_inner
static void dump_primary_expr_ast_to_file_inner(FILE*f, const struct PRIMARY_EXPR_AST*ast, size_t spaces_num)
{
    switch (ast->type) {
    case AST_PRIMARY_EXPR_TYPE_HAS_PROPERTY:
        dump_has_property_expr_ast_to_file_inner(f, ast->has_property_expr, spaces_num);
        break;
    case AST_PRIMARY_EXPR_TYPE_LEN:
        dump_len_expr_ast_to_file_inner(f, ast->len_expr, spaces_num);
        break;
    case AST_PRIMARY_EXPR_TYPE_FUNCTION_CALL:
        dump_function_call_ast_to_file_inner(f, ast->function_call, spaces_num);
        break;
    case AST_PRIMARY_EXPR_TYPE_VARIABLE:
        dump_variable_ast_to_file_inner(f, ast->var_name, spaces_num);
        break;
    case AST_PRIMARY_EXPR_TYPE_NUMBER:
        dump_number_ast_to_file_inner(f, ast->number, spaces_num);
        break;
    case AST_PRIMARY_EXPR_TYPE_LOGICAL_OR_EXPR:
        dump_logical_or_expr_ast_to_file_inner(f, ast->logical_or_expr, spaces_num);
        break;
    default:
        fprintf(stderr, "Invalid PRIMARY_EXPR_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);                
        break;
    }
}

// Assembly:
movl 0x8(%rsi), %eax
cmpq $0x5, %rax
ja 0x7ffc
leaq 0x69c1(%rip), %rcx      # 0xe984
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rsi
jmp 0x80c7
movq (%rsi), %rsi
jmp 0x8559
movq (%rsi), %rsi
jmp 0x82c4
movq (%rsi), %rsi
jmp 0x6c2c
movq (%rsi), %rsi
jmp 0x81ca
movq (%rsi), %rsi
jmp 0x7326
pushq %rax
movq 0xdfec(%rip), %rcx      # 0x15ff0
movq (%rcx), %rdi
leaq 0x6a80(%rip), %rsi      # 0xea8e
movl %eax, %edx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_has_property_expr_ast
struct HAS_PROPERTY_EXPR_AST*create_has_property_expr_ast(struct VARIABLE_AST*obj, struct IDENT_AST*ident,
                                                          size_t line, size_t pos)
{
    struct HAS_PROPERTY_EXPR_AST*has_property;
    SAFE_MALLOC(has_property, 1);
    has_property->obj = obj;
    has_property->ident = ident;

    has_property->line = line;
    has_property->pos = pos;

    return has_property;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x8093
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xdf56(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x651a(%rip), %rsi      # 0xe5be
leaq 0x690d(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x5e9, %ecx            # imm = 0x5E9
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_has_property_expr_ast_to_file_inner
static void dump_has_property_expr_ast_to_file_inner(FILE*f, const struct HAS_PROPERTY_EXPR_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<has_property_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->obj, spaces_num);
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</has_property_expr>\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 0x6970(%rip), %r12      # 0xea52
leaq 0x611d(%rip), %r15      # 0xe206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x6ff9(%rip), %rsi      # 0xf0fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x6c2c
movq 0x8(%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x84b7
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6fda(%rip), %rdi      # 0xf128
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_len_expr_ast
struct LEN_EXPR_AST*create_len_expr_ast(struct VARIABLE_AST*arr, size_t line, size_t pos)
{
    struct LEN_EXPR_AST*len;
    SAFE_MALLOC(len, 1);
    len->arr = arr;

    len->line = line;
    len->pos = pos;

    return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x8196
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xde53(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6417(%rip), %rsi      # 0xe5be
leaq 0x680a(%rip), %rdx      # 0xe9b8
pushq $0x18
popq %r8
movl $0x60c, %ecx            # imm = 0x60C
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_len_expr_ast_to_file_inner
static void dump_len_expr_ast_to_file_inner(FILE*f, const struct LEN_EXPR_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<len_expr line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->arr, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</len_expr>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x686f(%rip), %r12      # 0xea52
leaq 0x601c(%rip), %r15      # 0xe206
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
leaq 0x6f38(%rip), %rsi      # 0xf13e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdx
addq $0x2, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x6c2c
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x6f22(%rip), %rdi      # 0xf15f
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_function_call_ast
struct FUNCTION_CALL_AST*create_function_call_ast(struct IDENT_AST*function_name, struct ARGS_LIST_AST*args_list,
                                                  size_t line, size_t pos)
{
    struct FUNCTION_CALL_AST*function_call;
    SAFE_MALLOC(function_call, 1);
    function_call->function_name = function_name;
    function_call->args_list = args_list;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x8290
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xdd59(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x631d(%rip), %rsi      # 0xe5be
leaq 0x6710(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x62d, %ecx            # imm = 0x62D
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_function_call_ast_to_file_inner
static void dump_function_call_ast_to_file_inner(FILE*f, const struct FUNCTION_CALL_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<function_call 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->args_list != NULL) {
        dump_args_list_ast_to_file_inner(f, ast->args_list, spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</function_call>\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 0x6773(%rip), %rbp      # 0xea52
leaq 0x5f20(%rip), %r13      # 0xe206
movq %rbp, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6e6a(%rip), %rsi      # 0xf16c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x2(%r14), %r12
movq %rbx, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x67b1(%rip), %rsi      # 0xeae3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdx
addq $0x4, %rdx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x84b7
movq %rbx, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x67a1(%rip), %rdi      # 0xeb09
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x838a
movq %rbx, %rdi
movq %r12, %rdx
callq 0x71da
leaq 0x66c1(%rip), %rsi      # 0xea52
leaq 0x5e6e(%rip), %rcx      # 0xe206
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6de6(%rip), %rdi      # 0xf192
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_args_list_ast
struct ARGS_LIST_AST*create_args_list_ast(struct ASSIGNMENT_EXPR_AST**assignment_exprs, size_t assignment_exprs_len,
                                          size_t line, size_t pos)
{
    struct ARGS_LIST_AST*args_list;
    SAFE_MALLOC(args_list, 1);
    args_list->assignment_exprs = assignment_exprs;
    args_list->assignment_exprs_len = assignment_exprs_len;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x8404
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xdbe5(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x61a9(%rip), %rsi      # 0xe5be
leaq 0x659c(%rip), %rdx      # 0xe9b8
pushq $0x20
popq %r8
movl $0x659, %ecx            # imm = 0x659
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_ident_ast
struct IDENT_AST*create_ident_ast(const char*ident, size_t line, size_t pos)
{
    struct IDENT_AST*ident_ast;
    SAFE_MALLOC(ident_ast, 1);
    strncpy(ident_ast->ident, ident, sizeof(ident_ast->ident));

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x30
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x8483
movq %rax, %r12
pushq $0x20
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r14, 0x20(%r12)
movq %rbx, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xdb66(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x612a(%rip), %rsi      # 0xe5be
leaq 0x651d(%rip), %rdx      # 0xe9b8
pushq $0x30
popq %r8
movl $0x682, %ecx            # imm = 0x682
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_number_ast
struct NUMBER_AST*create_number_ast(long long number, size_t line, size_t pos)
{
    struct NUMBER_AST*number_ast;
    SAFE_MALLOC(number_ast, 1);
    number_ast->number = number;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x8525
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xdac4(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6088(%rip), %rsi      # 0xe5be
leaq 0x647b(%rip), %rdx      # 0xe9b8
pushq $0x18
popq %r8
movl $0x69d, %ecx            # imm = 0x69D
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: create_constant_from_double
struct CONSTANT create_constant_from_double(double double_cnst)
{
    struct CONSTANT cnst;
    memset(&cnst, 0, sizeof(cnst));
    cnst.double_cnst = double_cnst;
    cnst.type = CONSTANT_TYPE_DOUBLE;
    return cnst;
}

// Assembly:
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x18(%rdi)
movups %xmm1, 0x8(%rdi)
movsd %xmm0, (%rdi)
movl $0x1, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: create_constant_from_fieldref
struct CONSTANT create_constant_from_fieldref(const char*str_cnst)
{
    struct CONSTANT cnst;
    memset(&cnst, 0, sizeof(cnst));
    strncpy(cnst.str_cnst, str_cnst, sizeof(cnst.str_cnst));
    cnst.type = CONSTANT_TYPE_FIELDREF;
    return cnst;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x20(%rdi)
pushq $0x20
popq %rdx
callq 0x1040
movl $0x2, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: create_constant_from_functionref
struct CONSTANT create_constant_from_functionref(const char*str_cnst)
{
    struct CONSTANT cnst;
    memset(&cnst, 0, sizeof(cnst));
    strncpy(cnst.str_cnst, str_cnst, sizeof(cnst.str_cnst));
    cnst.type = CONSTANT_TYPE_FUNCTIONREF;
    return cnst;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x20(%rdi)
pushq $0x20
popq %rdx
callq 0x1040
movl $0x3, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: bytecode_generator_generate
enum BYTECODE_GENERATOR_CODES bytecode_generator_generate(bytecode_generator_type_t bc_gen, struct BYTECODE**bc)
{   
    /* now only one function without arguments is supported. */
    struct FUNCTION_DECL_AST*f = bc_gen->ast->functions[0];
    enum BYTECODE_GENERATOR_CODES r = body_ast_bytecode_generate(bc_gen, f->body, NULL,
                                                                 NULL, NULL, NULL);
    if (r != BYTECODE_GENERATOR_OK) {
        bytecode_free(bc_gen->bc);
        return r;
    }

    (*bc) = bc_gen->bc;
    return BYTECODE_GENERATOR_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8699
movl %eax, %ebp
movq 0x8(%r14), %rdi
testl %eax, %eax
je 0x868f
callq 0x92d7
jmp 0x8692
movq %rdi, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: logical_or_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES logical_or_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct LOGICAL_OR_EXPR_AST*ast)
{
    size_t i;

    enum BYTECODE_GENERATOR_CODES r = logical_and_expr_ast_bytecode_generate(bc_gen, ast->and_exprs[0]);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }    
    
    for (i = 1; i < ast->and_exprs_len; i++) {
        r = logical_and_expr_ast_bytecode_generate(bc_gen, ast->and_exprs[i]);
        if (r != BYTECODE_GENERATOR_OK) {
            return r;
        }
        PUSH_BACK(bc_gen->bc->op_codes, BC_OP_LOGICAL_OR);
    }

    return BYTECODE_GENERATOR_OK;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rsi
callq 0x9fec
testl %eax, %eax
je 0x9ddc
movl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r13
pushq $0x8
popq %r12
xorl %r15d, %r15d
cmpq 0x8(%rbx), %r13
jae 0x9dca
movq (%rbx), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x9fec
testl %eax, %eax
jne 0x9dc7
movq 0x8(%r14), %rbp
movq 0x8(%rbp), %rsi
cmpq 0x10(%rbp), %rsi
jne 0x9e3b
testq %rsi, %rsi
je 0x9e41
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%rbp)
movq (%rbp), %rdi
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%r14), %rbp
movq %rax, (%rbp)
testq %rax, %rax
je 0x9e70
movq 0x8(%rbp), %rsi
jmp 0x9e5c
movq (%rbp), %rax
jmp 0x9e5c
movq $0x1, 0x10(%rbp)
movq %r12, %rdi
callq 0x1130
movq %rax, (%rbp)
testq %rax, %rax
je 0x9e92
xorl %esi, %esi
movq $0xc, (%rax,%rsi,8)
incq 0x8(%rbp)
incq %r13
jmp 0x9de7
movq 0xc179(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq 0x10(%rbp), %r8
shlq $0x3, %r8
leaq 0x4a68(%rip), %rsi      # 0xe8f1
leaq 0x5488(%rip), %rdx      # 0xf318
jmp 0x9eae
movq 0xc157(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x471b(%rip), %rsi      # 0xe5be
leaq 0x546e(%rip), %rdx      # 0xf318
pushq $0x8
popq %r8
movl $0x1e0, %ecx            # imm = 0x1E0
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: constant_pool_push_back
static int constant_pool_push_back(bytecode_type_t bc, struct CONSTANT cnst)
{
    size_t i;

    for (i = 0; i < bc->constant_pool_len; i++) {
        if (memcmp((char*) &cnst, (char*) (bc->constant_pool + i), sizeof(struct CONSTANT)) == 0) {
            return i;
        }
    }

    PUSH_BACK(bc->constant_pool, cnst);

    return bc->constant_pool_len - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq 0x20(%rdi), %r13
xorl %ebp, %ebp
pushq $0x28
popq %r12
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x9f0a
movq 0x18(%rbx), %rsi
addq %rbp, %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x1140
testl %eax, %eax
je 0x9f8a
incq %r15
addq $0x28, %rbp
jmp 0x9ee2
cmpq 0x28(%rbx), %r13
jne 0x9f3d
testq %r13, %r13
je 0x9f43
leaq (,%r13,2), %rax
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdi
imulq $0x50, %r13, %rsi
callq 0x1160
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x9f9c
movq 0x20(%rbx), %r13
jmp 0x9f5f
movq 0x18(%rbx), %rax
jmp 0x9f5f
movq $0x1, 0x28(%rbx)
pushq $0x28
popq %rdi
callq 0x1130
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x9fbe
xorl %r13d, %r13d
imulq $0x28, %r13, %rcx
movq 0x20(%r14), %rdx
movq %rdx, 0x20(%rax,%rcx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq 0x20(%rbx), %r15
leaq 0x1(%r15), %rax
movq %rax, 0x20(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc04d(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
imulq $0x28, 0x28(%rbx), %r8
leaq 0x493f(%rip), %rsi      # 0xe8f1
leaq 0x535f(%rip), %rdx      # 0xf318
pushq $0x45
popq %rcx
jmp 0x9fdd
movq 0xc02b(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x45ef(%rip), %rsi      # 0xe5be
leaq 0x5342(%rip), %rdx      # 0xf318
pushq $0x45
popq %rcx
pushq $0x28
popq %r8
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: logical_and_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES logical_and_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct LOGICAL_AND_EXPR_AST*ast)
{
    size_t i;

    enum BYTECODE_GENERATOR_CODES r = eq_expr_ast_bytecode_generate(bc_gen, ast->eq_exprs[0]);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }    
    for (i = 1; i < ast->eq_exprs_len; i++) {
        r = eq_expr_ast_bytecode_generate(bc_gen, ast->eq_exprs[i]);
        if (r != BYTECODE_GENERATOR_OK) {
            return r;
        }
        PUSH_BACK(bc_gen->bc->op_codes, BC_OP_LOGICAL_AND);
    }

    return BYTECODE_GENERATOR_OK;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rsi
callq 0xa107
testl %eax, %eax
je 0xa021
movl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r13
pushq $0x8
popq %r12
xorl %r15d, %r15d
cmpq 0x8(%rbx), %r13
jae 0xa00f
movq (%rbx), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0xa107
testl %eax, %eax
jne 0xa00c
movq 0x8(%r14), %rbp
movq 0x8(%rbp), %rsi
cmpq 0x10(%rbp), %rsi
jne 0xa080
testq %rsi, %rsi
je 0xa086
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%rbp)
movq (%rbp), %rdi
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%r14), %rbp
movq %rax, (%rbp)
testq %rax, %rax
je 0xa0b5
movq 0x8(%rbp), %rsi
jmp 0xa0a1
movq (%rbp), %rax
jmp 0xa0a1
movq $0x1, 0x10(%rbp)
movq %r12, %rdi
callq 0x1130
movq %rax, (%rbp)
testq %rax, %rax
je 0xa0d7
xorl %esi, %esi
movq $0xd, (%rax,%rsi,8)
incq 0x8(%rbp)
incq %r13
jmp 0xa02c
movq 0xbf34(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq 0x10(%rbp), %r8
shlq $0x3, %r8
leaq 0x4823(%rip), %rsi      # 0xe8f1
leaq 0x5243(%rip), %rdx      # 0xf318
jmp 0xa0f3
movq 0xbf12(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x44d6(%rip), %rsi      # 0xe5be
leaq 0x5229(%rip), %rdx      # 0xf318
pushq $0x8
popq %r8
movl $0x1cc, %ecx            # imm = 0x1CC
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: emit_loop
static void emit_loop(bytecode_generator_type_t bc_gen, size_t loop_start)
{
    int offset;
    
    PUSH_BACK(bc_gen->bc->op_codes, BC_OP_JUMP);

    offset = ((int) (bc_gen->bc->op_codes_len - loop_start + 1)) * (-1);
    
    PUSH_BACK(bc_gen->bc->op_codes, offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
jne 0xba32
testq %rsi, %rsi
je 0xba37
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r15)
movq (%r15), %rdi
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%r14), %r15
movq %rax, (%r15)
testq %rax, %rax
je 0xbad6
movq 0x8(%r15), %rsi
jmp 0xba55
movq (%r15), %rax
jmp 0xba55
movq $0x1, 0x10(%r15)
pushq $0x8
popq %rdi
callq 0x1130
movq %rax, (%r15)
testq %rax, %rax
je 0xbb1a
xorl %esi, %esi
movq $0x1d, (%rax,%rsi,8)
movq 0x8(%r15), %r12
leaq 0x1(%r12), %rsi
movq %rsi, 0x8(%r15)
cmpq 0x10(%r15), %rsi
jne 0xbab9
testq %rsi, %rsi
je 0xba9b
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x10(%r15)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x1160
movq 0x8(%r14), %r15
movq %rax, (%r15)
testq %rax, %rax
je 0xbaf8
movq 0x8(%r15), %rsi
jmp 0xbab9
movq $0x1, 0x10(%r15)
pushq $0x8
popq %rdi
callq 0x1130
movq %rax, (%r15)
testq %rax, %rax
je 0xbb3d
xorl %esi, %esi
subl %r12d, %ebx
addl $-0x2, %ebx
movslq %ebx, %rcx
movq %rcx, (%rax,%rsi,8)
incq 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa513(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq 0x10(%r15), %r8
shlq $0x3, %r8
leaq 0x2e02(%rip), %rsi      # 0xe8f1
leaq 0x3822(%rip), %rdx      # 0xf318
jmp 0xbb36
movq 0xa4f1(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq 0x10(%r15), %r8
shlq $0x3, %r8
leaq 0x2de0(%rip), %rsi      # 0xe8f1
leaq 0x3800(%rip), %rdx      # 0xf318
jmp 0xbb59
movq 0xa4cf(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x2a93(%rip), %rsi      # 0xe5be
leaq 0x37e6(%rip), %rdx      # 0xf318
pushq $0x8
popq %r8
movl $0x26a, %ecx            # imm = 0x26A
jmp 0xbb5e
movq 0xa4ac(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x2a70(%rip), %rsi      # 0xe5be
leaq 0x37c3(%rip), %rdx      # 0xf318
pushq $0x8
popq %r8
movl $0x26e, %ecx            # imm = 0x26E
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: virtual_machine_conf
void virtual_machine_conf(virtual_machine_type_t vm, bytecode_type_t bc, size_t stack_size, size_t start_heap_size_b, int trace)
{
    vm->bc = bc;
    vm->ip = bc->op_codes;
    
    vm->stack_cap = stack_size;
    SAFE_MALLOC(vm->stack, vm->stack_cap);
    vm->stack_top = vm->stack;

    vm->gc = create_garbage_collector();
    garbage_collector_conf(vm->gc, start_heap_size_b, &(vm->stack), &(vm->stack_top), trace);

    vm->trace = trace;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r15
movq %rdi, %r14
movq %rsi, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x20(%rdi)
imulq $0x18, %rdx, %r12
movq %r12, %rdi
callq 0x1130
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0xbc1f
leaq 0x10(%r14), %r12
leaq 0x18(%r14), %r13
movq %rax, 0x18(%r14)
xorl %eax, %eax
callq 0xc6ec
movq %rax, 0x28(%r14)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebx, %r8d
callq 0xc731
movl %ebx, 0x30(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa3ca(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x298e(%rip), %rsi      # 0xe5be
leaq 0x3c5d(%rip), %rdx      # 0xf894
pushq $0x46
popq %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1180