LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2282f
leal -0x41(%rdx), %r9d
cmpb $0x19, %r9b
ja 0x22820
addl $0x20, %eax
je 0x2282f
addb $-0x41, %r8b
cmpb $0x19, %r8b
ja 0x22839
addl $-0x20, %eax
jne 0x22839
incq %rcx
testb %dl, %dl
jne 0x22801
xorl %eax, %eax
retq
sarl $0x1f, %eax
orl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2287f
movq 0x62796(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x474a8(%rip), %rsi     # 0x69d0c
leaq 0x474bf(%rip), %rdx     # 0x69d2a
movl $0x1a6f, %ecx           # imm = 0x1A6F
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movl %ebp, %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpl %edx, %ecx
je 0x228ca
movsbl (%r14,%rdx), %edi
movsbl (%rbx,%rdx), %r8d
movl %edi, %esi
subl %r8d, %esi
je 0x228b8
leal -0x41(%rdi), %r9d
cmpb $0x19, %r9b
ja 0x228a9
addl $0x20, %esi
je 0x228b8
addb $-0x41, %r8b
cmpb $0x19, %r8b
ja 0x228c2
addl $-0x20, %esi
jne 0x228c2
incq %rdx
testb %dil, %dil
jne 0x22885
jmp 0x228ca
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_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x5e, (%rsi)
jne 0x228f3
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x22918
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22918
testl %eax, %eax
jne 0x22911
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x228f6
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %r15b
addq $0x2, %r14
pushq $0x1
popq %rbp
testb %r15b, %r15b
je 0x22999
movb -0x1(%r14), %cl
cmpb $0x2a, %cl
je 0x2298a
movl %r15d, %eax
xorb $0x24, %al
movb (%rbx), %dl
orb %cl, %al
je 0x2299d
xorl %eax, %eax
testb %dl, %dl
je 0x229a4
cmpb $0x2e, %r15b
setne %sil
cmpb %dl, %r15b
setne %dl
testb %dl, %sil
jne 0x229a4
incq %rbx
incq %r14
movl %ecx, %r15d
jmp 0x2292f
cmpb $0x2e, %r15b
sete %cl
movb (%rbx), %sil
cmpb %r15b, %sil
sete %dl
xorl %eax, %eax
testb %sil, %sil
je 0x229a4
incq %rbx
orb %dl, %cl
je 0x229a4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22918
testl %eax, %eax
je 0x2296c
movl %ebp, %eax
jmp 0x229a4
xorl %eax, %eax
testb %dl, %dl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_murmur_hash
NK_API nk_hash
nk_murmur_hash(const void * key, int len, nk_hash seed)
{
    /* 32-Bit MurmurHash3: https://code.google.com/p/smhasher/wiki/MurmurHash3*/
    #define NK_ROTL(x,r) ((x) << (r) | ((x) >> (32 - r)))

    nk_uint h1 = seed;
    nk_uint k1;
    const nk_byte *data = (const nk_byte*)key;
    const nk_byte *keyptr = data;
    nk_byte *k1ptr;
    const int bsize = sizeof(k1);
    const int nblocks = len/4;

    const nk_uint c1 = 0xcc9e2d51;
    const nk_uint c2 = 0x1b873593;
    const nk_byte *tail;
    int i;

    /* body */
    if (!key) return 0;
    for (i = 0; i < nblocks; ++i, keyptr += bsize) {
        k1ptr = (nk_byte*)&k1;
        k1ptr[0] = keyptr[0];
        k1ptr[1] = keyptr[1];
        k1ptr[2] = keyptr[2];
        k1ptr[3] = keyptr[3];

        k1 *= c1;
        k1 = NK_ROTL(k1,15);
        k1 *= c2;

        h1 ^= k1;
        h1 = NK_ROTL(h1,13);
        h1 = h1*5+0xe6546b64;
    }

    /* tail */
    tail = (const nk_byte*)(data + nblocks*4);
    k1 = 0;
    switch (len & 3) {
        case 3: k1 ^= (nk_uint)(tail[2] << 16); /* fallthrough */
        case 2: k1 ^= (nk_uint)(tail[1] << 8u); /* fallthrough */
        case 1: k1 ^= tail[0];
            k1 *= c1;
            k1 = NK_ROTL(k1,15);
            k1 *= c2;
            h1 ^= k1;
            break;
        default: break;
    }

    /* finalization */
    h1 ^= (nk_uint)len;
    /* fmix32 */
    h1 ^= h1 >> 16;
    h1 *= 0x85ebca6b;
    h1 ^= h1 >> 13;
    h1 *= 0xc2b2ae35;
    h1 ^= h1 >> 16;

    #undef NK_ROTL
    return h1;
}

// Assembly:
movl %edx, %ecx
pushq $0x4
popq %r8
movl %esi, %eax
cltd
idivl %r8d
testq %rdi, %rdi
je 0x22d68
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
cmpl %edx, %r8d
je 0x22cea
movl (%rdi,%rdx,4), %r9d
imull $0xcc9e2d51, %r9d, %r10d # imm = 0xCC9E2D51
imull $0x16a88000, %r9d, %r9d # imm = 0x16A88000
shrl $0x11, %r10d
orl %r9d, %r10d
imull $0x1b873593, %r10d, %r9d # imm = 0x1B873593
xorl %ecx, %r9d
roll $0xd, %r9d
leal (%r9,%r9,4), %ecx
addl $0xe6546b64, %ecx       # imm = 0xE6546B64
incq %rdx
jmp 0x22caf
movslq %eax, %rdx
movl %esi, %r8d
andl $0x3, %r8d
xorl %eax, %eax
leaq 0x43c73(%rip), %r9      # 0x66970
movslq (%r9,%r8,4), %r8
addq %r9, %r8
jmpq *%r8
movzbl 0x2(%rdi,%rdx,4), %eax
shll $0x10, %eax
movzbl 0x1(%rdi,%rdx,4), %r8d
shll $0x8, %r8d
orl %r8d, %eax
movb (%rdi,%rdx,4), %dl
xorb %al, %dl
andl $0xffff00, %eax         # imm = 0xFFFF00
movzbl %dl, %edx
orl %eax, %edx
imull $0xcc9e2d51, %edx, %eax # imm = 0xCC9E2D51
imull $0x16a88000, %edx, %edx # imm = 0x16A88000
shrl $0x11, %eax
orl %edx, %eax
imull $0x1b873593, %eax, %eax # imm = 0x1B873593
xorl %eax, %ecx
xorl %esi, %ecx
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
imull $0x85ebca6b, %eax, %eax # imm = 0x85EBCA6B
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae35, %ecx, %ecx # imm = 0xC2B2AE35
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x43ab8(%rip), %xmm0    # 0x66834
jne 0x22d84
jp 0x22d84
movl %edi, %edx
jmp 0x22db5
movl $0xff, %esi
movl %edi, %edx
andl %esi, %edx
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
andl %esi, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %esi, %ecx
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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
cmpb $0x23, (%rdi)
sete %r15b
addq %r15, %rdi
callq 0x22e73
movl %eax, %ebp
leaq (%rbx,%r15), %rdi
addq $0x2, %rdi
callq 0x22e73
movl %eax, %r14d
leaq (%rbx,%r15), %rdi
addq $0x4, %rdi
callq 0x22e73
shll $0x10, %eax
shll $0x8, %r14d
movzwl %r14w, %ecx
orl %ecx, %eax
movzbl %bpl, %ecx
orl %ecx, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x2, %rcx
je 0x22ead
movzbl (%rdi,%rcx), %edx
leal -0x61(%rdx), %esi
cmpb $0x5, %sil
ja 0x22e8f
addl $-0x57, %edx
jmp 0x22ea3
leal -0x41(%rdx), %esi
cmpb $0x5, %sil
ja 0x22e9d
addl $-0x37, %edx
jmp 0x22ea3
movsbl %dl, %edx
addl $-0x30, %edx
shll $0x4, %eax
addl %edx, %eax
incq %rcx
jmp 0x22e77
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %r12d, %r12d
cmpb $0x23, (%rdi)
sete %r12b
addq %r12, %rdi
callq 0x22e73
movl %eax, %ebx
leaq (%r14,%r12), %rdi
addq $0x2, %rdi
callq 0x22e73
movl %eax, %ebp
leaq (%r14,%r12), %rdi
addq $0x4, %rdi
callq 0x22e73
movl %eax, %r15d
leaq (%r14,%r12), %rdi
addq $0x6, %rdi
callq 0x22e73
shll $0x18, %eax
movl $0xff, %ecx
andl %ecx, %r15d
shll $0x10, %r15d
orl %r15d, %eax
shll $0x8, %ebp
movzwl %bp, %edx
orl %edx, %eax
andl %ecx, %ebx
orl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x435ad(%rip), %xmm2    # 0x66510
movdqa %xmm2, %xmm0
pcmpgtd 0x435b1(%rip), %xmm0    # 0x66520
movdqa 0x435b9(%rip), %xmm1    # 0x66530
por %xmm2, %xmm1
paddd 0x435bd(%rip), %xmm2    # 0x66540
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_O2/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 0x434c0(%rip), %xmm2    # 0x66510
movdqa %xmm2, %xmm0
pcmpgtd 0x434c4(%rip), %xmm0    # 0x66520
movdqa 0x434cc(%rip), %xmm1    # 0x66530
por %xmm2, %xmm1
paddd 0x434d0(%rip), %xmm2    # 0x66540
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_O2/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 0x436eb(%rip), %xmm4    # 0x66834
movaps %xmm4, %xmm6
minss %xmm0, %xmm6
movss 0x436e0(%rip), %xmm0    # 0x66838
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_O2/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 0x43630(%rip), %xmm3    # 0x66834
movaps %xmm3, %xmm4
minss %xmm2, %xmm4
movl $0xff000000, %ecx       # imm = 0xFF000000
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm4
jbe 0x2322d
mulss 0x43618(%rip), %xmm4    # 0x66838
cvttss2si %xmm4, %ecx
shll $0x10, %ecx
orl $0xff000000, %ecx       # imm = 0xFF000000
movaps %xmm3, %xmm4
minss %xmm1, %xmm4
movss 0x435fc(%rip), %xmm1    # 0x66838
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_O2/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:
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 0x43567(%rip), %xmm4    # 0x66838
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
jmp 0x136d0
// File: /workspace/github_c_makefile_star2_O2/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 0x233fb
divss 0x434a4(%rip), %xmm0    # 0x6683c
cvttss2si %xmm0, %eax
cvttps2dq %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
subss %xmm4, %xmm0
movss 0x43485(%rip), %xmm5    # 0x66834
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 0x23434
mulss %xmm0, %xmm1
subss %xmm1, %xmm5
mulss %xmm2, %xmm5
leaq 0x43596(%rip), %rcx     # 0x66980
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movaps %xmm5, %xmm0
movaps %xmm2, %xmm1
jmp 0x2343a
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 0x23444
movaps %xmm2, %xmm0
movaps %xmm4, %xmm1
movaps %xmm5, %xmm4
jmp 0x2343a
movaps %xmm4, %xmm0
movaps %xmm5, %xmm1
jmp 0x23424
movaps %xmm6, %xmm0
movaps %xmm4, %xmm1
movaps %xmm2, %xmm4
jmp 0x2343a
movaps %xmm4, %xmm0
movaps %xmm2, %xmm1
movaps %xmm6, %xmm4
jmp 0x2343a
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_O2/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 0x43394(%rip), %xmm1    # 0x66840
mulss %xmm1, %xmm0
movss %xmm0, (%rdi)
andl %r11d, %eax
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
andl %r11d, %r9d
cvtsi2ss %r9d, %xmm2
movss %xmm0, (%rsi)
cvtsi2ss %r10d, %xmm0
mulss %xmm1, %xmm2
movss %xmm2, (%rdx)
mulss %xmm1, %xmm0
movss %xmm0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_d
NK_API void
nk_color_d(double *r, double *g, double *b, double *a, struct nk_color in)
{
    NK_STORAGE const double s = 1.0/255.0;
    *r = (double)in.r * s;
    *g = (double)in.g * s;
    *b = (double)in.b * s;
    *a = (double)in.a * s;
}

// Assembly:
movl %r8d, %eax
shrl $0x8, %eax
movl %r8d, %r9d
shrl $0x10, %r9d
movl %r8d, %r10d
movl $0xff, %r11d
andl %r11d, %r8d
cvtsi2sd %r8d, %xmm0
movsd 0x433e3(%rip), %xmm1    # 0x66920
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
andl %r11d, %eax
cvtsi2sd %eax, %xmm0
shrl $0x18, %r10d
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
andl %r11d, %r9d
cvtsi2sd %r9d, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
cvtsi2sd %r10d, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x43222(%rip), %xmm3    # 0x66844
andps %xmm2, %xmm3
jbe 0x23638
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 0x431fe(%rip), %xmm5    # 0x66848
subss %xmm3, %xmm5
movaps %xmm0, %xmm2
cmpltss %xmm4, %xmm2
andps %xmm2, %xmm5
andnps %xmm3, %xmm2
orps %xmm5, %xmm2
jbe 0x23665
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 0x431c6(%rip), %xmm4    # 0x6684c
mulss %xmm5, %xmm4
movss 0x431be(%rip), %xmm6    # 0x66850
addss %xmm6, %xmm4
divss %xmm4, %xmm3
addss %xmm3, %xmm2
movaps 0x42ecb(%rip), %xmm3    # 0x66570
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_O2/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 0x138e0
movss 0x43101(%rip), %xmm0    # 0x66838
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_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hsv_b
NK_API void
nk_color_hsv_b(nk_byte *out_h, nk_byte *out_s, nk_byte *out_v, struct nk_color in)
{
    int tmp[4];
    nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in);
    *out_h = (nk_byte)tmp[0];
    *out_s = (nk_byte)tmp[1];
    *out_v = (nk_byte)tmp[2];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r8d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %rsp, %r12
movq %r12, %rdi
callq 0x126a0
movb (%r12), %al
movb %al, (%r15)
movb 0x4(%r12), %al
movb %al, (%r14)
movb 0x8(%r12), %al
movb %al, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hsv_bv
NK_API void
nk_color_hsv_bv(nk_byte *out, struct nk_color in)
{
    int tmp[4];
    nk_color_hsv_i(&tmp[0], &tmp[1], &tmp[2], in);
    out[0] = (nk_byte)tmp[0];
    out[1] = (nk_byte)tmp[1];
    out[2] = (nk_byte)tmp[2];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ecx
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x13ec0
movb (%r14), %al
movb %al, (%rbx)
movb 0x4(%r14), %al
movb %al, 0x1(%rbx)
movb 0x8(%r14), %al
movb %al, 0x2(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, (%rsp)
testq %rdi, %rdi
jne 0x2394a
movq 0x616cd(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x463de(%rip), %rsi     # 0x69d0c
leaq 0x463f5(%rip), %rdx     # 0x69d2a
movl $0x1fa8, %ecx           # imm = 0x1FA8
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %rbx, %rbx
je 0x239c9
xorl %ebp, %ebp
testq %r14, %r14
je 0x23a1c
testq %rbx, %rbx
je 0x23a1c
testl %r15d, %r15d
je 0x23a1c
movl $0xfffd, (%rbx)         # imm = 0xFFFD
movsbl (%r14), %edi
leaq 0x4(%rsp), %r13
movq %r13, %rsi
callq 0x23a2d
movl %eax, %r12d
movl (%r13), %esi
leal -0x1(%rsi), %eax
cmpl $0x2, %eax
ja 0x239f9
movslq %r15d, %rbp
pushq $0x1
popq %r13
movq %rsp, %r15
cmpq %rbp, %r13
jge 0x239fe
cmpl %r13d, %esi
jle 0x239fe
movsbl (%r14,%r13), %edi
movq %r15, %rsi
callq 0x23a2d
cmpl $0x0, (%rsp)
jne 0x23a19
shll $0x6, %r12d
orl %eax, %r12d
incq %r13
movl 0x4(%rsp), %esi
jmp 0x2399c
movq 0x61620(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x46332(%rip), %rsi     # 0x69d0c
leaq 0x46349(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x1fa9, %ecx           # imm = 0x1FA9
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
jmp 0x23a1c
pushq $0x1
popq %rbp
jmp 0x23a1c
cmpl %r13d, %esi
movl $0x0, %ebp
jg 0x23a1c
movl %r12d, (%rbx)
movq %rbx, %rdi
callq 0x23ab1
movl 0x4(%rsp), %ebp
jmp 0x23a1c
movl %r13d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_utf_decode_byte
NK_INTERN nk_rune
nk_utf_decode_byte(char c, int *i)
{
    NK_ASSERT(i);
    if (!i) return 0;
    for(*i = 0; *i < (int)NK_LEN(nk_utfmask); ++(*i)) {
        if (((nk_byte)c & nk_utfmask[*i]) == nk_utfbyte[*i])
            return (nk_byte)(c & ~nk_utfmask[*i]);
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x23a61
xorl %eax, %eax
leaq 0x46261(%rip), %rcx     # 0x69ca0
leaq 0x4625f(%rip), %rdx     # 0x69ca5
cmpq $0x5, %rax
je 0x23a91
movb (%rax,%rcx), %r8b
movl %r8d, %r9d
andb %dil, %r9b
cmpb (%rax,%rdx), %r9b
je 0x23a9b
incq %rax
jmp 0x23a46
movq 0x61588(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x4629a(%rip), %rsi     # 0x69d0c
leaq 0x462b1(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x1f9a, %ecx           # imm = 0x1F9A
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x23aa7
movl $0x5, (%rsi)
xorl %ebx, %ebx
jmp 0x23aa7
movl %eax, (%rsi)
notb %r8b
andb %dil, %r8b
movzbl %r8b, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x23ad8
movslq %esi, %rcx
leaq 0x461ec(%rip), %rdx     # 0x69cb0
movl (%rdi), %eax
cmpl %eax, (%rdx,%rcx,4)
jbe 0x23b08
movl $0xfffd, (%rdi)         # imm = 0xFFFD
movl $0xfffd, %eax           # imm = 0xFFFD
jmp 0x23b22
movq 0x61511(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x46223(%rip), %rsi     # 0x69d0c
leaq 0x4623a(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x1f8f, %ecx           # imm = 0x1F8F
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x23b37
leal -0xd800(%rax), %edx
cmpl $0x7ff, %edx            # imm = 0x7FF
jb 0x23acb
leaq 0x461b3(%rip), %rdx     # 0x69cd0
cmpl (%rdx,%rcx,4), %eax
jae 0x23acb
xorl %ebx, %ebx
leaq 0x461a5(%rip), %rcx     # 0x69cd0
movq %rbx, %rdx
incq %rbx
cmpl 0x4(%rcx,%rdx,4), %eax
ja 0x23b2b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
leaq 0xc(%rsp), %rax
movl %edi, (%rax)
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
callq 0x23ab1
cmpl $0x4, %eax
jg 0x23bb8
cmpl %r14d, %eax
jg 0x23bb8
testl %eax, %eax
je 0x23bb8
movl 0xc(%rsp), %ecx
movslq %eax, %rdx
leaq -0x1(%rdx), %rdi
movq %rdi, %rsi
subq $0x1, %rsi
jb 0x23b9b
movl %ecx, %r8d
andb $0x3f, %r8b
orb $-0x80, %r8b
movb %r8b, (%rbx,%rdi)
shrl $0x6, %ecx
movq %rsi, %rdi
jmp 0x23b7e
leaq 0x46103(%rip), %rsi     # 0x69ca5
leaq 0x460f7(%rip), %rdi     # 0x69ca0
movzbl (%rdx,%rdi), %edi
notl %edi
andl %edi, %ecx
orb (%rdx,%rsi), %cl
movb %cl, (%rbx)
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23c14
movl %esi, %ebp
testl %esi, %esi
je 0x23c44
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rsi
movl %ebp, %edx
callq 0x13020
xorl %ebx, %ebx
xorl %r12d, %r12d
testl %eax, %eax
je 0x23c46
cmpl %ebp, %r12d
jge 0x23c46
incl %ebx
addl %eax, %r12d
movslq %r12d, %rax
leaq (%r14,%rax), %rdi
movl %ebp, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x13020
jmp 0x23bf1
movq 0x613d5(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x460e7(%rip), %rsi     # 0x69d0c
leaq 0x460fe(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x1fdc, %ecx           # imm = 0x1FDC
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x23c46
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./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, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x23ca1
movq 0x61376(%rip), %r13     # 0x84ff0
movq (%r13), %rdi
leaq 0x46087(%rip), %rsi     # 0x69d0c
leaq 0x4609e(%rip), %rdx     # 0x69d2a
movl $0x1ff3, %ecx           # imm = 0x1FF3
xorl %eax, %eax
callq 0x12ea0
movq (%r13), %rdi
callq 0x13960
testq %r15, %r15
jne 0x23cd4
movq 0x61343(%rip), %r13     # 0x84ff0
movq (%r13), %rdi
leaq 0x46054(%rip), %rsi     # 0x69d0c
leaq 0x4606b(%rip), %rdx     # 0x69d2a
movl $0x1ff4, %ecx           # imm = 0x1FF4
xorl %eax, %eax
callq 0x12ea0
movq (%r13), %rdi
callq 0x13960
testq %r14, %r14
je 0x23d20
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x23d61
testl %ebp, %ebp
js 0x23d50
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x13020
xorl %r13d, %r13d
testl %eax, %eax
je 0x23d5d
subl $0x1, %ebp
jb 0x23d65
addl %eax, %r13d
movslq %r13d, %rax
leaq (%rbx,%rax), %rdi
movl %r12d, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x13020
jmp 0x23cfe
movq 0x612c9(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x45fdb(%rip), %rsi     # 0x69d0c
leaq 0x45ff2(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x1ff5, %ecx           # imm = 0x1FF5
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x23d6e
movl $0xfffd, (%r15)         # imm = 0xFFFD
andl $0x0, (%r14)
jmp 0x23d61
testl %ebp, %ebp
je 0x23d68
xorl %ebx, %ebx
jmp 0x23d6e
movl %eax, (%r14)
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_O2/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
andq $0x0, (%rsi)
leaq 0x1e(%rip), %rax        # 0x23db0
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x23db8
movq %rax, 0x10(%rsi)
movl $0x1000, %edx           # imm = 0x1000
callq 0x12e80
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_init
NK_API void
nk_buffer_init(struct nk_buffer *b, const struct nk_allocator *a,
    nk_size initial_size)
{
    NK_ASSERT(b);
    NK_ASSERT(a);
    NK_ASSERT(initial_size);
    if (!b || !a || !initial_size) return;

    nk_zero(b, sizeof(*b));
    b->type = NK_BUFFER_DYNAMIC;
    b->memory.ptr = a->alloc(a->userdata,0, initial_size);
    b->memory.size = initial_size;
    b->size = initial_size;
    b->grow_factor = 2.0f;
    b->pool = *a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x23e04
movq 0x61213(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x45f24(%rip), %rsi     # 0x69d0c
leaq 0x45f3b(%rip), %rdx     # 0x69d2a
movl $0x2035, %ecx           # imm = 0x2035
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %r14, %r14
jne 0x23e37
movq 0x611e0(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x45ef1(%rip), %rsi     # 0x69d0c
leaq 0x45f08(%rip), %rdx     # 0x69d2a
movl $0x2036, %ecx           # imm = 0x2036
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %r15, %r15
je 0x23e99
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x23e8d
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x23ed0
movl $0x1, 0x38(%rbx)
movq (%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq *0x8(%r14)
movq %rax, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movq %r15, 0x70(%rbx)
movl $0x40000000, 0x50(%rbx) # imm = 0x40000000
movups (%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x61150(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x45e62(%rip), %rsi     # 0x69d0c
leaq 0x45e79(%rip), %rdx     # 0x69d2a
movl $0x2037, %ecx           # imm = 0x2037
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_init_fixed
NK_API void
nk_buffer_init_fixed(struct nk_buffer *b, void *m, nk_size size)
{
    NK_ASSERT(b);
    NK_ASSERT(m);
    NK_ASSERT(size);
    if (!b || !m || !size) return;

    nk_zero(b, sizeof(*b));
    b->type = NK_BUFFER_FIXED;
    b->memory.ptr = m;
    b->memory.size = size;
    b->size = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
jne 0x23f60
movq 0x610b7(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x45dc8(%rip), %rsi     # 0x69d0c
leaq 0x45ddf(%rip), %rdx     # 0x69d2a
movl $0x2045, %ecx           # imm = 0x2045
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %r15, %r15
jne 0x23f93
movq 0x61084(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x45d95(%rip), %rsi     # 0x69d0c
leaq 0x45dac(%rip), %rdx     # 0x69d2a
movl $0x2046, %ecx           # imm = 0x2046
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %rbx, %rbx
je 0x23fd0
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x23fc4
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x23ed0
andl $0x0, 0x38(%r14)
movq %r15, 0x40(%r14)
movq %rbx, 0x48(%r14)
movq %rbx, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x61019(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x45d2b(%rip), %rsi     # 0x69d0c
leaq 0x45d42(%rip), %rdx     # 0x69d2a
movl $0x2047, %ecx           # imm = 0x2047
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_mark
NK_API void
nk_buffer_mark(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
{
    NK_ASSERT(buffer);
    if (!buffer) return;
    buffer->marker[type].active = nk_true;
    if (type == NK_BUFFER_BACK)
        buffer->marker[type].offset = buffer->size;
    else buffer->marker[type].offset = buffer->allocated;
}

// Assembly:
testq %rdi, %rdi
je 0x244a6
movl %esi, %ecx
shlq $0x4, %rcx
leaq (%rdi,%rcx), %rax
movl $0x1, (%rdi,%rcx)
cmpl $0x1, %esi
jne 0x244d4
movq 0x70(%rdi), %rcx
jmp 0x244d8
pushq %rbx
movq 0x60b42(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x45854(%rip), %rsi     # 0x69d0c
leaq 0x4586b(%rip), %rdx     # 0x69d2a
movl $0x20d3, %ecx           # imm = 0x20D3
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
jmp 0x13960
movq 0x58(%rdi), %rcx
movq %rcx, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_reset
NK_API void
nk_buffer_reset(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
{
    NK_ASSERT(buffer);
    if (!buffer) return;
    if (type == NK_BUFFER_BACK) {
        /* reset back buffer either back to marker or empty */
        buffer->needed -= (buffer->memory.size - buffer->marker[type].offset);
        if (buffer->marker[type].active)
            buffer->size = buffer->marker[type].offset;
        else buffer->size = buffer->memory.size;
        buffer->marker[type].active = nk_false;
    } else {
        /* reset front buffer either back to back marker or empty */
        buffer->needed -= (buffer->allocated - buffer->marker[type].offset);
        if (buffer->marker[type].active)
            buffer->allocated = buffer->marker[type].offset;
        else buffer->allocated = 0;
        buffer->marker[type].active = nk_false;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2450a
cmpl $0x1, %esi
jne 0x24538
movq 0x18(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
addq %rdx, 0x60(%rdi)
cmpl $0x0, 0x10(%rdi)
cmoveq %rcx, %rax
movq %rax, 0x70(%rdi)
andl $0x0, 0x10(%rdi)
retq
pushq %rbx
movq 0x60ade(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x457f0(%rip), %rsi     # 0x69d0c
leaq 0x45807(%rip), %rdx     # 0x69d2a
movl $0x20dd, %ecx           # imm = 0x20DD
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
jmp 0x13960
movl %esi, %eax
shlq $0x4, %rax
movq 0x8(%rdi,%rax), %rcx
movq %rcx, %rdx
subq 0x58(%rdi), %rdx
addq %rdx, 0x60(%rdi)
xorl %edx, %edx
cmpl $0x0, (%rdi,%rax)
cmovneq %rcx, %rdx
movq %rdx, 0x58(%rdi)
andl $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_clear
NK_API void
nk_buffer_clear(struct nk_buffer *b)
{
    NK_ASSERT(b);
    if (!b) return;
    b->allocated = 0;
    b->size = b->memory.size;
    b->calls = 0;
    b->needed = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2457b
andq $0x0, 0x58(%rdi)
movq 0x48(%rdi), %rax
movq %rax, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
retq
pushq %rbx
movq 0x60a6d(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x4577f(%rip), %rsi     # 0x69d0c
leaq 0x45796(%rip), %rdx     # 0x69d2a
movl $0x20f2, %ecx           # imm = 0x20F2
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_free
NK_API void
nk_buffer_free(struct nk_buffer *b)
{
    NK_ASSERT(b);
    if (!b || !b->memory.ptr) return;
    if (b->type == NK_BUFFER_FIXED) return;
    if (!b->pool.free) return;
    NK_ASSERT(b->pool.free);
    b->pool.free(b->pool.userdata, b->memory.ptr);
}

// Assembly:
testq %rdi, %rdi
je 0x245cd
movq 0x40(%rdi), %rsi
testq %rsi, %rsi
je 0x245cc
cmpl $0x0, 0x38(%rdi)
je 0x245cc
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x245cc
movq 0x20(%rdi), %rdi
jmpq *%rax
retq
pushq %rbx
movq 0x60a1b(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x4572d(%rip), %rsi     # 0x69d0c
leaq 0x45744(%rip), %rdx     # 0x69d2a
movl $0x20fc, %ecx           # imm = 0x20FC
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_info
NK_API void
nk_buffer_info(struct nk_memory_status *s, struct nk_buffer *b)
{
    NK_ASSERT(b);
    NK_ASSERT(s);
    if (!s || !b) return;
    s->allocated = b->allocated;
    s->size =  b->memory.size;
    s->needed = b->needed;
    s->memory = b->memory.ptr;
    s->calls = b->calls;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2462d
testq %rbx, %rbx
je 0x24666
movq 0x48(%rsi), %rax
movq %rax, 0x10(%rbx)
movups 0x58(%rsi), %xmm0
movups %xmm0, 0x18(%rbx)
movq 0x40(%rsi), %rax
movq %rax, (%rbx)
movq 0x68(%rsi), %rax
movq %rax, 0x28(%rbx)
jmp 0x2465e
movq 0x609bc(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x456ce(%rip), %rsi     # 0x69d0c
leaq 0x456e5(%rip), %rdx     # 0x69d2a
movl $0x2106, %ecx           # imm = 0x2106
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
testq %rbx, %rbx
je 0x24666
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x60983(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x45695(%rip), %rsi     # 0x69d0c
leaq 0x456ac(%rip), %rdx     # 0x69d2a
movl $0x2107, %ecx           # imm = 0x2107
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_init_default
NK_API void
nk_str_init_default(struct nk_str *str)
{
    struct nk_allocator alloc;
    alloc.userdata.ptr = 0;
    alloc.alloc = nk_malloc;
    alloc.free = nk_mfree;
    nk_buffer_init(&str->buffer, &alloc, 32);
    str->len = 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq -0x9d9(%rip), %rax      # 0x23db0
movq %rax, 0x8(%rsi)
leaq -0x9dc(%rip), %rax      # 0x23db8
movq %rax, 0x10(%rsi)
pushq $0x20
popq %rdx
callq 0x12e80
andl $0x0, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
retq