LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %esi
callq 0x12f30
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x139f0
testl %eax, %eax
je 0x2189d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x218ca
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 0x218d4
orb $0x1, 0x71(%rax)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x13df0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x2, %eax
jne 0x21915
callq 0x13800
movq %rax, %r15
xorl %r12d, %r12d
jmp 0x21920
callq 0x12f30
movq %rax, %r12
xorl %r15d, %r15d
movl $0x18, %esi
movq %rbx, %rdi
callq 0x13a00
testq %r15, %r15
je 0x21937
movq %r15, (%rax)
jmp 0x2193a
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 0x468d8(%rip), %rdx     # 0x68244
leaq 0x468dd(%rip), %rcx     # 0x68250
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x1a(%rip), %rcx        # 0x219a7
movq %rcx, 0x8(%rax)
testq %r15, %r15
jne 0x2199a
orb $-0x80, 0x70(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x46706(%rip), %rsi     # 0x680c2
movq %r15, %rdx
callq 0x121c0
leaq 0x46885(%rip), %rdx     # 0x68250
movq %r14, %rdi
movq %r15, %rsi
callq 0x13d00
testl %eax, %eax
je 0x219e5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x46196(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
cvtss2sd 0x154(%rax), %xmm0
movq %rbx, %rdi
callq 0x13180
xorps %xmm0, %xmm0
cvtss2sd 0x158(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x46148(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
cvtss2sd 0x15c(%rax), %xmm0
movq %rbx, %rdi
callq 0x13180
xorps %xmm0, %xmm0
cvtss2sd 0x160(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x460fa(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
cvtss2sd 0x144(%rax), %xmm0
movq %rbx, %rdi
callq 0x13180
xorps %xmm0, %xmm0
cvtss2sd 0x148(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x460ac(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
cvtss2sd 0x14c(%rax), %xmm0
movq %rbx, %rdi
callq 0x13180
xorps %xmm0, %xmm0
cvtss2sd 0x150(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45ea6(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13410
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x45e54(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
movapd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
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_O1/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 0x45df8(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x13960
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x139c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45d9d(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x129c0
testl %eax, %eax
je 0x22529
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x22546
xorl %ebx, %ebx
xorl %r15d, %r15d
movl (%rsp,%r15,4), %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0x139c0
incq %r15
cmpq $0x1e, %r15
jne 0x2252e
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x45d19(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x13960
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq 0x12b90
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45c98(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
movapd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvtpd2ps %xmm1, %xmm0
movq %r14, %rdi
callq 0x140e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x45c3c(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x22693
movl $0x3, %r15d
leal -0x1(%r15), %esi
movq %rbx, %rdi
callq 0x12f30
movsbl %al, %esi
movq %r14, %rdi
callq 0x13990
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13df0
incl %r15d
testl %eax, %eax
jg 0x2266a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45bd0(%rip), %rcx     # 0x68280
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x12cd0
movq (%r12), %rdx
leaq -0x5(%rdx), %rcx
cmpq $-0x5, %rcx
ja 0x22702
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
callq 0x13ac0
movq %r14, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x2271d
leaq 0xc(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x13010
movq %r15, %rdi
movq %r14, %rsi
callq 0x12040
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x45b46(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x22788
movl $0x3, %r15d
leal -0x1(%r15), %esi
movq %rbx, %rdi
callq 0x12f30
movq %r14, %rdi
movl %eax, %esi
callq 0x137b0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13df0
incl %r15d
testl %eax, %eax
jg 0x22760
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x45ad4(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x138c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x45a3a(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x138a0
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x459eb(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %eax, %esi
callq 0x12e30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4598b(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
movl %r15d, %esi
movl %eax, %edx
callq 0x13a30
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45917(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x6, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movl %eax, %edx
callq 0x124c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x458a5(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13750
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4583d(%rip), %rcx     # 0x68280
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x6, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, (%rsp)
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r12
movq %rbx, %rdi
movl $0x4, %esi
movq %r12, %rcx
callq 0x14040
movl (%r12), %edi
testl %edi, %edi
je 0x22ab4
callq 0x13ac0
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x22b01
movq %rax, %r15
xorps %xmm0, %xmm0
cvtsd2ss (%rsp), %xmm0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
testq %rsi, %rsi
je 0x22ae2
movq %rbx, %rdi
movss %xmm0, (%rsp)
callq 0x130d0
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 0x129a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45764(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13f00
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45704(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13d70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x456c4(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13200
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45517(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14160
testl %eax, %eax
je 0x22daf
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x22dcd
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x134b0
leaq 0x10(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x126b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4549a(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14160
testl %eax, %eax
je 0x22e2c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x22e4a
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x12760
leaq 0x10(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x126b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4541d(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
je 0x22ea9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x22ed0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x13e40
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq 0x18(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12710
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45397(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
je 0x22f2f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x22f56
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x13110
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq 0x18(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12710
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x65085(%rip), %rax     # 0x87ff0
movq %rdi, (%rax)
callq 0x13f70
leaq 0xb0(%rip), %rdi        # 0x2302a
callq 0x67460
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movq %rbx, %rdi
callq 0x12db0
movq %rbx, %rdi
callq 0x13340
movq %rbx, %rdi
callq 0x13510
movq %rbx, %rdi
callq 0x12f50
movq %rbx, %rdi
callq 0x12080
movq %rbx, %rdi
callq 0x13370
movq %rbx, %rdi
callq 0x13590
movq %rbx, %rdi
callq 0x13440
movq %rbx, %rdi
callq 0x12b00
movq %rbx, %rdi
callq 0x12720
movq %rbx, %rdi
callq 0x12e60
movq %rbx, %rdi
callq 0x12580
movq %rbx, %rdi
callq 0x13390
movq %rbx, %rdi
callq 0x13b60
movq %rbx, %rdi
callq 0x12c50
movq %rbx, %rdi
callq 0x12fe0
movq %rbx, %rdi
callq 0x12130
movq %rbx, %rdi
callq 0x12bf0
movq %rbx, %rdi
callq 0x13c50
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45166(%rip), %rcx     # 0x68256
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x120d0
movq %rax, %r14
movq (%r15), %rax
testb $0x2, 0x71(%rax)
jne 0x2311b
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
jmp 0x23126
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x13450
movzwl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0x1a(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0x1e(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movq 0x8(%rsp), %rcx
movl $0x5, %eax
testb $0x4, 0x71(%rcx)
je 0x231aa
movzwl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
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 0x12710
movl $0x8, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %esi
callq 0x12f30
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
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 0x23335
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %esi
callq 0x12f30
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12f30
movq %rax, %r13
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12f30
movq %rax, %rbp
movq %rbx, %rdi
movl $0x8, %esi
callq 0x12f30
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x139f0
testl %eax, %eax
je 0x232df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x23326
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 0x23335
orb $0x4, 0x71(%rax)
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/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, %r15d
movl %ecx, %r13d
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl %edx, 0x8(%rsp)
movl %esi, %r12d
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x2, %eax
jne 0x23386
callq 0x13800
movq %rax, %rbp
xorl %r14d, %r14d
jmp 0x23390
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
movl $0x20, %esi
movq %rbx, %rdi
callq 0x13a00
testq %rbp, %rbp
je 0x233a7
movq %rbp, (%rax)
jmp 0x233aa
movl %r14d, (%rax)
movw %r13w, 0x18(%rax)
movw %r15w, 0x1a(%rax)
movl 0xc(%rsp), %ecx
movw %cx, 0x1c(%rax)
movzwl 0x70(%rsp), %ecx
movw %cx, 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 0x44e5a(%rip), %rdx     # 0x68256
leaq 0x44e5f(%rip), %rcx     # 0x68262
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x1c(%rip), %rcx        # 0x23439
movq %rcx, 0x8(%rax)
testq %rbp, %rbp
jne 0x2342a
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_O1/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 0x44c74(%rip), %rsi     # 0x680c2
movq %r15, %rdx
callq 0x121c0
leaq 0x44e05(%rip), %rdx     # 0x68262
movq %r14, %rdi
movq %r15, %rsi
callq 0x13d00
testl %eax, %eax
je 0x23477
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strlen
NK_API int
nk_strlen(const char *str)
{
    int siz = 0;
    NK_ASSERT(str);
    while (str && *str++ != '\0') siz++;
    return siz;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x23640
cmpb $0x0, (%rdi)
je 0x23670
xorl %ebx, %ebx
cmpb $0x0, 0x1(%rdi,%rbx)
leaq 0x1(%rbx), %rbx
jne 0x23633
jmp 0x23672
movq 0x649a9(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4e73b(%rip), %rsi     # 0x71d8c
leaq 0x4e752(%rip), %rdx     # 0x71daa
xorl %ebx, %ebx
movl $0x19f7, %ecx           # imm = 0x19F7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x23672
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
jne 0x236b8
movq 0x64964(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4e6f6(%rip), %rsi     # 0x71d8c
leaq 0x4e70d(%rip), %rdx     # 0x71daa
xorl %ebx, %ebx
movl $0x1a02, %ecx           # imm = 0x1A02
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x23707
incq %rdi
movzbl (%rdi), %eax
cmpl $0x20, %eax
je 0x236b5
cmpl $0x2d, %eax
jne 0x236cf
incq %rdi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x236d4
movl $0x1, %eax
movb (%rdi), %cl
leal -0x30(%rcx), %edx
xorl %ebx, %ebx
cmpb $0x9, %dl
ja 0x236fc
xorl %ebx, %ebx
leal (%rbx,%rbx,4), %edx
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rdx,2), %ebx
movb 0x1(%rdi), %cl
incq %rdi
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x236e2
testq %rsi, %rsi
je 0x23704
movq %rdi, (%rsi)
imull %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2374f
movq 0x648d2(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4e664(%rip), %rsi     # 0x71d8c
leaq 0x4e67b(%rip), %rdx     # 0x71daa
movl $0x1a1c, %ecx           # imm = 0x1A1C
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
xorpd %xmm0, %xmm0
jmp 0x2385a
incq %rdi
movzbl (%rdi), %eax
cmpl $0x20, %eax
je 0x2374c
cmpl $0x2d, %eax
jne 0x23769
incq %rdi
movsd 0x4b219(%rip), %xmm0    # 0x6e980
jmp 0x23771
movsd 0x4b217(%rip), %xmm0    # 0x6e988
xorpd %xmm1, %xmm1
movsd 0x4b21b(%rip), %xmm2    # 0x6e998
movzbl (%rdi), %eax
testl %eax, %eax
je 0x237e1
cmpl $0x65, %eax
je 0x237e1
cmpl $0x2e, %eax
je 0x237a8
movsbl %al, %eax
addl $-0x30, %eax
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
incq %rdi
jmp 0x2377d
incq %rdi
movsd 0x4b1dd(%rip), %xmm3    # 0x6e990
movapd %xmm3, %xmm4
movzbl (%rdi), %eax
testl %eax, %eax
je 0x237e1
cmpl $0x65, %eax
je 0x237e1
movsbl %al, %eax
addl $-0x30, %eax
xorps %xmm5, %xmm5
cvtsi2sd %eax, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
mulsd %xmm3, %xmm4
incq %rdi
jmp 0x237b7
cmpb $0x65, (%rdi)
jne 0x23826
leaq 0x1(%rdi), %rax
movb 0x1(%rdi), %cl
leaq 0x2(%rdi), %rdx
leal -0x2b(%rcx), %r8d
xorl %r9d, %r9d
testb $-0x3, %r8b
sete %r9b
cmoveq %rdx, %rax
movb 0x1(%r9,%rdi), %dil
xorl %edx, %edx
testb %dil, %dil
je 0x2382b
leal (%rdx,%rdx,4), %edx
movsbl %dil, %edi
leal (%rdi,%rdx,2), %edx
addl $-0x30, %edx
movb 0x1(%rax), %dil
incq %rax
jmp 0x2380b
movq %rdi, %rax
jmp 0x2384e
movsd 0x4b155(%rip), %xmm3    # 0x6e988
testl %edx, %edx
jle 0x2383f
mulsd %xmm2, %xmm3
decl %edx
jne 0x23837
cmpb $0x2d, %cl
je 0x2384a
mulsd %xmm3, %xmm1
jmp 0x2384e
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
testq %rsi, %rsi
je 0x2385a
movq %rax, (%rsi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stricmp
NK_API int
nk_stricmp(const char *s1, const char *s2)
{
    nk_int c1,c2,d;
    do {
        c1 = *s1++;
        c2 = *s2++;
        d = c1 - c2;
        while (d) {
            if (c1 <= 'Z' && c1 >= 'A') {
                d += ('a' - 'A');
                if (!d) break;
            }
            if (c2 <= 'Z' && c2 >= 'A') {
                d -= ('a' - 'A');
                if (!d) break;
            }
            return ((d >= 0) << 1) - 1;
        }
    } while (c1);
    return 0;
}

// Assembly:
xorl %ecx, %ecx
movsbl (%rdi,%rcx), %edx
movsbl (%rsi,%rcx), %r8d
movl %edx, %eax
subl %r8d, %eax
je 0x23898
leal -0x41(%rdx), %r9d
cmpb $0x19, %r9b
ja 0x23889
addl $0x20, %eax
je 0x23898
addb $-0x41, %r8b
cmpb $0x19, %r8b
ja 0x238a2
addl $-0x20, %eax
jne 0x238a2
incq %rcx
testb %dl, %dl
jne 0x2386a
xorl %eax, %eax
retq
sarl $0x1f, %eax
orl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stricmpn
NK_API int
nk_stricmpn(const char *s1, const char *s2, int n)
{
    int c1,c2,d;
    NK_ASSERT(n >= 0);
    do {
        c1 = *s1++;
        c2 = *s2++;
        if (!n--) return 0;

        d = c1 - c2;
        while (d) {
            if (c1 <= 'Z' && c1 >= 'A') {
                d += ('a' - 'A');
                if (!d) break;
            }
            if (c2 <= 'Z' && c2 >= 'A') {
                d -= ('a' - 'A');
                if (!d) break;
            }
            return ((d >= 0) << 1) - 1;
        }
    } while (c1);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jns 0x238e8
movq 0x6472d(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4e4bf(%rip), %rsi     # 0x71d8c
leaq 0x4e4d6(%rip), %rdx     # 0x71daa
movl $0x1a6f, %ecx           # imm = 0x1A6F
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movl %ebp, %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpl %edx, %ecx
je 0x23933
movsbl (%r14,%rdx), %edi
movsbl (%rbx,%rdx), %r8d
movl %edi, %esi
subl %r8d, %esi
je 0x23921
leal -0x41(%rdi), %r9d
cmpb $0x19, %r9b
ja 0x23912
addl $0x20, %esi
je 0x23921
addb $-0x41, %r8b
cmpb $0x19, %r8b
ja 0x2392b
addl $-0x20, %esi
jne 0x2392b
incq %rdx
testb %dil, %dil
jne 0x238ee
jmp 0x23933
sarl $0x1f, %esi
orl $0x1, %esi
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strfilter
NK_API int
nk_strfilter(const char *text, const char *regexp)
{
    /*
    c    matches any literal character c
    .    matches any single character
    ^    matches the beginning of the input string
    $    matches the end of the input string
    *    matches zero or more occurrences of the previous character*/
    if (regexp[0] == '^')
        return nk_str_match_here(regexp+1, text);
    do {    /* must look even if string is empty */
        if (nk_str_match_here(regexp, text))
            return 1;
    } while (*text++ != '\0');
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x5e, (%rsi)
jne 0x2395f
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23989
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23989
testl %eax, %eax
jne 0x2397c
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x2395f
xorl %eax, %eax
jmp 0x23981
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_match_here
NK_INTERN int
nk_str_match_here(const char *regexp, const char *text)
{
    if (regexp[0] == '\0')
        return 1;
    if (regexp[1] == '*')
        return nk_str_match_star(regexp[0], regexp+2, text);
    if (regexp[0] == '$' && regexp[1] == '\0')
        return *text == '\0';
    if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
        return nk_str_match_here(regexp+1, text+1);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x2, %r14
movb -0x2(%r14), %bpl
testb %bpl, %bpl
je 0x239ff
movb -0x1(%r14), %al
cmpb $0x2a, %al
je 0x239f0
movl %ebp, %edx
xorb $0x24, %dl
movb (%rbx), %cl
orb %al, %dl
je 0x23a06
xorl %eax, %eax
testb %cl, %cl
je 0x23a0d
cmpb $0x2e, %bpl
setne %dl
cmpb %cl, %bpl
setne %cl
testb %cl, %dl
jne 0x23a0d
incq %rbx
incq %r14
jmp 0x23997
cmpb $0x2e, %bpl
sete %cl
movb (%rbx), %sil
cmpb %bpl, %sil
sete %dl
xorl %eax, %eax
testb %sil, %sil
je 0x23a0d
incq %rbx
orb %dl, %cl
je 0x23a0d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23989
testl %eax, %eax
je 0x239d2
movl $0x1, %eax
jmp 0x23a0d
xorl %eax, %eax
testb %cl, %cl
sete %al
popq %rbx
popq %r14
popq %rbp
retq