LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x4aae5(%rip), %xmm0    # 0x6e8b4
jne 0x23dd7
jp 0x23dd7
movl %edi, %edx
jmp 0x23e0e
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_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgba
NK_API struct nk_color
nk_rgba(int r, int g, int b, int a)
{
    struct nk_color ret;
    ret.r = (nk_byte)NK_CLAMP(0, r, 255);
    ret.g = (nk_byte)NK_CLAMP(0, g, 255);
    ret.b = (nk_byte)NK_CLAMP(0, b, 255);
    ret.a = (nk_byte)NK_CLAMP(0, a, 255);
    return ret;
}

// Assembly:
movl $0xff, %eax
cmpl %eax, %edi
cmovgel %eax, %edi
xorl %r8d, %r8d
testl %edi, %edi
cmovlel %r8d, %edi
cmpl %eax, %esi
cmovgel %eax, %esi
testl %esi, %esi
cmovlel %r8d, %esi
cmpl %eax, %edx
cmovgel %eax, %edx
testl %edx, %edx
cmovlel %r8d, %edx
cmpl %eax, %ecx
cmovll %ecx, %eax
testl %eax, %eax
cmovlel %r8d, %eax
shll $0x18, %eax
shll $0x10, %edx
orl %edx, %eax
shll $0x8, %esi
orl %edi, %esi
orl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %edx, %edx
xorl %ecx, %ecx
movzbl (%rax,%rdx), %esi
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x23e8f
addl $-0x57, %esi
jmp 0x23ea0
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x23e9d
addl $-0x37, %esi
jmp 0x23ea0
addl $-0x30, %esi
shll $0x4, %ecx
addl %esi, %ecx
incq %rdx
cmpq $0x1, %rdx
je 0x23e7d
xorl %esi, %esi
xorl %edx, %edx
movzbl 0x2(%rax,%rsi), %edi
leal -0x61(%rdi), %r8d
cmpb $0x5, %r8b
ja 0x23ec6
addl $-0x57, %edi
jmp 0x23ed8
leal -0x41(%rdi), %r8d
cmpb $0x5, %r8b
ja 0x23ed5
addl $-0x37, %edi
jmp 0x23ed8
addl $-0x30, %edi
shll $0x4, %edx
addl %edi, %edx
incq %rsi
cmpq $0x1, %rsi
je 0x23eb2
xorl %edi, %edi
xorl %esi, %esi
movzbl 0x4(%rax,%rdi), %r8d
leal -0x61(%r8), %r9d
cmpb $0x5, %r9b
ja 0x23f00
addl $-0x57, %r8d
jmp 0x23f14
leal -0x41(%r8), %r9d
cmpb $0x5, %r9b
ja 0x23f10
addl $-0x37, %r8d
jmp 0x23f14
addl $-0x30, %r8d
shll $0x4, %esi
addl %r8d, %esi
incq %rdi
cmpq $0x1, %rdi
je 0x23eea
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_O1/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 %edx, %edx
xorl %eax, %eax
movzbl (%rcx,%rdx), %esi
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x23f5a
addl $-0x57, %esi
jmp 0x23f6b
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x23f68
addl $-0x37, %esi
jmp 0x23f6b
addl $-0x30, %esi
shll $0x4, %eax
addl %esi, %eax
incq %rdx
cmpq $0x1, %rdx
je 0x23f48
xorl %esi, %esi
xorl %edx, %edx
movzbl 0x2(%rcx,%rsi), %edi
leal -0x61(%rdi), %r8d
cmpb $0x5, %r8b
ja 0x23f91
addl $-0x57, %edi
jmp 0x23fa3
leal -0x41(%rdi), %r8d
cmpb $0x5, %r8b
ja 0x23fa0
addl $-0x37, %edi
jmp 0x23fa3
addl $-0x30, %edi
shll $0x4, %edx
addl %edi, %edx
incq %rsi
cmpq $0x1, %rsi
je 0x23f7d
xorl %edi, %edi
xorl %esi, %esi
movzbl 0x4(%rcx,%rdi), %r8d
leal -0x61(%r8), %r9d
cmpb $0x5, %r9b
ja 0x23fcb
addl $-0x57, %r8d
jmp 0x23fdf
leal -0x41(%r8), %r9d
cmpb $0x5, %r9b
ja 0x23fdb
addl $-0x37, %r8d
jmp 0x23fdf
addl $-0x30, %r8d
shll $0x4, %esi
addl %r8d, %esi
incq %rdi
cmpq $0x1, %rdi
je 0x23fb5
xorl %r8d, %r8d
xorl %edi, %edi
movzbl 0x6(%rcx,%r8), %r9d
leal -0x61(%r9), %r10d
cmpb $0x5, %r10b
ja 0x24009
addl $-0x57, %r9d
jmp 0x2401d
leal -0x41(%r9), %r10d
cmpb $0x5, %r10b
ja 0x24019
addl $-0x37, %r9d
jmp 0x2401d
addl $-0x30, %r9d
shll $0x4, %edi
addl %r9d, %edi
incq %r8
cmpq $0x1, %r8
je 0x23ff3
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_O1/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 0x4a485(%rip), %xmm2    # 0x6e510
movdqa %xmm2, %xmm0
pcmpgtd 0x4a489(%rip), %xmm0    # 0x6e520
movdqa 0x4a491(%rip), %xmm1    # 0x6e530
por %xmm2, %xmm1
paddd 0x4a495(%rip), %xmm2    # 0x6e540
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_O1/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 0x4a398(%rip), %xmm2    # 0x6e510
movdqa %xmm2, %xmm0
pcmpgtd 0x4a39c(%rip), %xmm0    # 0x6e520
movdqa 0x4a3a4(%rip), %xmm1    # 0x6e530
por %xmm2, %xmm1
paddd 0x4a3a8(%rip), %xmm2    # 0x6e540
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_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgb
NK_API struct nk_color
nk_rgb(int r, int g, int b)
{
    struct nk_color ret;
    ret.r = (nk_byte)NK_CLAMP(0, r, 255);
    ret.g = (nk_byte)NK_CLAMP(0, g, 255);
    ret.b = (nk_byte)NK_CLAMP(0, b, 255);
    ret.a = (nk_byte)255;
    return ret;
}

// Assembly:
movl $0xff, %eax
cmpl %eax, %edi
cmovgel %eax, %edi
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
cmpl %eax, %esi
cmovgel %eax, %esi
testl %esi, %esi
cmovlel %ecx, %esi
cmpl %eax, %edx
cmovll %edx, %eax
testl %eax, %eax
cmovlel %ecx, %eax
shll $0x10, %eax
shll $0x8, %esi
orl %esi, %eax
orl %edi, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a5e8(%rip), %xmm4    # 0x6e8b4
movaps %xmm4, %xmm6
minss %xmm0, %xmm6
movss 0x4a5dd(%rip), %xmm0    # 0x6e8b8
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_O1/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 0x4a52d(%rip), %xmm3    # 0x6e8b4
movaps %xmm3, %xmm4
minss %xmm2, %xmm4
movl $0xff000000, %ecx       # imm = 0xFF000000
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm4
jbe 0x243b0
mulss 0x4a515(%rip), %xmm4    # 0x6e8b8
cvttss2si %xmm4, %ecx
shll $0x10, %ecx
orl $0xff000000, %ecx       # imm = 0xFF000000
movaps %xmm3, %xmm4
minss %xmm1, %xmm4
movss 0x4a4f9(%rip), %xmm1    # 0x6e8b8
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_O1/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 0x4a463(%rip), %xmm4    # 0x6e8b8
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_O1/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 0x245e1
divss 0x4a33e(%rip), %xmm0    # 0x6e8bc
cvttss2si %xmm0, %eax
cvttps2dq %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
subss %xmm4, %xmm0
movss 0x4a31f(%rip), %xmm5    # 0x6e8b4
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 0x2461a
mulss %xmm0, %xmm1
subss %xmm1, %xmm5
mulss %xmm2, %xmm5
leaq 0x4a430(%rip), %rcx     # 0x6ea00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movaps %xmm5, %xmm0
movaps %xmm2, %xmm1
jmp 0x24620
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 0x2462a
movaps %xmm2, %xmm0
movaps %xmm4, %xmm1
movaps %xmm5, %xmm4
jmp 0x24620
movaps %xmm4, %xmm0
movaps %xmm5, %xmm1
jmp 0x2460a
movaps %xmm6, %xmm0
movaps %xmm4, %xmm1
movaps %xmm2, %xmm4
jmp 0x24620
movaps %xmm4, %xmm0
movaps %xmm2, %xmm1
movaps %xmm6, %xmm4
jmp 0x24620
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_O1/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 0x4a213(%rip), %xmm1    # 0x6e8c0
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_O1/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 0x4a252(%rip), %xmm1    # 0x6e9a0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
andl %r11d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
shrl $0x18, %r10d
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
andl %r11d, %r9d
xorps %xmm0, %xmm0
cvtsi2sd %r9d, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
xorps %xmm0, %xmm0
cvtsi2sd %r10d, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49f8c(%rip), %xmm3    # 0x6e8c4
andps %xmm2, %xmm3
jbe 0x2494e
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 0x49f68(%rip), %xmm5    # 0x6e8c8
subss %xmm3, %xmm5
movaps %xmm0, %xmm2
cmpltss %xmm4, %xmm2
andps %xmm2, %xmm5
andnps %xmm3, %xmm2
orps %xmm5, %xmm2
jbe 0x2497b
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 0x49f30(%rip), %xmm4    # 0x6e8cc
mulss %xmm5, %xmm4
movss 0x49f28(%rip), %xmm6    # 0x6e8d0
addss %xmm6, %xmm4
divss %xmm4, %xmm3
addss %xmm3, %xmm2
movaps 0x49bb5(%rip), %xmm3    # 0x6e570
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_O1/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 0x49db8(%rip), %xmm0    # 0x6e8b8
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_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hsva_b
NK_API void
nk_color_hsva_b(nk_byte *h, nk_byte *s, nk_byte *v, nk_byte *a, struct nk_color in)
{
    int tmp[4];
    nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in);
    *h = (nk_byte)tmp[0];
    *s = (nk_byte)tmp[1];
    *v = (nk_byte)tmp[2];
    *a = (nk_byte)tmp[3];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %rsp, %r13
movq %r13, %rdi
callq 0x12640
movb (%r13), %al
movb %al, (%r12)
movb 0x4(%r13), %al
movb %al, (%r15)
movb 0x8(%r13), %al
movb %al, (%r14)
movb 0xc(%r13), %al
movb %al, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12640
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_O1/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 $0x28, %rsp
movl %esi, %r8d
movq %rdi, %rbx
leaq 0x14(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
callq 0x12640
movb (%r14), %al
movb %al, (%rbx)
movb 0x4(%r14), %al
movb %al, 0x1(%rbx)
movb 0x8(%r14), %al
movb %al, 0x2(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
jne 0x24d1d
movq 0x632fa(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4d08b(%rip), %rsi     # 0x71d8c
leaq 0x4d0a2(%rip), %rdx     # 0x71daa
movl $0x1fa8, %ecx           # imm = 0x1FA8
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x24d50
movq 0x632c7(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4d058(%rip), %rsi     # 0x71d8c
leaq 0x4d06f(%rip), %rdx     # 0x71daa
movl $0x1fa9, %ecx           # imm = 0x1FA9
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
xorl %eax, %eax
testq %r15, %r15
je 0x24e5e
testq %rbx, %rbx
je 0x24e5e
testl %r14d, %r14d
je 0x24e5e
movl $0xfffd, (%rbx)         # imm = 0xFFFD
movb (%r15), %al
xorl %r12d, %r12d
leaq 0x4cfa0(%rip), %rcx     # 0x71d20
leaq 0x4cf9e(%rip), %rdx     # 0x71d25
movb (%r12,%rcx), %sil
movl %esi, %edi
andb %al, %dil
cmpb (%r12,%rdx), %dil
je 0x24da9
incq %r12
cmpq $0x5, %r12
jne 0x24d87
xorl %esi, %esi
movl $0x5, %r12d
jmp 0x24db2
notb %sil
andb %sil, %al
movzbl %al, %esi
leal -0x1(%r12), %edi
movl $0x1, %eax
cmpl $0x2, %edi
ja 0x24e5e
cmpl $0x2, %r14d
setl %al
cmpl $0x2, %r12d
setge %dil
setl %r8b
orb %al, %r8b
jne 0x24e47
leal -0x2(%r12), %eax
addl $-0x2, %r14d
cmpl %r14d, %eax
cmovbl %eax, %r14d
addl $0x2, %r14d
movl $0x1, %eax
movb (%r15,%rax), %dil
xorl %r8d, %r8d
movb (%r8,%rcx), %r9b
movl %r9d, %r10d
andb %dil, %r10b
cmpb (%r8,%rdx), %r10b
je 0x24e1d
incq %r8
cmpq $0x5, %r8
jne 0x24dfd
xorl %r8d, %r8d
xorl %edi, %edi
jmp 0x24e2e
notb %r9b
andb %r9b, %dil
movzbl %dil, %edi
testq %r8, %r8
sete %r8b
testb %r8b, %r8b
je 0x24e5e
shll $0x6, %esi
orl %edi, %esi
incq %rax
cmpq %r14, %rax
jne 0x24df6
cmpl %eax, %r12d
seta %dil
xorl %eax, %eax
testb %dil, %dil
jne 0x24e5e
movl %esi, (%rbx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x24e6a
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24e89
movslq %esi, %rax
leaq 0x4ceb6(%rip), %rdx     # 0x71d30
movl (%rdi), %ecx
cmpl %ecx, (%rdx,%rax,4)
jbe 0x24eb6
movl $0xfffd, (%rdi)         # imm = 0xFFFD
jmp 0x24ed0
movq 0x63160(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4cef2(%rip), %rsi     # 0x71d8c
leaq 0x4cf09(%rip), %rdx     # 0x71daa
movl $0x1f8f, %ecx           # imm = 0x1F8F
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
leal -0xd800(%rcx), %edx
cmpl $0x7ff, %edx            # imm = 0x7FF
jb 0x24e81
leaq 0x4ce85(%rip), %rdx     # 0x71d50
cmpl (%rdx,%rax,4), %ecx
jae 0x24e81
movl (%rdi), %eax
leaq 0x4ce7b(%rip), %rcx     # 0x71d54
leaq 0x4(%rcx), %rdx
cmpl (%rcx), %eax
movq %rdx, %rcx
ja 0x24ed9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4ce40(%rip), %rax     # 0x71d50
movq %rcx, %rdi
incq %rcx
cmpl 0x4(%rax,%rdi,4), %r8d
ja 0x24f10
cmpl %edx, %ecx
setg %dl
cmpq $0x5, %rcx
setae %dil
xorl %eax, %eax
orb %dl, %dil
jne 0x24f70
cmpq $0x1, %rcx
je 0x24f52
leaq -0x1(%rcx), %rax
cltq
movl %r8d, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, (%rsi,%rax)
shrl $0x6, %r8d
decq %rax
jne 0x24f3d
leaq 0x4cdcc(%rip), %rax     # 0x71d25
leaq 0x4cdc0(%rip), %rdx     # 0x71d20
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_O1/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
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x24fb3
movq 0x63062(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4cdf4(%rip), %rsi     # 0x71d8c
leaq 0x4ce0b(%rip), %rdx     # 0x71daa
movl $0x1fdc, %ecx           # imm = 0x1FDC
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
sete %al
testl %ebx, %ebx
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x2500c
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x12ef0
testl %eax, %eax
sete %cl
testl %ebx, %ebx
setle %dl
orb %cl, %dl
jne 0x2500c
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %ebp, %ebp
addl %eax, %r12d
incl %ebp
movslq %r12d, %rax
leaq (%r14,%rax), %rdi
movl %ebx, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x12ef0
testl %eax, %eax
je 0x2500c
cmpl %r12d, %ebx
jg 0x24feb
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movq %rcx, %r15
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x25068
movq 0x62faf(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x4cd40(%rip), %rsi     # 0x71d8c
leaq 0x4cd57(%rip), %rdx     # 0x71daa
movl $0x1ff3, %ecx           # imm = 0x1FF3
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %r15, %r15
jne 0x2509b
movq 0x62f7c(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x4cd0d(%rip), %rsi     # 0x71d8c
leaq 0x4cd24(%rip), %rdx     # 0x71daa
movl $0x1ff4, %ecx           # imm = 0x1FF4
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %rbp, %rbp
jne 0x250ce
movq 0x62f49(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x4ccda(%rip), %rsi     # 0x71d8c
leaq 0x4ccf1(%rip), %rdx     # 0x71daa
movl $0x1ff5, %ecx           # imm = 0x1FF5
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %rbp, %rbp
sete %al
testq %r15, %r15
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
orb %al, %dl
jne 0x25157
testl %r14d, %r14d
js 0x2512a
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x12ef0
testl %eax, %eax
je 0x2513a
movq %rbp, (%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpl %ebp, %r14d
je 0x25141
incl %ebp
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 0x25106
jmp 0x2514a
movl $0xfffd, (%r15)         # imm = 0xFFFD
movl $0x0, (%rbp)
jmp 0x25157
xorl %r13d, %r13d
xorl %ebp, %ebp
jmp 0x2514a
movq (%rsp), %rcx
movl %eax, (%rcx)
movl %r14d, %ebp
cmpl %r14d, %ebp
jne 0x25157
movslq %r13d, %rax
addq %rax, %rbx
jmp 0x25159
xorl %ebx, %ebx
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_O1/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        # 0x2519e
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x251a6
movq %rax, 0x10(%rsi)
movl $0x1000, %edx           # imm = 0x1000
callq 0x12d60
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x251f5
movq 0x62e22(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4cbb3(%rip), %rsi     # 0x71d8c
leaq 0x4cbca(%rip), %rdx     # 0x71daa
movl $0x2035, %ecx           # imm = 0x2035
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r14, %r14
jne 0x25228
movq 0x62def(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4cb80(%rip), %rsi     # 0x71d8c
leaq 0x4cb97(%rip), %rdx     # 0x71daa
movl $0x2036, %ecx           # imm = 0x2036
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
jne 0x2525b
movq 0x62dbc(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4cb4d(%rip), %rsi     # 0x71d8c
leaq 0x4cb64(%rip), %rdx     # 0x71daa
movl $0x2037, %ecx           # imm = 0x2037
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
orb %al, %dl
jne 0x25307
movq %rbx, %r12
andq $0x3, %r12
je 0x2529f
movl $0x4, %r13d
subq %r12, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
orq $0x74, %r12
addq %rbx, %r13
jmp 0x252a8
movl $0x78, %r12d
movq %rbx, %r13
movl %r12d, %ebp
andl $-0x4, %ebp
movq %r13, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x12b50
andq $0x3, %r12
je 0x252d1
addq %rbp, %r13
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
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 %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
jne 0x25416
movq 0x62c01(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4c992(%rip), %rsi     # 0x71d8c
leaq 0x4c9a9(%rip), %rdx     # 0x71daa
movl $0x2045, %ecx           # imm = 0x2045
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
jne 0x25449
movq 0x62bce(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4c95f(%rip), %rsi     # 0x71d8c
leaq 0x4c976(%rip), %rdx     # 0x71daa
movl $0x2046, %ecx           # imm = 0x2046
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x2547c
movq 0x62b9b(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4c92c(%rip), %rsi     # 0x71d8c
leaq 0x4c943(%rip), %rdx     # 0x71daa
movl $0x2047, %ecx           # imm = 0x2047
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
sete %al
testq %r15, %r15
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
orb %al, %dl
jne 0x25502
movq %r14, %r12
andq $0x3, %r12
je 0x254bc
movl $0x4, %r13d
subq %r12, %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
orq $0x74, %r12
addq %r14, %r13
jmp 0x254c5
movl $0x78, %r12d
movq %r14, %r13
movl %r12d, %ebp
andl $-0x4, %ebp
movq %r13, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x12b50
andq $0x3, %r12
je 0x254ee
addq %rbp, %r13
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
movl $0x0, 0x38(%r14)
movq %r15, 0x40(%r14)
movq %rbx, 0x48(%r14)
movq %rbx, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25a3b
movl %esi, %ecx
shlq $0x4, %rcx
leaq (%rdi,%rcx), %rax
movl $0x1, (%rdi,%rcx)
cmpl $0x1, %esi
jne 0x25a69
movq 0x70(%rdi), %rcx
jmp 0x25a6d
pushq %rbx
movq 0x625ad(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4c33f(%rip), %rsi     # 0x71d8c
leaq 0x4c356(%rip), %rdx     # 0x71daa
movl $0x20d3, %ecx           # imm = 0x20D3
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
movq 0x58(%rdi), %rcx
movq %rcx, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25aa2
cmpl $0x1, %esi
jne 0x25ad0
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)
movl $0x0, 0x10(%rdi)
retq
pushq %rbx
movq 0x62546(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4c2d8(%rip), %rsi     # 0x71d8c
leaq 0x4c2ef(%rip), %rdx     # 0x71daa
movl $0x20dd, %ecx           # imm = 0x20DD
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
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)
movl $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25b19
movq $0x0, 0x58(%rdi)
movq 0x48(%rdi), %rax
movq %rax, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
retq
pushq %rbx
movq 0x624cf(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4c261(%rip), %rsi     # 0x71d8c
leaq 0x4c278(%rip), %rdx     # 0x71daa
movl $0x20f2, %ecx           # imm = 0x20F2
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O1/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 0x25b6b
movq 0x40(%rdi), %rsi
testq %rsi, %rsi
je 0x25b6a
cmpl $0x0, 0x38(%rdi)
je 0x25b6a
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x25b6a
movq 0x20(%rdi), %rdi
jmpq *%rax
retq
pushq %rbx
movq 0x6247d(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4c20f(%rip), %rsi     # 0x71d8c
leaq 0x4c226(%rip), %rdx     # 0x71daa
movl $0x20fc, %ecx           # imm = 0x20FC
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x25bd5
movq 0x62440(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4c1d2(%rip), %rsi     # 0x71d8c
leaq 0x4c1e9(%rip), %rdx     # 0x71daa
movl $0x2106, %ecx           # imm = 0x2106
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x25c06
movq 0x6240f(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4c1a1(%rip), %rsi     # 0x71d8c
leaq 0x4c1b8(%rip), %rdx     # 0x71daa
movl $0x2107, %ecx           # imm = 0x2107
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x25c36
movq 0x48(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x58(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
movq 0x40(%r14), %rax
movq %rax, (%rbx)
movq 0x68(%r14), %rax
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rsi)
leaq -0xb91(%rip), %rax      # 0x2519e
movq %rax, 0x8(%rsi)
leaq -0xb94(%rip), %rax      # 0x251a6
movq %rax, 0x10(%rsi)
movl $0x20, %edx
callq 0x12d60
movl $0x0, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_text_char
NK_API int
nk_str_append_text_char(struct nk_str *s, const char *str, int len)
{
    char *mem;
    NK_ASSERT(s);
    NK_ASSERT(str);
    if (!s || !str || !len) return 0;
    mem = (char*)nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0);
    if (!mem) return 0;
    NK_MEMCPY(mem, str, (nk_size)len * sizeof(char));
    s->len += nk_utf_len(str, len);
    return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
jne 0x25dbd
movq 0x6225a(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4bfeb(%rip), %rsi     # 0x71d8c
leaq 0x4c002(%rip), %rdx     # 0x71daa
movl $0x214b, %ecx           # imm = 0x214B
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
jne 0x25df0
movq 0x62227(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4bfb8(%rip), %rsi     # 0x71d8c
leaq 0x4bfcf(%rip), %rdx     # 0x71daa
movl $0x214c, %ecx           # imm = 0x214C
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
xorl %r12d, %r12d
testq %r14, %r14
je 0x25e3a
testq %r15, %r15
je 0x25e3a
testl %ebx, %ebx
je 0x25e3a
movslq %ebx, %r13
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x25548
testq %rax, %rax
je 0x25e3a
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x258b3
movq %r15, %rdi
movl %ebx, %esi
callq 0x12730
addl %eax, 0x78(%r14)
movl %ebx, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_text_utf8
NK_API int
nk_str_append_text_utf8(struct nk_str *str, const char *text, int len)
{
    int i = 0;
    int byte_len = 0;
    nk_rune unicode;
    if (!str || !text || !len) return 0;
    for (i = 0; i < len; ++i)
        byte_len += nk_utf_decode(text+byte_len, &unicode, 4);
    nk_str_append_text_char(str, text, byte_len);
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testl %edx, %edx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x25ed2
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
jle 0x25ec2
leaq 0x4(%rsp), %r13
movl %ebx, %ebp
movslq %r12d, %r12
leaq (%r14,%r12), %rdi
movq %r13, %rsi
movl $0x4, %edx
callq 0x12ef0
addl %eax, %r12d
decl %ebp
jne 0x25ea7
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x13640
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_str_utf8
NK_API int
nk_str_append_str_utf8(struct nk_str *str, const char *text)
{
    int byte_len = 0;
    int num_runes = 0;
    int glyph_len = 0;
    nk_rune unicode;
    if (!str || !text) return 0;

    glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
    while (unicode != '\0' && glyph_len) {
        glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
        byte_len += glyph_len;
        num_runes++;
    }
    nk_str_append_text_char(str, text, byte_len);
    return num_runes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x25f6d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r12
movq %rsi, %rdi
movq %r12, %rsi
movl $0x4, %edx
callq 0x12ef0
movl %eax, %r15d
cmpl $0x0, (%r12)
setne %al
testl %r15d, %r15d
setne %cl
andb %al, %cl
xorl %ebp, %ebp
cmpb $0x1, %cl
jne 0x25f5f
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movslq %r15d, %r15
leaq (%rbx,%r15), %rdi
movq %r12, %rsi
movl $0x4, %edx
callq 0x12ef0
addl %eax, %r15d
incl %ebp
cmpl $0x0, 0xc(%rsp)
je 0x25f5f
testl %eax, %eax
jne 0x25f3b
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x13640
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq