LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: continue_stmt_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES continue_stmt_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct CONTINUE_STMT_AST*ast, int*loop_start_idx)
{
    PREFIX_UNUSED(ast);

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

    emit_loop(bc_gen, (*loop_start_idx));

    return BYTECODE_GENERATOR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf7a1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
callq 0xfad0
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xf7b8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x13cd0
movl $0x0, -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: return_stmt_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES return_stmt_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct RETURN_STMT_AST*ast)
{
    if (ast->result != NULL) {
        enum BYTECODE_GENERATOR_CODES r = assignment_expr_ast_bytecode_generate(bc_gen, ast->result);
        if (r != BYTECODE_GENERATOR_OK) {
            return r;
        }
    }

    PUSH_BACK(bc_gen->bc->op_codes, BC_OP_RETURN);

    return BYTECODE_GENERATOR_OK;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf830
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xf9b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xf82e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf99c
jmp 0xf830
jmp 0xf832
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0xf962
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0xf8da
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1130
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xf8d3
movq 0xf754(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
shlq $0x3, %r8
leaq 0x8d58(%rip), %rsi      # 0x1860e
leaq 0x9b23(%rip), %rdx      # 0x193e0
movl $0x2d5, %ecx            # imm = 0x2D5
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xf8d5
jmp 0xf960
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x1150
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xf95c
movq 0xf6cb(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
shlq $0x3, %r8
leaq 0x9056(%rip), %rsi      # 0x18995
leaq 0x9a9a(%rip), %rdx      # 0x193e0
movl $0x2d5, %ecx            # imm = 0x2D5
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0xf95e
jmp 0xf960
jmp 0xf962
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq $0x1e, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -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: assignment_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES assignment_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct ASSIGNMENT_EXPR_AST*ast)
{
    enum BYTECODE_GENERATOR_CODES r;
    
    switch (ast->type) {
    case AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL:
        r = object_literal_ast_bytecode_generate(bc_gen, ast->object_literal);
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL:
        r = array_literal_ast_bytecode_generate(bc_gen, ast->array_literal);
        break;
    case AST_ASSIGNMENT_EXPR_TYPE_LOGICAL_OR_EXPR:
        r = logical_or_expr_ast_bytecode_generate(bc_gen, ast->logical_or_expr);
        break;
    default:
        fprintf(stderr, "Invalid ASSIGNMENT_EXPR_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);
        break;
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xf9e4
jmp 0xf9d0
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xf9f9
jmp 0xf9da
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xfa0e
jmp 0xfa23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xfb50
movl %eax, -0x14(%rbp)
jmp 0xfa4c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xfe90
movl %eax, -0x14(%rbp)
jmp 0xfa4c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x10360
movl %eax, -0x14(%rbp)
jmp 0xfa4c
movq 0xf5c6(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x90b9(%rip), %rsi      # 0x18af4
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movl -0x14(%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: local_variable_index
static int local_variable_index(bytecode_generator_type_t bc_gen, const char*var_name)
{
    int i;
    
    for (i = bc_gen->locals_len - 1; i >= 0; i--) {
        if (strcmp(bc_gen->locals[i].name, var_name) == 0) {
            return i;
        }
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xfabb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0xfaae
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfac2
jmp 0xfab0
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfa7f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
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: constant_pool_push_back
static int constant_pool_push_back(bytecode_type_t bc, struct CONSTANT cnst)
{
    size_t i;

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

    PUSH_BACK(bc->constant_pool, cnst);

    return bc->constant_pool_len - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x10939
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
imulq $0x28, -0x18(%rbp), %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x10c0
cmpl $0x0, %eax
jne 0x10929
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x10a70
jmp 0x1092b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x108ec
jmp 0x1093b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x10a2f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x109bf
movq -0x10(%rbp), %rax
movq $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
imulq $0x28, 0x28(%rax), %rdi
callq 0x1130
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x109bb
movq 0xe665(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
imulq $0x28, 0x28(%rax), %r8
leaq 0x7c70(%rip), %rsi      # 0x1860e
leaq 0x8a3b(%rip), %rdx      # 0x193e0
movl $0x45, %ecx
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x109bd
jmp 0x10a2d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
shlq %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
imulq $0x28, 0x28(%rax), %rsi
callq 0x1150
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x10a29
movq 0xe5f7(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
imulq $0x28, 0x28(%rax), %r8
leaq 0x7f89(%rip), %rsi      # 0x18995
leaq 0x89cd(%rip), %rdx      # 0x193e0
movl $0x45, %ecx
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x10a2b
jmp 0x10a2d
jmp 0x10a2f
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
imulq $0x28, 0x20(%rax), %rax
addq %rax, %rdi
movl $0x28, %edx
callq 0x1120
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: left_unary_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES left_unary_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct LEFT_UNARY_EXPR_AST*ast)
{

    enum BYTECODE_GENERATOR_CODES r = primary_expr_ast_bytecode_generate(bc_gen, ast->expr);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }
    if (ast->op != AST_LEFT_UNARY_OP_PLUS) {
        if (ast->op == AST_LEFT_UNARY_OP_MINUS) {
            PUSH_BACK(bc_gen->bc->op_codes, BC_OP_NEGATE);
        }
    }

    return BYTECODE_GENERATOR_OK;
}

// 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 0x121b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x12015
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1219f
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x12198
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x12196
jmp 0x12031
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0x12161
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x120d9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1130
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x120d2
movq 0xcf55(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
shlq $0x3, %r8
leaq 0x6559(%rip), %rsi      # 0x1860e
leaq 0x7324(%rip), %rdx      # 0x193e0
movl $0x143, %ecx            # imm = 0x143
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x120d4
jmp 0x1215f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x1150
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1215b
movq 0xcecc(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
shlq $0x3, %r8
leaq 0x6857(%rip), %rsi      # 0x18995
leaq 0x729b(%rip), %rdx      # 0x193e0
movl $0x143, %ecx            # imm = 0x143
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x1215d
jmp 0x1215f
jmp 0x12161
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq $0x19, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x12196
jmp 0x12198
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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: primary_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES primary_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct PRIMARY_EXPR_AST*ast)
{
    enum BYTECODE_GENERATOR_CODES r;
    
    switch (ast->type) {
    case AST_PRIMARY_EXPR_TYPE_HAS_PROPERTY:
        r = has_property_expr_ast_bytecode_generate(bc_gen, ast->has_property_expr);
        break;
    case AST_PRIMARY_EXPR_TYPE_LEN:
        r = len_expr_ast_bytecode_generate(bc_gen, ast->len_expr);
        break;
    case AST_PRIMARY_EXPR_TYPE_FUNCTION_CALL:
        r = function_call_expr_ast_bytecode_generate(bc_gen, ast->function_call);
        break;
    case AST_PRIMARY_EXPR_TYPE_VARIABLE:
        r = variable_ast_bytecode_generate(bc_gen, ast->var_name);
        break;
    case AST_PRIMARY_EXPR_TYPE_NUMBER:
        r = number_ast_bytecode_generate(bc_gen, ast->number);
        break;
    case AST_PRIMARY_EXPR_TYPE_LOGICAL_OR_EXPR:
        r = logical_or_expr_ast_bytecode_generate(bc_gen, ast->logical_or_expr);
        break;
    default:
        fprintf(stderr, "Invalid PRIMARY_EXPR_AST type: %d\n", ast->type);
        exit(EXIT_FAILURE);        
        break;
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x1226a
movq -0x20(%rbp), %rax
leaq 0x71e8(%rip), %rcx      # 0x193c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x122a0
movl %eax, -0x14(%rbp)
jmp 0x12293
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x12600
movl %eax, -0x14(%rbp)
jmp 0x12293
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x127b0
movl %eax, -0x14(%rbp)
jmp 0x12293
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x127c0
movl %eax, -0x14(%rbp)
jmp 0x12293
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x127f0
movl %eax, -0x14(%rbp)
jmp 0x12293
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x10360
movl %eax, -0x14(%rbp)
jmp 0x12293
movq 0xcd7f(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x68d4(%rip), %rsi      # 0x18b56
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/bytecode-generator/bytecode-generator.c
// Function: len_expr_ast_bytecode_generate
static enum BYTECODE_GENERATOR_CODES len_expr_ast_bytecode_generate(bytecode_generator_type_t bc_gen, const struct LEN_EXPR_AST*ast)
{
    enum BYTECODE_GENERATOR_CODES r = variable_ast_bytecode_generate_inner(bc_gen, ast->arr, 0);
    if (r != BYTECODE_GENERATOR_OK) {
        return r;
    }
    PUSH_BACK(bc_gen->bc->op_codes, BC_OP_LEN);

    return BYTECODE_GENERATOR_OK;
}

// 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 (%rax), %rsi
xorl %edx, %edx
callq 0x12b10
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x12636
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x127a2
jmp 0x12638
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0x12768
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x126e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1130
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x126d9
movq 0xc94e(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
shlq $0x3, %r8
leaq 0x5f52(%rip), %rsi      # 0x1860e
leaq 0x6d1d(%rip), %rdx      # 0x193e0
movl $0x10c, %ecx            # imm = 0x10C
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x126db
jmp 0x12766
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x1150
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x12762
movq 0xc8c5(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
shlq $0x3, %r8
leaq 0x6250(%rip), %rsi      # 0x18995
leaq 0x6c94(%rip), %rdx      # 0x193e0
movl $0x10c, %ecx            # imm = 0x10C
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x12764
jmp 0x12766
jmp 0x12768
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq $0x1b, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: virtual_machine_conf
void virtual_machine_conf(virtual_machine_type_t vm, bytecode_type_t bc, size_t stack_size, size_t start_heap_size_b, int trace)
{
    vm->bc = bc;
    vm->ip = bc->op_codes;
    
    vm->stack_cap = stack_size;
    SAFE_MALLOC(vm->stack, vm->stack_cap);
    vm->stack_top = vm->stack;

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

    vm->trace = trace;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
imulq $0x18, 0x20(%rax), %rdi
callq 0x1130
movq -0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x140d5
movq 0xaf4b(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x18, 0x20(%rax), %r8
leaq 0x4556(%rip), %rsi      # 0x1860e
leaq 0x589d(%rip), %rdx      # 0x1995c
movl $0x46, %ecx
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x140d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x0, %al
callq 0x15d40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movl -0x24(%rbp), %r8d
callq 0x15db0
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: create_obj
struct OBJECT*create_obj(virtual_machine_type_t vm)
{
    size_t i;

    size_t properties_num = READ_BYTE();
    
    struct OBJECT*obj = garbage_collector_malloc_obj(vm->gc, properties_num);
    
    for (i = 0; i < properties_num; i++) {
        struct VALUE key = virtual_machine_stack_pop(vm);
        struct VALUE val = virtual_machine_stack_pop(vm);
        
        obj->properties[i].key = key.int_val;
        obj->properties[i].val = val;
    }
    
    obj->properties_len = properties_num;
    obj->properties_cap = properties_num * 2;

    return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15e20
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x141ea
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x14210
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x14210
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14173
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
shlq %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: create_arr
struct ARRAY*create_arr(virtual_machine_type_t vm)
{
    size_t i;

    size_t arr_len = READ_BYTE();

    struct ARRAY*arr = garbage_collector_malloc_arr(vm->gc, arr_len);

    for (i = 0; i < arr_len; i++) {
        struct VALUE val = virtual_machine_stack_pop(vm);
        arr->values[i] = val;
    }
    arr->len = arr_len;

    return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x16200
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x142df
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x14210
movq -0x20(%rbp), %rax
addq $0x10, %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14293
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_conf
void garbage_collector_conf(garbage_collector_type_t gc, size_t sizemem_start, struct VALUE**stack, struct VALUE**stack_top, int trace)
{
    gc->stack = stack;
    gc->stack_top = stack_top;
    allocator_malloc_pool(&(gc->a), sizemem_start);
    allocator_malloc_pool(&(gc->b), sizemem_start);

    gc->trace = trace;
}

// 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 %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x16c80
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
callq 0x16c80
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_malloc_obj
struct OBJECT*garbage_collector_malloc_obj(garbage_collector_type_t gc, size_t start_properties_num)
{
    size_t start_properties_cap = start_properties_num * 2;
    size_t sizemem = sizeof(char) + sizeof(struct OBJECT) + sizeof(struct PROPERTY) * start_properties_cap;
    
    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return malloc_obj_force(gc, start_properties_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, NULL, sizemem);

    return malloc_obj_force(gc, start_properties_cap, sizemem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq $0x11, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x15e86
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x1(%rax), %rax
movq -0x28(%rbp), %rcx
addq $0x22, %rcx
cmpq %rcx, %rax
jb 0x15e86
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x15ec0
movq %rax, -0x8(%rbp)
jmp 0x15eac
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x15f20
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x15ec0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: malloc_obj_force
static struct OBJECT*malloc_obj_force(garbage_collector_type_t gc, size_t start_properties_cap, size_t sizemem)
{
    struct OBJECT*obj;
    char*ptr = allocator_malloc_block(&(gc->a), sizemem);

    ptr[0] = VALUE_TYPE_OBJ;
    obj = (struct OBJECT*) (ptr + 1);
    obj->properties_len = 0;
    obj->properties_cap = start_properties_cap;
    
    return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x16ec0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x2, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: run_gc
static void run_gc(garbage_collector_type_t gc, void**ptr, size_t ptr_sizemem)
{
    struct ALLOCATOR tmp;

    int need_realloc;

    if (gc->trace) {
        printf("\t<info>GC</info>\n");
    }

    run_gc_inner(gc, ptr);

    /* check if realloc is needed. */
    need_realloc = ((gc->b.busy_list.sizemem + gc->b.busy_list.count * BLOCK_OVERHEAD) +
                    (ptr_sizemem + BLOCK_OVERHEAD)) >= gc->b.sizemem / 2;

    if (need_realloc) {
        size_t new_sizemem = (gc->b.sizemem + (ptr_sizemem + BLOCK_OVERHEAD)) * 2;

        tmp = gc->a;
        gc->a = gc->b;
        gc->b = tmp;
        
        allocator_free_pool(&(gc->b));
        allocator_malloc_pool(&(gc->b), new_sizemem);

        run_gc_inner(gc, ptr);

        allocator_free_pool(&(gc->a));
        allocator_malloc_pool(&(gc->a), new_sizemem);
    }

    tmp = gc->a;
    gc->a = gc->b;
    gc->b = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
je 0x15f52
leaq 0x3cfc(%rip), %rdi      # 0x19c47
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16410
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x8(%rbp), %rcx
imulq $0x22, 0xa0(%rcx), %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
addq $0x22, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0x16050
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x22, %rcx
addq %rcx, %rax
shlq %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdi
movl $0x50, %edx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
movl $0x50, %edx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x68(%rbp), %rsi
movl $0x50, %edx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x16e90
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x78(%rbp), %rsi
callq 0x16c80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16410
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x16e90
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x78(%rbp), %rsi
callq 0x16c80
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdi
movl $0x50, %edx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
movl $0x50, %edx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x68(%rbp), %rsi
movl $0x50, %edx
callq 0x1120
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_realloc_obj
struct OBJECT*garbage_collector_realloc_obj(garbage_collector_type_t gc, struct OBJECT*obj, size_t new_properties_num)
{
    size_t new_properties_cap = new_properties_num * 2;
    size_t sizemem = sizeof(char) + sizeof(struct OBJECT) + sizeof(struct PROPERTY) * new_properties_cap;

    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return realloc_obj_force(gc, obj, new_properties_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, (void**) &obj, sizemem);

    return realloc_obj_force(gc, obj, new_properties_cap, sizemem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq $0x11, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1610e
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x1(%rax), %rax
movq -0x30(%rbp), %rcx
addq $0x22, %rcx
cmpq %rcx, %rax
jb 0x1610e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x16150
movq %rax, -0x8(%rbp)
jmp 0x16138
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0x15f20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x16150
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: realloc_obj_force
static struct OBJECT*realloc_obj_force(garbage_collector_type_t gc,
                                       struct OBJECT*obj,
                                       size_t new_properties_cap, size_t sizemem)
{
    char*prev_ptr = ((char*) obj) - 1;
    char*new_ptr = allocator_realloc_block(&(gc->a), prev_ptr, sizemem);

    change_one_ptr(gc, prev_ptr, new_ptr);
    obj = (struct OBJECT*) (new_ptr + 1);
    obj->properties_cap = new_properties_cap;

    return obj;
}

// 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 -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17320
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x16820
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_malloc_arr
struct ARRAY*garbage_collector_malloc_arr(garbage_collector_type_t gc, size_t arr_len)
{
    size_t start_arr_cap = arr_len * 2;
    size_t sizemem = sizeof(char) + sizeof(struct ARRAY) + sizeof(struct VALUE) * start_arr_cap;
    
    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return malloc_arr_force(gc, start_arr_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, NULL, sizemem);

    return malloc_arr_force(gc, start_arr_cap, sizemem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
imulq $0x18, -0x20(%rbp), %rax
addq $0x11, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x16263
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x1(%rax), %rax
movq -0x28(%rbp), %rcx
addq $0x22, %rcx
cmpq %rcx, %rax
jb 0x16263
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x162a0
movq %rax, -0x8(%rbp)
jmp 0x16289
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x15f20
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x162a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_realloc_arr
struct ARRAY*garbage_collector_realloc_arr(garbage_collector_type_t gc, struct ARRAY*arr, size_t new_arr_len)
{
    size_t new_arr_cap = new_arr_len * 2;
    size_t sizemem = sizeof(struct ARRAY) + sizeof(struct VALUE) * new_arr_cap;

    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return realloc_arr_force(gc, arr, new_arr_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, (void**) &arr, sizemem);

    return realloc_arr_force(gc, arr, new_arr_cap, sizemem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
imulq $0x18, -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1636b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x1(%rax), %rax
movq -0x30(%rbp), %rcx
addq $0x22, %rcx
cmpq %rcx, %rax
jb 0x1636b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x163a0
movq %rax, -0x8(%rbp)
jmp 0x16395
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0x15f20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x163a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: lookup_new_location
static void*lookup_new_location(garbage_collector_type_t gc, void*ptr)
{
    void*o = BLOCK_PTR_FROM_DATA((((char*) ptr) - 1));
    
    if (ptrs_map_get(&(gc->ptrs_map), o) == NULL) {
        ptrs_map_set(&(gc->ptrs_map), o, gc->b.free_list.first);

        allocator_malloc_block(&(gc->b), BLOCK_L_DATA_LEN(o));
        memcpy(BLOCK_DATA(gc->b.busy_list.last), BLOCK_DATA(o), BLOCK_L_DATA_LEN(o));
    }

    return (((char*) BLOCK_DATA(ptrs_map_get(&(gc->ptrs_map), o))) + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
addq $-0x8, %rax
addq $-0x8, %rax
addq $-0x8, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x18(%rbp), %rsi
callq 0x16ba0
cmpq $0x0, %rax
jne 0x167e3
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdx
callq 0x16a70
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rax
movq 0x1(%rax), %rsi
callq 0x16ec0
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
addq $0x1, %rdi
addq $0x8, %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
addq $0x8, %rsi
addq $0x8, %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rax
movq 0x1(%rax), %rdx
callq 0x1120
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
movq -0x18(%rbp), %rsi
callq 0x16ba0
addq $0x1, %rax
addq $0x8, %rax
addq $0x8, %rax
addq $0x8, %rax
addq $0x1, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: change_one_ptr
static void change_one_ptr(garbage_collector_type_t gc, char*prev_ptr, char*new_ptr)
{
    struct VALUE*stack = (*(gc->stack));
    struct VALUE*stack_top = (*(gc->stack_top));

    struct VALUE*val;
    
    void*cur;

    for (val = stack; val != stack_top; val++) {
        change_vals_ptr(val, prev_ptr, new_ptr);
    }

    cur = gc->a.busy_list.first;

    while (cur != NULL) {
        size_t i;
        char*ptr = BLOCK_DATA(cur);
        if (ptr[0] == VALUE_TYPE_OBJ) {
            struct OBJECT*obj = (struct OBJECT*) (ptr + 1);
            for (i = 0; i < obj->properties_len; i++) {
                val = &(obj->properties[i].val);
                change_vals_ptr(val, prev_ptr, new_ptr);
            }
        } else if (ptr[0] == VALUE_TYPE_ARR) {
            size_t i;
            struct ARRAY*arr = (struct ARRAY*) (ptr + 1);
            for (i = 0; i < arr->len; i++) {
                val = &(arr->values[i]);
                change_vals_ptr(val, prev_ptr, new_ptr);
            }
        }
        cur = BLOCK_LIST_NEXT(cur);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x16882
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x169a0
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x16859
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1698f
movq -0x38(%rbp), %rax
addq $0x1, %rax
addq $0x8, %rax
addq $0x8, %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2, %eax
jne 0x1691a
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x16918
movq -0x50(%rbp), %rax
addq $0x10, %rax
movq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x169a0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x168d1
jmp 0x1697e
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3, %eax
jne 0x1697c
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1697a
movq -0x60(%rbp), %rax
addq $0x10, %rax
imulq $0x18, -0x58(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x169a0
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x1693a
jmp 0x1697c
jmp 0x1697e
movq -0x38(%rbp), %rax
movq 0x11(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1688e
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: change_vals_ptr
static void change_vals_ptr(struct VALUE*val, char*prev_ptr, char*new_ptr)
{
    if ((val->type == VALUE_TYPE_OBJ) &&
        (val->obj_val == (struct OBJECT*) (prev_ptr + 1))) {
        val->obj_val = (struct OBJECT*) (new_ptr + 1);
    } else if ((val->type == VALUE_TYPE_ARR) &&
               (val->arr_val == (struct ARRAY*) (prev_ptr + 1))) {
        val->arr_val = (struct ARRAY*) (new_ptr + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x169e1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x169e1
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x16a12
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x16a10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x16a10
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x16a12
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/ptrs-map.c
// Function: ptrs_map_set
void ptrs_map_set(ptrs_map_type_t pm, void*key, void*val)
{
    size_t i;

    if (key == NULL) {
        fprintf(stderr, "insertion null-key in map is prohibited\n");
        exit(1);
    }

    for (i = 0; i < pm->len; i++) {
        if (pm->elems[i].key == key) {
            pm->elems[i].val = val;
            return;
        }
    }

    if (pm->len == pm->cap) {
        fprintf(stderr, "non enough memory in map to handle new value\n");
        exit(1);
    }

    pm->elems[pm->len].key = key;
    pm->elems[pm->len].val = val;
    pm->len++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16aad
movq 0x855e(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
leaq 0x31bd(%rip), %rsi      # 0x19c59
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x16b0d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x16afd
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x16b8c
jmp 0x16aff
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16ab5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x16b41
movq 0x84ca(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
leaq 0x3152(%rip), %rsi      # 0x19c82
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/ptrs-map.c
// Function: ptrs_map_get
void*ptrs_map_get(ptrs_map_type_t pm, void*key)
{
    size_t i;

    if (key == NULL) {
        fprintf(stderr, "selection by null-key from map is prohibited\n");
        exit(1);
    }

    for (i = 0; i < pm->len; i++) {
        if (pm->elems[i].key == key) {
            return pm->elems[i].val;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16bd9
movq 0x8432(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
leaq 0x30e8(%rip), %rsi      # 0x19cb0
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x16c36
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x16c26
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x16c3e
jmp 0x16c28
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16be1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_malloc_pool
void allocator_malloc_pool(allocator_type_t a, size_t sizemem)
{
    if (sizemem < MIN_BLOCK_LEN) {
        fprintf(stderr, "not enough memory for allocator:\n");
        fprintf(stderr, "got:         %ld bytes\n", sizemem);
        fprintf(stderr, "minimum:     %ld bytes;\n", MIN_BLOCK_LEN);
        fprintf(stderr, "recommended: %ld bytes;\n", MIN_BLOCK_LEN * 1024 * 1024);
        
        exit(EXIT_FAILURE);
    }
    
    a->sizemem = sizemem;
    SAFE_MALLOC(a->mem, a->sizemem);

    allocator_clean_pool(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x23, -0x10(%rbp)
jae 0x16d0f
movq 0x8352(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
leaq 0x3036(%rip), %rsi      # 0x19cde
movb $0x0, %al
callq 0x1100
movq 0x833a(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x303c(%rip), %rsi      # 0x19d00
movb $0x0, %al
callq 0x1100
movq 0x831e(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
leaq 0x303c(%rip), %rsi      # 0x19d18
movl $0x23, %edx
movb $0x0, %al
callq 0x1100
movq 0x8301(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
leaq 0x3038(%rip), %rsi      # 0x19d31
movl $0x2300000, %edx        # imm = 0x2300000
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
shlq $0x0, %rdi
callq 0x1130
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x16d73
movq 0x82b0(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
shlq $0x0, %r8
leaq 0x18b8(%rip), %rsi      # 0x1860e
leaq 0x2fed(%rip), %rdx      # 0x19d4a
movl $0x11, %ecx
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x16d75
movq -0x8(%rbp), %rdi
callq 0x16d90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_clean_pool
void allocator_clean_pool(allocator_type_t a)
{
    size_t len = a->sizemem - BLOCK_OVERHEAD;

    BLOCK_L_FLAG(a->mem) = FREE_BLOCK;
    BLOCK_L_DATA_LEN(a->mem) = len;
    BLOCK_LIST_PREV(a->mem) = NULL;
    BLOCK_LIST_NEXT(a->mem) = NULL;
    BLOCK_R_DATA_LEN(a->mem) = len;
    BLOCK_R_FLAG(a->mem) = FREE_BLOCK;

    a->free_list.first = a->mem;
    a->free_list.last = a->mem;
    a->free_list.count = 1;
    a->free_list.sizemem = a->sizemem - BLOCK_OVERHEAD;

    a->busy_list.first = NULL;
    a->busy_list.last = NULL;
    a->busy_list.count = 0;
    a->busy_list.sizemem = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x22, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x9(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x11(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x1(%rcx), %rcx
shlq $0x0, %rcx
movq %rdx, 0x19(%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x1(%rcx), %rcx
shlq $0x0, %rcx
movb $0x0, 0x21(%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x22, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
popq %rbp
retq
nopl (%rax)