LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x134d0
movq %rax, %rbx
testq %rax, %rax
je 0x5bf80
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
callq 0x123e0
testq %rax, %rax
je 0x5bfd2
movq %rax, %rbx
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x142b0
cmpl $0x5, %eax
jne 0x5bfd6
movq %r14, %rdi
callq 0x12100
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x5bfee
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x12190
xorl %eax, %eax
testl %ebp, %ebp
cmoveq %rax, %rbx
jmp 0x5bf72
xorl %ebx, %ebx
jmp 0x5bf72
leaq 0x10604(%rip), %rsi     # 0x6c5e1
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x13bb0
jmp 0x5bf72
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x1061c(%rip), %rdx     # 0x6c619
callq 0x13a60
testl %eax, %eax
je 0x5c023
movq %rbx, %rdi
callq 0x12100
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x13910
testl %eax, %eax
je 0x5c027
pushq $0x1
popq %rbp
jmp 0x5c03d
xorl %ebp, %ebp
jmp 0x5c048
movq %rbx, %rdi
callq 0x12100
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x5bfee
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12190
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14120
testl %eax, %eax
je 0x5c0e5
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x12e90
leaq 0x10599(%rip), %rdx     # 0x6c619
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12b50
testq %r15, %r15
je 0x5c09d
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x12400
testq %r14, %r14
je 0x5c0cc
leaq 0x10570(%rip), %rdx     # 0x6c619
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x12d70
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x12400
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12190
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12190
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10510(%rip), %rsi     # 0x6c5fc
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13bb0
// File: /workspace/github_c_makefile_star2_O2/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 0x142b0
cmpl $0x5, %eax
jne 0x5c169
leaq 0x104ee(%rip), %rdx     # 0x6c619
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r14, %rdx
callq 0x142b0
cmpl $0x5, %eax
jne 0x5c178
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x13070
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x12190
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10471(%rip), %rsi     # 0x6c5e1
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x5c185
leaq 0x10462(%rip), %rsi     # 0x6c5e1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x13bb0
// File: /workspace/github_c_makefile_star2_O2/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 0x142b0
cmpl $0x5, %eax
jne 0x5c1f3
testq %r14, %r14
je 0x5c1e0
leaq 0x1045c(%rip), %rdx     # 0x6c619
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x12d70
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x12400
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12190
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12190
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x103e7(%rip), %rsi     # 0x6c5e1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x13bb0
// File: /workspace/github_c_makefile_star2_O2/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 0x5c24d
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5c292
testq %rax, %rax
je 0x5c256
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12c10
leaq 0x104a8(%rip), %rsi     # 0x6c6fc
jmp 0x5c25d
leaq 0x10491(%rip), %rsi     # 0x6c6ee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13bb0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12ca0
movq %rax, %r14
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0x13c00
movq %rax, %r15
testq %r14, %r14
je 0x5c30f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x13150
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12650
cmpl $0x0, (%r15)
je 0x5c3e2
testl %eax, %eax
je 0x5c3de
leaq 0x1028e(%rip), %rdx     # 0x6c662
movq %r14, %rdi
movl %ebx, %esi
callq 0x124a0
xorl %eax, %eax
jmp 0x5c3ec
movq %r14, %rdi
movl %ebx, %esi
callq 0x139f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14030
cmpl $0x1, %eax
jne 0x5c459
andl $0x0, (%rbx)
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x12320
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14400
testl %eax, %eax
je 0x5c4c5
xorl %r14d, %r14d
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12650
testl %eax, %eax
jle 0x5c4d0
andl $0x0, (%rbx)
decl %eax
movl %eax, %r14d
jmp 0x5c4d3
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %r14d, %r14d
jmp 0x5c4d3
orl $-0x1, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13060
testl %eax, %eax
jle 0x5c4fd
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1018b(%rip), %rdx     # 0x6c68f
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x124a0
// File: /workspace/github_c_makefile_star2_O2/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 0x13470
testl %eax, %eax
jle 0x5c536
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10152(%rip), %rdx     # 0x6c68f
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x124a0
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rcx, %rbx
movl %esi, %ebp
movq %rdx, 0x8(%rsp)
andl $0x0, (%rdx)
movq %rdi, %r15
andl $0x0, (%rcx)
callq 0x14030
testl %eax, %eax
jle 0x5c630
movq %r15, %rdi
movl %ebp, %esi
callq 0x14030
cmpl $0x5, %eax
jne 0x5c634
movq %r15, %rdi
movl %ebp, %esi
callq 0x14050
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x5c638
shlq $0x20, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rax, %rsi
sarq $0x1d, %rsi
callq 0x12c70
testq %rax, %rax
je 0x5c63c
movq %rax, %r13
movq %rbx, 0x10(%rsp)
xorl %r14d, %r14d
pushq $-0x2
popq %r12
movq 0x8(%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %r14
jge 0x5c646
leaq 0x1(%r14), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12a00
cmpl $0x4, %eax
jne 0x5c658
movq %r15, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x12690
movq %r15, %rdi
movq %rax, %rsi
callq 0x138b0
movq %rax, (%r13,%r14,8)
movq %r15, %rdi
movl %r12d, %esi
callq 0x12190
movq %rbx, %r14
jmp 0x5c5e0
pushq $0x1
jmp 0x5c63e
pushq $-0x4
jmp 0x5c63e
pushq $-0x5
jmp 0x5c63e
pushq $-0x6
popq %r12
movl %r12d, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r12d, %esi
callq 0x12190
movq 0x8(%rsp), %rbx
movl (%rbx), %edx
movq %r13, %rsi
callq 0x12d90
andl $0x0, (%rbx)
movq 0x10(%rsp), %rbx
jmp 0x5c640
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x5c6b5
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
xorl %r15d, %r15d
testl %edx, %edx
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x5c6a8
movq (%rbx,%r15,8), %rsi
callq 0x13220
incq %r15
jmp 0x5c695
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13220
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
testl %ebp, %ebp
cmovgl %ebp, %r12d
negq %r12
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
leaq (%r12,%r15), %rax
cmpq $0x1, %rax
je 0x5c70b
movq -0x8(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x141d0
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x130d0
incq %r15
jmp 0x5c6e2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rcx, %rbx
movl %esi, %ebp
movq %rdx, (%rsp)
andl $0x0, (%rdx)
movq %rdi, %r15
andl $0x0, (%rcx)
callq 0x14030
testl %eax, %eax
jle 0x5c7ec
movq %r15, %rdi
movl %ebp, %esi
callq 0x14030
cmpl $0x5, %eax
jne 0x5c7f0
movq %r15, %rdi
movl %ebp, %esi
callq 0x14050
movq (%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x5c7f4
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x12c70
testq %rax, %rax
je 0x5c80e
movq %rax, %r13
movl %ebp, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
xorl %r14d, %r14d
pushq $-0x2
popq %rbp
pushq $-0x1
popq %r12
movq (%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %r14
jge 0x5c7fc
leaq 0x1(%r14), %rbx
movq %r15, %rdi
movl 0xc(%rsp), %esi
movq %rbx, %rdx
callq 0x12a00
movq %r15, %rdi
movl %r12d, %esi
callq 0x12d00
testl %eax, %eax
je 0x5c813
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x12ec0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r13,%r14,4)
movq %r15, %rdi
movl %ebp, %esi
callq 0x12190
movq %rbx, %r14
jmp 0x5c797
pushq $0x1
jmp 0x5c7f6
pushq $-0x4
jmp 0x5c7f6
pushq $-0x5
popq %rbp
movl %ebp, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x6
popq %rbp
jmp 0x5c82a
movq %r15, %rdi
movl %ebp, %esi
callq 0x12190
movq %r13, %rsi
callq 0x13220
movq 0x10(%rsp), %rbx
movq (%rsp), %rax
andl $0x0, (%rax)
jmp 0x5c7f7
// File: /workspace/github_c_makefile_star2_O2/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 %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
testl %ebp, %ebp
cmovgl %ebp, %r12d
negq %r12
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
leaq (%r12,%r15), %rax
cmpq $0x1, %rax
je 0x5c88f
cvtss2sd -0x4(%rbx,%r15,4), %xmm0
movq %r14, %rdi
callq 0x132d0
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x130d0
incq %r15
jmp 0x5c864
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebp
andl $0x0, (%rdx)
movq %rdi, %r15
movq %rcx, 0x10(%rsp)
andl $0x0, (%rcx)
callq 0x14030
testl %eax, %eax
jle 0x5c948
movq %r15, %rdi
movl %ebp, %esi
callq 0x14030
cmpl $0x5, %eax
jne 0x5c94c
movq %r15, %rdi
movl %ebp, %esi
callq 0x14050
movl %eax, (%r14)
testl %eax, %eax
je 0x5c950
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x12c70
testq %rax, %rax
je 0x5c96d
xorl %r13d, %r13d
pushq $-0x2
popq %r12
movq %rax, 0x8(%rsp)
movq %rax, %rbx
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x5c973
incq %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12a00
movq %r15, %rdi
pushq $-0x1
popq %rsi
movq %rbx, %rdx
callq 0x143f0
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
jne 0x5c97a
movq %r15, %rdi
movl %r12d, %esi
callq 0x12190
addq $0x8, %rbx
jmp 0x5c906
pushq $0x1
jmp 0x5c952
pushq $-0x4
jmp 0x5c952
pushq $-0x5
popq %r12
movq 0x10(%rsp), %rax
movl %r12d, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x6
popq %r12
jmp 0x5c98f
movq 0x8(%rsp), %rax
jmp 0x5c95e
pushq $-0x3
popq %rsi
movq %r15, %rdi
callq 0x12190
movq 0x8(%rsp), %rsi
callq 0x13220
andl $0x0, (%r14)
jmp 0x5c954
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebp
andl $0x0, (%rdx)
movq %rdi, %r15
movq %rcx, 0x10(%rsp)
andl $0x0, (%rcx)
callq 0x14030
testl %eax, %eax
jle 0x5ca4a
movq %r15, %rdi
movl %ebp, %esi
callq 0x14030
cmpl $0x5, %eax
jne 0x5ca4e
movq %r15, %rdi
movl %ebp, %esi
callq 0x14050
movl %eax, (%r14)
testl %eax, %eax
je 0x5ca52
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x12c70
testq %rax, %rax
je 0x5ca6f
xorl %r13d, %r13d
pushq $-0x2
popq %r12
movq %rax, 0x8(%rsp)
movq %rax, %rbx
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x5ca75
incq %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12a00
movq %r15, %rdi
pushq $-0x1
popq %rsi
movq %rbx, %rdx
callq 0x130f0
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
jne 0x5ca7c
movq %r15, %rdi
movl %r12d, %esi
callq 0x12190
addq $0x4, %rbx
jmp 0x5ca08
pushq $0x1
jmp 0x5ca54
pushq $-0x4
jmp 0x5ca54
pushq $-0x5
popq %r12
movq 0x10(%rsp), %rax
movl %r12d, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x6
popq %r12
jmp 0x5ca91
movq 0x8(%rsp), %rax
jmp 0x5ca60
pushq $-0x3
popq %rsi
movq %r15, %rdi
callq 0x12190
movq 0x8(%rsp), %rsi
callq 0x13220
andl $0x0, (%r14)
jmp 0x5ca56
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rdx)
movq %rdi, %r15
andl $0x0, (%rcx)
callq 0x14030
testl %eax, %eax
jle 0x5cb7d
movq %r15, %rdi
movl %ebp, %esi
callq 0x14030
cmpl $0x5, %eax
jne 0x5cb85
movq %r15, %rdi
movl %ebp, %esi
callq 0x14050
movl %eax, (%r14)
testl %eax, %eax
je 0x5cb8d
shlq $0x20, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rax, %rsi
sarq $0x1e, %rsi
callq 0x12c70
testq %rax, %rax
je 0x5cb95
movq %rax, %r12
movq %rbx, 0x10(%rsp)
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x5cbb4
leaq 0x1(%r13), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12a00
movq %r15, %rdi
pushq $-0x1
popq %rsi
leaq 0xc(%rsp), %rdx
callq 0x12650
movl %eax, (%r12,%r13,4)
movq %r15, %rdi
pushq $-0x2
popq %rsi
callq 0x12190
cmpl $0x0, 0xc(%rsp)
movq %rbx, %r13
jne 0x5cb1e
movq %r12, %rsi
callq 0x13220
andl $0x0, (%r14)
movq 0x10(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x5cb9f
movl $0x1, (%rbx)
jmp 0x5cb9f
movl $0xfffffffc, (%rbx)     # imm = 0xFFFFFFFC
jmp 0x5cb9f
movl $0xfffffffb, (%rbx)     # imm = 0xFFFFFFFB
jmp 0x5cb9f
andl $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
andl $0x0, (%r12,%rax,4)
jmp 0x5cba2
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
testq %rbx, %rbx
je 0x5cc0b
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
movl -0x4(%rbx,%r15,4), %esi
testq %rsi, %rsi
je 0x5cc0b
movq %r14, %rdi
callq 0x12c20
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x130d0
incq %r15
jmp 0x5cbe7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3598(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rbp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13bf0
testl %eax, %eax
je 0x5cd2a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
jmp 0x5cd97
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5cd5e
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5cd6d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
jmp 0x5cd1a
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x12990
jmp 0x5cd80
movsd 0x8(%rsp), %xmm0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x122b0
movl %eax, %esi
movq %rbx, %rdi
callq 0x12c20
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x12790
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x338a(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %r14, %rdi
movl %eax, %esi
callq 0x12310
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3340(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %r15
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13450
movl %eax, %r12d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13950
movq %r14, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x12a10
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x32e1(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %eax, %esi
callq 0x12080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x30b2(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x8
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %r14, %rdi
movl %eax, %esi
callq 0x12900
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3075(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x8
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %r14, %rdi
movl %eax, %esi
callq 0x14210
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2ff3(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5d318
pushq $0x6
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x5d33d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x6
jmp 0x5d360
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x12940
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
jmp 0x5d36e
pushq $0x7
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x5d37d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x7
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %r8d
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x12370
jmp 0x5d331
// File: /workspace/github_c_makefile_star2_O2/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 0x2eca(%rip), %rcx      # 0x60280
xorl %r15d, %r15d
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5d441
pushq $0x6
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x5d45b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x6
jmp 0x5d47e
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x13970
jmp 0x5d48d
pushq $0x7
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x5d49d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x7
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %r8d
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x13710
xorl %r15d, %r15d
jmp 0x5d48d
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Chart_push
static int Chart_push(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float value = luaL_checknumber(L, 2);
    int slot = optindex(L, 3, 0);
    pushflags(L, nk_chart_push_slot(context, value, slot)); /* charteventflags */
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2dac(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x14420
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
movl %eax, %esi
callq 0x12440
movl %eax, %esi
movq %rbx, %rdi
callq 0x12c20
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Plot
static int Plot(lua_State *L)
    {
    int nvalues, err;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 4);
    int offset = luaL_checkinteger(L, 5);
    float *values = checkfloatlist(L, 3, &nvalues, &err);
    if(err) return argerrorc(L, 3, err);
    /* plots values[offset] to values[offset+count-1] */
    if(offset < 0 || (offset+count) > nvalues)
        {
        freefloatlist(L, values, count);
        return argerrorc(L, 4, ERR_BOUNDARIES);
        }
    nk_plot(context, chart_type, values, count, offset);
    freefloatlist(L, values, count);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2d20(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, 0x8(%rsp)
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x3
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x14290
movl (%r14), %edi
testl %edi, %edi
je 0x5d5c3
callq 0x13cc0
pushq $0x3
jmp 0x5d5f2
movq %rax, %r13
movq 0x8(%rsp), %rdi
testl %r12d, %r12d
js 0x5d5da
leal (%r12,%r15), %eax
cmpl 0x4(%rsp), %eax
jle 0x5d60d
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x12bb0
pushq $-0xa
popq %rdi
callq 0x13cc0
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %esi
movq %r13, %rdx
movl %r15d, %ecx
movl %r12d, %r8d
callq 0x12e70
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x12bb0
xorl %eax, %eax
jmp 0x5d5fe
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Plot_function
static int Plot_function(lua_State *L)
    {
    cbinfo_t info;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 4);
    int offset = luaL_checkinteger(L, 5);
    if(!lua_isfunction(L, 3))
        return argerrorc(L, 3, ERR_TYPE);
    lua_pushvalue(L, 3);
    info.ref = luaL_ref(L, LUA_REGISTRYINDEX);
    nk_plot_function(context, chart_type, &info, ValueGetter, count, offset);
    luaL_unref(L, LUA_REGISTRYINDEX, info.ref);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2c39(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x14030
cmpl $0x6, %eax
jne 0x5d6ed
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12e90
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12800
leaq 0x8(%rsp), %r13
movl %eax, (%r13)
leaq 0x1c2b(%rip), %rcx      # 0x5f2e3
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r15d, %r8d
movl %r12d, %r9d
callq 0x14260
movl (%r13), %edx
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x14190
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x2
popq %rdi
callq 0x13cc0
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x124a0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Check
static int Check(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    lua_pushboolean(L, nk_check_text(context, s, (int)len, active));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2b59(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13950
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %ecx
callq 0x13540
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Check_flags
static int Check_flags(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    unsigned int flags = luaL_checkinteger(L, 3);
    unsigned int value = luaL_checkinteger(L, 4);
    lua_pushinteger(L, nk_check_flags_text(context, s, len, flags, value));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2aeb(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r13
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %ecx
movl %eax, %r8d
callq 0x12c00
movl %eax, %esi
movq %rbx, %rdi
callq 0x12c20
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Check_align
static int Check_align(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    unsigned int widgetalignflags = luaL_checkinteger(L, 4);
    unsigned int textalignflags = luaL_checkinteger(L, 5);
    lua_pushboolean(L, nk_check_text_align(context, s, (int)len, active, widgetalignflags, textalignflags));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2a6b(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13950
movl %eax, %r13d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %ecx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x13270
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Checkbox
static int Checkbox(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    nk_checkbox_text(context, s, len, &active);
    lua_pushboolean(L, active);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x29d8(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13950
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x12350
movl (%r13), %esi
movq %rbx, %rdi
callq 0x133d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Checkbox_flags
static int Checkbox_flags(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    unsigned int flags = luaL_checkinteger(L, 3);
    unsigned int value = luaL_checkinteger(L, 4);
    nk_checkbox_flags_text(context, s, len, &flags, value);
    lua_pushinteger(L, flags);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2959(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movl %eax, %r8d
callq 0x131c0
movl (%r13), %esi
movq %rbx, %rdi
callq 0x12c20
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Checkbox_align
static int Checkbox_align(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    unsigned int widgetalignflags = luaL_checkinteger(L, 4);
    unsigned int textalignflags = luaL_checkinteger(L, 5);
    nk_checkbox_text_align(context, s, len, &active, widgetalignflags, textalignflags);
    lua_pushboolean(L, active);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x28cc(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13950
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x13860
movl (%r13), %esi
movq %rbx, %rdi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq