LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/tracing.c
// Function: Type
static int Type(lua_State *L)
    {
#define TRY(xxx) do { if(test##xxx(L, 1, NULL) != 0) { lua_pushstring(L, ""#xxx); return 1; } } while(0)
    TRY(context);
    TRY(atlas);
    TRY(font);
    TRY(image);
    TRY(cursor);
    TRY(buffer);
    TRY(edit);
    TRY(panel);
    TRY(canvas);
    return 0;
#undef TRY
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5edc(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x623c1
leaq 0x6019(%rip), %rsi      # 0x683d5
jmp 0x624ee
leaq 0x5c38(%rip), %rcx      # 0x68000
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x623e8
leaq 0x5c29(%rip), %rsi      # 0x6800c
jmp 0x624ee
leaq 0x5cc2(%rip), %rcx      # 0x680b1
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6240f
leaq 0x12055(%rip), %rsi     # 0x7445f
jmp 0x624ee
leaq 0x5e2e(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x62436
leaq 0x5e1f(%rip), %rsi      # 0x68250
jmp 0x624ee
leaq 0x5c85(%rip), %rcx      # 0x680c2
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6245d
leaq 0xbaa7(%rip), %rsi      # 0x6deff
jmp 0x624ee
leaq 0x5c71(%rip), %rcx      # 0x680d5
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x62481
leaq 0x5c80(%rip), %rsi      # 0x680ff
jmp 0x624ee
leaq 0x5f67(%rip), %rcx      # 0x683ef
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x624a5
leaq 0x5f58(%rip), %rsi      # 0x683fb
jmp 0x624ee
leaq 0x5f31(%rip), %rcx      # 0x683dd
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x624cc
leaq 0x5f1f(%rip), %rsi      # 0x683e9
jmp 0x624ee
leaq 0x5c6f(%rip), %rcx      # 0x68142
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x624fc
leaq 0x5c60(%rip), %rsi      # 0x6814e
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_unref
int udata_unref(lua_State *L, uint64_t id)
/* unreference udata so that it will be garbage collected */
    {
//  printf("unref object %lu\n", id);
    udata_t *udata = udata_search(id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %p", (void*)id);
    if(udata->ref != LUA_NOREF)
        {
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
        udata->ref = LUA_NOREF;
        }
    return 0;
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq 0x268ab(%rip), %rbx     # 0x89148
testq %rbx, %rbx
je 0x628b3
cmpq %rdx, 0x20(%rbx)
ja 0x628ae
jae 0x628b5
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0x6289d
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x628d7
movl 0x28(%rbx), %edx
cmpl $-0x2, %edx
je 0x628d3
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
movl $0xfffffffe, 0x28(%rbx) # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
retq
leaq 0x11d8a(%rip), %rsi     # 0x74668
xorl %eax, %eax
popq %rbx
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_free
int udata_free(lua_State *L, uint64_t id)
/* this should be called in the __gc metamethod
 */
    {
    udata_t *udata = udata_search(id);
//  printf("free object %lu\n", id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %p", (void*)id);
    /* release all references */
    if(udata->ref != LUA_NOREF)
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
    udata_remove(udata);
    Free(L, udata);
    /* mem is released by Lua at garbage collection */
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x26851(%rip), %r14     # 0x89148
testq %r14, %r14
je 0x6290d
cmpq %rdx, 0x20(%r14)
ja 0x62908
jae 0x62910
addq $0x8, %r14
movq (%r14), %r14
jmp 0x628f7
xorl %r14d, %r14d
testq %r14, %r14
je 0x62948
movl 0x28(%r14), %edx
cmpl $-0x2, %edx
je 0x6292b
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
movq %r14, %rdi
callq 0x62960
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11d19(%rip), %rsi     # 0x74668
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_push
int udata_push(lua_State *L, uint64_t id)
    {
    udata_t *udata = udata_search(id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %p", (void*)id);
    if(udata->ref == LUA_NOREF)
        return luaL_error(L, "unreferenced object");
    if(lua_rawgeti(L, LUA_REGISTRYINDEX, udata->ref) != LUA_TUSERDATA)
        return luaL_error(L, UNEXPECTED_ERROR);
    return 1; /* one value pushed */
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x26405(%rip), %rax     # 0x89148
testq %rax, %rax
je 0x62d59
cmpq %rdx, 0x20(%rax)
ja 0x62d54
jae 0x62d5b
addq $0x8, %rax
movq (%rax), %rax
jmp 0x62d43
xorl %eax, %eax
testq %rax, %rax
je 0x62d7c
movslq 0x28(%rax), %rdx
cmpq $-0x2, %rdx
jne 0x62d8e
leaq 0x11914(%rip), %rsi     # 0x74685
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x139b0
leaq 0x118e5(%rip), %rsi     # 0x74668
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x139b0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
cmpl $0x7, %eax
jne 0x62da7
movl $0x1, %eax
popq %rbx
retq
leaq 0x5371(%rip), %rsi      # 0x6811f
leaq 0x118e4(%rip), %rdx     # 0x74699
movq %rbx, %rdi
movl $0xa3, %ecx
xorl %eax, %eax
popq %rbx
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_free_all
void udata_free_all(lua_State *L)
/* free all without unreferencing (for atexit()) */
    {
    udata_t *udata;
    while((udata = udata_first(0)))
        {
        udata_remove(udata);
        Free(L, udata);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x26375(%rip), %rax     # 0x89148
testq %rax, %rax
je 0x62dec
movq %rax, %r14
cmpq $0x0, 0x20(%rax)
je 0x62def
movq (%r14), %rax
testq %rax, %rax
jne 0x62dd8
jmp 0x62def
xorl %r14d, %r14d
testq %r14, %r14
je 0x62e09
movq %r14, %rdi
callq 0x62960
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130d0
jmp 0x62dcc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_scan
int udata_scan(lua_State *L, const char *mt,  
            void *info, int (*func)(lua_State *L, const void *mem, const char* mt, const void *info))
/* scans the udata database, and calls the func callback for every 'mt' object found
 * (the object may be deleted in the callback).
 * func must return 0 to continue the scan, !=0 to interrupt it.
 * returns 1 if interrupted, 0 otherwise
 */
    {
    int stop = 0;
    uint64_t id = 0;
    udata_t *udata;
    while((udata = udata_first(id)))
        {
        id = udata->id + 1;
        if(mt == udata->mt)
            {
            stop = func(L, (const void*)(udata->mem), mt, info);
            if(stop) return 1;
            }
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq 0x26318(%rip), %rcx     # 0x89148
xorl %eax, %eax
testq %rcx, %rcx
je 0x62e50
cmpq %r13, 0x20(%rcx)
jbe 0x62e42
movq %rcx, %rax
jmp 0x62e48
jae 0x62e4d
addq $0x8, %rcx
movq (%rcx), %rcx
jmp 0x62e32
movq %rcx, %rax
testq %rax, %rax
je 0x62e7c
movq 0x20(%rax), %r13
incq %r13
cmpq %r15, 0x38(%rax)
jne 0x62e29
movq 0x30(%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x62e29
movl $0x1, %eax
jmp 0x62e7e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_test
void *udata_test(lua_State *L, int arg, const char *mt)
/* same as luaL_testudata(), but succeeds also if the userdata has not
 * mt as metatable but as ancestor
 */ 
    {
    void *mem;
    int ok;
    if((mem = luaL_testudata(L, arg, mt)))
        return mem;
    
    if((mem = lua_touserdata(L, arg)) == NULL)
        return NULL;

    if(luaL_getmetatable(L, mt)!=LUA_TTABLE)
        { luaL_error(L, "cannot find metatable '%s'", mt); return NULL; }
    ok = is_subclass(L, arg, lua_gettop(L));
    lua_pop(L, 1);
    return ok ? mem : NULL;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq 0x13360
movq %rax, %rbx
testq %rax, %rax
je 0x62eb2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
callq 0x123a0
testq %rax, %rax
je 0x62f06
movq %rax, %rbx
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x14050
cmpl $0x5, %eax
jne 0x62f0a
movq %r14, %rdi
callq 0x120f0
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x62f22
movl %eax, %ebp
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %eax, %eax
testl %ebp, %ebp
cmoveq %rax, %rbx
jmp 0x62ea4
xorl %ebx, %ebx
jmp 0x62ea4
leaq 0x11790(%rip), %rsi     # 0x746a1
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x139b0
jmp 0x62ea4
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: is_subclass
static int is_subclass(lua_State *L, int arg, int mt_index)
    {
    int ok;
    if(luaL_getmetafield(L, arg, "__index") == LUA_TNIL)
        return 0;
    if(lua_rawequal(L, mt_index, lua_gettop(L)))
        {
        lua_pop(L, 1);
        return 1;
        }
    ok = is_subclass(L, lua_gettop(L), mt_index);
    lua_pop(L, 1);
    return ok;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x117a7(%rip), %rdx     # 0x746d9
callq 0x13870
testl %eax, %eax
je 0x62f7f
movq %rbx, %rdi
callq 0x120f0
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x13730
movl $0x1, %r14d
testl %eax, %eax
jne 0x62f70
movq %rbx, %rdi
callq 0x120f0
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x62f22
movl %eax, %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
jmp 0x62f82
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_define
int udata_define(lua_State *L, const char* mt, const luaL_Reg* methods, const luaL_Reg* metamethods)
    {
    /* create the metatable */
    if(!luaL_newmetatable(L, mt))
        return luaL_error(L, "cannot create metatable '%s'", mt);
    lua_pushvalue(L, -1);
    lua_setfield(L, -2, "__index");
    if(metamethods)
        /* add metamethods */
        luaL_setfuncs(L, metamethods, 0);
    if(methods)
        {
        /* add methods */
        luaL_getsubtable(L, -1, "__index");
        luaL_setfuncs(L, methods, 0);
        lua_pop(L, 1);
        }
    lua_pop(L, 1);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x13ee0
testl %eax, %eax
je 0x6302c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12d70
leaq 0x1171a(%rip), %rdx     # 0x746d9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
testq %r15, %r15
je 0x62fde
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x123c0
testq %r14, %r14
je 0x63011
leaq 0x116ef(%rip), %rdx     # 0x746d9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12c80
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x123c0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x11689(%rip), %rsi     # 0x746bc
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_inherit
int udata_inherit(lua_State *L, const char *sub, const char *super)
/* Sets  metatable(sub).__index = metatable(super)
 *
 * This way, if one accesses a field/method of a 'sub' object which is not defined in
 * the 'sub' metatable, Lua searches for it in the 'super' metatable (i.e., the 'sub'
 * type inherits from 'super').
 */
    {
    if(luaL_getmetatable(L, sub)!=LUA_TTABLE)
        return luaL_error(L, "cannot find metatable '%s'", sub);
    luaL_getsubtable(L, -1, "__index");
    if(luaL_getmetatable(L, super)!=LUA_TTABLE)
        return luaL_error(L, "cannot find metatable '%s'", super);
    lua_setmetatable(L, -2);
    lua_pop(L, 2);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x14050
cmpl $0x5, %eax
jne 0x630b6
leaq 0x11667(%rip), %rdx     # 0x746d9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12c80
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r14, %rdx
callq 0x14050
cmpl $0x5, %eax
jne 0x630c5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12f40
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x12180
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x115e4(%rip), %rsi     # 0x746a1
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x630d2
leaq 0x115d5(%rip), %rsi     # 0x746a1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_addmethods
int udata_addmethods(lua_State *L, const char* mt, const luaL_Reg* methods)
/* Adds methods to the metatable mt */
    {
    if(luaL_getmetatable(L, mt)!=LUA_TTABLE)
        return luaL_error(L, "cannot find metatable '%s'", mt);
    if(methods)
        {
        /* add methods */
        luaL_getsubtable(L, -1, "__index");
        luaL_setfuncs(L, methods, 0);
        lua_pop(L, 1);
        }
    lua_pop(L, 1);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x14050
cmpl $0x5, %eax
jne 0x63146
testq %r14, %r14
je 0x63131
leaq 0x115cf(%rip), %rdx     # 0x746d9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12c80
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x123c0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11554(%rip), %rsi     # 0x746a1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x139b0
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr;
    if(size == 0)
        { luaL_error(L, errstring(ERR_MALLOC_ZERO)); return NULL; }
    ptr = Malloc_(size);
    if(ptr==NULL)
        { luaL_error(L, errstring(ERR_MEMORY)); return NULL; }
    memset(ptr, 0, size);
    //DBG("Malloc %p\n", ptr);
    return ptr;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6319e
movq %rsi, %r14
movq 0x25fc9(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x631a7
movq 0x25fc5(%rip), %rdi     # 0x89158
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *%rax
jmp 0x631a9
leaq 0x11617(%rip), %rsi     # 0x747bc
jmp 0x631c9
xorl %eax, %eax
testq %rax, %rax
je 0x631c2
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12b50
leaq 0x115e5(%rip), %rsi     # 0x747ae
movq %rbx, %rdi
xorl %eax, %eax
callq 0x139b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_Strdup
char *Strdup(lua_State *L, const char *s)
    {
    size_t len = strnlen(s, 256);
    char *ptr = (char*)Malloc(L, len + 1);
    if(len>0)
        memcpy(ptr, s, len);
    ptr[len]='\0';
    return ptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x12bc0
movq %rax, %r14
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0x13a00
movq %rax, %r15
testq %r14, %r14
je 0x63276
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x13010
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checklightuserdataorzero
void *checklightuserdataorzero(lua_State *L, int arg)
    {
    int val, isnum;
    val = lua_tointegerx(L, arg, &isnum);
    if(!isnum)
        return checklightuserdata(L, arg);
    if(val != 0)
        luaL_argerror(L, arg, "expected lightuserdata or 0");
    return NULL;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x125f0
cmpl $0x0, (%r15)
je 0x63349
testl %eax, %eax
je 0x63345
leaq 0x113e7(%rip), %rdx     # 0x74722
movq %r14, %rdi
movl %ebx, %esi
callq 0x12460
xorl %eax, %eax
jmp 0x63353
movq %r14, %rdi
movl %ebx, %esi
callq 0x13800
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_testboolean
int testboolean(lua_State *L, int arg, int *err)
    {
    if(!lua_isboolean(L, arg))
        { *err = ERR_TYPE; return 0; }
    *err = 0;
    return lua_toboolean(L, arg); // ? nk_true : nk_false;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x13df0
cmpl $0x1, %eax
jne 0x633c3
movl $0x0, (%rbx)
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x122e0
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_testindex
int testindex(lua_State *L, int arg, int *err)
    {
    int val;
    if(!lua_isinteger(L, arg))
        { *err = ERR_TYPE; return 0; }
    val = lua_tointeger(L, arg);
    if(val < 1)
        { *err = ERR_GENERIC; return 0; }
    *err = 0;
    return val - 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x14170
testl %eax, %eax
je 0x63432
xorl %r14d, %r14d
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x125f0
testl %eax, %eax
jle 0x6343d
movl $0x0, (%rbx)
decl %eax
movl %eax, %r14d
jmp 0x63443
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %r14d, %r14d
jmp 0x63443
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkindex
int checkindex(lua_State *L, int arg)
    {
    int val = luaL_checkinteger(L, arg);
    if(val < 1)
        return luaL_argerror(L, arg, "expected 1-based index");
    return val - 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x12f30
testl %eax, %eax
jle 0x6346d
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x112db(%rip), %rdx     # 0x7474f
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_optindex
int optindex(lua_State *L, int arg, int optval /* 0-based */)
    {
    int val = luaL_optinteger(L, arg, optval + 1);
    if(val < 1)
        return luaL_argerror(L, arg, "expected 1-based index");
    return val - 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
incl %edx
movslq %edx, %rdx
callq 0x13310
testl %eax, %eax
jle 0x634a6
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x112a2(%rip), %rdx     # 0x7474f
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkstringlist
char** checkstringlist(lua_State *L, int arg, int *count, int *err)
    {
    int t;
    char** list;
    const char* s;
    int i;
    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }
    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }
    list = (char**)MallocNoErr(L, sizeof(char*) * (*count + 1));
    if(!list)
        { *err = ERR_MEMORY; return NULL; }
    for(i=0; i<*count; i++)
        {
        t = lua_rawgeti(L, arg, i+1);
        if(t != LUA_TSTRING)
            {
            lua_pop(L, 1);
            freestringlist(L, list, *count);
            *count = 0;
            *err = ERR_TYPE;
            return NULL;
            }
        s = lua_tostring(L, -1);
        list[i] = Strdup(L, s);
        lua_pop(L, 1);
        }
    /* list[*count]=NULL; */
    return list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x63550
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x6360c
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x6355a
movq %r12, (%rsp)
shlq $0x20, %rax
movabsq $0x100000000, %r13      # imm = 0x100000000
addq %rax, %r13
sarq $0x1d, %r13
movq 0x25c1a(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63564
movq 0x25c16(%rip), %rdi     # 0x89158
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
callq *%rax
movq %rax, %r12
jmp 0x63567
movl $0x1, %ebx
jmp 0x6360c
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
jmp 0x6360c
xorl %r12d, %r12d
testq %r12, %r12
je 0x6357b
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
jmp 0x6357e
xorl %r12d, %r12d
testq %r12, %r12
je 0x635dd
cmpl $0x0, (%r14)
jle 0x63613
xorl %ebx, %ebx
leaq 0x1(%rbx), %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12950
cmpl $0x4, %eax
jne 0x635e4
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r15, %rdi
movq %rax, %rsi
callq 0x136d0
movq %rax, (%r12,%rbx,8)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movslq (%r14), %rax
movq %r13, %rbx
cmpq %rax, %r13
jl 0x6358f
jmp 0x63613
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
jmp 0x63608
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl (%r14), %edx
movq %r12, %rsi
callq 0x12c90
movl $0x0, (%r14)
movq (%rsp), %r12
movl %ebx, (%r12)
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_freestringlist
void freestringlist(lua_State *L, char** list, int count)
    {
    int i;
    if(!list)
        return;
    for(i=0; i<count; i++)
        Free(L, list[i]);
    Free(L, list);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x63687
movq %rsi, %rbx
testl %edx, %edx
jle 0x63666
movl %edx, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rsi
testq %rsi, %rsi
je 0x6365e
movq 0x25b04(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x6365e
movq 0x25b00(%rip), %rdi     # 0x89158
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
incq %r15
cmpq %r15, %r14
jne 0x6363c
movq 0x25ae3(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63687
movq 0x25adf(%rip), %rdi     # 0x89158
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_pushstringlist
void pushstringlist(lua_State *L, char** list, int count)
    {
    int i;
    lua_newtable(L);
    for(i=0; i<count; i++)
        {
        lua_pushstring(L, list[i]);
        lua_rawseti(L, -2, i+1);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
testl %ebp, %ebp
jle 0x636e3
movl %ebp, %r12d
negq %r12
movl $0x1, %r15d
movq -0x8(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x13f90
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x12f90
leaq (%r12,%r15), %rax
incq %rax
incq %r15
cmpq $0x1, %rax
jne 0x636b6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkfloatlist
float* checkfloatlist(lua_State *L, int arg, int *count, int *err)
    {
    float* list;
    int i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }

    list = (float*)MallocNoErr(L, sizeof(float) * (*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        if(!lua_isnumber(L, -1))
            { lua_pop(L, 1); Free(L, list); *count = 0; *err = ERR_TYPE; return NULL; }
        list[i] = lua_tonumber(L, -1);
        lua_pop(L, 1);
        }
    return list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x63763
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x6383f
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x6376e
movslq %eax, %r13
shlq $0x2, %r13
movq 0x25a07(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63779
movq 0x25a03(%rip), %rdi     # 0x89158
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
callq *%rax
movq %rax, %r12
jmp 0x6377c
movl $0x1, %r13d
jmp 0x6383f
movl $0xfffffffb, %r13d      # imm = 0xFFFFFFFB
jmp 0x6383f
xorl %r12d, %r12d
testq %r12, %r12
je 0x63790
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
jmp 0x63793
xorl %r12d, %r12d
testq %r12, %r12
je 0x637fd
cmpl $0x0, (%r14)
jle 0x63845
movq %rbx, (%rsp)
xorl %ebx, %ebx
leaq 0x1(%rbx), %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12950
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12c20
testl %eax, %eax
je 0x63805
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12da0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%rbx,4)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movslq (%r14), %rax
movq %r13, %rbx
cmpq %rax, %r13
jl 0x637a8
jmp 0x63845
movl $0xfffffffa, %r13d      # imm = 0xFFFFFFFA
jmp 0x63838
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq 0x25931(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63834
movq 0x2592d(%rip), %rdi     # 0x89158
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq (%rsp), %rbx
movl $0x0, (%r14)
movl %r13d, (%rbx)
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_pushfloatlist
void pushfloatlist(lua_State *L, float *list, int count)
    {
    int i;
    lua_newtable(L);
    for(i=0; i<count; i++)
        {
        lua_pushnumber(L, list[i]);
        lua_rawseti(L, -2, i+1);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
testl %ebp, %ebp
jle 0x638d1
movl %ebp, %r12d
negq %r12
movl $0x1, %r15d
xorps %xmm0, %xmm0
cvtss2sd -0x4(%rbx,%r15,4), %xmm0
movq %r14, %rdi
callq 0x13180
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x12f90
leaq (%r12,%r15), %rax
incq %rax
incq %r15
cmpq $0x1, %rax
jne 0x6389f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkvec2list
float* checkvec2list(lua_State *L, int arg, int *count, int *err)
    {
    nk_vec2_t* list;
    int i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }

    list = (nk_vec2_t*)MallocNoErr(L, sizeof(nk_vec2_t)*(*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        *err = echeckvec2(L, -1, &list[i]);
        if(*err)
            { lua_pop(L, 2); Free(L, list); *count = 0; *err=ERR_TYPE; return NULL; }
        lua_pop(L, 1);
        }
    return (float*)list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x63952
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r12d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x63a24
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r13)
testl %eax, %eax
je 0x6395d
movslq %eax, %r12
shlq $0x3, %r12
movq 0x25818(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63968
movq 0x25814(%rip), %rdi     # 0x89158
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq *%rax
movq %rax, %r14
jmp 0x6396b
movl $0x1, %r12d
jmp 0x63a24
movl $0xfffffffb, %r12d      # imm = 0xFFFFFFFB
jmp 0x63a24
xorl %r14d, %r14d
testq %r14, %r14
je 0x6397f
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
jmp 0x63982
xorl %r14d, %r14d
testq %r14, %r14
je 0x639e1
cmpl $0x0, (%r13)
jle 0x63a2a
movq %r13, (%rsp)
xorl %r13d, %r13d
movq %r14, %r12
incq %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12950
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x14160
movl %eax, (%rbx)
testl %eax, %eax
jne 0x639e9
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq (%rsp), %rax
movslq (%rax), %rax
addq $0x8, %r12
cmpq %rax, %r13
jl 0x6399c
jmp 0x63a2a
movl $0xfffffffa, %r12d      # imm = 0xFFFFFFFA
jmp 0x63a1c
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x12180
movq 0x25753(%rip), %rax     # 0x89150
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x63a18
movq 0x25749(%rip), %rdi     # 0x89158
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq (%rsp), %r13
movl $0x0, (%r13)
movl %r12d, (%rbx)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkvec2ilist
float* checkvec2ilist(lua_State *L, int arg, int *count, int *err)
    {
    nk_vec2i_t* list;
    int i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }

    list = (nk_vec2i_t*)MallocNoErr(L, sizeof(nk_vec2i_t)*(*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        *err = echeckvec2i(L, -1, &list[i]);
        if(*err)
            { lua_pop(L, 2); Free(L, list); *count = 0; *err=ERR_TYPE; return NULL; }
        lua_pop(L, 1);
        }
    return (float*)list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x63ad3
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r12d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x63ba5
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r13)
testl %eax, %eax
je 0x63ade
movslq %eax, %r12
shlq $0x2, %r12
movq 0x25697(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63ae9
movq 0x25693(%rip), %rdi     # 0x89158
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq *%rax
movq %rax, %r14
jmp 0x63aec
movl $0x1, %r12d
jmp 0x63ba5
movl $0xfffffffb, %r12d      # imm = 0xFFFFFFFB
jmp 0x63ba5
xorl %r14d, %r14d
testq %r14, %r14
je 0x63b00
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
jmp 0x63b03
xorl %r14d, %r14d
testq %r14, %r14
je 0x63b62
cmpl $0x0, (%r13)
jle 0x63bab
movq %r13, (%rsp)
xorl %r13d, %r13d
movq %r14, %r12
incq %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12950
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x12fb0
movl %eax, (%rbx)
testl %eax, %eax
jne 0x63b6a
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq (%rsp), %rax
movslq (%rax), %rax
addq $0x4, %r12
cmpq %rax, %r13
jl 0x63b1d
jmp 0x63bab
movl $0xfffffffa, %r12d      # imm = 0xFFFFFFFA
jmp 0x63b9d
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x12180
movq 0x255d2(%rip), %rax     # 0x89150
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x63b99
movq 0x255c8(%rip), %rdi     # 0x89158
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq (%rsp), %r13
movl $0x0, (%r13)
movl %r12d, (%rbx)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkrunelist
nk_rune* checkrunelist(lua_State *L, int arg, int *count, int *err)
    {
    nk_rune* list;
    int i, isnum;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }

    list = (nk_rune*)MallocNoErr(L, sizeof(nk_rune) * (*count + 1));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        list[i] = lua_tointegerx(L, -1, &isnum);
        lua_pop(L, 1);
        if(!isnum)
            { Free(L, list); *count = 0; *err = ERR_TYPE; return NULL; }
        }
    list[*count] = 0; /* terminating rune */
    return list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x63c5a
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x63c65
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x63c70
shlq $0x20, %rax
movabsq $0x100000000, %r13      # imm = 0x100000000
addq %rax, %r13
sarq $0x1e, %r13
movq 0x25510(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63c7b
movq 0x2550c(%rip), %rdi     # 0x89158
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
callq *%rax
movq %rax, %r12
jmp 0x63c7e
movl $0x1, (%rbx)
jmp 0x63d2c
movl $0xfffffffc, (%rbx)     # imm = 0xFFFFFFFC
jmp 0x63d2c
movl $0xfffffffb, (%rbx)     # imm = 0xFFFFFFFB
jmp 0x63d2c
xorl %r12d, %r12d
testq %r12, %r12
je 0x63c92
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
jmp 0x63c95
xorl %r12d, %r12d
testq %r12, %r12
je 0x63d1f
movq %rbx, 0x10(%rsp)
xorl %ebx, %ebx
movslq (%r14), %rax
cmpq %rax, %rbx
jge 0x63d41
leaq 0x1(%rbx), %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12950
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %rdx
callq 0x125f0
movl %eax, (%r12,%rbx,4)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
cmpl $0x0, 0xc(%rsp)
movq %r13, %rbx
jne 0x63ca5
movq 0x2545a(%rip), %rax     # 0x89150
testq %rax, %rax
je 0x63d0b
movq 0x25456(%rip), %rdi     # 0x89158
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movl $0x0, (%r14)
movq 0x10(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x63d2c
movl $0x0, (%r14)
movl $0xfffffffa, (%rbx)     # imm = 0xFFFFFFFA
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%r12,%rax,4)
jmp 0x63d2f
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_pushrunelist
void pushrunelist(lua_State *L, const nk_rune *list)
    {
    int i = 0;
    lua_newtable(L);
    if(!list) return; /* empty table */
    while(list[i]!=0)
        {
        lua_pushinteger(L, list[i]);
        lua_rawseti(L, -2, ++i);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
testq %rbx, %rbx
je 0x63db4
movl (%rbx), %eax
testl %eax, %eax
je 0x63db4
movl $0x1, %r15d
movl %eax, %esi
movq %r14, %rdi
callq 0x12b60
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x12f90
movl (%rbx,%r15,4), %eax
incq %r15
testl %eax, %eax
jne 0x63d8f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Widget
static int Widget(lua_State *L)
/* widget(context, bounds, [padding]) */
    {
    nk_rect_t bounds;
    nk_vec2_t padding;
    nk_flags state;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &bounds)) return argerror(L, 2);
    if(lua_isnoneornil(L, 3))
        state = nk_widget(&bounds, context);
    else
        {
        if(echeckvec2(L, 3, &padding)) return argerror(L, 3);
        state = nk_widget_fitting(&bounds, context, padding);
        }
    pushflags(L, state); /* widgetlayoutstates */
    pushrect(L, &bounds);
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x43f5(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x63ed1
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x63f49
movl $0x3, %esi
callq 0x13df0
testl %eax, %eax
jle 0x63f0c
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x63f1b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x63ec7
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
jmp 0x63f2d
movsd (%rsp), %xmm0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12270
movl %eax, %esi
movq %rbx, %rdi
callq 0x12b60
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12710
movl $0x2, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Widget_is_mouse_clicked
static int Widget_is_mouse_clicked(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_buttons button = checkbuttons(L, 2);
    lua_pushboolean(L, nk_widget_is_mouse_clicked(context, button));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x41e1(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x122d0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Widget_has_mouse_click_down
static int Widget_has_mouse_click_down(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_buttons button = checkbuttons(L, 2);
    int down = checkboolean(L, 3);
    lua_pushboolean(L, nk_widget_has_mouse_click_down(context, button, down));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4191(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x12960
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Spacing
static int Spacing(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    int cols = luaL_checkinteger(L, 2);
    nk_spacing(context, cols);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4133(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %r14, %rdi
movl %eax, %esi
callq 0x12070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Button_set_behavior
static int Button_set_behavior(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_button_behavior behavior = checkbuttonbehavior(L, 2);
    nk_button_set_behavior(context, behavior);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3ee0(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x12850
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Button_push_behavior
static int Button_push_behavior(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_button_behavior behavior = checkbuttonbehavior(L, 2);
    lua_pushboolean(L, nk_button_push_behavior(context, behavior));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e9d(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x13fd0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Chart_begin
static int Chart_begin(lua_State *L)
    {
    int rc;
    nk_color_t color, highlight;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 3);
    float min = luaL_checknumber(L, 4);
    float max = luaL_checknumber(L, 5);
    if(lua_isnoneornil(L, 6))
        rc = nk_chart_begin(context, chart_type, count, min, max);
    else
        {
        if(echeckcolor(L, 6, &color)) return argerror(L, 6);
        if(echeckcolor(L, 7, &highlight)) return argerror(L, 7);
        rc = nk_chart_begin_colored(context, chart_type, color, highlight, count, min, max);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3e17(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0xa, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x13df0
testl %eax, %eax
jle 0x6450a
leaq 0x14(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x64534
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x64561
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x12890
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
jmp 0x64569
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x64574
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %r8d
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x12330
jmp 0x64523
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Chart_add_slot
static int Chart_add_slot(lua_State *L)
    {
    nk_color_t color, highlight;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 3);
    float min = luaL_checknumber(L, 4);
    float max = luaL_checknumber(L, 5);
    if(lua_isnoneornil(L, 6))
        nk_chart_add_slot(context, chart_type, count, min, max);
    else
        {
        if(echeckcolor(L, 6, &color)) return argerror(L, 6);
        if(echeckcolor(L, 7, &highlight)) return argerror(L, 7);
        nk_chart_add_slot_colored(context, chart_type, color, highlight, count, min, max);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3cd3(%rip), %rcx      # 0x68280
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0xa, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x13df0
testl %eax, %eax
jle 0x64650
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x6466a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x64697
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x13790
jmp 0x646a2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x646b2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %r8d
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x13550
xorl %r14d, %r14d
jmp 0x646a2