LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2834(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x13360
testl %eax, %eax
je 0x5da88
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x5dac0
pushq $0xb
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %rsp, %r15
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movq %r14, %rdi
movl %eax, %esi
callq 0x13a70
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13fd0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x279e(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x5
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5db32
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x5
jmp 0x5db87
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rcx
callq 0x13310
movl (%r13), %edi
testl %edi, %edi
je 0x5db5b
callq 0x13cc0
pushq $0x2
jmp 0x5db87
movq %rax, %rsi
testl %r15d, %r15d
setle %al
movl 0x4(%rsp), %edx
cmpl %r15d, %edx
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5dba6
movq %rbx, %rdi
callq 0x12d90
pushq $-0xe
popq %rdi
callq 0x13cc0
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
movl %ebp, %eax
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 %rsi, %r13
movl %r15d, %ecx
movl %r12d, %r8d
callq 0x12680
movl %eax, %r14d
incl %r14d
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12d90
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x12c20
jmp 0x5db95
// File: /workspace/github_c_makefile_star2_O2/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 0x2686(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r13
pushq $0x6
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5dc59
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x6
jmp 0x5dcf8
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
cmpl $0x6, %eax
jne 0x5dcee
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12e90
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12800
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, %rdx
decl %r15d
movsd (%rsp), %xmm0
leaq 0x16bb(%rip), %rsi      # 0x5f35e
movq %r14, %rdi
movl %r15d, %ecx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x14310
movl %eax, %r14d
leaq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x5dccd
movq %rbx, %rdi
callq 0x13220
movl 0x8(%rsp), %edx
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x14190
incl %r14d
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x12c20
jmp 0x5dd06
pushq $-0x2
popq %rdi
callq 0x13cc0
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
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_O2/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 0x23b8(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
je 0x5df42
leaq 0x2338(%rip), %rcx      # 0x60244
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
testq %rax, %rax
je 0x5df56
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 0x13da0
jmp 0x5df78
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13410
jmp 0x5df78
pushq $0xe
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl 0x20(%rsp), %ecx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x12c80
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x229f(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5e021
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
jmp 0x5e044
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x5e05f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq %r14, %rdi
movl %r15d, %esi
callq 0x12b90
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
jmp 0x5e052
// File: /workspace/github_c_makefile_star2_O2/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 0x21e4(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5e116
leaq 0x2164(%rip), %rcx      # 0x60244
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
testq %rax, %rax
je 0x5e12a
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 0x132e0
jmp 0x5e14c
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13a50
jmp 0x5e14c
pushq $0xe
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl 0x20(%rsp), %ecx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x13aa0
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20ce(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
leaq 0x207e(%rip), %rcx      # 0x60244
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x120e0
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x12fe0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2074(%rip), %rcx      # 0x60280
xorl %r14d, %r14d
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r13
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5e280
pushq $0x4
popq %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x5e294
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
jmp 0x5e2ae
movl 0x8(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %ecx
callq 0x13b50
jmp 0x5e2ae
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %r8d
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %ecx
callq 0x129a0
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_O2/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 0x1fac(%rip), %rcx      # 0x60280
xorl %r14d, %r14d
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5e33a
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x5e34b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
jmp 0x5e361
movl 0x10(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12f20
jmp 0x5e361
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq %r15, %rdi
movq %r12, %rsi
callq 0x13510
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x1efa(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x5
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5e3ec
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
jmp 0x5e48b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5e43e
leaq 0x1e42(%rip), %rcx      # 0x60244
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
testq %rax, %rax
je 0x5e458
movl 0x28(%rsp), %edx
movsd 0x20(%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 0x12c50
jmp 0x5e481
movl 0x28(%rsp), %edx
movsd 0x20(%rsp), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x12520
jmp 0x5e481
pushq $0xe
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl 0x28(%rsp), %edx
movsd 0x20(%rsp), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
movl %eax, %r8d
callq 0x13090
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1dd1(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5e529
leaq 0x1d51(%rip), %rcx      # 0x60244
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
testq %rax, %rax
je 0x5e53d
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 0x141c0
jmp 0x5e55f
movl 0x20(%rsp), %edx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x13b40
jmp 0x5e55f
pushq $0xe
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl 0x20(%rsp), %ecx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x13420
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c78(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0xc
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r13
pushq $0x5
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x5e679
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
jmp 0x5e6a0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x12220
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
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_O2/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 0x1b80(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13db0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movl (%r15), %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2c(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x135c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x1adb(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12920
leaq 0x18(%rsp), %r12
movsd %xmm0, (%r12)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x8(%rsp)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, (%rsp)
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm3
movq %r14, %rdi
movq %r15, %rsi
movsd 0x10(%rsp), %xmm0
movq %r12, %rdx
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x13d90
movsd (%r12), %xmm0
movq %rbx, %rdi
callq 0x132d0
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1a17(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x7
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x13900
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12c20
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19a0(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rbp
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13950
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x13000
movl %eax, %r14d
movl (%r13), %esi
movq %rbx, %rdi
callq 0x133d0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x133d0
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_O2/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 0x1913(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13950
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13060
movl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x12980
movl %eax, %ebp
movl (%r13), %esi
movq %rbx, %rdi
callq 0x133d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x133d0
pushq $0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1871(%rip), %rcx      # 0x60280
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x13950
movl %eax, %ebp
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x5ea5e
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x5ea6c
movl 0x4(%rsp), %esi
movq %r15, %rdi
movl %ebp, %edx
callq 0x12cc0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17f1(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x3
popq %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13950
movl %eax, 0x24(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
je 0x5eb1d
leaq 0x1762(%rip), %rcx      # 0x60244
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
testq %rax, %rax
je 0x5eb36
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 0x13130
jmp 0x5eb5d
movl 0x28(%rsp), %edx
leaq 0x24(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %ecx
callq 0x12060
jmp 0x5eb5d
pushq $0xe
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl 0x28(%rsp), %ecx
leaq 0x24(%rsp), %r9
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %r12d, %r8d
callq 0x13e40
movl %eax, %ebp
movl 0x24(%rsp), %esi
movq %rbx, %rdi
callq 0x133d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x133d0
pushq $0x2
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x16e7(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
leaq 0x14(%rsp), %r15
movss %xmm0, (%r15)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm2
movq %r14, %rdi
movss 0x10(%rsp), %xmm0
movq %r15, %rsi
movss 0xc(%rsp), %xmm1
callq 0x13480
cvtss2sd (%r15), %xmm0
movq %rbx, %rdi
callq 0x132d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1629(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %r14, %rdi
movq %rax, %rsi
callq 0x12300
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x15ec(%rip), %rcx      # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x13f70
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x157f(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, 0x28(%rsp)
pushq $0xd
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x13450
movl %eax, %r12d
pushq $0x5
popq %rsi
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x12dd0
movq %rax, %r13
leaq 0x14e7(%rip), %rcx      # 0x60244
pushq $0x6
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
movl (%r14), %r9d
testq %rax, %rax
je 0x5eda1
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 0x140c0
jmp 0x5edbd
movl $0x397, (%rsp)          # imm = 0x397
movq 0x28(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r8
callq 0x133f0
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1471(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, 0x38(%rsp)
pushq $0xd
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x13450
movl %eax, %r12d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x13950
movl %eax, 0x34(%rsp)
pushq $0x6
popq %rsi
leaq 0x40(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x12dd0
movq %rax, %r13
leaq 0x13ca(%rip), %rcx      # 0x60244
pushq $0x7
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x143e0
movl (%r14), %ecx
testq %rax, %rax
je 0x5eec7
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 0x13a40
jmp 0x5eeec
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 0x13c80
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl 0x34(%rsp), %esi
movq %rbx, %rdi
callq 0x133d0
pushq $0x2
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_state_push
static int Tree_state_push(lua_State *L)
    {
    int rc;
    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 state = checkcollapsestates(L, 4);
    rc = nk_tree_state_push(context, tree_type, title, &state);
    lua_pushboolean(L, rc);
    pushcollapsestates(L, state);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1339(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0xd
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r12
pushq $0x4
popq %r13
movq %rbx, %rdi
movl %r13d, %esi
movl %r13d, %edx
callq 0x13450
leaq 0x4(%rsp), %rbp
movl %eax, (%rbp)
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x13460
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl (%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x12640
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_state_image_push
static int Tree_state_image_push(lua_State *L)
    {
    int rc;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_tree_type tree_type = checktreetype(L, 2);
    nk_image_t *image = checkimage(L, 3, NULL);
    const char *title = luaL_checkstring(L, 4);
    enum nk_collapse_states state = checkcollapsestates(L, 5);
    rc = nk_tree_state_image_push(context, tree_type, *image, title, &state);
    lua_pushboolean(L, rc);
    pushcollapsestates(L, state);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x129e(%rip), %rcx      # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, 0x18(%rsp)
pushq $0xd
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %r12d
leaq 0x123b(%rip), %rcx      # 0x60244
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r13
pushq $0x4
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %rbp
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13450
leaq 0x24(%rsp), %r14
movl %eax, (%r14)
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq 0x18(%rsp), %rdi
movl %r12d, %esi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x14370
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl (%r14), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12640
pushq $0x2
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Color_from_bytes
static int Color_from_bytes(lua_State *L)
/* converts a RGBA-0-255 color to a normalized float color */
    {
    nk_color_t color;
    color.r = luaL_checkinteger(L, 1);
    color.g = luaL_checkinteger(L, 2);
    color.b = luaL_checkinteger(L, 3);
    color.a = luaL_optinteger(L, 4, 255);
    return pushcolor(L, &color);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x13060
leaq 0x4(%rsp), %r14
movb %al, (%r14)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movb %al, 0x1(%r14)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movb %al, 0x2(%r14)
pushq $0x4
popq %rsi
movl $0xff, %edx
movq %rbx, %rdi
callq 0x13470
movb %al, 0x3(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13a10
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Color_bytes
static int Color_bytes(lua_State *L)
    {
    nk_color_t colorb;
    nk_colorf_t color;
    if(echeckcolorf(L, 1, &color)) return argerror(L, 1);
    colorb = nk_rgba_cf(color);
    lua_pushinteger(L, colorb.r);
    lua_pushinteger(L, colorb.g);
    lua_pushinteger(L, colorb.b);
    lua_pushinteger(L, colorb.a);
    return 4;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x13360
testl %eax, %eax
je 0x5f147
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x5f1a8
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x139b0
movl %eax, %r14d
shrl $0x8, %r14d
movl %eax, %r15d
shrl $0x10, %r15d
movl %eax, %r12d
shrl $0x18, %r12d
movl $0xff, %ebp
andl %ebp, %eax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12c20
andl %ebp, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12c20
andl %ebp, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12c20
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12c20
pushq $0x4
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Rgba_to_hsva
static int Rgba_to_hsva(lua_State *L)
    {
    float h, s, v, a;
    nk_colorf_t color;
    if(echeckcolorf(L, 1, &color)) return argerror(L, 1);
    nk_colorf_hsva_f(&h, &s, &v, &a, color);
    color.r = h;
    color.g = s;
    color.b = v;
    color.a = a;
    return pushcolorf(L, &color);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x18(%rsp), %rdx
callq 0x13360
testl %eax, %eax
je 0x5f1f4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x5f261
leaq 0x18(%rsp), %r14
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x13d30
movss (%r15), %xmm0
movss %xmm0, (%r14)
movss (%r12), %xmm0
movss %xmm0, 0x4(%r14)
movss (%r13), %xmm0
movss %xmm0, 0x8(%r14)
movss (%rbp), %xmm0
movss %xmm0, 0xc(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13fd0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: Hsva_to_rgba
static int Hsva_to_rgba(lua_State *L)
    {
    nk_colorf_t color;
    if(echeckcolorf(L, 1, &color)) return argerror(L, 1);
    color = nk_hsva_colorf(color.r, color.g, color.b, color.a);
    return pushcolorf(L, &color);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x13360
testl %eax, %eax
je 0x5f2a8
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
jmp 0x5f2db
leaq 0x8(%rsp), %r14
movss (%r14), %xmm0
movss 0x4(%r14), %xmm1
movss 0x8(%r14), %xmm2
movss 0xc(%r14), %xmm3
callq 0x13580
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13fd0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: ValueGetter
static float ValueGetter(void* info_, int index)
    {
#define info ((cbinfo_t*)(info_))
#define L moonnuklear_L
    float val;
    lua_rawgeti(L, LUA_REGISTRYINDEX, info->ref);
    pushindex(L, index);
    if(lua_pcall(L, 1, 1, 0) != LUA_OK)
        { lua_error(L); return 0; }
    val = luaL_checknumber(L, -1);
    lua_pop(L, 1);
    return val;
#undef L
#undef info
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x25d00(%rip), %r14     # 0x84ff0
movq (%r14), %rax
movslq (%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r14), %rdi
movl %ebx, %esi
callq 0x142c0
movq (%r14), %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
movq (%r14), %rdi
testl %eax, %eax
je 0x5f333
callq 0x13960
xorps %xmm0, %xmm0
jmp 0x5f356
pushq $-0x1
popq %rsi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r14), %rdi
pushq $-0x2
popq %rsi
callq 0x12190
movss 0x4(%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/widgets.c
// Function: ItemGetter
static void ItemGetter(void* info_, int selected, const char** item)
    {
#define info ((cbinfo_t*)(info_))
#define L moonnuklear_L
    const char *s;
    lua_rawgeti(L, LUA_REGISTRYINDEX, info->ref);
    lua_pushinteger(L, selected+1);
    if(lua_pcall(L, 1, 1, 0) != LUA_OK)
        { lua_error(L); return; }
    if(info->item) Free(L, info->item);
    s = luaL_checkstring(L, -1);
    info->item = Strdup(L, s);
    *item = info->item;
    lua_pop(L, 1);
    return;
#undef L
#undef info
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x25c7c(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
movslq (%r14), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r15), %rdi
incl %ebp
movslq %ebp, %rsi
callq 0x12c20
movq (%r15), %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
testl %eax, %eax
je 0x5f3bc
movq (%r15), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13960
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x5f3cd
movq (%r15), %rdi
callq 0x13220
movq (%r15), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x12dd0
movq (%r15), %rdi
movq %rax, %rsi
callq 0x138b0
movq %rax, 0x8(%r14)
movq %rax, (%rbx)
movq (%r15), %rdi
pushq $-0x2
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12190
nopl (%rax)