LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x63ff9(%rip), %rax     # 0x86ff0
movq %rdi, (%rax)
callq 0x13f70
leaq 0xb0(%rip), %rdi        # 0x230b6
callq 0x667f0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movq %rbx, %rdi
callq 0x12db0
movq %rbx, %rdi
callq 0x13340
movq %rbx, %rdi
callq 0x13510
movq %rbx, %rdi
callq 0x12f50
movq %rbx, %rdi
callq 0x12080
movq %rbx, %rdi
callq 0x13370
movq %rbx, %rdi
callq 0x13590
movq %rbx, %rdi
callq 0x13440
movq %rbx, %rdi
callq 0x12b00
movq %rbx, %rdi
callq 0x12720
movq %rbx, %rdi
callq 0x12e60
movq %rbx, %rdi
callq 0x12580
movq %rbx, %rdi
callq 0x13390
movq %rbx, %rdi
callq 0x13b60
movq %rbx, %rdi
callq 0x12c50
movq %rbx, %rdi
callq 0x12fe0
movq %rbx, %rdi
callq 0x12130
movq %rbx, %rdi
callq 0x12bf0
movq %rbx, %rdi
callq 0x13c50
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x440da(%rip), %rcx     # 0x67256
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x120d0
movq %rax, %r14
movq (%r15), %rax
testb $0x2, 0x71(%rax)
jne 0x231a7
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
jmp 0x231b2
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x13450
movzwl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0x1a(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0x1e(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movq 0x8(%rsp), %rcx
movl $0x5, %eax
testb $0x4, 0x71(%rcx)
je 0x23236
movzwl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movq 0xc(%r14), %xmm0
pxor %xmm1, %xmm1
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12710
movl $0x8, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x2, %esi
callq 0x12f30
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12f30
movq %rax, %r13
movq %rbx, %rdi
movl $0x7, %esi
callq 0x12f30
movq %rax, %rbp
movq %rbx, %rdi
movl $0x8, %esi
callq 0x12f30
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x139f0
testl %eax, %eax
je 0x2336b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x233b2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %r14d
movl %r14d, (%rsp)
movq 0x10(%rsp), %rsi
andl %eax, %esi
andl %eax, %r15d
andl %eax, %r12d
andl %eax, %r13d
andl %eax, %ebp
movq %rbx, %rdi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movl %ebp, %r9d
callq 0x233c1
orb $0x4, 0x71(%rax)
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/nine_slice.c
// Function: New
static ud_t* New(lua_State *L, unsigned short w, unsigned short h, nk_rect_t subregion, unsigned short l, unsigned short t, unsigned short r, unsigned short b)
    {
    ud_t *ud;
    nk_nine_slice_t *nine_slice;
    int id = 0;
    void *ptr = NULL;

    if(lua_type(L, 1) == LUA_TLIGHTUSERDATA)
        ptr = checklightuserdata(L, 1);
    else
        id = luaL_checkinteger(L, 1);

    nine_slice = (nk_nine_slice_t*)Malloc(L, sizeof(nk_nine_slice_t));
    if(ptr) { nine_slice->img.handle.ptr = ptr; } else { nine_slice->img.handle.id = id; }
    nine_slice->l = l;
    nine_slice->t = t;
    nine_slice->r = r;
    nine_slice->b = b;
    nine_slice->img.w = w;
    nine_slice->img.h = h;
    nine_slice->img.region[0] = (unsigned short)subregion.x;
    nine_slice->img.region[1] = (unsigned short)subregion.y;
    nine_slice->img.region[2] = (unsigned short)subregion.w;
    nine_slice->img.region[3] = (unsigned short)subregion.h;
    ud = newuserdata(L, nine_slice, NINE_SLICE_MT, "nine_slice");
    ud->parent_ud = NULL;
    ud->destructor = freenine_slice;
    if(!ptr) MarkNineSliceId(ud);
    return ud;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r15d
movl %ecx, %r13d
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x2, %eax
jne 0x23425
callq 0x13800
movq %rax, %rbp
movl $0x20, %esi
movq %rbx, %rdi
callq 0x13a00
testq %rbp, %rbp
je 0x2343c
movq %rbp, (%rax)
xorl %ebp, %ebp
jmp 0x23443
callq 0x12f30
movq %rax, %rbp
movl $0x20, %esi
movq %rbx, %rdi
callq 0x13a00
jmp 0x2343e
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, %bpl
movw %r13w, 0x18(%rax)
movw %r15w, 0x1a(%rax)
movl 0xc(%rsp), %ecx
movw %cx, 0x1c(%rax)
movzwl 0x70(%rsp), %ecx
movw %cx, 0x1e(%rax)
movw %r12w, 0x8(%rax)
movw %r14w, 0xa(%rax)
movaps 0x10(%rsp), %xmm0
unpcklpd 0x20(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
pshufhw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,6,6,7]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
movq %xmm0, 0xc(%rax)
leaq 0x43dc4(%rip), %rdx     # 0x67256
leaq 0x43dc9(%rip), %rcx     # 0x67262
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x1c(%rip), %rcx        # 0x234cf
movq %rcx, 0x8(%rax)
testb %bpl, %bpl
je 0x234c0
orb $0x2, 0x71(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x43bde(%rip), %rsi     # 0x670c2
movq %r15, %rdx
callq 0x121c0
leaq 0x43d6f(%rip), %rdx     # 0x67262
movq %r14, %rdi
movq %r15, %rsi
callq 0x13d00
testl %eax, %eax
je 0x2350d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x236d8
cmpb $0x0, (%rdi)
je 0x23708
xorl %ebx, %ebx
cmpb $0x0, 0x1(%rdi,%rbx)
leaq 0x1(%rbx), %rbx
jne 0x236cb
jmp 0x2370a
movq 0x63911(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x4d6b3(%rip), %rsi     # 0x70d9c
leaq 0x4d6ca(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x19f7, %ecx           # imm = 0x19F7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x2370a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x23737
incq %rdi
movzbl -0x1(%rdi), %ecx
cmpl $0x20, %ecx
je 0x2371d
cmpl $0x2d, %ecx
jne 0x23767
movb (%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2376f
movq 0x638b2(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x4d654(%rip), %rsi     # 0x70d9c
leaq 0x4d66b(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x1a02, %ecx           # imm = 0x1A02
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x237a0
decq %rdi
movl $0x1, %eax
leal -0x30(%rcx), %edx
xorl %ebx, %ebx
cmpb $0x9, %dl
ja 0x23795
xorl %ebx, %ebx
leal (%rbx,%rbx,4), %edx
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rdx,2), %ebx
movb 0x1(%rdi), %cl
incq %rdi
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x2377b
testq %rsi, %rsi
je 0x2379d
movq %rdi, (%rsi)
imull %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_strtod
NK_API double
nk_strtod(const char *str, const char **endptr)
{
    double m;
    double neg = 1.0;
    const char *p = str;
    double value = 0;
    double number = 0;

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

    /* skip whitespace */
    while (*p == ' ') p++;
    if (*p == '-') {
        neg = -1.0;
        p++;
    }

    while (*p && *p != '.' && *p != 'e') {
        value = value * 10.0 + (double) (*p - '0');
        p++;
    }

    if (*p == '.') {
        p++;
        for(m = 0.1; *p && *p != 'e'; p++ ) {
            value = value + (double) (*p - '0') * m;
            m *= 0.1;
        }
    }
    if (*p == 'e') {
        int i, pow, div;
        p++;
        if (*p == '-') {
            div = nk_true;
            p++;
        } else if (*p == '+') {
            div = nk_false;
            p++;
        } else div = nk_false;

        for (pow = 0; *p; p++)
            pow = pow * 10 + (int) (*p - '0');

        for (m = 1.0, i = 0; i < pow; i++)
            m *= 10.0;

        if (div)
            value /= m;
        else value *= m;
    }
    number = value * neg;
    if (endptr)
        *endptr = p;
    return number;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
jne 0x237e8
movq 0x63839(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x4d5db(%rip), %rsi     # 0x70d9c
leaq 0x4d5f2(%rip), %rdx     # 0x70dba
movl $0x1a1c, %ecx           # imm = 0x1A1C
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
xorpd %xmm0, %xmm0
jmp 0x2390c
incq %rdi
movzbl (%rdi), %eax
cmpl $0x20, %eax
je 0x237e5
cmpl $0x2d, %eax
jne 0x23802
incq %rdi
movsd 0x4a178(%rip), %xmm0    # 0x6d978
jmp 0x2380a
movsd 0x4a176(%rip), %xmm0    # 0x6d980
xorpd %xmm1, %xmm1
movsd 0x4a17a(%rip), %xmm2    # 0x6d990
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2387a
cmpl $0x65, %eax
je 0x2387a
cmpl $0x2e, %eax
je 0x23841
movsbl %al, %eax
addl $-0x30, %eax
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
incq %rdi
jmp 0x23816
incq %rdi
movsd 0x4a13c(%rip), %xmm3    # 0x6d988
movapd %xmm3, %xmm4
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2387a
cmpl $0x65, %eax
je 0x2387a
movsbl %al, %eax
addl $-0x30, %eax
xorps %xmm5, %xmm5
cvtsi2sd %eax, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm1
mulsd %xmm3, %xmm4
incq %rdi
jmp 0x23850
cmpb $0x65, %al
jne 0x238f7
leaq 0x1(%rdi), %rax
movb 0x1(%rdi), %cl
leaq 0x2(%rdi), %rdx
leal -0x2b(%rcx), %r8d
xorl %r9d, %r9d
testb $-0x3, %r8b
cmoveq %rdx, %rax
sete %r9b
movb 0x1(%r9,%rdi), %dl
movsd 0x4a0d7(%rip), %xmm3    # 0x6d980
testb %dl, %dl
je 0x238ec
xorl %r9d, %r9d
movl %r9d, %edi
leal (%rdi,%rdi,4), %r9d
movsbl %dl, %r8d
leal (%r8,%r9,2), %r9d
addl $-0x30, %r9d
movb 0x1(%rax), %dl
incq %rax
testb %dl, %dl
jne 0x238b0
testl %r9d, %r9d
jle 0x238ec
leal (%rdi,%rdi,4), %edx
leal (%r8,%rdx,2), %edx
addl $-0x30, %edx
movsd 0x4a09c(%rip), %xmm3    # 0x6d980
mulsd %xmm2, %xmm3
decl %edx
jne 0x238e4
cmpb $0x2d, %cl
je 0x238fc
mulsd %xmm3, %xmm1
jmp 0x23900
movq %rdi, %rax
jmp 0x23900
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
testq %rsi, %rsi
je 0x2390c
movq %rax, (%rsi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %ecx, %ecx
movsbl (%rdi,%rcx), %edx
movsbl (%rsi,%rcx), %r8d
movl %edx, %eax
subl %r8d, %eax
je 0x2394a
leal -0x41(%rdx), %r9d
cmpb $0x19, %r9b
ja 0x2393b
addl $0x20, %eax
je 0x2394a
addb $-0x41, %r8b
cmpb $0x19, %r8b
ja 0x23954
addl $-0x20, %eax
jne 0x23954
incq %rcx
testb %dl, %dl
jne 0x2391c
xorl %eax, %eax
retq
sarl $0x1f, %eax
orl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jns 0x2399a
movq 0x6367b(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x4d41d(%rip), %rsi     # 0x70d9c
leaq 0x4d434(%rip), %rdx     # 0x70dba
movl $0x1a6f, %ecx           # imm = 0x1A6F
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movl %ebp, %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpl %edx, %ecx
je 0x239e5
movsbl (%r14,%rdx), %edi
movsbl (%rbx,%rdx), %r8d
movl %edi, %esi
subl %r8d, %esi
je 0x239d3
leal -0x41(%rdi), %r9d
cmpb $0x19, %r9b
ja 0x239c4
addl $0x20, %esi
je 0x239d3
addb $-0x41, %r8b
cmpb $0x19, %r8b
ja 0x239dd
addl $-0x20, %esi
jne 0x239dd
incq %rdx
testb %dil, %dil
jne 0x239a0
jmp 0x239e5
sarl $0x1f, %esi
orl $0x1, %esi
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x5e, (%rsi)
jne 0x23a11
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23a3b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23a3b
testl %eax, %eax
jne 0x23a2e
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x23a11
xorl %eax, %eax
jmp 0x23a33
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x23ab8
movq %rsi, %rbx
movq %rdi, %r14
addq $0x2, %r14
movb -0x1(%r14), %cl
cmpb $0x2a, %cl
je 0x23aa9
movl %ebp, %eax
xorb $0x24, %al
movb (%rbx), %dl
orb %cl, %al
je 0x23ac2
xorl %eax, %eax
testb %dl, %dl
je 0x23abd
cmpb $0x2e, %bpl
setne %sil
cmpb %dl, %bpl
setne %dl
testb %dl, %sil
jne 0x23abd
incq %rbx
incq %r14
movl %ecx, %ebp
testb %cl, %cl
jne 0x23a51
jmp 0x23ab8
cmpb $0x2e, %bpl
sete %cl
movb (%rbx), %sil
cmpb %bpl, %sil
sete %dl
xorl %eax, %eax
testb %sil, %sil
je 0x23abd
incq %rbx
orb %dl, %cl
je 0x23abd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23a3b
testl %eax, %eax
je 0x23a8b
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
testb %dl, %dl
sete %al
jmp 0x23abd
// File: /workspace/github_c_makefile_star2_O3/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, %eax
shrl $0x8, %eax
movl %edi, %ecx
shrl $0x10, %ecx
ucomiss 0x49a05(%rip), %xmm0    # 0x6d8a4
jne 0x23ea7
jp 0x23ea7
movl %edi, %edx
jmp 0x23ede
movl $0xff, %esi
movl %edi, %edx
andl %esi, %edx
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
andl %esi, %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %esi, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
andl $0xff000000, %edi       # imm = 0xFF000000
movzbl %cl, %ecx
shll $0x10, %ecx
orl %edi, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movzbl %dl, %eax
orl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpb $0x23, (%rdi)
sete %al
addq %rdi, %rax
xorl %edi, %edi
movb $0x1, %sil
xorl %ecx, %ecx
movzbl (%rax,%rdi), %edx
leal -0x61(%rdx), %edi
cmpb $0x5, %dil
ja 0x23f62
addl $-0x57, %edx
jmp 0x23f73
leal -0x41(%rdx), %edi
cmpb $0x5, %dil
ja 0x23f70
addl $-0x37, %edx
jmp 0x23f73
addl $-0x30, %edx
shll $0x4, %ecx
addl %edx, %ecx
movl $0x1, %edi
xorl %edx, %edx
testb $0x1, %sil
movl $0x0, %esi
jne 0x23f50
movb $0x1, %dil
xorl %r8d, %r8d
movzbl 0x2(%rax,%r8), %esi
leal -0x61(%rsi), %r8d
cmpb $0x5, %r8b
ja 0x23fa5
addl $-0x57, %esi
jmp 0x23fb7
leal -0x41(%rsi), %r8d
cmpb $0x5, %r8b
ja 0x23fb4
addl $-0x37, %esi
jmp 0x23fb7
addl $-0x30, %esi
shll $0x4, %edx
addl %esi, %edx
movl $0x1, %r8d
xorl %esi, %esi
testb $0x1, %dil
movl $0x0, %edi
jne 0x23f90
movb $0x1, %dil
xorl %r8d, %r8d
movzbl 0x4(%rax,%r8), %r8d
leal -0x61(%r8), %r9d
cmpb $0x5, %r9b
ja 0x23feb
addl $-0x57, %r8d
jmp 0x23fff
leal -0x41(%r8), %r9d
cmpb $0x5, %r9b
ja 0x23ffb
addl $-0x37, %r8d
jmp 0x23fff
addl $-0x30, %r8d
shll $0x4, %esi
addl %r8d, %esi
movl $0x1, %r8d
testb $0x1, %dil
movl $0x0, %edi
jne 0x23fd5
shll $0x10, %esi
shll $0x8, %edx
movzwl %dx, %edx
orl %esi, %edx
movzbl %cl, %eax
orl %edx, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %ecx, %ecx
cmpb $0x23, (%rdi)
sete %cl
addq %rdi, %rcx
xorl %edi, %edi
movb $0x1, %sil
xorl %eax, %eax
movzbl (%rcx,%rdi), %edx
leal -0x61(%rdx), %edi
cmpb $0x5, %dil
ja 0x24050
addl $-0x57, %edx
jmp 0x24061
leal -0x41(%rdx), %edi
cmpb $0x5, %dil
ja 0x2405e
addl $-0x37, %edx
jmp 0x24061
addl $-0x30, %edx
shll $0x4, %eax
addl %edx, %eax
movl $0x1, %edi
xorl %edx, %edx
testb $0x1, %sil
movl $0x0, %esi
jne 0x2403e
movb $0x1, %dil
xorl %r8d, %r8d
movzbl 0x2(%rcx,%r8), %esi
leal -0x61(%rsi), %r8d
cmpb $0x5, %r8b
ja 0x24093
addl $-0x57, %esi
jmp 0x240a5
leal -0x41(%rsi), %r8d
cmpb $0x5, %r8b
ja 0x240a2
addl $-0x37, %esi
jmp 0x240a5
addl $-0x30, %esi
shll $0x4, %edx
addl %esi, %edx
movl $0x1, %r8d
xorl %esi, %esi
testb $0x1, %dil
movl $0x0, %edi
jne 0x2407e
movb $0x1, %r8b
xorl %r9d, %r9d
movzbl 0x4(%rcx,%r9), %edi
leal -0x61(%rdi), %r9d
cmpb $0x5, %r9b
ja 0x240d8
addl $-0x57, %edi
jmp 0x240ea
leal -0x41(%rdi), %r9d
cmpb $0x5, %r9b
ja 0x240e7
addl $-0x37, %edi
jmp 0x240ea
addl $-0x30, %edi
shll $0x4, %esi
addl %edi, %esi
movl $0x1, %r9d
xorl %edi, %edi
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x240c3
movb $0x1, %r8b
xorl %r9d, %r9d
movzbl 0x6(%rcx,%r9), %r9d
leal -0x61(%r9), %r10d
cmpb $0x5, %r10b
ja 0x2411f
addl $-0x57, %r9d
jmp 0x24133
leal -0x41(%r9), %r10d
cmpb $0x5, %r10b
ja 0x2412f
addl $-0x37, %r9d
jmp 0x24133
addl $-0x30, %r9d
shll $0x4, %edi
addl %r9d, %edi
movl $0x1, %r9d
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x24109
shll $0x18, %edi
movl $0xff, %ecx
andl %ecx, %esi
shll $0x10, %esi
orl %edi, %esi
shll $0x8, %edx
movzwl %dx, %edx
orl %esi, %edx
andl %ecx, %eax
orl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hex_rgba
NK_API void
nk_color_hex_rgba(char *output, struct nk_color col)
{
    #define NK_TO_HEX(i) ((i) <= 9 ? '0' + (i): 'A' - 10 + (i))
    output[0] = (char)NK_TO_HEX((col.r & 0xF0) >> 4);
    output[1] = (char)NK_TO_HEX((col.r & 0x0F));
    output[2] = (char)NK_TO_HEX((col.g & 0xF0) >> 4);
    output[3] = (char)NK_TO_HEX((col.g & 0x0F));
    output[4] = (char)NK_TO_HEX((col.b & 0xF0) >> 4);
    output[5] = (char)NK_TO_HEX((col.b & 0x0F));
    output[6] = (char)NK_TO_HEX((col.a & 0xF0) >> 4);
    output[7] = (char)NK_TO_HEX((col.a & 0x0F));
    output[8] = '\0';
    #undef NK_TO_HEX
}

// Assembly:
movl %esi, %edx
shrl $0x8, %edx
movl %esi, %ecx
shrl $0x10, %ecx
movl %esi, %eax
shrl $0x18, %eax
movl %esi, %r8d
shrl $0x4, %r8d
movl %esi, %r9d
shrl $0xc, %r9d
movd %edx, %xmm0
movd %r9d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd %esi, %xmm0
movd %r8d, %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
pand 0x49366(%rip), %xmm2    # 0x6d510
movdqa %xmm2, %xmm0
pcmpgtd 0x4936a(%rip), %xmm0    # 0x6d520
movdqa 0x49372(%rip), %xmm1    # 0x6d530
por %xmm2, %xmm1
paddd 0x49376(%rip), %xmm2    # 0x6d540
pand %xmm0, %xmm2
pandn %xmm1, %xmm0
por %xmm2, %xmm0
packuswb %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, (%rdi)
movl %esi, %edx
shrl $0x14, %edx
andl $0xf, %edx
leal 0x37(%rdx), %r8d
leal 0x30(%rdx), %r9d
cmpl $0xa, %edx
movzbl %r9b, %edx
movzbl %r8b, %r8d
cmovbl %edx, %r8d
movb %r8b, 0x4(%rdi)
andl $0xf, %ecx
leal 0x37(%rcx), %edx
leal 0x30(%rcx), %r8d
cmpl $0xa, %ecx
movzbl %r8b, %ecx
movzbl %dl, %edx
cmovbl %ecx, %edx
movl %esi, %ecx
shrl $0x1c, %ecx
leal 0x37(%rcx), %r8d
orb $0x30, %cl
cmpl $0xa0000000, %esi       # imm = 0xA0000000
movzbl %cl, %ecx
movzbl %r8b, %esi
cmovbl %ecx, %esi
movb %dl, 0x5(%rdi)
movb %sil, 0x6(%rdi)
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edx
cmpl $0xa, %eax
movzbl %dl, %eax
movzbl %cl, %ecx
cmovbl %eax, %ecx
movb %cl, 0x7(%rdi)
movb $0x0, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hex_rgb
NK_API void
nk_color_hex_rgb(char *output, struct nk_color col)
{
    #define NK_TO_HEX(i) ((i) <= 9 ? '0' + (i): 'A' - 10 + (i))
    output[0] = (char)NK_TO_HEX((col.r & 0xF0) >> 4);
    output[1] = (char)NK_TO_HEX((col.r & 0x0F));
    output[2] = (char)NK_TO_HEX((col.g & 0xF0) >> 4);
    output[3] = (char)NK_TO_HEX((col.g & 0x0F));
    output[4] = (char)NK_TO_HEX((col.b & 0xF0) >> 4);
    output[5] = (char)NK_TO_HEX((col.b & 0x0F));
    output[6] = '\0';
    #undef NK_TO_HEX
}

// Assembly:
movl %esi, %ecx
shrl $0x8, %ecx
movl %esi, %eax
shrl $0x10, %eax
movl %esi, %edx
shrl $0x4, %edx
movl %esi, %r8d
shrl $0xc, %r8d
movd %ecx, %xmm0
movd %r8d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd %esi, %xmm0
movd %edx, %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
pand 0x49279(%rip), %xmm2    # 0x6d510
movdqa %xmm2, %xmm0
pcmpgtd 0x4927d(%rip), %xmm0    # 0x6d520
movdqa 0x49285(%rip), %xmm1    # 0x6d530
por %xmm2, %xmm1
paddd 0x49289(%rip), %xmm2    # 0x6d540
pand %xmm0, %xmm2
pandn %xmm1, %xmm0
por %xmm2, %xmm0
packuswb %xmm0, %xmm0
packuswb %xmm0, %xmm0
shrl $0x14, %esi
andl $0xf, %esi
leal 0x37(%rsi), %ecx
leal 0x30(%rsi), %edx
cmpl $0xa, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
cmovbl %edx, %ecx
movd %xmm0, (%rdi)
movb %cl, 0x4(%rdi)
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edx
cmpl $0xa, %eax
movzbl %dl, %eax
movzbl %cl, %ecx
cmovbl %eax, %ecx
movb %cl, 0x5(%rdi)
movb $0x0, 0x6(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgba_f
NK_API struct nk_color
nk_rgba_f(float r, float g, float b, float a)
{
    struct nk_color ret;
    ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f);
    ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f);
    ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f);
    ret.a = (nk_byte)(NK_SATURATE(a) * 255.0f);
    return ret;
}

// Assembly:
movss 0x494b9(%rip), %xmm4    # 0x6d8a4
movaps %xmm4, %xmm6
minss %xmm0, %xmm6
movss 0x494ae(%rip), %xmm0    # 0x6d8a8
movaps %xmm6, %xmm5
mulss %xmm0, %xmm5
cvttss2si %xmm5, %ecx
movl $0xff, %esi
andl %esi, %ecx
xorl %edx, %edx
xorps %xmm5, %xmm5
ucomiss %xmm5, %xmm6
cmovbel %edx, %ecx
movaps %xmm4, %xmm6
minss %xmm1, %xmm6
movaps %xmm6, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %esi, %eax
shll $0x8, %eax
ucomiss %xmm5, %xmm6
cmovbel %edx, %eax
movaps %xmm4, %xmm1
minss %xmm2, %xmm1
movaps %xmm1, %xmm2
mulss %xmm0, %xmm2
cvttss2si %xmm2, %edi
andl %esi, %edi
shll $0x10, %edi
ucomiss %xmm5, %xmm1
cmovbel %edx, %edi
minss %xmm3, %xmm4
mulss %xmm4, %xmm0
cvttss2si %xmm0, %esi
shll $0x18, %esi
ucomiss %xmm5, %xmm4
cmovbel %edx, %esi
orl %ecx, %eax
orl %edi, %eax
orl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgb_f
NK_API struct nk_color
nk_rgb_f(float r, float g, float b)
{
    struct nk_color ret;
    ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f);
    ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f);
    ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f);
    ret.a = 255;
    return ret;
}

// Assembly:
movss 0x493fe(%rip), %xmm3    # 0x6d8a4
movaps %xmm3, %xmm4
minss %xmm2, %xmm4
movl $0xff000000, %ecx       # imm = 0xFF000000
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm4
jbe 0x244cf
mulss 0x493e6(%rip), %xmm4    # 0x6d8a8
cvttss2si %xmm4, %ecx
shll $0x10, %ecx
orl $0xff000000, %ecx       # imm = 0xFF000000
movaps %xmm3, %xmm4
minss %xmm1, %xmm4
movss 0x493ca(%rip), %xmm1    # 0x6d8a8
movaps %xmm4, %xmm5
mulss %xmm1, %xmm5
cvttss2si %xmm5, %edx
movl $0xff, %esi
andl %esi, %edx
shll $0x8, %edx
xorl %edi, %edi
ucomiss %xmm2, %xmm4
cmovbel %edi, %edx
minss %xmm0, %xmm3
mulss %xmm3, %xmm1
cvttss2si %xmm1, %eax
andl %esi, %eax
ucomiss %xmm2, %xmm3
cmovbel %edi, %eax
orl %edx, %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_hsva
NK_API struct nk_color
nk_hsva(int h, int s, int v, int a)
{
    float hf = ((float)NK_CLAMP(0, h, 255)) / 255.0f;
    float sf = ((float)NK_CLAMP(0, s, 255)) / 255.0f;
    float vf = ((float)NK_CLAMP(0, v, 255)) / 255.0f;
    float af = ((float)NK_CLAMP(0, a, 255)) / 255.0f;
    return nk_hsva_f(hf, sf, vf, af);
}

// Assembly:
pushq %rax
movl $0xff, %eax
cmpl %eax, %edi
cmovgel %eax, %edi
xorl %r8d, %r8d
testl %edi, %edi
cmovlel %r8d, %edi
cvtsi2ss %edi, %xmm0
cmpl %eax, %esi
cmovgel %eax, %esi
testl %esi, %esi
cmovlel %r8d, %esi
cvtsi2ss %esi, %xmm1
cmpl %eax, %edx
cmovgel %eax, %edx
movss 0x49334(%rip), %xmm4    # 0x6d8a8
testl %edx, %edx
cmovlel %r8d, %edx
divss %xmm4, %xmm0
cvtsi2ss %edx, %xmm2
divss %xmm4, %xmm1
cmpl %eax, %ecx
cmovll %ecx, %eax
divss %xmm4, %xmm2
testl %eax, %eax
cmovlel %r8d, %eax
cvtsi2ss %eax, %xmm3
divss %xmm4, %xmm3
callq 0x13400
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm4     # xmm4 = xmm4[1,1],xmm0[1,1]
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm1, %xmm2
movaps %xmm4, %xmm1
popq %rax
jmp 0x131e0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_hsva_colorf
NK_API struct nk_colorf
nk_hsva_colorf(float h, float s, float v, float a)
{
    int i;
    float p, q, t, f;
    struct nk_colorf out = {0,0,0,0};
    if (s <= 0.0f) {
        out.r = v; out.g = v; out.b = v; out.a = a;
        return out;
    }
    h = h / (60.0f/360.0f);
    i = (int)h;
    f = h - (float)i;
    p = v * (1.0f - s);
    q = v * (1.0f - (s * f));
    t = v * (1.0f - s * (1.0f - f));

    switch (i) {
    case 0: default: out.r = v; out.g = t; out.b = p; break;
    case 1: out.r = q; out.g = v; out.b = p; break;
    case 2: out.r = p; out.g = v; out.b = t; break;
    case 3: out.r = p; out.g = q; out.b = v; break;
    case 4: out.r = t; out.g = p; out.b = v; break;
    case 5: out.r = v; out.g = p; out.b = q; break;}
    out.a = a;
    return out;
}

// Assembly:
xorps %xmm4, %xmm4
ucomiss %xmm1, %xmm4
jae 0x24700
divss 0x4920f(%rip), %xmm0    # 0x6d8ac
cvttss2si %xmm0, %eax
cvttps2dq %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
subss %xmm4, %xmm0
movss 0x491f0(%rip), %xmm5    # 0x6d8a4
movaps %xmm5, %xmm4
subss %xmm1, %xmm4
mulss %xmm2, %xmm4
movaps %xmm5, %xmm7
subss %xmm0, %xmm7
mulss %xmm1, %xmm7
movaps %xmm5, %xmm6
subss %xmm7, %xmm6
mulss %xmm2, %xmm6
decl %eax
cmpl $0x4, %eax
ja 0x24739
mulss %xmm0, %xmm1
subss %xmm1, %xmm5
mulss %xmm2, %xmm5
leaq 0x49311(%rip), %rcx     # 0x6da00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movaps %xmm5, %xmm0
movaps %xmm2, %xmm1
jmp 0x2473f
xorps %xmm1, %xmm1
movss %xmm2, %xmm1            # xmm1 = xmm2[0],xmm1[1,2,3]
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
movaps %xmm2, %xmm0
jmp 0x24749
movaps %xmm2, %xmm0
movaps %xmm4, %xmm1
movaps %xmm5, %xmm4
jmp 0x2473f
movaps %xmm4, %xmm0
movaps %xmm5, %xmm1
jmp 0x24729
movaps %xmm6, %xmm0
movaps %xmm4, %xmm1
movaps %xmm2, %xmm4
jmp 0x2473f
movaps %xmm4, %xmm0
movaps %xmm2, %xmm1
movaps %xmm6, %xmm4
jmp 0x2473f
movaps %xmm2, %xmm0
movaps %xmm6, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
xorps %xmm1, %xmm1
movss %xmm4, %xmm1            # xmm1 = xmm4[0],xmm1[1,2,3]
movlhps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm3     # xmm3 = xmm3[2,0],xmm1[2,3]
movaps %xmm3, %xmm1
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_f
NK_API void
nk_color_f(float *r, float *g, float *b, float *a, struct nk_color in)
{
    NK_STORAGE const float s = 1.0f/255.0f;
    *r = (float)in.r * s;
    *g = (float)in.g * s;
    *b = (float)in.b * s;
    *a = (float)in.a * s;
}

// Assembly:
movl %r8d, %eax
shrl $0x8, %eax
movl %r8d, %r9d
shrl $0x10, %r9d
movl %r8d, %r10d
shrl $0x18, %r10d
movl $0xff, %r11d
andl %r11d, %r8d
cvtsi2ss %r8d, %xmm0
movss 0x490e4(%rip), %xmm1    # 0x6d8b0
mulss %xmm1, %xmm0
movss %xmm0, (%rdi)
andl %r11d, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
andl %r11d, %r9d
cvtsi2ss %r9d, %xmm2
movss %xmm0, (%rsi)
xorps %xmm0, %xmm0
cvtsi2ss %r10d, %xmm0
mulss %xmm1, %xmm2
movss %xmm2, (%rdx)
mulss %xmm1, %xmm0
movss %xmm0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_colorf_hsva_f
NK_API void
nk_colorf_hsva_f(float *out_h, float *out_s,
    float *out_v, float *out_a, struct nk_colorf in)
{
    float chroma;
    float K = 0.0f;
    if (in.g < in.b) {
        const float t = in.g; in.g = in.b; in.b = t;
        K = -1.f;
    }
    if (in.r < in.g) {
        const float t = in.r; in.r = in.g; in.g = t;
        K = -2.f/6.0f - K;
    }
    chroma = in.r - ((in.g < in.b) ? in.g: in.b);
    *out_h = NK_ABS(K + (in.g - in.b)/(6.0f * chroma + 1e-20f));
    *out_s = chroma / (in.r + 1e-20f);
    *out_v = in.r;
    *out_a = in.a;

}

// Assembly:
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
ucomiss %xmm2, %xmm1
cmpltss %xmm1, %xmm2
movss 0x48e5d(%rip), %xmm3    # 0x6d8b4
andps %xmm2, %xmm3
jbe 0x24a6d
movaps %xmm0, %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
shufps $0x11, %xmm0, %xmm1     # xmm1 = xmm1[1,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
movaps %xmm2, %xmm0
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm4     # xmm4 = xmm4[1,1],xmm0[1,1]
ucomiss %xmm0, %xmm4
movss 0x48e39(%rip), %xmm5    # 0x6d8b8
subss %xmm3, %xmm5
movaps %xmm0, %xmm2
cmpltss %xmm4, %xmm2
andps %xmm2, %xmm5
andnps %xmm3, %xmm2
orps %xmm5, %xmm2
jbe 0x24a9a
shufps $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movaps %xmm3, %xmm4
minss %xmm1, %xmm4
movaps %xmm0, %xmm5
subss %xmm4, %xmm5
subss %xmm1, %xmm3
movss 0x48e01(%rip), %xmm4    # 0x6d8bc
mulss %xmm5, %xmm4
movss 0x48df9(%rip), %xmm6    # 0x6d8c0
addss %xmm6, %xmm4
divss %xmm4, %xmm3
addss %xmm3, %xmm2
movaps 0x48a96(%rip), %xmm3    # 0x6d570
xorps %xmm2, %xmm3
maxss %xmm2, %xmm3
movss %xmm3, (%rdi)
movaps %xmm0, %xmm2
addss %xmm6, %xmm2
divss %xmm2, %xmm5
movss %xmm5, (%rsi)
movss %xmm0, (%rdx)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss %xmm1, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hsva_i
NK_API void
nk_color_hsva_i(int *out_h, int *out_s, int *out_v,
                int *out_a, struct nk_color in)
{
    float h,s,v,a;
    nk_color_hsva_f(&h, &s, &v, &a, in);
    *out_h = (nk_byte)(h * 255.0f);
    *out_s = (nk_byte)(s * 255.0f);
    *out_v = (nk_byte)(v * 255.0f);
    *out_a = (nk_byte)(a * 255.0f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x24(%rsp), %rbp
leaq 0x20(%rsp), %r15
leaq 0x1c(%rsp), %rbx
leaq 0xc(%rsp), %rcx
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13700
movss 0x48c89(%rip), %xmm0    # 0x6d8a8
movss (%rbp), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0xff, %ecx
andl %ecx, %eax
movl %eax, (%r13)
movss (%r15), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %ecx, %eax
movl %eax, (%r12)
movss (%rbx), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %ecx, %eax
movl %eax, (%r14)
leaq 0xc(%rsp), %rax
mulss (%rax), %xmm0
cvttss2si %xmm0, %eax
andl %ecx, %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_utf_decode
NK_API int
nk_utf_decode(const char *c, nk_rune *u, int clen)
{
    int i, j, len, type=0;
    nk_rune udecoded;

    NK_ASSERT(c);
    NK_ASSERT(u);

    if (!c || !u) return 0;
    if (!clen) return 0;
    *u = NK_UTF_INVALID;

    udecoded = nk_utf_decode_byte(c[0], &len);
    if (!NK_BETWEEN(len, 1, NK_UTF_SIZE))
        return 1;

    for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
        udecoded = (udecoded << 6) | nk_utf_decode_byte(c[i], &type);
        if (type != 0)
            return j;
    }
    if (j < len)
        return 0;
    *u = udecoded;
    nk_utf_validate(u, len);
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x24e39
movq 0x621dc(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x4bf7e(%rip), %rsi     # 0x70d9c
leaq 0x4bf95(%rip), %rdx     # 0x70dba
movl $0x1fa8, %ecx           # imm = 0x1FA8
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x24e55
testq %r14, %r14
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
je 0x24e89
xorl %r12d, %r12d
jmp 0x24f65
movq 0x62194(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x4bf36(%rip), %rsi     # 0x70d9c
leaq 0x4bf4d(%rip), %rdx     # 0x70dba
xorl %r12d, %r12d
movl $0x1fa9, %ecx           # imm = 0x1FA9
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
jmp 0x24f65
movl $0xfffd, (%rbx)         # imm = 0xFFFD
movb (%r14), %dl
xorl %r15d, %r15d
leaq 0x4be94(%rip), %rax     # 0x70d30
leaq 0x4be92(%rip), %rcx     # 0x70d35
movb (%r15,%rax), %sil
movl %esi, %edi
andb %dl, %dil
cmpb (%r15,%rcx), %dil
je 0x24ec6
incq %r15
cmpq $0x5, %r15
jne 0x24ea3
movl $0x1, %r12d
jmp 0x24f65
leal -0x1(%r15), %edi
movl $0x1, %r12d
cmpl $0x2, %edi
ja 0x24f65
notb %sil
andb %sil, %dl
movzbl %dl, %edx
cmpl $0x2, %ebp
setl %sil
cmpq $0x2, %r15
setae %dil
setb %r8b
orb %sil, %r8b
jne 0x24f4c
movl %ebp, %esi
movl $0x1, %r12d
movb (%r14,%r12), %dil
xorl %r8d, %r8d
movb (%r8,%rax), %r9b
movl %r9d, %r10d
andb %dil, %r10b
cmpb (%r8,%rcx), %r10b
je 0x24f24
incq %r8
cmpq $0x5, %r8
jne 0x24f09
jmp 0x24f65
testq %r8, %r8
jne 0x24f65
notb %r9b
andb %r9b, %dil
movzbl %dil, %edi
shll $0x6, %edx
orl %edi, %edx
incq %r12
cmpl %r15d, %r12d
setb %dil
cmpq %rsi, %r12
jae 0x24f4c
cmpl %r15d, %r12d
jb 0x24f02
testb %dil, %dil
jne 0x24e4d
movl %edx, (%rbx)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x24f71
movl %r15d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_utf_validate
NK_INTERN int
nk_utf_validate(nk_rune *u, int i)
{
    NK_ASSERT(u);
    if (!u) return 0;
    if (!NK_BETWEEN(*u, nk_utfmin[i], nk_utfmax[i]) ||
         NK_BETWEEN(*u, 0xD800, 0xDFFF))
            *u = NK_UTF_INVALID;
    for (i = 1; *u > nk_utfmax[i]; ++i);
    return i;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x24f95
movslq %esi, %rcx
leaq 0x4bdbf(%rip), %rdx     # 0x70d40
movl (%rdi), %eax
cmpl %eax, (%rdx,%rcx,4)
jbe 0x24fc2
movl $0xfffd, (%rdi)         # imm = 0xFFFD
movl $0xfffd, %eax           # imm = 0xFFFD
jmp 0x24fdc
movq 0x62054(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x4bdf6(%rip), %rsi     # 0x70d9c
leaq 0x4be0d(%rip), %rdx     # 0x70dba
movl $0x1f8f, %ecx           # imm = 0x1F8F
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
leal -0xd800(%rax), %edx
cmpl $0x7ff, %edx            # imm = 0x7FF
jb 0x24f88
leaq 0x4bd89(%rip), %rdx     # 0x70d60
cmpl (%rdx,%rcx,4), %eax
jae 0x24f88
leaq 0x4bd81(%rip), %rcx     # 0x70d64
leaq 0x4(%rcx), %rdx
cmpl (%rcx), %eax
movq %rdx, %rcx
ja 0x24fe3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_utf_encode
NK_API int
nk_utf_encode(nk_rune u, char *c, int clen)
{
    int len, i;
    len = nk_utf_validate(&u, 0);
    if (clen < len || !len || len > NK_UTF_SIZE)
        return 0;

    for (i = len - 1; i != 0; --i) {
        c[i] = nk_utf_encode_byte(u, 0);
        u >>= 6;
    }
    c[0] = nk_utf_encode_byte(u, len);
    return len;
}

// Assembly:
leal -0xd800(%rdi), %eax
cmpl $0x7ff, %eax            # imm = 0x7FF
movl $0xfffd, %eax           # imm = 0xFFFD
movl %edi, %r8d
cmovbl %eax, %r8d
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
cmovael %eax, %r8d
xorl %ecx, %ecx
leaq 0x4bd46(%rip), %rax     # 0x70d60
movq %rcx, %rdi
incq %rcx
cmpl 0x4(%rax,%rdi,4), %r8d
ja 0x2501a
cmpl %edx, %ecx
setg %dl
cmpq $0x5, %rcx
setae %dil
xorl %eax, %eax
orb %dl, %dil
jne 0x2507a
cmpq $0x1, %rcx
je 0x2505c
leaq -0x1(%rcx), %rax
cltq
movl %r8d, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, (%rsi,%rax)
shrl $0x6, %r8d
decq %rax
jne 0x25047
leaq 0x4bcd2(%rip), %rax     # 0x70d35
leaq 0x4bcc6(%rip), %rdx     # 0x70d30
movzbl (%rcx,%rdx), %edx
notl %edx
andl %r8d, %edx
orb (%rcx,%rax), %dl
movb %dl, (%rsi)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_utf_len
NK_API int
nk_utf_len(const char *str, int len)
{
    const char *text;
    int glyphs = 0;
    int text_len;
    int glyph_len;
    int src_len = 0;
    nk_rune unicode;

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

    text = str;
    text_len = len;
    glyph_len = nk_utf_decode(text, &unicode, text_len);
    while (glyph_len && src_len < len) {
        glyphs++;
        src_len = src_len + glyph_len;
        glyph_len = nk_utf_decode(text + src_len, &unicode, text_len - src_len);
    }
    return glyphs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x250de
movl %esi, %ebp
xorl %ebx, %ebx
testl %esi, %esi
je 0x2510c
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl %ebp, %edx
callq 0x12ef0
testl %eax, %eax
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0x2510c
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %ebx, %ebx
addl %eax, %r12d
incl %ebx
movslq %r12d, %rax
leaq (%r14,%rax), %rdi
movl %ebp, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x12ef0
testl %eax, %eax
je 0x2510c
cmpl %r12d, %ebp
jg 0x250bb
jmp 0x2510c
movq 0x61f0b(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x4bcad(%rip), %rsi     # 0x70d9c
leaq 0x4bcc4(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x1fdc, %ecx           # imm = 0x1FDC
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_utf_at
NK_API const char*
nk_utf_at(const char *buffer, int length, int index,
    nk_rune *unicode, int *len)
{
    int i = 0;
    int src_len = 0;
    int glyph_len = 0;
    const char *text;
    int text_len;

    NK_ASSERT(buffer);
    NK_ASSERT(unicode);
    NK_ASSERT(len);

    if (!buffer || !unicode || !len) return 0;
    if (index < 0) {
        *unicode = NK_UTF_INVALID;
        *len = 0;
        return 0;
    }

    text = buffer;
    text_len = length;
    glyph_len = nk_utf_decode(text, unicode, text_len);
    while (glyph_len) {
        if (i == index) {
            *len = glyph_len;
            break;
        }

        i++;
        src_len = src_len + glyph_len;
        glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len);
    }
    if (i != index) return 0;
    return buffer + src_len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x25165
movq 0x61eb0(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x4bc52(%rip), %rsi     # 0x70d9c
leaq 0x4bc69(%rip), %rdx     # 0x70dba
movl $0x1ff3, %ecx           # imm = 0x1FF3
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %r15, %r15
jne 0x25196
movq 0x61e7f(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x4bc21(%rip), %rsi     # 0x70d9c
leaq 0x4bc38(%rip), %rdx     # 0x70dba
movl $0x1ff4, %ecx           # imm = 0x1FF4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %r13, %r13
je 0x251f4
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x25240
testl %ebp, %ebp
js 0x25224
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x12ef0
testl %eax, %eax
je 0x25235
movq %r13, (%rsp)
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpl %r14d, %ebp
je 0x25244
incl %r14d
addl %eax, %r13d
movslq %r13d, %rax
leaq (%rbx,%rax), %rdi
movl %r12d, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x12ef0
testl %eax, %eax
jne 0x251cf
jmp 0x2523b
movq 0x61df5(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x4bb97(%rip), %rsi     # 0x70d9c
leaq 0x4bbae(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x1ff5, %ecx           # imm = 0x1FF5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x25250
movl $0xfffd, (%r15)         # imm = 0xFFFD
movl $0x0, (%r13)
jmp 0x25240
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpl %ebp, %r14d
je 0x2524a
xorl %ebx, %ebx
jmp 0x25250
movq (%rsp), %rcx
movl %eax, (%rcx)
movslq %r13d, %rax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_init_default
NK_API void
nk_buffer_init_default(struct nk_buffer *buffer)
{
    struct nk_allocator alloc;
    alloc.userdata.ptr = 0;
    alloc.alloc = nk_malloc;
    alloc.free = nk_mfree;
    nk_buffer_init(buffer, &alloc, NK_BUFFER_DEFAULT_INITIAL_SIZE);
}

// Assembly:
subq $0x18, %rsp
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq 0x1e(%rip), %rax        # 0x25295
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x2529d
movq %rax, 0x10(%rsi)
movl $0x1000, %edx           # imm = 0x1000
callq 0x12d60
addq $0x18, %rsp
retq