LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: QueryCallback
static void QueryCallback(nk_handle handle, float height, nk_user_font_glyph_t *glyph, nk_rune codepoint, nk_rune next_codepoint) // nk_query_font_glyph_f
    {
#define L moonnuklear_L
    ud_t *ud = (ud_t*)(handle.ptr);
    pushvalue(L, ud->ref2);             // function
    lua_pushnumber(L, height);          // arg1
    lua_pushinteger(L, codepoint);      // arg2
    lua_pushinteger(L, next_codepoint); // arg3
    if(lua_pcall(L, 3, 6, 0) != LUA_OK)
        { lua_error(L); return; }
    /* fill glyph with the returned values */
    if(echeckvec2(L, -6, &glyph->uv[0])) argerror(L, -6);  // retval1
    if(echeckvec2(L, -5, &glyph->uv[1])) argerror(L, -5);  // retval2
    if(echeckvec2(L, -4, &glyph->offset)) argerror(L, -4); // retval3
    glyph->width = luaL_checknumber(L, -3);                // retval4
    glyph->height = luaL_checknumber(L, -2);               // retval5
    glyph->xadvance = luaL_checknumber(L, -1);             // retval6
    lua_pop(L, 6);
    return;
#undef L
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movss %xmm0, 0x4(%rsp)
movq 0x64783(%rip), %r15     # 0x84ff0
movq (%r15), %rax
movslq 0x78(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r15), %rdi
cvtss2sd 0x4(%rsp), %xmm0
callq 0x132d0
movq (%r15), %rdi
movl %r14d, %esi
callq 0x12c20
movq (%r15), %rdi
movl %ebp, %esi
callq 0x12c20
movq (%r15), %rdi
pushq $0x3
popq %rsi
pushq $0x6
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
movq (%r15), %rdi
testl %eax, %eax
je 0x208d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13960
pushq $-0x6
popq %rsi
movq %rbx, %rdx
callq 0x143f0
testl %eax, %eax
je 0x208fd
movq (%r15), %r14
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $-0x6
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movq (%r15), %rdi
leaq 0x8(%rbx), %rdx
pushq $-0x5
popq %rsi
callq 0x143f0
testl %eax, %eax
je 0x2092e
movq (%r15), %r14
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $-0x5
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movq (%r15), %rdi
leaq 0x10(%rbx), %rdx
pushq $-0x4
popq %rsi
callq 0x143f0
testl %eax, %eax
je 0x2095f
movq (%r15), %r14
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $-0x4
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movq (%r15), %rdi
pushq $-0x3
popq %rsi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rbx)
movq (%r15), %rdi
pushq $-0x2
popq %rsi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rbx)
movq (%r15), %rdi
pushq $-0x1
popq %rsi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rbx)
movq (%r15), %rdi
pushq $-0x7
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12190
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/image.c
// Function: Image_info
static int Image_info(lua_State *L)
    {
    ud_t *ud;
    nk_rect_t r;
    nk_image_t *image = checkimage(L, 1, &ud);
    if(IsImageId(ud))
        lua_pushlightuserdata(L, image->handle.ptr);
    else
        lua_pushinteger(L, image->handle.id);
    if(!IsSubImage(ud))
        return 1;
    lua_pushinteger(L, image->w);
    lua_pushinteger(L, image->h);
    r.x = image->region[0];
    r.y = image->region[1];
    r.w = image->region[2];
    r.h = image->region[3];
    pushrect(L, &r);
    return 4;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x3f7e9(%rip), %rcx     # 0x60244
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
movl %ebp, %esi
movq %r15, %rdx
callq 0x120e0
movq %rax, %r14
movq (%r15), %rax
testb $-0x80, 0x70(%rax)
jne 0x20a86
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x12c20
jmp 0x20a91
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x135e0
movq 0x8(%rsp), %rax
testb $0x1, 0x71(%rax)
je 0x20ada
movzwl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movzwl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movq 0xc(%r14), %xmm0
pxor %xmm1, %xmm1
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12790
pushq $0x4
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/image.c
// Function: NewSubImage
static int NewSubImage(lua_State *L)
/* image = new_subimage(ptr|id, w, h, rect) */
    {
    ud_t *ud;
    nk_rect_t subregion;
    unsigned short w = luaL_checkinteger(L, 2);
    unsigned short h = luaL_checkinteger(L, 3);
    if(echeckrect(L, 4, &subregion)) return argerror(L, 4);
    ud = New(L, w, h, subregion);
    MarkSubImage(ud);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x13060
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x20b50
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x20b7b
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %r14d
andl %eax, %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x20b85
orb $0x1, 0x71(%rax)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/image.c
// Function: New
static ud_t* New(lua_State *L, unsigned short w, unsigned short h, nk_rect_t subregion)
    {
    ud_t *ud;
    nk_image_t *image;
    int id = 0;
    void *ptr = NULL;

    if(lua_type(L, 1) == LUA_TLIGHTUSERDATA)
        ptr = checklightuserdata(L, 1);
    else
        id = luaL_checkinteger(L, 1);

    image = (nk_image_t*)Malloc(L, sizeof(nk_image_t));
    if(ptr) { image->handle.ptr = ptr; } else { image->handle.id = id; }
    image->w = w;
    image->h = h;
    image->region[0] = (unsigned short)subregion.x;
    image->region[1] = (unsigned short)subregion.y;
    image->region[2] = (unsigned short)subregion.w;
    image->region[3] = (unsigned short)subregion.h;
    ud = newuserdata(L, image, IMAGE_MT, "image");
    ud->parent_ud = NULL;
    ud->destructor = freeimage;
    if(!ptr) MarkImageId(ud);
    return ud;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x14030
pushq $0x1
popq %rsi
movq %rbx, %rdi
cmpl $0x2, %eax
jne 0x20bc2
callq 0x139f0
movq %rax, %r15
xorl %r12d, %r12d
jmp 0x20bcd
callq 0x13060
movq %rax, %r12
xorl %r15d, %r15d
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x13c00
testq %r15, %r15
je 0x20be2
movq %r15, (%rax)
jmp 0x20be5
movl %r12d, (%rax)
movw %r14w, 0x8(%rax)
movw %bp, 0xa(%rax)
movaps (%rsp), %xmm0
unpcklpd 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
pshufhw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,6,6,7]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
movq %xmm0, 0xc(%rax)
leaq 0x3f62d(%rip), %rdx     # 0x60244
leaq 0x3f632(%rip), %rcx     # 0x60250
movq %rbx, %rdi
movq %rax, %rsi
callq 0x140d0
andq $0x0, 0x10(%rax)
leaq 0x1a(%rip), %rcx        # 0x20c4f
movq %rcx, 0x8(%rax)
testq %r15, %r15
jne 0x20c42
orb $-0x80, 0x70(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/image.c
// Function: freeimage
static int freeimage(lua_State *L, ud_t *ud)
    {
    nk_image_t *image = (nk_image_t*)ud->handle;
    freechildren(L, CURSOR_MT, ud);
    if(!freeuserdata(L, ud, "image")) return 0;
    Free(L, image);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x3f45e(%rip), %rsi     # 0x600c2
movq %r15, %rdx
callq 0x121f0
leaq 0x3f5dd(%rip), %rdx     # 0x60250
movq %r14, %rdi
movq %r15, %rsi
callq 0x13f10
testl %eax, %eax
je 0x20c8d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: Mouse_delta
static int Mouse_delta(lua_State *L)
    {
    const nk_input_t *input = checkinput(L, 1);
    lua_pushnumber(L, input->mouse.delta.x);
    lua_pushnumber(L, input->mouse.delta.y);
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21437
movq %rax, %r14
cvtss2sd 0x154(%rax), %xmm0
movq %rbx, %rdi
callq 0x132d0
cvtss2sd 0x158(%r14), %xmm0
movq %rbx, %rdi
callq 0x132d0
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: Mouse_scroll_delta
static int Mouse_scroll_delta(lua_State *L)
    {
    const nk_input_t *input = checkinput(L, 1);
    lua_pushnumber(L, input->mouse.scroll_delta.x);
    lua_pushnumber(L, input->mouse.scroll_delta.y);
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21437
movq %rax, %r14
cvtss2sd 0x15c(%rax), %xmm0
movq %rbx, %rdi
callq 0x132d0
cvtss2sd 0x160(%r14), %xmm0
movq %rbx, %rdi
callq 0x132d0
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: Mouse_pos
static int Mouse_pos(lua_State *L)
    {
    const nk_input_t *input = checkinput(L, 1);
    lua_pushnumber(L, input->mouse.pos.x);
    lua_pushnumber(L, input->mouse.pos.y);
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21437
movq %rax, %r14
cvtss2sd 0x144(%rax), %xmm0
movq %rbx, %rdi
callq 0x132d0
cvtss2sd 0x148(%r14), %xmm0
movq %rbx, %rdi
callq 0x132d0
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: Mouse_prev
static int Mouse_prev(lua_State *L)
    {
    const nk_input_t *input = checkinput(L, 1);
    lua_pushnumber(L, input->mouse.prev.x);
    lua_pushnumber(L, input->mouse.prev.y);
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21437
movq %rax, %r14
cvtss2sd 0x14c(%rax), %xmm0
movq %rbx, %rdi
callq 0x132d0
cvtss2sd 0x150(%r14), %xmm0
movq %rbx, %rdi
callq 0x132d0
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputMotion
static int InputMotion(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    int x = luaL_checkinteger(L, 2);
    int y = luaL_checkinteger(L, 3);
    nk_input_motion(context, x, y);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3eded(%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 %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13590
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: Input_mouse_pos
static int Input_mouse_pos(lua_State *L)
    {
    nk_input_t *input = checkinput(L, 1);
    float x = luaL_checknumber(L, 2);
    float y = luaL_checknumber(L, 3);
    input->mouse.pos.x = x;
    input->mouse.pos.y = y;
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x21437
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
movapd %xmm0, (%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x144(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputKey
static int InputKey(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_keys key = checkkeys(L, 2);
    int down = optboolean(L, 3, nk_false);
    nk_input_key(context, key, down);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3ed57(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13b60
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x13bc0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputKeys
static int InputKeys(lua_State *L)
    {
    int key;
    int down[NK_KEY_MAX];
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckkeytable(L, 2, down)) return argerror(L, 2);
    for(key = 0; key < NK_KEY_MAX; key++)
        nk_input_key(context, (enum nk_keys)key, down[key]);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x3ed05(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x12a80
testl %eax, %eax
je 0x215c6
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, %ebx
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq $0x1e, %r15
je 0x215b7
movl (%rsp,%r15,4), %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0x13bc0
incq %r15
jmp 0x215cb
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputButton
static int InputButton(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_buttons button = checkbuttons(L, 2);
    int x = luaL_checkinteger(L, 3);
    int y = luaL_checkinteger(L, 4);
    int down = optboolean(L, 5, nk_false);
    nk_input_button(context, button, x, y, down);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3ec86(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rbp
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13450
movl %eax, %r15d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13060
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r13
pushq $0x5
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13b60
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
movl %eax, %r8d
callq 0x12c60
xorl %eax, %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/input.c
// Function: InputScroll
static int InputScroll(lua_State *L)
    {
    nk_vec2_t scroll;
    nk_context_t *context = checkcontext(L, 1, NULL);
    scroll.x = luaL_checknumber(L, 2);
    scroll.y = luaL_checknumber(L, 3);
    nk_input_scroll(context, scroll);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3ec08(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
movapd %xmm0, (%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvtpd2ps %xmm1, %xmm0
movq %r14, %rdi
callq 0x14360
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputChar
static int InputChar(lua_State *L)
    {
    int arg = 2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    while(!lua_isnoneornil(L, arg))
        nk_input_char(context, luaL_checkinteger(L, arg++));
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3ebb0(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14030
testl %eax, %eax
jle 0x2170f
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movsbl %al, %esi
movq %r14, %rdi
callq 0x13b90
movl %ebp, %r15d
jmp 0x216e1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputGlyph
static int InputGlyph(lua_State *L)
    {
    size_t len;
    nk_glyph glyph;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    if(len == 0 || len > NK_UTF_SIZE)
        return argerrorc(L, 2, ERR_LENGTH);
    memcpy(glyph, s, len);
    nk_input_glyph(context, glyph);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x3eb4f(%rip), %rcx     # 0x60280
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x12dd0
movq (%r12), %rdx
leaq -0x5(%rdx), %rcx
cmpq $-0x5, %rcx
ja 0x2177b
pushq $-0x8
popq %rdi
callq 0x13cc0
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x21796
leaq 0xc(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x13150
movq %r15, %rdi
movq %r14, %rsi
callq 0x12050
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/input.c
// Function: InputUnicode
static int InputUnicode(lua_State *L)
    {
    int arg = 2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    while(!lua_isnoneornil(L, arg))
        nk_input_unicode(context, luaL_checkinteger(L, arg++));
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3eacb(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14030
testl %eax, %eax
jle 0x217f3
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movq %r14, %rdi
movl %eax, %esi
callq 0x139a0
movl %ebp, %r15d
jmp 0x217c6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_set_min_row_height
static int Layout_set_min_row_height(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float height = luaL_checknumber(L, 1);
    nk_layout_set_min_row_height(context, height);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3ea64(%rip), %rcx     # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13ab0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_ratio_from_pixel
static int Layout_ratio_from_pixel(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float pixel_width = luaL_checknumber(L, 2);
    lua_pushnumber(L, nk_layout_ratio_from_pixel(context, pixel_width));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3e9d4(%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
movq %r14, %rdi
callq 0x13a90
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x132d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_dynamic
static int Layout_row_dynamic(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float height = luaL_checknumber(L, 2);
    int cols = luaL_checkinteger(L, 3);
    nk_layout_row_dynamic(context, height, cols);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e98d(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %eax, %esi
callq 0x12f50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_static
static int Layout_row_static(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float height = luaL_checknumber(L, 2);
    int item_width = luaL_checkinteger(L, 3);
    int cols = luaL_checkinteger(L, 4);
    nk_layout_row_static(context, height, item_width, cols);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3e933(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
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
callq 0x13060
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
movl %r15d, %esi
movl %eax, %edx
callq 0x13c30
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_begin
static int Layout_row_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_layout_format fmt = checklayoutformat(L, 2);
    float row_height = luaL_checknumber(L, 3);
    int cols = luaL_checkinteger(L, 4);
    nk_layout_row_begin(context, fmt, row_height, cols);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3e8c7(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x6
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movl %eax, %edx
callq 0x12500
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_push
static int Layout_row_push(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float value = luaL_checknumber(L, 2);
    nk_layout_row_push(context, value);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e85f(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13930
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row
static int Layout_row(lua_State *L)
    {
    ud_t *ud;
    int cols, err;
    nk_context_t *context = checkcontext(L, 1, &ud);
    enum nk_layout_format fmt = checklayoutformat(L, 2);
    float height = luaL_checknumber(L, 3);
    float *ratio = checkfloatlist(L, 4, &cols, &err);
    if(err) return argerrorc(L, 4, err);
    /* free the old list and replace it with the new one 
    *  (This is because it seems that nuklear retains the passed float*
    *  instead of making an internal copy. So, to avoid memory leaks, we
    *  store it the context's ud and free it the next time this function
    *  is called, or when the context itself is deleted.)
    */
    if(ud->ratio) Free(L, ud->ratio);
    ud->ratio = ratio;
    nk_layout_row(context, fmt, height, cols, ratio);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3e7fd(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x120e0
movq %rax, %r14
pushq $0x6
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, (%rsp)
pushq $0x4
popq %rsi
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
callq 0x14290
movl (%r12), %edi
testl %edi, %edi
je 0x21ae8
callq 0x13cc0
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x21b32
movq %rax, %r15
cvtsd2ss (%rsp), %xmm0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
testq %rsi, %rsi
je 0x21b18
movq %rbx, %rdi
movss %xmm0, (%rsp)
callq 0x13220
movss (%rsp), %xmm0
movq 0x10(%rsp), %rax
movq %r15, 0x80(%rax)
movl 0xc(%rsp), %edx
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rcx
callq 0x12a50
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_template_begin
static int Layout_row_template_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float row_height = luaL_checknumber(L, 2);
    nk_layout_row_template_begin(context, row_height);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e733(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x14140
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_template_push_variable
static int Layout_row_template_push_variable(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float min_width = luaL_checknumber(L, 2);
    nk_layout_row_template_push_variable(context, min_width);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e6d9(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13f90
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_template_push_static
static int Layout_row_template_push_static(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float width = luaL_checknumber(L, 2);
    nk_layout_row_template_push_static(context, width);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e69d(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13350
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_begin
static int Layout_space_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_layout_format fmt = checklayoutformat(L, 2);
    float height = luaL_checknumber(L, 3);
    int widget_count = luaL_checkinteger(L, 4);
    nk_layout_space_begin(context, fmt, height, widget_count);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3e63f(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x6
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movl %eax, %edx
callq 0x12d60
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_push
static int Layout_space_push(lua_State *L)
    {
    nk_rect_t bounds; 
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &bounds)) return argerror(L, 2);
    nk_layout_space_push(context, bounds);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x3e5d2(%rip), %rcx     # 0x60280
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x21cee
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x21d01
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r15, %rdi
callq 0x13dc0
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_to_screen
static int Layout_space_to_screen(lua_State *L)
    {
    nk_vec2_t v1, v2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckvec2(L, 2, &v1)) return argerror(L, 2);
    v2 = nk_layout_space_to_screen(context, v1);
    return pushvec2(L, &v2);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3e50c(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x21db2
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x21dd0
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x13640
leaq 0x10(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12730
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_to_local
static int Layout_space_to_local(lua_State *L)
    {
    nk_vec2_t v1, v2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckvec2(L, 2, &v1)) return argerror(L, 2);
    v2 = nk_layout_space_to_local(context, v1);
    return pushvec2(L, &v2);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3e497(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x21e27
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x21e45
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x127e0
leaq 0x10(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12730
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_rect_to_screen
static int Layout_space_rect_to_screen(lua_State *L)
    {
    nk_rect_t r1, r2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &r1)) return argerror(L, 2);
    r2 = nk_layout_space_rect_to_screen(context, r1);
    return pushrect(L, &r2);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x3e422(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x21e9c
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x21ec3
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x14080
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq 0x18(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12790
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_rect_to_local
static int Layout_space_rect_to_local(lua_State *L)
    {
    nk_rect_t r1, r2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &r1)) return argerror(L, 2);
    r2 = nk_layout_space_rect_to_local(context, r1);
    return pushrect(L, &r2);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x3e3a4(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x21f1a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x21f41
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x13260
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq 0x18(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12790
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/main.c
// Function: luaopen_moonnuklear
int luaopen_moonnuklear(lua_State *L)
/* Lua calls this function to load the module */
    {
    moonnuklear_L = L;

    moonnuklear_utils_init(L);
    atexit(AtExit);

    lua_newtable(L); /* the nk table */

    /* add nk functions: */
    moonnuklear_open_versions(L);
    moonnuklear_open_enums(L);
    moonnuklear_open_flags(L);
    moonnuklear_open_tracing(L);
    moonnuklear_open_window(L);
    moonnuklear_open_layout(L);
    moonnuklear_open_widgets(L);
    moonnuklear_open_style(L);
    moonnuklear_open_context(L);
    moonnuklear_open_atlas(L);
    moonnuklear_open_font(L);
    moonnuklear_open_buffer(L);
    moonnuklear_open_image(L);
    moonnuklear_open_nine_slice(L);
    moonnuklear_open_cursor(L);
    moonnuklear_open_edit(L);
    moonnuklear_open_canvas(L);
    moonnuklear_open_panel(L);
    moonnuklear_open_input(L);

#if 0
    /* Add functions implemented in Lua @@ */
    lua_pushvalue(L, -1); lua_setglobal(L, "moonnuklear");
    if(luaL_dostring(L, "require('moonnuklear.utils')") != 0) lua_error(L);
    lua_pushnil(L);  lua_setglobal(L, "moonnuklear");
#endif

    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x63099(%rip), %rax     # 0x84ff0
movq %rdi, (%rax)
callq 0x141b0
leaq 0xae(%rip), %rdi        # 0x22014
callq 0x5ff80
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
movq %rbx, %rdi
callq 0x12ed0
movq %rbx, %rdi
callq 0x134b0
movq %rbx, %rdi
callq 0x136a0
movq %rbx, %rdi
callq 0x13080
movq %rbx, %rdi
callq 0x12090
movq %rbx, %rdi
callq 0x134e0
movq %rbx, %rdi
callq 0x13750
movq %rbx, %rdi
callq 0x135d0
movq %rbx, %rdi
callq 0x12bc0
movq %rbx, %rdi
callq 0x127a0
movq %rbx, %rdi
callq 0x12f80
movq %rbx, %rdi
callq 0x125e0
movq %rbx, %rdi
callq 0x13500
movq %rbx, %rdi
callq 0x13d60
movq %rbx, %rdi
callq 0x12d30
movq %rbx, %rdi
callq 0x13120
movq %rbx, %rdi
callq 0x12140
movq %rbx, %rdi
callq 0x12cd0
movq %rbx, %rdi
callq 0x13e50
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/nine_slice.c
// Function: NineSlice_info
static int NineSlice_info(lua_State *L)
    {
    ud_t *ud;
    nk_rect_t r;
    nk_nine_slice_t *nine_slice = checknine_slice(L, 1, &ud);
    if(IsNineSliceId(ud))
        lua_pushlightuserdata(L, nine_slice->img.handle.ptr);
    else
        lua_pushinteger(L, nine_slice->img.handle.id);
    lua_pushinteger(L, nine_slice->l);
    lua_pushinteger(L, nine_slice->t);
    lua_pushinteger(L, nine_slice->r);
    lua_pushinteger(L, nine_slice->b);
    if(!IsSubNineSlice(ud))
        return 5;
    lua_pushinteger(L, nine_slice->img.w);
    lua_pushinteger(L, nine_slice->img.h);
    r.x = nine_slice->img.region[0];
    r.y = nine_slice->img.region[1];
    r.w = nine_slice->img.region[2];
    r.h = nine_slice->img.region[3];
    pushrect(L, &r);
    return 8;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3e17c(%rip), %rcx     # 0x60256
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x120e0
movq %rax, %r14
movq (%r15), %rax
testb $0x2, 0x71(%rax)
jne 0x22103
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x12c20
jmp 0x2210e
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x135e0
movzwl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movzwl 0x1a(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movzwl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movzwl 0x1e(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movq 0x8(%rsp), %rax
testb $0x4, 0x71(%rax)
jne 0x22151
pushq $0x5
jmp 0x2218e
movzwl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movzwl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movq 0xc(%r14), %xmm0
pxor %xmm1, %xmm1
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12790
pushq $0x8
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/nine_slice.c
// Function: NewNineSlice
static int NewNineSlice(lua_State *L)
/* nine_slice = new_nine_slice(ptr|id, l, t, r, b) */
    { 
    nk_rect_t subregion;
    unsigned short l = luaL_checkinteger(L, 2);
    unsigned short t = luaL_checkinteger(L, 3);
    unsigned short r = luaL_checkinteger(L, 4);
    unsigned short b = luaL_checkinteger(L, 5);
    memset(&subregion, 0, sizeof(subregion));
    New(L, 0, 0, subregion, l, t, r, b);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x13060
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movl $0xffff, %ecx           # imm = 0xFFFF
andl %ecx, %eax
movl %eax, (%rsp)
andl %ecx, %r14d
andl %ecx, %r15d
andl %ecx, %r12d
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r14d, %ecx
movl %r15d, %r8d
movl %r12d, %r9d
callq 0x222fc
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/nine_slice.c
// Function: NewSubNineSlice
static int NewSubNineSlice(lua_State *L)
/* nine_slice = new_subnine_slice(ptr|id, w, h, rect, l, t, r, b) */
    {
    ud_t *ud;
    nk_rect_t subregion;
    unsigned short w = luaL_checkinteger(L, 2);
    unsigned short h = luaL_checkinteger(L, 3);
    unsigned short l = luaL_checkinteger(L, 5);
    unsigned short t = luaL_checkinteger(L, 6);
    unsigned short r = luaL_checkinteger(L, 7);
    unsigned short b = luaL_checkinteger(L, 8);
    if(echeckrect(L, 4, &subregion)) return argerror(L, 4);
    ud = New(L, w, h, subregion, l, t, r, b);
    MarkSubNineSlice(ud);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x13060
movq %rax, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r13
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %rbp
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r14
pushq $0x4
popq %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x222a8
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x222ed
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %r14d
movl %r14d, (%rsp)
movq 0x10(%rsp), %rsi
andl %eax, %esi
andl %eax, %r15d
andl %eax, %r12d
andl %eax, %r13d
andl %eax, %ebp
movq %rbx, %rdi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movl %ebp, %r9d
callq 0x222fc
orb $0x4, 0x71(%rax)
pushq $0x1
popq %rax
addq $0x28, %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/nine_slice.c
// Function: New
static ud_t* New(lua_State *L, unsigned short w, unsigned short h, nk_rect_t subregion, unsigned short l, unsigned short t, unsigned short r, unsigned short b)
    {
    ud_t *ud;
    nk_nine_slice_t *nine_slice;
    int id = 0;
    void *ptr = NULL;

    if(lua_type(L, 1) == LUA_TLIGHTUSERDATA)
        ptr = checklightuserdata(L, 1);
    else
        id = luaL_checkinteger(L, 1);

    nine_slice = (nk_nine_slice_t*)Malloc(L, sizeof(nk_nine_slice_t));
    if(ptr) { nine_slice->img.handle.ptr = ptr; } else { nine_slice->img.handle.id = id; }
    nine_slice->l = l;
    nine_slice->t = t;
    nine_slice->r = r;
    nine_slice->b = b;
    nine_slice->img.w = w;
    nine_slice->img.h = h;
    nine_slice->img.region[0] = (unsigned short)subregion.x;
    nine_slice->img.region[1] = (unsigned short)subregion.y;
    nine_slice->img.region[2] = (unsigned short)subregion.w;
    nine_slice->img.region[3] = (unsigned short)subregion.h;
    ud = newuserdata(L, nine_slice, NINE_SLICE_MT, "nine_slice");
    ud->parent_ud = NULL;
    ud->destructor = freenine_slice;
    if(!ptr) MarkNineSliceId(ud);
    return ud;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, 0x4(%rsp)
movl %ecx, %r13d
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl %edx, 0x8(%rsp)
movl %esi, %r12d
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x14030
pushq $0x1
popq %rsi
movq %rbx, %rdi
cmpl $0x2, %eax
jne 0x2234b
callq 0x139f0
movq %rax, %rbp
xorl %r14d, %r14d
jmp 0x22355
callq 0x13060
movq %rax, %r14
xorl %ebp, %ebp
movzwl 0x70(%rsp), %r15d
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x13c00
testq %rbp, %rbp
je 0x22370
movq %rbp, (%rax)
jmp 0x22373
movl %r14d, (%rax)
movw %r13w, 0x18(%rax)
movl 0x4(%rsp), %ecx
movw %cx, 0x1a(%rax)
movl 0xc(%rsp), %ecx
movw %cx, 0x1c(%rax)
movw %r15w, 0x1e(%rax)
movw %r12w, 0x8(%rax)
movl 0x8(%rsp), %ecx
movw %cx, 0xa(%rax)
movaps 0x10(%rsp), %xmm0
unpcklpd 0x20(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
pshufhw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,6,6,7]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
movq %xmm0, 0xc(%rax)
leaq 0x3de92(%rip), %rdx     # 0x60256
leaq 0x3de97(%rip), %rcx     # 0x60262
movq %rbx, %rdi
movq %rax, %rsi
callq 0x140d0
andq $0x0, 0x10(%rax)
leaq 0x1c(%rip), %rcx        # 0x223fe
movq %rcx, 0x8(%rax)
testq %rbp, %rbp
jne 0x223ef
orb $0x2, 0x71(%rax)
addq $0x38, %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/nine_slice.c
// Function: freenine_slice
static int freenine_slice(lua_State *L, ud_t *ud)
    {
    nk_nine_slice_t *nine_slice = (nk_nine_slice_t*)ud->handle;
    freechildren(L, CURSOR_MT, ud);
    if(!freeuserdata(L, ud, "nine_slice")) return 0;
    Free(L, nine_slice);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x3dcaf(%rip), %rsi     # 0x600c2
movq %r15, %rdx
callq 0x121f0
leaq 0x3de40(%rip), %rdx     # 0x60262
movq %r14, %rdi
movq %r15, %rsi
callq 0x13f10
testl %eax, %eax
je 0x2243c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strtoi
NK_API int
nk_strtoi(const char *str, const char **endptr)
{
    int neg = 1;
    const char *p = str;
    int value = 0;

    NK_ASSERT(str);
    if (!str) return 0;

    /* skip whitespace */
    while (*p == ' ') p++;
    if (*p == '-') {
        neg = -1;
        p++;
    }
    while (*p && *p >= '0' && *p <= '9') {
        value = value * 10 + (int) (*p - '0');
        p++;
    }
    if (endptr)
        *endptr = p;
    return neg*value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x22663
movzbl (%rdi), %eax
cmpl $0x20, %eax
jne 0x22657
incq %rdi
jmp 0x2264a
cmpl $0x2d, %eax
jne 0x22693
incq %rdi
pushq $-0x1
jmp 0x22695
movq 0x62986(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x47698(%rip), %rsi     # 0x69d0c
leaq 0x476af(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x1a02, %ecx           # imm = 0x1A02
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x226ba
pushq $0x1
popq %rax
xorl %ebx, %ebx
movb (%rdi), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x226af
imull $0xa, %ebx, %edx
movzbl %cl, %ebx
addl %edx, %ebx
incq %rdi
jmp 0x22698
testq %rsi, %rsi
je 0x226b7
movq %rdi, (%rsi)
imull %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strtod
NK_API double
nk_strtod(const char *str, const char **endptr)
{
    double m;
    double neg = 1.0;
    const char *p = str;
    double value = 0;
    double number = 0;

    NK_ASSERT(str);
    if (!str) return 0;

    /* skip whitespace */
    while (*p == ' ') p++;
    if (*p == '-') {
        neg = -1.0;
        p++;
    }

    while (*p && *p != '.' && *p != 'e') {
        value = value * 10.0 + (double) (*p - '0');
        p++;
    }

    if (*p == '.') {
        p++;
        for(m = 0.1; *p && *p != 'e'; p++ ) {
            value = value + (double) (*p - '0') * m;
            m *= 0.1;
        }
    }
    if (*p == 'e') {
        int i, pow, div;
        p++;
        if (*p == '-') {
            div = nk_true;
            p++;
        } else if (*p == '+') {
            div = nk_false;
            p++;
        } else div = nk_false;

        for (pow = 0; *p; p++)
            pow = pow * 10 + (int) (*p - '0');

        for (m = 1.0, i = 0; i < pow; i++)
            m *= 10.0;

        if (div)
            value /= m;
        else value *= m;
    }
    number = value * neg;
    if (endptr)
        *endptr = p;
    return number;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
jne 0x22702
movq 0x6291f(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x47631(%rip), %rsi     # 0x69d0c
leaq 0x47648(%rip), %rdx     # 0x69d2a
movl $0x1a1c, %ecx           # imm = 0x1A1C
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
xorpd %xmm0, %xmm0
jmp 0x227f1
incq %rdi
movzbl (%rdi), %eax
cmpl $0x20, %eax
je 0x226ff
cmpl $0x2d, %eax
jne 0x2271c
incq %rdi
movsd 0x441e6(%rip), %xmm0    # 0x66900
jmp 0x22724
movsd 0x441e4(%rip), %xmm0    # 0x66908
xorpd %xmm1, %xmm1
movsd 0x441e8(%rip), %xmm2    # 0x66918
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2278e
cmpl $0x65, %eax
je 0x2278e
cmpl $0x2e, %eax
je 0x22758
movsbl %al, %eax
addl $-0x30, %eax
cvtsi2sd %eax, %xmm3
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
incq %rdi
jmp 0x22730
incq %rdi
movsd 0x441ad(%rip), %xmm3    # 0x66910
movapd %xmm3, %xmm4
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2278e
cmpl $0x65, %eax
je 0x2278e
movsbl %al, %eax
addl $-0x30, %eax
cvtsi2sd %eax, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
mulsd %xmm3, %xmm4
incq %rdi
jmp 0x22767
cmpb $0x65, %al
jne 0x227e5
leaq 0x1(%rdi), %rcx
movb 0x1(%rdi), %al
addq $0x2, %rdi
leal -0x2b(%rax), %edx
testb $-0x3, %dl
cmovneq %rcx, %rdi
xorl %ecx, %ecx
movsbl (%rdi), %edx
testl %edx, %edx
je 0x227bd
imull $0xa, %ecx, %ecx
addl %edx, %ecx
addl $-0x30, %ecx
incq %rdi
jmp 0x227a9
xorl %edx, %edx
testl %ecx, %ecx
cmovgl %ecx, %edx
movsd 0x4413c(%rip), %xmm3    # 0x66908
subl $0x1, %edx
jb 0x227d7
mulsd %xmm2, %xmm3
jmp 0x227cc
cmpb $0x2d, %al
je 0x227e1
mulsd %xmm3, %xmm1
jmp 0x227e5
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
testq %rsi, %rsi
je 0x227f1
movq %rdi, (%rsi)
popq %rbx
retq