LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_text_char
NK_API int
nk_str_append_text_char(struct nk_str *s, const char *str, int len)
{
    char *mem;
    NK_ASSERT(s);
    NK_ASSERT(str);
    if (!s || !str || !len) return 0;
    mem = (char*)nk_buffer_alloc(&s->buffer, NK_BUFFER_FRONT, (nk_size)len * sizeof(char), 0);
    if (!mem) return 0;
    NK_MEMCPY(mem, str, (nk_size)len * sizeof(char));
    s->len += nk_utf_len(str, len);
    return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
jne 0x2480c
movq 0x6080b(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x4551c(%rip), %rsi     # 0x69d0c
leaq 0x45533(%rip), %rdx     # 0x69d2a
movl $0x214b, %ecx           # imm = 0x214B
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %r15, %r15
je 0x2485e
testq %r14, %r14
sete %al
testl %ebx, %ebx
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x2488d
movslq %ebx, %r13
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x2403e
testq %rax, %rax
je 0x2488d
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x24323
movq %r15, %rdi
movl %ebx, %esi
callq 0x127b0
addl %eax, 0x78(%r14)
movl %ebx, %r12d
jmp 0x2488d
movq 0x6078b(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x4549d(%rip), %rsi     # 0x69d0c
leaq 0x454b4(%rip), %rdx     # 0x69d2a
xorl %r12d, %r12d
movl $0x214c, %ecx           # imm = 0x214C
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_text_utf8
NK_API int
nk_str_append_text_utf8(struct nk_str *str, const char *text, int len)
{
    int i = 0;
    int byte_len = 0;
    nk_rune unicode;
    if (!str || !text || !len) return 0;
    for (i = 0; i < len; ++i)
        byte_len += nk_utf_decode(text+byte_len, &unicode, 4);
    nk_str_append_text_char(str, text, byte_len);
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testl %edx, %edx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x24934
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorl %ebp, %ebp
testl %ebx, %ebx
movl $0x0, %r15d
cmovgl %ebx, %r15d
leaq 0x14(%rsp), %r12
pushq $0x4
popq %r13
subl $0x1, %r15d
jb 0x24923
movslq %ebp, %rdi
addq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x13020
addl %eax, %ebp
jmp 0x24908
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x13800
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_append_str_utf8
NK_API int
nk_str_append_str_utf8(struct nk_str *str, const char *text)
{
    int byte_len = 0;
    int num_runes = 0;
    int glyph_len = 0;
    nk_rune unicode;
    if (!str || !text) return 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x249b3
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
pushq $0x4
popq %r12
movq %rsi, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x13020
movl %eax, %r13d
xorl %ebp, %ebp
cmpl $0x0, 0x4(%rsp)
je 0x249a5
testl %eax, %eax
je 0x249a5
movslq %r13d, %rdi
addq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x13020
addl %eax, %r13d
incl %ebp
jmp 0x24982
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x13800
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x24a08
movq 0x6060d(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x4531f(%rip), %rsi     # 0x69d0c
leaq 0x45336(%rip), %rdx     # 0x69d2a
movl $0x217e, %ecx           # imm = 0x217E
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
xorl %eax, %eax
testq %r15, %r15
je 0x24a5c
testq %r14, %r14
je 0x24a5c
testl %ebp, %ebp
je 0x24a5c
xorl %r13d, %r13d
testl %ebp, %ebp
movl $0x0, %ebx
movl %ebp, (%rsp)
cmovgl %ebp, %ebx
leaq 0x4(%rsp), %r12
pushq $0x4
popq %rbp
cmpq %r13, %rbx
je 0x24a59
movl (%r14,%r13,4), %edi
movq %r12, %rsi
movl %ebp, %edx
callq 0x12f70
testl %eax, %eax
je 0x24a59
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x13800
incq %r13
jmp 0x24a30
movl (%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x24ab5
movq %rsi, %r14
testq %rsi, %rsi
je 0x24ae5
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0xc(%rsp), %r12
pushq $0x4
popq %rbp
movl (%r14,%rbx,4), %edi
testl %edi, %edi
je 0x24ae7
movq %r12, %rsi
movl %ebp, %edx
callq 0x12f70
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x13800
incq %rbx
jmp 0x24a91
movq 0x60534(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x45246(%rip), %rsi     # 0x69d0c
leaq 0x4525d(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x218d, %ecx           # imm = 0x218D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x24ae7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 0x24d63
movq 0x602b4(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x44fc5(%rip), %rsi     # 0x69d0c
leaq 0x44fdc(%rip), %rdx     # 0x69d2a
movl $0x21c1, %ecx           # imm = 0x21C1
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testq %r14, %r14
jne 0x24d96
movq 0x60281(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x44f92(%rip), %rsi     # 0x69d0c
leaq 0x44fa9(%rip), %rdx     # 0x69d2a
movl $0x21c2, %ecx           # imm = 0x21C2
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
testl %ebx, %ebx
je 0x24ddc
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x24e37
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movl %ebp, %esi
callq 0x12420
cmpl $0x0, 0x78(%r15)
je 0x24e0d
xorl %r12d, %r12d
cmpq $0x0, 0x58(%r15)
je 0x24e1c
movq 0x40(%r15), %rcx
jmp 0x24e1e
movq 0x6020d(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44f1f(%rip), %rsi     # 0x69d0c
leaq 0x44f36(%rip), %rdx     # 0x69d2a
xorl %r12d, %r12d
movl $0x21c3, %ecx           # imm = 0x21C3
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
jmp 0x24e37
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13800
jmp 0x24e34
xorl %ecx, %ecx
testq %rax, %rax
je 0x24e37
subl %ecx, %eax
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x120d0
movl %eax, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
testq %rdi, %rdi
jne 0x24e8e
movq 0x60187(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x44e99(%rip), %rsi     # 0x69d0c
leaq 0x44eb0(%rip), %rdx     # 0x69d2a
movl $0x226e, %ecx           # imm = 0x226E
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
testq %r14, %r14
jne 0x24ebf
movq 0x60156(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x44e68(%rip), %rsi     # 0x69d0c
leaq 0x44e7f(%rip), %rdx     # 0x69d2a
movl $0x226f, %ecx           # imm = 0x226F
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
testq %rbx, %rbx
je 0x24f15
testq %r14, %r14
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x24f53
testl %ebp, %ebp
js 0x24f46
movq 0x40(%r12), %r15
movl 0x58(%r12), %r12d
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x13020
xorl %r13d, %r13d
testl %eax, %eax
je 0x24f4f
subl $0x1, %ebp
jb 0x24f58
addl %eax, %r13d
movslq %r13d, %rax
leaq (%r15,%rax), %rdi
movl %r12d, %edx
subl %eax, %edx
movq %r14, %rsi
callq 0x13020
jmp 0x24ef3
movq 0x600d4(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44de6(%rip), %rsi     # 0x69d0c
leaq 0x44dfd(%rip), %rdx     # 0x69d2a
xorl %r15d, %r15d
movl $0x2270, %ecx           # imm = 0x2270
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
jmp 0x24f60
andl $0x0, (%r14)
andl $0x0, (%rbx)
jmp 0x24f53
testl %ebp, %ebp
je 0x24f5a
xorl %r15d, %r15d
jmp 0x24f60
movl %eax, (%rbx)
movslq %r13d, %rax
addq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
testq %rdi, %rdi
jne 0x2501b
movq 0x5fffa(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44d0c(%rip), %rsi     # 0x69d0c
leaq 0x44d23(%rip), %rdx     # 0x69d2a
movl $0x21dd, %ecx           # imm = 0x21DD
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
testq %r14, %r14
je 0x25071
testq %r15, %r15
sete %al
testl %r13d, %r13d
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x250b7
movl %r12d, 0xc(%rsp)
xorl %r12d, %r12d
testl %r13d, %r13d
movl $0x0, %ebx
movl %r13d, 0x10(%rsp)
cmovgl %r13d, %ebx
leaq 0x14(%rsp), %r13
pushq $0x4
popq %rbp
subl $0x1, %ebx
jb 0x250a1
movslq %r12d, %rdi
addq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x13020
addl %eax, %r12d
jmp 0x25057
movq 0x5ff78(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44c8a(%rip), %rsi     # 0x69d0c
leaq 0x44ca1(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x21de, %ecx           # imm = 0x21DE
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
jmp 0x250b7
movq %r15, %rdi
movl 0xc(%rsp), %esi
movq %r14, %rdx
movl %r12d, %ecx
callq 0x12660
movl 0x10(%rsp), %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 0x25165
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, (%rsp)
leaq 0x4(%rsp), %r12
pushq $0x4
popq %r13
movq %rdx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x13020
movl %eax, %ebp
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rsp)
je 0x25155
testl %eax, %eax
je 0x25155
movslq %ebp, %rdi
addq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x13020
addl %eax, %ebp
incl %r15d
jmp 0x25132
movq %r14, %rdi
movl (%rsp), %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x12660
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_O2/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, %r14
movl %esi, %ebp
movq %rdi, %r15
testq %rdi, %rdi
jne 0x251be
movq 0x5fe57(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44b69(%rip), %rsi     # 0x69d0c
leaq 0x44b80(%rip), %rdx     # 0x69d2a
movl $0x21fe, %ecx           # imm = 0x21FE
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
xorl %eax, %eax
testq %r15, %r15
je 0x2521b
testq %r14, %r14
je 0x2521b
testl %r12d, %r12d
je 0x2521b
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebx
movl %r12d, (%rsp)
cmovgl %r12d, %ebx
movl %ebp, %ebp
leaq 0x4(%rsp), %r12
cmpq %r13, %rbx
je 0x25218
movl (%r14,%r13,4), %edi
movq %r12, %rsi
pushq $0x4
popq %rdx
callq 0x12f70
testl %eax, %eax
je 0x25218
leal (%rbp,%r13), %esi
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
callq 0x12660
incq %r13
jmp 0x251e9
movl (%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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
testq %rdi, %rdi
je 0x2527a
movq %rdx, %r14
testq %rdx, %rdx
je 0x252aa
movq %rdi, %r15
movl %esi, %r13d
xorl %ebx, %ebx
leaq 0x4(%rsp), %r12
pushq $0x4
popq %rbp
movl (%r14,%rbx,4), %edi
testl %edi, %edi
je 0x252ac
movq %r12, %rsi
movl %ebp, %edx
callq 0x12f70
leal (%rbx,%r13), %esi
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
callq 0x12660
incq %rbx
jmp 0x25252
movq 0x5fd6f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x44a81(%rip), %rsi     # 0x69d0c
leaq 0x44a98(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x220d, %ecx           # imm = 0x220D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x252ac
xorl %ebx, %ebx
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_O2/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
testq %rdi, %rdi
je 0x2532b
testl %ebp, %ebp
js 0x25366
movq %rdi, %rbx
movl %ebp, %r14d
movq 0x58(%rdi), %rsi
cmpq %r14, %rsi
jb 0x2535b
cmpl %ebp, %esi
jge 0x25316
movq 0x5fd03(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x44a15(%rip), %rsi     # 0x69d0c
leaq 0x44a2c(%rip), %rdx     # 0x69d2a
movl $0x221c, %ecx           # imm = 0x221C
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x58(%rbx), %rsi
subq %r14, %rsi
movq %rsi, 0x58(%rbx)
movq 0x40(%rbx), %rdi
callq 0x127b0
movl %eax, 0x78(%rbx)
jmp 0x2535b
movq 0x5fcbe(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x449d0(%rip), %rsi     # 0x69d0c
leaq 0x449e7(%rip), %rdx     # 0x69d2a
movl $0x2219, %ecx           # imm = 0x2219
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
testl %ebp, %ebp
js 0x25366
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5fc83(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44995(%rip), %rsi     # 0x69d0c
leaq 0x449ac(%rip), %rdx     # 0x69d2a
movl $0x221a, %ecx           # imm = 0x221A
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x8(%rsp)
testq %rdi, %rdi
jne 0x253de
movq 0x5fc37(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x44949(%rip), %rsi     # 0x69d0c
leaq 0x44960(%rip), %rdx     # 0x69d2a
movl $0x2228, %ecx           # imm = 0x2228
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
testl %ebp, %ebp
js 0x25414
testq %rbx, %rbx
je 0x2544c
movl 0x78(%rbx), %esi
subl %ebp, %esi
jle 0x25448
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x12420
movl 0x40(%rbx), %esi
addl 0x58(%rbx), %esi
subl %eax, %esi
incl %esi
movq %rbx, %rdi
callq 0x13eb0
jmp 0x2544c
movq 0x5fbd5(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x448e7(%rip), %rsi     # 0x69d0c
leaq 0x448fe(%rip), %rdx     # 0x69d2a
movl $0x2229, %ecx           # imm = 0x2229
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x13960
andl $0x0, 0x78(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x254e6
movl %edx, %ebp
testl %edx, %edx
je 0x25530
movq %rdi, %rbx
movslq %esi, %rdi
movq 0x58(%rbx), %rdx
cmpq %rdi, %rdx
jb 0x25530
addl %ebp, %esi
movslq %esi, %rsi
subq %rsi, %rdx
jb 0x25530
jbe 0x25516
movq 0x40(%rbx), %rax
addq %rax, %rdi
addq %rax, %rsi
callq 0x24323
movq 0x58(%rbx), %rsi
cmpl %ebp, %esi
jge 0x254da
movq 0x5fb3f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x44851(%rip), %rsi     # 0x69d0c
leaq 0x44868(%rip), %rdx     # 0x69d2a
movl $0x2241, %ecx           # imm = 0x2241
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x58(%rbx), %rsi
movslq %ebp, %rax
subq %rax, %rsi
movq %rsi, 0x58(%rbx)
jmp 0x25524
movq 0x5fb03(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x44815(%rip), %rsi     # 0x69d0c
leaq 0x4482c(%rip), %rdx     # 0x69d2a
movl $0x2238, %ecx           # imm = 0x2238
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x13960
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13eb0
movq 0x58(%rbx), %rsi
movq 0x40(%rbx), %rdi
callq 0x127b0
movl %eax, 0x78(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2557d
movq 0x5fa9a(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x447ab(%rip), %rsi     # 0x69d0c
leaq 0x447c2(%rip), %rdx     # 0x69d2a
movl $0x224f, %ecx           # imm = 0x224F
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movl 0x78(%rbx), %eax
leal (%r14,%r15), %ebp
cmpl %ebp, %eax
jge 0x255b9
movq 0x5fa61(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x44772(%rip), %rsi     # 0x69d0c
leaq 0x44789(%rip), %rdx     # 0x69d2a
movl $0x2250, %ecx           # imm = 0x2250
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movl 0x78(%rbx), %eax
cmpl %ebp, %eax
jge 0x255cd
xorl %ecx, %ecx
testl %r15d, %r15d
cmovgl %r15d, %ecx
subl %ecx, %eax
movl %eax, %r14d
js 0x25628
testl %r14d, %r14d
je 0x25628
movq 0x40(%rbx), %r12
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12420
testq %rax, %rax
je 0x25628
movq %rax, %r15
movq %rax, 0x40(%rbx)
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x12420
movq %r12, 0x40(%rbx)
testq %rax, %rax
je 0x25628
subl %r15d, %eax
subl %r12d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x129b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 0x25a20
movdqa %xmm0, (%rsp)
movdqa %xmm1, 0x10(%rsp)
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movdqu %xmm0, 0x8(%rdi)
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq 0x25a51
testq %rax, %rax
je 0x25a1a
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 0x5f5c9(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x442db(%rip), %rsi     # 0x69d0c
leaq 0x442f2(%rip), %rdx     # 0x69d2a
movl $0x232f, %ecx           # imm = 0x232F
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/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
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x25a97
movq 0x5f581(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x44293(%rip), %rsi     # 0x69d0c
leaq 0x442aa(%rip), %rdx     # 0x69d2a
movl $0x2315, %ecx           # imm = 0x2315
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq (%rbx), %rdi
pushq $0x8
popq %rcx
xorl %esi, %esi
movq %r14, %rdx
callq 0x2403e
testq %rax, %rax
je 0x25ad8
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)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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 %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x25b7e
xorps %xmm5, %xmm5
ucomiss %xmm4, %xmm5
jae 0x25b78
movl %esi, %ebx
pushq $0x2
popq %rsi
pushq $0x20
popq %rdx
movss %xmm3, 0xc(%rsp)
movaps %xmm4, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm2, 0x10(%rsp)
callq 0x25a51
movaps 0x10(%rsp), %xmm4
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm0
movss 0xc(%rsp), %xmm3
testq %rax, %rax
je 0x25b78
unpcklps %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
cvttps2dq %xmm0, %xmm0
movdqa 0x40a4c(%rip), %xmm1    # 0x665a0
movdqa %xmm1, %xmm2
pandn %xmm0, %xmm2
packssdw %xmm0, %xmm0
pand %xmm1, %xmm0
por %xmm2, %xmm0
movq %xmm0, 0x10(%rax)
cvttss2si %xmm3, %ecx
movw %cx, 0x18(%rax)
movl %ebx, 0x1a(%rax)
addq $0x50, %rsp
popq %rbx
retq
movq 0x5f46b(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x4417d(%rip), %rsi     # 0x69d0c
leaq 0x44194(%rip), %rdx     # 0x69d2a
movl $0x2344, %ecx           # imm = 0x2344
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x50, %rsp
popq %rbx
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/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 0x25c2d
movq 0x5f3f1(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x44103(%rip), %rsi     # 0x69d0c
leaq 0x4411a(%rip), %rdx     # 0x69d2a
movl $0x2356, %ecx           # imm = 0x2356
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movss 0xa0(%rsp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x25cdc
testq %r14, %r14
je 0x25cdc
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x25cdc
pushq $0x3
popq %rsi
pushq $0x28
popq %rdx
movq %r14, %rdi
callq 0x25a51
movd 0xa0(%rsp), %xmm2
testq %rax, %rax
je 0x25cdc
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 0x408ec(%rip), %xmm0    # 0x665a0
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_O2/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 0x25ec8
movq 0x5f161(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x43e73(%rip), %rsi     # 0x69d0c
leaq 0x43e8a(%rip), %rdx     # 0x69d2a
movl $0x2383, %ecx           # imm = 0x2383
xorl %eax, %eax
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
testq %r14, %r14
je 0x25fb0
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x25fb0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x25eeb
jnp 0x25fb0
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x25efd
jnp 0x25fb0
cmpl $0x0, 0x18(%r14)
je 0x25f4a
movss 0x8(%r14), %xmm3
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
ucomiss %xmm3, %xmm2
jbe 0x25fb0
addss 0x10(%r14), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x25fb0
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 0x25fb0
addss 0x14(%r14), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x25fb0
pushq $0x5
popq %rsi
pushq $0x20
popq %rdx
movq %r14, %rdi
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x25a51
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
testq %rax, %rax
je 0x25fb0
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_O2/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 0x2601b
movq 0x5f00e(%rip), %r13     # 0x84ff0
movq (%r13), %rdi
leaq 0x43d1f(%rip), %rsi     # 0x69d0c
leaq 0x43d36(%rip), %rdx     # 0x69d2a
movl $0x239b, %ecx           # imm = 0x239B
xorl %eax, %eax
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x12ea0
movq (%r13), %rdi
callq 0x13960
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %r12, %r12
je 0x260e8
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x26032
jnp 0x260e8
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x26044
jnp 0x260e8
cmpl $0x0, 0x18(%r12)
je 0x26092
movss 0x8(%r12), %xmm3
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
ucomiss %xmm3, %xmm2
jbe 0x260e8
addss 0x10(%r12), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x260e8
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 0x260e8
addss 0x14(%r12), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x260e8
pushq $0x6
popq %rsi
pushq $0x28
popq %rdx
movq %r12, %rdi
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x25a51
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %rax, %rax
je 0x260e8
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_O2/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 0x261f2
testq %rdi, %rdi
je 0x261f2
ucomiss %xmm3, %xmm1
jne 0x26117
jnp 0x261f2
movaps %xmm1, %xmm6
shufps $0x55, %xmm1, %xmm6     # xmm6 = xmm6[1,1],xmm1[1,1]
ucomiss %xmm3, %xmm6
jne 0x26129
jnp 0x261f2
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
cmpl $0x0, 0x18(%rdi)
je 0x2617b
movss 0x8(%rdi), %xmm3
movaps %xmm1, %xmm4
addss %xmm0, %xmm4
ucomiss %xmm3, %xmm4
jbe 0x261ed
addss 0x10(%rdi), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x261ed
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 0x261ed
addss 0x14(%rdi), %xmm3
ucomiss %xmm5, %xmm3
jbe 0x261ed
pushq $0x7
popq %rsi
pushq $0x20
popq %rdx
movaps %xmm0, 0x30(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm6, (%rsp)
callq 0x25a51
movaps (%rsp), %xmm5
movaps 0x10(%rsp), %xmm4
movaps 0x20(%rsp), %xmm3
movaps 0x30(%rsp), %xmm2
testq %rax, %rax
je 0x261ed
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_O2/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 0x26244
movq 0x5ede3(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x43af5(%rip), %rsi     # 0x69d0c
leaq 0x43b0c(%rip), %rdx     # 0x69d2a
movl $0x23c9, %ecx           # imm = 0x23C9
xorl %eax, %eax
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %r14, %r14
je 0x2631c
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x2631c
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x26267
jnp 0x2631c
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x26279
jnp 0x2631c
cmpl $0x0, 0x18(%r14)
je 0x262c2
movss 0x8(%r14), %xmm3
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
ucomiss %xmm3, %xmm2
jbe 0x2631c
addss 0x10(%r14), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x2631c
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 0x2631c
addss 0x14(%r14), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x2631c
pushq $0x8
popq %rsi
pushq $0x20
popq %rdx
movq %r14, %rdi
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x25a51
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testq %rax, %rax
je 0x2631c
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_O2/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 0x263e4
testq %rdi, %rdi
je 0x263e4
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
cmpl $0x1000000, %esi        # imm = 0x1000000
jb 0x263df
pushq $0x9
popq %rsi
pushq $0x28
popq %rdx
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 0x25a51
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 0x263df
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_O2/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 %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0x26487
movl %esi, %ebx
cmpl $0x1000000, %esi        # imm = 0x1000000
jb 0x26481
pushq $0xa
popq %rsi
pushq $0x28
popq %rdx
movss %xmm4, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movss %xmm2, 0x4(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x25a51
movdqa 0x10(%rsp), %xmm4
movdqa 0x20(%rsp), %xmm0
movss 0x4(%rsp), %xmm3
movss 0x8(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
testq %rax, %rax
je 0x26481
movl %ebx, %ecx
shrl $0x18, %ecx
punpckldq %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
cvttps2dq %xmm4, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
cvttss2si %xmm3, %edx
movd %xmm0, 0x10(%rax)
movw %dx, 0x14(%rax)
movss %xmm2, 0x18(%rax)
movss %xmm1, 0x1c(%rax)
movw %bx, 0x20(%rax)
shrl $0x10, %ebx
movb %bl, 0x22(%rax)
movb %cl, 0x23(%rax)
addq $0x30, %rsp
popq %rbx
retq
movq 0x5eb62(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x43874(%rip), %rsi     # 0x69d0c
leaq 0x4388b(%rip), %rdx     # 0x69d2a
movl $0x23f0, %ecx           # imm = 0x23F0
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x13960