LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_symboltype
static int Style_get_symboltype(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    enum nk_symbol_type *address = address_symboltype(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushsymboltype(L, *address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x894e(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x61541
testq %rax, %rax
je 0x5e97e
movl (%rax), %edx
movq %rbx, %rdi
movl $0xe, %esi
callq 0x125e0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: address_flags
static nk_flags* address_flags(nk_context_t *context, enum nonnk_style what)
    {
    switch(what)
        { 
        CASE_NONNK_STYLE_FLAGS
        default: return NULL;
        }
    return NULL;
    }

// Assembly:
xorl %eax, %eax
cmpl $0x182, %esi            # imm = 0x182
jle 0x5fddc
cmpl $0x22d, %esi            # imm = 0x22D
jle 0x5fe1a
cmpl $0x25b, %esi            # imm = 0x25B
jg 0x5fe92
cmpl $0x22e, %esi            # imm = 0x22E
je 0x5ff41
cmpl $0x241, %esi            # imm = 0x241
je 0x5ff6e
cmpl $0x254, %esi            # imm = 0x254
jne 0x5ff93
addq $0x1ec8, %rdi           # imm = 0x1EC8
jmp 0x5ff90
cmpl $0xf7, %esi
jg 0x5fe56
cmpl $0x35, %esi
jle 0x5fee6
cmpl $0x36, %esi
je 0x5ff2f
cmpl $0x96, %esi
je 0x5ff5c
cmpl $0xa9, %esi
jne 0x5ff93
addq $0xa88, %rdi            # imm = 0xA88
jmp 0x5ff90
cmpl $0x1b9, %esi            # imm = 0x1B9
jle 0x5fec2
cmpl $0x1ba, %esi            # imm = 0x1BA
je 0x5ff1d
cmpl $0x1fc, %esi            # imm = 0x1FC
je 0x5ff26
cmpl $0x21b, %esi            # imm = 0x21B
jne 0x5ff93
addq $0x1df0, %rdi           # imm = 0x1DF0
jmp 0x5ff90
cmpl $0x11d, %esi            # imm = 0x11D
jle 0x5ff04
cmpl $0x11e, %esi            # imm = 0x11E
je 0x5ff38
cmpl $0x131, %esi            # imm = 0x131
je 0x5ff65
cmpl $0x170, %esi            # imm = 0x170
jne 0x5ff93
addq $0x1490, %rdi           # imm = 0x1490
jmp 0x5ff90
cmpl $0x25c, %esi            # imm = 0x25C
je 0x5ff4a
cmpl $0x274, %esi            # imm = 0x274
je 0x5ff77
cmpl $0x287, %esi            # imm = 0x287
jne 0x5ff93
addq $0x23a0, %rdi           # imm = 0x23A0
jmp 0x5ff90
cmpl $0x183, %esi            # imm = 0x183
je 0x5ff53
cmpl $0x1a7, %esi            # imm = 0x1A7
jne 0x5ff93
addq $0x1200, %rdi           # imm = 0x1200
jmp 0x5ff90
cmpl $0x10, %esi
je 0x5ff80
cmpl $0x23, %esi
jne 0x5ff93
addq $0x338, %rdi            # imm = 0x338
jmp 0x5ff90
cmpl $0xf8, %esi
je 0x5ff89
cmpl $0x10b, %esi            # imm = 0x10B
jne 0x5ff93
addq $0x1900, %rdi           # imm = 0x1900
jmp 0x5ff90
addq $0x1128, %rdi           # imm = 0x1128
jmp 0x5ff90
addq $0x2140, %rdi           # imm = 0x2140
jmp 0x5ff90
addq $0x410, %rdi            # imm = 0x410
jmp 0x5ff90
addq $0x1b18, %rdi           # imm = 0x1B18
jmp 0x5ff90
addq $0x1d18, %rdi           # imm = 0x1D18
jmp 0x5ff90
addq $0x2400, %rdi           # imm = 0x2400
jmp 0x5ff90
addq $0x1568, %rdi           # imm = 0x1568
jmp 0x5ff90
addq $0x9b0, %rdi            # imm = 0x9B0
jmp 0x5ff90
addq $0x1bf0, %rdi           # imm = 0x1BF0
jmp 0x5ff90
addq $0x1fa0, %rdi           # imm = 0x1FA0
jmp 0x5ff90
addq $0x22c8, %rdi           # imm = 0x22C8
jmp 0x5ff90
addq $0x260, %rdi            # imm = 0x260
jmp 0x5ff90
addq $0x1828, %rdi           # imm = 0x1828
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: address_symboltype
static enum nk_symbol_type *address_symboltype(nk_context_t *context, enum nonnk_style what)
    {
    switch(what)
        { 
        CASE_NONNK_STYLE_SYMBOL_TYPE
        default: return NULL;
        }
    return NULL;
    }

// Assembly:
xorl %eax, %eax
cmpl $0x192, %esi            # imm = 0x192
jg 0x61593
cmpl $0xdd, %esi
jle 0x615d7
cmpl $0x155, %esi            # imm = 0x155
jle 0x61669
cmpl $0x156, %esi            # imm = 0x156
je 0x616d1
cmpl $0x157, %esi            # imm = 0x157
je 0x616bf
cmpl $0x192, %esi            # imm = 0x192
jne 0x616f6
addq $0xcb0, %rdi            # imm = 0xCB0
jmp 0x616f3
cmpl $0x206, %esi            # imm = 0x206
jle 0x615fd
cmpl $0x25c, %esi            # imm = 0x25C
jle 0x61682
cmpl $0x25d, %esi            # imm = 0x25D
je 0x616da
cmpl $0x25e, %esi            # imm = 0x25E
je 0x616c8
cmpl $0x25f, %esi            # imm = 0x25F
jne 0x616f6
addq $0x23f0, %rdi           # imm = 0x23F0
jmp 0x616f3
cmpl $0xc8, %esi
jg 0x61629
cmpl $0x7e, %esi
je 0x6169b
cmpl $0x7f, %esi
jne 0x616f6
addq $0xad4, %rdi            # imm = 0xAD4
jmp 0x616f3
cmpl $0x1e7, %esi            # imm = 0x1E7
jg 0x61649
cmpl $0x193, %esi            # imm = 0x193
je 0x616a4
cmpl $0x1e7, %esi            # imm = 0x1E7
jne 0x616f6
addq $0x2188, %rdi           # imm = 0x2188
jmp 0x616f3
cmpl $0xc9, %esi
je 0x616ad
cmpl $0xca, %esi
jne 0x616f6
addq $0x1948, %rdi           # imm = 0x1948
jmp 0x616f3
cmpl $0x1e8, %esi            # imm = 0x1E8
je 0x616b6
cmpl $0x1e9, %esi            # imm = 0x1E9
jne 0x616f6
addq $0x2190, %rdi           # imm = 0x2190
jmp 0x616f3
cmpl $0xde, %esi
je 0x616e3
cmpl $0xdf, %esi
jne 0x616f6
addq $0x1c38, %rdi           # imm = 0x1C38
jmp 0x616f3
cmpl $0x207, %esi            # imm = 0x207
je 0x616ec
cmpl $0x208, %esi            # imm = 0x208
jne 0x616f6
addq $0x1fec, %rdi           # imm = 0x1FEC
jmp 0x616f3
addq $0xad0, %rdi            # imm = 0xAD0
jmp 0x616f3
addq $0xcb4, %rdi            # imm = 0xCB4
jmp 0x616f3
addq $0x194c, %rdi           # imm = 0x194C
jmp 0x616f3
addq $0x218c, %rdi           # imm = 0x218C
jmp 0x616f3
addq $0x15b0, %rdi           # imm = 0x15B0
jmp 0x616f3
addq $0x23ec, %rdi           # imm = 0x23EC
jmp 0x616f3
addq $0x15b4, %rdi           # imm = 0x15B4
jmp 0x616f3
addq $0x23e8, %rdi           # imm = 0x23E8
jmp 0x616f3
addq $0x1c3c, %rdi           # imm = 0x1C3C
jmp 0x616f3
addq $0x1fe8, %rdi           # imm = 0x1FE8
movq %rdi, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5b6c(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x61731
leaq 0x5ca9(%rip), %rsi      # 0x673d5
jmp 0x6185e
leaq 0x58c8(%rip), %rcx      # 0x67000
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x61758
leaq 0x58b9(%rip), %rsi      # 0x6700c
jmp 0x6185e
leaq 0x5952(%rip), %rcx      # 0x670b1
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6177f
leaq 0x11cb5(%rip), %rsi     # 0x7342f
jmp 0x6185e
leaq 0x5abe(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x617a6
leaq 0x5aaf(%rip), %rsi      # 0x67250
jmp 0x6185e
leaq 0x5915(%rip), %rcx      # 0x670c2
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x617cd
leaq 0xb737(%rip), %rsi      # 0x6ceff
jmp 0x6185e
leaq 0x5901(%rip), %rcx      # 0x670d5
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x617f1
leaq 0x5910(%rip), %rsi      # 0x670ff
jmp 0x6185e
leaq 0x5bf7(%rip), %rcx      # 0x673ef
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x61815
leaq 0x5be8(%rip), %rsi      # 0x673fb
jmp 0x6185e
leaq 0x5bc1(%rip), %rcx      # 0x673dd
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6183c
leaq 0x5baf(%rip), %rsi      # 0x673e9
jmp 0x6185e
leaq 0x58ff(%rip), %rcx      # 0x67142
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6186c
leaq 0x58f0(%rip), %rsi      # 0x6714e
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_O3/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 0x26528(%rip), %rbx     # 0x88148
testq %rbx, %rbx
je 0x61c36
cmpq %rdx, 0x20(%rbx)
ja 0x61c31
jae 0x61c45
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0x61c20
leaq 0x119fb(%rip), %rsi     # 0x73638
xorl %eax, %eax
popq %rbx
jmp 0x139b0
movl 0x28(%rbx), %edx
cmpl $-0x2, %edx
je 0x61c5e
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
movl $0xfffffffe, 0x28(%rbx) # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x264d5(%rip), %r14     # 0x88148
testq %r14, %r14
je 0x61c89
cmpq %rdx, 0x20(%r14)
ja 0x61c84
jae 0x61ca1
addq $0x8, %r14
movq (%r14), %r14
jmp 0x61c73
leaq 0x119a8(%rip), %rsi     # 0x73638
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x139b0
movl 0x28(%r14), %edx
cmpl $-0x2, %edx
je 0x61cb7
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
movq %r14, %rdi
callq 0x61cd4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2606d(%rip), %rax     # 0x88148
testq %rax, %rax
je 0x620f1
cmpq %rdx, 0x20(%rax)
ja 0x620ec
jae 0x62103
addq $0x8, %rax
movq (%rax), %rax
jmp 0x620db
leaq 0x11540(%rip), %rsi     # 0x73638
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x139b0
movslq 0x28(%rax), %rdx
cmpq $-0x2, %rdx
jne 0x6211f
leaq 0x11541(%rip), %rsi     # 0x73655
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x139b0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
cmpl $0x7, %eax
jne 0x62138
movl $0x1, %eax
popq %rbx
retq
leaq 0x4fe0(%rip), %rsi      # 0x6711f
leaq 0x11523(%rip), %rdx     # 0x73669
movq %rbx, %rdi
movl $0xa3, %ecx
xorl %eax, %eax
popq %rbx
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x25feb(%rip), %rax     # 0x88148
testq %rax, %rax
je 0x621a1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rax, %r14
cmpq $0x0, 0x20(%rax)
je 0x6217b
movq (%r14), %rax
testq %rax, %rax
jne 0x62169
movq %r14, %rdi
callq 0x61cd4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130d0
movq 0x25fb3(%rip), %rax     # 0x88148
testq %rax, %rax
jne 0x62169
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x25f9f(%rip), %rax     # 0x88148
testq %rax, %rax
je 0x6222b
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edx, %edx
movq %rax, %rsi
xorl %ecx, %ecx
movq 0x20(%rsi), %r13
cmpq %rdx, %r13
jbe 0x621d8
movq %rsi, %rcx
jmp 0x621de
jae 0x621f1
addq $0x8, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x621ca
testq %rcx, %rcx
je 0x6221f
movq 0x20(%rcx), %r13
jmp 0x621f4
movq %rsi, %rcx
cmpq %r15, 0x38(%rcx)
jne 0x62214
movq 0x30(%rcx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
jne 0x6222e
movq 0x25f34(%rip), %rax     # 0x88148
incq %r13
movq %r13, %rdx
testq %rax, %rax
jne 0x621c5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
movl $0x1, %eax
jmp 0x62221
// File: /workspace/github_c_makefile_star2_O3/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 0x6225f
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 0x622b3
movq %rax, %rbx
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x14050
cmpl $0x5, %eax
jne 0x622b7
movq %r14, %rdi
callq 0x120f0
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x622cf
movl %eax, %ebp
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %eax, %eax
testl %ebp, %ebp
cmoveq %rax, %rbx
jmp 0x62251
xorl %ebx, %ebx
jmp 0x62251
leaq 0x113b3(%rip), %rsi     # 0x73671
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x139b0
jmp 0x62251
// File: /workspace/github_c_makefile_star2_O3/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 0x113ca(%rip), %rdx     # 0x736a9
callq 0x13870
testl %eax, %eax
je 0x6232c
movq %rbx, %rdi
callq 0x120f0
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x13730
movl $0x1, %r14d
testl %eax, %eax
jne 0x6231d
movq %rbx, %rdi
callq 0x120f0
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x622cf
movl %eax, %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
jmp 0x6232f
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x623d9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12d70
leaq 0x1133d(%rip), %rdx     # 0x736a9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
testq %r15, %r15
je 0x6238b
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x123c0
testq %r14, %r14
je 0x623be
leaq 0x11312(%rip), %rdx     # 0x736a9
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 0x112ac(%rip), %rsi     # 0x7368c
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_O3/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 0x62463
leaq 0x1128a(%rip), %rdx     # 0x736a9
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 0x62472
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 0x11207(%rip), %rsi     # 0x73671
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x6247f
leaq 0x111f8(%rip), %rsi     # 0x73671
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O3/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 0x624f3
testq %r14, %r14
je 0x624de
leaq 0x111f2(%rip), %rdx     # 0x736a9
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 0x11177(%rip), %rsi     # 0x73671
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O3/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 0x6256a
movq 0x25c20(%rip), %rax     # 0x88150
testq %rax, %rax
je 0x62561
movq %rsi, %r14
movq 0x25c19(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *%rax
testq %rax, %rax
je 0x62561
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12b50
leaq 0x11216(%rip), %rsi     # 0x7377e
jmp 0x62571
leaq 0x1121b(%rip), %rsi     # 0x7378c
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_O3/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_MallocNoErr
void *MallocNoErr(lua_State *L, size_t size) /* do not raise errors (check the retval) */
    {
    void *ptr = Malloc_(size);
    (void)L;
    if(ptr==NULL)
        return NULL;
    memset(ptr, 0, size);
    //DBG("MallocNoErr %p\n", ptr);
    return ptr;
    }

// Assembly:
pushq %rbx
movq 0x25ba2(%rip), %rax     # 0x88150
testq %rax, %rax
je 0x625d9
movq %rsi, %rbx
movq 0x25b9b(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq *%rax
testq %rax, %rax
je 0x625d9
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x12b50
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6261a
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_O3/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 0x626ed
testl %eax, %eax
je 0x626e9
leaq 0x11013(%rip), %rdx     # 0x736f2
movq %r14, %rdi
movl %ebx, %esi
callq 0x12460
xorl %eax, %eax
jmp 0x626f7
movq %r14, %rdi
movl %ebx, %esi
callq 0x13800
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x62767
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_O3/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 0x627d6
xorl %r14d, %r14d
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x125f0
testl %eax, %eax
jle 0x627e1
movl $0x0, (%rbx)
decl %eax
movl %eax, %r14d
jmp 0x627e7
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %r14d, %r14d
jmp 0x627e7
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_O3/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 0x62811
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10f07(%rip), %rdx     # 0x7371f
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/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 0x6284a
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10ece(%rip), %rdx     # 0x7371f
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/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, %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 0x62970
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x6297e
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x62978
movq 0x25886(%rip), %r8      # 0x88150
movl $0xfffffffa, %r13d      # imm = 0xFFFFFFFA
testq %r8, %r8
je 0x6297e
shlq $0x20, %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rax, %rcx
sarq $0x1d, %rcx
movq 0x25863(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %rcx, (%rsp)
callq *%r8
testq %rax, %rax
je 0x6297e
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x12b50
cmpl $0x0, (%r14)
jle 0x62984
movq %rbx, (%rsp)
xorl %ebx, %ebx
leaq 0x1(%rbx), %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x12950
cmpl $0x4, %eax
jne 0x62996
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 0x62922
jmp 0x62984
movl $0x1, %r13d
jmp 0x6297e
movl $0xfffffffb, %r13d      # imm = 0xFFFFFFFB
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
movl $0xfffffffe, %r13d      # 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), %rbx
jmp 0x6297e
// File: /workspace/github_c_makefile_star2_O3/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 0x62a23
movq %rsi, %rbx
testl %edx, %edx
jle 0x62a02
movl %edx, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rsi
testq %rsi, %rsi
je 0x629fa
movq 0x25768(%rip), %rax     # 0x88150
testq %rax, %rax
je 0x629fa
movq 0x25764(%rip), %rdi     # 0x88158
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
incq %r15
cmpq %r15, %r14
jne 0x629d8
movq 0x25747(%rip), %rax     # 0x88150
testq %rax, %rax
je 0x62a23
movq 0x25743(%rip), %rdi     # 0x88158
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_O3/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 0x62b8d
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x62bd7
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x62b95
movq 0x2566a(%rip), %r8      # 0x88150
movl $0xfffffffa, %r13d      # imm = 0xFFFFFFFA
testq %r8, %r8
je 0x62bd0
movslq %eax, %rcx
shlq $0x2, %rcx
movq 0x25655(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %rcx, (%rsp)
callq *%r8
testq %rax, %rax
je 0x62bd0
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x12b50
cmpl $0x0, (%r14)
jle 0x62bdd
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 0x62b9d
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 0x62b38
jmp 0x62bdd
movl $0x1, %r13d
jmp 0x62bd7
movl $0xfffffffb, %r13d      # imm = 0xFFFFFFFB
jmp 0x62bd7
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq 0x25599(%rip), %rax     # 0x88150
testq %rax, %rax
je 0x62bcc
movq 0x25595(%rip), %rdi     # 0x88158
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_O3/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 0x62c69
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 0x62c37
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x62d6c
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x62db5
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x62d74
movq %r14, (%rsp)
movq 0x2547c(%rip), %r8      # 0x88150
movl $0xfffffffa, %r13d      # imm = 0xFFFFFFFA
testq %r8, %r8
je 0x62dab
movslq %eax, %r12
shlq $0x3, %r12
movq 0x25467(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq *%r8
testq %rax, %rax
je 0x62dab
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
movq (%rsp), %rax
cmpl $0x0, (%rax)
jle 0x62dbb
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 0x62d7c
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq (%rsp), %rax
movslq (%rax), %rax
addq $0x8, %r12
cmpq %rax, %r13
jl 0x62d27
jmp 0x62dbb
movl $0x1, %r13d
jmp 0x62db5
movl $0xfffffffb, %r13d      # imm = 0xFFFFFFFB
jmp 0x62db5
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x12180
movq 0x253c0(%rip), %rax     # 0x88150
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x62dab
movq 0x253b6(%rip), %rdi     # 0x88158
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq (%rsp), %rax
movl $0x0, (%rax)
movl %r13d, (%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_O3/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, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x13df0
testl %eax, %eax
jle 0x62ee6
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x62f2f
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x62eee
movq %r14, (%rsp)
movq 0x25302(%rip), %r8      # 0x88150
movl $0xfffffffa, %r13d      # imm = 0xFFFFFFFA
testq %r8, %r8
je 0x62f25
movslq %eax, %r12
shlq $0x2, %r12
movq 0x252ed(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq *%r8
testq %rax, %rax
je 0x62f25
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
movq (%rsp), %rax
cmpl $0x0, (%rax)
jle 0x62f35
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 0x62ef6
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq (%rsp), %rax
movslq (%rax), %rax
addq $0x4, %r12
cmpq %rax, %r13
jl 0x62ea1
jmp 0x62f35
movl $0x1, %r13d
jmp 0x62f2f
movl $0xfffffffb, %r13d      # imm = 0xFFFFFFFB
jmp 0x62f2f
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x12180
movq 0x25246(%rip), %rax     # 0x88150
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x62f25
movq 0x2523c(%rip), %rdi     # 0x88158
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq (%rsp), %rax
movl $0x0, (%rax)
movl %r13d, (%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_O3/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 0x6308b
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x63093
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movl %eax, (%r14)
testl %eax, %eax
je 0x630aa
movq 0x2518f(%rip), %r8      # 0x88150
testq %r8, %r8
je 0x6309b
shlq $0x20, %rax
movabsq $0x100000000, %r13      # imm = 0x100000000
addq %rax, %r13
sarq $0x1e, %r13
movq 0x25172(%rip), %rdi     # 0x88158
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
callq *%r8
testq %rax, %rax
je 0x6309b
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movq %r13, %rdx
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
callq 0x12b50
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x630c5
leaq 0x1(%r13), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12950
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %rdx
callq 0x125f0
movl %eax, (%r12,%r13,4)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
cmpl $0x0, 0xc(%rsp)
movq %rbx, %r13
jne 0x63011
movq 0x250ee(%rip), %rax     # 0x88150
testq %rax, %rax
je 0x63077
movq 0x250ea(%rip), %rdi     # 0x88158
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movl $0x0, (%r14)
movq 0x10(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x630b0
movl $0x1, (%rbx)
jmp 0x630b0
movl $0xfffffffc, (%rbx)     # imm = 0xFFFFFFFC
jmp 0x630b0
movl $0x0, (%r14)
movl $0xfffffffa, (%rbx)     # imm = 0xFFFFFFFA
jmp 0x630b0
movl $0xfffffffb, (%rbx)     # imm = 0xFFFFFFFB
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 0x630b3
// File: /workspace/github_c_makefile_star2_O3/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 0x63138
movl (%rbx), %eax
testl %eax, %eax
je 0x63138
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 0x63113
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4071(%rip), %rcx      # 0x67280
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 0x63255
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x632cd
movl $0x3, %esi
callq 0x13df0
testl %eax, %eax
jle 0x63290
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x6329f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x6324b
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
jmp 0x632b1
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_O3/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 0x3e5d(%rip), %rcx      # 0x67280
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_O3/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 0x3e0d(%rip), %rcx      # 0x67280
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_O3/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 0x3daf(%rip), %rcx      # 0x67280
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