LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_char
NK_API void
nk_input_char(struct nk_context *ctx, char c)
{
    nk_glyph glyph;
    NK_ASSERT(ctx);
    if (!ctx) return;
    glyph[0] = c;
    nk_input_glyph(ctx, glyph);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c8db
movq 0x78741(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64ae7(%rip), %rsi     # 0xb13a0
leaq 0x64afe(%rip), %rdx     # 0xb13be
movl $0x4675, %ecx           # imm = 0x4675
movb $0x0, %al
callq 0x13ec0
movq 0x7871d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c8dd
cmpq $0x0, 0x10(%rsp)
jne 0x4c8e7
jmp 0x4c8fe
movb 0xf(%rsp), %al
movb %al, 0xb(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x13050
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_unicode
NK_API void
nk_input_unicode(struct nk_context *ctx, nk_rune unicode)
{
    nk_glyph rune;
    NK_ASSERT(ctx);
    if (!ctx) return;
    nk_utf_encode(unicode, rune, NK_UTF_SIZE);
    nk_input_glyph(ctx, rune);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c958
movq 0x786c4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64a6a(%rip), %rsi     # 0xb13a0
leaq 0x64a81(%rip), %rdx     # 0xb13be
movl $0x467e, %ecx           # imm = 0x467E
movb $0x0, %al
callq 0x13ec0
movq 0x786a0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c95a
cmpq $0x0, 0x10(%rsp)
jne 0x4c964
jmp 0x4c986
movl 0xc(%rsp), %edi
leaq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x13f80
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x13050
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_has_mouse_click
NK_API nk_bool
nk_input_has_mouse_click(const struct nk_input *i, enum nk_buttons id)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return (btn->clicked && btn->down == nk_false) ? nk_true : nk_false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x4c9ab
movl $0x0, -0x4(%rsp)
jmp 0x4c9fb
movq -0x10(%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl -0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x4(%rcx)
movb %al, -0x21(%rsp)
je 0x4c9e6
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_has_mouse_click_in_rect
NK_API nk_bool
nk_input_has_mouse_click_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h))
        return nk_false;
    return nk_true;
}

// Assembly:
movlpd %xmm0, -0x14(%rsp)
movlpd %xmm1, -0xc(%rsp)
movq %rdi, -0x20(%rsp)
movl %esi, -0x24(%rsp)
cmpq $0x0, -0x20(%rsp)
jne 0x4ca2a
movl $0x0, -0x4(%rsp)
jmp 0x4cab7
movq -0x20(%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl -0x24(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movss -0x14(%rsp), %xmm1
movq -0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4caa5
movq -0x30(%rsp), %rax
movss 0x8(%rax), %xmm1
movss -0x14(%rsp), %xmm0
addss -0xc(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4caa5
movss -0x10(%rsp), %xmm1
movq -0x30(%rsp), %rax
movss 0xc(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4caa5
movq -0x30(%rsp), %rax
movss 0xc(%rax), %xmm1
movss -0x10(%rsp), %xmm0
addss -0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
ja 0x4caaf
movl $0x0, -0x4(%rsp)
jmp 0x4cab7
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_has_mouse_click_in_button_rect
NK_API nk_bool
nk_input_has_mouse_click_in_button_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
#ifdef NK_BUTTON_TRIGGER_ON_RELEASE
    if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h)
        || !NK_INBOX(i->mouse.down_pos.x,i->mouse.down_pos.y,b.x,b.y,b.w,b.h))
#else
    if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h))
#endif
        return nk_false;
    return nk_true;
}

// Assembly:
movlpd %xmm0, -0x14(%rsp)
movlpd %xmm1, -0xc(%rsp)
movq %rdi, -0x20(%rsp)
movl %esi, -0x24(%rsp)
cmpq $0x0, -0x20(%rsp)
jne 0x4caea
movl $0x0, -0x4(%rsp)
jmp 0x4cb77
movq -0x20(%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl -0x24(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movss -0x14(%rsp), %xmm1
movq -0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4cb65
movq -0x30(%rsp), %rax
movss 0x8(%rax), %xmm1
movss -0x14(%rsp), %xmm0
addss -0xc(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4cb65
movss -0x10(%rsp), %xmm1
movq -0x30(%rsp), %rax
movss 0xc(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4cb65
movq -0x30(%rsp), %rax
movss 0xc(%rax), %xmm1
movss -0x10(%rsp), %xmm0
addss -0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
ja 0x4cb6f
movl $0x0, -0x4(%rsp)
jmp 0x4cb77
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_has_mouse_click_down_in_rect
NK_API nk_bool
nk_input_has_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b, nk_bool down)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return nk_input_has_mouse_click_in_rect(i, id, b) && (btn->down == down);
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x24(%rsp)
movlpd %xmm1, 0x2c(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x4cbaf
movl $0x0, 0x34(%rsp)
jmp 0x4cc0f
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shlq $0x4, %rcx
leaq 0x104(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
callq 0x130d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x4cc02
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x10(%rsp), %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %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_input_is_mouse_click_in_rect
NK_API nk_bool
nk_input_is_mouse_click_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return (nk_input_has_mouse_click_down_in_rect(i, id, b, nk_false) &&
            btn->clicked) ? nk_true : nk_false;
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x24(%rsp)
movlpd %xmm1, 0x2c(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x4cc4b
movl $0x0, 0x34(%rsp)
jmp 0x4ccb3
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shlq $0x4, %rcx
leaq 0x104(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
xorl %edx, %edx
callq 0x13780
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x4cc9e
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %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_input_is_mouse_click_down_in_rect
NK_API nk_bool
nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b, nk_bool down)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return (nk_input_has_mouse_click_down_in_rect(i, id, b, down) &&
            btn->clicked) ? nk_true : nk_false;
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x24(%rsp)
movlpd %xmm1, 0x2c(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x4ccef
movl $0x0, 0x34(%rsp)
jmp 0x4cd59
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shlq $0x4, %rcx
leaq 0x104(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
callq 0x13780
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x4cd44
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_any_mouse_click_in_rect
NK_API nk_bool
nk_input_any_mouse_click_in_rect(const struct nk_input *in, struct nk_rect b)
{
    int i, down = 0;
    for (i = 0; i < NK_BUTTON_MAX; ++i)
        down = down || nk_input_is_mouse_click_in_rect(in, (enum nk_buttons)i, b);
    return down;
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x18(%rsp)
movlpd %xmm1, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x4cde7
movb $0x1, %al
cmpl $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
jne 0x4cdcd
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x14640
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4cd95
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_is_mouse_pressed
NK_API nk_bool
nk_input_is_mouse_pressed(const struct nk_input *i, enum nk_buttons id)
{
    const struct nk_mouse_button *b;
    if (!i) return nk_false;
    b = &i->mouse.buttons[id];
    if (b->down && b->clicked)
        return nk_true;
    return nk_false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x4d06b
movl $0x0, -0x4(%rsp)
jmp 0x4d0ad
movq -0x10(%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl -0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4d0a5
movq -0x20(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4d0a5
movl $0x1, -0x4(%rsp)
jmp 0x4d0ad
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_is_key_pressed
NK_API nk_bool
nk_input_is_key_pressed(const struct nk_input *i, enum nk_keys key)
{
    const struct nk_key *k;
    if (!i) return nk_false;
    k = &i->keyboard.keys[key];
    if ((k->down && k->clicked) || (!k->down && k->clicked >= 2))
        return nk_true;
    return nk_false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x4d14b
movl $0x0, -0x4(%rsp)
jmp 0x4d19c
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4d175
movq -0x20(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x4d18a
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x4d194
movq -0x20(%rsp), %rax
cmpl $0x2, 0x4(%rax)
jb 0x4d194
movl $0x1, -0x4(%rsp)
jmp 0x4d19c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_is_key_down
NK_API nk_bool
nk_input_is_key_down(const struct nk_input *i, enum nk_keys key)
{
    const struct nk_key *k;
    if (!i) return nk_false;
    k = &i->keyboard.keys[key];
    if (k->down) return nk_true;
    return nk_false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x4d24b
movl $0x0, -0x4(%rsp)
jmp 0x4d27c
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4d274
movl $0x1, -0x4(%rsp)
jmp 0x4d27c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_set_font
NK_API void
nk_style_set_font(struct nk_context *ctx, const struct nk_user_font *font)
{
    struct nk_style *style;
    NK_ASSERT(ctx);

    if (!ctx) return;
    style = &ctx->style;
    style->font = font;
    ctx->stacks.fonts.head = 0;
    if (ctx->current)
        nk_layout_reset_min_row_height(ctx);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x525c9
movq 0x72a53(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5edf9(%rip), %rsi     # 0xb13a0
leaq 0x5ee10(%rip), %rdx     # 0xb13be
movl $0x49cb, %ecx           # imm = 0x49CB
movb $0x0, %al
callq 0x13ec0
movq 0x72a2f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x525cb
cmpq $0x0, 0x10(%rsp)
jne 0x525d5
jmp 0x52618
movq 0x10(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x2fc8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x52618
movq 0x10(%rsp), %rdi
callq 0x14e40
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_reset_min_row_height
NK_API void
nk_layout_reset_min_row_height(struct nk_context *ctx)
{
    struct nk_window *win;
    struct nk_panel *layout;

    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return;

    win = ctx->current;
    layout = win->layout;
    layout->row.min_height = ctx->style.font->height;
    layout->row.min_height += ctx->style.text.padding.y*2;
    layout->row.min_height += ctx->style.window.min_row_height_padding*2;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x52664
movq 0x729b8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5ed5e(%rip), %rsi     # 0xb13a0
leaq 0x5ed75(%rip), %rdx     # 0xb13be
movl $0x54d6, %ecx           # imm = 0x54D6
movb $0x0, %al
callq 0x13ec0
movq 0x72994(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x52666
jmp 0x52668
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x526aa
movq 0x72972(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5ed18(%rip), %rsi     # 0xb13a0
leaq 0x5ed2f(%rip), %rdx     # 0xb13be
movl $0x54d7, %ecx           # imm = 0x54D7
movb $0x0, %al
callq 0x13ec0
movq 0x7294e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x526ac
jmp 0x526ae
movq 0x10(%rsp), %rax
movq 0x4780(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x526f7
movq 0x72925(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5eccb(%rip), %rsi     # 0xb13a0
leaq 0x5ece2(%rip), %rdx     # 0xb13be
movl $0x54d8, %ecx           # imm = 0x54D8
movb $0x0, %al
callq 0x13ec0
movq 0x72901(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x526f9
cmpq $0x0, 0x10(%rsp)
je 0x52726
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x52726
movq 0x10(%rsp), %rax
movq 0x4780(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x5272b
jmp 0x527ac
movq 0x10(%rsp), %rax
movq 0x4780(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x168(%rax), %rax
movss 0x8(%rax), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x7c(%rax)
movq 0x10(%rsp), %rax
movss 0x1c4(%rax), %xmm0
movq (%rsp), %rax
movss 0x7c(%rax), %xmm1
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x7c(%rax)
movq 0x10(%rsp), %rax
movss 0x24ac(%rax), %xmm0
movq (%rsp), %rax
movss 0x7c(%rax), %xmm1
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x7c(%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_style_push_font
NK_API nk_bool
nk_style_push_font(struct nk_context *ctx, const struct nk_user_font *font)
{
    struct nk_config_stack_user_font *font_stack;
    struct nk_config_stack_user_font_element *element;

    NK_ASSERT(ctx);
    if (!ctx) return 0;

    font_stack = &ctx->stacks.fonts;
    NK_ASSERT(font_stack->head < (int)NK_LEN(font_stack->elements));
    if (font_stack->head >= (int)NK_LEN(font_stack->elements))
        return 0;

    element = &font_stack->elements[font_stack->head++];
    element->address = &ctx->style.font;
    element->old_value = ctx->style.font;
    ctx->style.font = font;
    return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x52809
movq 0x72813(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5ebb9(%rip), %rsi     # 0xb13a0
leaq 0x5ebd0(%rip), %rdx     # 0xb13be
movl $0x49da, %ecx           # imm = 0x49DA
movb $0x0, %al
callq 0x13ec0
movq 0x727ef(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x5280b
cmpq $0x0, 0x18(%rsp)
jne 0x52820
movl $0x0, 0x24(%rsp)
jmp 0x528ee
movq 0x18(%rsp), %rax
addq $0x25a0, %rax           # imm = 0x25A0
addq $0xa28, %rax            # imm = 0xA28
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x8, (%rax)
jl 0x52873
movq 0x727a9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5eb4f(%rip), %rsi     # 0xb13a0
leaq 0x5eb66(%rip), %rdx     # 0xb13be
movl $0x49de, %ecx           # imm = 0x49DE
movb $0x0, %al
callq 0x13ec0
movq 0x72785(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x52875
movq 0x8(%rsp), %rax
cmpl $0x8, (%rax)
jl 0x52889
movl $0x0, 0x24(%rsp)
jmp 0x528ee
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
addq $0x168, %rcx            # imm = 0x168
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x168(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x168(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_pop_font
NK_API nk_bool
nk_style_pop_font(struct nk_context *ctx)
{
    struct nk_config_stack_user_font *font_stack;
    struct nk_config_stack_user_font_element *element;

    NK_ASSERT(ctx);
    if (!ctx) return 0;

    font_stack = &ctx->stacks.fonts;
    NK_ASSERT(font_stack->head > 0);
    if (font_stack->head < 1)
        return 0;

    element = &font_stack->elements[--font_stack->head];
    *element->address = element->old_value;
    return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x52944
movq 0x726d8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5ea7e(%rip), %rsi     # 0xb13a0
leaq 0x5ea95(%rip), %rdx     # 0xb13be
movl $0x49ee, %ecx           # imm = 0x49EE
movb $0x0, %al
callq 0x13ec0
movq 0x726b4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x52946
cmpq $0x0, 0x18(%rsp)
jne 0x5295b
movl $0x0, 0x24(%rsp)
jmp 0x52a04
movq 0x18(%rsp), %rax
addq $0x25a0, %rax           # imm = 0x25A0
addq $0xa28, %rax            # imm = 0xA28
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jg 0x529ae
movq 0x7266e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5ea14(%rip), %rsi     # 0xb13a0
leaq 0x5ea2b(%rip), %rdx     # 0xb13be
movl $0x49f2, %ecx           # imm = 0x49F2
movb $0x0, %al
callq 0x13ec0
movq 0x7264a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x529b0
movq 0x10(%rsp), %rax
cmpl $0x1, (%rax)
jge 0x529c4
movl $0x0, 0x24(%rsp)
jmp 0x52a04
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x10(%rsp), %rdx
movl (%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_set_cursor
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk, style_item, style_items)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(nk,float, floats)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk, vec2, vectors)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(nk,flags, flags)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk,color, colors)

NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(style_item, style_items)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(float,floats)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(vec2, vectors)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(flags,flags)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(color,colors)

NK_API nk_bool
nk_style_set_cursor(struct nk_context *ctx, enum nk_style_cursor c)
{
    struct nk_style *style;
    NK_ASSERT(ctx);
    if (!ctx) return 0;
    style = &ctx->style;
    if (style->cursors[c]) {
        style->cursor_active = style->cursors[c];
        return 1;
    }
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x535c8
movq 0x71a54(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5ddfa(%rip), %rsi     # 0xb13a0
leaq 0x5de11(%rip), %rdx     # 0xb13be
movl $0x4a2a, %ecx           # imm = 0x4A2A
movb $0x0, %al
callq 0x13ec0
movq 0x71a30(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x535ca
cmpq $0x0, 0x18(%rsp)
jne 0x535dc
movl $0x0, 0x24(%rsp)
jmp 0x53626
movq 0x18(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x5361e
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movq 0x8(%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, 0x24(%rsp)
jmp 0x53626
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_load_cursor
NK_API void
nk_style_load_cursor(struct nk_context *ctx, enum nk_style_cursor cursor,
    const struct nk_cursor *c)
{
    struct nk_style *style;
    NK_ASSERT(ctx);
    if (!ctx) return;
    style = &ctx->style;
    style->cursors[cursor] = c;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x536bd
movq 0x7195f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5dd05(%rip), %rsi     # 0xb13a0
leaq 0x5dd1c(%rip), %rdx     # 0xb13be
movl $0x4a42, %ecx           # imm = 0x4A42
movb $0x0, %al
callq 0x13ec0
movq 0x7193b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x536bf
cmpq $0x0, 0x20(%rsp)
jne 0x536c9
jmp 0x536ec
movq 0x20(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq %rdx, 0x8(%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_load_all_cursors
NK_API void
nk_style_load_all_cursors(struct nk_context *ctx, struct nk_cursor *cursors)
{
    int i = 0;
    struct nk_style *style;
    NK_ASSERT(ctx);
    if (!ctx) return;
    style = &ctx->style;
    for (i = 0; i < NK_CURSOR_COUNT; ++i)
        style->cursors[i] = &cursors[i];
    style->cursor_visible = nk_true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x53751
movq 0x718cb(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5dc71(%rip), %rsi     # 0xb13a0
leaq 0x5dc88(%rip), %rdx     # 0xb13be
movl $0x4a4c, %ecx           # imm = 0x4A4C
movb $0x0, %al
callq 0x13ec0
movq 0x718a7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53753
cmpq $0x0, 0x20(%rsp)
jne 0x5375d
jmp 0x537b5
movq 0x20(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x7, 0x14(%rsp)
jge 0x537a9
movq 0x18(%rsp), %rdx
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x53775
movq 0x8(%rsp), %rax
movl $0x1, 0x50(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init_default
NK_API nk_bool
nk_init_default(struct nk_context *ctx, const struct nk_user_font *font)
{
    struct nk_allocator alloc;
    alloc.userdata.ptr = 0;
    alloc.alloc = nk_malloc;
    alloc.free = nk_mfree;
    return nk_init(ctx, &alloc, font);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, (%rsp)
leaq -0x248bd(%rip), %rax    # 0x2ef20
movq %rax, 0x8(%rsp)
leaq -0x248a9(%rip), %rax    # 0x2ef40
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rsp, %rsi
callq 0x152b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init
NK_API nk_bool
nk_init(struct nk_context *ctx, struct nk_allocator *alloc,
    const struct nk_user_font *font)
{
    NK_ASSERT(alloc);
    if (!alloc) return 0;
    nk_setup(ctx, font);
    nk_buffer_init(&ctx->memory, alloc, NK_DEFAULT_COMMAND_BUFFER_SIZE);
    nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY);
    ctx->use_pool = nk_true;
    return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5385e
movq 0x717be(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5db64(%rip), %rsi     # 0xb13a0
leaq 0x5db7b(%rip), %rdx     # 0xb13be
movl $0x4a99, %ecx           # imm = 0x4A99
movb $0x0, %al
callq 0x13ec0
movq 0x7179a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53860
cmpq $0x0, 0x10(%rsp)
jne 0x53872
movl $0x0, 0x24(%rsp)
jmp 0x538ce
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x53990
movq 0x18(%rsp), %rdi
addq $0x2508, %rdi           # imm = 0x2508
movq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x13ea0
movq 0x18(%rsp), %rdi
addq $0x4720, %rdi           # imm = 0x4720
movq 0x10(%rsp), %rsi
movl $0x10, %edx
callq 0x53c60
movq 0x18(%rsp), %rax
movl $0x1, 0x471c(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init_fixed
NK_API nk_bool
nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size,
    const struct nk_user_font *font)
{
    NK_ASSERT(memory);
    if (!memory) return 0;
    nk_setup(ctx, font);
    nk_buffer_init_fixed(&ctx->memory, memory, size);
    ctx->use_pool = nk_false;
    return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x53932
movq 0x716ea(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5da90(%rip), %rsi     # 0xb13a0
leaq 0x5daa7(%rip), %rdx     # 0xb13be
movl $0x4a79, %ecx           # imm = 0x4A79
movb $0x0, %al
callq 0x13ec0
movq 0x716c6(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53934
cmpq $0x0, 0x10(%rsp)
jne 0x53946
movl $0x0, 0x24(%rsp)
jmp 0x53986
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x53990
movq 0x18(%rsp), %rdi
addq $0x2508, %rdi           # imm = 0x2508
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x13720
movq 0x18(%rsp), %rax
movl $0x0, 0x471c(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_setup
NK_INTERN void
nk_setup(struct nk_context *ctx, const struct nk_user_font *font)
{
    NK_ASSERT(ctx);
    if (!ctx) return;
    nk_zero_struct(*ctx);
    nk_style_default(ctx);
    ctx->seq = 1;
    if (font) ctx->style.font = font;
#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
    nk_draw_list_init(&ctx->draw_list);
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x539d9
movq 0x71643(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5d9e9(%rip), %rsi     # 0xb13a0
leaq 0x5da00(%rip), %rdx     # 0xb13be
movl $0x4a60, %ecx           # imm = 0x4A60
movb $0x0, %al
callq 0x13ec0
movq 0x7161f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x539db
cmpq $0x0, 0x10(%rsp)
jne 0x539e5
jmp 0x53a37
movq 0x10(%rsp), %rdi
movl $0x4798, %esi           # imm = 0x4798
callq 0x2f0e0
movq 0x10(%rsp), %rdi
callq 0x13240
movq 0x10(%rsp), %rax
movl $0x1, 0x4794(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x53a26
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x168(%rax)
movq 0x10(%rsp), %rdi
addq $0x30e0, %rdi           # imm = 0x30E0
callq 0x141f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init_custom
NK_API nk_bool
nk_init_custom(struct nk_context *ctx, struct nk_buffer *cmds,
    struct nk_buffer *pool, const struct nk_user_font *font)
{
    NK_ASSERT(cmds);
    NK_ASSERT(pool);
    if (!cmds || !pool) return 0;

    nk_setup(ctx, font);
    ctx->memory = *cmds;
    if (pool->type == NK_BUFFER_FIXED) {
        /* take memory from buffer and alloc fixed pool */
        nk_pool_init_fixed(&ctx->pool, pool->memory.ptr, pool->memory.size);
    } else {
        /* create dynamic pool from buffer allocator */
        struct nk_allocator *alloc = &pool->pool;
        nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY);
    }
    ctx->use_pool = nk_true;
    return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x53a93
movq 0x71589(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5d92f(%rip), %rsi     # 0xb13a0
leaq 0x5d946(%rip), %rdx     # 0xb13be
movl $0x4a84, %ecx           # imm = 0x4A84
movb $0x0, %al
callq 0x13ec0
movq 0x71565(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53a95
jmp 0x53a97
cmpq $0x0, 0x18(%rsp)
jne 0x53ad2
movq 0x7154a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5d8f0(%rip), %rsi     # 0xb13a0
leaq 0x5d907(%rip), %rdx     # 0xb13be
movl $0x4a85, %ecx           # imm = 0x4A85
movb $0x0, %al
callq 0x13ec0
movq 0x71526(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53ad4
cmpq $0x0, 0x20(%rsp)
je 0x53ae4
cmpq $0x0, 0x18(%rsp)
jne 0x53af1
movl $0x0, 0x34(%rsp)
jmp 0x53b8b
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x53990
movq 0x28(%rsp), %rdi
addq $0x2508, %rdi           # imm = 0x2508
movq 0x20(%rsp), %rsi
movl $0x78, %edx
callq 0x14160
movq 0x18(%rsp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x53b4b
movq 0x28(%rsp), %rdi
addq $0x4720, %rdi           # imm = 0x4720
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rdx
callq 0x53ba0
jmp 0x53b74
movq 0x18(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0x4720, %rdi           # imm = 0x4720
movq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x53c60
movq 0x28(%rsp), %rax
movl $0x1, 0x471c(%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_pool_init_fixed
NK_LIB void
nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size)
{
    nk_zero(pool, sizeof(*pool));
    NK_ASSERT(size >= sizeof(struct nk_page));
    if (size < sizeof(struct nk_page)) return;
    /* first nk_page_element is embedded in nk_page, additional elements follow in adjacent space */
    pool->capacity = (unsigned)(1 + (size - sizeof(struct nk_page)) / sizeof(struct nk_page_element));
    pool->pages = (struct nk_page*)memory;
    pool->type = NK_BUFFER_FIXED;
    pool->size = size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x48, %esi
callq 0x2f0e0
cmpq $0x218, (%rsp)          # imm = 0x218
jae 0x53bfe
movq 0x7141e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5d7c4(%rip), %rsi     # 0xb13a0
leaq 0x5d7db(%rip), %rdx     # 0xb13be
movl $0x4bd2, %ecx           # imm = 0x4BD2
movb $0x0, %al
callq 0x13ec0
movq 0x713fa(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53c00
cmpq $0x218, (%rsp)          # imm = 0x218
jae 0x53c0c
jmp 0x53c55
movq (%rsp), %rax
subq $0x218, %rax            # imm = 0x218
movl $0x208, %ecx            # imm = 0x208
xorl %edx, %edx
divq %rcx
addq $0x1, %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_pool_init
NK_LIB void
nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc,
    unsigned int capacity)
{
    NK_ASSERT(capacity >= 1);
    nk_zero(pool, sizeof(*pool));
    pool->alloc = *alloc;
    pool->capacity = capacity;
    pool->type = NK_BUFFER_DYNAMIC;
    pool->pages = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jae 0x53cac
movq 0x71370(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5d716(%rip), %rsi     # 0xb13a0
leaq 0x5d72d(%rip), %rdx     # 0xb13be
movl $0x4bba, %ecx           # imm = 0x4BBA
movb $0x0, %al
callq 0x13ec0
movq 0x7134c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53cae
movq 0x10(%rsp), %rdi
movl $0x48, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_free
NK_API void
nk_free(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    if (!ctx) return;
    nk_buffer_free(&ctx->memory);
    if (ctx->use_pool)
        nk_pool_free(&ctx->pool);

    nk_zero(&ctx->input, sizeof(ctx->input));
    nk_zero(&ctx->style, sizeof(ctx->style));
    nk_zero(&ctx->memory, sizeof(ctx->memory));

    ctx->seq = 0;
    ctx->build = 0;
    ctx->begin = 0;
    ctx->end = 0;
    ctx->active = 0;
    ctx->current = 0;
    ctx->freelist = 0;
    ctx->count = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x53d4f
movq 0x712cd(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5d673(%rip), %rsi     # 0xb13a0
leaq 0x5d68a(%rip), %rdx     # 0xb13be
movl $0x4aae, %ecx           # imm = 0x4AAE
movb $0x0, %al
callq 0x13ec0
movq 0x712a9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x53d51
cmpq $0x0, (%rsp)
jne 0x53d5d
jmp 0x53e37
movq (%rsp), %rdi
addq $0x2508, %rdi           # imm = 0x2508
callq 0x14fc0
movq (%rsp), %rax
cmpl $0x0, 0x471c(%rax)
je 0x53d8a
movq (%rsp), %rdi
addq $0x4720, %rdi           # imm = 0x4720
callq 0x53e40
movq (%rsp), %rdi
movl $0x168, %esi            # imm = 0x168
callq 0x2f0e0
movq (%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
movl $0x23a0, %esi           # imm = 0x23A0
callq 0x2f0e0
movq (%rsp), %rdi
addq $0x2508, %rdi           # imm = 0x2508
movl $0x78, %esi
callq 0x2f0e0
movq (%rsp), %rax
movl $0x0, 0x4794(%rax)
movq (%rsp), %rax
movl $0x0, 0x4718(%rax)
movq (%rsp), %rax
movq $0x0, 0x4768(%rax)
movq (%rsp), %rax
movq $0x0, 0x4770(%rax)
movq (%rsp), %rax
movq $0x0, 0x4778(%rax)
movq (%rsp), %rax
movq $0x0, 0x4780(%rax)
movq (%rsp), %rax
movq $0x0, 0x4788(%rax)
movq (%rsp), %rax
movl $0x0, 0x4790(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_pool_free
NK_LIB void
nk_pool_free(struct nk_pool *pool)
{
    struct nk_page *iter;
    if (!pool) return;
    iter = pool->pages;
    if (pool->type == NK_BUFFER_FIXED) return;
    while (iter) {
        struct nk_page *next = iter->next;
        pool->alloc.free(pool->alloc.userdata, iter);
        iter = next;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x53e53
jmp 0x53ea8
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x53e6e
jmp 0x53ea8
jmp 0x53e70
cmpq $0x0, 0x8(%rsp)
je 0x53ea8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rsi
movq (%rcx), %rdi
callq *%rax
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x53e70
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_free_window
NK_LIB void
nk_free_window(struct nk_context *ctx, struct nk_window *win)
{
    /* unlink windows from list */
    struct nk_table *it = win->tables;
    if (win->popup.win) {
        nk_free_window(ctx, win->popup.win);
        win->popup.win = 0;
    }
    win->next = 0;
    win->prev = 0;

    while (it) {
        /*free window state tables */
        struct nk_table *n = it->next;
        nk_remove_table(win, it);
        nk_free_table(ctx, it);
        if (it == win->tables)
            win->tables = n;
        it = n;
    }

    /* link windows into freelist */
    {union nk_page_data *pd = NK_CONTAINER_OF(win, union nk_page_data, win);
    struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data);
    nk_free_page_element(ctx, pe);}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x1b8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x120(%rax)
je 0x54284
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rsi
callq 0x54230
movq 0x28(%rsp), %rax
movq $0x0, 0x120(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x1c8(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x1d0(%rax)
cmpq $0x0, 0x20(%rsp)
je 0x5430b
movq 0x20(%rsp), %rax
movq 0x1e8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x54340
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x54400
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x1b8(%rcx), %rax
jne 0x542ff
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x1b8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x542a4
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x85770
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_remove_table
NK_LIB void
nk_remove_table(struct nk_window *win, struct nk_table *tbl)
{
    if (win->tables == tbl)
        win->tables = tbl->next;
    if (tbl->next)
        tbl->next->prev = tbl->prev;
    if (tbl->prev)
        tbl->prev->next = tbl->next;
    tbl->next = 0;
    tbl->prev = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x1b8(%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0x54375
movq -0x10(%rsp), %rax
movq 0x1e8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x1b8(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x1e8(%rax)
je 0x543a3
movq -0x10(%rsp), %rax
movq 0x1f0(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x1e8(%rax), %rax
movq %rcx, 0x1f0(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x1f0(%rax)
je 0x543d1
movq -0x10(%rsp), %rax
movq 0x1e8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x1f0(%rax), %rax
movq %rcx, 0x1e8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x1e8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x1f0(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_remove_window
NK_LIB void
nk_remove_window(struct nk_context *ctx, struct nk_window *win)
{
    if (win == ctx->begin || win == ctx->end) {
        if (win == ctx->begin) {
            ctx->begin = win->next;
            if (win->next)
                win->next->prev = 0;
        }
        if (win == ctx->end) {
            ctx->end = win->prev;
            if (win->prev)
                win->prev->next = 0;
        }
    } else {
        if (win->next)
            win->next->prev = win->prev;
        if (win->prev)
            win->prev->next = win->next;
    }
    if (win == ctx->active || !ctx->active) {
        ctx->active = ctx->end;
        if (ctx->end)
            ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM;
    }
    win->next = 0;
    win->prev = 0;
    ctx->count--;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x4768(%rcx), %rax
je 0x54474
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x4770(%rcx), %rax
jne 0x5451c
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x4768(%rcx), %rax
jne 0x544c7
movq -0x10(%rsp), %rax
movq 0x1c8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x4768(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x1c8(%rax)
je 0x544c5
movq -0x10(%rsp), %rax
movq 0x1c8(%rax), %rax
movq $0x0, 0x1d0(%rax)
jmp 0x544c7
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x4770(%rcx), %rax
jne 0x5451a
movq -0x10(%rsp), %rax
movq 0x1d0(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x4770(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
je 0x54518
movq -0x10(%rsp), %rax
movq 0x1d0(%rax), %rax
movq $0x0, 0x1c8(%rax)
jmp 0x5451a
jmp 0x5457a
movq -0x10(%rsp), %rax
cmpq $0x0, 0x1c8(%rax)
je 0x5454a
movq -0x10(%rsp), %rax
movq 0x1d0(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x1c8(%rax), %rax
movq %rcx, 0x1d0(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
je 0x54578
movq -0x10(%rsp), %rax
movq 0x1c8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x1d0(%rax), %rax
movq %rcx, 0x1c8(%rax)
jmp 0x5457a
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x4778(%rcx), %rax
je 0x5459c
movq -0x8(%rsp), %rax
cmpq $0x0, 0x4778(%rax)
jne 0x545dd
movq -0x8(%rsp), %rax
movq 0x4770(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x4778(%rax)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x4770(%rax)
je 0x545db
movq -0x8(%rsp), %rax
movq 0x4770(%rax), %rax
movl 0x48(%rax), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
movl %ecx, 0x48(%rax)
jmp 0x545dd
movq -0x10(%rsp), %rax
movq $0x0, 0x1c8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x1d0(%rax)
movq -0x8(%rsp), %rax
movl 0x4790(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4790(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_find_window
NK_LIB struct nk_window*
nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name)
{
    struct nk_window *iter;
    iter = ctx->begin;
    while (iter) {
        NK_ASSERT(iter != iter->next);
        if (iter->name == hash) {
            int max_len = nk_strlen(iter->name_string);
            if (!nk_stricmpn(iter->name_string, name, max_len))
                return iter;
        }
        iter = iter->next;
    }
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x4768(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x557d9
jmp 0x55731
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x1c8(%rcx), %rax
jne 0x55777
movq 0x6f8a5(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5bc4b(%rip), %rsi     # 0xb13a0
leaq 0x5bc62(%rip), %rdx     # 0xb13be
movl $0x4f2b, %ecx           # imm = 0x4F2B
movb $0x0, %al
callq 0x13ec0
movq 0x6f881(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x55779
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0x557c3
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x14050
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x14850
cmpl $0x0, %eax
jne 0x557c1
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x557e2
jmp 0x557c3
movq 0x10(%rsp), %rax
movq 0x1c8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x55723
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_create_window
NK_LIB void*
nk_create_window(struct nk_context *ctx)
{
    struct nk_page_element *elem;
    elem = nk_create_page_element(ctx);
    if (!elem) return 0;
    elem->data.win.seq = ctx->seq;
    return &elem->data.win;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x85870
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x55819
movq $0x0, 0x10(%rsp)
jmp 0x55833
movq 0x8(%rsp), %rax
movl 0x4794(%rax), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_command_buffer_init
NK_LIB void
nk_command_buffer_init(struct nk_command_buffer *cb,
    struct nk_buffer *b, enum nk_command_clipping clip)
{
    NK_ASSERT(cb);
    NK_ASSERT(b);
    if (!cb || !b) return;
    cb->base = b;
    cb->use_clipping = (int)clip;
    cb->begin = b->allocated;
    cb->end = b->allocated;
    cb->last = b->allocated;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x55b9d
movq 0x6f47f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5b825(%rip), %rsi     # 0xb13a0
leaq 0x5b83c(%rip), %rdx     # 0xb13be
movl $0x22f4, %ecx           # imm = 0x22F4
movb $0x0, %al
callq 0x13ec0
movq 0x6f45b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x55b9f
jmp 0x55ba1
cmpq $0x0, 0x8(%rsp)
jne 0x55bdc
movq 0x6f440(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x5b7e6(%rip), %rsi     # 0xb13a0
leaq 0x5b7fd(%rip), %rdx     # 0xb13be
movl $0x22f5, %ecx           # imm = 0x22F5
movb $0x0, %al
callq 0x13ec0
movq 0x6f41c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x55bde
cmpq $0x0, 0x10(%rsp)
je 0x55bee
cmpq $0x0, 0x8(%rsp)
jne 0x55bf0
jmp 0x55c3f
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%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_create_panel
NK_LIB void*
nk_create_panel(struct nk_context *ctx)
{
    struct nk_page_element *elem;
    elem = nk_create_page_element(ctx);
    if (!elem) return 0;
    nk_zero_struct(*elem);
    return &elem->data.pan;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x85870
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x55d29
movq $0x0, 0x10(%rsp)
jmp 0x55d40
movq (%rsp), %rdi
movl $0x208, %esi            # imm = 0x208
callq 0x2f0e0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)