LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Chart_push
static int Chart_push(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float value = luaL_checknumber(L, 2);
    int slot = optindex(L, 3, 0);
    pushflags(L, nk_chart_push_slot(context, value, slot)); /* charteventflags */
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b9b(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x14190
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %eax, %esi
callq 0x12400
movl %eax, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Plot
static int Plot(lua_State *L)
    {
    int nvalues, err;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 4);
    int offset = luaL_checkinteger(L, 5);
    float *values = checkfloatlist(L, 3, &nvalues, &err);
    if(err) return argerrorc(L, 3, err);
    /* plots values[offset] to values[offset+count-1] */
    if(offset < 0 || (offset+count) > nvalues)
        {
        freefloatlist(L, values, count);
        return argerrorc(L, 4, ERR_BOUNDARIES);
        }
    nk_plot(context, chart_type, values, count, offset);
    freefloatlist(L, values, count);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3b07(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0xa, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r14
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movq %rax, %r12
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r15
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rcx
callq 0x14040
movl (%r15), %edi
testl %edi, %edi
je 0x647ee
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x64825
movq %rax, %r13
movq 0x8(%rsp), %rdi
testl %r12d, %r12d
js 0x64805
leal (%r12,%r14), %eax
cmpl 0x4(%rsp), %eax
jle 0x6483c
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x12af0
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x13ac0
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %esi
movq %r13, %rdx
movl %r14d, %ecx
movl %r12d, %r8d
callq 0x12d50
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x12af0
xorl %eax, %eax
jmp 0x6482d
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Plot_function
static int Plot_function(lua_State *L)
    {
    cbinfo_t info;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 4);
    int offset = luaL_checkinteger(L, 5);
    if(!lua_isfunction(L, 3))
        return argerrorc(L, 3, ERR_TYPE);
    lua_pushvalue(L, 3);
    info.ref = luaL_ref(L, LUA_REGISTRYINDEX);
    nk_plot_function(context, chart_type, &info, ValueGetter, count, offset);
    luaL_unref(L, LUA_REGISTRYINDEX, info.ref);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3a0a(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0xa, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x6492a
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12780
leaq 0x8(%rsp), %r13
movl %eax, (%r13)
leaq 0x1e11(%rip), %rcx      # 0x66706
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r15d, %r8d
movl %r12d, %r9d
callq 0x14010
movl (%r13), %edx
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Check
static int Check(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    lua_pushboolean(L, nk_check_text(context, s, (int)len, active));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x391c(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %ecx
callq 0x133c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Check_flags
static int Check_flags(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    unsigned int flags = luaL_checkinteger(L, 3);
    unsigned int value = luaL_checkinteger(L, 4);
    lua_pushinteger(L, nk_check_flags_text(context, s, len, flags, value));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x38a8(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %ecx
movl %eax, %r8d
callq 0x12b40
movl %eax, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Check_align
static int Check_align(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    unsigned int widgetalignflags = luaL_checkinteger(L, 4);
    unsigned int textalignflags = luaL_checkinteger(L, 5);
    lua_pushboolean(L, nk_check_text_align(context, s, (int)len, active, widgetalignflags, textalignflags));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x381e(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
movl %r13d, %r8d
movl %eax, %r9d
callq 0x13120
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Checkbox
static int Checkbox(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    nk_checkbox_text(context, s, len, &active);
    lua_pushboolean(L, active);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3782(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
leaq 0x4(%rsp), %r13
movl %eax, (%r13)
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x12310
movl (%r13), %esi
movq %rbx, %rdi
callq 0x13270
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Checkbox_flags
static int Checkbox_flags(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    unsigned int flags = luaL_checkinteger(L, 3);
    unsigned int value = luaL_checkinteger(L, 4);
    nk_checkbox_flags_text(context, s, len, &flags, value);
    lua_pushinteger(L, flags);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x36fe(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
leaq 0x4(%rsp), %r13
movl %eax, (%r13)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movl %eax, %r8d
callq 0x13070
movl (%r13), %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Checkbox_align
static int Checkbox_align(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    unsigned int widgetalignflags = luaL_checkinteger(L, 4);
    unsigned int textalignflags = luaL_checkinteger(L, 5);
    nk_checkbox_text_align(context, s, len, &active, widgetalignflags, textalignflags);
    lua_pushboolean(L, active);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3669(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %rbp
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x13690
movl (%r13), %esi
movq %rbx, %rdi
callq 0x13270
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Color_picker
static int Color_picker(lua_State *L)
    {
    nk_colorf_t color;
    enum nk_color_format fmt;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckcolorf(L, 2, &color)) return argerror(L, 2);
    fmt = checkcolorformat(L, 3);
    color = nk_color_picker(context, color, fmt);
    return pushcolorf(L, &color);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x35c5(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13210
movq %rbx, %rdi
testl %eax, %eax
je 0x64cff
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x64d38
movl $0xb, %esi
movl $0x3, %edx
callq 0x132f0
movq %rsp, %r15
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movq %r14, %rdi
movl %eax, %esi
callq 0x13880
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13db0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Combo
static int Combo(lua_State *L)
    {
    nk_vec2_t size;
    char **items;
    int count, err;
    nk_context_t *context = checkcontext(L, 1, NULL);
    int selected = luaL_checkinteger(L, 3);
    int item_height = luaL_checkinteger(L, 4);
    if(echeckvec2(L, 5, &size)) return argerror(L, 5);
    items = checkstringlist(L, 2, &count, &err);
    if(err) return argerrorc(L, 2, err);
    if(selected < 1 || selected > count)
        { freestringlist(L, items, count); return argerrorc(L, 3, ERR_RANGE); }
    selected = nk_combo(context, (const char**)items, count, selected - 1, item_height, size) + 1;
    //int nk_combo_separator(struct nk_context *ctx, const char *items_separated_by_separator,
    //    int separator, int selected, int count, int item_height, struct nk_vec2 size)
    freestringlist(L, items, count);
    lua_pushinteger(L, selected);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3526(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x14160
testl %eax, %eax
je 0x64db8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x64e1a
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movl $0x2, %esi
movq %rbp, %rcx
callq 0x131c0
movl (%rbp), %edi
testl %edi, %edi
je 0x64de8
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x64e1a
movq %rax, %r13
testl %r15d, %r15d
jle 0x64df9
movl 0x4(%rsp), %edx
cmpl %r15d, %edx
jge 0x64e31
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12c90
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decl %r15d
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movq %r13, %rsi
movl %r15d, %ecx
movl %r12d, %r8d
callq 0x12620
movl %eax, %ebp
incl %ebp
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12c90
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
jmp 0x64e22
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Combo_callback
static int Combo_callback(lua_State *L)
    {
    cbinfo_t info;
    nk_vec2_t size;
    nk_context_t *context = checkcontext(L, 1, NULL);
    int selected = luaL_checkinteger(L, 3);
    int count = luaL_checkinteger(L, 4);
    int item_height = luaL_checkinteger(L, 5);
    if(echeckvec2(L, 6, &size)) return argerror(L, 6);
    if(!lua_isfunction(L, 2))
        return argerrorc(L, 2, ERR_TYPE);
    lua_pushvalue(L, 2);
    info.ref = luaL_ref(L, LUA_REGISTRYINDEX);
    info.item = NULL;
    selected = nk_combo_callback(context, ItemGetter, &info, selected-1, count, item_height, size);
    if(info.item) Free(L, info.item);
    luaL_unref(L, LUA_REGISTRYINDEX, info.ref);
    lua_pushinteger(L, selected+1);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x33f8(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movq %rax, %r13
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x14160
movq %rbx, %rdi
testl %eax, %eax
je 0x64ef7
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x64fa3
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x64f91
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12780
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq $0x0, 0x8(%rcx)
movq %rcx, %rdx
decl %r15d
movsd (%rsp), %xmm0
leaq 0x1845(%rip), %rsi      # 0x6678a
movq %r14, %rdi
movq %rcx, %r14
movl %r15d, %ecx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x14090
movl %eax, %ebp
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x64f6c
movq %rbx, %rdi
callq 0x130d0
movl 0x8(%rsp), %edx
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
incl %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
jmp 0x64fab
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Combo_item
static int Combo_item(lua_State *L)
    {
    int rc;
    size_t len;
    enum nk_symbol_type symbol;
    nk_image_t *image;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *s = luaL_checklstring(L, 3, &len);
    nk_flags alignment = checkflags(L, 4); /* textalign */
    int arg_type = lua_type(L, 2);
    if(arg_type == LUA_TNIL)
        rc = nk_combo_item_text(context, s, len, alignment);
    else if((image = testimage(L, 2, NULL)) != NULL)
        rc = nk_combo_item_image_text(context, *image, s, len, alignment);
    else
        {
        symbol = checksymboltype(L, 2);
        rc = nk_combo_item_symbol_text(context, symbol, s, len, alignment);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30fa(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
je 0x6520a
leaq 0x3072(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6521e
movl 0x20(%rsp), %edx
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13ba0
jmp 0x65244
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x132b0
jmp 0x65244
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x132f0
movl 0x20(%rsp), %ecx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x12bb0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Contextual_begin
static int Contextual_begin(lua_State *L)
    {
    nk_vec2_t size;
    nk_rect_t trigger_bounds;
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_flags flags = checkflags(L, 2); /* panelflags */
    if(echeckvec2(L, 3, &size)) return argerror(L, 3);
    if(echeckrect(L, 4, &trigger_bounds)) return argerror(L, 4);
    lua_pushboolean(L, nk_contextual_begin(context, flags, size, trigger_bounds));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x2fce(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x65300
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x6532d
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x139f0
testl %eax, %eax
je 0x6533f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movq %r14, %rdi
movl %r15d, %esi
callq 0x12ad0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
jmp 0x65335
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Contextual_item
static int Contextual_item(lua_State *L)
    {
    int rc;
    size_t len;
    enum nk_symbol_type symbol;
    nk_image_t *image;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *s = luaL_checklstring(L, 3, &len);
    nk_flags alignment = checkflags(L, 4); /* textalign */
    if(lua_isnoneornil(L, 2))
        rc = nk_contextual_item_text(context, s, len, alignment);
    else if((image = testimage(L, 2, NULL)) != NULL)
        rc = nk_contextual_item_image_text(context, *image, s, len, alignment);
    else
        {
        symbol = checksymboltype(L, 2);
        rc = nk_contextual_item_symbol_text(context, symbol, s, len, alignment);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x2efe(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x65406
leaq 0x2e76(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6541a
movl 0x20(%rsp), %edx
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13190
jmp 0x65440
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13860
jmp 0x65440
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x132f0
movl 0x20(%rsp), %ecx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x138b0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Image
static int Image(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_image_t *image = checkimage(L, 2, NULL);
    nk_image(context, *image);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2dd4(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x2d82(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x120d0
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x12eb0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Label
static int Label(lua_State *L)
    {
    size_t len;
    nk_color_t color;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    nk_flags alignment = checkflags(L, 3); /* textalign */
    if(lua_isnoneornil(L, 4))
        nk_text(context, s, len, alignment);
    else
        {
        if(echeckcolor(L, 4, &color)) return argerror(L, 4);
        nk_text_colored(context, s, len, alignment, color);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2d76(%rip), %rcx      # 0x68280
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13df0
testl %eax, %eax
jle 0x6558c
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x655a0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x655ba
movl 0x8(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %ecx
callq 0x13950
jmp 0x655ba
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %r8d
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %ecx
callq 0x128f0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Label_wrap
static int Label_wrap(lua_State *L)
    {
    size_t len;
    nk_color_t color;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    if(lua_isnoneornil(L, 3))
        nk_text_wrap(context, s, len);
    else
        {
        if(echeckcolor(L, 3, &color)) return argerror(L, 3);
        nk_text_wrap_colored(context, s, len, color);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2ca0(%rip), %rcx      # 0x68280
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13df0
testl %eax, %eax
jle 0x65652
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x65663
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x65679
movl 0x10(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12e00
jmp 0x65679
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq %r15, %rdi
movq %r12, %rsi
callq 0x133a0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Menu_begin
static int Menu_begin(lua_State *L)
    {
    int rc;
    size_t len;
    nk_vec2_t size;
    enum nk_symbol_type symbol;
    nk_image_t *image;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *s = luaL_checklstring(L, 3, &len);
    nk_flags alignment = checkflags(L, 4); /* textalign */
    if(echeckvec2(L, 5, &size)) return argerror(L, 5);
    if(lua_isnoneornil(L, 2))
        rc = nk_menu_begin_text(context, s, len, alignment, size);
    else if((image = testimage(L, 2, NULL)) != NULL)
        rc = nk_menu_begin_image_text(context, s, len, alignment, *image, size);
    else
        {
        symbol = checksymboltype(L, 2);
        rc = nk_menu_begin_symbol_text(context, s, len, alignment, symbol, size);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x2be3(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x14160
movq %rbx, %rdi
testl %eax, %eax
je 0x6570b
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x657b4
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x6575e
leaq 0x2b24(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x65778
movl 0x20(%rsp), %edx
movsd 0x18(%rsp), %xmm0
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm1
movups %xmm1, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x12b80
jmp 0x657a5
movl 0x20(%rsp), %edx
movsd 0x18(%rsp), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x124e0
jmp 0x657a5
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x132f0
movl 0x20(%rsp), %edx
movsd 0x18(%rsp), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
movl %eax, %r8d
callq 0x12f60
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Menu_item
static int Menu_item(lua_State *L)
    {
    int rc;
    size_t len;
    enum nk_symbol_type symbol;
    nk_image_t *image;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *s = luaL_checklstring(L, 3, &len);
    nk_flags alignment = checkflags(L, 4); /* textalign */
    if(lua_isnoneornil(L, 2))
        rc = nk_menu_item_text(context, s, len, alignment);
    else if((image = testimage(L, 2, NULL)) != NULL)
        rc = nk_menu_item_image_text(context, *image, s, len, alignment);
    else
        {
        symbol = checksymboltype(L, 2);
        rc = nk_menu_item_symbol_text(context, symbol, s, len, alignment);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x2aab(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x65859
leaq 0x2a23(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x6586d
movl 0x20(%rsp), %edx
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13f80
jmp 0x65893
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13940
jmp 0x65893
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x132f0
movl 0x20(%rsp), %ecx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x132c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Popup_begin
static int Popup_begin(lua_State *L)
    {
    nk_rect_t bounds;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_popup_type popup_type = checkpopuptype(L,2);
    const char *s = luaL_checkstring(L, 3);
    nk_flags flags = checkflags(L, 4); /* nk_window_flags */
    if(echeckrect(L, 5, &bounds)) return argerror(L, 5);
    lua_pushboolean(L, nk_popup_begin(context, popup_type, s, flags, bounds));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x293a(%rip), %rcx      # 0x68280
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0xc, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %r15d
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r13
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x139f0
testl %eax, %eax
je 0x659ca
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebp
jmp 0x659f1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x121f0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Popup_get_scroll
static int Popup_get_scroll(lua_State *L)
    {
    nk_uint offset_x, offset_y;
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_popup_get_scroll(context, &offset_x, &offset_y);
    lua_pushinteger(L, offset_x);
    lua_pushinteger(L, offset_y);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x282b(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13bb0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movl (%r15), %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Popup_set_scroll
static int Popup_set_scroll(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_uint offset_x = luaL_checkinteger(L, 2);
    nk_uint offset_y = luaL_checkinteger(L, 3);
    nk_popup_set_scroll(context, offset_x, offset_y);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x27d3(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13430
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Property
static int Property(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *text = luaL_checkstring(L, 2);
    double min = luaL_checknumber(L, 3);
    double val = luaL_checknumber(L, 4);
    double max = luaL_checknumber(L, 5);
    double step = luaL_checknumber(L, 6);
    float inc_per_pixel = luaL_checknumber(L, 7);
    nk_property_double(context, text, min, &val, max, step, inc_per_pixel);
    lua_pushnumber(L, val);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x277d(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
leaq 0x20(%rsp), %r12
movsd %xmm0, (%r12)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm3
movq %r14, %rdi
movq %r15, %rsi
movsd 0x18(%rsp), %xmm0
movq %r12, %rdx
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x13b90
movsd (%r12), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Progress
static int Progress(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_size cur = luaL_checkinteger(L, 2);
    nk_size max = luaL_checkinteger(L, 3);
    enum nk_modify modifyable = checkmodify(L, 4);
    lua_pushinteger(L, nk_prog(context, cur, max, (int)modifyable));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x26a9(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x7, %esi
movl $0x4, %edx
callq 0x132f0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x13720
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Option
static int Option(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    int changed = nk_radio_text(context, s, len, &active);
    lua_pushboolean(L, active);
    lua_pushboolean(L, changed);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2624(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x12ed0
movl %eax, %ebp
movl (%r13), %esi
movq %rbx, %rdi
callq 0x13270
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13270
movl $0x2, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Option_align
static int Option_align(lua_State *L)
    {
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    int active = checkboolean(L, 3);
    unsigned int widgetalignflags = luaL_checkinteger(L, 4);
    unsigned int textalignflags = luaL_checkinteger(L, 5);
    int changed = nk_radio_text_align(context, s, len, &active, widgetalignflags, textalignflags);
    lua_pushboolean(L, active);
    lua_pushboolean(L, changed);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2592(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13770
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %rbp
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x128d0
movl %eax, %ebp
movl (%r13), %esi
movq %rbx, %rdi
callq 0x13270
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13270
movl $0x2, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Rule_horizontal
static int Rule_horizontal(lua_State *L)
    {
    nk_color_t color;
    nk_context_t *context = checkcontext(L, 1, NULL);
    int rounding = checkboolean(L, 3);
    if(echeckcolor(L, 2, &color)) return argerror(L, 2);
    nk_rule_horizontal(context, color, rounding);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x24e4(%rip), %rcx      # 0x68280
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x3, %esi
callq 0x13770
movl %eax, %ebp
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x2, %esi
callq 0x12100
testl %eax, %eax
je 0x65df5
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x65e03
movl 0x4(%rsp), %esi
movq %r15, %rdi
movl %ebp, %edx
callq 0x12be0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Selectable
static int Selectable(lua_State *L)
    {
    size_t len;
    int changed;
    enum nk_symbol_type symbol;
    nk_image_t *image;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 3, &len);
    nk_flags alignment = checkflags(L, 4); /* textalign */
    int value = checkboolean(L, 5);
    int arg_type = lua_type(L, 2);
    if(arg_type == LUA_TNIL)
        changed = nk_selectable_text(context, s, len, alignment, &value);
    else if((image = testimage(L, 2, NULL)) != NULL)
        changed = nk_selectable_image_text(context, *image, s, len, alignment, &value);
    else
        {
        symbol = checksymboltype(L, 2);
        changed = nk_selectable_symbol_text(context, symbol, s, len, alignment, &value);
        }
    lua_pushboolean(L, value);
    lua_pushboolean(L, changed);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x245a(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13770
movl %eax, 0x24(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
je 0x65ec0
leaq 0x23c1(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x65ed9
movl 0x28(%rsp), %edx
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
leaq 0x24(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x12ff0
jmp 0x65f04
movl 0x28(%rsp), %edx
leaq 0x24(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x12050
jmp 0x65f04
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x132f0
movl 0x28(%rsp), %ecx
leaq 0x24(%rsp), %r9
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x13c40
movl %eax, %ebp
movl 0x24(%rsp), %esi
movq %rbx, %rdi
callq 0x13270
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13270
movl $0x2, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Slider
static int Slider(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float min = luaL_checknumber(L, 2);
    float val = luaL_checknumber(L, 3);
    float max = luaL_checknumber(L, 4);
    float step = luaL_checknumber(L, 5);
    nk_slider_float(context, min, &val, max, step);
    lua_pushnumber(L, val);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x233f(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
leaq 0xc(%rsp), %r15
movss %xmm0, (%r15)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm2
movq %r14, %rdi
movss 0x8(%rsp), %xmm0
movq %r15, %rsi
movss 0x4(%rsp), %xmm1
callq 0x13320
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Tooltip
static int Tooltip(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *s = luaL_checkstring(L, 2);
    nk_tooltip(context, s);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2272(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %r14, %rdi
movq %rax, %rsi
callq 0x122c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Tooltip_begin
static int Tooltip_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float width = luaL_checknumber(L, 2);
    lua_pushboolean(L, nk_tooltip_begin(context, width));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2231(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13d50
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_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_push
static int Tree_push(lua_State *L)
/* tree_push(context, type, title, state, hash, [image] */
    {
    int rc;
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_tree_type tree_type = checktreetype(L, 2);
    const char *title = luaL_checkstring(L, 3);
    enum nk_collapse_states init_state = checkcollapsestates(L, 4);
    const char *hash = luaL_checklstring(L, 5, &len);
    int seed = __LINE__; //* always the same... is it important? @@
    nk_image_t *image = testimage(L, 6, NULL);
    if(image)
        rc = nk_tree_image_push_hashed(context, tree_type, *image, title, init_state, hash, (int)len, seed);
    else
        rc = nk_tree_push_hashed(context, tree_type, title, init_state, hash, (int)len, seed);
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x21ba(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movl $0xd, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x132f0
movl %eax, %r12d
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rdx
callq 0x12cd0
movq %rax, %r13
leaq 0x2113(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x6, %esi
xorl %edx, %edx
callq 0x14150
movl (%r14), %r9d
testq %rax, %rax
je 0x66177
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movl $0x397, 0x18(%rsp)      # imm = 0x397
movq 0x28(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r8
callq 0x13e80
jmp 0x66193
movl $0x397, (%rsp)          # imm = 0x397
movq 0x28(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r8
callq 0x13290
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq