LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_checkbox_text
NK_API nk_bool
nk_checkbox_text(struct nk_context *ctx, const char *text, int len, nk_bool *active)
{
    int old_val;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_val = *active;
    *active = nk_check_text(ctx, text, len, *active);
    return old_val != *active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x48119
movq 0x3eefe(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x28c9f(%rip), %rsi     # 0x70d9c
leaq 0x28cb6(%rip), %rdx     # 0x70dba
movl $0x6194, %ecx           # imm = 0x6194
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r14, %r14
jne 0x4814c
movq 0x3eecb(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x28c6c(%rip), %rsi     # 0x70d9c
leaq 0x28c83(%rip), %rdx     # 0x70dba
movl $0x6195, %ecx           # imm = 0x6195
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x48185
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x481b4
movl (%rbx), %r13d
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0x133c0
movl %eax, (%rbx)
xorl %r12d, %r12d
cmpl %eax, %r13d
setne %r12b
jmp 0x481b4
movq 0x3ee64(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x28c06(%rip), %rsi     # 0x70d9c
leaq 0x28c1d(%rip), %rdx     # 0x70dba
xorl %r12d, %r12d
movl $0x6196, %ecx           # imm = 0x6196
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %r12d, %eax
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_checkbox_text_align
NK_API nk_bool
nk_checkbox_text_align(struct nk_context *ctx, const char *text, int len, nk_bool *active, nk_flags widget_alignment, nk_flags text_alignment)
{
    int old_val;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_val = *active;
    *active = nk_check_text_align(ctx, text, len, *active, widget_alignment, text_alignment);
    return old_val != *active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
jne 0x48216
movq 0x3edff(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x28ba1(%rip), %rsi     # 0x70d9c
leaq 0x28bb8(%rip), %rdx     # 0x70dba
movl $0x61a0, %ecx           # imm = 0x61A0
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %r12, %r12
jne 0x48247
movq 0x3edce(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x28b70(%rip), %rsi     # 0x70d9c
leaq 0x28b87(%rip), %rdx     # 0x70dba
movl $0x61a1, %ecx           # imm = 0x61A1
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x48287
movl %ebp, %r9d
testq %r12, %r12
sete %al
testq %r13, %r13
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x482b5
movl (%rbx), %r14d
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
movl 0x4(%rsp), %r8d
callq 0x13120
movl %eax, (%rbx)
xorl %ebp, %ebp
cmpl %eax, %r14d
setne %bpl
jmp 0x482b5
movq 0x3ed62(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x28b04(%rip), %rsi     # 0x70d9c
leaq 0x28b1b(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x61a2, %ecx           # imm = 0x61A2
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_checkbox_flags_text
NK_API nk_bool
nk_checkbox_flags_text(struct nk_context *ctx, const char *text, int len,
    unsigned int *flags, unsigned int value)
{
    nk_bool active;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(flags);
    if (!ctx || !text || !flags) return 0;

    active = (int)((*flags & value) & value);
    if (nk_checkbox_text(ctx, text, len, &active)) {
        if (active) *flags |= value;
        else *flags &= ~value;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
testq %rdi, %rdi
jne 0x48312
movq 0x3ed05(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x28aa6(%rip), %rsi     # 0x70d9c
leaq 0x28abd(%rip), %rdx     # 0x70dba
movl $0x61ad, %ecx           # imm = 0x61AD
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %r15, %r15
jne 0x48345
movq 0x3ecd2(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x28a73(%rip), %rsi     # 0x70d9c
leaq 0x28a8a(%rip), %rdx     # 0x70dba
movl $0x61ae, %ecx           # imm = 0x61AE
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %r14, %r14
je 0x4837e
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
xorl %r13d, %r13d
orb %al, %cl
jne 0x483bd
movl %ebp, %edx
movl (%r14), %ebp
andl %ebx, %ebp
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x133c0
cmpl %eax, %ebp
je 0x483bd
testl %eax, %eax
je 0x483af
orl (%r14), %ebx
jmp 0x483b4
movq 0x3ec6b(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x28a0d(%rip), %rsi     # 0x70d9c
leaq 0x28a24(%rip), %rdx     # 0x70dba
xorl %r13d, %r13d
movl $0x61af, %ecx           # imm = 0x61AF
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
jmp 0x483bd
notl %ebx
andl (%r14), %ebx
movl %ebx, (%r14)
movl $0x1, %r13d
movl %r13d, %eax
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_option_text
NK_API nk_bool
nk_option_text(struct nk_context *ctx, const char *text, int len, nk_bool is_active)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    struct nk_rect bounds;
    enum nk_widget_layout_states state;

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

    win = ctx->current;
    style = &ctx->style;
    layout = win->layout;

    state = nk_widget(&bounds, ctx);
    if (!state) return (int)state;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &is_active,
        text, len, NK_TOGGLE_OPTION, &style->option, in, style->font, NK_WIDGET_LEFT, NK_TEXT_LEFT);
    return is_active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, 0x4(%rsp)
testq %rdi, %rdi
jne 0x4851d
movq 0x3eafa(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x2889b(%rip), %rsi     # 0x70d9c
leaq 0x288b2(%rip), %rdx     # 0x70dba
movl $0x61e0, %ecx           # imm = 0x61E0
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%rbx), %r12
testq %r12, %r12
jne 0x4855e
movq 0x3eac0(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x28861(%rip), %rsi     # 0x70d9c
leaq 0x28878(%rip), %rdx     # 0x70dba
movl $0x61e1, %ecx           # imm = 0x61E1
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%rbx), %r12
cmpq $0x0, 0xa8(%r12)
jne 0x485a7
movq 0x3ea80(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x28821(%rip), %rsi     # 0x70d9c
leaq 0x28838(%rip), %rdx     # 0x70dba
movl $0x61e2, %ecx           # imm = 0x61E2
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%rbx), %r12
testq %r12, %r12
je 0x48631
movq 0xa8(%r12), %r13
testq %r13, %r13
je 0x48631
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x128e0
movl %eax, %r15d
testl %eax, %eax
je 0x48631
xorl %eax, %eax
cmpl $0x1, %r15d
jne 0x485d9
testb $0x10, 0x5(%r13)
cmoveq %rbx, %rax
leaq 0x2598(%rbx), %rdi
addq $0x68, %r12
leaq 0x458(%rbx), %r10
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subq $0x8, %rsp
movl $0x11, %r11d
leaq 0xc(%rsp), %r15
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movl $0x1, %r9d
pushq %r11
pushq %r11
pushq 0x168(%rbx)
pushq %rax
pushq %r10
callq 0x475f4
addq $0x30, %rsp
movl (%r15), %r15d
movl %r15d, %eax
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_option_text_align
NK_API nk_bool
nk_option_text_align(struct nk_context *ctx, const char *text, int len, nk_bool is_active, nk_flags widget_alignment, nk_flags text_alignment)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    struct nk_rect bounds;
    enum nk_widget_layout_states state;

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

    win = ctx->current;
    style = &ctx->style;
    layout = win->layout;

    state = nk_widget(&bounds, ctx);
    if (!state) return (int)state;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &is_active,
        text, len, NK_TOGGLE_OPTION, &style->option, in, style->font, widget_alignment, text_alignment);
    return is_active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movl %ecx, 0x4(%rsp)
testq %rdi, %rdi
jne 0x4869a
movq 0x3e97b(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x2871d(%rip), %rsi     # 0x70d9c
leaq 0x28734(%rip), %rdx     # 0x70dba
movl $0x61fc, %ecx           # imm = 0x61FC
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movq 0x4780(%r14), %rbx
testq %rbx, %rbx
jne 0x486d9
movq 0x3e943(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x286e5(%rip), %rsi     # 0x70d9c
leaq 0x286fc(%rip), %rdx     # 0x70dba
movl $0x61fd, %ecx           # imm = 0x61FD
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movq 0x4780(%r14), %rbx
cmpq $0x0, 0xa8(%rbx)
jne 0x4871f
movq 0x3e906(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x286a8(%rip), %rsi     # 0x70d9c
leaq 0x286bf(%rip), %rdx     # 0x70dba
movl $0x61fe, %ecx           # imm = 0x61FE
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movq 0x4780(%r14), %rbx
testq %rbx, %rbx
je 0x487ac
movq %r15, 0x8(%rsp)
movq 0xa8(%rbx), %r15
testq %r15, %r15
je 0x487ac
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %r13d
testl %eax, %eax
je 0x487ac
xorl %eax, %eax
cmpl $0x1, %r13d
jne 0x48755
testb $0x10, 0x5(%r15)
cmoveq %r14, %rax
leaq 0x2598(%r14), %rdi
addq $0x68, %rbx
leaq 0x458(%r14), %r10
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subq $0x8, %rsp
leaq 0xc(%rsp), %r13
movq %rbx, %rsi
movq %r13, %rdx
movq 0x18(%rsp), %rcx
movl %r12d, %r8d
movl $0x1, %r9d
pushq %rbp
pushq 0x18(%rsp)
pushq 0x168(%r14)
pushq %rax
pushq %r10
callq 0x475f4
addq $0x30, %rsp
movl (%r13), %r13d
movl %r13d, %eax
addq $0x28, %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_radio_text
NK_API nk_bool
nk_radio_text(struct nk_context *ctx, const char *text, int len, nk_bool *active)
{
    int old_value;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_value = *active;
    *active = nk_option_text(ctx, text, len, old_value);
    return old_value != *active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x48807
movq 0x3e810(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x285b1(%rip), %rsi     # 0x70d9c
leaq 0x285c8(%rip), %rdx     # 0x70dba
movl $0x6211, %ecx           # imm = 0x6211
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r14, %r14
jne 0x4883a
movq 0x3e7dd(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x2857e(%rip), %rsi     # 0x70d9c
leaq 0x28595(%rip), %rdx     # 0x70dba
movl $0x6212, %ecx           # imm = 0x6212
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x48873
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x488a2
movl (%rbx), %r13d
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0x13920
movl %eax, (%rbx)
xorl %r12d, %r12d
cmpl %eax, %r13d
setne %r12b
jmp 0x488a2
movq 0x3e776(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x28518(%rip), %rsi     # 0x70d9c
leaq 0x2852f(%rip), %rdx     # 0x70dba
xorl %r12d, %r12d
movl $0x6213, %ecx           # imm = 0x6213
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %r12d, %eax
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_radio_text_align
NK_API nk_bool
nk_radio_text_align(struct nk_context *ctx, const char *text, int len, nk_bool *active, nk_flags widget_alignment, nk_flags text_alignment)
{
    int old_value;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_value = *active;
    *active = nk_option_text_align(ctx, text, len, old_value, widget_alignment, text_alignment);
    return old_value != *active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
jne 0x48904
movq 0x3e711(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x284b3(%rip), %rsi     # 0x70d9c
leaq 0x284ca(%rip), %rdx     # 0x70dba
movl $0x621d, %ecx           # imm = 0x621D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %r12, %r12
jne 0x48935
movq 0x3e6e0(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x28482(%rip), %rsi     # 0x70d9c
leaq 0x28499(%rip), %rdx     # 0x70dba
movl $0x621e, %ecx           # imm = 0x621E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x48975
movl %ebp, %r9d
testq %r12, %r12
sete %al
testq %r13, %r13
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x489a3
movl (%rbx), %r14d
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
movl 0x4(%rsp), %r8d
callq 0x13980
movl %eax, (%rbx)
xorl %ebp, %ebp
cmpl %eax, %r14d
setne %bpl
jmp 0x489a3
movq 0x3e674(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x28416(%rip), %rsi     # 0x70d9c
leaq 0x2842d(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x621f, %ecx           # imm = 0x621F
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_selectable_text
NK_API nk_bool
nk_selectable_text(struct nk_context *ctx, const char *str, int len,
    nk_flags align, nk_bool *value)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    enum nk_widget_layout_states state;
    struct nk_rect bounds;

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

    win = ctx->current;
    layout = win->layout;
    style = &ctx->style;

    state = nk_widget(&bounds, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    return nk_do_selectable(&ctx->last_widget_state, &win->buffer, bounds,
                str, len, align, value, &style->selectable, in, style->font);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
testq %rdi, %rdi
jne 0x48acf
movq 0x3e546(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x282e8(%rip), %rsi     # 0x70d9c
leaq 0x282ff(%rip), %rdx     # 0x70dba
movl $0x630d, %ecx           # imm = 0x630D
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x48b00
movq 0x3e515(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x282b7(%rip), %rsi     # 0x70d9c
leaq 0x282ce(%rip), %rdx     # 0x70dba
movl $0x630e, %ecx           # imm = 0x630E
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
testq %r13, %r13
jne 0x48b3f
movq 0x3e4dd(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2827f(%rip), %rsi     # 0x70d9c
leaq 0x28296(%rip), %rdx     # 0x70dba
movl $0x630f, %ecx           # imm = 0x630F
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
cmpq $0x0, 0xa8(%r13)
jne 0x48b83
movq 0x3e4a0(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x28242(%rip), %rsi     # 0x70d9c
leaq 0x28259(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x6310, %ecx           # imm = 0x6310
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
testq %r13, %r13
je 0x48c02
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x48c02
movq 0xa8(%r13), %r15
testq %r15, %r15
je 0x48c02
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %ebp
testl %eax, %eax
je 0x48c02
xorl %eax, %eax
cmpl $0x1, %ebp
jne 0x48bb9
testb $0x10, 0x5(%r15)
cmoveq %r14, %rax
leaq 0x2598(%r14), %rdi
addq $0x68, %r13
leaq 0x698(%r14), %r10
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subq $0x8, %rsp
movq %r13, %rsi
movq %r12, %rdx
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %r8d
movq %rbx, %r9
pushq 0x168(%r14)
pushq %rax
pushq %r10
callq 0x48c13
addq $0x20, %rsp
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_selectable_image_text
NK_API nk_bool
nk_selectable_image_text(struct nk_context *ctx, struct nk_image img,
    const char *str, int len, nk_flags align, nk_bool *value)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    enum nk_widget_layout_states state;
    struct nk_rect bounds;

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

    win = ctx->current;
    layout = win->layout;
    style = &ctx->style;

    state = nk_widget(&bounds, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    return nk_do_selectable_image(&ctx->last_widget_state, &win->buffer, bounds,
                str, len, align, value, &img, &style->selectable, in, style->font);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
testq %rdi, %rdi
jne 0x48f12
movq 0x3e103(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x27ea5(%rip), %rsi     # 0x70d9c
leaq 0x27ebc(%rip), %rdx     # 0x70dba
movl $0x632a, %ecx           # imm = 0x632A
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x48f43
movq 0x3e0d2(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x27e74(%rip), %rsi     # 0x70d9c
leaq 0x27e8b(%rip), %rdx     # 0x70dba
movl $0x632b, %ecx           # imm = 0x632B
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
testq %r13, %r13
jne 0x48f82
movq 0x3e09a(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x27e3c(%rip), %rsi     # 0x70d9c
leaq 0x27e53(%rip), %rdx     # 0x70dba
movl $0x632c, %ecx           # imm = 0x632C
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
cmpq $0x0, 0xa8(%r13)
jne 0x48fca
movq 0x3e05d(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x27dff(%rip), %rsi     # 0x70d9c
leaq 0x27e16(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x632d, %ecx           # imm = 0x632D
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
testq %r13, %r13
je 0x4904c
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x4904c
movq 0xa8(%r13), %r15
testq %r15, %r15
je 0x4904c
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %ebp
testl %eax, %eax
je 0x4904c
leaq 0x50(%rsp), %rax
xorl %r10d, %r10d
cmpl $0x1, %ebp
jne 0x49006
testb $0x10, 0x5(%r15)
cmoveq %r14, %r10
leaq 0x2598(%r14), %rdi
addq $0x68, %r13
leaq 0x698(%r14), %r11
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r13, %rsi
movq %r12, %rdx
movl (%rsp), %ecx
movl 0x4(%rsp), %r8d
movq %rbx, %r9
pushq 0x168(%r14)
pushq %r10
pushq %r11
pushq %rax
callq 0x4905d
addq $0x20, %rsp
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_delete_selection
NK_API void
nk_textedit_delete_selection(struct nk_text_edit *state)
{
    /* delete the section */
    nk_textedit_clamp(state);
    if (NK_TEXT_HAS_SELECTION(state)) {
        if (state->select_start < state->select_end) {
            nk_textedit_delete(state, state->select_start,
                state->select_end - state->select_start);
            state->select_end = state->cursor = state->select_start;
        } else {
            nk_textedit_delete(state, state->select_end,
                state->select_start - state->select_end);
            state->select_start = state->cursor = state->select_end;
        }
        state->has_preferred_x = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4ac86
movl 0xac(%rbx), %esi
movl 0xb0(%rbx), %edx
movl %esi, %eax
subl %edx, %eax
je 0x4ac84
jge 0x4ac5f
subl %esi, %edx
movq %rbx, %rdi
callq 0x12360
movl 0xac(%rbx), %eax
movl %eax, 0xb0(%rbx)
jmp 0x4ac77
movq %rbx, %rdi
movl %edx, %esi
movl %eax, %edx
callq 0x12360
movl 0xb0(%rbx), %eax
movl %eax, 0xac(%rbx)
movl %eax, 0xa8(%rbx)
movb $0x0, 0xb7(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_clamp
NK_INTERN void
nk_textedit_clamp(struct nk_text_edit *state)
{
    /* make the selection/cursor state valid if client altered the string */
    int n = state->string.len;
    if (NK_TEXT_HAS_SELECTION(state)) {
        if (state->select_start > n) state->select_start = n;
        if (state->select_end   > n) state->select_end = n;
        /* if clamping forced them to be equal, move the cursor to match */
        if (state->select_start == state->select_end)
            state->cursor = state->select_start;
    }
    if (state->cursor > n) state->cursor = n;
}

// Assembly:
movl 0x90(%rdi), %eax
movl 0xac(%rdi), %ecx
movl 0xb0(%rdi), %edx
cmpl %edx, %ecx
je 0x4acbe
cmpl %eax, %ecx
jle 0x4aca8
movl %eax, 0xac(%rdi)
movl %eax, %ecx
cmpl %eax, %edx
jle 0x4acb4
movl %eax, 0xb0(%rdi)
movl %eax, %edx
cmpl %edx, %ecx
jne 0x4acbe
movl %ecx, 0xa8(%rdi)
cmpl %eax, 0xa8(%rdi)
jle 0x4accc
movl %eax, 0xa8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_cut
NK_API nk_bool
nk_textedit_cut(struct nk_text_edit *state)
{
    /* API cut: delete selection */
    if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
        return 0;
    if (NK_TEXT_HAS_SELECTION(state)) {
        nk_textedit_delete_selection(state); /* implicitly clamps */
        state->has_preferred_x = 0;
        return 1;
    }
   return 0;
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0xb4(%rdi)
je 0x4acff
pushq %rbx
movq %rdi, %rbx
movl 0xac(%rdi), %ecx
cmpl 0xb0(%rdi), %ecx
je 0x4acfe
movq %rbx, %rdi
callq 0x13e30
movb $0x0, 0xb7(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_paste
NK_API nk_bool
nk_textedit_paste(struct nk_text_edit *state, char const *ctext, int len)
{
    /* API paste: replace existing selection with passed-in text */
    int glyphs;
    const char *text = (const char *) ctext;
    if (state->mode == NK_TEXT_EDIT_MODE_VIEW) return 0;

    /* if there's a selection, the paste should delete it */
    nk_textedit_clamp(state);
    nk_textedit_delete_selection(state);

    /* try to insert the characters */
    glyphs = nk_utf_len(ctext, len);
    if (nk_str_insert_text_char(&state->string, state->cursor, text, len)) {
        nk_textedit_makeundo_insert(state, state->cursor, glyphs);
        state->cursor += len;
        state->has_preferred_x = 0;
        return 1;
    }
    /* remove the undo since we didn't actually insert the characters */
    if (state->undo.undo_point)
        --state->undo.undo_point;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
cmpb $0x0, 0xb4(%rdi)
je 0x4ad91
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4ac86
movq %rbx, %rdi
callq 0x13e30
movq %r15, %rdi
movl %r14d, %esi
callq 0x12730
movl %eax, %r12d
leaq 0x18(%rbx), %rdi
movl 0xa8(%rbx), %esi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x139a0
testl %eax, %eax
je 0x4ad7c
movl 0xa8(%rbx), %esi
leaq 0xc0(%rbx), %rdi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x58016
addl %r14d, 0xa8(%rbx)
movb $0x0, 0xb7(%rbx)
movl $0x1, %ebp
jmp 0x4ad91
movzwl 0x1500(%rbx), %eax
testw %ax, %ax
je 0x4ad91
decl %eax
movw %ax, 0x1500(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_init_fixed
NK_API void
nk_textedit_init_fixed(struct nk_text_edit *state, void *memory, nk_size size)
{
    NK_ASSERT(state);
    NK_ASSERT(memory);
    if (!state || !memory || !size) return;
    NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
    nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
    nk_str_init_fixed(&state->string, memory, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4b49f
movq 0x3bb78(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x25919(%rip), %rsi     # 0x70d9c
leaq 0x25930(%rip), %rdx     # 0x70dba
movl $0x6a3f, %ecx           # imm = 0x6A3F
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
je 0x4b4f9
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x4b58f
movq %rbx, %r12
andq $0x3, %r12
je 0x4b533
movl $0x4, %r13d
subq %r12, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
leaq (%rbx,%r13), %rdi
movl $0x1504, %edx           # imm = 0x1504
xorl %esi, %esi
callq 0x12b50
leaq (%rbx,%r13), %rdi
addq $0x1504, %rdi           # imm = 0x1504
xorl %esi, %esi
movq %r12, %rdx
jmp 0x4b53d
movq 0x3baf0(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x25892(%rip), %rsi     # 0x70d9c
leaq 0x258a9(%rip), %rdx     # 0x70dba
movl $0x6a40, %ecx           # imm = 0x6A40
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movl $0x1500, %edx           # imm = 0x1500
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12b50
movabsq $0x3e7000000630000, %rax # imm = 0x3E7000000630000
movq %rax, 0x1500(%rbx)
movaps 0x222d6(%rip), %xmm0    # 0x6d830
movups %xmm0, 0xa8(%rbx)
xorl %ebp, %ebp
movl %ebp, 0xbc(%rbx)
movb $0x1, 0xb8(%rbx)
leaq 0x18(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x12680
movl %ebp, 0x90(%rbx)
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_textedit_init
NK_API void
nk_textedit_init(struct nk_text_edit *state, struct nk_allocator *alloc, nk_size size)
{
    NK_ASSERT(state);
    NK_ASSERT(alloc);
    if (!state || !alloc) return;
    NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
    nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
    nk_str_init(&state->string, alloc, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x4b605
testq %rbx, %rbx
je 0x4b63a
movq %rdx, %r15
movq %rdi, %r14
movq %rdi, %r12
andq $0x3, %r12
je 0x4b674
movl $0x4, %r13d
subq %r12, %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
leaq (%r14,%r13), %rdi
movl $0x1504, %edx           # imm = 0x1504
xorl %esi, %esi
callq 0x12b50
leaq (%r14,%r13), %rdi
addq $0x1504, %rdi           # imm = 0x1504
xorl %esi, %esi
movq %r12, %rdx
jmp 0x4b67e
movq 0x3b9e4(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x25786(%rip), %rsi     # 0x70d9c
leaq 0x2579d(%rip), %rdx     # 0x70dba
movl $0x6a49, %ecx           # imm = 0x6A49
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x4b6d5
movq 0x3b9af(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x25751(%rip), %rsi     # 0x70d9c
leaq 0x25768(%rip), %rdx     # 0x70dba
movl $0x6a4a, %ecx           # imm = 0x6A4A
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movl $0x1500, %edx           # imm = 0x1500
movq %r14, %rdi
xorl %esi, %esi
callq 0x12b50
movabsq $0x3e7000000630000, %rax # imm = 0x3E7000000630000
movq %rax, 0x1500(%r14)
movaps 0x22195(%rip), %xmm0    # 0x6d830
movups %xmm0, 0xa8(%r14)
xorl %ebp, %ebp
movl %ebp, 0xbc(%r14)
movb $0x1, 0xb8(%r14)
leaq 0x18(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%r14)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x12d60
movl %ebp, 0x90(%r14)
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_textedit_init_default
NK_API void
nk_textedit_init_default(struct nk_text_edit *state)
{
    NK_ASSERT(state);
    if (!state) return;
    NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
    nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
    nk_str_init_default(&state->string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x4b737
movq %rdi, %rbx
movq %rdi, %r14
andq $0x3, %r14
je 0x4b76d
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
leaq (%rbx,%r15), %rdi
movl $0x1504, %edx           # imm = 0x1504
xorl %esi, %esi
callq 0x12b50
leaq (%rbx,%r15), %rdi
addq $0x1504, %rdi           # imm = 0x1504
xorl %esi, %esi
movq %r14, %rdx
jmp 0x4b777
movq 0x3b8b2(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x25654(%rip), %rsi     # 0x70d9c
leaq 0x2566b(%rip), %rdx     # 0x70dba
movl $0x6a54, %ecx           # imm = 0x6A54
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movl $0x1500, %edx           # imm = 0x1500
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12b50
movabsq $0x3e7000000630000, %rax # imm = 0x3E7000000630000
movq %rax, 0x1500(%rbx)
movaps 0x2209c(%rip), %xmm0    # 0x6d830
movups %xmm0, 0xa8(%rbx)
xorl %ebp, %ebp
movl %ebp, 0xbc(%rbx)
movb $0x1, 0xb8(%rbx)
leaq 0x18(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq -0x26534(%rip), %rax    # 0x25295
movq %rax, 0x8(%rsi)
leaq -0x26537(%rip), %rax    # 0x2529d
movq %rax, 0x10(%rsi)
movl $0x20, %edx
callq 0x12d60
movl %ebp, 0x90(%rbx)
addq $0x18, %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_edit_focus
NK_API void
nk_edit_focus(struct nk_context *ctx, nk_flags flags)
{
    nk_hash hash;
    struct nk_window *win;

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

    win = ctx->current;
    hash = win->edit.seq;
    win->edit.active = nk_true;
    win->edit.name = hash;
    if (flags & NK_EDIT_ALWAYS_INSERT_MODE)
        win->edit.mode = NK_TEXT_EDIT_MODE_INSERT;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x4b956
movq 0x3b6bf(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x25461(%rip), %rsi     # 0x70d9c
leaq 0x25478(%rip), %rdx     # 0x70dba
movl $0x6d11, %ecx           # imm = 0x6D11
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
testq %rax, %rax
jne 0x4b99a
movq 0x3b687(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x25429(%rip), %rsi     # 0x70d9c
leaq 0x25440(%rip), %rdx     # 0x70dba
movl $0x6d12, %ecx           # imm = 0x6D12
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
testq %rax, %rax
je 0x4b9bd
movl 0x184(%rax), %ecx
movl $0x1, 0x18c(%rax)
movl %ecx, 0x180(%rax)
btl $0x9, %ebx
jae 0x4b9bd
movb $0x1, 0x1a8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_edit_unfocus
NK_API void
nk_edit_unfocus(struct nk_context *ctx)
{
    struct nk_window *win;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return;

    win = ctx->current;
    win->edit.active = nk_false;
    win->edit.name = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4b9fb
movq 0x3b61a(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x253bc(%rip), %rsi     # 0x70d9c
leaq 0x253d3(%rip), %rdx     # 0x70dba
movl $0x6d20, %ecx           # imm = 0x6D20
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x4ba3f
movq 0x3b5e2(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x25384(%rip), %rsi     # 0x70d9c
leaq 0x2539b(%rip), %rdx     # 0x70dba
movl $0x6d21, %ecx           # imm = 0x6D21
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x4ba4d
xorl %ecx, %ecx
movl %ecx, 0x18c(%rax)
movl %ecx, 0x180(%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_property_int
NK_API void
nk_property_int(struct nk_context *ctx, const char *name,
    int min, int *val, int max, int step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);
    NK_ASSERT(val);

    if (!ctx || !ctx->current || !name || !val) return;
    variant = nk_property_variant_int(*val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT);
    *val = variant.value.i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
movl %r8d, %r15d
movq %rcx, %rbx
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r12
testq %rdi, %rdi
jne 0x4d9f5
movq 0x39622(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x233c3(%rip), %rsi     # 0x70d9c
leaq 0x233da(%rip), %rdx     # 0x70dba
movl $0x6f54, %ecx           # imm = 0x6F54
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r14, %r14
jne 0x4da28
movq 0x395ef(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x23390(%rip), %rsi     # 0x70d9c
leaq 0x233a7(%rip), %rdx     # 0x70dba
movl $0x6f55, %ecx           # imm = 0x6F55
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x4da5b
movq 0x395bc(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x2335d(%rip), %rsi     # 0x70d9c
leaq 0x23374(%rip), %rdx     # 0x70dba
movl $0x6f56, %ecx           # imm = 0x6F56
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r12, %r12
je 0x4dab0
testq %rbx, %rbx
je 0x4dab0
testq %r14, %r14
je 0x4dab0
cmpq $0x0, 0x4780(%r12)
je 0x4dab0
movl (%rbx), %eax
leaq 0x10(%rsp), %rbp
movl $0x0, (%rbp)
movl %eax, 0x8(%rbp)
movl %r13d, 0x10(%rbp)
movl %r15d, 0x18(%rbp)
movl 0x8(%rsp), %eax
movl %eax, 0x20(%rbp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movss 0xc(%rsp), %xmm0
xorl %ecx, %ecx
callq 0x4dabf
movl 0x8(%rbp), %eax
movl %eax, (%rbx)
addq $0x38, %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_property_float
NK_API void
nk_property_float(struct nk_context *ctx, const char *name,
    float min, float *val, float max, float step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);
    NK_ASSERT(val);

    if (!ctx || !ctx->current || !name || !val) return;
    variant = nk_property_variant_float(*val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    *val = variant.value.f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movq %rdx, %rbx
movss %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x4ee62
movq 0x381b5(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x21f56(%rip), %rsi     # 0x70d9c
leaq 0x21f6d(%rip), %rdx     # 0x70dba
movl $0x6f62, %ecx           # imm = 0x6F62
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r14, %r14
jne 0x4ee95
movq 0x38182(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x21f23(%rip), %rsi     # 0x70d9c
leaq 0x21f3a(%rip), %rdx     # 0x70dba
movl $0x6f63, %ecx           # imm = 0x6F63
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x4eec8
movq 0x3814f(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x21ef0(%rip), %rsi     # 0x70d9c
leaq 0x21f07(%rip), %rdx     # 0x70dba
movl $0x6f64, %ecx           # imm = 0x6F64
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
je 0x4ef43
testq %rbx, %rbx
je 0x4ef43
testq %r14, %r14
je 0x4ef43
cmpq $0x0, 0x4780(%r15)
je 0x4ef43
movss (%rbx), %xmm0
leaq 0x10(%rsp), %r12
movl $0x1, (%r12)
movss %xmm0, 0x8(%r12)
movss (%rsp), %xmm0
movss %xmm0, 0x10(%r12)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x20(%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movss 0xc(%rsp), %xmm0
movl $0x1, %ecx
callq 0x4dabf
movss 0x8(%r12), %xmm0
movss %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_double
NK_API void
nk_property_double(struct nk_context *ctx, const char *name,
    double min, double *val, double max, double step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);
    NK_ASSERT(val);

    if (!ctx || !ctx->current || !name || !val) return;
    variant = nk_property_variant_double(*val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    *val = variant.value.d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movss %xmm3, 0x4(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rdx, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x4efae
movq 0x38069(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x21e0a(%rip), %rsi     # 0x70d9c
leaq 0x21e21(%rip), %rdx     # 0x70dba
movl $0x6f70, %ecx           # imm = 0x6F70
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r14, %r14
jne 0x4efe1
movq 0x38036(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x21dd7(%rip), %rsi     # 0x70d9c
leaq 0x21dee(%rip), %rdx     # 0x70dba
movl $0x6f71, %ecx           # imm = 0x6F71
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x4f014
movq 0x38003(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x21da4(%rip), %rsi     # 0x70d9c
leaq 0x21dbb(%rip), %rdx     # 0x70dba
movl $0x6f72, %ecx           # imm = 0x6F72
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
je 0x4f090
testq %rbx, %rbx
je 0x4f090
testq %r14, %r14
je 0x4f090
cmpq $0x0, 0x4780(%r15)
je 0x4f090
movsd (%rbx), %xmm0
leaq 0x20(%rsp), %r12
movl $0x2, (%r12)
movsd %xmm0, 0x8(%r12)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%r12)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%r12)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movss 0x4(%rsp), %xmm0
movl $0x1, %ecx
callq 0x4dabf
movsd 0x8(%r12), %xmm0
movsd %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_propertyi
NK_API int
nk_propertyi(struct nk_context *ctx, const char *name, int min, int val,
    int max, int step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);

    if (!ctx || !ctx->current || !name) return val;
    variant = nk_property_variant_int(val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT);
    val = variant.value.i;
    return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
movl %r8d, %r15d
movl %ecx, %ebx
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r12
testq %rdi, %rdi
jne 0x4f0f6
movq 0x37f21(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x21cc2(%rip), %rsi     # 0x70d9c
leaq 0x21cd9(%rip), %rdx     # 0x70dba
movl $0x6f7e, %ecx           # imm = 0x6F7E
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r14, %r14
jne 0x4f129
movq 0x37eee(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x21c8f(%rip), %rsi     # 0x70d9c
leaq 0x21ca6(%rip), %rdx     # 0x70dba
movl $0x6f7f, %ecx           # imm = 0x6F7F
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r12, %r12
je 0x4f175
testq %r14, %r14
je 0x4f175
cmpq $0x0, 0x4780(%r12)
je 0x4f175
leaq 0x10(%rsp), %rbp
movl $0x0, (%rbp)
movl %ebx, 0x8(%rbp)
movl %r13d, 0x10(%rbp)
movl %r15d, 0x18(%rbp)
movl 0x8(%rsp), %eax
movl %eax, 0x20(%rbp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movss 0xc(%rsp), %xmm0
xorl %ecx, %ecx
callq 0x4dabf
movl 0x8(%rbp), %ebx
movl %ebx, %eax
addq $0x38, %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_propertyf
NK_API float
nk_propertyf(struct nk_context *ctx, const char *name, float min,
    float val, float max, float step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);

    if (!ctx || !ctx->current || !name) return val;
    variant = nk_property_variant_float(val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    val = variant.value.f;
    return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movss %xmm4, 0x14(%rsp)
movss %xmm3, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x4f1ea
movq 0x37e37(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x21bd9(%rip), %rsi     # 0x70d9c
leaq 0x21bf0(%rip), %rdx     # 0x70dba
movl $0x6f8c, %ecx           # imm = 0x6F8C
xorl %eax, %eax
movss %xmm1, 0x4(%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movss 0x4(%rsp), %xmm1
testq %rbx, %rbx
jne 0x4f227
movq 0x37dfa(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x21b9c(%rip), %rsi     # 0x70d9c
leaq 0x21bb3(%rip), %rdx     # 0x70dba
movl $0x6f8d, %ecx           # imm = 0x6F8D
xorl %eax, %eax
movss %xmm1, 0x4(%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movss 0x4(%rsp), %xmm1
testq %r14, %r14
je 0x4f290
testq %rbx, %rbx
je 0x4f290
cmpq $0x0, 0x4780(%r14)
je 0x4f290
leaq 0x18(%rsp), %r15
movl $0x1, (%r15)
movss %xmm1, 0x8(%r15)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x10(%r15)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r15)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movss 0x14(%rsp), %xmm0
movl $0x1, %ecx
callq 0x4dabf
movss 0x8(%r15), %xmm1
movaps %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_propertyd
NK_API double
nk_propertyd(struct nk_context *ctx, const char *name, double min,
    double val, double max, double step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);

    if (!ctx || !ctx->current || !name) return val;
    variant = nk_property_variant_double(val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    val = variant.value.d;
    return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movss %xmm4, 0xc(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x4f2ff
movq 0x37d20(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x21ac2(%rip), %rsi     # 0x70d9c
leaq 0x21ad9(%rip), %rdx     # 0x70dba
movl $0x6f9a, %ecx           # imm = 0x6F9A
xorl %eax, %eax
movsd %xmm1, (%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movsd (%rsp), %xmm1
testq %rbx, %rbx
jne 0x4f33a
movq 0x37ce5(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x21a87(%rip), %rsi     # 0x70d9c
leaq 0x21a9e(%rip), %rdx     # 0x70dba
movl $0x6f9b, %ecx           # imm = 0x6F9B
xorl %eax, %eax
movsd %xmm1, (%rsp)
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movsd (%rsp), %xmm1
testq %r14, %r14
je 0x4f3a3
testq %rbx, %rbx
je 0x4f3a3
cmpq $0x0, 0x4780(%r14)
je 0x4f3a3
leaq 0x28(%rsp), %r15
movl $0x2, (%r15)
movsd %xmm1, 0x8(%r15)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%r15)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%r15)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movss 0xc(%rsp), %xmm0
movl $0x1, %ecx
callq 0x4dabf
movsd 0x8(%r15), %xmm1
movaps %xmm1, %xmm0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_chart_end
NK_API void
nk_chart_end(struct nk_context *ctx)
{
    struct nk_window *win;
    struct nk_chart *chart;

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

    win = ctx->current;
    chart = &win->layout->chart;
    NK_MEMSET(chart, 0, sizeof(*chart));
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x500ce
movq 0x36f47(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x20ce9(%rip), %rsi     # 0x70d9c
leaq 0x20d00(%rip), %rdx     # 0x70dba
movl $0x70b7, %ecx           # imm = 0x70B7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x50112
movq 0x36f0f(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x20cb1(%rip), %rsi     # 0x70d9c
leaq 0x20cc8(%rip), %rdx     # 0x70dba
movl $0x70b8, %ecx           # imm = 0x70B8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x50173
movl $0xf8, %ebx
addq 0xa8(%rax), %rbx
movq %rbx, %r14
andq $0x3, %r14
je 0x5015f
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
leaq (%rbx,%r15), %rdi
movl $0xc0, %edx
xorl %esi, %esi
callq 0x12b50
leaq (%rbx,%r15), %rdi
addq $0xc0, %rdi
xorl %esi, %esi
movq %r14, %rdx
jmp 0x50169
movl $0xc4, %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x12b50
popq %rbx
popq %r14
popq %r15
retq