LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_begin
NK_API void
nk_input_begin(struct nk_context *ctx)
{
    int i;
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    for (i = 0; i < NK_BUTTON_MAX; ++i)
        in->mouse.buttons[i].clicked = 0;

    in->keyboard.text_len = 0;
    in->mouse.scroll_delta = nk_vec2(0,0);
    in->mouse.prev.x = in->mouse.pos.x;
    in->mouse.prev.y = in->mouse.pos.y;
    in->mouse.delta.x = 0;
    in->mouse.delta.y = 0;
    for (i = 0; i < NK_KEY_MAX; i++)
        in->keyboard.keys[i].clicked = 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x36724
xorl %eax, %eax
movl $0x0, 0x108(%rdi,%rax)
addq $0x10, %rax
cmpq $0x40, %rax
jne 0x36623
movl $0x0, 0x100(%rdi)
movq $0x0, 0x15c(%rdi)
movsd 0x144(%rdi), %xmm0
movups %xmm0, 0x14c(%rdi)
movdqa 0x3703c(%rip), %xmm0    # 0x6d6a0
movdqa 0x36f24(%rip), %xmm1    # 0x6d590
xorl %eax, %eax
movdqa 0x36efa(%rip), %xmm2    # 0x6d570
movdqa 0x37032(%rip), %xmm3    # 0x6d6b0
pshufd $0xf5, %xmm3, %xmm4     # xmm4 = xmm3[1,1,3,3]
movdqa 0x37035(%rip), %xmm5    # 0x6d6c0
movdqa %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm3, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm4, %xmm6
pand %xmm7, %xmm6
movd %xmm6, %ecx
testb $0x1, %cl
je 0x366b9
movl $0x0, 0x4(%rdi,%rax,8)
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x366cb
movl $0x0, 0xc(%rdi,%rax,8)
movdqa %xmm0, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm3, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm4, %xmm6
pand %xmm7, %xmm6
pextrw $0x0, %xmm6, %ecx
testb $0x1, %cl
je 0x366fa
movl $0x0, 0x14(%rdi,%rax,8)
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x3670c
movl $0x0, 0x1c(%rdi,%rax,8)
addq $0x4, %rax
paddq %xmm5, %xmm1
paddq %xmm5, %xmm0
cmpq $0x20, %rax
jne 0x3668b
popq %rbx
retq
movq 0x508c5(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a667(%rip), %rsi     # 0x70d9c
leaq 0x3a67e(%rip), %rdx     # 0x70dba
movl $0x4603, %ecx           # imm = 0x4603
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_end
NK_API void
nk_input_end(struct nk_context *ctx)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->mouse.grab)
        in->mouse.grab = 0;
    if (in->mouse.ungrab) {
        in->mouse.grabbed = 0;
        in->mouse.ungrab = 0;
        in->mouse.grab = 0;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x36780
cmpb $0x0, 0x164(%rdi)
je 0x36766
movb $0x0, 0x164(%rdi)
cmpb $0x0, 0x166(%rdi)
je 0x3677f
movb $0x0, 0x166(%rdi)
movw $0x0, 0x164(%rdi)
retq
pushq %rbx
movq 0x50868(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a60a(%rip), %rsi     # 0x70d9c
leaq 0x3a621(%rip), %rdx     # 0x70dba
movl $0x4616, %ecx           # imm = 0x4616
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_motion
NK_API void
nk_input_motion(struct nk_context *ctx, int x, int y)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    in->mouse.pos.x = (float)x;
    in->mouse.pos.y = (float)y;
    in->mouse.delta.x = in->mouse.pos.x - in->mouse.prev.x;
    in->mouse.delta.y = in->mouse.pos.y - in->mouse.prev.y;
}

// Assembly:
testq %rdi, %rdi
je 0x367dc
movd %edx, %xmm0
movd %esi, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movlps %xmm0, 0x144(%rdi)
movsd 0x14c(%rdi), %xmm1
subps %xmm1, %xmm0
movlps %xmm0, 0x154(%rdi)
retq
pushq %rbx
movq 0x5080c(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a5ae(%rip), %rsi     # 0x70d9c
leaq 0x3a5c5(%rip), %rdx     # 0x70dba
movl $0x4625, %ecx           # imm = 0x4625
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_key
NK_API void
nk_input_key(struct nk_context *ctx, enum nk_keys key, nk_bool down)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
#ifdef NK_KEYSTATE_BASED_INPUT
    if (in->keyboard.keys[key].down != down)
        in->keyboard.keys[key].clicked++;
#else
    in->keyboard.keys[key].clicked++;
#endif
    in->keyboard.keys[key].down = down;
}

// Assembly:
testq %rdi, %rdi
je 0x3681e
movl %esi, %eax
cmpl %edx, (%rdi,%rax,8)
je 0x3681a
incl 0x4(%rdi,%rax,8)
movl %edx, (%rdi,%rax,8)
retq
pushq %rbx
movq 0x507ca(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a56c(%rip), %rsi     # 0x70d9c
leaq 0x3a583(%rip), %rdx     # 0x70dba
movl $0x4631, %ecx           # imm = 0x4631
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_button
NK_API void
nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, nk_bool down)
{
    struct nk_mouse_button *btn;
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->mouse.buttons[id].down == down) return;

    btn = &in->mouse.buttons[id];
    btn->clicked_pos.x = (float)x;
    btn->clicked_pos.y = (float)y;
    btn->down = down;
    btn->clicked++;

    /* Fix Click-Drag for touch events. */
    in->mouse.delta.x = 0;
    in->mouse.delta.y = 0;
#ifdef NK_BUTTON_TRIGGER_ON_RELEASE
    if (down == 1 && id == NK_BUTTON_LEFT)
    {
        in->mouse.down_pos.x = btn->clicked_pos.x;
        in->mouse.down_pos.y = btn->clicked_pos.y;
    }
#endif
}

// Assembly:
testq %rdi, %rdi
je 0x3688f
movl %esi, %eax
shlq $0x4, %rax
cmpl %r8d, 0x104(%rdi,%rax)
je 0x3688e
addq %rdi, %rax
addq $0x104, %rax            # imm = 0x104
movd %ecx, %xmm0
movd %edx, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movlps %xmm0, 0x8(%rax)
movl %r8d, (%rax)
incl 0x4(%rax)
movq $0x0, 0x154(%rdi)
retq
pushq %rbx
movq 0x50759(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a4fb(%rip), %rsi     # 0x70d9c
leaq 0x3a512(%rip), %rdx     # 0x70dba
movl $0x4641, %ecx           # imm = 0x4641
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_glyph
NK_API void
nk_input_glyph(struct nk_context *ctx, const nk_glyph glyph)
{
    int len = 0;
    nk_rune unicode;
    struct nk_input *in;

    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;

    len = nk_utf_decode(glyph, &unicode, NK_UTF_SIZE);
    if (len && ((in->keyboard.text_len + len) < NK_INPUT_MAX)) {
        nk_utf_encode(unicode, &in->keyboard.text[in->keyboard.text_len],
            NK_INPUT_MAX - in->keyboard.text_len);
        in->keyboard.text_len += len;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x36965
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x12ef0
testl %eax, %eax
je 0x3695d
movl %eax, %r14d
movslq 0x100(%rbx), %rax
leal (%rax,%r14), %ecx
cmpl $0xf, %ecx
jg 0x3695d
movl 0x4(%rsp), %edi
leaq (%rbx,%rax), %rsi
addq $0xf0, %rsi
movl $0x10, %edx
subl %eax, %edx
callq 0x12e50
addl %r14d, 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x50684(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a426(%rip), %rsi     # 0x70d9c
leaq 0x3a43d(%rip), %rdx     # 0x70dba
movl $0x4666, %ecx           # imm = 0x4666
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x369b8
leaq 0xc(%rsp), %rax
movb %sil, (%rax)
movq %rax, %rsi
callq 0x12040
addq $0x10, %rsp
popq %rbx
retq
movq 0x50631(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a3d3(%rip), %rsi     # 0x70d9c
leaq 0x3a3ea(%rip), %rdx     # 0x70dba
movl $0x4675, %ecx           # imm = 0x4675
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x36a1c
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, %edi
movq %r14, %rsi
movl $0x4, %edx
callq 0x12e50
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12040
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x505cd(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3a36f(%rip), %rsi     # 0x70d9c
leaq 0x3a386(%rip), %rdx     # 0x70dba
movl $0x467e, %ecx           # imm = 0x467E
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x36a78
movl %esi, %ecx
shlq $0x4, %rcx
cmpl $0x0, 0x108(%rdi,%rcx)
je 0x36a78
addq %rdi, %rcx
addq $0x104, %rcx            # imm = 0x104
xorl %eax, %eax
cmpl $0x0, (%rcx)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x36b7f
movl %esi, %ecx
shlq $0x4, %rcx
movss 0x10c(%rdi,%rcx), %xmm2
ucomiss %xmm0, %xmm2
jb 0x36b7f
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
ucomiss %xmm2, %xmm3
jbe 0x36b7f
leaq (%rdi,%rcx), %rsi
addq $0x10c, %rsi            # imm = 0x10C
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss 0x4(%rsi), %xmm2
ucomiss %xmm3, %xmm2
jb 0x36b7f
addps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm2, %xmm0
jbe 0x36b7f
addq $0x104, %rdi            # imm = 0x104
xorl %eax, %eax
cmpl %edx, (%rdi,%rcx)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x36bdc
movl %esi, %ecx
shlq $0x4, %rcx
movss 0x10c(%rdi,%rcx), %xmm2
ucomiss %xmm0, %xmm2
jb 0x36bdc
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
ucomiss %xmm2, %xmm3
jbe 0x36bdc
leaq (%rdi,%rcx), %rdx
addq $0x10c, %rdx            # imm = 0x10C
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss 0x4(%rdx), %xmm2
ucomiss %xmm3, %xmm2
jb 0x36bdc
addps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm2, %xmm0
jbe 0x36bdc
addq $0x104, %rdi            # imm = 0x104
cmpl $0x0, (%rdi,%rcx)
je 0x36bdd
retq
xorl %eax, %eax
cmpl $0x0, 0x4(%rdi,%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x36c4d
movl %esi, %ecx
shlq $0x4, %rcx
movss 0x10c(%rdi,%rcx), %xmm2
ucomiss %xmm0, %xmm2
jb 0x36c4d
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
ucomiss %xmm2, %xmm3
jbe 0x36c4d
leaq (%rdi,%rcx), %rsi
addq $0x10c, %rsi            # imm = 0x10C
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss 0x4(%rsi), %xmm2
ucomiss %xmm3, %xmm2
jb 0x36c4d
addps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm2, %xmm0
jbe 0x36c4d
addq $0x104, %rdi            # imm = 0x104
cmpl %edx, (%rdi,%rcx)
jne 0x36c4d
xorl %eax, %eax
cmpl $0x0, 0x4(%rdi,%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
addps %xmm0, %xmm1
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
xorl %eax, %eax
xorl %ecx, %ecx
testq %rdi, %rdi
sete %dl
orb %cl, %dl
testb $0x1, %dl
je 0x36c7c
addq $0x10, %rax
cmpq $0x40, %rax
jne 0x36c63
jmp 0x36cc1
movss 0x10c(%rdi,%rax), %xmm4
xorl %ecx, %ecx
ucomiss %xmm0, %xmm4
jb 0x36c70
ucomiss %xmm4, %xmm1
jbe 0x36c70
movss 0x110(%rdi,%rax), %xmm4
xorl %ecx, %ecx
ucomiss %xmm2, %xmm4
jb 0x36c70
ucomiss %xmm4, %xmm3
jbe 0x36c70
cmpl $0x0, 0x104(%rdi,%rax)
je 0x36cb4
xorl %ecx, %ecx
jmp 0x36c70
cmpl $0x0, 0x108(%rdi,%rax)
setne %cl
jmp 0x36c70
movzbl %cl, %eax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x36e25
movl %esi, %eax
shlq $0x4, %rax
cmpl $0x0, 0x104(%rdi,%rax)
je 0x36e26
leaq (%rdi,%rax), %rcx
addq $0x104, %rcx            # imm = 0x104
movl $0x1, %eax
cmpl $0x0, 0x4(%rcx)
je 0x36e26
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x36e71
movl %esi, %eax
cmpl $0x0, (%rdi,%rax,8)
movl 0x4(%rdi,%rax,8), %ecx
movl $0x1, %eax
je 0x36e72
testl %ecx, %ecx
je 0x36e77
retq
cmpl $0x1, %ecx
ja 0x36e71
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x387a1
movq %rsi, 0x168(%rdi)
movl $0x0, 0x2fc8(%rdi)
cmpq $0x0, 0x4780(%rdi)
jne 0x13bf0
retq
pushq %rbx
movq 0x4e847(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x385e9(%rip), %rsi     # 0x70d9c
leaq 0x38600(%rip), %rdx     # 0x70dba
movl $0x49cb, %ecx           # imm = 0x49CB
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x38807
movq 0x4e80e(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x385b0(%rip), %rsi     # 0x70d9c
leaq 0x385c7(%rip), %rdx     # 0x70dba
movl $0x54d6, %ecx           # imm = 0x54D6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38846
movq 0x4e7d6(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x38578(%rip), %rsi     # 0x70d9c
leaq 0x3858f(%rip), %rdx     # 0x70dba
movl $0x54d7, %ecx           # imm = 0x54D7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x38888
movq 0x4e799(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x3853b(%rip), %rsi     # 0x70d9c
leaq 0x38552(%rip), %rdx     # 0x70dba
movl $0x54d8, %ecx           # imm = 0x54D8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x388c1
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x388c1
movq 0x168(%rbx), %rcx
movss 0x1c4(%rbx), %xmm0
addss %xmm0, %xmm0
addss 0x8(%rcx), %xmm0
movss 0x24ac(%rbx), %xmm1
addss %xmm1, %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x7c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x38960
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2fc8(%rdi), %eax
cmpl $0x8, %eax
jl 0x38924
movq 0x4e6ff(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x384a1(%rip), %rsi     # 0x70d9c
leaq 0x384b8(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x49de, %ecx           # imm = 0x49DE
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movl 0x2fc8(%r14), %eax
cmpl $0x7, %eax
jg 0x3898e
leal 0x1(%rax), %ecx
movl %ecx, 0x2fc8(%r14)
cltq
shlq $0x4, %rax
leaq 0x168(%r14), %rcx
movq %rcx, 0x2fd0(%r14,%rax)
movq 0x168(%r14), %rcx
movq %rcx, 0x2fd8(%r14,%rax)
movq %rbx, 0x168(%r14)
movl $0x1, %ebp
jmp 0x3898e
movq 0x4e689(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3842b(%rip), %rsi     # 0x70d9c
leaq 0x38442(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x49da, %ecx           # imm = 0x49DA
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x38a0f
movq %rdi, %rbx
movl 0x2fc8(%rdi), %eax
testl %eax, %eax
jg 0x389e9
movq 0x4e638(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x383da(%rip), %rsi     # 0x70d9c
leaq 0x383f1(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x49f2, %ecx           # imm = 0x49F2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl 0x2fc8(%rbx), %eax
testl %eax, %eax
jle 0x38a3d
decl %eax
movl %eax, 0x2fc8(%rbx)
shlq $0x4, %rax
movq 0x2fd0(%rbx,%rax), %rcx
movq 0x2fd8(%rbx,%rax), %rax
movq %rax, (%rcx)
movl $0x1, %ebp
jmp 0x38a3d
movq 0x4e5da(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3837c(%rip), %rsi     # 0x70d9c
leaq 0x38393(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x49ee, %ecx           # imm = 0x49EE
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x391f7
movl %esi, %eax
movq 0x170(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x39227
movq %rax, 0x1a8(%rdi)
movl $0x1, %ebx
jmp 0x39229
movq 0x4ddf2(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x37b94(%rip), %rsi     # 0x70d9c
leaq 0x37bab(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x4a2a, %ecx           # imm = 0x4A2A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x39229
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x39318
movdqa 0x342f8(%rip), %xmm0    # 0x6d590
xorl %eax, %eax
movdqa 0x342ce(%rip), %xmm1    # 0x6d570
movdqa 0x343e6(%rip), %xmm2    # 0x6d690
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x34379(%rip), %xmm4    # 0x6d630
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %ecx
testb $0x1, %cl
je 0x392e5
movq %rsi, 0x170(%rdi,%rax,8)
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0x392fb
leaq 0x28(%rsi), %rcx
movq %rcx, 0x178(%rdi,%rax,8)
addq $0x2, %rax
paddq %xmm4, %xmm0
addq $0x50, %rsi
cmpq $0x8, %rax
jne 0x392b7
movl $0x1, 0x1b8(%rdi)
retq
pushq %rbx
movq 0x4dcd0(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x37a72(%rip), %rsi     # 0x70d9c
leaq 0x37a89(%rip), %rdx     # 0x70dba
movl $0x4a4c, %ecx           # imm = 0x4A4C
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %rsi, %rdx
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq -0x140c9(%rip), %rax    # 0x25295
movq %rax, 0x8(%rsi)
leaq -0x140cc(%rip), %rax    # 0x2529d
movq %rax, 0x10(%rsi)
callq 0x13ff0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x393f1
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x3949a
leaq 0x2508(%rbx), %rdi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0x12d60
leaq 0x4720(%rbx), %rdi
movl $0x48, %esi
callq 0x2542e
movq 0x10(%r14), %rax
movq %rax, 0x4730(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x4720(%rbx)
movl $0x10, 0x4750(%rbx)
movl $0x1, %ebp
movl %ebp, 0x4738(%rbx)
movq $0x0, 0x4740(%rbx)
movl %ebp, 0x471c(%rbx)
jmp 0x3941f
movq 0x4dbf8(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3799a(%rip), %rsi     # 0x70d9c
leaq 0x379b1(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x4a99, %ecx           # imm = 0x4A99
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x39464
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x3949a
leaq 0x2508(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12680
movl $0x0, 0x471c(%rbx)
movl $0x1, %ebx
jmp 0x39492
movq 0x4db85(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x37927(%rip), %rsi     # 0x70d9c
leaq 0x3793e(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x4a79, %ecx           # imm = 0x4A79
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x394ee
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
andq $0x3, %r15
je 0x39525
movl $0x4, %r12d
subq %r15, %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
leaq (%rbx,%r12), %rdi
movl $0x4794, %edx           # imm = 0x4794
xorl %esi, %esi
callq 0x12b50
leaq (%rbx,%r12), %rdi
addq $0x4794, %rdi           # imm = 0x4794
xorl %esi, %esi
movq %r15, %rdx
jmp 0x3952f
movq 0x4dafb(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3789d(%rip), %rsi     # 0x70d9c
leaq 0x378b4(%rip), %rdx     # 0x70dba
movl $0x4a60, %ecx           # imm = 0x4A60
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13780
movl $0x4798, %edx           # imm = 0x4798
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12b50
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12a10
movl $0x1, 0x4794(%rbx)
testq %r14, %r14
je 0x39554
movq %r14, 0x168(%rbx)
addq $0x30e0, %rbx           # imm = 0x30E0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13090
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
testq %rsi, %rsi
je 0x395ff
testq %r14, %r14
je 0x39636
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x3949a
leaq 0x2508(%rbx), %rdi
movl $0xf, %ecx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpl $0x0, 0x38(%r14)
je 0x39669
leaq 0x4720(%rbx), %rdi
movl $0x48, %esi
callq 0x2542e
movq 0x30(%r14), %rax
movq %rax, 0x4730(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x4720(%rbx)
movl $0x10, 0x4750(%rbx)
movl $0x1, 0x4738(%rbx)
movq $0x0, 0x4740(%rbx)
jmp 0x396f1
movq 0x4d9ea(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x3778c(%rip), %rsi     # 0x70d9c
leaq 0x377a3(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x4a84, %ecx           # imm = 0x4A84
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
jne 0x39700
movq 0x4d9b3(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x37755(%rip), %rsi     # 0x70d9c
leaq 0x3776c(%rip), %rdx     # 0x70dba
xorl %ebx, %ebx
movl $0x4a85, %ecx           # imm = 0x4A85
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x39700
leaq 0x4720(%rbx), %rdi
movq 0x40(%r14), %r15
movq 0x48(%r14), %r14
movl $0x48, %esi
callq 0x2542e
cmpq $0x217, %r14            # imm = 0x217
jbe 0x396c5
leaq -0x218(%r14), %rax
movabsq $0xfc0fc0fc0fc0fc1, %rcx # imm = 0xFC0FC0FC0FC0FC1
mulq %rcx
shrq $0x5, %rdx
incl %edx
movl %edx, 0x4750(%rbx)
movq %r15, 0x4740(%rbx)
movl $0x0, 0x4738(%rbx)
movq %r14, 0x4758(%rbx)
jmp 0x396f1
movq 0x4d924(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x376c6(%rip), %rsi     # 0x70d9c
leaq 0x376dd(%rip), %rdx     # 0x70dba
movl $0x4bd2, %ecx           # imm = 0x4BD2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl $0x1, 0x471c(%rbx)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x397c5
movq %rdi, %rbx
movq 0x2548(%rdi), %rsi
testq %rsi, %rsi
je 0x39747
cmpl $0x0, 0x2540(%rbx)
je 0x39747
movq 0x2538(%rbx), %rax
testq %rax, %rax
je 0x39747
movq 0x2528(%rbx), %rdi
callq *%rax
cmpl $0x0, 0x471c(%rbx)
je 0x39784
movq 0x4740(%rbx), %rsi
cmpl $0x0, 0x4738(%rbx)
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x39784
movq 0x8(%rsi), %r14
movq 0x4720(%rbx), %rdi
callq *0x4730(%rbx)
movq %r14, %rsi
testq %r14, %r14
jne 0x3976b
movq %rbx, %r14
andq $0x3, %r14
je 0x397fa
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
leaq (%rbx,%r15), %rdi
movl $0x164, %edx            # imm = 0x164
xorl %esi, %esi
callq 0x12b50
leaq (%rbx,%r15), %rdi
addq $0x164, %rdi            # imm = 0x164
xorl %esi, %esi
movq %r14, %rdx
jmp 0x39804
movq 0x4d824(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x375c6(%rip), %rsi     # 0x70d9c
leaq 0x375dd(%rip), %rdx     # 0x70dba
movl $0x4aae, %ecx           # imm = 0x4AAE
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13780
movl $0x168, %edx            # imm = 0x168
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12b50
leaq 0x2508(%rbx), %r14
leaq 0x168(%rbx), %r15
movq %r15, %r12
andq $0x3, %r12
je 0x39858
movl $0x4, %r13d
subq %r12, %r13
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
leaq (%r15,%r13), %rdi
movl $0x239c, %edx           # imm = 0x239C
xorl %esi, %esi
callq 0x12b50
leaq (%r15,%r13), %rdi
addq $0x239c, %rdi           # imm = 0x239C
xorl %esi, %esi
movq %r12, %rdx
jmp 0x39862
movl $0x23a0, %edx           # imm = 0x23A0
movq %r15, %rdi
xorl %esi, %esi
callq 0x12b50
movq %r14, %r15
andq $0x3, %r15
je 0x398c0
movl $0x4, %r12d
subq %r15, %r12
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
xorps %xmm0, %xmm0
leaq (%r14,%r12), %rdi
addq $0x74, %rdi
movups %xmm0, -0x74(%rdi)
movups %xmm0, -0x64(%rdi)
movups %xmm0, -0x54(%rdi)
movups %xmm0, -0x44(%rdi)
movups %xmm0, -0x34(%rdi)
movups %xmm0, -0x24(%rdi)
movups %xmm0, -0x14(%rdi)
movl $0x0, -0x4(%rdi)
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
jmp 0x398ed
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq $0x0, 0x70(%r14)
movl $0x0, 0x4718(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4768(%rbx)
movups %xmm0, 0x4778(%rbx)
movups %xmm0, 0x4788(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x120(%rsi), %rsi
movq 0x1b8(%rbx), %r15
testq %rsi, %rsi
je 0x39c4a
movq %r14, %rdi
callq 0x39c16
movq $0x0, 0x120(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rbx)
testq %r15, %r15
je 0x39cc9
movq 0x1b8(%rbx), %rax
movq 0x1e8(%r15), %r12
cmpq %r15, %rax
jne 0x39c73
movq %r12, 0x1b8(%rbx)
movq 0x1f0(%r15), %rax
testq %r12, %r12
je 0x39c87
movq %rax, 0x1f0(%r12)
testq %rax, %rax
je 0x39c93
movq %r12, 0x1e8(%rax)
leaq 0x1e8(%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x56ab8
movq 0x1b8(%rbx), %rax
cmpq %rax, %r15
jne 0x39cc1
movq %r12, 0x1b8(%rbx)
movq %r12, %rax
movq %r12, %r15
testq %r12, %r12
jne 0x39c60
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x56ab8
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq %rsi, 0x4768(%rdi)
je 0x39d15
movq 0x4770(%rdi), %rax
cmpq %rsi, %rax
je 0x39d33
movq 0x1c8(%rsi), %rdx
movq 0x1d0(%rsi), %rcx
testq %rdx, %rdx
je 0x39d0e
movq %rcx, 0x1d0(%rdx)
testq %rcx, %rcx
jne 0x39d57
jmp 0x39d5e
movq 0x1c8(%rsi), %rax
movq %rax, 0x4768(%rdi)
testq %rax, %rax
je 0x39d33
movq $0x0, 0x1d0(%rax)
movq 0x4770(%rdi), %rax
cmpq %rsi, %rax
jne 0x39d5e
movq 0x1d0(%rsi), %rcx
movq %rcx, 0x4770(%rdi)
testq %rcx, %rcx
je 0x39d96
xorl %edx, %edx
movq %rcx, %rax
movq %rdx, 0x1c8(%rcx)
movq 0x4778(%rdi), %rcx
cmpq %rsi, %rcx
sete %dl
testq %rcx, %rcx
sete %cl
orb %dl, %cl
je 0x39d85
movq %rax, 0x4778(%rdi)
testq %rax, %rax
je 0x39d85
andb $-0x11, 0x49(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rsi)
decl 0x4790(%rdi)
retq
movq 0x4778(%rdi), %rax
cmpq %rsi, %rax
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x39d85
movq $0x0, 0x4778(%rdi)
jmp 0x39d85
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4768(%rdi), %rbx
testq %rbx, %rbx
je 0x3a5a6
movq %rdx, %r14
movl %esi, %ebp
movq 0x4cab8(%rip), %r13     # 0x86ff0
leaq 0x3685d(%rip), %r15     # 0x70d9c
leaq 0x36874(%rip), %r12     # 0x70dba
cmpq 0x1c8(%rbx), %rbx
jne 0x3a56e
movq (%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x4f2b, %ecx           # imm = 0x4F2B
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
cmpl %ebp, 0x4(%rbx)
jne 0x3a59a
cmpb $0x0, 0x8(%rbx)
je 0x3a588
xorl %edx, %edx
cmpb $0x0, 0x9(%rbx,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x3a57b
jmp 0x3a58a
xorl %edx, %edx
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x13660
testl %eax, %eax
je 0x3a5a8
movq 0x1c8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3a546
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_insert_window
NK_LIB void
nk_insert_window(struct nk_context *ctx, struct nk_window *win,
    enum nk_window_insert_location loc)
{
    const struct nk_window *iter;
    NK_ASSERT(ctx);
    NK_ASSERT(win);
    if (!win || !ctx) return;

    iter = ctx->begin;
    while (iter) {
        NK_ASSERT(iter != iter->next);
        NK_ASSERT(iter != win);
        if (iter == win) return;
        iter = iter->next;
    }

    if (!ctx->begin) {
        win->next = 0;
        win->prev = 0;
        ctx->begin = win;
        ctx->end = win;
        ctx->count = 1;
        return;
    }
    if (loc == NK_INSERT_BACK) {
        struct nk_window *end;
        end = ctx->end;
        end->flags |= NK_WINDOW_ROM;
        end->next = win;
        win->prev = ctx->end;
        win->next = 0;
        ctx->end = win;
        ctx->active = ctx->end;
        ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM;
    } else {
        /*ctx->end->flags |= NK_WINDOW_ROM;*/
        ctx->begin->prev = win;
        win->next = ctx->begin;
        win->prev = 0;
        ctx->begin = win;
        ctx->begin->flags &= ~(nk_flags)NK_WINDOW_ROM;
    }
    ctx->count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x3a660
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
leaq 0x4768(%rdi), %rax
movq 0x4ca07(%rip), %rbp     # 0x86ff0
leaq 0x367ac(%rip), %r15     # 0x70d9c
leaq 0x367c3(%rip), %r12     # 0x70dba
movq %rax, 0x10(%rsp)
movq (%rax), %r13
testq %r13, %r13
je 0x3a69a
cmpq 0x1c8(%r13), %r13
jne 0x3a630
movq (%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x4f40, %ecx           # imm = 0x4F40
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
leaq 0x1c8(%r13), %rax
cmpq %r14, %r13
jne 0x3a5fc
movq (%rbp), %rdi
leaq 0x36755(%rip), %rsi     # 0x70d9c
leaq 0x3676c(%rip), %rdx     # 0x70dba
movl $0x4f41, %ecx           # imm = 0x4F41
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
jmp 0x3a687
movq 0x4c989(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x3672b(%rip), %rsi     # 0x70d9c
leaq 0x36742(%rip), %rdx     # 0x70dba
movl $0x4f3b, %ecx           # imm = 0x4F3B
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x3a6c9
cmpl $0x0, 0xc(%rsp)
je 0x3a6ee
movq %r14, 0x1d0(%rax)
movq %rax, 0x1c8(%r14)
movq $0x0, 0x1d0(%r14)
jmp 0x3a723
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%r14)
movq %r14, 0x4768(%rbx)
movq %r14, 0x4770(%rbx)
movl $0x1, 0x4790(%rbx)
jmp 0x3a731
movq 0x4770(%rbx), %rax
orl $0x1000, 0x48(%rax)     # imm = 0x1000
movq %r14, 0x1c8(%rax)
movq %rax, 0x1d0(%r14)
movq $0x0, 0x1c8(%r14)
movq %r14, 0x4770(%rbx)
leaq 0x4778(%rbx), %rcx
movq %r14, (%rcx)
andb $-0x11, 0x49(%r14)
incl 0x4790(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
callq 0x56b07
movq %rax, %rbx
testq %rax, %rax
je 0x3a796
movq %rbx, %r14
andq $0x3, %r14
je 0x3a79f
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
leaq (%rbx,%r15), %rdi
movl $0x204, %edx            # imm = 0x204
xorl %esi, %esi
callq 0x12b50
leaq (%rbx,%r15), %rdi
addq $0x204, %rdi            # imm = 0x204
xorl %esi, %esi
movq %r14, %rdx
callq 0x12b50
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x208, %edx            # imm = 0x208
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x12b50
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_bounds
NK_API struct nk_rect
nk_window_get_bounds(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_rect(0,0,0,0);
    return ctx->current->bounds;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c0b0
movq 0x4af65(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34d07(%rip), %rsi     # 0x70d9c
leaq 0x34d1e(%rip), %rdx     # 0x70dba
movl $0x5035, %ecx           # imm = 0x5035
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3c0f4
movq 0x4af2d(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34ccf(%rip), %rsi     # 0x70d9c
leaq 0x34ce6(%rip), %rdx     # 0x70dba
movl $0x5036, %ecx           # imm = 0x5036
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3c106
movsd 0x4c(%rax), %xmm0
movsd 0x54(%rax), %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
jmp 0x3c0fe
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_position
NK_API struct nk_vec2
nk_window_get_position(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->bounds.x, ctx->current->bounds.y);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c146
movq 0x4aecf(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34c71(%rip), %rsi     # 0x70d9c
leaq 0x34c88(%rip), %rdx     # 0x70dba
movl $0x503d, %ecx           # imm = 0x503D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3c18a
movq 0x4ae97(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34c39(%rip), %rsi     # 0x70d9c
leaq 0x34c50(%rip), %rdx     # 0x70dba
movl $0x503e, %ecx           # imm = 0x503E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3c197
movsd 0x4c(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x3c18f
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_size
NK_API struct nk_vec2
nk_window_get_size(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->bounds.w, ctx->current->bounds.h);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c1d4
movq 0x4ae41(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34be3(%rip), %rsi     # 0x70d9c
leaq 0x34bfa(%rip), %rdx     # 0x70dba
movl $0x5045, %ecx           # imm = 0x5045
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3c218
movq 0x4ae09(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34bab(%rip), %rsi     # 0x70d9c
leaq 0x34bc2(%rip), %rdx     # 0x70dba
movl $0x5046, %ecx           # imm = 0x5046
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3c225
movsd 0x54(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x3c21d
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_width
NK_API float
nk_window_get_width(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return 0;
    return ctx->current->bounds.w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c262
movq 0x4adb3(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34b55(%rip), %rsi     # 0x70d9c
leaq 0x34b6c(%rip), %rdx     # 0x70dba
movl $0x504d, %ecx           # imm = 0x504D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3c2a6
movq 0x4ad7b(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x34b1d(%rip), %rsi     # 0x70d9c
leaq 0x34b34(%rip), %rdx     # 0x70dba
movl $0x504e, %ecx           # imm = 0x504E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3c2b3
movss 0x54(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x3c2ab