LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_string_float_limit
NK_LIB int
nk_string_float_limit(char *string, int prec)
{
    int dot = 0;
    char *c = string;
    while (*c) {
        if (*c == '.') {
            dot = 1;
            c++;
            continue;
        }
        if (dot == (prec+1)) {
            *c = 0;
            break;
        }
        if (dot > 0) dot++;
        c++;
    }
    return (int)(c - string);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x90105
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x900ca
movl $0x1, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x9009b
movl -0x10(%rsp), %eax
movl -0xc(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x900e3
movq -0x18(%rsp), %rax
movb $0x0, (%rax)
jmp 0x90105
cmpl $0x0, -0x10(%rsp)
jle 0x900f5
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x9009b
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
subq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_behavior
NK_LIB void
nk_property_behavior(nk_flags *ws, const struct nk_input *in,
    struct nk_rect property,  struct nk_rect label, struct nk_rect edit,
    struct nk_rect empty, int *state, struct nk_property_variant *variant,
    float inc_per_pixel)
{
    nk_widget_state_reset(ws);
    if (in && *state == NK_PROPERTY_DEFAULT) {
        if (nk_button_behavior(ws, edit, in, NK_BUTTON_DEFAULT))
            *state = NK_PROPERTY_EDIT;
        else if (nk_input_is_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, label, nk_true))
            *state = NK_PROPERTY_DRAG;
        else if (nk_input_is_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, empty, nk_true))
            *state = NK_PROPERTY_DRAG;
    }
    if (*state == NK_PROPERTY_DRAG) {
        nk_drag_behavior(ws, in, property, variant, inc_per_pixel);
        if (!(*ws & NK_WIDGET_STATE_ACTIVED)) *state = NK_PROPERTY_DEFAULT;
    }
}

// Assembly:
subq $0x68, %rsp
movss 0x70(%rsp), %xmm8
movlpd %xmm0, 0x58(%rsp)
movlpd %xmm1, 0x60(%rsp)
movlpd %xmm2, 0x48(%rsp)
movlpd %xmm3, 0x50(%rsp)
movlpd %xmm4, 0x38(%rsp)
movlpd %xmm5, 0x40(%rsp)
movlpd %xmm6, 0x28(%rsp)
movlpd %xmm7, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x9018b
movq 0x20(%rsp), %rax
movl $0x6, (%rax)
jmp 0x90196
movq 0x20(%rsp), %rax
movl $0x4, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0x90245
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x90245
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
xorl %edx, %edx
callq 0x78060
cmpl $0x0, %eax
je 0x901df
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
jmp 0x90243
movq 0x18(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
xorl %eax, %eax
xorl %esi, %esi
movl $0x1, %edx
callq 0x14c80
cmpl $0x0, %eax
je 0x90210
movq 0x10(%rsp), %rax
movl $0x2, (%rax)
jmp 0x90241
movq 0x18(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
xorl %eax, %eax
xorl %esi, %esi
movl $0x1, %edx
callq 0x14c80
cmpl $0x0, %eax
je 0x9023f
movq 0x10(%rsp), %rax
movl $0x2, (%rax)
jmp 0x90241
jmp 0x90243
jmp 0x90245
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x90291
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movss 0x70(%rsp), %xmm2
movsd 0x58(%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
callq 0x908f0
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x9028f
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
jmp 0x90291
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strrev_ascii
NK_INTERN void
nk_strrev_ascii(char *s)
{
    int len = nk_strlen(s);
    int end = len / 2;
    int i = 0;
    char t;
    for (; i < end; ++i) {
        t = s[i];
        s[i] = s[len - 1 - i];
        s[len -1 - i] = t;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14050
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x90724
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x3(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
subl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movb 0x3(%rsp), %dl
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
subl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x906bf
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_log10
NK_LIB int
nk_log10(double n)
{
    int neg;
    int ret;
    int exp = 0;

    neg = (n < 0) ? 1 : 0;
    ret = (neg) ? (int)-n : (int)n;
    while ((ret / 10) > 0) {
        ret /= 10;
        exp++;
    }
    if (neg) exp = -exp;
    return exp;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movsd -0x8(%rsp), %xmm1
xorps %xmm0, %xmm0
xorl %eax, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
je 0x90787
movsd -0x8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rsp)
jmp 0x90791
cvttsd2si -0x8(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %eax
jle 0x907c7
movl -0x10(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x90799
cmpl $0x0, -0xc(%rsp)
je 0x907d8
xorl %eax, %eax
subl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_pow
NK_LIB double
nk_pow(double x, int n)
{
    /*  check the sign of n */
    double r = 1;
    int plus = n >= 0;
    n = (plus) ? n : -n;
    while (n > 0) {
        if ((n & 1) == 1)
            r *= x;
        n /= 2;
        x *= x;
    }
    return plus ? r : 1.0 / r;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movl %edi, -0xc(%rsp)
movsd 0x1cdc6(%rip), %xmm0    # 0xad5b8
movsd %xmm0, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
je 0x9081a
movl -0xc(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x90824
xorl %eax, %eax
subl -0xc(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jle 0x90875
movl -0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x90851
movsd -0x8(%rsp), %xmm0
mulsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movl -0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rsp)
movsd -0x8(%rsp), %xmm0
mulsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x9082c
cmpl $0x0, -0x1c(%rsp)
je 0x9088a
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x9089e
movsd 0x1cd26(%rip), %xmm0    # 0xad5b8
divsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/objects.c
// Function: moonnuklear_newuserdata
ud_t *newuserdata(lua_State *L, void *handle, const char *mt, const char *tracename)
    {
    ud_t *ud;
    /* we use handle as search key */
    ud = (ud_t*)udata_new(L, sizeof(ud_t), (uint64_t)(uintptr_t)handle, mt);
    memset(ud, 0, sizeof(ud_t));
    ud->handle = handle;
    ud->ref1 = LUA_NOREF;
    ud->ref2 = LUA_NOREF;
    MarkValid(ud);
    if(trace_objects)
        printf("create %s %p (%p)\n", tracename, (void*)ud, handle);
    return ud;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0xa0, %esi
callq 0x14f90
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0xa0, %edx
callq 0x13c40
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0xfffffffe, 0x74(%rax) # imm = 0xFFFFFFFE
movq (%rsp), %rax
movl $0xfffffffe, 0x78(%rax) # imm = 0xFFFFFFFE
movq (%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, 0x70(%rax)
movq 0x331f9(%rip), %rax     # 0xc4fb8
cmpl $0x0, (%rax)
je 0x91de0
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20415(%rip), %rdi     # 0xb21ee
movb $0x0, %al
callq 0x13a20
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/objects.c
// Function: moonnuklear_freeuserdata
int freeuserdata(lua_State *L, ud_t *ud, const char *tracename)
    {
    /* The 'Valid' mark prevents double calls when an object is explicitly destroyed, 
     * and subsequently deleted also by the GC (the ud sticks around until the GC
     * collects it, so we mark it as invalid when the object is explicitly destroyed
     * by the script, or implicitly destroyed because child of a destroyed object). */
    if(!IsValid(ud)) return 0;
    CancelValid(ud);
    unreference(L, ud->ref1);
    unreference(L, ud->ref2);
    if(ud->info) 
        Free(L, ud->info);
    if(trace_objects)
        printf("delete %s %p (%p)\n", tracename, (void*)ud, ud->handle);
    udata_free(L, (uint64_t)(uintptr_t)ud->handle);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x91e20
movl $0x0, 0x24(%rsp)
jmp 0x91f04
jmp 0x91e22
movq 0x10(%rsp), %rax
movl 0x70(%rax), %ecx
andl $-0x2, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x70(%rax)
jmp 0x91e37
movq 0x10(%rsp), %rax
cmpl $-0x2, 0x74(%rax)
je 0x91e65
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x74(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15200
movq 0x10(%rsp), %rax
movl $0xfffffffe, 0x74(%rax) # imm = 0xFFFFFFFE
jmp 0x91e67
jmp 0x91e69
movq 0x10(%rsp), %rax
cmpl $-0x2, 0x78(%rax)
je 0x91e97
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x78(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15200
movq 0x10(%rsp), %rax
movl $0xfffffffe, 0x78(%rax) # imm = 0xFFFFFFFE
jmp 0x91e99
movq 0x10(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x91ebe
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rsi
callq 0x14230
movq 0x330f3(%rip), %rax     # 0xc4fb8
cmpl $0x0, (%rax)
je 0x91eea
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
leaq 0x2031e(%rip), %rdi     # 0xb2201
movb $0x0, %al
callq 0x13a20
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x151e0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/objects.c
// Function: freeifchild
static int freeifchild(lua_State *L, const void *mem, const char *mt, const void *parent_ud)
/* callback for udata_scan */
    {
    ud_t *ud = (ud_t*)mem;
    (void)mt;
    if(IsValid(ud) && (ud->parent_ud == parent_ud))
        ud->destructor(L, ud);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x70(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x91fa2
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x91fa2
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/objects.c
// Function: moonnuklear_testxxx
void *testxxx(lua_State *L, int arg, ud_t **udp, const char *mt)
    {
    ud_t *ud = (ud_t*)udata_test(L, arg, mt);
    if(ud && IsValid(ud)) { if(udp) *udp=ud; return ud->handle; }
    if(udp) *udp = NULL;
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x149d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x920cb
movq 0x8(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x920cb
cmpq $0x0, 0x18(%rsp)
je 0x920bc
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x920e8
cmpq $0x0, 0x18(%rsp)
je 0x920df
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/objects.c
// Function: moonnuklear_checkxxx
void *checkxxx(lua_State *L, int arg, ud_t **udp, const char *mt)
    {
    ud_t *ud = (ud_t*)udata_test(L, arg, mt);
    if(ud && IsValid(ud)) 
        { if(udp) *udp = ud; return ud->handle; }
    lua_pushfstring(L, "not a %s", mt);
    luaL_argerror(L, arg, lua_tostring(L, -1));
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x149d0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x9216b
movq 0x18(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x9216b
cmpq $0x0, 0x28(%rsp)
je 0x9215c
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x921c2
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x200a2(%rip), %rsi     # 0xb221e
movb $0x0, %al
callq 0x13ec0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x134c0
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/panel.c
// Function: Get_offset
static int Get_offset(lua_State *L)
    {
    nk_panel_t* panel = checkpanel(L, 1, NULL);
    lua_pushinteger(L, *panel->offset_x);
    lua_pushinteger(L, *panel->offset_y);
    return 2;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x14e0f(%rip), %rcx     # 0xa73dd
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x13c50
movl $0x2, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/panel.c
// Function: Get_at
static int Get_at(lua_State *L)
    {
    nk_panel_t* panel = checkpanel(L, 1, NULL);
    lua_pushnumber(L, panel->at_x);
    lua_pushnumber(L, panel->at_y);
    return 2;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x14daf(%rip), %rcx     # 0xa73dd
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x28(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x2c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movl $0x2, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/panel.c
// Function: moonnuklear_newpanel
static int newpanel(lua_State *L, ud_t *context_ud, nk_panel_t *panel)
    {
    ud_t *ud = userdata(panel);
    if(ud) /* already in */
        return pushpanel(L, panel);
    ud = newuserdata(L, panel, PANEL_MT, "panel");
    ud->parent_ud = context_ud;
    ud->context = (nk_context_t*)context_ud->context;
    ud->destructor = freepanel;
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14450
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x928fd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14e50
movl %eax, 0x24(%rsp)
jmp 0x92953
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x14acf(%rip), %rdx     # 0xa73dd
leaq 0x14ad4(%rip), %rcx     # 0xa73e9
callq 0x15130
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
leaq 0x19(%rip), %rcx        # 0x92960
movq %rcx, 0x8(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_echeckvec2
int echeckvec2(lua_State *L, int arg, nk_vec2_t *p)
    {
    int err;
    ECHECK_PREAMBLE;
    GetFloati(x, 1);
    GetFloati(y, 2);
    return ERR_SUCCESS;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x13c40
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0x92a14
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0x1, 0x34(%rsp)
jmp 0x92bc4
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0x92a53
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0xfffffffc, 0x34(%rsp) # imm = 0xFFFFFFFC
jmp 0x92bc4
jmp 0x92a55
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13d30
cmpl $0x0, %eax
je 0x92aa6
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13ee0
cvtsd2ss %xmm0, %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x92ad2
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x92ac8
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x92ad0
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x92ad2
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x92b06
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1f2c0(%rip), %rsi     # 0xb1db8
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x92bc4
jmp 0x92b08
jmp 0x92b0a
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x2, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13d30
cmpl $0x0, %eax
je 0x92b5c
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13ee0
cvtsd2ss %xmm0, %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, 0x4(%rax)
jmp 0x92b89
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x92b7f
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x92b87
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x92b89
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x92bba
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1e8f6(%rip), %rsi     # 0xb14a5
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x92bc4
jmp 0x92bbc
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushvec2
int pushvec2(lua_State *L, nk_vec2_t *p)
    {
    lua_newtable(L);
    SetFloati(x, 1);
    SetFloati(y, 2);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x13f00
jmp 0x92c79
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x13f00
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_echeckvec2i
int echeckvec2i(lua_State *L, int arg, nk_vec2i_t *p)
    {
    int err;
    ECHECK_PREAMBLE;
    GetIntegeri(x, 1);
    GetIntegeri(y, 2);
    return ERR_SUCCESS;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x13c40
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0x92d14
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0x1, 0x34(%rsp)
jmp 0x92ebc
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0x92d53
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0xfffffffc, 0x34(%rsp) # imm = 0xFFFFFFFC
jmp 0x92ebc
jmp 0x92d55
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15470
cmpl $0x0, %eax
je 0x92da4
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13670
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, (%rax)
jmp 0x92dce
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x92dc4
movq 0x18(%rsp), %rax
movw $0x0, (%rax)
jmp 0x92dcc
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x92dce
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x92e02
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1efc4(%rip), %rsi     # 0xb1db8
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x92ebc
jmp 0x92e04
jmp 0x92e06
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x2, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15470
cmpl $0x0, %eax
je 0x92e56
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13670
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x2(%rax)
jmp 0x92e81
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x92e77
movq 0x18(%rsp), %rax
movw $0x0, 0x2(%rax)
jmp 0x92e7f
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x92e81
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x92eb2
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1e5fe(%rip), %rsi     # 0xb14a5
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x92ebc
jmp 0x92eb4
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushvec2i
int pushvec2i(lua_State *L, nk_vec2i_t *p)
    {
    lua_newtable(L);
    SetIntegeri(x, 1);
    SetIntegeri(y, 2);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movswq (%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x13f00
jmp 0x92f15
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movswq 0x2(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x13f00
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_echecscrollk
int echeckscroll(lua_State *L, int arg, nk_scroll_t *p)
    {
    int err;
    ECHECK_PREAMBLE;
    GetIntegeri(x, 1);
    GetIntegeri(y, 2);
    return ERR_SUCCESS;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x13c40
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0x92fb4
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0x1, 0x34(%rsp)
jmp 0x9315a
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0x92ff3
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0xfffffffc, 0x34(%rsp) # imm = 0xFFFFFFFC
jmp 0x9315a
jmp 0x92ff5
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15470
cmpl $0x0, %eax
je 0x93042
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13670
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x9306d
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x93063
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
jmp 0x9306b
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x9306d
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x930a1
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1ed25(%rip), %rsi     # 0xb1db8
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x9315a
jmp 0x930a3
jmp 0x930a5
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x2, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15470
cmpl $0x0, %eax
je 0x930f3
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13670
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x9311f
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x93115
movq 0x18(%rsp), %rax
movl $0x0, 0x4(%rax)
jmp 0x9311d
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x9311f
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x93150
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1e360(%rip), %rsi     # 0xb14a5
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x9315a
jmp 0x93152
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pusscrollh
int pushscroll(lua_State *L, nk_scroll_t *p)
    {
    lua_newtable(L);
    SetIntegeri(x, 1);
    SetIntegeri(y, 2);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x13f00
jmp 0x931b5
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x13f00
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushrect
int pushrect(lua_State *L, nk_rect_t *p)
    {
    lua_newtable(L);
    SetFloati(x, 1);
    SetFloati(y, 2);
    SetFloati(w, 3);
    SetFloati(h, 4);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x13f00
jmp 0x935c9
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x13f00
jmp 0x935f7
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x13f00
jmp 0x93625
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x4, %edx
callq 0x13f00
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_echeckcolor
int echeckcolor(lua_State *L, int arg, nk_color_t *p)
    {
    nk_colorf_t color; 
    int err = echeckcolorf(L, arg, &color);
    if(err) return err;
    *p = nk_rgba_cf(color);
    return ERR_SUCCESS;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
leaq 0x18(%rsp), %rdx
callq 0x14370
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x9369a
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x936ce
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x149f0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushcolorf
int pushcolorf(lua_State *L, nk_colorf_t *p)
    {
    lua_newtable(L);
    SetFloati(r, 1);
    SetFloati(g, 2);
    SetFloati(b, 3);
    SetFloati(a, 4);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x13f00
jmp 0x93af9
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x13f00
jmp 0x93b27
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x13f00
jmp 0x93b55
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x4, %edx
callq 0x13f00
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushmemorystatus
int pushmemorystatus(lua_State *L, nk_memory_status_t *p)
    {
    lua_newtable(L);
//  SetEnum(type, "type", pushbufferallocationtype);
    SetInteger(size, "size");
    SetInteger(allocated, "allocated");
    SetInteger(needed, "needed");
    SetInteger(calls, "calls");
    lua_pushlightuserdata(L, p->memory);
    lua_setfield(L, -2, "ptr");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1be0b(%rip), %rdx     # 0xb189b
callq 0x13b80
jmp 0x95a97
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1ca36(%rip), %rdx     # 0xb24f1
callq 0x13b80
jmp 0x95ac2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1ca15(%rip), %rdx     # 0xb24fb
callq 0x13b80
jmp 0x95aed
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1c9f1(%rip), %rdx     # 0xb2502
callq 0x13b80
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x14600
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1188a(%rip), %rdx     # 0xa73c3
callq 0x13b80
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_echeckdrawvertexlayoutelement
int echeckdrawvertexlayoutelement(lua_State *L, int arg, nk_draw_vertex_layout_element_t *p)
    {
    int err;
    ECHECK_PREAMBLE;
    GetEnumi(attribute, 1, testdrawvertexlayoutattribute);
    GetEnumi(format, 2, testdrawvertexlayoutformat);
    GetIntegeriOpt(offset, 3, 0);
    return ERR_SUCCESS;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x13c40
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0x95bb4
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0x1, 0x34(%rsp)
jmp 0x95d88
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0x95bf3
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x15240
movl $0xfffffffc, 0x34(%rsp) # imm = 0xFFFFFFFC
jmp 0x95d88
jmp 0x95bf5
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x13a30
movq 0x28(%rsp), %rdi
movl $0x19, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %rcx
callq 0x145d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x95c5e
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1c168(%rip), %rsi     # 0xb1db8
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x95d88
jmp 0x95c60
jmp 0x95c62
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x2, %edx
callq 0x13a30
movq 0x28(%rsp), %rdi
movl $0x1a, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %rcx
callq 0x145d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x95ccc
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1b7e7(%rip), %rsi     # 0xb14a5
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x95d88
jmp 0x95cce
jmp 0x95cd0
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x3, %edx
callq 0x13a30
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15470
cmpl $0x0, %eax
je 0x95d20
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13670
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x95d4d
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15090
cmpl $0x0, %eax
jg 0x95d43
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x95d4b
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x95d4d
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x14(%rsp)
je 0x95d7e
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x1c595(%rip), %rsi     # 0xb2308
callq 0x92bd0
movl %eax, 0x34(%rsp)
jmp 0x95d88
jmp 0x95d80
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushstyleitem
int pushstyleitem(lua_State *L, nk_style_item_t *p)
    {
    if(p->type == NK_STYLE_ITEM_IMAGE)
        pushimage(L, &p->data.image);
    else if(p->type == NK_STYLE_ITEM_NINE_SLICE)
        pushnine_slice(L, &p->data.image);
    else if(p->type == NK_STYLE_ITEM_COLOR)
        {
        if(p->data.color.r == 0 && p->data.color.b == 0 
                && p->data.color.g == 0 && p->data.color.a == 0)
            lua_pushstring(L, "hide");
        else
            pushcolor(L, &p->data.color);
        }
    else
        return unexpected(L);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
cmpl $0x1, (%rax)
jne 0x95dcd
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x8, %rsi
callq 0x14e50
jmp 0x95e7a
movq (%rsp), %rax
cmpl $0x2, (%rax)
jne 0x95ded
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x8, %rsi
callq 0x14e50
jmp 0x95e78
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0x95e51
movq (%rsp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x95e3d
movq (%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x95e3d
movq (%rsp), %rax
movzbl 0x9(%rax), %eax
cmpl $0x0, %eax
jne 0x95e3d
movq (%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jne 0x95e3d
movq 0x8(%rsp), %rdi
leaq 0x1701f(%rip), %rsi     # 0xace55
callq 0x15240
jmp 0x95e4f
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x8, %rsi
callq 0x14a50
jmp 0x95e76
movq 0x8(%rsp), %rdi
leaq 0x112c2(%rip), %rsi     # 0xa711f
leaq 0x1c6a4(%rip), %rdx     # 0xb2508
movl $0x1aa, %ecx            # imm = 0x1AA
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x14(%rsp)
jmp 0x95e82
jmp 0x95e78
jmp 0x95e7a
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_checkstyleitem
nk_style_item_t checkstyleitem(lua_State *L, int arg)
    {
    nk_color_t color;
    nk_image_t *image;
    nk_nine_slice_t *nine_slice;
    if(lua_isstring(L, arg))
        {
        if(strcmp(lua_tostring(L, arg), "hide") == 0)
            return nk_style_item_hide();
        }
    else if((image = testimage(L, arg, NULL)) != NULL)
        return nk_style_item_image(*image);
    else if((nine_slice = testnine_slice(L, arg, NULL)) != NULL)
        return nk_style_item_nine_slice(*nine_slice);
    else
        {
        if(echeckcolor(L, arg, &color)==ERR_SUCCESS)
            return nk_style_item_color(color);
        }
    argerrorc(L, arg, ERR_VALUE);
    return nk_style_item_hide(); /* not reached */
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
callq 0x154b0
cmpl $0x0, %eax
je 0x95ef4
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq %rax, %rdi
leaq 0x16f7f(%rip), %rsi     # 0xace55
callq 0x13fc0
cmpl $0x0, %eax
jne 0x95eef
movq 0x38(%rsp), %rdi
callq 0x14e30
jmp 0x96001
jmp 0x95fca
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x1133c(%rip), %rcx     # 0xa7244
callq 0x15450
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x95f45
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x13530
jmp 0x96001
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x112fd(%rip), %rcx     # 0xa7256
callq 0x15450
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
je 0x95f9c
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x14f40
jmp 0x96001
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
leaq 0x58(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
jne 0x95fc4
movq 0x38(%rsp), %rdi
movl 0x58(%rsp), %esi
callq 0x139f0
jmp 0x96001
jmp 0x95fc6
jmp 0x95fc8
jmp 0x95fca
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %esi
movq %rax, %rdx
callq 0x134c0
movq 0x38(%rsp), %rdi
callq 0x14e30
movq 0x40(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_testpluginfilter
nk_plugin_filter testpluginfilter(lua_State *L, int arg)
    {
    int err;
    int what = testfilter(L, arg, &err);
    if(err == ERR_NOTPRESENT)
        return nk_filter_default;
    if(err > 0)
        { argerrorc(L, arg, err); return NULL; }
    switch(what)
        {
        case MOONNUKLEAR_FILTER_DEFAULT: return nk_filter_default;
        case MOONNUKLEAR_FILTER_ASCII: return nk_filter_ascii;
        case MOONNUKLEAR_FILTER_FLOAT: return nk_filter_float;
        case MOONNUKLEAR_FILTER_DECIMAL: return nk_filter_decimal;
        case MOONNUKLEAR_FILTER_HEX: return nk_filter_hex;
        case MOONNUKLEAR_FILTER_OCT: return nk_filter_oct;
        case MOONNUKLEAR_FILTER_BINARY: return nk_filter_binary;
        default: unexpected(L); break;
        }
    return NULL;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
movl $0x66, %esi
leaq 0x20(%rsp), %rcx
callq 0x145d0
movl %eax, 0x1c(%rsp)
cmpl $0x1, 0x20(%rsp)
jne 0x962b1
movq 0x2ed19(%rip), %rax     # 0xc4fc0
movq %rax, 0x30(%rsp)
jmp 0x963a3
cmpl $0x0, 0x20(%rsp)
jle 0x962f2
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x20(%rsp), %edi
callq 0x14d10
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movq %rax, %rdx
callq 0x134c0
movq $0x0, 0x30(%rsp)
jmp 0x963a3
movl 0x1c(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x6, %eax
ja 0x9637b
movq 0x8(%rsp), %rax
leaq 0x1bf94(%rip), %rcx     # 0xb22a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x2eca0(%rip), %rax     # 0xc4fc0
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x2ecb2(%rip), %rax     # 0xc4fe0
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x2ec9c(%rip), %rax     # 0xc4fd8
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x2ec46(%rip), %rax     # 0xc4f90
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x2ec48(%rip), %rax     # 0xc4fa0
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x2ec42(%rip), %rax     # 0xc4fa8
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x2ec54(%rip), %rax     # 0xc4fc8
movq %rax, 0x30(%rsp)
jmp 0x963a3
movq 0x28(%rsp), %rdi
leaq 0x10d98(%rip), %rsi     # 0xa711f
leaq 0x1c17a(%rip), %rdx     # 0xb2508
movl $0x1e8, %ecx            # imm = 0x1E8
movb $0x0, %al
callq 0x14bf0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: command_scissor
static int command_scissor(lua_State *L, nk_command_t *pp)
    {
    nk_command_scissor_t *p = (nk_command_scissor_t*)pp;
    SetInteger(x, "x");
    SetInteger(y, "y");
    SetInteger(w, "w");
    SetInteger(h, "h");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movswq 0x10(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1b216(%rip), %rdx     # 0xb1d81
callq 0x13b80
jmp 0x96b72
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movswq 0x12(%rax), %rsi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1ac7a(%rip), %rdx     # 0xb1810
callq 0x13b80
jmp 0x96b9d
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movzwl 0x14(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x106d4(%rip), %rdx     # 0xa7296
callq 0x13b80
jmp 0x96bc9
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movzwl 0x16(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1a7e2(%rip), %rdx     # 0xb13d0
callq 0x13b80
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: command_line
static int command_line(lua_State *L, nk_command_t *pp)
    {
    nk_command_line_t *p = (nk_command_line_t*)pp;
    SetInteger(line_thickness, "line_thickness");
    SetVec2i(begin, "start");
    SetVec2i(end, "stop");
    SetColor(color, "color");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movzwl 0x10(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1b96b(%rip), %rdx     # 0xb25a7
callq 0x13b80
jmp 0x96c43
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
addq $0x12, %rsi
callq 0x14110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x10962(%rip), %rdx     # 0xa75c8
callq 0x13b80
jmp 0x96c6d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
addq $0x16, %rsi
callq 0x14110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1b926(%rip), %rdx     # 0xb25b6
callq 0x13b80
jmp 0x96c97
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
addq $0x1a, %rsi
callq 0x14a50
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x10f70(%rip), %rdx     # 0xa7c2a
callq 0x13b80
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/structs.c
// Function: command_curve
static int command_curve(lua_State *L, nk_command_t *pp)
    {
    nk_command_curve_t *p = (nk_command_curve_t*)pp;
    SetInteger(line_thickness, "line_thickness");
    SetVec2i(begin, "start");
    SetVec2i(end, "stop");
    SetVec2iArray(ctrl, "ctrl", 2);
    SetColor(color, "color");
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1b899(%rip), %rdx     # 0xb25a7
callq 0x13b80
jmp 0x96d15
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x12, %rsi
callq 0x14110
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1088f(%rip), %rdx     # 0xa75c8
callq 0x13b80
jmp 0x96d40
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x16, %rsi
callq 0x14110
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1b852(%rip), %rdx     # 0xb25b6
callq 0x13b80
jmp 0x96d6b
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x96dcd
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1a, %rsi
movslq 0xc(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x14110
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x13f00
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x96d81
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x106ec(%rip), %rdx     # 0xa74ca
callq 0x13b80
jmp 0x96de5
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x22, %rsi
callq 0x14a50
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x10e21(%rip), %rdx     # 0xa7c2a
callq 0x13b80
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)