LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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, -0x4(%rsp)
movq %rdi, -0x10(%rsp)
movzbl -0x4(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
cmpl $0x9, %eax
jg 0x2ccf1
movzbl -0x4(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
addl $0x30, %eax
movl %eax, -0x14(%rsp)
jmp 0x2cd05
movzbl -0x4(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
addl $0x37, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movzbl -0x4(%rsp), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jg 0x2cd30
movzbl -0x4(%rsp), %eax
andl $0xf, %eax
addl $0x30, %eax
movl %eax, -0x18(%rsp)
jmp 0x2cd3f
movzbl -0x4(%rsp), %eax
andl $0xf, %eax
addl $0x37, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movzbl -0x3(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
cmpl $0x9, %eax
jg 0x2cd75
movzbl -0x3(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
addl $0x30, %eax
movl %eax, -0x1c(%rsp)
jmp 0x2cd89
movzbl -0x3(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
addl $0x37, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movzbl -0x3(%rsp), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jg 0x2cdb5
movzbl -0x3(%rsp), %eax
andl $0xf, %eax
addl $0x30, %eax
movl %eax, -0x20(%rsp)
jmp 0x2cdc4
movzbl -0x3(%rsp), %eax
andl $0xf, %eax
addl $0x37, %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x3(%rax)
movzbl -0x2(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
cmpl $0x9, %eax
jg 0x2cdfa
movzbl -0x2(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
addl $0x30, %eax
movl %eax, -0x24(%rsp)
jmp 0x2ce0e
movzbl -0x2(%rsp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
addl $0x37, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x4(%rax)
movzbl -0x2(%rsp), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jg 0x2ce3a
movzbl -0x2(%rsp), %eax
andl $0xf, %eax
addl $0x30, %eax
movl %eax, -0x28(%rsp)
jmp 0x2ce49
movzbl -0x2(%rsp), %eax
andl $0xf, %eax
addl $0x37, %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x6(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
cmpl $0xff, -0x8(%rsp)
jge 0x2cf10
movl -0x8(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x2cf1b
movl $0xff, %eax
movl %eax, -0x14(%rsp)
jmp 0x2cf1b
movl -0x14(%rsp), %eax
cmpl $0x0, %eax
jge 0x2cf2c
xorl %eax, %eax
movl %eax, -0x18(%rsp)
jmp 0x2cf53
cmpl $0xff, -0x8(%rsp)
jge 0x2cf40
movl -0x8(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x2cf4b
movl $0xff, %eax
movl %eax, -0x1c(%rsp)
jmp 0x2cf4b
movl -0x1c(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movb %al, -0x4(%rsp)
cmpl $0xff, -0xc(%rsp)
jge 0x2cf6f
movl -0xc(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x2cf7a
movl $0xff, %eax
movl %eax, -0x20(%rsp)
jmp 0x2cf7a
movl -0x20(%rsp), %eax
cmpl $0x0, %eax
jge 0x2cf8b
xorl %eax, %eax
movl %eax, -0x24(%rsp)
jmp 0x2cfb2
cmpl $0xff, -0xc(%rsp)
jge 0x2cf9f
movl -0xc(%rsp), %eax
movl %eax, -0x28(%rsp)
jmp 0x2cfaa
movl $0xff, %eax
movl %eax, -0x28(%rsp)
jmp 0x2cfaa
movl -0x28(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movb %al, -0x3(%rsp)
cmpl $0xff, -0x10(%rsp)
jge 0x2cfce
movl -0x10(%rsp), %eax
movl %eax, -0x2c(%rsp)
jmp 0x2cfd9
movl $0xff, %eax
movl %eax, -0x2c(%rsp)
jmp 0x2cfd9
movl -0x2c(%rsp), %eax
cmpl $0x0, %eax
jge 0x2cfea
xorl %eax, %eax
movl %eax, -0x30(%rsp)
jmp 0x2d011
cmpl $0xff, -0x10(%rsp)
jge 0x2cffe
movl -0x10(%rsp), %eax
movl %eax, -0x34(%rsp)
jmp 0x2d009
movl $0xff, %eax
movl %eax, -0x34(%rsp)
jmp 0x2d009
movl -0x34(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x30(%rsp), %eax
movb %al, -0x2(%rsp)
movb $-0x1, -0x1(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgba_u32
NK_API struct nk_color
nk_rgba_u32(nk_uint in)
{
    struct nk_color ret;
    ret.r = (in & 0xFF);
    ret.g = ((in >> 8) & 0xFF);
    ret.b = ((in >> 16) & 0xFF);
    ret.a = (nk_byte)((in >> 24) & 0xFF);
    return ret;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
andl $0xff, %eax
movb %al, -0x4(%rsp)
movl -0x8(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x3(%rsp)
movl -0x8(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x2(%rsp)
movl -0x8(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x1(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_rgb_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 %xmm0, -0x8(%rsp)
movss %xmm1, -0xc(%rsp)
movss %xmm2, -0x10(%rsp)
movss -0x8(%rsp), %xmm0
movss 0x80098(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jbe 0x2d465
movss 0x8008b(%rip), %xmm0    # 0xad4e8
movss %xmm0, -0x14(%rsp)
jmp 0x2d471
movss -0x8(%rsp), %xmm0
movss %xmm0, -0x14(%rsp)
movss -0x14(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2d4bc
movss -0x8(%rsp), %xmm0
movss 0x8005b(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jbe 0x2d4a2
movss 0x8004e(%rip), %xmm0    # 0xad4e8
movss %xmm0, -0x18(%rsp)
jmp 0x2d4ae
movss -0x8(%rsp), %xmm0
movss %xmm0, -0x18(%rsp)
movss -0x18(%rsp), %xmm0
movss %xmm0, -0x1c(%rsp)
jmp 0x2d4c7
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rsp)
jmp 0x2d4c7
movss -0x1c(%rsp), %xmm0
movss 0x80017(%rip), %xmm1    # 0xad4ec
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x4(%rsp)
movss -0xc(%rsp), %xmm0
movss 0x7fff9(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jbe 0x2d504
movss 0x7ffec(%rip), %xmm0    # 0xad4e8
movss %xmm0, -0x20(%rsp)
jmp 0x2d510
movss -0xc(%rsp), %xmm0
movss %xmm0, -0x20(%rsp)
movss -0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2d55b
movss -0xc(%rsp), %xmm0
movss 0x7ffbc(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jbe 0x2d541
movss 0x7ffaf(%rip), %xmm0    # 0xad4e8
movss %xmm0, -0x24(%rsp)
jmp 0x2d54d
movss -0xc(%rsp), %xmm0
movss %xmm0, -0x24(%rsp)
movss -0x24(%rsp), %xmm0
movss %xmm0, -0x28(%rsp)
jmp 0x2d566
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rsp)
jmp 0x2d566
movss -0x28(%rsp), %xmm0
movss 0x7ff78(%rip), %xmm1    # 0xad4ec
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x3(%rsp)
movss -0x10(%rsp), %xmm0
movss 0x7ff5a(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jbe 0x2d5a3
movss 0x7ff4d(%rip), %xmm0    # 0xad4e8
movss %xmm0, -0x2c(%rsp)
jmp 0x2d5af
movss -0x10(%rsp), %xmm0
movss %xmm0, -0x2c(%rsp)
movss -0x2c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2d5fa
movss -0x10(%rsp), %xmm0
movss 0x7ff1d(%rip), %xmm1    # 0xad4e8
ucomiss %xmm1, %xmm0
jbe 0x2d5e0
movss 0x7ff10(%rip), %xmm0    # 0xad4e8
movss %xmm0, -0x30(%rsp)
jmp 0x2d5ec
movss -0x10(%rsp), %xmm0
movss %xmm0, -0x30(%rsp)
movss -0x30(%rsp), %xmm0
movss %xmm0, -0x34(%rsp)
jmp 0x2d605
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rsp)
jmp 0x2d605
movss -0x34(%rsp), %xmm0
movss 0x7fed9(%rip), %xmm1    # 0xad4ec
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x2(%rsp)
movb $-0x1, -0x1(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl %edi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
cmpl $0xff, 0x50(%rsp)
jge 0x2d718
movl 0x50(%rsp), %eax
movl %eax, 0x30(%rsp)
jmp 0x2d723
movl $0xff, %eax
movl %eax, 0x30(%rsp)
jmp 0x2d723
movl 0x30(%rsp), %eax
cmpl $0x0, %eax
jge 0x2d734
xorl %eax, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2d75b
cmpl $0xff, 0x50(%rsp)
jge 0x2d748
movl 0x50(%rsp), %eax
movl %eax, 0x28(%rsp)
jmp 0x2d753
movl $0xff, %eax
movl %eax, 0x28(%rsp)
jmp 0x2d753
movl 0x28(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss 0x7fd81(%rip), %xmm1    # 0xad4ec
divss %xmm1, %xmm0
movss %xmm0, 0x40(%rsp)
cmpl $0xff, 0x4c(%rsp)
jge 0x2d789
movl 0x4c(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2d794
movl $0xff, %eax
movl %eax, 0x24(%rsp)
jmp 0x2d794
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jge 0x2d7a5
xorl %eax, %eax
movl %eax, 0x20(%rsp)
jmp 0x2d7cc
cmpl $0xff, 0x4c(%rsp)
jge 0x2d7b9
movl 0x4c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x2d7c4
movl $0xff, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2d7c4
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss 0x7fd10(%rip), %xmm1    # 0xad4ec
divss %xmm1, %xmm0
movss %xmm0, 0x3c(%rsp)
cmpl $0xff, 0x48(%rsp)
jge 0x2d7fa
movl 0x48(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x2d805
movl $0xff, %eax
movl %eax, 0x18(%rsp)
jmp 0x2d805
movl 0x18(%rsp), %eax
cmpl $0x0, %eax
jge 0x2d816
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x2d83d
cmpl $0xff, 0x48(%rsp)
jge 0x2d82a
movl 0x48(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2d835
movl $0xff, %eax
movl %eax, 0x10(%rsp)
jmp 0x2d835
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss 0x7fc9f(%rip), %xmm1    # 0xad4ec
divss %xmm1, %xmm0
movss %xmm0, 0x38(%rsp)
cmpl $0xff, 0x44(%rsp)
jge 0x2d86b
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x2d876
movl $0xff, %eax
movl %eax, 0xc(%rsp)
jmp 0x2d876
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jge 0x2d887
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x2d8ae
cmpl $0xff, 0x44(%rsp)
jge 0x2d89b
movl 0x44(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x2d8a6
movl $0xff, %eax
movl %eax, 0x4(%rsp)
jmp 0x2d8a6
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss 0x7fc2e(%rip), %xmm1    # 0xad4ec
divss %xmm1, %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x40(%rsp), %xmm0
movss 0x3c(%rsp), %xmm1
movss 0x38(%rsp), %xmm2
movss 0x34(%rsp), %xmm3
callq 0x146f0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_u32
NK_API nk_uint
nk_color_u32(struct nk_color in)
{
    nk_uint out = (nk_uint)in.r;
    out |= ((nk_uint)in.g << 8);
    out |= ((nk_uint)in.b << 16);
    out |= ((nk_uint)in.a << 24);
    return out;
}

// Assembly:
movl %edi, -0x4(%rsp)
movzbl -0x4(%rsp), %eax
movl %eax, -0x8(%rsp)
movzbl -0x3(%rsp), %eax
shll $0x8, %eax
orl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movzbl -0x2(%rsp), %eax
shll $0x10, %eax
orl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movzbl -0x1(%rsp), %eax
shll $0x18, %eax
orl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x4(%rsp)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movzbl -0x4(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss 0x7f68a(%rip), %xmm1    # 0xad4f4
mulss %xmm1, %xmm0
movq -0x10(%rsp), %rax
movss %xmm0, (%rax)
movzbl -0x3(%rsp), %eax
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
movq -0x18(%rsp), %rax
movss %xmm0, (%rax)
movzbl -0x2(%rsp), %eax
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
movq -0x20(%rsp), %rax
movss %xmm0, (%rax)
movzbl -0x1(%rsp), %eax
cvtsi2ss %eax, %xmm0
movss 0x7f640(%rip), %xmm1    # 0xad4f4
mulss %xmm1, %xmm0
movq -0x28(%rsp), %rax
movss %xmm0, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x4(%rsp)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movzbl -0x4(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x7f65e(%rip), %xmm1    # 0xad5d8
mulsd %xmm1, %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movzbl -0x3(%rsp), %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
movzbl -0x2(%rsp), %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movzbl -0x1(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x7f614(%rip), %xmm1    # 0xad5d8
mulsd %xmm1, %xmm0
movq -0x28(%rsp), %rax
movsd %xmm0, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movlpd %xmm0, -0x10(%rsp)
movlpd %xmm1, -0x8(%rsp)
movq %rdi, -0x18(%rsp)
movq %rsi, -0x20(%rsp)
movq %rdx, -0x28(%rsp)
movq %rcx, -0x30(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rsp)
movss -0xc(%rsp), %xmm1
movss -0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2e17c
movss -0xc(%rsp), %xmm0
movss %xmm0, -0x3c(%rsp)
movss -0x8(%rsp), %xmm0
movss %xmm0, -0xc(%rsp)
movss -0x3c(%rsp), %xmm0
movss %xmm0, -0x8(%rsp)
movss 0x7f382(%rip), %xmm0    # 0xad4f8
movss %xmm0, -0x38(%rsp)
movss -0x10(%rsp), %xmm1
movss -0xc(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2e1c5
movss -0x10(%rsp), %xmm0
movss %xmm0, -0x40(%rsp)
movss -0xc(%rsp), %xmm0
movss %xmm0, -0x10(%rsp)
movss -0x40(%rsp), %xmm0
movss %xmm0, -0xc(%rsp)
movss 0x7f343(%rip), %xmm0    # 0xad4fc
subss -0x38(%rsp), %xmm0
movss %xmm0, -0x38(%rsp)
movss -0x10(%rsp), %xmm0
movss %xmm0, -0x44(%rsp)
movss -0xc(%rsp), %xmm1
movss -0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2e1f0
movss -0xc(%rsp), %xmm0
movss %xmm0, -0x48(%rsp)
jmp 0x2e1fc
movss -0x8(%rsp), %xmm0
movss %xmm0, -0x48(%rsp)
movss -0x44(%rsp), %xmm0
movss -0x48(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x34(%rsp)
movss -0x38(%rsp), %xmm1
movss -0xc(%rsp), %xmm0
subss -0x8(%rsp), %xmm0
movss -0x34(%rsp), %xmm2
movss 0x7f2ce(%rip), %xmm3    # 0xad500
mulss %xmm3, %xmm2
movss 0x7f2c6(%rip), %xmm3    # 0xad504
addss %xmm3, %xmm2
divss %xmm2, %xmm0
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2e29f
movss -0x38(%rsp), %xmm0
movss -0xc(%rsp), %xmm1
subss -0x8(%rsp), %xmm1
movss -0x34(%rsp), %xmm2
movss 0x7f28e(%rip), %xmm3    # 0xad500
mulss %xmm3, %xmm2
movss 0x7f286(%rip), %xmm3    # 0xad504
addss %xmm3, %xmm2
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x4c(%rsp)
jmp 0x2e2dd
movss -0x38(%rsp), %xmm0
movss -0xc(%rsp), %xmm1
subss -0x8(%rsp), %xmm1
movss -0x34(%rsp), %xmm2
movss 0x7f241(%rip), %xmm3    # 0xad500
mulss %xmm3, %xmm2
movss 0x7f239(%rip), %xmm3    # 0xad504
addss %xmm3, %xmm2
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x4c(%rsp)
movss -0x4c(%rsp), %xmm0
movq -0x18(%rsp), %rax
movss %xmm0, (%rax)
movss -0x34(%rsp), %xmm0
movss 0x7f20a(%rip), %xmm1    # 0xad504
addss -0x10(%rsp), %xmm1
divss %xmm1, %xmm0
movq -0x20(%rsp), %rax
movss %xmm0, (%rax)
movss -0x10(%rsp), %xmm0
movq -0x28(%rsp), %rax
movss %xmm0, (%rax)
movss -0x4(%rsp), %xmm0
movq -0x30(%rsp), %rax
movss %xmm0, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %r8d, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x34(%rsp), %r8d
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
callq 0x14910
movss 0xc(%rsp), %xmm0
movss 0x7f0e5(%rip), %xmm1    # 0xad4ec
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movzbl %al, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movss 0x8(%rsp), %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movzbl %al, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movss 0x4(%rsp), %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movzbl %al, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movss (%rsp), %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movzbl %al, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_color_hsva_bv
NK_API void
nk_color_hsva_bv(nk_byte *out, struct nk_color in)
{
    int tmp[4];
    nk_color_hsva_i(&tmp[0], &tmp[1], &tmp[2], &tmp[3], in);
    out[0] = (nk_byte)tmp[0];
    out[1] = (nk_byte)tmp[1];
    out[2] = (nk_byte)tmp[2];
    out[3] = (nk_byte)tmp[3];
}

// Assembly:
subq $0x28, %rsp
movl %esi, 0x24(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsp, %rdi
movq %rsp, %rsi
addq $0x4, %rsi
movq %rsp, %rdx
addq $0x8, %rdx
movq %rsp, %rcx
addq $0xc, %rcx
movl 0x24(%rsp), %r8d
callq 0x136d0
movl (%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x2(%rax)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x3(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %r8d, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsp, %rdi
movq %rsp, %rsi
addq $0x4, %rsi
movq %rsp, %rdx
addq $0x8, %rdx
movq %rsp, %rcx
addq $0xc, %rcx
movl 0x34(%rsp), %r8d
callq 0x136d0
movl (%rsp), %eax
movb %al, %cl
movq 0x28(%rsp), %rax
movb %cl, (%rax)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %ecx, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsp, %rdi
movq %rsp, %rsi
addq $0x4, %rsi
movq %rsp, %rdx
addq $0x8, %rdx
movq %rsp, %rcx
addq $0xc, %rcx
movl 0x34(%rsp), %r8d
callq 0x136d0
movl (%rsp), %eax
movb %al, %cl
movq 0x28(%rsp), %rax
movb %cl, (%rax)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %esi, 0x24(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsp, %rdi
movq %rsp, %rsi
addq $0x4, %rsi
movq %rsp, %rdx
addq $0x8, %rdx
movl 0x24(%rsp), %ecx
callq 0x14f00
movl (%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x2(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2e745
movq 0x968d7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x82c7d(%rip), %rsi     # 0xb13a0
leaq 0x82c94(%rip), %rdx     # 0xb13be
movl $0x1fa8, %ecx           # imm = 0x1FA8
movb $0x0, %al
callq 0x13ec0
movq 0x968b3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2e747
jmp 0x2e749
cmpq $0x0, 0x20(%rsp)
jne 0x2e784
movq 0x96898(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x82c3e(%rip), %rsi     # 0xb13a0
leaq 0x82c55(%rip), %rdx     # 0xb13be
movl $0x1fa9, %ecx           # imm = 0x1FA9
movb $0x0, %al
callq 0x13ec0
movq 0x96874(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2e786
cmpq $0x0, 0x28(%rsp)
je 0x2e796
cmpq $0x0, 0x20(%rsp)
jne 0x2e7a3
movl $0x0, 0x34(%rsp)
jmp 0x2e8c0
cmpl $0x0, 0x1c(%rsp)
jne 0x2e7b7
movl $0x0, 0x34(%rsp)
jmp 0x2e8c0
movq 0x20(%rsp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
movq 0x28(%rsp), %rax
leaq 0x10(%rsp), %rsi
movsbl (%rax), %edi
callq 0x2e8d0
movl %eax, 0x8(%rsp)
movl $0x1, %eax
cmpl 0x10(%rsp), %eax
jg 0x2e7ea
cmpl $0x4, 0x10(%rsp)
jl 0x2e7f7
movl $0x1, 0x34(%rsp)
jmp 0x2e8c0
movl $0x1, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x18(%rsp), %ecx
xorl %eax, %eax
cmpl 0x1c(%rsp), %ecx
movb %al, 0x7(%rsp)
jge 0x2e826
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2e830
jmp 0x2e88b
movl 0x8(%rsp), %eax
shll $0x6, %eax
movl %eax, (%rsp)
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %rsi
movsbl (%rax,%rcx), %edi
callq 0x2e8d0
movl %eax, %ecx
movl (%rsp), %eax
orl %ecx, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x2e86e
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2e8c0
jmp 0x2e870
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2e807
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x2e89f
movl $0x0, 0x34(%rsp)
jmp 0x2e8c0
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2e9c0
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x13(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2e91b
movq 0x96701(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x82aa7(%rip), %rsi     # 0xb13a0
leaq 0x82abe(%rip), %rdx     # 0xb13be
movl $0x1f9a, %ecx           # imm = 0x1F9A
movb $0x0, %al
callq 0x13ec0
movq 0x966dd(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2e91d
cmpq $0x0, 0x8(%rsp)
jne 0x2e932
movl $0x0, 0x14(%rsp)
jmp 0x2e9b6
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
cmpl $0x5, (%rax)
jge 0x2e9ae
movzbl 0x13(%rsp), %eax
movq 0x8(%rsp), %rcx
movslq (%rcx), %rdx
leaq 0x82959(%rip), %rcx     # 0xb12b4
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movq 0x8(%rsp), %rcx
movslq (%rcx), %rdx
leaq 0x82949(%rip), %rcx     # 0xb12b9
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2e99e
movsbl 0x13(%rsp), %eax
movq 0x8(%rsp), %rcx
movslq (%rcx), %rdx
leaq 0x82928(%rip), %rcx     # 0xb12b4
movzbl (%rcx,%rdx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x2e9b6
jmp 0x2e9a0
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2e93d
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ea08
movq 0x96614(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x829ba(%rip), %rsi     # 0xb13a0
leaq 0x829d1(%rip), %rdx     # 0xb13be
movl $0x1f8f, %ecx           # imm = 0x1F8F
movb $0x0, %al
callq 0x13ec0
movq 0x965f0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2ea0a
cmpq $0x0, 0x8(%rsp)
jne 0x2ea1f
movl $0x0, 0x14(%rsp)
jmp 0x2eaac
movslq 0x4(%rsp), %rcx
leaq 0x82895(%rip), %rax     # 0xb12c0
movl (%rax,%rcx,4), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
ja 0x2ea6a
movq 0x8(%rsp), %rax
movl (%rax), %eax
movslq 0x4(%rsp), %rdx
leaq 0x82896(%rip), %rcx     # 0xb12e0
cmpl (%rcx,%rdx,4), %eax
jae 0x2ea6a
movq 0x8(%rsp), %rcx
movl $0xd800, %eax           # imm = 0xD800
cmpl (%rcx), %eax
ja 0x2ea75
movq 0x8(%rsp), %rax
cmpl $0xdfff, (%rax)         # imm = 0xDFFF
jae 0x2ea75
movq 0x8(%rsp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
movl $0x1, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movslq 0x4(%rsp), %rdx
leaq 0x82850(%rip), %rcx     # 0xb12e0
cmpl (%rcx,%rdx,4), %eax
jbe 0x2eaa4
jmp 0x2ea97
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2ea7d
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x2e9c0
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jl 0x2eaf9
cmpl $0x0, 0x10(%rsp)
je 0x2eaf9
cmpl $0x4, 0x10(%rsp)
jle 0x2eb03
movl $0x0, 0x24(%rsp)
jmp 0x2eb65
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x2eb47
movl 0x20(%rsp), %edi
xorl %esi, %esi
callq 0x2eb70
movb %al, %dl
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
shrl $0x6, %eax
movl %eax, 0x20(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2eb0e
movl 0x20(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x2eb70
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2ec08
movq 0x96414(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x827ba(%rip), %rsi     # 0xb13a0
leaq 0x827d1(%rip), %rdx     # 0xb13be
movl $0x1fdc, %ecx           # imm = 0x1FDC
movb $0x0, %al
callq 0x13ec0
movq 0x963f0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2ec0a
cmpq $0x0, 0x28(%rsp)
je 0x2ec19
cmpl $0x0, 0x24(%rsp)
jne 0x2ec26
movl $0x0, 0x34(%rsp)
jmp 0x2ecb9
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %edx
leaq 0x4(%rsp), %rsi
callq 0x14030
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0x3(%rsp)
je 0x2ec6b
movl 0x8(%rsp), %eax
cmpl 0x24(%rsp), %eax
setl %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x2ec75
jmp 0x2ecb1
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rax
addq %rax, %rdi
movl 0x10(%rsp), %edx
subl 0x8(%rsp), %edx
leaq 0x4(%rsp), %rsi
callq 0x14030
movl %eax, 0xc(%rsp)
jmp 0x2ec4f
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x37(%rip), %rax        # 0x2ef20
movq %rax, 0x10(%rsp)
leaq 0x4b(%rip), %rax        # 0x2ef40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x13ea0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2efad
movq 0x9606f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x82415(%rip), %rsi     # 0xb13a0
leaq 0x8242c(%rip), %rdx     # 0xb13be
movl $0x2035, %ecx           # imm = 0x2035
movb $0x0, %al
callq 0x13ec0
movq 0x9604b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2efaf
jmp 0x2efb1
cmpq $0x0, 0x8(%rsp)
jne 0x2efec
movq 0x96030(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x823d6(%rip), %rsi     # 0xb13a0
leaq 0x823ed(%rip), %rdx     # 0xb13be
movl $0x2036, %ecx           # imm = 0x2036
movb $0x0, %al
callq 0x13ec0
movq 0x9600c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2efee
jmp 0x2eff0
cmpq $0x0, (%rsp)
jne 0x2f02a
movq 0x95ff2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x82398(%rip), %rsi     # 0xb13a0
leaq 0x823af(%rip), %rdx     # 0xb13be
movl $0x2037, %ecx           # imm = 0x2037
movb $0x0, %al
callq 0x13ec0
movq 0x95fce(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2f02c
cmpq $0x0, 0x10(%rsp)
je 0x2f043
cmpq $0x0, 0x8(%rsp)
je 0x2f043
cmpq $0x0, (%rsp)
jne 0x2f048
jmp 0x2f0d7
movq 0x10(%rsp), %rdi
movl $0x78, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rax
movl $0x1, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rsp), %rdx
movq (%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x10(%rsp), %rax
movss 0x7e433(%rip), %xmm0    # 0xad4e4
movss %xmm0, 0x50(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x30(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2f19d
movq 0x95e7f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x82225(%rip), %rsi     # 0xb13a0
leaq 0x8223c(%rip), %rdx     # 0xb13be
movl $0x2045, %ecx           # imm = 0x2045
movb $0x0, %al
callq 0x13ec0
movq 0x95e5b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2f19f
jmp 0x2f1a1
cmpq $0x0, 0x8(%rsp)
jne 0x2f1dc
movq 0x95e40(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x821e6(%rip), %rsi     # 0xb13a0
leaq 0x821fd(%rip), %rdx     # 0xb13be
movl $0x2046, %ecx           # imm = 0x2046
movb $0x0, %al
callq 0x13ec0
movq 0x95e1c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2f1de
jmp 0x2f1e0
cmpq $0x0, (%rsp)
jne 0x2f21a
movq 0x95e02(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x821a8(%rip), %rsi     # 0xb13a0
leaq 0x821bf(%rip), %rdx     # 0xb13be
movl $0x2047, %ecx           # imm = 0x2047
movb $0x0, %al
callq 0x13ec0
movq 0x95dde(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2f21c
cmpq $0x0, 0x10(%rsp)
je 0x2f233
cmpq $0x0, 0x8(%rsp)
je 0x2f233
cmpq $0x0, (%rsp)
jne 0x2f235
jmp 0x2f278
movq 0x10(%rsp), %rdi
movl $0x78, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x70(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2fad8
movq 0x95544(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x818ea(%rip), %rsi     # 0xb13a0
leaq 0x81901(%rip), %rdx     # 0xb13be
movl $0x20d3, %ecx           # imm = 0x20D3
movb $0x0, %al
callq 0x13ec0
movq 0x95520(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2fada
cmpq $0x0, 0x10(%rsp)
jne 0x2fae4
jmp 0x2fb3d
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
cmpl $0x1, 0xc(%rsp)
jne 0x2fb20
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rcx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x2fb3d
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2fb98
movq 0x95484(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8182a(%rip), %rsi     # 0xb13a0
leaq 0x81841(%rip), %rdx     # 0xb13be
movl $0x20dd, %ecx           # imm = 0x20DD
movb $0x0, %al
callq 0x13ec0
movq 0x95460(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2fb9a
cmpq $0x0, 0x10(%rsp)
jne 0x2fba7
jmp 0x2fcc4
cmpl $0x1, 0xc(%rsp)
jne 0x2fc40
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
subq 0x8(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x2fc13
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x70(%rax)
jmp 0x2fc25
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
jmp 0x2fcc4
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
subq 0x8(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x2fca1
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
jmp 0x2fcae
movq 0x10(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2fd0f
movq 0x9530d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x816b3(%rip), %rsi     # 0xb13a0
leaq 0x816ca(%rip), %rdx     # 0xb13be
movl $0x20f2, %ecx           # imm = 0x20F2
movb $0x0, %al
callq 0x13ec0
movq 0x952e9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2fd11
cmpq $0x0, (%rsp)
jne 0x2fd1a
jmp 0x2fd4e
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq (%rsp), %rax
movq 0x48(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x70(%rax)
movq (%rsp), %rax
movq $0x0, 0x68(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2fd8f
movq 0x9528d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x81633(%rip), %rsi     # 0xb13a0
leaq 0x8164a(%rip), %rdx     # 0xb13be
movl $0x20fc, %ecx           # imm = 0x20FC
movb $0x0, %al
callq 0x13ec0
movq 0x95269(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2fd91
cmpq $0x0, (%rsp)
je 0x2fda3
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2fda5
jmp 0x2fe1a
movq (%rsp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x2fdb1
jmp 0x2fe1a
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x2fdbe
jmp 0x2fe1a
jmp 0x2fdc0
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x2fdfe
movq 0x9521e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x815c4(%rip), %rsi     # 0xb13a0
leaq 0x815db(%rip), %rdx     # 0xb13be
movl $0x2100, %ecx           # imm = 0x2100
movb $0x0, %al
callq 0x13ec0
movq 0x951fa(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2fe00
movq (%rsp), %rax
movq 0x30(%rax), %rax
movq (%rsp), %rcx
movq (%rsp), %rdx
movq 0x40(%rdx), %rsi
movq 0x20(%rcx), %rdi
callq *%rax
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2fe69
movq 0x951b3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x81559(%rip), %rsi     # 0xb13a0
leaq 0x81570(%rip), %rdx     # 0xb13be
movl $0x2106, %ecx           # imm = 0x2106
movb $0x0, %al
callq 0x13ec0
movq 0x9518f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2fe6b
jmp 0x2fe6d
cmpq $0x0, 0x10(%rsp)
jne 0x2fea8
movq 0x95174(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8151a(%rip), %rsi     # 0xb13a0
leaq 0x81531(%rip), %rdx     # 0xb13be
movl $0x2107, %ecx           # imm = 0x2107
movb $0x0, %al
callq 0x13ec0
movq 0x95150(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x2feaa
cmpq $0x0, 0x10(%rsp)
je 0x2feba
cmpq $0x0, 0x8(%rsp)
jne 0x2febc
jmp 0x2ff15
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
leaq -0x1199(%rip), %rax     # 0x2ef20
movq %rax, 0x10(%rsp)
leaq -0x1185(%rip), %rax     # 0x2ef40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x20, %edx
callq 0x13ea0
movq 0x20(%rsp), %rax
movl $0x0, 0x78(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x301bd
movq 0x94e5f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x81205(%rip), %rsi     # 0xb13a0
leaq 0x8121c(%rip), %rdx     # 0xb13be
movl $0x214b, %ecx           # imm = 0x214B
movb $0x0, %al
callq 0x13ec0
movq 0x94e3b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x301bf
jmp 0x301c1
cmpq $0x0, 0x10(%rsp)
jne 0x301fc
movq 0x94e20(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x811c6(%rip), %rsi     # 0xb13a0
leaq 0x811dd(%rip), %rdx     # 0xb13be
movl $0x214c, %ecx           # imm = 0x214C
movb $0x0, %al
callq 0x13ec0
movq 0x94dfc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x301fe
cmpq $0x0, 0x18(%rsp)
je 0x30215
cmpq $0x0, 0x10(%rsp)
je 0x30215
cmpl $0x0, 0xc(%rsp)
jne 0x3021f
movl $0x0, 0x24(%rsp)
jmp 0x30287
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rdx
shlq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x2f2e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x3024d
movl $0x0, 0x24(%rsp)
jmp 0x30287
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
shlq $0x0, %rdx
callq 0x2f750
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x137e0
movl %eax, %ecx
movq 0x18(%rsp), %rax
addl 0x78(%rax), %ecx
movl %ecx, 0x78(%rax)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x30319
cmpq $0x0, 0x10(%rsp)
je 0x30319
cmpl $0x0, 0xc(%rsp)
jne 0x30323
movl $0x0, 0x24(%rsp)
jmp 0x3037f
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x30364
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rax
addq %rax, %rdi
movq %rsp, %rsi
movl $0x4, %edx
callq 0x14030
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3032b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x14820
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)