LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_text_runes
NK_API int
nk_str_append_text_runes(struct nk_str *str, const nk_rune *text, int len)
{
    int i = 0;
    int byte_len = 0;
    nk_glyph glyph;

    NK_ASSERT(str);
    if (!str || !text || !len) return 0;
    for (i = 0; i < len; ++i) {
        byte_len = nk_utf_encode(text[i], glyph, NK_UTF_SIZE);
        if (!byte_len) break;
        nk_str_append_text_char(str, glyph, byte_len);
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x25fc2
movq 0x62055(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4bde6(%rip), %rsi     # 0x71d8c
leaq 0x4bdfd(%rip), %rdx     # 0x71daa
movl $0x217e, %ecx           # imm = 0x217E
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
xorl %eax, %eax
testq %r15, %r15
je 0x2600a
testq %r14, %r14
je 0x2600a
testl %ebx, %ebx
je 0x2600a
jle 0x26008
movl %ebx, %r13d
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movl (%r14,%rbp,4), %edi
movq %r12, %rsi
movl $0x4, %edx
callq 0x12e50
testl %eax, %eax
je 0x26008
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x13640
incq %rbp
cmpq %rbp, %r13
jne 0x25fde
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_runes
NK_API int
nk_str_append_str_runes(struct nk_str *str, const nk_rune *runes)
{
    int i = 0;
    nk_glyph glyph;
    int byte_len;
    NK_ASSERT(str);
    if (!str || !runes) return 0;
    while (runes[i] != '\0') {
        byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE);
        nk_str_append_text_char(str, glyph, byte_len);
        i++;
    }
    return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x26058
movq 0x61fbd(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4bd4f(%rip), %rsi     # 0x71d8c
leaq 0x4bd66(%rip), %rdx     # 0x71daa
movl $0x218d, %ecx           # imm = 0x218D
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x2609f
movl (%rbx), %edi
testl %edi, %edi
je 0x2609f
xorl %r15d, %r15d
leaq 0x4(%rsp), %r12
movq %r12, %rsi
movl $0x4, %edx
callq 0x12e50
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x13640
movl 0x4(%rbx,%r15,4), %edi
incq %r15
testl %edi, %edi
jne 0x26079
movl %r15d, %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_str_insert_at_rune
NK_API int
nk_str_insert_at_rune(struct nk_str *str, int pos, const char *cstr, int len)
{
    int glyph_len;
    nk_rune unicode;
    const char *begin;
    const char *buffer;

    NK_ASSERT(str);
    NK_ASSERT(cstr);
    NK_ASSERT(len);
    if (!str || !cstr || !len) return 0;
    begin = nk_str_at_rune(str, pos, &unicode, &glyph_len);
    if (!str->len)
        return nk_str_append_text_char(str, cstr, len);
    buffer = nk_str_get_const(str);
    if (!begin) return 0;
    return nk_str_insert_at_char(str, (int)(begin - buffer), cstr, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testq %rdi, %rdi
jne 0x2630d
movq 0x61d0a(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4ba9b(%rip), %rsi     # 0x71d8c
leaq 0x4bab2(%rip), %rdx     # 0x71daa
movl $0x21c1, %ecx           # imm = 0x21C1
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r14, %r14
jne 0x26340
movq 0x61cd7(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4ba68(%rip), %rsi     # 0x71d8c
leaq 0x4ba7f(%rip), %rdx     # 0x71daa
movl $0x21c2, %ecx           # imm = 0x21C2
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testl %ebx, %ebx
jne 0x26372
movq 0x61ca5(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4ba36(%rip), %rsi     # 0x71d8c
leaq 0x4ba4d(%rip), %rdx     # 0x71daa
movl $0x21c3, %ecx           # imm = 0x21C3
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testl %ebx, %ebx
sete %cl
testq %r14, %r14
sete %al
testq %r15, %r15
sete %dl
orb %al, %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x263dd
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x123e0
cmpl $0x0, 0x78(%r15)
je 0x263b8
movq %rax, %rsi
xorl %eax, %eax
cmpq $0x0, 0x58(%r15)
je 0x263c7
movq 0x40(%r15), %rcx
jmp 0x263c9
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13640
jmp 0x263dd
xorl %ecx, %ecx
testq %rsi, %rsi
je 0x263dd
subl %ecx, %esi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x120c0
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_str_at_rune
NK_API char*
nk_str_at_rune(struct nk_str *str, int pos, nk_rune *unicode, int *len)
{
    int i = 0;
    int src_len = 0;
    int glyph_len = 0;
    char *text;
    int text_len;

    NK_ASSERT(str);
    NK_ASSERT(unicode);
    NK_ASSERT(len);

    if (!str || !unicode || !len) return 0;
    if (pos < 0) {
        *unicode = 0;
        *len = 0;
        return 0;
    }

    text = (char*)str->buffer.memory.ptr;
    text_len = (int)str->buffer.allocated;
    glyph_len = nk_utf_decode(text, unicode, text_len);
    while (glyph_len) {
        if (i == pos) {
            *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 != pos) return 0;
    return text + src_len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %r12
testq %rdi, %rdi
jne 0x26432
movq 0x61be3(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4b975(%rip), %rsi     # 0x71d8c
leaq 0x4b98c(%rip), %rdx     # 0x71daa
movl $0x226e, %ecx           # imm = 0x226E
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
testq %r15, %r15
jne 0x26463
movq 0x61bb2(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4b944(%rip), %rsi     # 0x71d8c
leaq 0x4b95b(%rip), %rdx     # 0x71daa
movl $0x226f, %ecx           # imm = 0x226F
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
testq %rbp, %rbp
jne 0x26494
movq 0x61b81(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4b913(%rip), %rsi     # 0x71d8c
leaq 0x4b92a(%rip), %rdx     # 0x71daa
movl $0x2270, %ecx           # imm = 0x2270
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
testq %rbp, %rbp
sete %al
testq %r15, %r15
sete %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
orb %al, %dl
jne 0x26521
testl %r14d, %r14d
js 0x264f8
movq %rbp, (%rsp)
movq 0x40(%r12), %r13
movl 0x58(%r12), %ebp
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x12ef0
testl %eax, %eax
je 0x26504
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpl %ebx, %r14d
je 0x2650b
incl %ebx
addl %eax, %r12d
movslq %r12d, %rax
leaq (%rax,%r13), %rdi
movl %ebp, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x12ef0
testl %eax, %eax
jne 0x264d5
jmp 0x26514
xorl %r13d, %r13d
movl %r13d, (%r15)
movl %r13d, (%rbp)
jmp 0x26524
xorl %r12d, %r12d
xorl %ebx, %ebx
jmp 0x26514
movq (%rsp), %rcx
movl %eax, (%rcx)
movl %r14d, %ebx
cmpl %r14d, %ebx
jne 0x26521
movslq %r12d, %rax
addq %rax, %r13
jmp 0x26524
xorl %r13d, %r13d
movq %r13, %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_str_insert_text_utf8
NK_API int
nk_str_insert_text_utf8(struct nk_str *str, int pos, const char *text, int len)
{
    int i = 0;
    int byte_len = 0;
    nk_rune unicode;

    NK_ASSERT(str);
    NK_ASSERT(text);
    if (!str || !text || !len) return 0;
    for (i = 0; i < len; ++i)
        byte_len += nk_utf_decode(text+byte_len, &unicode, 4);
    nk_str_insert_at_rune(str, pos, text, byte_len);
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
testq %rdi, %rdi
jne 0x265db
movq 0x61a3a(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4b7cc(%rip), %rsi     # 0x71d8c
leaq 0x4b7e3(%rip), %rdx     # 0x71daa
movl $0x21dd, %ecx           # imm = 0x21DD
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
testq %r14, %r14
jne 0x2660c
movq 0x61a09(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4b79b(%rip), %rsi     # 0x71d8c
leaq 0x4b7b2(%rip), %rdx     # 0x71daa
movl $0x21de, %ecx           # imm = 0x21DE
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
xorl %eax, %eax
testq %r15, %r15
je 0x2665f
testq %r14, %r14
je 0x2665f
testl %ebp, %ebp
je 0x2665f
movl %r12d, (%rsp)
jle 0x26649
xorl %r12d, %r12d
leaq 0x4(%rsp), %r13
movl %ebp, %ebx
movslq %r12d, %r12
leaq (%r14,%r12), %rdi
movq %r13, %rsi
movl $0x4, %edx
callq 0x12ef0
addl %eax, %r12d
decl %ebx
jne 0x2662c
jmp 0x2664c
xorl %r12d, %r12d
movq %r15, %rdi
movl (%rsp), %esi
movq %r14, %rdx
movl %r12d, %ecx
callq 0x12600
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_insert_str_utf8
NK_API int
nk_str_insert_str_utf8(struct nk_str *str, int pos, 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_insert_at_rune(str, pos, text, byte_len);
    return num_runes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x26727
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movq %rdx, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x12ef0
movl %eax, %r12d
cmpl $0x0, (%r15)
setne %al
testl %r12d, %r12d
setne %cl
andb %al, %cl
xorl %r15d, %r15d
cmpb $0x1, %cl
jne 0x26717
xorl %r15d, %r15d
leaq 0x4(%rsp), %r13
movslq %r12d, %r12
leaq (%rbx,%r12), %rdi
movq %r13, %rsi
movl $0x4, %edx
callq 0x12ef0
addl %eax, %r12d
incl %r15d
cmpl $0x0, 0x4(%rsp)
je 0x26717
testl %eax, %eax
jne 0x266f2
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x12600
movl %r15d, %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_insert_text_runes
NK_API int
nk_str_insert_text_runes(struct nk_str *str, int pos, const nk_rune *runes, int len)
{
    int i = 0;
    int byte_len = 0;
    nk_glyph glyph;

    NK_ASSERT(str);
    if (!str || !runes || !len) return 0;
    for (i = 0; i < len; ++i) {
        byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE);
        if (!byte_len) break;
        nk_str_insert_at_rune(str, pos+i, glyph, byte_len);
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdi, %rdi
jne 0x26780
movq 0x61895(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4b627(%rip), %rsi     # 0x71d8c
leaq 0x4b63e(%rip), %rdx     # 0x71daa
movl $0x21fe, %ecx           # imm = 0x21FE
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
xorl %r15d, %r15d
testq %r14, %r14
je 0x267cf
testq %rbx, %rbx
je 0x267cf
testl %r12d, %r12d
je 0x267cf
movl %r12d, %r15d
jle 0x267cf
movl %ebp, %r13d
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movl (%rbx,%rbp,4), %edi
movq %r12, %rsi
movl $0x4, %edx
callq 0x12e50
testl %eax, %eax
je 0x267cf
leal (%r13,%rbp), %esi
movq %r14, %rdi
movq %r12, %rdx
movl %eax, %ecx
callq 0x12600
incq %rbp
cmpq %rbp, %r15
jne 0x267a1
movl %r15d, %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_insert_str_runes
NK_API int
nk_str_insert_str_runes(struct nk_str *str, int pos, const nk_rune *runes)
{
    int i = 0;
    nk_glyph glyph;
    int byte_len;
    NK_ASSERT(str);
    if (!str || !runes) return 0;
    while (runes[i] != '\0') {
        byte_len = nk_utf_encode(runes[i], glyph, NK_UTF_SIZE);
        nk_str_insert_at_rune(str, pos+i, glyph, byte_len);
        i++;
    }
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdi, %rdi
jne 0x26825
movq 0x617f0(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4b582(%rip), %rsi     # 0x71d8c
leaq 0x4b599(%rip), %rdx     # 0x71daa
movl $0x220d, %ecx           # imm = 0x220D
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x26873
movl (%rbx), %edi
testl %edi, %edi
je 0x26873
movl %ebp, %r13d
xorl %r15d, %r15d
leaq 0x4(%rsp), %r12
movq %r12, %rsi
movl $0x4, %edx
callq 0x12e50
leal (%r15,%r13), %esi
movq %r14, %rdi
movq %r12, %rdx
movl %eax, %ecx
callq 0x12600
movl 0x4(%rbx,%r15,4), %edi
incq %r15
testl %edi, %edi
jne 0x26849
movl %r15d, %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_remove_chars
NK_API void
nk_str_remove_chars(struct nk_str *s, int len)
{
    NK_ASSERT(s);
    NK_ASSERT(len >= 0);
    if (!s || len < 0 || (nk_size)len > s->buffer.allocated) return;
    NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0);
    s->buffer.allocated -= (nk_size)len;
    s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x268c2
movq 0x61753(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4b4e5(%rip), %rsi     # 0x71d8c
leaq 0x4b4fc(%rip), %rdx     # 0x71daa
movl $0x2219, %ecx           # imm = 0x2219
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testl %ebp, %ebp
jns 0x268f2
movq 0x61723(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4b4b5(%rip), %rsi     # 0x71d8c
leaq 0x4b4cc(%rip), %rdx     # 0x71daa
movl $0x221a, %ecx           # imm = 0x221A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
sete %al
testl %ebp, %ebp
sets %cl
orb %al, %cl
jne 0x26954
movl %ebp, %r14d
movq 0x58(%rbx), %rax
cmpq %r14, %rax
jb 0x26954
cmpl %ebp, %eax
jge 0x2693d
movq 0x616d8(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4b46a(%rip), %rsi     # 0x71d8c
leaq 0x4b481(%rip), %rdx     # 0x71daa
movl $0x221c, %ecx           # imm = 0x221C
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x40(%rbx), %rdi
movq 0x58(%rbx), %rsi
subq %r14, %rsi
movq %rsi, 0x58(%rbx)
callq 0x12730
movl %eax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_remove_runes
NK_API void
nk_str_remove_runes(struct nk_str *str, int len)
{
    int index;
    const char *begin;
    const char *end;
    nk_rune unicode;

    NK_ASSERT(str);
    NK_ASSERT(len >= 0);
    if (!str || len < 0) return;
    if (len >= str->len) {
        str->len = 0;
        return;
    }

    index = str->len - len;
    begin = nk_str_at_rune(str, index, &unicode, &len);
    end = (const char*)str->buffer.memory.ptr + str->buffer.allocated;
    nk_str_remove_chars(str, (int)(end-begin)+1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rsp)
testq %rdi, %rdi
jne 0x2699a
movq 0x6167b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4b40d(%rip), %rsi     # 0x71d8c
leaq 0x4b424(%rip), %rdx     # 0x71daa
movl $0x2228, %ecx           # imm = 0x2228
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x0, (%rsp)
jns 0x269cc
movq 0x61649(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4b3db(%rip), %rsi     # 0x71d8c
leaq 0x4b3f2(%rip), %rdx     # 0x71daa
movl $0x2229, %ecx           # imm = 0x2229
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
sete %cl
movl (%rsp), %eax
testl %eax, %eax
sets %dl
orb %cl, %dl
jne 0x26a10
movl 0x78(%rbx), %esi
subl %eax, %esi
jle 0x26a09
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x123e0
movl 0x40(%rbx), %esi
addl 0x58(%rbx), %esi
subl %eax, %esi
incl %esi
movq %rbx, %rdi
callq 0x13cb0
jmp 0x26a10
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_delete_chars
NK_API void
nk_str_delete_chars(struct nk_str *s, int pos, int len)
{
    NK_ASSERT(s);
    if (!s || !len || (nk_size)pos > s->buffer.allocated ||
        (nk_size)(pos + len) > s->buffer.allocated) return;

    if ((nk_size)(pos + len) < s->buffer.allocated) {
        /* memmove */
        char *dst = nk_ptr_add(char, s->buffer.memory.ptr, pos);
        char *src = nk_ptr_add(char, s->buffer.memory.ptr, pos + len);
        NK_MEMCPY(dst, src, s->buffer.allocated - (nk_size)(pos + len));
        NK_ASSERT(((int)s->buffer.allocated - (int)len) >= 0);
        s->buffer.allocated -= (nk_size)len;
    } else nk_str_remove_chars(s, len);
    s->len = nk_utf_len((char *)s->buffer.memory.ptr, (int)s->buffer.allocated);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x26a58
movq 0x615bd(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4b34f(%rip), %rsi     # 0x71d8c
leaq 0x4b366(%rip), %rdx     # 0x71daa
movl $0x2238, %ecx           # imm = 0x2238
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %rbx, %rbx
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x26ae2
movslq %r14d, %rdi
movq 0x58(%rbx), %rdx
cmpq %rdi, %rdx
jb 0x26ae2
addl %ebp, %r14d
movslq %r14d, %rsi
subq %rsi, %rdx
jb 0x26ae2
jbe 0x26ac9
movq 0x40(%rbx), %rax
addq %rax, %rdi
addq %rax, %rsi
callq 0x258b3
cmpl %ebp, 0x58(%rbx)
jge 0x26ac0
movq 0x61555(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x4b2e7(%rip), %rsi     # 0x71d8c
leaq 0x4b2fe(%rip), %rdx     # 0x71daa
movl $0x2241, %ecx           # imm = 0x2241
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movslq %ebp, %rax
subq %rax, 0x58(%rbx)
jmp 0x26ad3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13cb0
movq 0x40(%rbx), %rdi
movl 0x58(%rbx), %esi
callq 0x12730
movl %eax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_delete_runes
NK_API void
nk_str_delete_runes(struct nk_str *s, int pos, int len)
{
    char *temp;
    nk_rune unicode;
    char *begin;
    char *end;
    int unused;

    NK_ASSERT(s);
    NK_ASSERT(s->len >= pos + len);
    if (s->len < pos + len)
        len = NK_CLAMP(0, (s->len - pos), s->len);
    if (!len) return;

    temp = (char *)s->buffer.memory.ptr;
    begin = nk_str_at_rune(s, pos, &unicode, &unused);
    if (!begin) return;
    s->buffer.memory.ptr = begin;
    end = nk_str_at_rune(s, len, &unicode, &unused);
    s->buffer.memory.ptr = temp;
    if (!end) return;
    nk_str_delete_chars(s, (int)(begin - temp), (int)(end - begin));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x26b35
movq 0x614e2(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4b273(%rip), %rsi     # 0x71d8c
leaq 0x4b28a(%rip), %rdx     # 0x71daa
movl $0x224f, %ecx           # imm = 0x224F
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
leal (%r14,%r15), %ebp
cmpl %ebp, 0x78(%rbx)
jge 0x26b6c
movq 0x614ab(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x4b23c(%rip), %rsi     # 0x71d8c
leaq 0x4b253(%rip), %rdx     # 0x71daa
movl $0x2250, %ecx           # imm = 0x2250
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movl 0x78(%rbx), %eax
cmpl %ebp, %eax
jge 0x26b8b
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
subl %edx, %eax
testl %eax, %eax
cmovlel %ecx, %eax
movl %eax, %r14d
testl %r14d, %r14d
je 0x26be6
movq 0x40(%rbx), %r12
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x123e0
testq %rax, %rax
je 0x26be6
movq %rax, %r15
movq %rax, 0x40(%rbx)
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x123e0
movq %r12, 0x40(%rbx)
testq %rax, %rax
je 0x26be6
subl %r15d, %eax
subl %r12d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x12900
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_push_scissor
NK_API void
nk_push_scissor(struct nk_command_buffer *b, struct nk_rect r)
{
    struct nk_command_scissor *cmd;
    NK_ASSERT(b);
    if (!b) return;

    b->clip.x = r.x;
    b->clip.y = r.y;
    b->clip.w = r.w;
    b->clip.h = r.h;
    cmd = (struct nk_command_scissor*)
        nk_command_buffer_push(b, NK_COMMAND_SCISSOR, sizeof(*cmd));

    if (!cmd) return;
    cmd->x = (short)r.x;
    cmd->y = (short)r.y;
    cmd->w = (unsigned short)NK_MAX(0, r.w);
    cmd->h = (unsigned short)NK_MAX(0, r.h);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x2700c
movdqa %xmm0, (%rsp)
movdqa %xmm1, 0x10(%rsp)
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movdqu %xmm0, 0x8(%rdi)
movl $0x18, %edx
movl $0x1, %esi
callq 0x2703d
testq %rax, %rax
je 0x27006
cvttps2dq (%rsp), %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x10(%rax)
pxor %xmm0, %xmm0
movaps 0x10(%rsp), %xmm1
maxps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x14(%rax)
addq $0x20, %rsp
popq %rbx
retq
movq 0x60fdd(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x4ad6f(%rip), %rsi     # 0x71d8c
leaq 0x4ad86(%rip), %rdx     # 0x71daa
movl $0x232f, %ecx           # imm = 0x232F
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_command_buffer_push
NK_LIB void*
nk_command_buffer_push(struct nk_command_buffer* b,
    enum nk_command_type t, nk_size size)
{
    NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_command);
    struct nk_command *cmd;
    nk_size alignment;
    void *unaligned;
    void *memory;

    NK_ASSERT(b);
    NK_ASSERT(b->base);
    if (!b) return 0;
    cmd = (struct nk_command*)nk_buffer_alloc(b->base,NK_BUFFER_FRONT,size,align);
    if (!cmd) return 0;

    /* make sure the offset to the next command is aligned */
    b->last = (nk_size)((nk_byte*)cmd - (nk_byte*)b->base->memory.ptr);
    unaligned = (nk_byte*)cmd + size;
    memory = NK_ALIGN_PTR(unaligned, align);
    alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned);
#ifdef NK_ZERO_COMMAND_MEMORY
    NK_MEMSET(cmd, 0, size + alignment);
#endif

    cmd->type = t;
    cmd->next = b->base->allocated + alignment;
#ifdef NK_INCLUDE_COMMAND_USERDATA
    cmd->userdata = b->userdata;
#endif
    b->end = cmd->next;
    return cmd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2707e
movq 0x60f97(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4ad29(%rip), %rsi     # 0x71d8c
leaq 0x4ad40(%rip), %rdx     # 0x71daa
movl $0x2315, %ecx           # imm = 0x2315
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq (%rbx), %rdi
xorl %r15d, %r15d
movl $0x8, %ecx
xorl %esi, %esi
movq %r14, %rdx
callq 0x25548
testq %rax, %rax
je 0x270ca
movq (%rbx), %rcx
movq %rax, %rdx
subq 0x40(%rcx), %rdx
movq %rdx, 0x38(%rbx)
leaq (%rax,%r14), %rdx
leaq (%rax,%r14), %rsi
addq $0x7, %rsi
andq $-0x8, %rsi
subq %rdx, %rsi
movl %ebp, (%rax)
addq 0x58(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq %rsi, 0x30(%rbx)
movq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stroke_line
NK_API void
nk_stroke_line(struct nk_command_buffer *b, float x0, float y0,
    float x1, float y1, float line_thickness, struct nk_color c)
{
    struct nk_command_line *cmd;
    NK_ASSERT(b);
    if (!b || line_thickness <= 0) return;
    cmd = (struct nk_command_line*)
        nk_command_buffer_push(b, NK_COMMAND_LINE, sizeof(*cmd));
    if (!cmd) return;
    cmd->line_thickness = (unsigned short)line_thickness;
    cmd->begin.x = (short)x0;
    cmd->begin.y = (short)y0;
    cmd->end.x = (short)x1;
    cmd->end.y = (short)y1;
    cmd->color = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movss %xmm3, 0xc(%rsp)
movdqa %xmm2, 0x20(%rsp)
movdqa %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %rdi, %r14
testq %rdi, %rdi
jne 0x27138
movq 0x60ee7(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4ac79(%rip), %rsi     # 0x71d8c
leaq 0x4ac90(%rip), %rdx     # 0x71daa
movl $0x2344, %ecx           # imm = 0x2344
xorl %eax, %eax
movaps %xmm4, 0x10(%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movaps 0x10(%rsp), %xmm4
testq %r14, %r14
je 0x271aa
xorps %xmm0, %xmm0
ucomiss %xmm4, %xmm0
jae 0x271aa
movl $0x20, %edx
movq %r14, %rdi
movl $0x2, %esi
movaps %xmm4, 0x10(%rsp)
callq 0x2703d
movaps 0x10(%rsp), %xmm0
testq %rax, %rax
je 0x271aa
movaps 0x40(%rsp), %xmm1
unpcklps 0x20(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
unpcklps 0x30(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
cvttps2dq %xmm0, %xmm0
movdqa 0x4741c(%rip), %xmm1    # 0x6e5a0
movdqa %xmm1, %xmm2
pandn %xmm0, %xmm2
packssdw %xmm0, %xmm0
pand %xmm1, %xmm0
por %xmm2, %xmm0
movq %xmm0, 0x10(%rax)
cvttss2si 0xc(%rsp), %ecx
movw %cx, 0x18(%rax)
movl %ebx, 0x1a(%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stroke_curve
NK_API void
nk_stroke_curve(struct nk_command_buffer *b, float ax, float ay,
    float ctrl0x, float ctrl0y, float ctrl1x, float ctrl1y,
    float bx, float by, float line_thickness, struct nk_color col)
{
    struct nk_command_curve *cmd;
    NK_ASSERT(b);
    if (!b || col.a == 0 || line_thickness <= 0) return;

    cmd = (struct nk_command_curve*)
        nk_command_buffer_push(b, NK_COMMAND_CURVE, sizeof(*cmd));
    if (!cmd) return;
    cmd->line_thickness = (unsigned short)line_thickness;
    cmd->begin.x = (short)ax;
    cmd->begin.y = (short)ay;
    cmd->ctrl[0].x = (short)ctrl0x;
    cmd->ctrl[0].y = (short)ctrl0y;
    cmd->ctrl[1].x = (short)ctrl1x;
    cmd->ctrl[1].y = (short)ctrl1y;
    cmd->end.x = (short)bx;
    cmd->end.y = (short)by;
    cmd->color = col;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebx
movaps %xmm7, 0x70(%rsp)
movaps %xmm6, 0x30(%rsp)
movss %xmm5, 0xc(%rsp)
movaps %xmm4, 0x40(%rsp)
movaps %xmm3, 0x60(%rsp)
movdqa %xmm2, 0x50(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdi, %r14
movss 0xa0(%rsp), %xmm1
testq %rdi, %rdi
jne 0x27232
movq 0x60dec(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4ab7e(%rip), %rsi     # 0x71d8c
leaq 0x4ab95(%rip), %rdx     # 0x71daa
movl $0x2356, %ecx           # imm = 0x2356
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movss 0xa0(%rsp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x272e5
testq %r14, %r14
je 0x272e5
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x272e5
movl $0x28, %edx
movq %r14, %rdi
movl $0x3, %esi
callq 0x2703d
movd 0xa0(%rsp), %xmm2
testq %rax, %rax
je 0x272e5
movl %ebx, %ecx
shrl $0x18, %ecx
movdqa 0x20(%rsp), %xmm0
punpckldq 0x30(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
punpckldq 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
movaps 0x60(%rsp), %xmm1
unpcklps 0x40(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movaps 0x70(%rsp), %xmm0
unpcklps 0x50(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
cvttps2dq %xmm0, %xmm0
cvttps2dq %xmm2, %xmm1
movdqa %xmm1, %xmm2
packssdw %xmm0, %xmm2
movdqa 0x472e3(%rip), %xmm0    # 0x6e5a0
pand %xmm0, %xmm2
pandn %xmm1, %xmm0
por %xmm2, %xmm0
cvttss2si 0xc(%rsp), %edx
movw %dx, 0x20(%rax)
movdqu %xmm0, 0x10(%rax)
movw %bx, 0x22(%rax)
shrl $0x10, %ebx
movb %bl, 0x24(%rax)
movb %cl, 0x25(%rax)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_fill_rect
NK_API void
nk_fill_rect(struct nk_command_buffer *b, struct nk_rect rect,
    float rounding, struct nk_color c)
{
    struct nk_command_rect_filled *cmd;
    NK_ASSERT(b);
    if (!b || c.a == 0 || rect.w == 0 || rect.h == 0) return;
    if (b->use_clipping) {
        const struct nk_rect *clip = &b->clip;
        if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h,
            clip->x, clip->y, clip->w, clip->h)) return;
    }

    cmd = (struct nk_command_rect_filled*)
        nk_command_buffer_push(b, NK_COMMAND_RECT_FILLED, sizeof(*cmd));
    if (!cmd) return;
    cmd->rounding = (unsigned short)rounding;
    cmd->x = (short)rect.x;
    cmd->y = (short)rect.y;
    cmd->w = (unsigned short)NK_MAX(0, rect.w);
    cmd->h = (unsigned short)NK_MAX(0, rect.h);
    cmd->color = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movss %xmm2, 0xc(%rsp)
movq %rdi, %r14
testq %rdi, %rdi
jne 0x274d5
movq 0x60b54(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4a8e6(%rip), %rsi     # 0x71d8c
leaq 0x4a8fd(%rip), %rdx     # 0x71daa
movl $0x2383, %ecx           # imm = 0x2383
xorl %eax, %eax
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
testq %r14, %r14
je 0x275c1
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x275c1
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x274f8
jnp 0x275c1
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x2750a
jnp 0x275c1
cmpl $0x0, 0x18(%r14)
je 0x27557
movss 0x8(%r14), %xmm3
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
ucomiss %xmm3, %xmm2
jbe 0x275c1
addss 0x10(%r14), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x275c1
movss 0xc(%r14), %xmm3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss %xmm2, %xmm4
ucomiss %xmm3, %xmm4
jbe 0x275c1
addss 0x14(%r14), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x275c1
movl $0x20, %edx
movq %r14, %rdi
movl $0x5, %esi
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x2703d
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
testq %rax, %rax
je 0x275c1
movl %ebx, %ecx
shrl $0x18, %ecx
cvttss2si 0xc(%rsp), %edx
movw %dx, 0x10(%rax)
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x12(%rax)
pxor %xmm0, %xmm0
maxps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x16(%rax)
movw %bx, 0x1a(%rax)
shrl $0x10, %ebx
movb %bl, 0x1c(%rax)
movb %cl, 0x1d(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_fill_rect_multi_color
NK_API void
nk_fill_rect_multi_color(struct nk_command_buffer *b, struct nk_rect rect,
    struct nk_color left, struct nk_color top, struct nk_color right,
    struct nk_color bottom)
{
    struct nk_command_rect_multi_color *cmd;
    NK_ASSERT(b);
    if (!b || rect.w == 0 || rect.h == 0) return;
    if (b->use_clipping) {
        const struct nk_rect *clip = &b->clip;
        if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h,
            clip->x, clip->y, clip->w, clip->h)) return;
    }

    cmd = (struct nk_command_rect_multi_color*)
        nk_command_buffer_push(b, NK_COMMAND_RECT_MULTI_COLOR, sizeof(*cmd));
    if (!cmd) return;
    cmd->x = (short)rect.x;
    cmd->y = (short)rect.y;
    cmd->w = (unsigned short)NK_MAX(0, rect.w);
    cmd->h = (unsigned short)NK_MAX(0, rect.h);
    cmd->left = left;
    cmd->top = top;
    cmd->right = right;
    cmd->bottom = bottom;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
testq %rdi, %rdi
jne 0x2762c
movq 0x609fd(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x4a78e(%rip), %rsi     # 0x71d8c
leaq 0x4a7a5(%rip), %rdx     # 0x71daa
movl $0x239b, %ecx           # imm = 0x239B
xorl %eax, %eax
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %r12, %r12
je 0x276fd
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x27643
jnp 0x276fd
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x27655
jnp 0x276fd
cmpl $0x0, 0x18(%r12)
je 0x276a3
movss 0x8(%r12), %xmm3
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
ucomiss %xmm3, %xmm2
jbe 0x276fd
addss 0x10(%r12), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x276fd
movss 0xc(%r12), %xmm3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss %xmm2, %xmm4
ucomiss %xmm3, %xmm4
jbe 0x276fd
addss 0x14(%r12), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x276fd
movl $0x28, %edx
movq %r12, %rdi
movl $0x6, %esi
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x2703d
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %rax, %rax
je 0x276fd
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x10(%rax)
pxor %xmm0, %xmm0
maxps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x14(%rax)
movl %r15d, 0x18(%rax)
movl %r14d, 0x1c(%rax)
movl %ebp, 0x24(%rax)
movl %ebx, 0x20(%rax)
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_stroke_circle
NK_API void
nk_stroke_circle(struct nk_command_buffer *b, struct nk_rect r,
    float line_thickness, struct nk_color c)
{
    struct nk_command_circle *cmd;
    if (!b || r.w == 0 || r.h == 0 || line_thickness <= 0) return;
    if (b->use_clipping) {
        const struct nk_rect *clip = &b->clip;
        if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h))
            return;
    }

    cmd = (struct nk_command_circle*)
        nk_command_buffer_push(b, NK_COMMAND_CIRCLE, sizeof(*cmd));
    if (!cmd) return;
    cmd->line_thickness = (unsigned short)line_thickness;
    cmd->x = (short)r.x;
    cmd->y = (short)r.y;
    cmd->w = (unsigned short)NK_MAX(r.w, 0);
    cmd->h = (unsigned short)NK_MAX(r.h, 0);
    cmd->color = c;
}

// Assembly:
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
jae 0x2780f
testq %rdi, %rdi
je 0x2780f
ucomiss %xmm3, %xmm1
jne 0x2772c
jnp 0x2780f
movaps %xmm1, %xmm6
shufps $0x55, %xmm1, %xmm6     # xmm6 = xmm6[1,1],xmm1[1,1]
ucomiss %xmm3, %xmm6
jne 0x2773e
jnp 0x2780f
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
cmpl $0x0, 0x18(%rdi)
je 0x27794
movss 0x8(%rdi), %xmm3
movaps %xmm1, %xmm4
addss %xmm0, %xmm4
ucomiss %xmm3, %xmm4
jbe 0x2780a
addss 0x10(%rdi), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x2780a
movss 0xc(%rdi), %xmm3
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
movaps %xmm5, %xmm4
addss %xmm6, %xmm4
ucomiss %xmm3, %xmm4
jbe 0x2780a
addss 0x14(%rdi), %xmm3
ucomiss %xmm5, %xmm3
jbe 0x2780a
movl $0x20, %edx
movl $0x7, %esi
movaps %xmm0, 0x30(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm6, (%rsp)
callq 0x2703d
movaps (%rsp), %xmm5
movaps 0x10(%rsp), %xmm4
movaps 0x20(%rsp), %xmm3
movaps 0x30(%rsp), %xmm2
testq %rax, %rax
je 0x2780a
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm4, %xmm1
movlhps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
shufps $0x24, %xmm1, %xmm2     # xmm2 = xmm2[0,1],xmm1[2,0]
cvttps2dq %xmm2, %xmm1
pshuflw $0xe8, %xmm1, %xmm2     # xmm2 = xmm1[0,2,2,3,4,5,6,7]
pshufhw $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,1,2,3,4,6,6,7]
pshufd $0xaa, %xmm1, %xmm1     # xmm1 = xmm1[2,2,2,2]
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movq %xmm2, 0x10(%rax)
maxss %xmm5, %xmm0
cvttss2si %xmm0, %ecx
movw %cx, 0x18(%rax)
movl %ebx, 0x1a(%rax)
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_fill_circle
NK_API void
nk_fill_circle(struct nk_command_buffer *b, struct nk_rect r, struct nk_color c)
{
    struct nk_command_circle_filled *cmd;
    NK_ASSERT(b);
    if (!b || c.a == 0 || r.w == 0 || r.h == 0) return;
    if (b->use_clipping) {
        const struct nk_rect *clip = &b->clip;
        if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h))
            return;
    }

    cmd = (struct nk_command_circle_filled*)
        nk_command_buffer_push(b, NK_COMMAND_CIRCLE_FILLED, sizeof(*cmd));
    if (!cmd) return;
    cmd->x = (short)r.x;
    cmd->y = (short)r.y;
    cmd->w = (unsigned short)NK_MAX(r.w, 0);
    cmd->h = (unsigned short)NK_MAX(r.h, 0);
    cmd->color = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x27861
movq 0x607c6(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4a558(%rip), %rsi     # 0x71d8c
leaq 0x4a56f(%rip), %rdx     # 0x71daa
movl $0x23c9, %ecx           # imm = 0x23C9
xorl %eax, %eax
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %r14, %r14
je 0x2793d
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x2793d
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x27884
jnp 0x2793d
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x27896
jnp 0x2793d
cmpl $0x0, 0x18(%r14)
je 0x278df
movss 0x8(%r14), %xmm3
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
ucomiss %xmm3, %xmm2
jbe 0x2793d
addss 0x10(%r14), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x2793d
movss 0xc(%r14), %xmm3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss %xmm2, %xmm4
ucomiss %xmm3, %xmm4
jbe 0x2793d
addss 0x14(%r14), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x2793d
movl $0x20, %edx
movq %r14, %rdi
movl $0x8, %esi
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x2703d
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %rax, %rax
je 0x2793d
movl %ebx, %ecx
shrl $0x18, %ecx
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x10(%rax)
pxor %xmm0, %xmm0
maxps %xmm1, %xmm0
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x14(%rax)
movw %bx, 0x18(%rax)
shrl $0x10, %ebx
movb %bl, 0x1a(%rax)
movb %cl, 0x1b(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stroke_arc
NK_API void
nk_stroke_arc(struct nk_command_buffer *b, float cx, float cy, float radius,
    float a_min, float a_max, float line_thickness, struct nk_color c)
{
    struct nk_command_arc *cmd;
    if (!b || c.a == 0 || line_thickness <= 0) return;
    cmd = (struct nk_command_arc*)
        nk_command_buffer_push(b, NK_COMMAND_ARC, sizeof(*cmd));
    if (!cmd) return;
    cmd->line_thickness = (unsigned short)line_thickness;
    cmd->cx = (short)cx;
    cmd->cy = (short)cy;
    cmd->r = (unsigned short)radius;
    cmd->a[0] = a_min;
    cmd->a[1] = a_max;
    cmd->color = c;
}

// Assembly:
xorps %xmm6, %xmm6
ucomiss %xmm5, %xmm6
jae 0x27a09
testq %rdi, %rdi
je 0x27a09
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
cmpl $0x1000000, %esi        # imm = 0x1000000
jb 0x27a04
movl $0x28, %edx
movl $0x9, %esi
movss %xmm4, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm5, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
callq 0x2703d
movaps 0x10(%rsp), %xmm5
movaps 0x20(%rsp), %xmm4
movaps 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm0
movss 0x8(%rsp), %xmm3
movss 0xc(%rsp), %xmm2
testq %rax, %rax
je 0x27a04
movl %ebx, %ecx
shrl $0x18, %ecx
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
unpcklps %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
movlhps %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
cvttps2dq %xmm4, %xmm0
pshuflw $0xe8, %xmm0, %xmm1     # xmm1 = xmm0[0,2,2,3,4,5,6,7]
pshufhw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,6,6,7]
pshufd $0xaa, %xmm0, %xmm0     # xmm0 = xmm0[2,2,2,2]
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq %xmm1, 0x10(%rax)
movss %xmm3, 0x18(%rax)
movss %xmm2, 0x1c(%rax)
movw %bx, 0x20(%rax)
shrl $0x10, %ebx
movb %bl, 0x22(%rax)
movb %cl, 0x23(%rax)
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_fill_arc
NK_API void
nk_fill_arc(struct nk_command_buffer *b, float cx, float cy, float radius,
    float a_min, float a_max, struct nk_color c)
{
    struct nk_command_arc_filled *cmd;
    NK_ASSERT(b);
    if (!b || c.a == 0) return;
    cmd = (struct nk_command_arc_filled*)
        nk_command_buffer_push(b, NK_COMMAND_ARC_FILLED, sizeof(*cmd));
    if (!cmd) return;
    cmd->cx = (short)cx;
    cmd->cy = (short)cy;
    cmd->r = (unsigned short)radius;
    cmd->a[0] = a_min;
    cmd->a[1] = a_max;
    cmd->color = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movss %xmm4, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movss %xmm2, 0x4(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdi, %r14
testq %rdi, %rdi
jne 0x27a65
movq 0x605b0(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x4a342(%rip), %rsi     # 0x71d8c
leaq 0x4a359(%rip), %rdx     # 0x71daa
movl $0x23f0, %ecx           # imm = 0x23F0
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
sete %al
cmpl $0x1000000, %ebx        # imm = 0x1000000
setb %cl
orb %al, %cl
jne 0x27ad9
movl $0x28, %edx
movq %r14, %rdi
movl $0xa, %esi
callq 0x2703d
testq %rax, %rax
je 0x27ad9
movl %ebx, %ecx
shrl $0x18, %ecx
movaps 0x10(%rsp), %xmm0
unpcklps 0x20(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
cvttss2si 0x4(%rsp), %edx
movd %xmm0, 0x10(%rax)
movw %dx, 0x14(%rax)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x18(%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x1c(%rax)
movw %bx, 0x20(%rax)
shrl $0x10, %ebx
movb %bl, 0x22(%rax)
movb %cl, 0x23(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stroke_polygon
NK_API void
nk_stroke_polygon(struct nk_command_buffer *b,  float *points, int point_count,
    float line_thickness, struct nk_color col)
{
    int i;
    nk_size size = 0;
    struct nk_command_polygon *cmd;

    NK_ASSERT(b);
    if (!b || col.a == 0 || line_thickness <= 0) return;
    size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count;
    cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size);
    if (!cmd) return;
    cmd->color = col;
    cmd->line_thickness = (unsigned short)line_thickness;
    cmd->point_count = (unsigned short)point_count;
    for (i = 0; i < point_count; ++i) {
        cmd->points[i].x = (short)points[i*2];
        cmd->points[i].y = (short)points[i*2+1];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
jne 0x27f05
movq 0x6011e(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x49eaf(%rip), %rsi     # 0x71d8c
leaq 0x49ec6(%rip), %rdx     # 0x71daa
movl $0x243a, %ecx           # imm = 0x243A
xorl %eax, %eax
movss %xmm0, 0xc(%rsp)
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movss 0xc(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x27f8a
testq %r15, %r15
je 0x27f8a
cmpl $0x1000000, %r14d       # imm = 0x1000000
jb 0x27f8a
movslq %ebp, %rax
leaq 0x20(,%rax,4), %rdx
movq %r15, %rdi
movl $0xd, %esi
movss %xmm0, 0xc(%rsp)
callq 0x2703d
movss 0xc(%rsp), %xmm0
testq %rax, %rax
je 0x27f8a
movl %r14d, %ecx
shrl $0x18, %ecx
movw %r14w, 0x10(%rax)
shrl $0x10, %r14d
movb %r14b, 0x12(%rax)
cvttss2si %xmm0, %edx
movb %cl, 0x13(%rax)
movw %dx, 0x14(%rax)
movw %bp, 0x16(%rax)
testl %ebp, %ebp
jle 0x27f8a
movl %ebp, %ecx
xorl %edx, %edx
movsd (%rbx,%rdx,8), %xmm0
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x18(%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x27f6e
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_fill_polygon
NK_API void
nk_fill_polygon(struct nk_command_buffer *b, float *points, int point_count,
    struct nk_color col)
{
    int i;
    nk_size size = 0;
    struct nk_command_polygon_filled *cmd;

    NK_ASSERT(b);
    if (!b || col.a == 0) return;
    size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count;
    cmd = (struct nk_command_polygon_filled*)
        nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size);
    if (!cmd) return;
    cmd->color = col;
    cmd->point_count = (unsigned short)point_count;
    for (i = 0; i < point_count; ++i) {
        cmd->points[i].x = (short)points[i*2+0];
        cmd->points[i].y = (short)points[i*2+1];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
jne 0x27fdd
movq 0x6003a(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x49dcb(%rip), %rsi     # 0x71d8c
leaq 0x49de2(%rip), %rdx     # 0x71daa
movl $0x244f, %ecx           # imm = 0x244F
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
sete %al
cmpl $0x1000000, %r14d       # imm = 0x1000000
setb %cl
orb %al, %cl
jne 0x2804c
movslq %ebp, %rax
leaq 0x20(,%rax,4), %rdx
movq %r15, %rdi
movl $0xe, %esi
callq 0x2703d
testq %rax, %rax
je 0x2804c
movl %r14d, %ecx
shrl $0x18, %ecx
movw %r14w, 0x10(%rax)
shrl $0x10, %r14d
movb %r14b, 0x12(%rax)
movb %cl, 0x13(%rax)
movw %bp, 0x14(%rax)
testl %ebp, %ebp
jle 0x2804c
movl %ebp, %ecx
xorl %edx, %edx
movsd (%rbx,%rdx,8), %xmm0
cvttps2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x16(%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x28030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq