LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/input.c
// Function: InputButton
static int InputButton(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_buttons button = checkbuttons(L, 2);
    int x = luaL_checkinteger(L, 3);
    int y = luaL_checkinteger(L, 4);
    int down = optboolean(L, 5, nk_false);
    nk_input_button(context, button, x, y, down);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7dbc2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x14ba0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq 0x13c90
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/input.c
// Function: InputScroll
static int InputScroll(lua_State *L)
    {
    nk_vec2_t scroll;
    nk_context_t *context = checkcontext(L, 1, NULL);
    scroll.x = luaL_checknumber(L, 2);
    scroll.y = luaL_checknumber(L, 3);
    nk_input_scroll(context, scroll);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x7db2b(%rip), %rcx     # 0xa7280
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x130f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x153d0
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/input.c
// Function: InputChar
static int InputChar(lua_State *L)
    {
    int arg = 2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    while(!lua_isnoneornil(L, arg))
        nk_input_char(context, luaL_checkinteger(L, arg++));
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x2, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7daaa(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x297fc
jmp 0x2982c
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x14070
movq 0x8(%rsp), %rdi
movsbl %al, %esi
callq 0x14bd0
jmp 0x297e0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/input.c
// Function: InputGlyph
static int InputGlyph(lua_State *L)
    {
    size_t len;
    nk_glyph glyph;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char* s = luaL_checklstring(L, 2, &len);
    if(len == 0 || len > NK_UTF_SIZE)
        return argerrorc(L, 2, ERR_LENGTH);
    memcpy(glyph, s, len);
    nk_input_glyph(context, glyph);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7da22(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x13df0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x29891
cmpq $0x4, 0x20(%rsp)
jbe 0x298bb
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x298e6
leaq 0x1c(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x14160
movq 0x10(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x13050
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/input.c
// Function: InputUnicode
static int InputUnicode(lua_State *L)
    {
    int arg = 2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    while(!lua_isnoneornil(L, arg))
        nk_input_unicode(context, luaL_checkinteger(L, arg++));
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x2, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d96a(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2993c
jmp 0x2996b
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x14070
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x149e0
jmp 0x29920
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_set_min_row_height
static int Layout_set_min_row_height(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float height = luaL_checknumber(L, 1);
    nk_layout_set_min_row_height(context, height);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d8c2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movss 0x4(%rsp), %xmm0
callq 0x14af0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_ratio_from_pixel
static int Layout_ratio_from_pixel(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float pixel_width = luaL_checknumber(L, 2);
    lua_pushnumber(L, nk_layout_ratio_from_pixel(context, pixel_width));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d7c2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movss 0x14(%rsp), %xmm0
callq 0x14ad0
movq 0x8(%rsp), %rdi
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_dynamic
static int Layout_row_dynamic(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float height = luaL_checknumber(L, 2);
    int cols = luaL_checkinteger(L, 3);
    nk_layout_row_dynamic(context, height, cols);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d742(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movss 0x4(%rsp), %xmm0
movl (%rsp), %esi
callq 0x13f60
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_static
static int Layout_row_static(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float height = luaL_checknumber(L, 2);
    int item_width = luaL_checkinteger(L, 3);
    int cols = luaL_checkinteger(L, 4);
    nk_layout_row_static(context, height, item_width, cols);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d6d2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movss 0x14(%rsp), %xmm0
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x14c70
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_begin
static int Layout_row_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_layout_format fmt = checklayoutformat(L, 2);
    float row_height = luaL_checknumber(L, 3);
    int cols = luaL_checkinteger(L, 4);
    nk_layout_row_begin(context, fmt, row_height, cols);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d642(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x6, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movss 0x10(%rsp), %xmm0
movl 0xc(%rsp), %edx
callq 0x13520
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_push
static int Layout_row_push(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float value = luaL_checknumber(L, 2);
    nk_layout_row_push(context, value);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d5b2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movss 0x4(%rsp), %xmm0
callq 0x14960
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row
static int Layout_row(lua_State *L)
    {
    ud_t *ud;
    int cols, err;
    nk_context_t *context = checkcontext(L, 1, &ud);
    enum nk_layout_format fmt = checklayoutformat(L, 2);
    float height = luaL_checknumber(L, 3);
    float *ratio = checkfloatlist(L, 4, &cols, &err);
    if(err) return argerrorc(L, 4, err);
    /* free the old list and replace it with the new one 
    *  (This is because it seems that nuklear retains the passed float*
    *  instead of making an internal copy. So, to avoid memory leaks, we
    *  store it the context's ud and free it the next time this function
    *  is called, or when the context itself is deleted.)
    */
    if(ud->ratio) Free(L, ud->ratio);
    ud->ratio = ratio;
    nk_layout_row(context, fmt, height, cols, ratio);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0x7d511(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x2c(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0x152f0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x28(%rsp)
je 0x29dfa
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %edi
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x29e55
movq 0x30(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29e1f
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x80(%rax), %rsi
callq 0x14230
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movss 0x18(%rsp), %xmm0
movl 0x2c(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0x13a80
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_template_begin
static int Layout_row_template_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float row_height = luaL_checknumber(L, 2);
    nk_layout_row_template_begin(context, row_height);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d402(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movss 0x4(%rsp), %xmm0
callq 0x151c0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_row_template_push_static
static int Layout_row_template_push_static(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float width = luaL_checknumber(L, 2);
    nk_layout_row_template_push_static(context, width);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d302(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movss 0x4(%rsp), %xmm0
callq 0x14360
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_begin
static int Layout_space_begin(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_layout_format fmt = checklayoutformat(L, 2);
    float height = luaL_checknumber(L, 3);
    int widget_count = luaL_checkinteger(L, 4);
    nk_layout_space_begin(context, fmt, height, widget_count);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d262(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x6, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movss 0x10(%rsp), %xmm0
movl 0xc(%rsp), %edx
callq 0x13d90
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_push
static int Layout_space_push(lua_State *L)
    {
    nk_rect_t bounds; 
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &bounds)) return argerror(L, 2);
    nk_layout_space_push(context, bounds);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d1d2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x2a106
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x2a124
movq 0x10(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x14e10
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_to_screen
static int Layout_space_to_screen(lua_State *L)
    {
    nk_vec2_t v1, v2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckvec2(L, 2, &v1)) return argerror(L, 2);
    v2 = nk_layout_space_to_screen(context, v1);
    return pushvec2(L, &v2);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7d092(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x15460
cmpl $0x0, %eax
je 0x2a244
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x2a277
movq 0x10(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x14670
movlpd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13760
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_to_local
static int Layout_space_to_local(lua_State *L)
    {
    nk_vec2_t v1, v2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckvec2(L, 2, &v1)) return argerror(L, 2);
    v2 = nk_layout_space_to_local(context, v1);
    return pushvec2(L, &v2);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7cfe2(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x15460
cmpl $0x0, %eax
je 0x2a2f4
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x2a327
movq 0x10(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x13810
movlpd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13760
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_rect_to_screen
static int Layout_space_rect_to_screen(lua_State *L)
    {
    nk_rect_t r1, r2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &r1)) return argerror(L, 2);
    r2 = nk_layout_space_rect_to_screen(context, r1);
    return pushrect(L, &r2);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7cf32(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x38(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x2a3a6
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x2a3ef
movq 0x20(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
callq 0x150e0
movlpd %xmm0, 0x10(%rsp)
movlpd %xmm1, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x137c0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/layout.c
// Function: Layout_space_rect_to_local
static int Layout_space_rect_to_local(lua_State *L)
    {
    nk_rect_t r1, r2;
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(echeckrect(L, 2, &r1)) return argerror(L, 2);
    r2 = nk_layout_space_rect_to_local(context, r1);
    return pushrect(L, &r2);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x7ce62(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x38(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x2a476
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x2a4bf
movq 0x20(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
callq 0x14270
movlpd %xmm0, 0x10(%rsp)
movlpd %xmm1, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x137c0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/main.c
// Function: luaopen_moonnuklear
int luaopen_moonnuklear(lua_State *L)
/* Lua calls this function to load the module */
    {
    moonnuklear_L = L;

    moonnuklear_utils_init(L);
    atexit(AtExit);

    lua_newtable(L); /* the nk table */

    /* add nk functions: */
    moonnuklear_open_versions(L);
    moonnuklear_open_enums(L);
    moonnuklear_open_flags(L);
    moonnuklear_open_tracing(L);
    moonnuklear_open_window(L);
    moonnuklear_open_layout(L);
    moonnuklear_open_widgets(L);
    moonnuklear_open_style(L);
    moonnuklear_open_context(L);
    moonnuklear_open_atlas(L);
    moonnuklear_open_font(L);
    moonnuklear_open_buffer(L);
    moonnuklear_open_image(L);
    moonnuklear_open_nine_slice(L);
    moonnuklear_open_cursor(L);
    moonnuklear_open_edit(L);
    moonnuklear_open_canvas(L);
    moonnuklear_open_panel(L);
    moonnuklear_open_input(L);

#if 0
    /* Add functions implemented in Lua @@ */
    lua_pushvalue(L, -1); lua_setglobal(L, "moonnuklear");
    if(luaL_dostring(L, "require('moonnuklear.utils')") != 0) lua_error(L);
    lua_pushnil(L);  lua_setglobal(L, "moonnuklear");
#endif

    return 1;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rcx
movq 0x9ab10(%rip), %rax     # 0xc4ff0
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0x15220
leaq 0xcd(%rip), %rdi        # 0x2a5c0
callq 0xa6a30
movq (%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movq (%rsp), %rdi
callq 0x13ef0
movq (%rsp), %rdi
callq 0x144d0
movq (%rsp), %rdi
callq 0x146d0
movq (%rsp), %rdi
callq 0x14090
movq (%rsp), %rdi
callq 0x13090
movq (%rsp), %rdi
callq 0x14500
movq (%rsp), %rdi
callq 0x14770
movq (%rsp), %rdi
callq 0x145f0
movq (%rsp), %rdi
callq 0x13bf0
movq (%rsp), %rdi
callq 0x137d0
movq (%rsp), %rdi
callq 0x13f90
movq (%rsp), %rdi
callq 0x13600
movq (%rsp), %rdi
callq 0x14520
movq (%rsp), %rdi
callq 0x14db0
movq (%rsp), %rdi
callq 0x13d60
movq (%rsp), %rdi
callq 0x14130
movq (%rsp), %rdi
callq 0x13150
movq (%rsp), %rdi
callq 0x13d00
movq (%rsp), %rdi
callq 0x14e90
movl $0x1, %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/nine_slice.c
// Function: NineSlice_info
static int NineSlice_info(lua_State *L)
    {
    ud_t *ud;
    nk_rect_t r;
    nk_nine_slice_t *nine_slice = checknine_slice(L, 1, &ud);
    if(IsNineSliceId(ud))
        lua_pushlightuserdata(L, nine_slice->img.handle.ptr);
    else
        lua_pushinteger(L, nine_slice->img.handle.id);
    lua_pushinteger(L, nine_slice->l);
    lua_pushinteger(L, nine_slice->t);
    lua_pushinteger(L, nine_slice->r);
    lua_pushinteger(L, nine_slice->b);
    if(!IsSubNineSlice(ud))
        return 5;
    lua_pushinteger(L, nine_slice->img.w);
    lua_pushinteger(L, nine_slice->img.h);
    r.x = nine_slice->img.region[0];
    r.y = nine_slice->img.region[1];
    r.w = nine_slice->img.region[2];
    r.h = nine_slice->img.region[3];
    pushrect(L, &r);
    return 8;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x7cb67(%rip), %rcx     # 0xa7256
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x200, %eax            # imm = 0x200
jne 0x2a721
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x14600
jmp 0x2a733
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
callq 0x13c50
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movzwl 0x1a(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movzwl 0x1c(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movzwl 0x1e(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x400, %eax            # imm = 0x400
je 0x2a7a8
movl $0x5, 0x34(%rsp)
jmp 0x2a835
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movzwl 0x8(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movzwl 0xa(%rax), %eax
movl %eax, %esi
callq 0x13c50
movq 0x8(%rsp), %rax
movzwl 0xc(%rax), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movzwl 0xe(%rax), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x10(%rax), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x12(%rax), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x137c0
movl $0x8, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/nine_slice.c
// Function: NewNineSlice
static int NewNineSlice(lua_State *L)
/* nine_slice = new_nine_slice(ptr|id, l, t, r, b) */
    { 
    nk_rect_t subregion;
    unsigned short l = luaL_checkinteger(L, 2);
    unsigned short t = luaL_checkinteger(L, 3);
    unsigned short r = luaL_checkinteger(L, 4);
    unsigned short b = luaL_checkinteger(L, 5);
    memset(&subregion, 0, sizeof(subregion));
    New(L, 0, 0, subregion, l, t, r, b);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x14070
movw %ax, 0xe(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movw %ax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x14070
movw %ax, 0xa(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x14070
movw %ax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movw 0xe(%rsp), %cx
movw 0xc(%rsp), %dx
movw 0xa(%rsp), %ax
movw 0x8(%rsp), %si
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
xorl %r8d, %r8d
movzwl %si, %r8d
movq %rsp, %rsi
movl %r8d, (%rsi)
movzwl %cx, %ecx
movzwl %dx, %r8d
movzwl %ax, %r9d
xorl %edx, %edx
movl %edx, %esi
callq 0x2aa50
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/nine_slice.c
// Function: NewSubNineSlice
static int NewSubNineSlice(lua_State *L)
/* nine_slice = new_subnine_slice(ptr|id, w, h, rect, l, t, r, b) */
    {
    ud_t *ud;
    nk_rect_t subregion;
    unsigned short w = luaL_checkinteger(L, 2);
    unsigned short h = luaL_checkinteger(L, 3);
    unsigned short l = luaL_checkinteger(L, 5);
    unsigned short t = luaL_checkinteger(L, 6);
    unsigned short r = luaL_checkinteger(L, 7);
    unsigned short b = luaL_checkinteger(L, 8);
    if(echeckrect(L, 4, &subregion)) return argerror(L, 4);
    ud = New(L, w, h, subregion, l, t, r, b);
    MarkSubNineSlice(ud);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x14070
movw %ax, 0x1e(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movw %ax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x14070
movw %ax, 0x1a(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x14070
movw %ax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x14070
movw %ax, 0x16(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x14070
movw %ax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x20(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x2a9cf
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x2aa43
movq 0x38(%rsp), %rdi
movw 0x1e(%rsp), %si
movw 0x1c(%rsp), %dx
movw 0x1a(%rsp), %cx
movw 0x18(%rsp), %r8w
movw 0x16(%rsp), %ax
movw 0x14(%rsp), %r9w
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movzwl %r9w, %r10d
movq %rsp, %r9
movl %r10d, (%r9)
movzwl %si, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %r8w, %r8d
movzwl %ax, %r9d
callq 0x2aa50
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movq 0x30(%rsp), %rax
movl %ecx, 0x70(%rax)
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/nine_slice.c
// Function: freenine_slice
static int freenine_slice(lua_State *L, ud_t *ud)
    {
    nk_nine_slice_t *nine_slice = (nk_nine_slice_t*)ud->handle;
    freechildren(L, CURSOR_MT, ud);
    if(!freeuserdata(L, ud, "nine_slice")) return 0;
    Free(L, nine_slice);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x7c456(%rip), %rsi     # 0xa70c2
callq 0x131f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x7c5e0(%rip), %rdx     # 0xa7262
callq 0x14f50
cmpl $0x0, %eax
jne 0x2ac96
movl $0x0, 0x24(%rsp)
jmp 0x2acad
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_recti
NK_API struct nk_rect
nk_recti(int x, int y, int w, int h)
{
    struct nk_rect r;
    r.x = (float)x;
    r.y = (float)y;
    r.w = (float)w;
    r.h = (float)h;
    return r;
}

// Assembly:
movl %edi, -0x14(%rsp)
movl %esi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl %ecx, -0x20(%rsp)
cvtsi2ssl -0x14(%rsp), %xmm0
movss %xmm0, -0x10(%rsp)
cvtsi2ssl -0x18(%rsp), %xmm0
movss %xmm0, -0xc(%rsp)
cvtsi2ssl -0x1c(%rsp), %xmm0
movss %xmm0, -0x8(%rsp)
cvtsi2ssl -0x20(%rsp), %xmm0
movss %xmm0, -0x4(%rsp)
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strlen
NK_API int
nk_strlen(const char *str)
{
    int siz = 0;
    NK_ASSERT(str);
    while (str && *str++ != '\0') siz++;
    return siz;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2b58c
movq 0x99a90(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x85e36(%rip), %rsi     # 0xb13a0
leaq 0x85e4d(%rip), %rdx     # 0xb13be
movl $0x19f7, %ecx           # imm = 0x19F7
movb $0x0, %al
callq 0x13ec0
movq 0x99a6c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2b58e
jmp 0x2b590
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xb(%rsp)
je 0x2b5bc
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x2b5c6
jmp 0x2b5d3
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2b590
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strtoi
NK_API int
nk_strtoi(const char *str, const char **endptr)
{
    int neg = 1;
    const char *p = str;
    int value = 0;

    NK_ASSERT(str);
    if (!str) return 0;

    /* skip whitespace */
    while (*p == ' ') p++;
    if (*p == '-') {
        neg = -1;
        p++;
    }
    while (*p && *p >= '0' && *p <= '9') {
        value = value * 10 + (int) (*p - '0');
        p++;
    }
    if (endptr)
        *endptr = p;
    return neg*value;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2b643
movq 0x999d9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x85d7f(%rip), %rsi     # 0xb13a0
leaq 0x85d96(%rip), %rdx     # 0xb13be
movl $0x1a02, %ecx           # imm = 0x1A02
movb $0x0, %al
callq 0x13ec0
movq 0x999b5(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2b645
cmpq $0x0, 0x28(%rsp)
jne 0x2b65a
movl $0x0, 0x34(%rsp)
jmp 0x2b728
jmp 0x2b65c
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2b679
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b65c
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2b69c
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b69e
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xb(%rsp)
je 0x2b6d6
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, 0xb(%rsp)
jl 0x2b6d6
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x2b6e0
jmp 0x2b706
imull $0xa, 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b69e
cmpq $0x0, 0x20(%rsp)
je 0x2b71b
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %eax
imull 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stricmp
NK_API int
nk_stricmp(const char *s1, const char *s2)
{
    nk_int c1,c2,d;
    do {
        c1 = *s1++;
        c2 = *s2++;
        d = c1 - c2;
        while (d) {
            if (c1 <= 'Z' && c1 >= 'A') {
                d += ('a' - 'A');
                if (!d) break;
            }
            if (c2 <= 'Z' && c2 >= 'A') {
                d -= ('a' - 'A');
                if (!d) break;
            }
            return ((d >= 0) << 1) - 1;
        }
    } while (c1);
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rsp)
movsbl (%rax), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
subl -0x20(%rsp), %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
je 0x2bb8d
cmpl $0x5a, -0x1c(%rsp)
jg 0x2bb51
cmpl $0x41, -0x1c(%rsp)
jl 0x2bb51
movl -0x24(%rsp), %eax
addl $0x20, %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
jne 0x2bb4f
jmp 0x2bb8d
jmp 0x2bb51
cmpl $0x5a, -0x20(%rsp)
jg 0x2bb75
cmpl $0x41, -0x20(%rsp)
jl 0x2bb75
movl -0x24(%rsp), %eax
subl $0x20, %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
jne 0x2bb73
jmp 0x2bb8d
jmp 0x2bb75
cmpl $0x0, -0x24(%rsp)
setge %al
andb $0x1, %al
movzbl %al, %eax
shll %eax
subl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2bba2
jmp 0x2bb8f
cmpl $0x0, -0x1c(%rsp)
jne 0x2baea
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stricmpn
NK_API int
nk_stricmpn(const char *s1, const char *s2, int n)
{
    int c1,c2,d;
    NK_ASSERT(n >= 0);
    do {
        c1 = *s1++;
        c2 = *s2++;
        if (!n--) return 0;

        d = c1 - c2;
        while (d) {
            if (c1 <= 'Z' && c1 >= 'A') {
                d += ('a' - 'A');
                if (!d) break;
            }
            if (c2 <= 'Z' && c2 >= 'A') {
                d -= ('a' - 'A');
                if (!d) break;
            }
            return ((d >= 0) << 1) - 1;
        }
    } while (c1);
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x2bbfc
movq 0x99420(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x857c6(%rip), %rsi     # 0xb13a0
leaq 0x857dd(%rip), %rdx     # 0xb13be
movl $0x1a6f, %ecx           # imm = 0x1A6F
movb $0x0, %al
callq 0x13ec0
movq 0x993fc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2bbfe
jmp 0x2bc00
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movsbl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x0, %eax
jne 0x2bc4c
movl $0x0, 0x24(%rsp)
jmp 0x2bccb
movl 0x8(%rsp), %eax
subl 0x4(%rsp), %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x2bcb6
cmpl $0x5a, 0x8(%rsp)
jg 0x2bc7e
cmpl $0x41, 0x8(%rsp)
jl 0x2bc7e
movl (%rsp), %eax
addl $0x20, %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x2bc7c
jmp 0x2bcb6
jmp 0x2bc7e
cmpl $0x5a, 0x4(%rsp)
jg 0x2bc9f
cmpl $0x41, 0x4(%rsp)
jl 0x2bc9f
movl (%rsp), %eax
subl $0x20, %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x2bc9d
jmp 0x2bcb6
jmp 0x2bc9f
cmpl $0x0, (%rsp)
setge %al
andb $0x1, %al
movzbl %al, %eax
shll %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2bccb
jmp 0x2bcb8
cmpl $0x0, 0x8(%rsp)
jne 0x2bc00
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strfilter
NK_API int
nk_strfilter(const char *text, const char *regexp)
{
    /*
    c    matches any literal character c
    .    matches any single character
    ^    matches the beginning of the input string
    $    matches the end of the input string
    *    matches zero or more occurrences of the previous character*/
    if (regexp[0] == '^')
        return nk_str_match_here(regexp+1, text);
    do {    /* must look even if string is empty */
        if (nk_str_match_here(regexp, text))
            return 1;
    } while (*text++ != '\0');
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x2bd11
movq (%rsp), %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
callq 0x2bd60
movl %eax, 0x14(%rsp)
jmp 0x2bd53
jmp 0x2bd13
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2bd60
cmpl $0x0, %eax
je 0x2bd30
movl $0x1, 0x14(%rsp)
jmp 0x2bd53
jmp 0x2bd32
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2bd13
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_match_here
NK_INTERN int
nk_str_match_here(const char *regexp, const char *text)
{
    if (regexp[0] == '\0')
        return 1;
    if (regexp[1] == '*')
        return nk_str_match_star(regexp[0], regexp+2, text);
    if (regexp[0] == '$' && regexp[1] == '\0')
        return *text == '\0';
    if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
        return nk_str_match_here(regexp+1, text+1);
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2bd87
movl $0x1, 0x14(%rsp)
jmp 0x2be3b
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x2bdb8
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
movq 0x8(%rsp), %rsi
addq $0x2, %rsi
movq (%rsp), %rdx
callq 0x7ca40
movl %eax, 0x14(%rsp)
jmp 0x2be3b
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x2bdeb
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x2bdeb
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x2be3b
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2be33
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x2be17
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
movq (%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2be33
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
movq (%rsp), %rsi
addq $0x1, %rsi
callq 0x2bd60
movl %eax, 0x14(%rsp)
jmp 0x2be3b
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgb_factor
NK_API struct nk_color
nk_rgb_factor(struct nk_color col, const float factor)
{
    if (factor == 1.0f)
        return col;
    col.r = (nk_byte)(col.r * factor);
    col.g = (nk_byte)(col.g * factor);
    col.b = (nk_byte)(col.b * factor);
    return col;
}

// Assembly:
movl %edi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movss -0xc(%rsp), %xmm0
movss 0x80e70(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jne 0x2c689
jp 0x2c689
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x2c6e2
movzbl -0x8(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x8(%rsp)
movzbl -0x7(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x7(%rsp)
movzbl -0x6(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x6(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgba
NK_API struct nk_color
nk_rgba(int r, int g, int b, int a)
{
    struct nk_color ret;
    ret.r = (nk_byte)NK_CLAMP(0, r, 255);
    ret.g = (nk_byte)NK_CLAMP(0, g, 255);
    ret.b = (nk_byte)NK_CLAMP(0, b, 255);
    ret.a = (nk_byte)NK_CLAMP(0, a, 255);
    return ret;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
cmpl $0xff, -0x8(%rsp)
jge 0x2c714
movl -0x8(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x2c71f
movl $0xff, %eax
movl %eax, -0x18(%rsp)
jmp 0x2c71f
movl -0x18(%rsp), %eax
cmpl $0x0, %eax
jge 0x2c730
xorl %eax, %eax
movl %eax, -0x1c(%rsp)
jmp 0x2c757
cmpl $0xff, -0x8(%rsp)
jge 0x2c744
movl -0x8(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x2c74f
movl $0xff, %eax
movl %eax, -0x20(%rsp)
jmp 0x2c74f
movl -0x20(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movb %al, -0x4(%rsp)
cmpl $0xff, -0xc(%rsp)
jge 0x2c773
movl -0xc(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x2c77e
movl $0xff, %eax
movl %eax, -0x24(%rsp)
jmp 0x2c77e
movl -0x24(%rsp), %eax
cmpl $0x0, %eax
jge 0x2c78f
xorl %eax, %eax
movl %eax, -0x28(%rsp)
jmp 0x2c7b6
cmpl $0xff, -0xc(%rsp)
jge 0x2c7a3
movl -0xc(%rsp), %eax
movl %eax, -0x2c(%rsp)
jmp 0x2c7ae
movl $0xff, %eax
movl %eax, -0x2c(%rsp)
jmp 0x2c7ae
movl -0x2c(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
movb %al, -0x3(%rsp)
cmpl $0xff, -0x10(%rsp)
jge 0x2c7d2
movl -0x10(%rsp), %eax
movl %eax, -0x30(%rsp)
jmp 0x2c7dd
movl $0xff, %eax
movl %eax, -0x30(%rsp)
jmp 0x2c7dd
movl -0x30(%rsp), %eax
cmpl $0x0, %eax
jge 0x2c7ee
xorl %eax, %eax
movl %eax, -0x34(%rsp)
jmp 0x2c815
cmpl $0xff, -0x10(%rsp)
jge 0x2c802
movl -0x10(%rsp), %eax
movl %eax, -0x38(%rsp)
jmp 0x2c80d
movl $0xff, %eax
movl %eax, -0x38(%rsp)
jmp 0x2c80d
movl -0x38(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
movb %al, -0x2(%rsp)
cmpl $0xff, -0x14(%rsp)
jge 0x2c831
movl -0x14(%rsp), %eax
movl %eax, -0x3c(%rsp)
jmp 0x2c83c
movl $0xff, %eax
movl %eax, -0x3c(%rsp)
jmp 0x2c83c
movl -0x3c(%rsp), %eax
cmpl $0x0, %eax
jge 0x2c84d
xorl %eax, %eax
movl %eax, -0x40(%rsp)
jmp 0x2c874
cmpl $0xff, -0x14(%rsp)
jge 0x2c861
movl -0x14(%rsp), %eax
movl %eax, -0x44(%rsp)
jmp 0x2c86c
movl $0xff, %eax
movl %eax, -0x44(%rsp)
jmp 0x2c86c
movl -0x44(%rsp), %eax
movl %eax, -0x40(%rsp)
movl -0x40(%rsp), %eax
movb %al, -0x1(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgb_hex
NK_API struct nk_color
nk_rgb_hex(const char *rgb)
{
    struct nk_color col;
    const char *c = rgb;
    if (*c == '#') c++;
    col.r = (nk_byte)nk_parse_hex(c, 2);
    col.g = (nk_byte)nk_parse_hex(c+2, 2);
    col.b = (nk_byte)nk_parse_hex(c+4, 2);
    col.a = 255;
    return col;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x2c8ba
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x14(%rsp)
movq (%rsp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x15(%rsp)
movq (%rsp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x16(%rsp)
movb $-0x1, 0x17(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_parse_hex
NK_INTERN int
nk_parse_hex(const char *p, int length)
{
    int i = 0;
    int len = 0;
    while (len < length) {
        i <<= 4;
        if (p[len] >= 'a' && p[len] <= 'f')
            i += ((p[len] - 'a') + 10);
        else if (p[len] >= 'A' && p[len] <= 'F')
            i += ((p[len] - 'A') + 10);
        else i += (p[len] - '0');
        len++;
    }
    return i;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x2c9f5
movl -0x10(%rsp), %eax
shll $0x4, %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x2c986
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
jg 0x2c986
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x61, %eax
addl $0xa, %eax
addl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
jmp 0x2c9e5
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x2c9ca
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jg 0x2c9ca
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x41, %eax
addl $0xa, %eax
addl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
jmp 0x2c9e3
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
addl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
jmp 0x2c9e5
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2c929
movl -0x10(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgba_hex
NK_API struct nk_color
nk_rgba_hex(const char *rgb)
{
    struct nk_color col;
    const char *c = rgb;
    if (*c == '#') c++;
    col.r = (nk_byte)nk_parse_hex(c, 2);
    col.g = (nk_byte)nk_parse_hex(c+2, 2);
    col.b = (nk_byte)nk_parse_hex(c+4, 2);
    col.a = (nk_byte)nk_parse_hex(c+6, 2);
    return col;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x2ca2a
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x14(%rsp)
movq (%rsp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x15(%rsp)
movq (%rsp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x16(%rsp)
movq (%rsp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
callq 0x2c910
movb %al, 0x17(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)