LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x303c6
cmpq $0x0, 0x20(%rsp)
jne 0x303d3
movl $0x0, 0x34(%rsp)
jmp 0x3046e
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x14030
movl %eax, 0x1c(%rsp)
movl %eax, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x30410
cmpl $0x0, 0x14(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3041a
jmp 0x30453
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x14030
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x303f7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x14820
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x304dd
movq 0x94b3f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80ee5(%rip), %rsi     # 0xb13a0
leaq 0x80efc(%rip), %rdx     # 0xb13be
movl $0x217e, %ecx           # imm = 0x217E
movb $0x0, %al
callq 0x13ec0
movq 0x94b1b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x304df
cmpq $0x0, 0x18(%rsp)
je 0x304f6
cmpq $0x0, 0x10(%rsp)
je 0x304f6
cmpl $0x0, 0xc(%rsp)
jne 0x30500
movl $0x0, 0x24(%rsp)
jmp 0x3055f
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x30557
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edi
movq %rsp, %rsi
movl $0x4, %edx
callq 0x13f80
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x30539
jmp 0x30557
movq 0x18(%rsp), %rdi
movq %rsp, %rsi
movl 0x4(%rsp), %edx
callq 0x14820
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x30508
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x305c1
movq 0x94a5b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80e01(%rip), %rsi     # 0xb13a0
leaq 0x80e18(%rip), %rdx     # 0xb13be
movl $0x218d, %ecx           # imm = 0x218D
movb $0x0, %al
callq 0x13ec0
movq 0x94a37(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x305c3
cmpq $0x0, 0x18(%rsp)
je 0x305d3
cmpq $0x0, 0x10(%rsp)
jne 0x305dd
movl $0x0, 0x24(%rsp)
jmp 0x30637
jmp 0x305df
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3062f
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x13f80
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x14820
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x305df
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x309c1
movq 0x9465b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80a01(%rip), %rsi     # 0xb13a0
leaq 0x80a18(%rip), %rdx     # 0xb13be
movl $0x21c1, %ecx           # imm = 0x21C1
movb $0x0, %al
callq 0x13ec0
movq 0x94637(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x309c3
jmp 0x309c5
cmpq $0x0, 0x28(%rsp)
jne 0x30a00
movq 0x9461c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x809c2(%rip), %rsi     # 0xb13a0
leaq 0x809d9(%rip), %rdx     # 0xb13be
movl $0x21c2, %ecx           # imm = 0x21C2
movb $0x0, %al
callq 0x13ec0
movq 0x945f8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x30a02
jmp 0x30a04
cmpl $0x0, 0x24(%rsp)
jne 0x30a3e
movq 0x945de(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80984(%rip), %rsi     # 0xb13a0
leaq 0x8099b(%rip), %rdx     # 0xb13be
movl $0x21c3, %ecx           # imm = 0x21C3
movb $0x0, %al
callq 0x13ec0
movq 0x945ba(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x30a40
cmpq $0x0, 0x38(%rsp)
je 0x30a57
cmpq $0x0, 0x28(%rsp)
je 0x30a57
cmpl $0x0, 0x24(%rsp)
jne 0x30a64
movl $0x0, 0x44(%rsp)
jmp 0x30aec
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
leaq 0x1c(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x13430
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x30aa5
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0x14820
movl %eax, 0x44(%rsp)
jmp 0x30aec
movq 0x38(%rsp), %rdi
callq 0x130a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x30ac6
movl $0x0, 0x44(%rsp)
jmp 0x30aec
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rcx, %rax
movl %eax, %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x130e0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x30e31
movq 0x941eb(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80591(%rip), %rsi     # 0xb13a0
leaq 0x805a8(%rip), %rdx     # 0xb13be
movl $0x21dd, %ecx           # imm = 0x21DD
movb $0x0, %al
callq 0x13ec0
movq 0x941c7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x30e33
jmp 0x30e35
cmpq $0x0, 0x18(%rsp)
jne 0x30e70
movq 0x941ac(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80552(%rip), %rsi     # 0xb13a0
leaq 0x80569(%rip), %rdx     # 0xb13be
movl $0x21de, %ecx           # imm = 0x21DE
movb $0x0, %al
callq 0x13ec0
movq 0x94188(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x30e72
cmpq $0x0, 0x28(%rsp)
je 0x30e89
cmpq $0x0, 0x18(%rsp)
je 0x30e89
cmpl $0x0, 0x14(%rsp)
jne 0x30e93
movl $0x0, 0x34(%rsp)
jmp 0x30ef5
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x30ed6
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rax
addq %rax, %rdi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x14030
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x30e9b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x13680
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x30f9a
cmpq $0x0, 0x18(%rsp)
jne 0x30fa7
movl $0x0, 0x34(%rsp)
jmp 0x31046
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x14030
movl %eax, 0x14(%rsp)
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x30fe4
cmpl $0x0, 0xc(%rsp)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x30fee
jmp 0x31027
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x14030
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x30fcb
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x13680
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x310b1
movq 0x93f6b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x80311(%rip), %rsi     # 0xb13a0
leaq 0x80328(%rip), %rdx     # 0xb13be
movl $0x21fe, %ecx           # imm = 0x21FE
movb $0x0, %al
callq 0x13ec0
movq 0x93f47(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x310b3
cmpq $0x0, 0x28(%rsp)
je 0x310ca
cmpq $0x0, 0x18(%rsp)
je 0x310ca
cmpl $0x0, 0x14(%rsp)
jne 0x310d4
movl $0x0, 0x34(%rsp)
jmp 0x3113f
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x31137
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x13f80
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x3110f
jmp 0x31137
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
addl 0x10(%rsp), %esi
leaq 0x8(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x13680
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x310dc
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x311a5
movq 0x93e77(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8021d(%rip), %rsi     # 0xb13a0
leaq 0x80234(%rip), %rdx     # 0xb13be
movl $0x220d, %ecx           # imm = 0x220D
movb $0x0, %al
callq 0x13ec0
movq 0x93e53(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x311a7
cmpq $0x0, 0x28(%rsp)
je 0x311b7
cmpq $0x0, 0x18(%rsp)
jne 0x311c1
movl $0x0, 0x34(%rsp)
jmp 0x31223
jmp 0x311c3
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3121b
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x13f80
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
addl 0x14(%rsp), %esi
leaq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x13680
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x311c3
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x31278
movq 0x93da4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8014a(%rip), %rsi     # 0xb13a0
leaq 0x80161(%rip), %rdx     # 0xb13be
movl $0x2219, %ecx           # imm = 0x2219
movb $0x0, %al
callq 0x13ec0
movq 0x93d80(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3127a
jmp 0x3127c
cmpl $0x0, 0xc(%rsp)
jge 0x312b6
movq 0x93d66(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8010c(%rip), %rsi     # 0xb13a0
leaq 0x80123(%rip), %rdx     # 0xb13be
movl $0x221a, %ecx           # imm = 0x221A
movb $0x0, %al
callq 0x13ec0
movq 0x93d42(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x312b8
cmpq $0x0, 0x10(%rsp)
je 0x312d7
cmpl $0x0, 0xc(%rsp)
jl 0x312d7
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jbe 0x312dc
jmp 0x3135d
jmp 0x312de
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
subl 0xc(%rsp), %eax
cmpl $0x0, %eax
jge 0x31323
movq 0x93cf9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8009f(%rip), %rsi     # 0xb13a0
leaq 0x800b6(%rip), %rdx     # 0xb13be
movl $0x221c, %ecx           # imm = 0x221C
movb $0x0, %al
callq 0x13ec0
movq 0x93cd5(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x31325
movslq 0xc(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movl %eax, %esi
callq 0x137e0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x78(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x313b8
movq 0x93c64(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x8000a(%rip), %rsi     # 0xb13a0
leaq 0x80021(%rip), %rdx     # 0xb13be
movl $0x2228, %ecx           # imm = 0x2228
movb $0x0, %al
callq 0x13ec0
movq 0x93c40(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x313ba
jmp 0x313bc
cmpl $0x0, 0x1c(%rsp)
jge 0x313f6
movq 0x93c26(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7ffcc(%rip), %rsi     # 0xb13a0
leaq 0x7ffe3(%rip), %rdx     # 0xb13be
movl $0x2229, %ecx           # imm = 0x2229
movb $0x0, %al
callq 0x13ec0
movq 0x93c02(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x313f8
cmpq $0x0, 0x20(%rsp)
je 0x31407
cmpl $0x0, 0x1c(%rsp)
jge 0x31409
jmp 0x31485
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x78(%rcx), %eax
jl 0x31425
movq 0x20(%rsp), %rax
movl $0x0, 0x78(%rax)
jmp 0x31485
movq 0x20(%rsp), %rax
movl 0x78(%rax), %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
leaq 0x4(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
callq 0x13430
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x20(%rsp), %rcx
addq 0x58(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
movl %eax, %esi
addl $0x1, %esi
callq 0x14ef0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x314dc
movq 0x93b40(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7fee6(%rip), %rsi     # 0xb13a0
leaq 0x7fefd(%rip), %rdx     # 0xb13be
movl $0x2238, %ecx           # imm = 0x2238
movb $0x0, %al
callq 0x13ec0
movq 0x93b1c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x314de
cmpq $0x0, 0x20(%rsp)
je 0x31512
cmpl $0x0, 0x18(%rsp)
je 0x31512
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x58(%rcx), %rax
ja 0x31512
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
cltq
movq 0x20(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jbe 0x31517
jmp 0x31616
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
cltq
movq 0x20(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x315e5
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x1c(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x1c(%rsp), %ecx
addl 0x18(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rdx
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
cltq
subq %rax, %rdx
callq 0x2f750
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
subl 0x18(%rsp), %eax
cmpl $0x0, %eax
jge 0x315cc
movq 0x93a50(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7fdf6(%rip), %rsi     # 0xb13a0
leaq 0x7fe0d(%rip), %rdx     # 0xb13be
movl $0x2241, %ecx           # imm = 0x2241
movb $0x0, %al
callq 0x13ec0
movq 0x93a2c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x315ce
movslq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x58(%rax)
jmp 0x315f3
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x14ef0
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movl %eax, %esi
callq 0x137e0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x78(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movlpd %xmm0, 0x18(%rsp)
movlpd %xmm1, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x31e30
movq 0x931ec(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7f592(%rip), %rsi     # 0xb13a0
leaq 0x7f5a9(%rip), %rdx     # 0xb13be
movl $0x232f, %ecx           # imm = 0x232F
movb $0x0, %al
callq 0x13ec0
movq 0x931c8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x31e32
cmpq $0x0, 0x10(%rsp)
jne 0x31e3f
jmp 0x31f44
movss 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x8(%rax)
movss 0x1c(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0xc(%rax)
movss 0x20(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x10(%rax)
movss 0x24(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x14(%rax)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x31f50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x31ea5
jmp 0x31f44
cvttss2si 0x18(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x10(%rax)
movss 0x1c(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x12(%rax)
movss 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x31ee9
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x31ef4
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x31ef4
movss 0x4(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x14(%rax)
movss 0x24(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x31f25
movss 0x24(%rsp), %xmm0
movss %xmm0, (%rsp)
jmp 0x31f2f
xorps %xmm0, %xmm0
movss %xmm0, (%rsp)
jmp 0x31f2f
movss (%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x16(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x31f9d
movq 0x9307f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7f425(%rip), %rsi     # 0xb13a0
leaq 0x7f43c(%rip), %rdx     # 0xb13be
movl $0x2314, %ecx           # imm = 0x2314
movb $0x0, %al
callq 0x13ec0
movq 0x9305b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x31f9f
jmp 0x31fa1
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x31fdf
movq 0x9303d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7f3e3(%rip), %rsi     # 0xb13a0
leaq 0x7f3fa(%rip), %rdx     # 0xb13be
movl $0x2315, %ecx           # imm = 0x2315
movb $0x0, %al
callq 0x13ec0
movq 0x93019(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x31fe1
cmpq $0x0, 0x38(%rsp)
jne 0x31ff7
movq $0x0, 0x40(%rsp)
jmp 0x320bc
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
xorl %esi, %esi
movl $0x8, %ecx
callq 0x2f2e0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3202b
movq $0x0, 0x40(%rsp)
jmp 0x320bc
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
subq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rcx
addq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %esi, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movss %xmm2, 0x1c(%rsp)
movss %xmm3, 0x18(%rsp)
movss %xmm4, 0x14(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x32136
movq 0x92ee6(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7f28c(%rip), %rsi     # 0xb13a0
leaq 0x7f2a3(%rip), %rdx     # 0xb13be
movl $0x2344, %ecx           # imm = 0x2344
movb $0x0, %al
callq 0x13ec0
movq 0x92ec2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x32138
cmpq $0x0, 0x28(%rsp)
je 0x3214a
xorps %xmm0, %xmm0
ucomiss 0x14(%rsp), %xmm0
jb 0x3214f
jmp 0x321dc
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x20, %edx
callq 0x31f50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x32172
jmp 0x321dc
cvttss2si 0x14(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x10(%rax)
cvttss2si 0x24(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x12(%rax)
cvttss2si 0x20(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x14(%rax)
cvttss2si 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x16(%rax)
movss 0x18(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x1a(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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:
subq $0x38, %rsp
movss 0x40(%rsp), %xmm8
movl %esi, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movss %xmm2, 0x1c(%rsp)
movss %xmm3, 0x18(%rsp)
movss %xmm4, 0x14(%rsp)
movss %xmm5, 0x10(%rsp)
movss %xmm6, 0xc(%rsp)
movss %xmm7, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3226f
movq 0x92dad(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7f153(%rip), %rsi     # 0xb13a0
leaq 0x7f16a(%rip), %rdx     # 0xb13be
movl $0x2356, %ecx           # imm = 0x2356
movb $0x0, %al
callq 0x13ec0
movq 0x92d89(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x32271
cmpq $0x0, 0x28(%rsp)
je 0x3228d
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
je 0x3228d
xorps %xmm0, %xmm0
ucomiss 0x40(%rsp), %xmm0
jb 0x32292
jmp 0x3235e
movq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x28, %edx
callq 0x31f50
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x322b6
jmp 0x3235e
cvttss2si 0x40(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x10(%rax)
cvttss2si 0x24(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x12(%rax)
cvttss2si 0x20(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x14(%rax)
cvttss2si 0x1c(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x1a(%rax)
cvttss2si 0x18(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x1c(%rax)
cvttss2si 0x14(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x1e(%rax)
cvttss2si 0x10(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x20(%rax)
cvttss2si 0xc(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x16(%rax)
movss 0x8(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x18(%rax)
movq (%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x22(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_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:
subq $0x48, %rsp
movlpd %xmm0, 0x38(%rsp)
movlpd %xmm1, 0x40(%rsp)
movl %esi, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movss %xmm2, 0x24(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x32a55
movss 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32a39
jp 0x32a39
jmp 0x32a55
movss 0x44(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32a4b
jp 0x32a4b
jmp 0x32a55
xorps %xmm0, %xmm0
ucomiss 0x24(%rsp), %xmm0
jb 0x32a5a
jmp 0x32bca
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x32af0
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movss (%rax), %xmm1
movss 0x38(%rsp), %xmm0
addss 0x40(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x32ae9
movss 0x38(%rsp), %xmm1
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
movq 0x10(%rsp), %rax
addss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x32ae9
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm1
movss 0x3c(%rsp), %xmm0
addss 0x44(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x32ae9
movss 0x3c(%rsp), %xmm1
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x10(%rsp), %rax
addss 0xc(%rax), %xmm0
ucomiss %xmm1, %xmm0
ja 0x32aee
jmp 0x32bca
jmp 0x32af0
movq 0x28(%rsp), %rdi
movl $0x7, %esi
movl $0x20, %edx
callq 0x31f50
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x32b16
jmp 0x32bca
cvttss2si 0x24(%rsp), %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x14(%rax)
cvttss2si 0x38(%rsp), %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x10(%rax)
movss 0x3c(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x12(%rax)
xorps %xmm0, %xmm0
ucomiss 0x40(%rsp), %xmm0
jbe 0x32b65
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x32b71
movss 0x40(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x16(%rax)
xorps %xmm0, %xmm0
ucomiss 0x44(%rsp), %xmm0
jbe 0x32b9c
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x32ba8
movss 0x44(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movw %cx, 0x18(%rax)
movq 0x18(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x1a(%rax)
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movlpd %xmm0, 0x28(%rsp)
movlpd %xmm1, 0x30(%rsp)
movl %esi, 0x24(%rsp)
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x32c24
movq 0x923f8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7e79e(%rip), %rsi     # 0xb13a0
leaq 0x7e7b5(%rip), %rdx     # 0xb13be
movl $0x23c9, %ecx           # imm = 0x23C9
movb $0x0, %al
callq 0x13ec0
movq 0x923d4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x32c26
cmpq $0x0, 0x18(%rsp)
je 0x32c5a
movzbl 0x27(%rsp), %eax
cmpl $0x0, %eax
je 0x32c5a
movss 0x30(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32c4a
jp 0x32c4a
jmp 0x32c5a
movss 0x34(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32c5f
jp 0x32c5f
jmp 0x32dba
movq 0x18(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x32cf5
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movss (%rax), %xmm1
movss 0x28(%rsp), %xmm0
addss 0x30(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x32cee
movss 0x28(%rsp), %xmm1
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
movq 0x8(%rsp), %rax
addss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x32cee
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm1
movss 0x2c(%rsp), %xmm0
addss 0x34(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x32cee
movss 0x2c(%rsp), %xmm1
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x8(%rsp), %rax
addss 0xc(%rax), %xmm0
ucomiss %xmm1, %xmm0
ja 0x32cf3
jmp 0x32dba
jmp 0x32cf5
movq 0x18(%rsp), %rdi
movl $0x8, %esi
movl $0x20, %edx
callq 0x31f50
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x32d1b
jmp 0x32dba
cvttss2si 0x28(%rsp), %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0x10(%rax)
movss 0x2c(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0x12(%rax)
xorps %xmm0, %xmm0
ucomiss 0x30(%rsp), %xmm0
jbe 0x32d58
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x32d64
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0x14(%rax)
xorps %xmm0, %xmm0
ucomiss 0x34(%rsp), %xmm0
jbe 0x32d8e
xorps %xmm0, %xmm0
movss %xmm0, (%rsp)
jmp 0x32d99
movss 0x34(%rsp), %xmm0
movss %xmm0, (%rsp)
movss (%rsp), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0x16(%rax)
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %ecx
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %esi, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movss %xmm2, 0x1c(%rsp)
movss %xmm3, 0x18(%rsp)
movss %xmm4, 0x14(%rsp)
movss %xmm5, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x32e0d
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
je 0x32e0d
xorps %xmm0, %xmm0
ucomiss 0x10(%rsp), %xmm0
jb 0x32e12
jmp 0x32ea9
movq 0x28(%rsp), %rdi
movl $0x9, %esi
movl $0x28, %edx
callq 0x31f50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x32e35
jmp 0x32ea9
cvttss2si 0x10(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x16(%rax)
cvttss2si 0x24(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x10(%rax)
cvttss2si 0x20(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x12(%rax)
cvttss2si 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x14(%rax)
movss 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x18(%rax)
movss 0x14(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x1c(%rax)
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x20(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %esi, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movss %xmm2, 0x1c(%rsp)
movss %xmm3, 0x18(%rsp)
movss %xmm4, 0x14(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x32f16
movq 0x92106(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7e4ac(%rip), %rsi     # 0xb13a0
leaq 0x7e4c3(%rip), %rdx     # 0xb13be
movl $0x23f0, %ecx           # imm = 0x23F0
movb $0x0, %al
callq 0x13ec0
movq 0x920e2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x32f18
cmpq $0x0, 0x28(%rsp)
je 0x32f2a
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
jne 0x32f2f
jmp 0x32fb4
movq 0x28(%rsp), %rdi
movl $0xa, %esi
movl $0x28, %edx
callq 0x31f50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x32f52
jmp 0x32fb4
cvttss2si 0x24(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x10(%rax)
cvttss2si 0x20(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x12(%rax)
cvttss2si 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x14(%rax)
movss 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x18(%rax)
movss 0x14(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x1c(%rax)
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x20(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %ecx, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x33550
movq 0x91acc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7de72(%rip), %rsi     # 0xb13a0
leaq 0x7de89(%rip), %rdx     # 0xb13be
movl $0x243a, %ecx           # imm = 0x243A
movb $0x0, %al
callq 0x13ec0
movq 0x91aa8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x33552
cmpq $0x0, 0x28(%rsp)
je 0x3356e
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
je 0x3356e
xorps %xmm0, %xmm0
ucomiss 0x18(%rsp), %xmm0
jb 0x33573
jmp 0x3363e
movslq 0x1c(%rsp), %rax
shlq $0x2, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xd, %esi
callq 0x31f50
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x335a9
jmp 0x3363e
movq (%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x10(%rax)
cvttss2si 0x18(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x14(%rax)
movl 0x1c(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x16(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3363e
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl %ecx, %edx
addl %edx, %edx
movslq %edx, %rdx
cvttss2si (%rax,%rdx,4), %eax
movw %ax, %dx
movq (%rsp), %rax
movw %dx, 0x18(%rax,%rcx,4)
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movw %dx, 0x1a(%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x335dc
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %ecx, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x336aa
movq 0x91972(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7dd18(%rip), %rsi     # 0xb13a0
leaq 0x7dd2f(%rip), %rdx     # 0xb13be
movl $0x244f, %ecx           # imm = 0x244F
movb $0x0, %al
callq 0x13ec0
movq 0x9194e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x336ac
cmpq $0x0, 0x28(%rsp)
je 0x336be
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
jne 0x336c3
jmp 0x33783
movslq 0x1c(%rsp), %rax
shlq $0x2, %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xe, %esi
callq 0x31f50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x336fb
jmp 0x33783
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x14(%rax)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x33783
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movl %ecx, %edx
addl %edx, %edx
movslq %edx, %rdx
cvttss2si (%rax,%rdx,4), %eax
movw %ax, %dx
movq 0x8(%rsp), %rax
movw %dx, 0x16(%rax,%rcx,4)
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movw %dx, 0x18(%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3371f
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_stroke_polyline
NK_API void
nk_stroke_polyline(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_polyline *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_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size);
    if (!cmd) return;
    cmd->color = col;
    cmd->point_count = (unsigned short)point_count;
    cmd->line_thickness = (unsigned short)line_thickness;
    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:
subq $0x38, %rsp
movl %ecx, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x337f0
movq 0x9182c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7dbd2(%rip), %rsi     # 0xb13a0
leaq 0x7dbe9(%rip), %rdx     # 0xb13be
movl $0x2464, %ecx           # imm = 0x2464
movb $0x0, %al
callq 0x13ec0
movq 0x91808(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x337f2
cmpq $0x0, 0x28(%rsp)
je 0x3380e
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
je 0x3380e
xorps %xmm0, %xmm0
ucomiss 0x18(%rsp), %xmm0
jb 0x33813
jmp 0x338dc
movslq 0x1c(%rsp), %rax
shlq $0x2, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xf, %esi
callq 0x31f50
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x33849
jmp 0x338dc
movq (%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x10(%rax)
movw 0x1c(%rsp), %cx
movq (%rsp), %rax
movw %cx, 0x16(%rax)
cvttss2si 0x18(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x14(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x338dc
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl %ecx, %edx
addl %edx, %edx
movslq %edx, %rdx
cvttss2si (%rax,%rdx,4), %eax
movw %ax, %dx
movq (%rsp), %rax
movw %dx, 0x18(%rax,%rcx,4)
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movw %dx, 0x1a(%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3387a
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)