LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq $0x0, (%rdx)
callq 0x13df0
testl %eax, %eax
jle 0x5a149
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x5a155
movl $0x1, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12c20
testl %eax, %eax
je 0x5a17c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12da0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0x2, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12c20
testl %eax, %eax
je 0x5a1b9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12da0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %ebp, %ebp
jmp 0x5a16f
movl $0x1, %ebp
movl $0x1, %edi
jmp 0x5a15f
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x13ac0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13f90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13df0
testl %eax, %eax
jle 0x5a206
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
leaq 0x16deb(%rip), %rsi     # 0x70f9b
leaq 0x173c3(%rip), %rdx     # 0x7157a
jmp 0x5a1f4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13df0
testl %eax, %eax
jle 0x5a20e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
leaq 0x16dae(%rip), %rsi     # 0x70f9b
leaq 0x16cad(%rip), %rdx     # 0x70ea1
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x12d80
jmp 0x5a16f
xorps %xmm0, %xmm0
jmp 0x5a0e8
xorps %xmm0, %xmm0
jmp 0x5a132
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl $0x0, (%rdx)
callq 0x13df0
testl %eax, %eax
jle 0x5a33e
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x5a34a
movl $0x1, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14170
testl %eax, %eax
je 0x5a371
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x125f0
movw %ax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0x2, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14170
testl %eax, %eax
je 0x5a3ae
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x125f0
movw %ax, 0x2(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %ebp, %ebp
jmp 0x5a364
movl $0x1, %ebp
movl $0x1, %edi
jmp 0x5a354
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x13ac0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13f90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13df0
testl %eax, %eax
jle 0x5a3fb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
leaq 0x16bf6(%rip), %rsi     # 0x70f9b
leaq 0x171ce(%rip), %rdx     # 0x7157a
jmp 0x5a3e9
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13df0
testl %eax, %eax
jle 0x5a402
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
leaq 0x16bb9(%rip), %rsi     # 0x70f9b
leaq 0x16ab8(%rip), %rdx     # 0x70ea1
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x12d80
jmp 0x5a364
xorl %eax, %eax
jmp 0x5a2e3
xorl %eax, %eax
jmp 0x5a328
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq $0x0, (%rdx)
callq 0x13df0
testl %eax, %eax
jle 0x5a52b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x5a537
movl $0x1, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14170
testl %eax, %eax
je 0x5a55e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x125f0
movl %eax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0x2, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14170
testl %eax, %eax
je 0x5a59b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x125f0
movl %eax, 0x4(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
xorl %ebp, %ebp
jmp 0x5a551
movl $0x1, %ebp
movl $0x1, %edi
jmp 0x5a541
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x13ac0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13f90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13df0
testl %eax, %eax
jle 0x5a5e8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
leaq 0x16a09(%rip), %rsi     # 0x70f9b
leaq 0x16fe1(%rip), %rdx     # 0x7157a
jmp 0x5a5d6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13df0
testl %eax, %eax
jle 0x5a5ef
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
leaq 0x169cc(%rip), %rsi     # 0x70f9b
leaq 0x168cb(%rip), %rdx     # 0x70ea1
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x12d80
jmp 0x5a551
xorl %eax, %eax
jmp 0x5a4d2
xorl %eax, %eax
jmp 0x5a516
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
leaq 0x14b70(%rip), %rdx     # 0x71113
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
leaq 0x16042(%rip), %rdx     # 0x72605
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
leaq 0x1602c(%rip), %rdx     # 0x7260f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
leaq 0x16013(%rip), %rdx     # 0x72616
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x13450
leaq 0xada1(%rip), %rdx      # 0x673c3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
callq 0x13df0
testl %eax, %eax
jle 0x5c6cf
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x5c6db
movl $0x1, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x19, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r12, %rcx
callq 0x13420
movl %eax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl (%r12), %edi
testl %edi, %edi
je 0x5c6f7
callq 0x13ac0
leaq 0x148d8(%rip), %rsi     # 0x70f9b
leaq 0x14eb0(%rip), %rdx     # 0x7157a
jmp 0x5c752
movl $0x1, %ebp
movl $0x1, %edi
jmp 0x5c6e5
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x13ac0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13f90
jmp 0x5c75f
movl $0x2, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x1a, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r12, %rcx
callq 0x13420
movl %eax, 0x4(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl (%r12), %edi
testl %edi, %edi
je 0x5c76e
callq 0x13ac0
leaq 0x14850(%rip), %rsi     # 0x70f9b
leaq 0x1474f(%rip), %rdx     # 0x70ea1
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x12d80
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12950
movl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x5c7ac
xorl %edx, %edx
callq 0x125f0
movq %rax, 0x8(%r14)
jmp 0x5c7c7
callq 0x13df0
testl %eax, %eax
jle 0x5c7bf
movl $0xfffffffe, 0xc(%rsp)  # imm = 0xFFFFFFFE
jmp 0x5c7c7
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0x5c806
callq 0x13ac0
leaq 0x147b3(%rip), %rsi     # 0x70f9b
leaq 0x15c2d(%rip), %rdx     # 0x7241c
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x12d80
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x5c75f
xorl %ebp, %ebp
jmp 0x5c75f
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x5c833
cmpl $0x2, %eax
je 0x5c825
cmpl $0x1, %eax
jne 0x5c86f
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x13c10
jmp 0x5c864
cmpb $0x0, 0x8(%rsi)
jne 0x5c84b
cmpb $0x0, 0xa(%rsi)
jne 0x5c84b
cmpb $0x0, 0x9(%rsi)
jne 0x5c84b
cmpb $0x0, 0xb(%rsi)
je 0x5c891
movl 0x8(%rsi), %edi
callq 0x13d20
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movq %rsp, %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x13db0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xa8a9(%rip), %rsi      # 0x6711f
leaq 0x15d9f(%rip), %rdx     # 0x7261c
movq %rbx, %rdi
movl $0x1aa, %ecx            # imm = 0x1AA
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x139b0
leaq 0x105bd(%rip), %rsi     # 0x6ce55
movq %rbx, %rdi
callq 0x13f90
jmp 0x5c864
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x141b0
testl %eax, %eax
je 0x5c900
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
leaq 0x10582(%rip), %rsi     # 0x6ce55
movq %rax, %rdi
callq 0x12e90
testl %eax, %eax
je 0x5c8f6
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movq %rbx, %rdi
callq 0x13be0
jmp 0x5c962
leaq 0xa93d(%rip), %rcx      # 0x67244
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x5c932
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x124d0
jmp 0x5c962
leaq 0xa91d(%rip), %rcx      # 0x67256
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x5c96e
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x13cf0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x13210
testl %eax, %eax
jne 0x5c8df
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x137c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x12910
jmp 0x5c962
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushfontglyph
int pushfontglyph(lua_State *L, const nk_font_glyph_t *p)
    {
    lua_newtable(L);
    SetInteger(codepoint, "codepoint");
    SetFloat(xadvance, "xadvance");
    SetFloat(x0, "x0");
    SetFloat(y0, "y0");
    SetFloat(x1, "x1");
    SetFloat(y1, "y1");
    SetFloat(w, "w");
    SetFloat(h, "h");
    SetFloat(u0, "u0");
    SetFloat(v0, "v0");
    SetFloat(u1, "u1");
    SetFloat(v1, "v1");
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x12b60
leaq 0x15c5f(%rip), %rdx     # 0x72626
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15c47(%rip), %rdx     # 0x72630
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x14696(%rip), %rdx     # 0x710a4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15c06(%rip), %rdx     # 0x72639
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x10(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15be4(%rip), %rdx     # 0x7263c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x14(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x14a46(%rip), %rdx     # 0x714c3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0xa7f4(%rip), %rdx      # 0x67296
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x14305(%rip), %rdx     # 0x70dcc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x20(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15b53(%rip), %rdx     # 0x7263f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x24(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15b31(%rip), %rdx     # 0x72642
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x28(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15b0f(%rip), %rdx     # 0x72645
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
xorps %xmm0, %xmm0
cvtss2sd 0x2c(%r14), %xmm0
movq %rbx, %rdi
callq 0x13180
leaq 0x15aed(%rip), %rdx     # 0x72648
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x66, %esi
movl %ebp, %edx
movq %r14, %rcx
callq 0x13420
movl (%r14), %edi
cmpl $0x1, %edi
jne 0x5cba7
movq 0x2a433(%rip), %r14     # 0x86fd8
jmp 0x5cbf6
jl 0x5cbc0
callq 0x13ac0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
xorl %r14d, %r14d
jmp 0x5cbf6
decl %eax
cmpl $0x7, %eax
jae 0x5cbd6
movl %eax, %eax
leaq 0x29840(%rip), %rcx     # 0x86410
movq (%rcx,%rax,8), %r14
jmp 0x5cbf6
leaq 0xa542(%rip), %rsi      # 0x6711f
leaq 0x15a38(%rip), %rdx     # 0x7261c
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1e8, %ecx            # imm = 0x1E8
xorl %eax, %eax
callq 0x139b0
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/structs.c
// Function: moonnuklear_pushdrawcommand
int pushdrawcommand(lua_State *L, nk_draw_command_t *p)
    {
    lua_newtable(L);
    SetInteger(elem_count, "elem_count");
    SetRect(clip_rect, "clip_rect");
    //pushhandle(L, &p->texture); lua_setfield(L, -2, "texture");
    lua_pushinteger(L, p->texture.id); lua_setfield(L, -2, "texture_id");
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x12b60
leaq 0x14c54(%rip), %rdx     # 0x72695
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x12710
leaq 0x14c3f(%rip), %rdx     # 0x726a0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movslq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
leaq 0x14c29(%rip), %rdx     # 0x726aa
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12a90
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_from_table
static int Style_from_table(lua_State *L)
    {
    nk_color_t table[NK_COLOR_COUNT];
    nk_color_t defcolor = nk_rgba(0, 0, 0, 255);
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(!lua_isnoneornil(L, 3) && echeckcolor(L, 3, &defcolor))
        return argerror(L, 3);
    if(echeckcolortable(L, 2, table, defcolor))
        return argerror(L, 2);
    nk_style_from_table(context, table);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movl $0xff, %ecx
callq 0x134c0
movl %eax, %ebp
movl %eax, 0xc(%rsp)
leaq 0x978b(%rip), %rcx      # 0x67280
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13df0
testl %eax, %eax
jle 0x5db4b
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x5db47
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x5db7a
movl 0xc(%rsp), %ebp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
movl %ebp, %ecx
callq 0x14180
testl %eax, %eax
je 0x5db84
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 0x5db93
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x12a10
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_load_cursor
static int Style_load_cursor(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_style_cursor style = checkstylecursor(L, 2);
    const nk_cursor_t* cursor = checkcursor(L, 3, NULL);
    nk_style_load_cursor(context, style, cursor);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x96d3(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0x94eb(%rip), %rcx      # 0x670c2
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x120d0
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x13f10
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_load_all_cursors
static int Style_load_all_cursors(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_atlas_t *atlas = checkatlas(L, 2, NULL);
    nk_style_load_all_cursors(context, atlas->cursors);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9678(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x93e2(%rip), %rcx      # 0x67000
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x120d0
leaq 0x48(%rax), %rsi
movq %r14, %rdi
callq 0x129b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_font
static int Style_set_font(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const nk_user_font_t *user_font = checkfont(L, 2, NULL);
    nk_style_set_font(context, user_font);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x962f(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x944a(%rip), %rcx      # 0x670b1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x120d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x12a20
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_cursor
static int Style_set_cursor(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_style_cursor stylecursor = checkstylecursor(L, 2);
    lua_pushboolean(L, nk_style_set_cursor(context, stylecursor));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x95e7(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x12550
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_push_font
static int Style_push_font(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const nk_user_font_t *user_font = checkfont(L, 2, NULL);
    lua_pushboolean(L, nk_style_push_font(context, user_font));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9557(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x9372(%rip), %rcx      # 0x670b1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x120d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x12b20
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_push_float
static int Style_push_float(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    float value = luaL_checknumber(L, 3);
    float *address = address_float(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, nk_style_push_float(context, address, value));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x94ce(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x5e99f
testq %rax, %rax
je 0x5de23
xorps %xmm0, %xmm0
cvtsd2ss 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rax, %rsi
callq 0x13d80
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_float
static int Style_set_float(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    float value = luaL_checknumber(L, 3);
    float *address = address_float(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x93f9(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x5e99f
testq %rax, %rax
je 0x5dee4
xorps %xmm0, %xmm0
cvtsd2ss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_float
static int Style_get_float(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    float *address = address_float(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushnumber(L, *address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x936c(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x5e99f
testq %rax, %rax
je 0x5df5d
cvtss2sd (%rax), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_push_vec2
static int Style_push_vec2(lua_State *L)
    {
    nk_vec2_t value;
    nk_vec2_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    if(echeckvec2(L, 3, &value)) return argerror(L, 3);
    address = address_vec2(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, nk_style_push_vec2(context, address, value));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x92f0(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x5dfea
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x5e019
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f5c0
testq %rax, %rax
je 0x5e022
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %rax, %rsi
callq 0x12190
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x5dfe0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_vec2
static int Style_set_vec2(lua_State *L)
    {
    nk_vec2_t value;
    nk_vec2_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    if(echeckvec2(L, 3, &value)) return argerror(L, 3);
    address = address_vec2(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9208(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x5e0d2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x5e0eb
movq %r14, %rdi
movl %ebp, %esi
callq 0x5f5c0
testq %rax, %rax
je 0x5e0f4
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x5e0c8
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_vec2
static int Style_get_vec2(lua_State *L)
    {
    nk_vec2_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    address = address_vec2(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushvec2(L, address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x916a(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x5f5c0
testq %rax, %rax
je 0x5e15e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x126b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_push_flags
static int Style_push_flags(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_flags value = checkflags(L, 3);
    nk_flags *address = address_flags(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, nk_style_push_flags(context, address, value));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x90f0(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x5fd8e
testq %rax, %rax
je 0x5e1fa
movq %r14, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x12a40
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_flags
static int Style_set_flags(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_flags value = checkflags(L, 3);
    nk_flags *address = address_flags(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9021(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r14
movq %r15, %rdi
movl %ebp, %esi
callq 0x5fd8e
testq %rax, %rax
je 0x5e2b4
movl %r14d, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_flags
static int Style_get_flags(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_flags *address = address_flags(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushflags(L, *address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8f9a(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x5fd8e
testq %rax, %rax
je 0x5e32d
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_push_color
static int Style_push_color(lua_State *L)
    {
    nk_color_t value;
    nk_color_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    if(echeckcolor(L, 3, &value)) return argerror(L, 3);
    address = address_color(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, nk_style_push_color(context, address, value));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8f20(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x5e3ba
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x5e3e7
movq %r14, %rdi
movl %ebp, %esi
callq 0x5ff94
testq %rax, %rax
je 0x5e3f0
movl 0xc(%rsp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x12830
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x5e3b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_color
static int Style_set_color(lua_State *L)
    {
    nk_color_t value;
    nk_color_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    if(echeckcolor(L, 3, &value)) return argerror(L, 3);
    address = address_color(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8e3a(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x5e4a0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x5e4b7
movq %r14, %rdi
movl %ebp, %esi
callq 0x5ff94
testq %rax, %rax
je 0x5e4c0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x5e496
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_color
static int Style_get_color(lua_State *L)
    {
    nk_color_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    address = address_color(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushcolor(L, address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8d9e(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x5ff94
testq %rax, %rax
je 0x5e52a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13820
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_push_style_item
static int Style_push_style_item(lua_State *L)
    {
    nk_style_item_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_style_item_t value = checkstyleitem(L, 3);
    address = address_styleitem(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, nk_style_push_style_item(context, address, value));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x8d21(%rip), %rcx      # 0x67280
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %r15d
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x13460
movq %r14, %rdi
movl %r15d, %esi
callq 0x60a21
testq %rax, %rax
je 0x5e5de
movq 0x50(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rax, %rsi
callq 0x13b70
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
jmp 0x5e5fa
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_style_item
static int Style_set_style_item(lua_State *L)
    {
    nk_style_item_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_style_item_t value = checkstyleitem(L, 3);
    address = address_styleitem(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x8c35(%rip), %rcx      # 0x67280
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rsp, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x13460
movq %r15, %rdi
movl %ebp, %esi
callq 0x60a21
testq %rax, %rax
je 0x5e6aa
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x5e6c6
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %r14, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_style_item
static int Style_get_style_item(lua_State *L)
    {
    nk_style_item_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    address = address_styleitem(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushstyleitem(L, address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8b9f(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x60a21
testq %rax, %rax
je 0x5e729
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12290
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_boolean
static int Style_set_boolean(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    int value = checkboolean(L, 3);
    int *address = address_boolean(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8b28(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rbx
movq %r14, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %r14, %rdi
movl $0x3, %esi
callq 0x13770
cmpl $0xe3, %ebp
jg 0x5e7a7
cmpl $0x84, %ebp
je 0x5e7dc
cmpl $0xcf, %ebp
jne 0x5e7be
movl $0x1794, %ecx           # imm = 0x1794
jmp 0x5e7e8
cmpl $0xe4, %ebp
je 0x5e7e3
cmpl $0x15c, %ebp            # imm = 0x15C
jne 0x5e7be
movl $0x13fc, %ecx           # imm = 0x13FC
jmp 0x5e7e8
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %r14, %rdi
movl $0x2, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x12460
movl $0x91c, %ecx            # imm = 0x91C
jmp 0x5e7e8
movl $0x1a84, %ecx           # imm = 0x1A84
movl %eax, (%rbx,%rcx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_get_boolean
static int Style_get_boolean(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    int *address = address_boolean(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, *address);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8a80(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
cmpl $0xe3, %eax
jg 0x5e83d
cmpl $0x84, %eax
je 0x5e873
cmpl $0xcf, %eax
jne 0x5e852
movl $0x1794, %eax           # imm = 0x1794
jmp 0x5e87f
cmpl $0xe4, %eax
je 0x5e87a
cmpl $0x15c, %eax            # imm = 0x15C
jne 0x5e852
movl $0x13fc, %eax           # imm = 0x13FC
jmp 0x5e87f
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12460
movl $0x91c, %eax            # imm = 0x91C
jmp 0x5e87f
movl $0x1a84, %eax           # imm = 0x1A84
movl (%r14,%rax), %esi
movq %rbx, %rdi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/style.c
// Function: Style_set_symboltype
static int Style_set_symboltype(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    enum nk_symbol_type value = checksymboltype(L, 3);
    enum nk_symbol_type *address = address_symboltype(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x89d7(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %r15d
movq %rbx, %rdi
movl $0xe, %esi
movl $0x3, %edx
callq 0x132f0
movl %eax, %ebp
movq %r14, %rdi
movl %r15d, %esi
callq 0x61541
testq %rax, %rax
je 0x5e900
movl %ebp, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12460