LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_init
runt_int runt_init(runt_vm *vm)
{
    vm->status = 0;
    vm->zproc = runt_proc_zero;
    vm->nil = runt_mk_ptr(RUNT_NIL, NULL);

    /* init stack */

    runt_stack_init(vm, &vm->stack);

    /* init dictionary */

    runt_dictionary_init(vm);

    /* record cells being parsed by default */

    runt_set_state(vm, RUNT_MODE_INTERACTIVE, RUNT_OFF);
    runt_set_state(vm, RUNT_MODE_RUNNING, RUNT_ON);

    vm->level = 0;
    vm->pos = 0;

    /* set print output to STDERR by default */
    vm->fp = stderr;

    /* set up plugin handle list */
    runt_list_init(&vm->plugins);

    vm->nwords = 0;
    vm->loader = load_nothing;

    runt_cell_bind(vm, &vm->empty, vm->zproc);
    runt_cell_data(vm, &vm->empty, vm->nil);

    runt_print_set(vm, runt_print_default);

    /* set up destructor list */
    runt_list_init(&vm->dtors);

    /* set up registers */
    runt_registers_init(vm);

    vm->anon = NULL;

    vm->last_cell_called = &vm->empty;

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x1158(%rax)
movq -0x8(%rbp), %rax
leaq 0x19b(%rip), %rcx       # 0x14a0
movq %rcx, 0x1160(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x14b0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x1168(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x1170(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x1178(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x14d0
movq -0x8(%rbp), %rdi
callq 0x1510
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1550
movq -0x8(%rbp), %rdi
movl $0x8, %esi
movl $0x3, %edx
callq 0x1550
movq -0x8(%rbp), %rax
movl $0x0, 0x11b8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x11bc(%rax)
movq 0xbc51(%rip), %rax      # 0xcff8
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x11d8(%rax)
movq -0x8(%rbp), %rdi
addq $0x11c0, %rdi           # imm = 0x11C0
callq 0x15b0
movq -0x8(%rbp), %rax
movl $0x0, 0x11f8(%rax)
movq -0x8(%rbp), %rax
leaq 0x1f2(%rip), %rcx       # 0x15d0
movq %rcx, 0x1200(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1190, %rsi           # imm = 0x1190
movq -0x8(%rbp), %rax
movq 0x1160(%rax), %rdx
callq 0x15e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1190, %rsi           # imm = 0x1190
movq -0x8(%rbp), %rax
addq $0x1168, %rax           # imm = 0x1168
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1610
movq -0x8(%rbp), %rdi
leaq 0x22a(%rip), %rsi       # 0x1670
callq 0x1650
movq -0x8(%rbp), %rdi
addq $0x1210, %rdi           # imm = 0x1210
callq 0x15b0
movq -0x8(%rbp), %rdi
callq 0x16b0
movq -0x8(%rbp), %rax
movq $0x0, 0x14a8(%rax)
movq -0x8(%rbp), %rcx
addq $0x1190, %rcx           # imm = 0x1190
movq -0x8(%rbp), %rax
movq %rcx, 0x14b0(%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_set_state
runt_int runt_set_state(runt_vm *vm, runt_uint mode, runt_uint state)
{
    runt_int rc = RUNT_OK;

    if(state == RUNT_ON) {
        vm->status |= mode;
    } else if(state == RUNT_OFF) {
        vm->status &= ~(mode);
    } else {
       rc = RUNT_NOT_OK;
    }

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x3, -0x10(%rbp)
jne 0x1580
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
orl 0x1158(%rax), %ecx
movl %ecx, 0x1158(%rax)
jmp 0x15a7
cmpl $0x4, -0x10(%rbp)
jne 0x159e
movl -0xc(%rbp), %ecx
xorl $-0x1, %ecx
movq -0x8(%rbp), %rax
andl 0x1158(%rax), %ecx
movl %ecx, 0x1158(%rax)
jmp 0x15a5
movl $0x0, -0x14(%rbp)
jmp 0x15a7
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_reinit
runt_int runt_reinit(runt_vm *vm)
{
    runt_init(vm);
    runt_cell_pool_set(vm, vm->cell_pool.cells, vm->cell_pool.size);
    runt_cell_pool_init(vm);
    runt_memory_pool_set(vm, vm->memory_pool.data, vm->memory_pool.size);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x510(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x518(%rax), %edx
callq 0x1770
movq -0x8(%rbp), %rdi
callq 0x17b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x528(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x530(%rax), %edx
callq 0x1820
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_pool_set
runt_int runt_cell_pool_set(runt_vm *vm, runt_cell *cells, runt_uint size)
{
    vm->cell_pool.cells = cells;
    vm->cell_pool.size = size;
    vm->cell_pool.used = 0;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x510(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x518(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x51c(%rax)
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_pool_init
runt_int runt_cell_pool_init(runt_vm *vm)
{
    runt_uint i;
    runt_cell *cells = vm->cell_pool.cells;

    for(i = 0; i < vm->cell_pool.size; i++) {
       runt_cell_clear(vm, &cells[i]);
    }
    vm->cell_pool.mark = 0;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x510(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x518(%rcx), %eax
jae 0x1803
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x1d60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17d2
movq -0x8(%rbp), %rax
movl $0x0, 0x520(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_memory_pool_set
runt_int runt_memory_pool_set(runt_vm *vm, unsigned char *buf, runt_uint size)
{
    vm->memory_pool.data = buf;
    vm->memory_pool.size = size;
    vm->memory_pool.used = 0;
    vm->memory_pool.mark = 0;
    memset(buf, 0, size);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x528(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x530(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x534(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x538(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x1090
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_load_minimal
runt_int runt_load_minimal(runt_vm *vm)
{
    /* create float type */
    runt_cell_malloc(vm, &vm->f_cell);
    runt_cell_bind(vm, vm->f_cell, rproc_float);

    /* create string type */
    runt_cell_malloc(vm, &vm->s_cell);
    runt_cell_bind(vm, vm->s_cell, rproc_string);

    /* ability to create procedures by default */
    runt_keyword_define_with_copy(vm, ":", 1, vm->zproc, rproc_begin, NULL);
    runt_keyword_define_with_copy(vm, ";", 1, vm->zproc, rproc_end, NULL);

    /* [ and ] for rec, stop */
    runt_keyword_define(vm, "[", 1, rproc_rec, NULL);
    runt_keyword_define_with_copy(vm, "]", 1, vm->zproc, rproc_stop, NULL);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1180, %rsi           # imm = 0x1180
callq 0x19b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1180(%rax), %rsi
leaq 0x15a(%rip), %rdx       # 0x1a20
callq 0x15e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1188, %rsi           # imm = 0x1188
callq 0x19b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1188(%rax), %rsi
leaq 0x1ab(%rip), %rdx       # 0x1aa0
callq 0x15e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1160(%rax), %rcx
leaq 0x79f8(%rip), %rsi      # 0x9308
movl $0x1, %edx
leaq 0x2a4(%rip), %r8        # 0x1bc0
xorl %eax, %eax
movl %eax, %r9d
callq 0x1b00
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1160(%rax), %rcx
leaq 0x79ce(%rip), %rsi      # 0x930a
movl $0x1, %edx
leaq 0x2b8(%rip), %r8        # 0x1c00
xorl %eax, %eax
movl %eax, %r9d
callq 0x1b00
movq -0x8(%rbp), %rdi
leaq 0x79af(%rip), %rsi      # 0x930c
movl $0x1, %edx
leaq 0x347(%rip), %rcx       # 0x1cb0
xorl %eax, %eax
movl %eax, %r8d
callq 0x1c70
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1160(%rax), %rcx
leaq 0x7985(%rip), %rsi      # 0x930e
movl $0x1, %edx
leaq 0x34b(%rip), %r8        # 0x1ce0
xorl %eax, %eax
movl %eax, %r9d
callq 0x1b00
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_malloc
runt_int runt_cell_malloc(runt_vm *vm, runt_cell **cell)
{
    runt_uint id;
    id = runt_malloc(vm, sizeof(runt_cell), (void **)cell);
    if(id == 0) return RUNT_NOT_OK;
    runt_cell_clear(vm, *cell);
    (*cell)->id = 0;
    return RUNT_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), %rdx
movl $0x28, %esi
callq 0x2060
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x19e4
movl $0x0, -0x4(%rbp)
jmp 0x1a09
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1d60
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x24(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: rproc_float
static int rproc_float(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_float *f;
    runt_int rc;

    f = runt_to_float(p);
    rc = runt_ppush(vm, &s);
    RUNT_ERROR_CHECK(rc);

    s->f = *f;
    s->t = RUNT_FLOAT;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x24c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2780
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1a71
movl $0x0, -0x4(%rbp)
jmp 0x1a93
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: rproc_string
static int rproc_string(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;

    s = runt_push(vm);
    s->p = p;
    s->t = RUNT_STRING;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21d0
movq -0x18(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_keyword_define_with_copy
runt_int runt_keyword_define_with_copy(runt_vm *vm,
        const char *name,
        runt_uint size,
        runt_proc proc,
        runt_copy_proc copy,
        runt_cell **pcell)
{
    runt_cell *cell;
    runt_entry *entry;
    runt_int rc;
    cell = NULL;
    entry = NULL;
    rc = runt_cell_malloc(vm, &cell);
    RUNT_ERROR_CHECK(rc);
    runt_cell_bind(vm, cell, proc);
    runt_entry_create(vm, cell, &entry);
    runt_entry_set_copy_proc(entry, copy);
    runt_word(vm, name, size, entry);
    if(pcell != NULL) *pcell = cell;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x19b0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x1b4e
movl $0x0, -0x4(%rbp)
jmp 0x1baa
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x15e0
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x2b30
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2bc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x2c50
cmpq $0x0, -0x38(%rbp)
je 0x1ba3
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: rproc_end
static int rproc_end(runt_vm *vm, runt_cell *src, runt_cell *dst)
{
    runt_stacklet *s = runt_peak(vm);
    runt_cell *proc = runt_to_cell(s->p);
    runt_cell_undo(vm);
    proc->psize--;
    return runt_proc_end(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fe0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2010
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45b0
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x2270
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: rproc_stop
static int rproc_stop(runt_vm *vm, runt_cell *src, runt_cell *dst)
{
    runt_cell_undo(vm);
    runt_set_state(vm, RUNT_MODE_INTERACTIVE, RUNT_ON);
    runt_mark_set(vm);
    return RUNT_OK;
}

// 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
callq 0x45b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x1550
movq -0x8(%rbp), %rdi
callq 0x4690
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_new
runt_uint runt_cell_new(runt_vm *vm, runt_cell **cell)
{
    runt_uint id;
    runt_cell_pool *pool = &vm->cell_pool;
    runt_cell *proc;
    runt_stacklet *s;

    pool->used++;

    if(runt_get_state(vm, RUNT_MODE_PANIC) == RUNT_ON) {
        return 0;
    }else if(pool->used >= pool->size) {
        runt_print(vm, "Oh dear. Runt cell pool space at maximum.\n");
        runt_set_state(vm, RUNT_MODE_PANIC, RUNT_ON);
        runt_set_state(vm, RUNT_MODE_RUNNING, RUNT_OFF);
        return 0;
    }

    if(vm->status & RUNT_MODE_PROC) {
        s = runt_peak(vm);
        proc = runt_to_cell(s->p);
        proc->psize++;
    }

    id = pool->used;
    *cell = &pool->cells[id - 1];
    (*cell)->id = id;
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax            # imm = 0x510
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x1f00
cmpl $0x3, %eax
jne 0x1e0a
movl $0x0, -0x4(%rbp)
jmp 0x1ef0
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x1e5e
movq -0x10(%rbp), %rdi
leaq 0x74eb(%rip), %rsi      # 0x9310
movb $0x0, %al
callq 0x1f40
movq -0x10(%rbp), %rdi
movl $0x20, %esi
movl $0x3, %edx
callq 0x1550
movq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x4, %edx
callq 0x1550
movl $0x0, -0x4(%rbp)
jmp 0x1ef0
jmp 0x1e60
movq -0x10(%rbp), %rax
movl 0x1158(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1eb6
movq -0x10(%rbp), %rdi
callq 0x1fe0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2010
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x24(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_to_cell
runt_cell * runt_to_cell(runt_ptr p)
{
    runt_cell *cell = NULL;
    /* TODO: error handling */
    if(p.type == RUNT_CELL) {
        cell = (runt_cell *)p.ud;
    } else {
        fprintf(stderr, "Not a cell!\n");
    }
    return cell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
cmpl $0x6, (%rax)
jne 0x203b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2053
movq 0xafb6(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x7310(%rip), %rsi      # 0x935c
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_malloc
runt_uint runt_malloc(runt_vm *vm, size_t size, void **ud)
{

    runt_memory_pool *pool = &vm->memory_pool;
    runt_uint id = 0;

#ifdef ALIGNED_MALLOC
    if(size % 4 != 0) {
        size = ((size/4) + 1) * 4;
    }
#endif

    /* TODO: overload error handling */
    if(pool->used + size >= pool->size) {
        return 0;
    }

    *ud = (void *)&pool->data[pool->used];

    id = pool->used + 1;
    pool->used += size;

    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x528, %rax            # imm = 0x528
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
addq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jb 0x20a5
movl $0x0, -0x4(%rbp)
jmp 0x20e1
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0xc(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_proc_begin
runt_int runt_proc_begin(runt_vm *vm, runt_cell *proc)
{
    runt_stacklet *s = runt_push(vm);
    runt_set_state(vm, RUNT_MODE_PROC, RUNT_ON);
    s->p = runt_mk_ptr(RUNT_CELL, (void *)proc);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x1550
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movl $0x6, %esi
callq 0x14b0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_push
runt_stacklet * runt_push(runt_vm *vm)
{
    /*TODO: wrapper for ppush */
    runt_stacklet *s;
   /*TODO: error handling for stack overflows */
    if(runt_stack_pos(vm, &vm->stack) == vm->stack.size) {
        runt_print(vm, "stack overflow!\n");
        s = &vm->stack.stack[0];
        return NULL;
    }

    runt_stack_inc(vm, &vm->stack);
    s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack) - 1];
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
movq -0x10(%rbp), %rcx
cmpl 0x504(%rcx), %eax
jne 0x2219
movq -0x10(%rbp), %rdi
leaq 0x71a9(%rip), %rsi      # 0x93a9
movb $0x0, %al
callq 0x1f40
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x225a
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2750
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
movl %eax, %ecx
movq -0x20(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_exec
runt_int runt_cell_exec(runt_vm *vm, runt_cell *cell)
{
    runt_uint i;
    runt_int rc = RUNT_OK;

    if(cell == NULL) {
        runt_print(vm, "Could not execute. Cell is NULL\n");
        return RUNT_NOT_OK;
    }

    if(cell->psize == 0) {
        return runt_cell_call(vm, cell);
    }

    for(i = 1; i <= cell->psize; i++) {
        if(cell[i].psize == 0) {
            rc = runt_cell_call(vm, &cell[i]);
        } else {
            rc = runt_cell_exec(vm, &cell[i]);
        }
        RUNT_ERROR_CHECK(rc);
    }

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x231c
movq -0x10(%rbp), %rdi
leaq 0x7032(%rip), %rsi      # 0x933b
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x23b7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x2338
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20f0
movl %eax, -0x4(%rbp)
jmp 0x23b7
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
ja 0x23b1
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jne 0x237b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x20f0
movl %eax, -0x20(%rbp)
jmp 0x2395
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x22e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x23a4
movl $0x0, -0x4(%rbp)
jmp 0x23b7
jmp 0x23a6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x233f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_to_float
runt_float * runt_to_float(runt_ptr p)
{
    runt_float *f = NULL;

    /* TODO: error handling */
    if(p.type == RUNT_FLOAT) {
        f = (runt_float *)p.ud;
    }

    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
cmpl $0x1, (%rax)
jne 0x24e5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_mk_float
runt_ptr runt_mk_float(runt_vm *vm, runt_float ival)
{
    runt_ptr p;
    float *val;
    val = NULL;
    p.pos = runt_malloc(vm, sizeof(runt_float), (void**)&val);
    p = runt_mk_ptr(RUNT_FLOAT, val);
    *val = ival;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq -0x18(%rbp), %rdx
callq 0x2060
movq -0x40(%rbp), %rdi
movl %eax, 0x10(%rdi)
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x14b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rcx
movss %xmm0, (%rcx)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_memory_pool_get
runt_int runt_memory_pool_get(runt_vm *vm, runt_uint id, void **ud)
{
    if(id > runt_memory_pool_size(vm)) {
        runt_print(vm, "Memory ID out of bounds!\n");
        return RUNT_NOT_OK;
    }
    if(id == 0) {
        runt_print(vm, "Memory ID has illegal value of zero.\n");
        return RUNT_NOT_OK;
    }
    *ud = &vm->memory_pool.data[id - 1];
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2610
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jbe 0x25b6
movq -0x10(%rbp), %rdi
leaq 0x6dc3(%rip), %rsi      # 0x9369
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x25fb
cmpl $0x0, -0x14(%rbp)
jne 0x25d7
movq -0x10(%rbp), %rdi
leaq 0x6dbc(%rip), %rsi      # 0x9383
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x25fb
movq -0x10(%rbp), %rax
movq 0x528(%rax), %rcx
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_to_string
const char * runt_to_string(runt_ptr p)
{
    const char *str;

    /*TODO: error handling */
    if(p.type == RUNT_STRING) {
        str = p.ud;
        return str;
    } else {
        return NULL;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, (%rax)
jne 0x2657
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x265f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_mk_string
runt_ptr runt_mk_string(runt_vm *vm, const char *str, runt_uint size)
{
    runt_ptr p;
    char *buf;
    runt_uint i;
    runt_uint pos;

    buf = NULL;
    pos = runt_malloc(vm, size + 1, (void *)&buf);
    for(i = 0; i < size; i++) {
        buf[i] = str[i];
    }

    buf[size] = 0;

    p = runt_mk_ptr(RUNT_STRING, (void *)buf);
    p.pos = pos;

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdx
callq 0x2060
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x26db
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x26b4
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x14b0
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x38(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movq -0x30(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movl -0x28(%rbp), %edx
movl %edx, 0x10(%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_ppush
runt_int runt_ppush(runt_vm *vm, runt_stacklet **s)
{
   /*TODO: error handling for stack overflows */
    if(runt_stack_pos(vm, &vm->stack) == vm->stack.size) {
        runt_print(vm, "stack overflow!\n");
        *s = &vm->stack.stack[0];
        return RUNT_NOT_OK;
    }

    runt_stack_inc(vm, &vm->stack);
    *s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack)- 1];
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
movq -0x10(%rbp), %rcx
cmpl 0x504(%rcx), %eax
jne 0x27cf
movq -0x10(%rbp), %rdi
leaq 0x6bf5(%rip), %rsi      # 0x93a9
movb $0x0, %al
callq 0x1f40
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x280f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2750
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
movq -0x20(%rbp), %rcx
subl $0x1, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_ppeak
runt_int runt_ppeak(runt_vm *vm, runt_stacklet **s)
{
    /*TODO: error handling for stack underflows */
    if(runt_stack_pos(vm, &vm->stack) > 0) {
        *s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack) - 1];
    } else {
        runt_print(vm, "Empty stack.\n");
        *s = &vm->stack.stack[0];
        return RUNT_NOT_OK;
    }

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
cmpl $0x0, %eax
jle 0x2870
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
movq -0x20(%rbp), %rcx
subl $0x1, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2896
movq -0x10(%rbp), %rdi
leaq 0x6b3f(%rip), %rsi      # 0x93ba
movb $0x0, %al
callq 0x1f40
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x289d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_ppeakn
runt_int runt_ppeakn(runt_vm *vm, runt_stacklet **s, runt_int pos)
{
    *s = &vm->stack.stack[0];
    if(abs(pos) > runt_stack_bias_pos(vm, &vm->stack)) {
        runt_print(vm, "Invalid range %d\n", pos);
        return RUNT_NOT_OK;
    }

    if(pos >= 0) {
        *s = &vm->stack.stack[pos + vm->stack.bias];
    } else {
        *s = &vm->stack.stack[runt_stack_bias_pos(vm, &vm->stack) + pos];
    }
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2980
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jle 0x290f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x6ac9(%rip), %rsi      # 0x93c8
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x296b
cmpl $0x0, -0x1c(%rbp)
jl 0x2938
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rdx
addl 0x508(%rdx), %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2964
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2980
movq -0x28(%rbp), %rcx
addl -0x1c(%rbp), %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_ppop
runt_int  runt_ppop(runt_vm *vm, runt_stacklet **s)
{
    *s = &vm->stack.stack[0];

    if(runt_stack_pos(vm, &vm->stack) > 0) {
        runt_stack_dec(vm, &vm->stack);
        *s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack)];
    } else {
        runt_print(vm, "Empty stack.\n");
        return RUNT_NOT_OK;
    }

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
cmpl $0x0, %eax
jle 0x2b05
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a40
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
movq -0x20(%rbp), %rcx
cltq
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2b20
movq -0x10(%rbp), %rdi
leaq 0x68aa(%rip), %rsi      # 0x93ba
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x2b27
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_entry_create
runt_uint runt_entry_create(runt_vm *vm,
        runt_cell *cell,
        runt_entry **entry)
{
    runt_entry *e;
    runt_malloc(vm, sizeof(runt_entry), (void **)entry);
    e = *entry;
    e->copy = runt_cell_link;
    e->cell = cell;
    e->p = vm->nil;
    e->size = 0;
    return 0;
}

// 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), %rdx
movl $0x58, %esi
callq 0x2060
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq -0x76c(%rip), %rcx      # 0x2400
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1168(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x1170(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x1178(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_word
runt_int runt_word(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry *entry)
{
    entry->p = runt_mk_string(vm, name, size);
    return runt_word_dict(vm,
                          name,
                          size,
                          entry,
                          runt_dictionary_get(vm));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x38(%rbp), %rdi
callq 0x2670
movq -0x60(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2d60
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x44(%rbp), %edx
movq -0x40(%rbp), %rcx
movq %rax, %r8
callq 0x2cf0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_word_dict
runt_int runt_word_dict(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry *entry,
        runt_dict *dict)
{
    runt_uint pos;
    runt_list *list;

    pos = runt_hash(name, size);
    list = &dict->list[pos];

    entry->size = size;

    runt_list_append(list, entry);

    dict->nwords++;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2d80
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2df0
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_hash
static runt_uint runt_hash(const char *str, runt_int size)
{
    runt_uint h = 5381;
    runt_int i = 0;

    for(i = 0; i < size; i++) {
        h = ((h << 5) + h) ^ str[i];
        h %= 0x7FFFFFFF;
    }

    return h % RUNT_DICT_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1505, -0x10(%rbp)    # imm = 0x1505
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2ddc
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ecx
movl %edx, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2da0
movl -0x10(%rbp), %eax
andl $0x7f, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_list_append
runt_int runt_list_append(runt_list *lst, runt_entry *ent)
{
    if(lst->size == 0) {
        lst->top = ent;
        lst->last = lst->top;
    } else {
        lst->last->next = ent;
    }
    ent->prev = lst->last;
    lst->last = ent;
    lst->size++;
    ent->list = lst;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2e23
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2e33
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x1, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_word_search
runt_int runt_word_search(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry **entry)
{
    return runt_word_search_dict(vm,
                                 name,
                                 size,
                                 entry,
                                 runt_dictionary_get(vm));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2d60
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq %rax, %r8
callq 0x2ed0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_word_search_dict
runt_int runt_word_search_dict(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry **entry,
        runt_dict *dict)
{
    runt_uint pos;
    runt_list *list;

    runt_uint i;
    runt_entry *ent;
    runt_entry *next;

    pos = runt_hash(name, size);
    list = &dict->list[pos];

    ent = runt_list_top(list);

    for(i = 0; i < list->size; i++) {
        next = ent->next;
        if(runt_strncmp(vm, name, size, ent) == 0) {
            *entry = ent;
            return RUNT_OK;
        }
        ent = next;
    }

    return RUNT_NOT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2d80
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2f90
movq %rax, -0x50(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x2f7b
movq -0x50(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x50(%rbp), %rcx
callq 0x2fb0
cmpl $0x0, %eax
jne 0x2f68
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2f82
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2f24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_list_pop
runt_int runt_list_pop(runt_vm *vm, runt_list *lst)
{
    if(lst->size == 0) {
        runt_print(vm, "No items on the list to pop off");
        return RUNT_NOT_OK;
    } else if(lst->size == 1) {
        lst->size = 0;
        return RUNT_OK;
    }

    lst->size--;
    lst->last = lst->last->prev;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3064
movq -0x10(%rbp), %rdi
leaq 0x6386(%rip), %rsi      # 0x93da
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x30a8
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3080
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x30a8
jmp 0x3082
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_list_prepend
runt_int runt_list_prepend(runt_list *lst, runt_entry *ent)
{
    if(lst->size > 0) {
        ent->next = lst->top;
    }
    lst->top = ent;
    lst->size++;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x30e5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_list_append_ptr
runt_int runt_list_append_ptr(runt_vm *vm, runt_list *lst, runt_ptr p)
{
    runt_entry *entry;
    entry = NULL;
    /* make entry, using empty cell */
    runt_entry_create(vm, &vm->empty, &entry);
    /* set ptr to "string" entry in struct. works better than it looks */
    entry->p = p;

    runt_list_append(lst, entry);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1190, %rsi           # imm = 0x1190
leaq -0x18(%rbp), %rdx
callq 0x2b30
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2df0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_list_append_cell
runt_int runt_list_append_cell(runt_vm *vm, runt_list *lst, runt_cell *cell)
{
    runt_entry *entry;
    entry = NULL;
    runt_entry_create(vm, cell, &entry);
    runt_list_append(lst, entry);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2b30
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2df0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_dict_init
void runt_dict_init(runt_vm *vm, runt_dict *dict)
{
    runt_uint i;
    dict->nwords = 0;
    for(i = 0; i < RUNT_DICT_SIZE; i++) {
        runt_list_init(&dict->list[i]);
    }
    dict->last = dict;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0x32bc
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x15b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3291
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc08(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_pool_get_cell
runt_int runt_cell_pool_get_cell(runt_vm *vm, runt_uint id, runt_cell **cell)
{
    runt_cell_pool *cell_pool = &vm->cell_pool;
    if(id > runt_cell_pool_size(vm) || id <= 0) {
        runt_print(vm, "psize: invalid id %d\n", id);
        return RUNT_NOT_OK;
    }
    *cell = &cell_pool->cells[id - 1];
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax            # imm = 0x510
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
ja 0x346f
cmpl $0x0, -0x14(%rbp)
ja 0x348d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x5f7d(%rip), %rsi      # 0x93fa
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x34b1
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)