LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x9d51
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 0x9ece
leaq 0x5cee(%rip), %rsi      # 0xfa46
leaq 0x54aa(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x6112(%rip), %rsi      # 0xfe8d
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 0x9ece
cmpq $0x2, 0x8(%r15)
jb 0x9e00
movl $0x1, %r13d
leaq 0x5457(%rip), %rbp      # 0xf209
leaq 0x60fc(%rip), %r14      # 0xfeb5
movq %rbx, %rdi
leaq 0x5c83(%rip), %rsi      # 0xfa46
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 0x9ece
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9db9
leaq 0x5c3f(%rip), %rsi      # 0xfa46
leaq 0x53fb(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x609f(%rip), %rdi      # 0xfec2
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_O1/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 0x9e69
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9ffa
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x9e54
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_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 0x9f08
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 0xa066
leaq 0x5b37(%rip), %rsi      # 0xfa46
leaq 0x52f3(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x5fa4(%rip), %rsi      # 0xfed6
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 0xa066
cmpq $0x2, 0x8(%r15)
jb 0x9fb7
movl $0x1, %r13d
leaq 0x52a0(%rip), %rbp      # 0xf209
leaq 0x5f8f(%rip), %r14      # 0xfeff
movq %rbx, %rdi
leaq 0x5acc(%rip), %rsi      # 0xfa46
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 0xa066
incq %r13
cmpq 0x8(%r15), %r13
jb 0x9f70
leaq 0x5a88(%rip), %rsi      # 0xfa46
leaq 0x5244(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x5f33(%rip), %rdi      # 0xff0d
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_O1/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 0xa198
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa014
callq 0xa198
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0xa05d
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 0x22bb
// File: /workspace/github_c_makefile_star2_O1/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 0xa0fd
leaq 0x59c1(%rip), %rsi      # 0xfa46
leaq 0x517d(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x5e7a(%rip), %rsi      # 0xff22
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa204
movl 0x8(%r15), %eax
cmpl $0x1, %eax
je 0xa116
testl %eax, %eax
jne 0xa14a
leaq 0x596b(%rip), %rsi      # 0xfa46
leaq 0x5127(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x5e4c(%rip), %rdi      # 0xff42
movl $0xe, %esi
jmp 0xa13d
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa204
leaq 0x5929(%rip), %rsi      # 0xfa46
leaq 0x50e5(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x5e19(%rip), %rdi      # 0xff51
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa204
leaq 0x58e6(%rip), %rsi      # 0xfa46
leaq 0x50a2(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x5de4(%rip), %rdi      # 0xff5f
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_O1/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 0xa315
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa1b2
callq 0xa315
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0xa1fb
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 0x22ec
// File: /workspace/github_c_makefile_star2_O1/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 0xa2fe
leaq 0x581e(%rip), %rsi      # 0xfa46
leaq 0x4fda(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x5d20(%rip), %rsi      # 0xff6b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa3b2
movl 0x8(%r15), %eax
cmpq $0x3, %rax
ja 0xa2b2
leaq 0x5721(%rip), %rcx      # 0xf99c
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
leaq 0x57bd(%rip), %rsi      # 0xfa46
leaq 0x4f79(%rip), %rcx      # 0xf209
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 0xa3b2
leaq 0x577e(%rip), %rsi      # 0xfa46
leaq 0x4f3a(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x5ce4(%rip), %rdi      # 0xffc7
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 0xa3b2
// File: /workspace/github_c_makefile_star2_O1/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 0xa33b
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xa51a
incq %r14
cmpq 0x10(%rbx), %r14
jb 0xa326
movq (%rbx), %rdi
callq 0x1030
xorl %r14d, %r14d
movq %r14, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x1030
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: 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 0xa3ec
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 0xa5c2
leaq 0x5653(%rip), %rsi      # 0xfa46
leaq 0x4e0f(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x5bc5(%rip), %rsi      # 0xffdb
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 0xa5c2
cmpq $0x2, 0x10(%r15)
jb 0xa4d7
movl $0x1, %r14d
leaq 0x55f5(%rip), %r13      # 0xfa46
leaq 0x4db1(%rip), %rbp      # 0xf209
movq 0x8(%r15), %rax
movl -0x4(%rax,%r14,4), %eax
cmpl $0x1, %eax
je 0xa490
testl %eax, %eax
jne 0xa4bc
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movl $0xe, %esi
movl $0x1, %edx
leaq 0x5b73(%rip), %rdi      # 0x10001
jmp 0xa4b4
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movl $0xf, %esi
movl $0x1, %edx
leaq 0x5b5c(%rip), %rdi      # 0x10010
movq %rbx, %rcx
callq 0x1190
movq (%r15), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa5c2
incq %r14
cmpq 0x10(%r15), %r14
jb 0xa458
leaq 0x5568(%rip), %rsi      # 0xfa46
leaq 0x4d24(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x5b26(%rip), %rdi      # 0x10020
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_O1/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 0xa54d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %r14
movq 0x8(%r14), %rdi
callq 0xa865
movq %r14, %rdi
callq 0x1030
incq %r15
cmpq 0x10(%rbx), %r15
jb 0xa52c
movq (%rbx), %rdi
callq 0x1030
xorl %r14d, %r14d
movq %r14, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x1030
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0xa5b9
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 0x234e
// File: /workspace/github_c_makefile_star2_O1/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 0xa5fc
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 0xa772
leaq 0x5443(%rip), %rsi      # 0xfa46
leaq 0x4bff(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rcx
leaq 0x5a0c(%rip), %rsi      # 0x10032
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 0xa772
cmpq $0x2, 0x10(%r15)
jb 0xa6d6
movl $0x1, %r13d
leaq 0x59fd(%rip), %rbp      # 0x1005e
movq 0x8(%r15), %rax
movl -0x4(%rax,%r13,4), %eax
movq %rbp, %r14
testl %eax, %eax
je 0xa68b
cmpl $0x2, %eax
je 0xa684
cmpl $0x1, %eax
jne 0xa6bb
leaq 0x59ea(%rip), %r14      # 0x1006c
jmp 0xa68b
leaq 0x59ef(%rip), %r14      # 0x1007a
movq %rbx, %rdi
leaq 0x53b1(%rip), %rsi      # 0xfa46
movl %r12d, %edx
leaq 0x4b6a(%rip), %rcx      # 0xf209
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 0xa772
incq %r13
cmpq 0x10(%r15), %r13
jb 0xa661
leaq 0x5369(%rip), %rsi      # 0xfa46
leaq 0x4b25(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1100
leaq 0x598f(%rip), %rdi      # 0x10088
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_O1/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 0xa769
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 0x237f
// File: /workspace/github_c_makefile_star2_O1/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 0xa847
leaq 0x52b0(%rip), %r13      # 0xfa46
leaq 0x4a6c(%rip), %r15      # 0xf209
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 0x58df(%rip), %rsi      # 0x100a0
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 0x58dd(%rip), %rdi      # 0x100c8
movl $0x15, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r12), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0xa914
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x58b7(%rip), %rdi      # 0x100de
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
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 0xa914
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpq $0x5, %rdi
ja 0xa8d4
leaq 0x50f0(%rip), %rax      # 0xf96c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rbx), %rdi
callq 0xa965
jmp 0xa8c5
movq (%rbx), %rdi
jmp 0xa8b6
movq (%rbx), %rdi
callq 0x8d1a
jmp 0xa8c5
movq (%rbx), %rdi
callq 0x8c06
jmp 0xa8c5
movq (%rbx), %r14
movq (%r14), %rdi
callq 0x8c06
movq %r14, %rdi
callq 0x1030
jmp 0xa8c5
movq (%rbx), %rdi
callq 0x8f73
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/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 0x5047(%rip), %r12      # 0xfa46
leaq 0x4803(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
leaq 0x56d0(%rip), %rsi      # 0x100f2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rbp
addq $0x2, %rbp
movq (%r13), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x9680
movq 0x8(%r13), %r13
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x5761(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x568e(%rip), %rdi      # 0x1011c
movl $0x15, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_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
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0xaadc
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x247b
// File: /workspace/github_c_makefile_star2_O1/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 0x4f48(%rip), %r12      # 0xfa46
leaq 0x4704(%rip), %r15      # 0xf209
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
leaq 0x5611(%rip), %rsi      # 0x10132
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdx
addq $0x2, %rdx
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x9680
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x55fb(%rip), %rdi      # 0x10153
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_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 0x4e71(%rip), %rbp      # 0xfa46
leaq 0x462d(%rip), %r13      # 0xf209
movq %rbp, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x5568(%rip), %rsi      # 0x10160
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %r12
addq $0x2, %r12
movq %rbx, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq %r13, %rcx
movq %r13, %rbp
xorl %eax, %eax
callq 0x1100
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x4ea9(%rip), %rsi      # 0xfad7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r15), %r13
leal 0x4(%r14), %edx
movq %rbx, %rdi
leaq 0x4dfd(%rip), %rsi      # 0xfa46
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r13), %rdx
movq 0x28(%r13), %rcx
leaq 0x5566(%rip), %rsi      # 0x101c8
movq %rbx, %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x1100
movq %rbx, %rdi
leaq 0x4dcd(%rip), %rsi      # 0xfa46
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1100
leaq 0x4e70(%rip), %rdi      # 0xfafd
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0xacb3
movq %rbx, %rdi
movq %r12, %rdx
callq 0x9bdc
leaq 0x4d8c(%rip), %rsi      # 0xfa46
leaq 0x4548(%rip), %rcx      # 0xf209
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x54b1(%rip), %rdi      # 0x10186
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_O1/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
movl $0x20, %edi
callq 0x1130
testq %rax, %rax
je 0xad33
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 0x24dd
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x30, %edi
callq 0x1130
testq %rax, %rax
je 0xad8b
movq %rax, %r12
movl $0x20, %edx
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
callq 0x250e
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0xae02
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x253f
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: create_constant_from_int
struct CONSTANT create_constant_from_int(long long int_cnst)
{
    struct CONSTANT cnst;
    memset(&cnst, 0, sizeof(cnst));
    cnst.int_cnst = int_cnst;
    cnst.type = CONSTANT_TYPE_INTEGER;
    return cnst;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rsi, (%rdi)
movl $0x0, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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, (%rdi)
movups %xmm1, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movsd %xmm0, (%rdi)
movl $0x1, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movl $0x20, %edx
callq 0x1040
movl $0x2, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xaf6b
movq 0x8(%r15), %rdi
testl %eax, %eax
je 0xaf5a
movl %eax, %ebp
callq 0xb8d3
movl %ebp, %r14d
jmp 0xaf5d
movq %rdi, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rsi
callq 0xc3b0
testl %eax, %eax
je 0xc21e
movl %eax, %ebx
jmp 0xc2b9
xorl %ebx, %ebx
cmpq $0x2, 0x8(%r14)
jb 0xc2b9
movl $0x1, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0xc3b0
testl %eax, %eax
jne 0xc217
movq 0x8(%r15), %r13
movq 0x10(%r13), %rsi
cmpq %rsi, 0x8(%r13)
jne 0xc295
testq %rsi, %rsi
je 0xc27a
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r13)
movq (%r13), %rdi
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%r15), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xc295
jmp 0xc2c5
movq $0x1, 0x10(%r13)
movl $0x8, %edi
callq 0x1130
movq %rax, (%r13)
testq %rax, %rax
je 0xc2ca
movq 0x8(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq $0xc, (%rcx,%rdx,8)
incq 0x8(%rax)
incq %r12
cmpq 0x8(%r14), %r12
jb 0xc231
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2db5
callq 0x2ded
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq 0x20(%rdi), %r13
testq %r13, %r13
je 0xc314
movq 0x18(%rbx), %r12
xorl %r15d, %r15d
movl $0x28, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1140
testl %eax, %eax
je 0xc39e
incq %r15
addq $0x28, %r12
cmpq %r15, %r13
jne 0xc2f0
movq 0x28(%rbx), %rax
cmpq %rax, %r13
jne 0xc36b
testq %rax, %rax
je 0xc350
leaq (%rax,%rax), %rcx
movq %rcx, 0x28(%rbx)
movq 0x18(%rbx), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,4), %rsi
callq 0x1160
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0xc36b
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x2e1e
movq $0x1, 0x28(%rbx)
movl $0x28, %edi
callq 0x1130
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0xc3ab
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq (%rcx,%rcx,4), %rcx
movq 0x20(%r14), %rdx
movq %rdx, 0x20(%rax,%rcx,8)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
movq 0x20(%rbx), %r15
leaq 0x1(%r15), %rax
movq %rax, 0x20(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2e50
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rsi
callq 0xc486
testl %eax, %eax
je 0xc3d5
movl %eax, %ebx
jmp 0xc470
xorl %ebx, %ebx
cmpq $0x2, 0x8(%r14)
jb 0xc470
movl $0x1, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0xc486
testl %eax, %eax
jne 0xc3ce
movq 0x8(%r15), %r13
movq 0x10(%r13), %rsi
cmpq %rsi, 0x8(%r13)
jne 0xc44c
testq %rsi, %rsi
je 0xc431
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r13)
movq (%r13), %rdi
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%r15), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xc44c
jmp 0xc47c
movq $0x1, 0x10(%r13)
movl $0x8, %edi
callq 0x1130
movq %rax, (%r13)
testq %rax, %rax
je 0xc481
movq 0x8(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq $0xd, (%rcx,%rdx,8)
incq 0x8(%rax)
incq %r12
cmpq 0x8(%r14), %r12
jb 0xc3e8
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2e7f
callq 0x2eb7
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: eq_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES eq_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct EQ_EXPR_AST*ast)
{
    enum BYTECODE_GENERATOR_CODES r = relational_expr_ast_bytecode_generate(bc_gen, ast->left);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }    
    if (ast->right != NULL) {
        r = relational_expr_ast_bytecode_generate(bc_gen, ast->right);
        if (r != BYTECODE_GENERATOR_OK) {
            return r;
        }
        if (ast->eq_op == AST_EQ_OP_EQEQ) {
            PUSH_BACK(bc_gen->bc->op_codes, BC_OP_EQ_EQEQ);
        } else if (ast->eq_op == AST_EQ_OP_NEQ) {
            PUSH_BACK(bc_gen->bc->op_codes, BC_OP_EQ_NEQ);
        } else {
            fprintf(stderr, "Invalid AST_EQ_OP type: %d\n", ast->eq_op);
            exit(EXIT_FAILURE);            
        }
    }

    return BYTECODE_GENERATOR_OK;    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rsi
callq 0xc5cc
testl %eax, %eax
je 0xc4b0
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0xc4a2
movq %r14, %rdi
callq 0xc5cc
testl %eax, %eax
jne 0xc4a0
movl 0x8(%r15), %edi
cmpl $0x1, %edi
je 0xc529
testl %edi, %edi
jne 0xc5c2
movq 0x8(%r14), %r12
addq $0x8, %r14
movq 0x10(%r12), %rsi
movl $0xe, %r15d
cmpq %rsi, 0x8(%r12)
jne 0xc5ab
testq %rsi, %rsi
je 0xc58f
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r12)
movq (%r12), %rdi
shlq $0x4, %rsi
callq 0x1160
movq (%r14), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xc5ab
callq 0x2f51
movq 0x8(%r14), %r12
addq $0x8, %r14
movq 0x10(%r12), %rsi
movl $0xf, %r15d
cmpq %rsi, 0x8(%r12)
jne 0xc5ab
testq %rsi, %rsi
je 0xc56e
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r12)
movq (%r12), %rdi
shlq $0x4, %rsi
callq 0x1160
movq (%r14), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xc5ab
callq 0x2ee8
movq $0x1, 0x10(%r12)
movl $0x8, %edi
callq 0x1130
movq %rax, (%r12)
testq %rax, %rax
jne 0xc5ab
callq 0x2f20
movq $0x1, 0x10(%r12)
movl $0x8, %edi
callq 0x1130
movq %rax, (%r12)
testq %rax, %rax
je 0xc5c7
movq (%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %r15, (%rcx,%rdx,8)
incq 0x8(%rax)
jmp 0xc4a2
callq 0x2fba
callq 0x2f89
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: additive_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES additive_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct ADDITIVE_EXPR_AST*ast)
{
    size_t i;

    enum BYTECODE_GENERATOR_CODES r = multiplicative_expr_ast_bytecode_generate(bc_gen, ast->muls[0]);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }
    for (i = 1; i < ast->muls_len; i++) {
        r = multiplicative_expr_ast_bytecode_generate(bc_gen, ast->muls[i]);
        if (r != BYTECODE_GENERATOR_OK) {
            return r;
        }
        if (ast->ops[i - 1] == AST_ADDITIVE_OP_PLUS) {
            PUSH_BACK(bc_gen->bc->op_codes, BC_OP_ADDITIVE_PLUS);
        } else if (ast->ops[i - 1] == AST_ADDITIVE_OP_MINUS) {
            PUSH_BACK(bc_gen->bc->op_codes, BC_OP_ADDITIVE_MINUS);
        } else {
            fprintf(stderr, "Invalid AST_ADDITIVE_OP type: %d\n", ast->ops[i - 1]);
            exit(EXIT_FAILURE);
        }
    }

    return BYTECODE_GENERATOR_OK;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rsi
callq 0xc972
testl %eax, %eax
jne 0xc94a
xorl %eax, %eax
cmpq $0x2, 0x10(%r14)
jb 0xc94a
leaq 0x8(%r15), %r12
movl $0x1, %r13d
movq (%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
callq 0xc972
testl %eax, %eax
jne 0xc94a
movq 0x8(%r14), %rax
movl -0x4(%rax,%r13,4), %edi
cmpl $0x1, %edi
je 0xc8b8
testl %edi, %edi
jne 0xc959
movq (%r12), %rbx
movq 0x10(%rbx), %rsi
movl $0x14, %ebp
cmpq %rsi, 0x8(%rbx)
jne 0xc928
testq %rsi, %rsi
je 0xc90e
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x1160
movq (%r12), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xc928
jmp 0xc95e
movq (%r12), %rbx
movq 0x10(%rbx), %rsi
movl $0x15, %ebp
cmpq %rsi, 0x8(%rbx)
jne 0xc928
testq %rsi, %rsi
je 0xc8f2
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x1160
movq (%r12), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xc928
jmp 0xc963
movq $0x1, 0x10(%rbx)
movl $0x8, %edi
callq 0x1130
movq %rax, (%rbx)
testq %rax, %rax
jne 0xc928
jmp 0xc968
movq $0x1, 0x10(%rbx)
movl $0x8, %edi
callq 0x1130
movq %rax, (%rbx)
testq %rax, %rax
je 0xc96d
movq (%r12), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rbp, (%rcx,%rdx,8)
incq 0x8(%rax)
incq %r13
cmpq 0x10(%r14), %r13
jb 0xc84a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3276
callq 0x320d
callq 0x31a4
callq 0x31dc
callq 0x3245
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%r15), %rsi
cmpq %rsi, 0x8(%r15)
jne 0xd68a
testq %rsi, %rsi
je 0xd66c
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r15)
movq (%r15), %rdi
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%rbx), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xd68a
callq 0x3b36
movq $0x1, 0x10(%r15)
movl $0x8, %edi
callq 0x1130
movq %rax, (%r15)
testq %rax, %rax
je 0xd724
movq 0x8(%rbx), %r12
movq (%r12), %rdi
movq 0x8(%r12), %rax
movq $0x1d, (%rdi,%rax,8)
movq 0x8(%r12), %r15
movq 0x10(%r12), %rsi
leaq 0x1(%r15), %rax
movq %rax, 0x8(%r12)
cmpq %rsi, %rax
jne 0xd6fb
testq %rsi, %rsi
je 0xd6df
leaq (%rsi,%rsi), %rax
movq %rax, 0x10(%r12)
shlq $0x4, %rsi
callq 0x1160
movq 0x8(%rbx), %rdi
movq %rax, (%rdi)
testq %rax, %rax
jne 0xd6fb
callq 0x3b6e
movq $0x1, 0x10(%r12)
movl $0x8, %edi
callq 0x1130
movq %rax, (%r12)
testq %rax, %rax
je 0xd729
subl %r15d, %r14d
addl $-0x2, %r14d
movslq %r14d, %rax
movq 0x8(%rbx), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movq %rax, (%rdx,%rsi,8)
incq 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3bd7
callq 0x3ba6
nop