LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0xbc7b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xbed0
jmp 0xbd95
jmp 0xbc7d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xce8c(%rip), %rsi      # 0x18b1a
leaq 0xde5a(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xd2f3(%rip), %rsi      # 0x18faa
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xbed0
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xbd54
jmp 0xbcf9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xce10(%rip), %rsi      # 0x18b1a
leaq 0xddde(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd2b0(%rip), %rsi      # 0x18fd3
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0xbed0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbce9
jmp 0xbd56
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xbd64
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xcda5(%rip), %rsi      # 0x18b1a
leaq 0xdd73(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd253(%rip), %rsi      # 0x18fe1
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xc050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbdd0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc050
jmp 0xbdd2
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x28, %edi
callq 0x1130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xbe53
movq 0x131ca(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xc7de(%rip), %rsi      # 0x1860e
leaq 0xcc49(%rip), %rdx      # 0x18a80
movl $0x47e, %ecx            # imm = 0x47E
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xbe55
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xbf08
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc180
jmp 0xc03d
jmp 0xbf0a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xcbff(%rip), %rsi      # 0x18b1a
leaq 0xdbcd(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xd0b2(%rip), %rsi      # 0x18ff6
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc180
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xbfaa
jmp 0xbf77
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xcb92(%rip), %rsi      # 0x18b1a
leaq 0xdb60(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd075(%rip), %rsi      # 0x19016
movb $0x0, %al
callq 0x1100
jmp 0xbfe9
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xbfe7
jmp 0xbfb6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xcb53(%rip), %rsi      # 0x18b1a
leaq 0xdb21(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd045(%rip), %rsi      # 0x19025
movb $0x0, %al
callq 0x1100
jmp 0xbfe9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc180
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xc00c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xcafd(%rip), %rsi      # 0x18b1a
leaq 0xdacb(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xcffd(%rip), %rsi      # 0x19033
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xc380
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc080
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc380
jmp 0xc082
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x28, %edi
callq 0x1130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc103
movq 0x12f1a(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xc52e(%rip), %rsi      # 0x1860e
leaq 0xc999(%rip), %rdx      # 0x18a80
movl $0x4b2, %ecx            # imm = 0x4B2
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xc105
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xc3c4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xc6d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc394
jmp 0xc3c6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xc3df
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xc3fa
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x28, %edi
callq 0x1130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc484
movq 0x12b99(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xc1ad(%rip), %rsi      # 0x1860e
leaq 0xc618(%rip), %rdx      # 0x18a80
movl $0x4ea, %ecx            # imm = 0x4EA
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xc486
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xc714
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xca70
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc6e4
jmp 0xc716
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xc72f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xc74a
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x28, %edi
callq 0x1130
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc7d4
movq 0x12849(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xbe5d(%rip), %rsi      # 0x1860e
leaq 0xc2c8(%rip), %rdx      # 0x18a80
movl $0x524, %ecx            # imm = 0x524
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xc7d6
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xcaff
movq 0x1251e(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xbb32(%rip), %rsi      # 0x1860e
leaq 0xbf9d(%rip), %rdx      # 0x18a80
movl $0x55e, %ecx            # imm = 0x55E
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xcb01
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xcc69
jmp 0xcb93
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xbf76(%rip), %rsi      # 0x18b1a
leaq 0xcf44(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xc5a7(%rip), %rsi      # 0x19174
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xcbe2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xbf27(%rip), %rsi      # 0x18b1a
leaq 0xcef5(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xc590(%rip), %rsi      # 0x1919c
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xcea0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xcc36
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xbed3(%rip), %rsi      # 0x18b1a
leaq 0xcea1(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xc552(%rip), %rsi      # 0x191b2
movb $0x0, %al
callq 0x1100
jmp 0xcc7e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xcea0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x5, %rax
ja 0xcd15
movq -0x10(%rbp), %rax
leaq 0xbd80(%rip), %rcx      # 0x18a38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xcfa0
jmp 0xcd3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xcfe0
jmp 0xcd3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9c90
jmp 0xcd3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9a80
jmp 0xcd3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd010
jmp 0xcd3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa030
jmp 0xcd3e
movq 0x122d4(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xbe29(%rip), %rsi      # 0x18b56
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xcd40
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xcdb7
movq 0x12266(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xb87a(%rip), %rsi      # 0x1860e
leaq 0xbce5(%rip), %rdx      # 0x18a80
movl $0x586, %ecx            # imm = 0x586
movl $0x10, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xcdb9
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xce28
movq -0x20(%rbp), %rax
leaq 0xbc7f(%rip), %rcx      # 0x18a50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xce4d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xce4d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xce4d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xce4d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xce4d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xce4d
movq 0x121c1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xbd1a(%rip), %rsi      # 0x18b56
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xcf67
movq -0x20(%rbp), %rax
leaq 0xbb94(%rip), %rcx      # 0x18a68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd110
jmp 0xcf90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd2a0
jmp 0xcf90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd430
jmp 0xcf90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xada0
jmp 0xcf90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd860
jmp 0xcf90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb990
jmp 0xcf90
movq 0x12082(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xbbd7(%rip), %rsi      # 0x18b56
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xd0a0
movq 0x11f7d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xb591(%rip), %rsi      # 0x1860e
leaq 0xb9fc(%rip), %rdx      # 0x18a80
movl $0x5e9, %ecx            # imm = 0x5E9
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xd0a2
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb9e5(%rip), %rsi      # 0x18b1a
leaq 0xc9b3(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xc068(%rip), %rsi      # 0x191c6
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xada0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd740
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xd1a8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb961(%rip), %rsi      # 0x18b1a
leaq 0xc92f(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xc01e(%rip), %rsi      # 0x191f0
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xd23c
movq 0x11de1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xb3f5(%rip), %rsi      # 0x1860e
leaq 0xb860(%rip), %rdx      # 0x18a80
movl $0x60c, %ecx            # imm = 0x60C
movl $0x18, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xd23e
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb855(%rip), %rsi      # 0x18b1a
leaq 0xc823(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xbf18(%rip), %rsi      # 0x19206
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xada0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xd323
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb7e6(%rip), %rsi      # 0x18b1a
leaq 0xc7b4(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xbeda(%rip), %rsi      # 0x19227
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xd3c0
movq 0x11c5d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xb271(%rip), %rsi      # 0x1860e
leaq 0xb6dc(%rip), %rdx      # 0x18a80
movl $0x62d, %ecx            # imm = 0x62D
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xd3c2
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb6c5(%rip), %rsi      # 0x18b1a
leaq 0xc693(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xbdb6(%rip), %rsi      # 0x19234
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xd493
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb676(%rip), %rsi      # 0x18b1a
leaq 0xc644(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xb6de(%rip), %rsi      # 0x18bab
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd740
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xd502
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb607(%rip), %rsi      # 0x18b1a
leaq 0xc5d5(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xb6a5(%rip), %rsi      # 0x18bd1
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd553
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb720
jmp 0xd555
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xd563
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xb5a6(%rip), %rsi      # 0x18b1a
leaq 0xc574(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xbccd(%rip), %rsi      # 0x1925a
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xd600
movq 0x11a1d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xb031(%rip), %rsi      # 0x1860e
leaq 0xb49c(%rip), %rdx      # 0x18a80
movl $0x659, %ecx            # imm = 0x659
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xd602
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xd6cc
movq 0x11951(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xaf65(%rip), %rsi      # 0x1860e
leaq 0xb3d0(%rip), %rdx      # 0x18a80
movl $0x682, %ecx            # imm = 0x682
movl $0x30, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xd6ce
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x20, %edx
callq 0x1040
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xd7fc
movq 0x11821(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xae35(%rip), %rsi      # 0x1860e
leaq 0xb2a0(%rip), %rdx      # 0x18a80
movl $0x69d, %ecx            # imm = 0x69D
movl $0x18, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xd7fe
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, (%rdi)
movl $0x0, 0x20(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rdi)
movl $0x1, 0x20(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x20, %edx
callq 0x1040
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl $0x2, 0x20(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0xdb40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xdb1e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xddc0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdb34
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: print_bytecode_error
void print_bytecode_error(const struct BYTECODE_ERROR*err)
{
    const char*error_str = NULL;

    switch (err->code) {
    case BYTECODE_GENERATOR_OK: {
        error_str = "ok?!";
        break;        
    }
    case BYTECODE_GENERATOR_NO_LOCAL_VARIABLE: {
        error_str = "no local variable!";
        break;
    }
    case BYTECODE_GENERATOR_ALREADY_HAVE_LOCAL_VARIABLE: {
        error_str = "already have local variable!";
        break;
    }
    case BYTECODE_GENERATOR_INVALID_BREAK: {
        error_str = "break outside of while!";
        break;
    }
    case BYTECODE_GENERATOR_INVALID_CONTINUE: {
        error_str = "continue outside of while!";
        break;
    }
    }
    
    fprintf(stderr, "%zu:%zu: error: %s\n",
            err->pos.line, err->pos.pos, error_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x4, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0xe64c
movq -0x18(%rbp), %rax
leaq 0xad78(%rip), %rcx      # 0x1937c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb1ae(%rip), %rax      # 0x197c2
movq %rax, -0x10(%rbp)
jmp 0xe64c
leaq 0xb1a6(%rip), %rax      # 0x197c7
movq %rax, -0x10(%rbp)
jmp 0xe64c
leaq 0xb1ac(%rip), %rax      # 0x197da
movq %rax, -0x10(%rbp)
jmp 0xe64c
leaq 0xb1bc(%rip), %rax      # 0x197f7
movq %rax, -0x10(%rbp)
jmp 0xe64c
leaq 0xb1c7(%rip), %rax      # 0x1980f
movq %rax, -0x10(%rbp)
movq 0x1099d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %r8
leaq 0xb1b9(%rip), %rsi      # 0x1982a
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: assign_stmt_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES assign_stmt_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct ASSIGN_STMT_AST*ast)
{
    enum BYTECODE_GENERATOR_CODES r = assignment_expr_ast_bytecode_generate(bc_gen, ast->assignment);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }    

    return variable_ast_bytecode_generate_inner(bc_gen, ast->var_name, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xf9b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xed12
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xed2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x12b10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: break_stmt_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES break_stmt_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct BREAK_STMT_AST*ast,
                                                                      int**loop_exit_idxs, size_t*loop_exit_idxs_len, size_t*loop_exit_idxs_cap)
{
    int loop_exit_idx;
    
    PREFIX_UNUSED(ast);

    if (loop_exit_idxs == NULL) {
        set_bytecode_generator_error(bc_gen, ast->line, ast->pos, BYTECODE_GENERATOR_INVALID_BREAK);
        return BYTECODE_GENERATOR_INVALID_BREAK;
    }

    loop_exit_idx = emit_jump(bc_gen, BC_OP_JUMP);

    PUSH_BACK(*loop_exit_idxs, loop_exit_idx);

    return BYTECODE_GENERATOR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf61c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
callq 0xfad0
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xf749
movq -0x10(%rbp), %rdi
movl $0x1d, %esi
callq 0x139a0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xf720
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf6b0
movq -0x30(%rbp), %rax
movq $0x1, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1130
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xf6ac
movq 0xf976(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %r8
shlq $0x2, %r8
leaq 0x8f7f(%rip), %rsi      # 0x1860e
leaq 0x9d4a(%rip), %rdx      # 0x193e0
movl $0x2a9, %ecx            # imm = 0x2A9
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xf6ae
jmp 0xf71e
movq -0x30(%rbp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
shlq $0x2, %rsi
callq 0x1150
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xf71a
movq 0xf908(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %r8
shlq $0x2, %r8
leaq 0x9298(%rip), %rsi      # 0x18995
leaq 0x9cdc(%rip), %rdx      # 0x193e0
movl $0x2a9, %ecx            # imm = 0x2A9
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xf71c
jmp 0xf71e
jmp 0xf720
movl -0x34(%rbp), %edx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)