LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: Button_set_behavior
static int Button_set_behavior(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_button_behavior behavior = checkbuttonbehavior(L, 2);
    nk_button_set_behavior(context, behavior);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b5c(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x12850
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: Button_push_behavior
static int Button_push_behavior(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_button_behavior behavior = checkbuttonbehavior(L, 2);
    lua_pushboolean(L, nk_button_push_behavior(context, behavior));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b19(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x132f0
movq %r14, %rdi
movl %eax, %esi
callq 0x13fd0
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/widgets.c
// Function: Chart_begin
static int Chart_begin(lua_State *L)
    {
    int rc;
    nk_color_t color, highlight;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 3);
    float min = luaL_checknumber(L, 4);
    float max = luaL_checknumber(L, 5);
    if(lua_isnoneornil(L, 6))
        rc = nk_chart_begin(context, chart_type, count, min, max);
    else
        {
        if(echeckcolor(L, 6, &color)) return argerror(L, 6);
        if(echeckcolor(L, 7, &highlight)) return argerror(L, 7);
        rc = nk_chart_begin_colored(context, chart_type, color, highlight, count, min, max);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3a93(%rip), %rcx      # 0x67280
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 $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x13df0
testl %eax, %eax
jle 0x6388e
leaq 0x14(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x638b8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x638e5
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x12890
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
jmp 0x638ed
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x638f8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %r8d
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x12330
jmp 0x638a7
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: Chart_add_slot
static int Chart_add_slot(lua_State *L)
    {
    nk_color_t color, highlight;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_chart_type chart_type = checkcharttype(L, 2);
    int count = luaL_checkinteger(L, 3);
    float min = luaL_checknumber(L, 4);
    float max = luaL_checknumber(L, 5);
    if(lua_isnoneornil(L, 6))
        nk_chart_add_slot(context, chart_type, count, min, max);
    else
        {
        if(echeckcolor(L, 6, &color)) return argerror(L, 6);
        if(echeckcolor(L, 7, &highlight)) return argerror(L, 7);
        nk_chart_add_slot_colored(context, chart_type, color, highlight, count, min, max);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x394f(%rip), %rcx      # 0x67280
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0xa, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r12
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, %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x13df0
testl %eax, %eax
jle 0x639d4
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x639ee
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x63a1b
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x13790
jmp 0x63a26
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x63a36
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %r8d
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x13550
xorl %r14d, %r14d
jmp 0x63a26
// File: /workspace/github_c_makefile_star2_O3/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 0x3783(%rip), %rcx      # 0x67280
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 0x63b72
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x63ba9
movq %rax, %r13
movq 0x8(%rsp), %rdi
testl %r12d, %r12d
js 0x63b89
leal (%r12,%r14), %eax
cmpl 0x4(%rsp), %eax
jle 0x63bc0
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 0x63bb1
// File: /workspace/github_c_makefile_star2_O3/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 0x3686(%rip), %rcx      # 0x67280
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 0x63cae
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 0x1e16(%rip), %rcx      # 0x65a8f
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_O3/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 0x3598(%rip), %rcx      # 0x67280
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_O3/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 0x3524(%rip), %rcx      # 0x67280
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_O3/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 0x33fe(%rip), %rcx      # 0x67280
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_O3/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 0x337a(%rip), %rcx      # 0x67280
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_O3/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 0x3241(%rip), %rcx      # 0x67280
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 0x64083
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x640bc
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_O3/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 0x31a2(%rip), %rcx      # 0x67280
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 0x6413c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x641a3
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 0x6416c
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x641a3
movq %rax, %r13
testl %r15d, %r15d
setle %al
movl 0x4(%rsp), %edx
cmpl %r15d, %edx
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x641ba
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 0x641ab
// File: /workspace/github_c_makefile_star2_O3/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 0x306f(%rip), %rcx      # 0x67280
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 0x64280
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x6432c
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x6431a
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      # 0x65b13
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 0x642f5
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 0x64334
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_O3/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 0x2d71(%rip), %rcx      # 0x67280
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 0x64593
leaq 0x2ce9(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x645a7
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 0x645cd
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x132b0
jmp 0x645cd
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_O3/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 0x2c45(%rip), %rcx      # 0x67280
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 0x64689
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x646b6
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x139f0
testl %eax, %eax
je 0x646c8
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 0x646be
// File: /workspace/github_c_makefile_star2_O3/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 0x2b75(%rip), %rcx      # 0x67280
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 0x6478f
leaq 0x2aed(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x647a3
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 0x647c9
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13860
jmp 0x647c9
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_O3/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 0x2a4b(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x29f9(%rip), %rcx      # 0x67244
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_O3/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 0x29ed(%rip), %rcx      # 0x67280
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 0x64915
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x64929
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 0x64943
movl 0x8(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %ecx
callq 0x13950
jmp 0x64943
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_O3/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 0x2917(%rip), %rcx      # 0x67280
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 0x649db
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x649ec
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 0x64a02
movl 0x10(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12e00
jmp 0x64a02
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_O3/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 0x285a(%rip), %rcx      # 0x67280
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 0x64a94
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x64b3d
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x64ae7
leaq 0x279b(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x64b01
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 0x64b2e
movl 0x20(%rsp), %edx
movsd 0x18(%rsp), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x124e0
jmp 0x64b2e
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_O3/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 0x2722(%rip), %rcx      # 0x67280
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 0x64be2
leaq 0x269a(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x64bf6
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 0x64c1c
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13940
jmp 0x64c1c
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_O3/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 0x25b1(%rip), %rcx      # 0x67280
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 0x64d53
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 0x64d7a
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_O3/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 0x24a2(%rip), %rcx      # 0x67280
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_O3/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 0x244a(%rip), %rcx      # 0x67280
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_O3/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 0x2320(%rip), %rcx      # 0x67280
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_O3/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 0x2209(%rip), %rcx      # 0x67280
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_O3/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 0x215b(%rip), %rcx      # 0x67280
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 0x6517e
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 0x6518c
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_O3/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 0x20d1(%rip), %rcx      # 0x67280
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 0x65249
leaq 0x2038(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14150
testq %rax, %rax
je 0x65262
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 0x6528d
movl 0x28(%rsp), %edx
leaq 0x24(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x12050
jmp 0x6528d
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_O3/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 0x1ee9(%rip), %rcx      # 0x67280
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_O3/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 0x1ea8(%rip), %rcx      # 0x67280
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_O3/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 0x1e31(%rip), %rcx      # 0x67280
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 0x1d8a(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x6, %esi
xorl %edx, %edx
callq 0x14150
movl (%r14), %r9d
testq %rax, %rax
je 0x65500
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 0x6551c
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
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_element_push
static int Tree_element_push(lua_State *L)
/* tree_element_push(context, type, title, state, selected, 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);
    int selected = checkboolean(L, 5);
    const char *hash = luaL_checklstring(L, 6, &len);
    int seed = __LINE__; //* always the same... is it important? @@
    nk_image_t *image = testimage(L, 7, NULL);
    if(image)
        rc = nk_tree_element_image_push_hashed(context, tree_type, *image, title, init_state, &selected, hash, (int)len, seed);
    else
        rc = nk_tree_element_push_hashed(context, tree_type, title, init_state, &selected, hash, (int)len, seed);
    lua_pushboolean(L, rc);
    lua_pushboolean(L, selected);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1d0e(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, 0x38(%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
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13770
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %r14
movq %rbx, %rdi
movl $0x6, %esi
movq %r14, %rdx
callq 0x12cd0
movq %rax, %r13
leaq 0x1c56(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0x14150
movl (%r14), %ecx
testq %rax, %rax
je 0x6563d
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movl %ecx, 0x18(%rsp)
movl $0x3af, 0x20(%rsp)      # imm = 0x3AF
leaq 0x34(%rsp), %r8
movq 0x38(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r9
callq 0x13850
jmp 0x65662
movl %ecx, (%rsp)
movl $0x3af, 0x8(%rsp)       # imm = 0x3AF
leaq 0x34(%rsp), %r8
movq 0x38(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r9
callq 0x13a80
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl 0x34(%rsp), %esi
movq %rbx, %rdi
callq 0x13270
movl $0x2, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq