LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_if_stmt_ast
struct IF_STMT_AST*create_if_stmt_ast(struct LOGICAL_OR_EXPR_AST*condition,
                                      struct BODY_AST*if_body,
                                      struct BODY_AST*else_body,
                                      size_t line, size_t pos)
{
    struct IF_STMT_AST*if_stmt;
    SAFE_MALLOC(if_stmt, 1);
    if_stmt->condition = condition;
    if_stmt->if_body = if_body;
    if_stmt->else_body = else_body;

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

// Assembly:
pushq %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 0x9d44
movq 0x152d9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xe8ed(%rip), %rsi      # 0x1860e
leaq 0xed58(%rip), %rdx      # 0x18a80
movl $0x1d6, %ecx            # imm = 0x1D6
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x9d46
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: logical_or_expr_ast_free
void logical_or_expr_ast_free(struct LOGICAL_OR_EXPR_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->and_exprs_len; i++) {
        logical_and_expr_ast_free(ast->and_exprs[i]);
    }
    SAFE_FREE(ast->and_exprs);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xa074
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbaf0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa044
jmp 0xa076
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xa08f
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_while_stmt_ast
struct WHILE_STMT_AST*create_while_stmt_ast(struct LOGICAL_OR_EXPR_AST*condition,
                                            struct BODY_AST*body,
                                            size_t line, size_t pos)
{
    struct WHILE_STMT_AST*while_stmt;
    SAFE_MALLOC(while_stmt, 1);
    while_stmt->condition = condition;
    while_stmt->body = body;

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

// 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 0xa110
movq 0x14f0d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xe521(%rip), %rsi      # 0x1860e
leaq 0xe98c(%rip), %rdx      # 0x18a80
movl $0x214, %ecx            # imm = 0x214
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa112
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_while_stmt_ast_to_file_inner
static void dump_while_stmt_ast_to_file_inner(FILE*f, const struct WHILE_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<while_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "<condition>\n");
    INC_SPACES_NUM();
    dump_logical_or_expr_ast_to_file_inner(f, ast->condition, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</condition>\n");

    dump_body_ast_to_file_inner(f, ast->body, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</while_stmt>\n");
}

// Assembly:
pushq %rbp
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 0xe975(%rip), %rsi      # 0x18b1a
leaq 0xf943(%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 0xebbe(%rip), %rsi      # 0x18d8c
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xa1e3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe926(%rip), %rsi      # 0x18b1a
leaq 0xf8f4(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xeb26(%rip), %rsi      # 0x18d33
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 0xb990
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xa242
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe8c7(%rip), %rsi      # 0x18b1a
leaq 0xf895(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xead4(%rip), %rsi      # 0x18d40
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x8ef0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xa296
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe873(%rip), %rsi      # 0x18b1a
leaq 0xf841(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xeaef(%rip), %rsi      # 0x18daf
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_break_stmt_ast
struct BREAK_STMT_AST*create_break_stmt_ast(size_t line, size_t pos) {
    struct BREAK_STMT_AST*break_stmt;
    SAFE_MALLOC(break_stmt, 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa328
movq 0x14cf5(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xe309(%rip), %rsi      # 0x1860e
leaq 0xe774(%rip), %rdx      # 0x18a80
movl $0x23b, %ecx            # imm = 0x23B
movl $0x10, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa32a
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%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: create_continue_stmt_ast
struct CONTINUE_STMT_AST*create_continue_stmt_ast(size_t line, size_t pos) {
    struct CONTINUE_STMT_AST*continue_stmt;
    SAFE_MALLOC(continue_stmt, 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa428
movq 0x14bf5(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xe209(%rip), %rsi      # 0x1860e
leaq 0xe674(%rip), %rdx      # 0x18a80
movl $0x255, %ecx            # imm = 0x255
movl $0x10, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa42a
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%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: create_append_stmt_ast
struct APPEND_STMT_AST*create_append_stmt_ast(struct VARIABLE_AST*arr, struct IDENT_AST*ident,
                                              size_t line, size_t pos)
{
    struct APPEND_STMT_AST*append_stmt;
    SAFE_MALLOC(append_stmt, 1);

    append_stmt->arr = arr;
    append_stmt->ident = ident;

    append_stmt->line = line;
    append_stmt->pos = pos;

    return append_stmt;
}

// 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 0xa530
movq 0x14aed(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xe101(%rip), %rsi      # 0x1860e
leaq 0xe56c(%rip), %rdx      # 0x18a80
movl $0x271, %ecx            # imm = 0x271
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa532
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_append_stmt_ast_to_file_inner
void dump_append_stmt_ast_to_file_inner(FILE*f, const struct APPEND_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<append_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->arr, spaces_num);
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</append_stmt>\n");
}

// Assembly:
pushq %rbp
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 0xe555(%rip), %rsi      # 0x18b1a
leaq 0xf523(%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 0xe7f8(%rip), %rsi      # 0x18de6
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 0xa638
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe4d1(%rip), %rsi      # 0x18b1a
leaq 0xf49f(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe7a8(%rip), %rsi      # 0x18e0a
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_delete_stmt_ast
struct DELETE_STMT_AST*create_delete_stmt_ast(struct VARIABLE_AST*var, struct IDENT_AST*ident,
                                              size_t line, size_t pos)
{
    struct DELETE_STMT_AST*delete_stmt;
    SAFE_MALLOC(delete_stmt, 1);

    delete_stmt->var = var;
    delete_stmt->ident = ident;

    delete_stmt->line = line;
    delete_stmt->pos = pos;

    return delete_stmt;
}

// 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 0xa6d0
movq 0x1494d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xdf61(%rip), %rsi      # 0x1860e
leaq 0xe3cc(%rip), %rdx      # 0x18a80
movl $0x297, %ecx            # imm = 0x297
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa6d2
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_delete_stmt_ast_to_file_inner
void dump_delete_stmt_ast_to_file_inner(FILE*f, const struct DELETE_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<delete_stmt line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_variable_ast_to_file_inner(f, ast->var, spaces_num);
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</delete_stmt>\n");
}

// Assembly:
pushq %rbp
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 0xe3b5(%rip), %rsi      # 0x18b1a
leaq 0xf383(%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 0xe68c(%rip), %rsi      # 0x18e1a
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 0xa7d8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe331(%rip), %rsi      # 0x18b1a
leaq 0xf2ff(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe63c(%rip), %rsi      # 0x18e3e
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_return_stmt_ast
struct RETURN_STMT_AST*create_return_stmt_ast(struct ASSIGNMENT_EXPR_AST*result,
                                              size_t line, size_t pos)
{
    struct RETURN_STMT_AST*return_stmt;
    SAFE_MALLOC(return_stmt, 1);
    return_stmt->result = result;

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

// Assembly:
pushq %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 0xa86c
movq 0x147b1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xddc5(%rip), %rsi      # 0x1860e
leaq 0xe230(%rip), %rdx      # 0x18a80
movl $0x2bd, %ecx            # imm = 0x2BD
movl $0x18, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa86e
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_return_stmt_ast_to_file_inner
static void dump_return_stmt_ast_to_file_inner(FILE*f, const struct RETURN_STMT_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<return_stmt> line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    if (ast->result != NULL) {
        INC_SPACES_NUM();
        dump_assignment_expr_ast_to_file_inner(f, ast->result, spaces_num);
        DEC_SPACES_NUM();
    }
    PUT_SPACES(); fprintf(f, "</return_stmt>\n");
}

// Assembly:
pushq %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 0xe225(%rip), %rsi      # 0x18b1a
leaq 0xf1f3(%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 0xe530(%rip), %rsi      # 0x18e4e
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa95f
jmp 0xa931
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 0xafb0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xa95f
jmp 0xa961
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe1a8(%rip), %rsi      # 0x18b1a
leaq 0xf176(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe4e8(%rip), %rsi      # 0x18e73
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: create_variable_part_ast
struct VARIABLE_PART_AST*create_variable_part_ast(void*variable_part_ptr, enum AST_VARIABLE_PART_TYPE type)
{
    struct VARIABLE_PART_AST*variable_part;
    SAFE_MALLOC(variable_part, 1);
    switch (type) {
    case AST_VARIABLE_PART_TYPE_FIELD:
        variable_part->field = variable_part_ptr;
        break;
    case AST_VARIABLE_PART_TYPE_INDEX:
        variable_part->index = variable_part_ptr;
        break;
    default:
        fprintf(stderr, "Invalid VARIABLE_EXPR_AST type: %d\n", type);
        exit(EXIT_FAILURE);
        break;        
    }
    variable_part->type = type;
    return variable_part;
}

// Assembly:
pushq %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 0xa9f7
movq 0x14626(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xdc3a(%rip), %rsi      # 0x1860e
leaq 0xe0a5(%rip), %rdx      # 0x18a80
movl $0x2e1, %ecx            # imm = 0x2E1
movl $0x10, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xa9f9
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xaa0f
jmp 0xaa05
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xaa1c
jmp 0xaa29
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xaa4e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xaa4e
movq 0x145c0(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xe06f(%rip), %rsi      # 0x18aac
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_variable_part_ast_to_file_inner
static void dump_variable_part_ast_to_file_inner(FILE*f, const struct VARIABLE_PART_AST*ast, size_t spaces_num)
{
    switch (ast->type) {
    case AST_VARIABLE_PART_TYPE_FIELD:
        PUT_SPACES(); fprintf(f, "<field>\n");
        INC_SPACES_NUM();
        dump_ident_ast_to_file_inner(f, ast->field, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</field>\n");
        break;
    case AST_VARIABLE_PART_TYPE_INDEX:
        PUT_SPACES(); fprintf(f, "<index>\n");
        INC_SPACES_NUM();
        dump_logical_or_expr_ast_to_file_inner(f, ast->index, spaces_num);
        DEC_SPACES_NUM();
        PUT_SPACES(); fprintf(f, "</index>\n");
        break;
    default:
        fprintf(stderr, "Invalid VARIABLE_PART_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;        
    }
}

// Assembly:
pushq %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
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xaad5
jmp 0xaac4
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xab6c
jmp 0xac00
jmp 0xaad7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xe032(%rip), %rsi      # 0x18b1a
leaq 0xf000(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe382(%rip), %rsi      # 0x18e83
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 0xab36
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xdfd3(%rip), %rsi      # 0x18b1a
leaq 0xefa1(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe32c(%rip), %rsi      # 0x18e8c
movb $0x0, %al
callq 0x1100
jmp 0xac29
jmp 0xab6e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xdf9b(%rip), %rsi      # 0x18b1a
leaq 0xef69(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe2fe(%rip), %rsi      # 0x18e96
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 0xb990
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xabcd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xdf3c(%rip), %rsi      # 0x18b1a
leaq 0xef0a(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe2a8(%rip), %rsi      # 0x18e9f
movb $0x0, %al
callq 0x1100
jmp 0xac29
movq 0x143e9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xdeb8(%rip), %rsi      # 0x18ad0
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: variable_part_ast_free
void variable_part_ast_free(struct VARIABLE_PART_AST*ast)
{
    switch (ast->type) {
    case AST_VARIABLE_PART_TYPE_FIELD:
        ident_ast_free(ast->field);
        break;
    case AST_VARIABLE_PART_TYPE_INDEX:
        logical_or_expr_ast_free(ast->index);
        break;
    default:
        fprintf(stderr, "Invalid VARIABLE_PART_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;
    }
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0xac56
jmp 0xac4c
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0xac64
jmp 0xac72
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8b30
jmp 0xac9b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa030
jmp 0xac9b
movq 0x14377(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xde46(%rip), %rsi      # 0x18ad0
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xac9d
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_variable_ast
struct VARIABLE_AST*create_variable_ast(struct IDENT_AST*ident, struct VARIABLE_PART_AST**parts, size_t parts_len,
                                        size_t line, size_t pos)
{
    struct VARIABLE_AST*variable;
    SAFE_MALLOC(variable, 1);
    variable->ident = ident;
    variable->parts = parts;
    variable->parts_len = parts_len;

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

// Assembly:
pushq %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 0xad24
movq 0x142f9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xd90d(%rip), %rsi      # 0x1860e
leaq 0xdd78(%rip), %rdx      # 0x18a80
movl $0x324, %ecx            # imm = 0x324
movl $0x28, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xad26
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: dump_variable_ast_to_file_inner
static void dump_variable_ast_to_file_inner(FILE*f, const struct VARIABLE_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<variable line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    dump_ident_ast_to_file_inner(f, ast->ident, spaces_num);
    for (i = 0; i < ast->parts_len; i++) {
        dump_variable_part_ast_to_file_inner(f, ast->parts[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</variable>\n");
}

// Assembly:
pushq %rbp
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 0xdd55(%rip), %rsi      # 0x18b1a
leaq 0xed23(%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 0xe0bb(%rip), %rsi      # 0x18ea9
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 $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xae56
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0xaaa0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xae1d
jmp 0xae58
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xae66
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xdca3(%rip), %rsi      # 0x18b1a
leaq 0xec71(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xe03a(%rip), %rsi      # 0x18eca
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_assignment_expr_ast
struct ASSIGNMENT_EXPR_AST*create_assignment_expr_ast(void*assignment_ptr, enum AST_ASSIGNMENT_EXPR_TYPE type)
{
    struct ASSIGNMENT_EXPR_AST*assignment_expr;
    SAFE_MALLOC(assignment_expr, 1);
    switch (type) {
    case AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL:
        assignment_expr->object_literal = assignment_ptr;
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL:
        assignment_expr->array_literal = assignment_ptr;
        break;        
    case AST_ASSIGNMENT_EXPR_TYPE_LOGICAL_OR_EXPR:
        assignment_expr->logical_or_expr = assignment_ptr;
        break;
    default:
        fprintf(stderr, "Invalid ASSIGNMENT_EXPR_AST type: %d\n", type);
        exit(EXIT_FAILURE);
        break;
    }
    assignment_expr->type = type;
    return assignment_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 0xaef7
movq 0x14126(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xd73a(%rip), %rsi      # 0x1860e
leaq 0xdba5(%rip), %rdx      # 0x18a80
movl $0x350, %ecx            # imm = 0x350
movl $0x10, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xaef9
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xaf19
jmp 0xaf05
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xaf26
jmp 0xaf0f
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xaf33
jmp 0xaf40
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xaf65
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xaf65
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xaf65
movq 0x140a9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xdba0(%rip), %rsi      # 0x18af4
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: dump_assignment_expr_ast_to_file_inner
static void dump_assignment_expr_ast_to_file_inner(FILE*f, const struct ASSIGNMENT_EXPR_AST*ast, size_t spaces_num)
{
    switch (ast->type) {
    case AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL:
        dump_object_literal_ast_to_file_inner(f, ast->object_literal, spaces_num);
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL:
        dump_array_literal_ast_to_file_inner(f, ast->array_literal, spaces_num);
        break;        
    case AST_ASSIGNMENT_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 ASSIGNMENT_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
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xafe8
jmp 0xafd4
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xaffe
jmp 0xafde
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb014
jmp 0xb02a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb1f0
jmp 0xb053
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb650
jmp 0xb053
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb990
jmp 0xb053
movq 0x13fbf(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xdab2(%rip), %rsi      # 0x18af4
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/ast.c
// Function: object_literal_ast_free
void object_literal_ast_free(struct OBJECT_LITERAL_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->properties_len; i++) {
        property_ast_free(ast->properties[i]);
    }
    SAFE_FREE(ast->properties);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xb0a4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb2e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb074
jmp 0xb0a6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xb0bf
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_object_literal_ast
struct OBJECT_LITERAL_AST*create_object_literal_ast(struct PROPERTY_AST**properties, size_t properties_len,
                                                    size_t line, size_t pos)
{
    struct OBJECT_LITERAL_AST*object_literal;
    SAFE_MALLOC(object_literal, 1);
    object_literal->properties = properties;
    object_literal->properties_len = properties_len;

    object_literal->line = line;
    object_literal->pos = pos;

    return object_literal;
}

// 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 0xb180
movq 0x13e9d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xd4b1(%rip), %rsi      # 0x1860e
leaq 0xd91c(%rip), %rdx      # 0x18a80
movl $0x398, %ecx            # imm = 0x398
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xb182
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_object_literal_ast_to_file_inner
static void dump_object_literal_ast_to_file_inner(FILE*f, const struct OBJECT_LITERAL_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<object_literal line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    for (i = 0; i < ast->properties_len; i++) {
        dump_property_ast_to_file_inner(f, ast->properties[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</object_literal>\n");
}

// Assembly:
pushq %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 0xd905(%rip), %rsi      # 0x18b1a
leaq 0xe8d3(%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 0xdc99(%rip), %rsi      # 0x18ed7
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xb291
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 0xb3f0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb259
jmp 0xb293
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xb2a1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xd868(%rip), %rsi      # 0x18b1a
leaq 0xe836(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xdc33(%rip), %rsi      # 0x18efe
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: create_property_ast
struct PROPERTY_AST*create_property_ast(struct IDENT_AST*key, struct ASSIGNMENT_EXPR_AST*value,
                                        size_t line, size_t pos)
{
    struct PROPERTY_AST*property;
    SAFE_MALLOC(property, 1);
    property->key = key;
    property->value = value;

    property->line = line;
    property->pos = pos;
    
    return 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 0xb380
movq 0x13c9d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xd2b1(%rip), %rsi      # 0x1860e
leaq 0xd71c(%rip), %rdx      # 0x18a80
movl $0x3c4, %ecx            # imm = 0x3C4
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xb382
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_array_literal_ast
struct ARRAY_LITERAL_AST*create_array_literal_ast(struct ARGS_LIST_AST*args_list,
                                                  size_t line, size_t pos)
{
    struct ARRAY_LITERAL_AST*array_literal;
    SAFE_MALLOC(array_literal, 1);
    array_literal->args_list = args_list;

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

// Assembly:
pushq %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 0xb61c
movq 0x13a01(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xd015(%rip), %rsi      # 0x1860e
leaq 0xd480(%rip), %rdx      # 0x18a80
movl $0x3f1, %ecx            # imm = 0x3F1
movl $0x18, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xb61e
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_array_literal_ast_to_file_inner
void dump_array_literal_ast_to_file_inner(FILE*f, const struct ARRAY_LITERAL_AST*ast, size_t spaces_num)
{
    PUT_SPACES(); fprintf(f, "<array_literal line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    if (ast->args_list != NULL) {
        dump_args_list_ast_to_file_inner(f, ast->args_list, spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</array_literal>\n");
}

// Assembly:
pushq %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 0xd4a5(%rip), %rsi      # 0x18b1a
leaq 0xe473(%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 0xd480(%rip), %rsi      # 0x18b1e
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb6cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb720
jmp 0xb6d1
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xb6df
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xd42a(%rip), %rsi      # 0x18b1a
leaq 0xe3f8(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd43b(%rip), %rsi      # 0x18b44
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: dump_args_list_ast_to_file_inner
static void dump_args_list_ast_to_file_inner(FILE*f, const struct ARGS_LIST_AST*ast, size_t spaces_num)
{
    size_t i;
    
    PUT_SPACES(); fprintf(f, "<args_list line=\"%zu\" pos=\"%zu\">\n", ast->line, ast->pos);
    INC_SPACES_NUM();
    for (i = 0; i < ast->assignment_exprs_len; i++) {
        dump_assignment_expr_ast_to_file_inner(f, ast->assignment_exprs[i], spaces_num);
    }
    DEC_SPACES_NUM();
    PUT_SPACES(); fprintf(f, "</args_list>\n");
}

// Assembly:
pushq %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 0xd3d5(%rip), %rsi      # 0x18b1a
leaq 0xe3a3(%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 0xdafe(%rip), %rsi      # 0x1926c
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xb7c1
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 0xafb0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb789
jmp 0xb7c3
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xb7d1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xd338(%rip), %rsi      # 0x18b1a
leaq 0xe306(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xda93(%rip), %rsi      # 0x1928e
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: args_list_ast_free
void args_list_ast_free(struct ARGS_LIST_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->assignment_exprs_len; i++) {
        assignment_expr_ast_free(ast->assignment_exprs[i]);
    }
    SAFE_FREE(ast->assignment_exprs);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xb884
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9810
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb854
jmp 0xb886
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xb89f
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_logical_or_expr_ast
struct LOGICAL_OR_EXPR_AST*create_logical_or_expr_ast(struct LOGICAL_AND_EXPR_AST**and_exprs, size_t and_exprs_len,
                                                      size_t line, size_t pos)
{
    struct LOGICAL_OR_EXPR_AST*logical_or_expr;
    SAFE_MALLOC(logical_or_expr, 1);
    logical_or_expr->and_exprs = and_exprs;
    logical_or_expr->and_exprs_len = and_exprs_len;

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

// Assembly:
pushq %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 0xb920
movq 0x136fd(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xcd11(%rip), %rsi      # 0x1860e
leaq 0xd17c(%rip), %rdx      # 0x18a80
movl $0x418, %ecx            # imm = 0x418
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xb922
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_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
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 0xb9cb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xbc40
jmp 0xbae5
jmp 0xb9cd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xd13c(%rip), %rsi      # 0x18b1a
leaq 0xe10a(%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 0xd55a(%rip), %rsi      # 0x18f61
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 0xbc40
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xbaa4
jmp 0xba49
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xd0c0(%rip), %rsi      # 0x18b1a
leaq 0xe08e(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd516(%rip), %rsi      # 0x18f89
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 0xbc40
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xba39
jmp 0xbaa6
movq -0x18(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xbab4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xd055(%rip), %rsi      # 0x18b1a
leaq 0xe023(%rip), %rcx      # 0x19aef
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0xd4b8(%rip), %rsi      # 0x18f96
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: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xbb34
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbda0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbb04
jmp 0xbb36
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xbb4f
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_logical_and_expr_ast
struct LOGICAL_AND_EXPR_AST*create_logical_and_expr_ast(struct EQ_EXPR_AST**eq_exprs, size_t eq_exprs_len,
                                                        size_t line, size_t pos)
{
    struct LOGICAL_AND_EXPR_AST*logical_and_expr;
    SAFE_MALLOC(logical_and_expr, 1);
    logical_and_expr->eq_exprs = eq_exprs;
    logical_and_expr->eq_exprs_len = eq_exprs_len;

    logical_and_expr->line = line;
    logical_and_expr->pos = pos;
    
    return logical_and_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)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xbbd0
movq 0x1344d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0xca61(%rip), %rsi      # 0x1860e
leaq 0xcecc(%rip), %rdx      # 0x18a80
movl $0x44a, %ecx            # imm = 0x44A
movl $0x20, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xbbd2
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)