LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_lex
runt_type runt_lex(runt_vm *vm,
        const char *str,
        runt_uint pos,
        runt_uint size)
{
    runt_uint c;
    runt_int off;
    runt_int lvl;

    lvl = 0;
    off = pos + size;
    for(c = pos; c < off; c++) {
        switch(lvl) {
            case 0:
                switch(str[c]) {
                    case '0':
                        if(size > 1) {
                            lvl = 1;
                            break;
                        }
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                        return RUNT_FLOAT;
                    case '-':
                        if(size == 1) {
                            return RUNT_PROC;
                        } else {
                            return RUNT_FLOAT;
                        }
                    case '"':
                    case '\'':
                        return RUNT_STRING;
                    case '_':
                        return RUNT_WORD;
                    case '\n':
                        return RUNT_NIL;
                    default:
                        return RUNT_PROC;
                }
                break;
            case 1:
                switch(str[c]) {
                    case 'x':
                        return RUNT_HEX;
                    default:
                        return RUNT_FLOAT;
                }
                break;
        }
    }

    return RUNT_NOT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x3838
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x3781
jmp 0x3770
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x3806
jmp 0x3828
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movsbl (%rax,%rcx), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x55, %eax
ja 0x37fb
movq -0x38(%rbp), %rax
leaq 0x586f(%rip), %rcx      # 0x9014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, -0x20(%rbp)
jbe 0x37bd
movl $0x1, -0x2c(%rbp)
jmp 0x3804
jmp 0x37bf
movl $0x1, -0x4(%rbp)
jmp 0x383f
cmpl $0x1, -0x20(%rbp)
jne 0x37d7
movl $0x5, -0x4(%rbp)
jmp 0x383f
movl $0x1, -0x4(%rbp)
jmp 0x383f
movl $0x2, -0x4(%rbp)
jmp 0x383f
movl $0x4, -0x4(%rbp)
jmp 0x383f
movl $0x0, -0x4(%rbp)
jmp 0x383f
movl $0x5, -0x4(%rbp)
jmp 0x383f
jmp 0x3828
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %al
subb $0x78, %al
jne 0x381f
jmp 0x3816
movl $0x8, -0x4(%rbp)
jmp 0x383f
movl $0x1, -0x4(%rbp)
jmp 0x383f
jmp 0x382a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3758
movl $0x0, -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_copy_float
static int runt_copy_float(runt_vm *vm, runt_cell *src, runt_cell *dest)
{
    runt_stacklet *s = runt_pop(vm);

    dest->fun = src->fun;
    dest->p = runt_mk_float(vm, s->f);

    return RUNT_OK;
}

// 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 0x22b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movss 0x20(%rax), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x24f0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%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_copy_string
static int runt_copy_string(runt_vm *vm, runt_cell *src, runt_cell *dest)
{
    runt_stacklet *s = runt_pop(vm);

    dest->fun = src->fun;
    dest->p = s->p;

    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 0x22b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_copy_cell
static int runt_copy_cell(runt_vm *vm, runt_cell *c)
{
    runt_stacklet *s = runt_pop(vm);

    c->fun = rproc_cell;
    c->p = s->p;

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11c8(%rip), %rcx      # 0x55f0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%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_word_last_defined
runt_int runt_word_last_defined(runt_vm *vm,
        runt_entry *ent,
        runt_uint c,
        runt_uint m)
{
    ent->c = c;
    ent->m = m;
    ent->last_word_defined = vm->last_word_defined;
    vm->last_word_defined = ent;
    vm->nwords++;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x11f0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x11f0(%rax)
movq -0x8(%rbp), %rax
movl 0x11f8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x11f8(%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_word_define_with_copy
runt_uint runt_word_define_with_copy(runt_vm *vm,
        const char *name,
        runt_uint size,
        runt_proc proc,
        runt_copy_proc copy)
{
    runt_cell *cell;
    runt_entry *entry;
    runt_uint id;
    entry = NULL;

    id = runt_cell_new(vm, &cell);
    if(id == 0) {
        return 0;
    }
    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);

    return id;
}

// 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 $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1dc0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x4552
movl $0x0, -0x4(%rbp)
jmp 0x459b
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x15e0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x2b30
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2bc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x40(%rbp), %rcx
callq 0x2c50
movl -0x44(%rbp), %eax
movl %eax, -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: runt_cell_undo
runt_int runt_cell_undo(runt_vm *vm)
{
    runt_cell_pool *pool = &vm->cell_pool;
    runt_cell *cell;

    if(pool->used == 0) {
        return RUNT_NOT_OK;
    }

    pool->used--;
    /* id is N - 1 */
    cell = &pool->cells[pool->used];
    runt_cell_clear(vm, cell);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax            # imm = 0x510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x45dd
movl $0x0, -0x4(%rbp)
jmp 0x4617
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d60
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_is_alive
runt_int runt_is_alive(runt_vm *vm)
{
    if(runt_get_state(vm, RUNT_MODE_RUNNING) == RUNT_ON &&
        runt_get_state(vm, RUNT_MODE_PANIC) == RUNT_OFF) {
        return RUNT_OK;
    } else {
        return RUNT_NOT_OK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x1f00
cmpl $0x3, %eax
jne 0x465b
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x1f00
cmpl $0x4, %eax
jne 0x465b
movl $0x1, -0x4(%rbp)
jmp 0x4662
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_pmark_set
void runt_pmark_set(runt_vm *vm)
{
    if(runt_get_state(vm, RUNT_MODE_INTERACTIVE) == RUNT_ON) {
        runt_mark_set(vm);
    } else {
        if(runt_get_state(vm, RUNT_MODE_VERBOSE) == RUNT_ON)
            runt_print(vm, "Not setting a mark!\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1f00
cmpl $0x3, %eax
jne 0x473a
movq -0x8(%rbp), %rdi
callq 0x4690
jmp 0x4761
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x1f00
cmpl $0x3, %eax
jne 0x475f
movq -0x8(%rbp), %rdi
leaq 0x4d3d(%rip), %rsi      # 0x9495
movb $0x0, %al
callq 0x1f40
jmp 0x4761
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_pmark_free
runt_uint runt_pmark_free(runt_vm *vm)
{
    if(runt_get_state(vm, RUNT_MODE_INTERACTIVE) == RUNT_ON) {
        runt_mark_free(vm);
    } else {
        if(runt_get_state(vm, RUNT_MODE_VERBOSE) == RUNT_ON)
            runt_print(vm, "Not freeing!\n");
    }
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1f00
cmpl $0x3, %eax
jne 0x479a
movq -0x8(%rbp), %rdi
callq 0x46d0
jmp 0x47c1
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x1f00
cmpl $0x3, %eax
jne 0x47bf
movq -0x8(%rbp), %rdi
leaq 0x4cf2(%rip), %rsi      # 0x94aa
movb $0x0, %al
callq 0x1f40
jmp 0x47c1
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_to_cptr
void * runt_to_cptr(runt_ptr p)
{
    void *cptr = NULL;

    /*TODO: error handling */
    if(p.type == RUNT_CPTR) {
        cptr = p.ud;
    }

    return cptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
cmpl $0x3, (%rax)
jne 0x47f5
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_to_list
runt_list * runt_to_list(runt_ptr p)
{
    runt_list *lst = NULL;
    /*TODO: error handling */
    if(p.type == RUNT_LIST) {
        lst = p.ud;
    }
    return lst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
cmpl $0x7, (%rax)
jne 0x4825
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_cptr_cell
runt_int runt_mk_cptr_cell(runt_vm *vm, void *cptr)
{
    runt_cell *cell;
    if(runt_cell_new(vm, &cell) == RUNT_NOT_OK) {
        return RUNT_NOT_OK;
    }
    cell->fun = rproc_cptr;
    cell->p = runt_mk_cptr(vm, cptr);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1dc0
cmpl $0x0, %eax
jne 0x488b
movl $0x0, -0x4(%rbp)
jmp 0x48d5
movq -0x20(%rbp), %rax
leaq 0x4a(%rip), %rcx        # 0x48e0
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x43d0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_word_bind_ptr
runt_int runt_word_bind_ptr(runt_vm *vm, runt_uint id, runt_ptr p)
{
    runt_cell *pool = vm->cell_pool.cells;
    if(id == 0) return RUNT_NOT_OK;
    pool[id - 1].p = p;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x510(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x49f1
movl $0x0, -0x4(%rbp)
jmp 0x4a26
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_close_plugins
runt_int runt_close_plugins(runt_vm *vm)
{
    runt_uint i;
    runt_entry *ent;
    runt_list *plugins;
    runt_uint size;

    /* first, call all user-made destructor functions */

    plugins = &vm->dtors;
    size = runt_list_size(plugins);
    ent = runt_list_top(plugins);

    for(i = 0; i < size; i++) {
        runt_cell_exec(vm, ent->cell);
        ent = ent->next;
    }

    /* next, close all dll plugins */

    plugins = &vm->plugins;
    size = runt_list_size(plugins);
    ent = runt_list_top(plugins);

    for(i = 0; i < size; i++) {
        runt_cell_exec(vm, ent->cell);
        ent = ent->next;
    }
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1210, %rax           # imm = 0x1210
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3220
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f90
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x4ad9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x22e0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4aaa
movq -0x8(%rbp), %rax
addq $0x11c0, %rax           # imm = 0x11C0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3220
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f90
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x4b36
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x22e0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4b07
movl $0x1, %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_cell_id_get
runt_int runt_cell_id_get(runt_vm *vm, runt_uint id, runt_cell **cell)
{
    if(id == 0) {
        *cell = vm->f_cell;
        return RUNT_NOT_OK;
    } else  {
        *cell = &vm->cell_pool.cells[id - 1];
        return RUNT_OK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x4bd0
movq -0x10(%rbp), %rax
movq 0x1180(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4bf8
movq -0x10(%rbp), %rax
movq 0x510(%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
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_dictionary_swap
runt_dict * runt_dictionary_swap(runt_vm *vm)
{
    runt_dict *last;

    last = vm->dict->last;
    last->last = vm->dict;
    vm->dict = last;

    return last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x540(%rax), %rax
movq 0xc08(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x540(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc08(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x540(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_getline
size_t runt_getline(char **lineptr, size_t *n, FILE *stream)
{
    char *bufptr = NULL;
    size_t size;
    char c;
    size_t pos;

    if (lineptr == NULL) {
        return -1;
    }
    if (stream == NULL) {
        return -1;
    }
    if (n == NULL) {
        return -1;
    }
    bufptr = *lineptr;
    size = *n;

    c = fgetc(stream);
    if (c == EOF) {
        return -1;
    }
    if (bufptr == NULL) {
        bufptr = malloc(128);
        if (bufptr == NULL) {
            return -1;
        }
        size = 128;
    }
    pos = 0;
    while(c != EOF) {
        if (pos >= (size - 1)) {
            size = size + 128;
            bufptr = realloc(bufptr, size);
            if (bufptr == NULL) {
                return -1;
            }
        }
        bufptr[pos] = c;
        pos++;
        if (c == '\n') {
            break;
        }
        c = fgetc(stream);
    }

    bufptr[pos] = '\0';
    *lineptr = bufptr;
    *n = size;
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4d10
movq $-0x1, -0x8(%rbp)
jmp 0x4e52
cmpq $0x0, -0x20(%rbp)
jne 0x4d24
movq $-0x1, -0x8(%rbp)
jmp 0x4e52
cmpq $0x0, -0x18(%rbp)
jne 0x4d38
movq $-0x1, -0x8(%rbp)
jmp 0x4e52
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10a0
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $-0x1, %eax
jne 0x4d70
movq $-0x1, -0x8(%rbp)
jmp 0x4e52
cmpq $0x0, -0x28(%rbp)
jne 0x4da1
movl $0x80, %edi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4d99
movq $-0x1, -0x8(%rbp)
jmp 0x4e52
movq $0x80, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $-0x1, %eax
je 0x4e28
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x4df5
movq -0x30(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4df3
movq $-0x1, -0x8(%rbp)
jmp 0x4e52
jmp 0x4df5
movb -0x31(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0xa, %eax
jne 0x4e1a
jmp 0x4e28
movq -0x20(%rbp), %rdi
callq 0x10a0
movb %al, -0x31(%rbp)
jmp 0x4da9
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_add_destructor
runt_int runt_add_destructor(runt_vm *vm, runt_proc proc, runt_ptr ptr)
{
    runt_cell *cell;
    runt_int rc;

    rc = runt_cell_malloc(vm, &cell);
    RUNT_ERROR_CHECK(rc);

    runt_cell_bind(vm, cell, proc);
    runt_cell_data(vm, cell, ptr);

    return runt_cell_destructor(vm, cell);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x19b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4e97
movl $0x0, -0x4(%rbp)
jmp 0x4ee2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15e0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
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 -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4ef0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_stack_dup
int runt_stack_dup(runt_vm *vm)
{
    runt_stacklet *val;
    runt_stacklet *s1;
    runt_stacklet *s2;

    runt_int rc;

    val = NULL;
    s1 = NULL;
    s2 = NULL;

    rc = runt_ppop(vm, &val);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &s1);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &s2);
    RUNT_ERROR_CHECK(rc);

    runt_stacklet_copy(vm, val, s1);
    runt_stacklet_copy(vm, val, s2);

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x4f63
movl $0x0, -0x4(%rbp)
jmp 0x4fc9
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2780
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x4f82
movl $0x0, -0x4(%rbp)
jmp 0x4fc9
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2780
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x4fa1
movl $0x0, -0x4(%rbp)
jmp 0x4fc9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4b50
movl -0x2c(%rbp), %eax
movl %eax, -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_stack_swap
int runt_stack_swap(runt_vm *vm)
{
    runt_stacklet *s1;
    runt_stacklet *s2;
    runt_int rc;
    runt_stacklet a, b;

    rc = runt_ppop(vm, &s1);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s1, &a);

    rc = runt_ppop(vm, &s1);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s1, &b);

    rc = runt_ppush(vm, &s1);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &s2);
    RUNT_ERROR_CHECK(rc);

    runt_stacklet_copy(vm, &a, s1);
    runt_stacklet_copy(vm, &b, s2);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x5011
movl $0x0, -0x4(%rbp)
jmp 0x50b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x5041
movl $0x0, -0x4(%rbp)
jmp 0x50b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2780
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x5071
movl $0x0, -0x4(%rbp)
jmp 0x50b9
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2780
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x5090
movl $0x0, -0x4(%rbp)
jmp 0x50b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x4b50
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x78(%rbp), %rsi
callq 0x4b50
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_cell_from_stack
runt_int runt_cell_from_stack(runt_vm *vm, runt_stacklet *s, runt_cell **cell)
{
    if(s->f > 0) {
        runt_cell_id_get(vm, s->f, cell);
    } else {
        *cell = runt_to_cptr(s->p);
    }
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x5110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
cvttss2si 0x20(%rax), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0x4ba0
jmp 0x5140
movq -0x10(%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 0x47d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_word_oops
runt_int runt_word_oops(runt_vm *vm)
{
    const char *name;
    runt_entry *last_word;

    if(vm->nwords == 0) {
        runt_print(vm, "No words to undefine.\n");
        return RUNT_NOT_OK;
    }

    last_word = vm->last_word_defined;
    name = runt_to_string(last_word->p);
    runt_print(vm, "Undefining word '%s'\n", name);

    runt_list_pop(vm, last_word->list);
    vm->cell_pool.used = last_word->c;
    vm->memory_pool.used = last_word->m;

    vm->last_word_defined = last_word->last_word_defined;
    vm->dict->nwords--;

    vm->nwords--;

    runt_mark_set(vm);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x11f8(%rax)
jne 0x5187
movq -0x10(%rbp), %rdi
leaq 0x4363(%rip), %rsi      # 0x94d7
movb $0x0, %al
callq 0x1f40
movl $0x0, -0x4(%rbp)
jmp 0x5251
movq -0x10(%rbp), %rax
movq 0x11f0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2630
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x431f(%rip), %rsi      # 0x94ee
movb $0x0, %al
callq 0x1f40
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x3030
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x51c(%rax)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x534(%rax)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x11f0(%rax)
movq -0x10(%rbp), %rax
movq 0x540(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x11f8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x11f8(%rax)
movq -0x10(%rbp), %rdi
callq 0x4690
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: runt_data_search
runt_int runt_data_search(runt_vm *vm, const char *name, runt_ptr *p)
{
    runt_entry *entry;
    runt_int rc;

    rc = runt_word_search(vm, name, strlen(name), &entry);
    RUNT_ERROR_CHECK(rc);
    *p = entry->cell->p;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
leaq -0x28(%rbp), %rcx
callq 0x2e70
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x5322
movl $0x0, -0x4(%rbp)
jmp 0x534b
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %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_proc_search
runt_int runt_proc_search(runt_vm *vm,
        runt_proc p,
        runt_entry **entry)
{
    runt_uint pos;
    runt_list *list;
    runt_dict *dict;

    runt_uint i;
    runt_entry *ent;
    runt_entry *next;

    dict = runt_dictionary_get(vm);

    for(pos = 0; pos < RUNT_DICT_SIZE; pos++) {
        list = &dict->list[pos];

        ent = runt_list_top(list);

        for(i = 0; i < list->size; i++) {
            next = ent->next;
            if(ent->cell->fun == p) {
                *entry = ent;
                return RUNT_OK;
            }
            ent = next;
        }
    }

    return RUNT_NOT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d60
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x80, -0x24(%rbp)
jae 0x551d
movq -0x38(%rbp), %rax
addq $0x8, %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2f90
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x550d
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x54fa
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5524
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x54bf
jmp 0x550f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5488
movl $0x0, -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_last_word_called
const char * runt_last_word_called(runt_vm *vm)
{
    runt_cell *lcc;
    runt_entry *ent;
    runt_int rc;

    lcc = vm->last_cell_called;

    if(lcc == &vm->empty) return NULL;

    rc = runt_proc_search(vm, lcc->fun, &ent);

    if(rc == RUNT_NOT_OK) return NULL;

    return runt_entry_get_name(ent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x14b0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1190, %rcx           # imm = 0x1190
cmpq %rcx, %rax
jne 0x55a9
movq $0x0, -0x8(%rbp)
jmp 0x55dd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5460
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x55d0
movq $0x0, -0x8(%rbp)
jmp 0x55dd
movq -0x20(%rbp), %rdi
callq 0x5530
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/runt.c
// Function: rproc_cell
static int rproc_cell(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;

    s = runt_push(vm);
    s->f = 0; /* explicitely overwrite any variable here */
    s->p = p;
    s->t = RUNT_CELL;
    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
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
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 $0x6, (%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_say
static runt_int rproc_say(runt_vm *vm, runt_ptr p)
{
    /* runt_stacklet *s = runt_pop(vm); */
    runt_stacklet *s;
    const char *str;

    runt_ppop(vm, &s);
    str = runt_to_string(s->p);
    runt_print(vm, "%s\n", str);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2aa0
movq -0x10(%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 0x2630
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x37ce(%rip), %rsi      # 0x9650
movb $0x0, %al
callq 0x1f40
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_print
static runt_int rproc_print(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_int rc;
    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_print(vm, "%g\n", s->f);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x5ecb
movl $0x0, -0x4(%rbp)
jmp 0x5ef1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movss 0x20(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x36ed(%rip), %rsi      # 0x95d0
movb $0x1, %al
callq 0x1f40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_add
static runt_int rproc_add(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s1;
    runt_stacklet *s2;
    runt_stacklet *out;
    runt_float v1;
    runt_float v2;

    runt_int rc = RUNT_OK;

    rc = runt_ppop(vm, &s1);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppop(vm, &s2);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &out);
    RUNT_ERROR_CHECK(rc);

    v1 = runt_stack_float(vm, s1);
    v2 = runt_stack_float(vm, s2);
    out->f = v1 + v2;
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x5f32
movl $0x0, -0x4(%rbp)
jmp 0x5fad
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x5f51
movl $0x0, -0x4(%rbp)
jmp 0x5fad
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x5f70
movl $0x0, -0x4(%rbp)
jmp 0x5fad
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29d0
movss %xmm0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29d0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x20(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_sub
static runt_int rproc_sub(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s1 = runt_pop(vm);
    runt_stacklet *s2 = runt_pop(vm);
    runt_stacklet *out = runt_push(vm);

    runt_float v1 = s1->f;
    runt_float v2 = s2->f;
    out->f = v2 - v1;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
subss -0x24(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x20(%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_peak
static int rproc_peak(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s1;
    runt_stacklet *s2;
    runt_stacklet *peak;
    runt_int rc;
    runt_int pos;

    rc = runt_ppop(vm, &s1);
    RUNT_ERROR_CHECK(rc);

    pos = s1->f;

    rc = runt_ppeakn(vm, &peak, pos);
    RUNT_ERROR_CHECK(rc);

    rc = runt_ppush(vm, &s2);
    RUNT_ERROR_CHECK(rc);

    runt_stacklet_copy(vm, peak, s2);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x619b
movl $0x0, -0x4(%rbp)
jmp 0x6200
movq -0x18(%rbp), %rax
cvttss2si 0x20(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0x28b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x61c9
movl $0x0, -0x4(%rbp)
jmp 0x6200
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2780
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x61e8
movl $0x0, -0x4(%rbp)
jmp 0x6200
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b50
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_rot
static int rproc_rot(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_stacklet *push[3];
    runt_int rc;
    runt_stacklet a, b, c;

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s, &a);

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s, &b);

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s, &c);

    rc = runt_ppush(vm, &push[0]);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &push[1]);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &push[2]);
    RUNT_ERROR_CHECK(rc);

    runt_stacklet_copy(vm, &b, push[0]);
    runt_stacklet_copy(vm, &a, push[1]);
    runt_stacklet_copy(vm, &c, push[2]);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6241
movl $0x0, -0x4(%rbp)
jmp 0x6366
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6274
movl $0x0, -0x4(%rbp)
jmp 0x6366
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x62aa
movl $0x0, -0x4(%rbp)
jmp 0x6366
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x62e0
movl $0x0, -0x4(%rbp)
jmp 0x6366
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6303
movl $0x0, -0x4(%rbp)
jmp 0x6366
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x10, %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6326
movl $0x0, -0x4(%rbp)
jmp 0x6366
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x88(%rbp), %rsi
callq 0x4b50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x60(%rbp), %rsi
callq 0x4b50
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0xb0(%rbp), %rsi
callq 0x4b50
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_nitems
static int rproc_nitems(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_int rc;
    rc = runt_ppush(vm, &s);
    RUNT_ERROR_CHECK(rc);
    /* subtract one to discount the pushed value itself */
    s->f = runt_stack_pos(vm, &vm->stack) - 1;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2780
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x63ab
movl $0x0, -0x4(%rbp)
jmp 0x63cf
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2730
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x20(%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/basic.c
// Function: rproc_rat
static int rproc_rat(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_stacklet *push[3];
    runt_int rc;
    runt_stacklet a, b, c;

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s, &a);

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s, &b);

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, s, &c);

    rc = runt_ppush(vm, &push[0]);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &push[1]);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &push[2]);
    RUNT_ERROR_CHECK(rc);

    runt_stacklet_copy(vm, &a, push[0]);
    runt_stacklet_copy(vm, &c, push[1]);
    runt_stacklet_copy(vm, &b, push[2]);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6411
movl $0x0, -0x4(%rbp)
jmp 0x6536
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6444
movl $0x0, -0x4(%rbp)
jmp 0x6536
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x647a
movl $0x0, -0x4(%rbp)
jmp 0x6536
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x4b50
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x64b0
movl $0x0, -0x4(%rbp)
jmp 0x6536
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x64d3
movl $0x0, -0x4(%rbp)
jmp 0x6536
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x10, %rsi
callq 0x2780
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x64f6
movl $0x0, -0x4(%rbp)
jmp 0x6536
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rsi
callq 0x4b50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0xb0(%rbp), %rsi
callq 0x4b50
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rsi
callq 0x4b50
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_drops
static runt_int rproc_drops(runt_vm *vm, runt_ptr p)
{
    runt_int rc;
    runt_stacklet *s;
    runt_uint n;
    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    n = s->f;
    runt_stack_dec_n(vm, &vm->stack, n);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x657b
movl $0x0, -0x4(%rbp)
jmp 0x659f
movq -0x20(%rbp), %rax
cvttss2si 0x20(%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x2a70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_over
static runt_int rproc_over(runt_vm *vm, runt_ptr p)
{
    runt_int rc;
    runt_stacklet *peak;
    runt_stacklet *s;
    rc = runt_ppeakn(vm, &peak, -2);
    RUNT_ERROR_CHECK(rc);
    rc = runt_ppush(vm, &s);
    RUNT_ERROR_CHECK(rc);
    runt_stacklet_copy(vm, peak, s);
    return RUNT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x28b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x65e0
movl $0x0, -0x4(%rbp)
jmp 0x6617
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2780
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x65ff
movl $0x0, -0x4(%rbp)
jmp 0x6617
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4b50
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_dynload
static runt_int rproc_dynload(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *val = runt_pop(vm);
    const char *filename = runt_to_string(val->p);
    runt_uint prev_state = runt_get_state(vm, RUNT_MODE_INTERACTIVE);
    runt_int rc = RUNT_OK;

    runt_set_state(vm, RUNT_MODE_INTERACTIVE, RUNT_OFF);

    /* remove dynload cell from cell pool */

    runt_cell_undo(vm);

    /* remove string from cell pool */

    vm->memory_pool.used = val->p.pos;

    rc = runt_load_plugin(vm, filename);

    if(rc == RUNT_NOT_OK) {
        runt_print(vm, "Error loading plugin\n");
    }

    /* mark it so it doesn't get overwritten in memory
     * NOTE: this will cause the filepath to stay in memory
     * this will be fixed in the future for sure...
     * is this fixed actually? */

    runt_mark_set(vm);

    runt_set_state(vm, RUNT_MODE_INTERACTIVE, prev_state);

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22b0
movq %rax, -0x10(%rbp)
movq -0x10(%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 0x2630
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1f00
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1550
movq -0x8(%rbp), %rdi
callq 0x45b0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x534(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4670
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x66d0
movq -0x8(%rbp), %rdi
leaq 0x2f0b(%rip), %rsi      # 0x95d4
movb $0x0, %al
callq 0x1f40
movq -0x8(%rbp), %rdi
callq 0x4690
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x2, %esi
callq 0x1550
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MuvikLabs[P]runt/basic.c
// Function: rproc_eval
static int rproc_eval(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_int rc;
    const char *str;

    rc = runt_ppop(vm, &s);
    RUNT_ERROR_CHECK(rc);
    str = runt_to_string(s->p);

    /* remove load cell from cell pool */
    runt_cell_undo(vm);

    /* remove string from cell pool */
    vm->memory_pool.used = s->p.pos;
    rc = runt_parse_file(vm, str);
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aa0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x694b
movl $0x0, -0x4(%rbp)
jmp 0x69a5
movq -0x18(%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 0x2630
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45b0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x534(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8580
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop