LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_contextual_item_symbol_text
NK_API nk_bool
nk_contextual_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbol,
    const char *text, int len, nk_flags align)
{
    struct nk_window *win;
    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 0;

    win = ctx->current;
    style = &ctx->style;
    state = nk_widget_fitting(&bounds, ctx, style->contextual_button.padding);
    if (!state) return nk_false;

    in = (state == NK_WIDGET_ROM || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds,
        symbol, text, len, align, NK_BUTTON_DEFAULT, &style->contextual_button, style->font, in)) {
        nk_contextual_close(ctx);
        return nk_true;
    }
    return nk_false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3eeaa
movq 0x4816d(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x31f0e(%rip), %rsi     # 0x70d9c
leaq 0x31f25(%rip), %rdx     # 0x70dba
movl $0x5345, %ecx           # imm = 0x5345
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%rbx), %r13
testq %r13, %r13
jne 0x3eeeb
movq 0x48133(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x31ed4(%rip), %rsi     # 0x70d9c
leaq 0x31eeb(%rip), %rdx     # 0x70dba
movl $0x5346, %ecx           # imm = 0x5346
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%rbx), %r13
cmpq $0x0, 0xa8(%r13)
jne 0x3ef35
movq 0x480f4(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x31e95(%rip), %rsi     # 0x70d9c
leaq 0x31eac(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x5347, %ecx           # imm = 0x5347
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%rbx), %r13
testq %r13, %r13
je 0x3efca
cmpq $0x0, 0xa8(%r13)
je 0x3efc8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x12270
movl %eax, %ebp
testl %eax, %eax
je 0x3efca
leaq 0x2a8(%rbx), %rax
cmpl $0x2, %ebp
jne 0x3ef67
xorl %r10d, %r10d
jmp 0x3ef79
movq 0xa8(%r13), %rcx
xorl %r10d, %r10d
testb $0x10, 0x5(%rcx)
cmoveq %rbx, %r10
movl %r14d, %r9d
movl 0x4(%rsp), %r8d
movq %r12, %rcx
movl %r15d, %edx
leaq 0x2598(%rbx), %rdi
addq $0x68, %r13
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r13, %rsi
pushq %r10
pushq 0x168(%rbx)
pushq %rax
pushq $0x0
callq 0x3efdb
addq $0x20, %rsp
testl %eax, %eax
je 0x3efc8
movq %rbx, %rdi
callq 0x134e0
movl $0x1, %ebp
jmp 0x3efca
xorl %ebp, %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_panel_get_padding
NK_LIB struct nk_vec2
nk_panel_get_padding(const struct nk_style *style, enum nk_panel_type type)
{
    switch (type) {
    default:
    case NK_PANEL_WINDOW: return style->window.padding;
    case NK_PANEL_GROUP: return style->window.group_padding;
    case NK_PANEL_POPUP: return style->window.popup_padding;
    case NK_PANEL_CONTEXTUAL: return style->window.contextual_padding;
    case NK_PANEL_COMBO: return style->window.combo_padding;
    case NK_PANEL_MENU: return style->window.menu_padding;
    case NK_PANEL_TOOLTIP: return style->window.menu_padding;}
}

// Assembly:
movl $0x2364, %eax           # imm = 0x2364
cmpl $0x1f, %esi
jg 0x3f4fd
cmpl $0x2, %esi
je 0x3f516
cmpl $0x4, %esi
je 0x3f524
cmpl $0x10, %esi
jne 0x3f529
movl $0x2384, %eax           # imm = 0x2384
jmp 0x3f529
cmpl $0x20, %esi
je 0x3f51d
cmpl $0x40, %esi
je 0x3f50f
cmpl $0x80, %esi
jne 0x3f529
movl $0x238c, %eax           # imm = 0x238C
jmp 0x3f529
movl $0x236c, %eax           # imm = 0x236C
jmp 0x3f529
movl $0x237c, %eax           # imm = 0x237C
jmp 0x3f529
movl $0x2374, %eax           # imm = 0x2374
movsd (%rdi,%rax), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_menubar_begin
NK_API void
nk_menubar_begin(struct nk_context *ctx)
{
    struct nk_panel *layout;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return;

    layout = ctx->current->layout;
    NK_ASSERT(layout->at_y == layout->bounds.y);
    /* if this assert triggers you allocated space between nk_begin and nk_menubar_begin.
    If you want a menubar the first nuklear function after `nk_begin` has to be a
    `nk_menubar_begin` call. Inside the menubar you then have to allocate space for
    widgets (also supports multiple rows).
    Example:
        if (nk_begin(...)) {
            nk_menubar_begin(...);
                nk_layout_xxxx(...);
                nk_button(...);
                nk_layout_xxxx(...);
                nk_button(...);
            nk_menubar_end(...);
        }
        nk_end(...);
    */
    if (layout->flags & NK_WINDOW_HIDDEN || layout->flags & NK_WINDOW_MINIMIZED)
        return;

    layout->menu.x = layout->at_x;
    layout->menu.y = layout->at_y + layout->row.height;
    layout->menu.w = layout->bounds.w;
    layout->menu.offset.x = *layout->offset_x;
    layout->menu.offset.y = *layout->offset_y;
    *layout->offset_y = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3f567
movq 0x47aae(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x31850(%rip), %rsi     # 0x70d9c
leaq 0x31867(%rip), %rdx     # 0x70dba
movl $0x539a, %ecx           # imm = 0x539A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3f5a6
movq 0x47a76(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x31818(%rip), %rsi     # 0x70d9c
leaq 0x3182f(%rip), %rdx     # 0x70dba
movl $0x539b, %ecx           # imm = 0x539B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3f5ec
movq 0x47a39(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x317db(%rip), %rsi     # 0x70d9c
leaq 0x317f2(%rip), %rdx     # 0x70dba
movl $0x539c, %ecx           # imm = 0x539C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3f672
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x3f672
movss 0x2c(%rbx), %xmm0
ucomiss 0xc(%rbx), %xmm0
jne 0x3f605
jnp 0x3f631
movq 0x479e4(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x31786(%rip), %rsi     # 0x70d9c
leaq 0x3179d(%rip), %rdx     # 0x70dba
movl $0x53a1, %ecx           # imm = 0x53A1
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testb $-0x60, 0x5(%rbx)
jne 0x3f672
movss 0x28(%rbx), %xmm0
movss %xmm0, 0x54(%rbx)
movss 0x2c(%rbx), %xmm0
addss 0x78(%rbx), %xmm0
movss %xmm0, 0x58(%rbx)
movss 0x10(%rbx), %xmm0
movss %xmm0, 0x5c(%rbx)
movq 0x18(%rbx), %rax
movl (%rax), %eax
movl %eax, 0x64(%rbx)
movq 0x20(%rbx), %rax
movl (%rax), %ecx
movl %ecx, 0x68(%rbx)
movl $0x0, (%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_menubar_end
NK_API void
nk_menubar_end(struct nk_context *ctx)
{
    struct nk_window *win;
    struct nk_panel *layout;
    struct nk_command_buffer *out;

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

    win = ctx->current;
    out = &win->buffer;
    layout = win->layout;
    if (layout->flags & NK_WINDOW_HIDDEN || layout->flags & NK_WINDOW_MINIMIZED)
        return;

    layout->menu.h  = layout->at_y - layout->menu.y;
    layout->menu.h += layout->row.height + ctx->style.window.spacing.y;

    layout->bounds.y += layout->menu.h;
    layout->bounds.h -= layout->menu.h;

    *layout->offset_x = layout->menu.offset.x;
    *layout->offset_y = layout->menu.offset.y;
    layout->at_y      = layout->bounds.y - layout->row.height;

    layout->clip.y = layout->bounds.y;
    layout->clip.h = layout->bounds.h;
    nk_push_scissor(out, layout->clip);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3f6b2
movq 0x47963(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x31705(%rip), %rsi     # 0x70d9c
leaq 0x3171c(%rip), %rdx     # 0x70dba
movl $0x53c2, %ecx           # imm = 0x53C2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rdi
testq %rdi, %rdi
jne 0x3f6f1
movq 0x4792b(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x316cd(%rip), %rsi     # 0x70d9c
leaq 0x316e4(%rip), %rdx     # 0x70dba
movl $0x53c3, %ecx           # imm = 0x53C3
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rdi
cmpq $0x0, 0xa8(%rdi)
jne 0x3f733
movq 0x478ee(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x31690(%rip), %rsi     # 0x70d9c
leaq 0x316a7(%rip), %rdx     # 0x70dba
movl $0x53c4, %ecx           # imm = 0x53C4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rdi
testq %rdi, %rdi
je 0x3f745
movq 0xa8(%rdi), %rax
testq %rax, %rax
je 0x3f745
testb $-0x60, 0x5(%rax)
je 0x3f74d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movss 0x2c(%rax), %xmm0
subss 0x58(%rax), %xmm0
addq $0x68, %rdi
movss 0x78(%rax), %xmm1
movss 0x24b8(%rbx), %xmm2
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, 0x60(%rax)
movss 0xc(%rax), %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0xc(%rax)
movss 0x14(%rax), %xmm3
subss %xmm2, %xmm3
movss %xmm3, 0x14(%rax)
movl 0x64(%rax), %ecx
movq 0x18(%rax), %rdx
movl %ecx, (%rdx)
movl 0x68(%rax), %ecx
movq 0x20(%rax), %rdx
movl %ecx, (%rdx)
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x2c(%rax)
movss %xmm0, 0x48(%rax)
movss %xmm3, 0x50(%rax)
movsd 0x44(%rax), %xmm0
movsd 0x4c(%rax), %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13a50
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_menu_begin_text
NK_API nk_bool
nk_menu_begin_text(struct nk_context *ctx, const char *title, int len,
    nk_flags align, struct nk_vec2 size)
{
    struct nk_window *win;
    const struct nk_input *in;
    struct nk_rect header;
    int is_clicked = nk_false;
    nk_flags state;

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

    win = ctx->current;
    state = nk_widget(&header, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || win->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    if (nk_do_button_text(&ctx->last_widget_state, &win->buffer, header,
        title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in, ctx->style.font))
        is_clicked = nk_true;
    return nk_menu_begin(ctx, win, title, is_clicked, header, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movaps %xmm0, 0x10(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3f820
movq 0x477f7(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x31598(%rip), %rsi     # 0x70d9c
leaq 0x315af(%rip), %rdx     # 0x70dba
movl $0x5407, %ecx           # imm = 0x5407
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %r12
testq %r12, %r12
jne 0x3f861
movq 0x477bd(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x3155e(%rip), %rsi     # 0x70d9c
leaq 0x31575(%rip), %rdx     # 0x70dba
movl $0x5408, %ecx           # imm = 0x5408
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %r12
cmpq $0x0, 0xa8(%r12)
jne 0x3f8ad
movq 0x4777d(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x3151e(%rip), %rsi     # 0x70d9c
leaq 0x31535(%rip), %rdx     # 0x70dba
xorl %r13d, %r13d
movl $0x5409, %ecx           # imm = 0x5409
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %r12
testq %r12, %r12
je 0x3f952
cmpq $0x0, 0xa8(%r12)
je 0x3f94f
movq %rsp, %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %r13d
testl %eax, %eax
je 0x3f952
xorl %eax, %eax
cmpl $0x1, %r13d
jne 0x3f8e4
testb $0x10, 0x49(%r12)
cmoveq %r14, %rax
leaq 0x2598(%r14), %rdi
leaq 0x68(%r12), %rsi
leaq 0x380(%r14), %r10
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
subq $0x8, %rsp
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq 0x168(%r14)
pushq %rax
pushq %r10
callq 0x3e5cb
addq $0x20, %rsp
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movaps 0x10(%rsp), %xmm2
callq 0x3f964
movl %eax, %r13d
jmp 0x3f952
xorl %r13d, %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_menu_begin
NK_INTERN int
nk_menu_begin(struct nk_context *ctx, struct nk_window *win,
    const char *id, int is_clicked, struct nk_rect header, struct nk_vec2 size)
{
    int is_open = 0;
    int is_active = 0;
    struct nk_rect body;
    struct nk_window *popup;
    nk_hash hash = nk_murmur_hash(id, (int)nk_strlen(id), NK_PANEL_MENU);

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

    body.x = header.x;
    body.w = size.x;
    body.y = header.y + header.h;
    body.h = size.y;

    popup = win->popup.win;
    is_open = popup ? nk_true : nk_false;
    is_active = (popup && (win->popup.name == hash) && win->popup.type == NK_PANEL_MENU);
    if ((is_clicked && is_open && !is_active) || (is_open && !is_active) ||
        (!is_open && !is_active && !is_clicked)) return 0;
    if (!nk_nonblock_begin(ctx, NK_WINDOW_NO_SCROLLBAR, body, header, NK_PANEL_MENU))
        return 0;

    win->popup.type = NK_PANEL_MENU;
    win->popup.name = hash;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps %xmm2, 0x10(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, (%rsp)
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x12f10
movq %r12, %rdi
movl %eax, %esi
movl $0x40, %edx
callq 0x12560
movl %eax, %ebp
movq 0x4780(%r14), %rax
testq %rax, %rax
jne 0x3f9e6
movq 0x47638(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x313d9(%rip), %rsi     # 0x70d9c
leaq 0x313f0(%rip), %rdx     # 0x70dba
movl $0x53e7, %ecx           # imm = 0x53E7
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3fa31
movq 0x475f9(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x3139a(%rip), %rsi     # 0x70d9c
leaq 0x313b1(%rip), %rdx     # 0x70dba
xorl %r12d, %r12d
movl $0x53e8, %ecx           # imm = 0x53E8
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
testq %rax, %rax
je 0x3fac7
cmpq $0x0, 0xa8(%rax)
je 0x3fac4
movq 0x120(%rbx), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x3fa62
cmpl %ebp, 0x158(%rbx)
jne 0x3fa62
cmpl $0x40, 0x128(%rbx)
sete %cl
jmp 0x3fa64
xorl %ecx, %ecx
testq %rax, %rax
sete %al
testl %r15d, %r15d
sete %dl
testb %al, %dl
jne 0x3fac7
orb %cl, %al
testb $0x1, %al
je 0x3fac7
movaps (%rsp), %xmm2
movaps %xmm2, %xmm0
movaps 0x20(%rsp), %xmm3
addps %xmm3, %xmm0
shufps $0x1, %xmm2, %xmm0      # xmm0 = xmm0[1,0],xmm2[0,0]
shufps $0xe2, %xmm2, %xmm0     # xmm0 = xmm0[2,0],xmm2[2,3]
movq %r14, %rdi
movl $0x20, %esi
movaps 0x10(%rsp), %xmm1
movl $0x40, %edx
callq 0x3df48
testl %eax, %eax
je 0x3fac7
movl $0x40, 0x128(%rbx)
movl %ebp, 0x158(%rbx)
movl $0x1, %r12d
jmp 0x3fac7
xorl %r12d, %r12d
movl %r12d, %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_menu_begin_image
NK_API nk_bool
nk_menu_begin_image(struct nk_context *ctx, const char *id, struct nk_image img,
    struct nk_vec2 size)
{
    struct nk_window *win;
    struct nk_rect header;
    const struct nk_input *in;
    int is_clicked = nk_false;
    nk_flags state;

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

    win = ctx->current;
    state = nk_widget(&header, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    if (nk_do_button_image(&ctx->last_widget_state, &win->buffer, header,
        img, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in))
        is_clicked = nk_true;
    return nk_menu_begin(ctx, win, id, is_clicked, header, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movaps %xmm0, 0x30(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3fb58
movq 0x474bd(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x3125f(%rip), %rsi     # 0x70d9c
leaq 0x31276(%rip), %rdx     # 0x70dba
movl $0x5425, %ecx           # imm = 0x5425
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r15
testq %r15, %r15
jne 0x3fb97
movq 0x47485(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x31227(%rip), %rsi     # 0x70d9c
leaq 0x3123e(%rip), %rdx     # 0x70dba
movl $0x5426, %ecx           # imm = 0x5426
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r15
cmpq $0x0, 0xa8(%r15)
jne 0x3fbdf
movq 0x47448(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x311ea(%rip), %rsi     # 0x70d9c
leaq 0x31201(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x5427, %ecx           # imm = 0x5427
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r15
testq %r15, %r15
je 0x3fc82
cmpq $0x0, 0xa8(%r15)
je 0x3fc1e
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %ebp
testl %eax, %eax
je 0x3fc82
leaq 0x70(%rsp), %rax
cmpl $0x1, %ebp
jne 0x3fc22
movq 0xa8(%r15), %rcx
xorl %r8d, %r8d
testb $0x10, 0x5(%rcx)
cmoveq %r14, %r8
jmp 0x3fc25
xorl %ebp, %ebp
jmp 0x3fc82
xorl %r8d, %r8d
leaq 0x2598(%r14), %rdi
leaq 0x68(%r15), %rsi
leaq 0x380(%r14), %rcx
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax), %xmm2
movups %xmm2, (%rsp)
xorl %edx, %edx
callq 0x3fc8f
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movaps 0x30(%rsp), %xmm2
callq 0x3f964
movl %eax, %ebp
movl %ebp, %eax
addq $0x48, %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_menu_begin_symbol
NK_API nk_bool
nk_menu_begin_symbol(struct nk_context *ctx, const char *id,
    enum nk_symbol_type sym, struct nk_vec2 size)
{
    struct nk_window *win;
    const struct nk_input *in;
    struct nk_rect header;
    int is_clicked = nk_false;
    nk_flags state;

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

    win = ctx->current;
    state = nk_widget(&header, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    if (nk_do_button_symbol(&ctx->last_widget_state,  &win->buffer, header,
        sym, NK_BUTTON_DEFAULT, &ctx->style.menu_button, in, ctx->style.font))
        is_clicked = nk_true;
    return nk_menu_begin(ctx, win, id, is_clicked, header, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movaps %xmm0, 0x20(%rsp)
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3feb0
movq 0x47165(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x30f07(%rip), %rsi     # 0x70d9c
leaq 0x30f1e(%rip), %rdx     # 0x70dba
movl $0x543e, %ecx           # imm = 0x543E
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r15
testq %r15, %r15
jne 0x3feef
movq 0x4712d(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x30ecf(%rip), %rsi     # 0x70d9c
leaq 0x30ee6(%rip), %rdx     # 0x70dba
movl $0x543f, %ecx           # imm = 0x543F
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r15
cmpq $0x0, 0xa8(%r15)
jne 0x3ff38
movq 0x470f0(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x30e92(%rip), %rsi     # 0x70d9c
leaq 0x30ea9(%rip), %rdx     # 0x70dba
xorl %r12d, %r12d
movl $0x5440, %ecx           # imm = 0x5440
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %r15
testq %r15, %r15
je 0x3ffd3
cmpq $0x0, 0xa8(%r15)
je 0x3ff70
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %r12d
testl %eax, %eax
je 0x3ffd3
cmpl $0x1, %r12d
jne 0x3ff75
movq 0xa8(%r15), %rax
xorl %r9d, %r9d
testb $0x10, 0x5(%rax)
cmoveq %r14, %r9
jmp 0x3ff78
xorl %r12d, %r12d
jmp 0x3ffd3
xorl %r9d, %r9d
leaq 0x2598(%r14), %rdi
leaq 0x68(%r15), %rsi
leaq 0x380(%r14), %r8
movq 0x168(%r14), %rax
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rax, (%rsp)
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x3ffe3
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movaps 0x20(%rsp), %xmm2
callq 0x3f964
movl %eax, %r12d
movl %r12d, %eax
addq $0x30, %rsp
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_do_button_symbol
NK_LIB nk_bool
nk_do_button_symbol(nk_flags *state,
    struct nk_command_buffer *out, struct nk_rect bounds,
    enum nk_symbol_type symbol, enum nk_button_behavior behavior,
    const struct nk_style_button *style, const struct nk_input *in,
    const struct nk_user_font *font)
{
    int ret;
    struct nk_rect content;

    NK_ASSERT(state);
    NK_ASSERT(style);
    NK_ASSERT(font);
    NK_ASSERT(out);
    if (!out || !style || !font || !state)
        return nk_false;

    ret = nk_do_button(state, out, bounds, style, in, behavior, &content);
    if (style->draw_begin) style->draw_begin(out, style->userdata);
    nk_draw_button_symbol(out, &bounds, &content, *state, style, symbol, font);
    if (style->draw_end) style->draw_end(out, style->userdata);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %rbx
movl %ecx, %r13d
movl %edx, 0x14(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x48(%rsp)
testq %rdi, %rdi
jne 0x4004b
movq 0x46fcc(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x30d6d(%rip), %rsi     # 0x70d9c
leaq 0x30d84(%rip), %rdx     # 0x70dba
movl $0x5eb9, %ecx           # imm = 0x5EB9
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0xa0(%rsp), %r12
testq %rbx, %rbx
jne 0x40086
movq 0x46f91(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x30d32(%rip), %rsi     # 0x70d9c
leaq 0x30d49(%rip), %rdx     # 0x70dba
movl $0x5eba, %ecx           # imm = 0x5EBA
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r12, %r12
jne 0x400b9
movq 0x46f5e(%rip), %rbp     # 0x86ff0
movq (%rbp), %rdi
leaq 0x30cff(%rip), %rsi     # 0x70d9c
leaq 0x30d16(%rip), %rdx     # 0x70dba
movl $0x5ebb, %ecx           # imm = 0x5EBB
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r14, %r14
je 0x40159
xorl %ebp, %ebp
testq %r15, %r15
je 0x40187
testq %rbx, %rbx
je 0x40187
testq %r12, %r12
je 0x40187
leaq 0x58(%rsp), %r9
movq %r15, %rdi
movq %r14, %rsi
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movq %rbx, %rdx
movq 0x18(%rsp), %rcx
movl %r13d, %r8d
callq 0x46a33
movl %eax, %ebp
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x4011e
movq 0xc0(%rbx), %rsi
movq %r14, %rdi
callq *%rax
movl (%r15), %ecx
movq %r12, (%rsp)
leaq 0x48(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %r8
movl 0x14(%rsp), %r9d
callq 0x5173c
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0x40187
movq 0xc0(%rbx), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x40187
movq 0x46e90(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x30c32(%rip), %rsi     # 0x70d9c
leaq 0x30c49(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x5ebc, %ecx           # imm = 0x5EBC
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
addq $0x68, %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_menu_begin_image_text
NK_API nk_bool
nk_menu_begin_image_text(struct nk_context *ctx, const char *title, int len,
    nk_flags align, struct nk_image img, struct nk_vec2 size)
{
    struct nk_window *win;
    struct nk_rect header;
    const struct nk_input *in;
    int is_clicked = nk_false;
    nk_flags state;

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

    win = ctx->current;
    state = nk_widget(&header, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    if (nk_do_button_text_image(&ctx->last_widget_state, &win->buffer,
        header, img, title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button,
        ctx->style.font, in))
        is_clicked = nk_true;
    return nk_menu_begin(ctx, win, title, is_clicked, header, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movaps %xmm0, 0x40(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x401e9
movq 0x46e2e(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x30bcf(%rip), %rsi     # 0x70d9c
leaq 0x30be6(%rip), %rdx     # 0x70dba
movl $0x5457, %ecx           # imm = 0x5457
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %r12
testq %r12, %r12
jne 0x4022a
movq 0x46df4(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x30b95(%rip), %rsi     # 0x70d9c
leaq 0x30bac(%rip), %rdx     # 0x70dba
movl $0x5458, %ecx           # imm = 0x5458
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %r12
cmpq $0x0, 0xa8(%r12)
jne 0x40276
movq 0x46db4(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x30b55(%rip), %rsi     # 0x70d9c
leaq 0x30b6c(%rip), %rdx     # 0x70dba
xorl %r13d, %r13d
movl $0x5459, %ecx           # imm = 0x5459
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %r12
testq %r12, %r12
je 0x40344
cmpq $0x0, 0xa8(%r12)
je 0x402bb
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %r13d
testl %eax, %eax
je 0x40344
leaq 0x90(%rsp), %rax
cmpl $0x1, %r13d
jne 0x402c3
movq 0xa8(%r12), %rdx
xorl %ecx, %ecx
testb $0x10, 0x5(%rdx)
cmoveq %r14, %rcx
jmp 0x402c5
xorl %r13d, %r13d
jmp 0x40344
xorl %ecx, %ecx
leaq 0x2598(%r14), %rdi
leaq 0x68(%r12), %rsi
leaq 0x380(%r14), %rdx
movq 0x168(%r14), %r8
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movq 0x10(%rax), %r9
movq %r9, 0x10(%rsp)
movups (%rax), %xmm2
movups %xmm2, (%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3eae5
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movaps 0x40(%rsp), %xmm2
callq 0x3f964
movl %eax, %r13d
movl %r13d, %eax
addq $0x58, %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_menu_begin_symbol_text
NK_API nk_bool
nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len,
    nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size)
{
    struct nk_window *win;
    struct nk_rect header;
    const struct nk_input *in;
    int is_clicked = nk_false;
    nk_flags state;

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

    win = ctx->current;
    state = nk_widget(&header, ctx);
    if (!state) return 0;

    in = (state == NK_WIDGET_ROM || state == NK_WIDGET_DISABLED || win->layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    if (nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer,
        header, sym, title, len, align, NK_BUTTON_DEFAULT, &ctx->style.menu_button,
        ctx->style.font, in)) is_clicked = nk_true;
    return nk_menu_begin(ctx, win, title, is_clicked, header, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps %xmm0, 0x20(%rsp)
movl %r8d, 0xc(%rsp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x403e6
movq 0x46c31(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x309d2(%rip), %rsi     # 0x70d9c
leaq 0x309e9(%rip), %rdx     # 0x70dba
movl $0x5477, %ecx           # imm = 0x5477
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
testq %r13, %r13
jne 0x40427
movq 0x46bf7(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x30998(%rip), %rsi     # 0x70d9c
leaq 0x309af(%rip), %rdx     # 0x70dba
movl $0x5478, %ecx           # imm = 0x5478
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
cmpq $0x0, 0xa8(%r13)
jne 0x40471
movq 0x46bb8(%rip), %r13     # 0x86ff0
movq (%r13), %rdi
leaq 0x30959(%rip), %rsi     # 0x70d9c
leaq 0x30970(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x5479, %ecx           # imm = 0x5479
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%r14), %r13
testq %r13, %r13
je 0x40518
cmpq $0x0, 0xa8(%r13)
je 0x404aa
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
movl %eax, %ebp
testl %eax, %eax
je 0x40518
cmpl $0x1, %ebp
jne 0x404ae
movq 0xa8(%r13), %rcx
xorl %eax, %eax
testb $0x10, 0x5(%rcx)
cmoveq %r14, %rax
jmp 0x404b0
xorl %ebp, %ebp
jmp 0x40518
xorl %eax, %eax
movl %r15d, %r9d
movl %r12d, %r8d
movl 0xc(%rsp), %edx
leaq 0x2598(%r14), %rdi
leaq 0x68(%r13), %rsi
leaq 0x380(%r14), %r10
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rcx
pushq %rax
pushq 0x168(%r14)
pushq %r10
pushq $0x0
callq 0x3efdb
addq $0x20, %rsp
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movaps 0x20(%rsp), %xmm2
callq 0x3f964
movl %eax, %ebp
movl %ebp, %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_layout_set_min_row_height
NK_API void
nk_layout_set_min_row_height(struct nk_context *ctx, float height)
{
    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 = height;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x40647
movq 0x469ce(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x30770(%rip), %rsi     # 0x70d9c
leaq 0x30787(%rip), %rdx     # 0x70dba
movl $0x54c6, %ecx           # imm = 0x54C6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x40686
movq 0x46996(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x30738(%rip), %rsi     # 0x70d9c
leaq 0x3074f(%rip), %rdx     # 0x70dba
movl $0x54c7, %ecx           # imm = 0x54C7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x406c8
movq 0x46959(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x306fb(%rip), %rsi     # 0x70d9c
leaq 0x30712(%rip), %rdx     # 0x70dba
movl $0x54c8, %ecx           # imm = 0x54C8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x406df
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x406df
movss 0x4(%rsp), %xmm0
movss %xmm0, 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_layout_ratio_from_pixel
NK_API float
nk_layout_ratio_from_pixel(struct nk_context *ctx, float pixel_width)
{
    struct nk_window *win;
    NK_ASSERT(ctx);
    NK_ASSERT(pixel_width);
    if (!ctx || !ctx->current || !ctx->current->layout) return 0;
    win = ctx->current;
    return NK_CLAMP(0.0f, pixel_width/win->bounds.x, 1.0f);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4072a
movq 0x468f3(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x30695(%rip), %rsi     # 0x70d9c
leaq 0x306ac(%rip), %rdx     # 0x70dba
movl $0x5543, %ecx           # imm = 0x5543
xorl %eax, %eax
movaps %xmm0, (%rsp)
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4076b
jp 0x4076b
movq 0x468b5(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x30657(%rip), %rsi     # 0x70d9c
leaq 0x3066e(%rip), %rdx     # 0x70dba
movl $0x5544, %ecx           # imm = 0x5544
xorl %eax, %eax
movaps %xmm0, (%rsp)
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm1, %xmm1
movaps (%rsp), %xmm0
testq %rbx, %rbx
je 0x407b9
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x407b9
cmpq $0x0, 0xa8(%rax)
je 0x407b9
divss 0x4c(%rax), %xmm0
movss 0x2d111(%rip), %xmm2    # 0x6d8a4
ucomiss %xmm0, %xmm2
setbe %al
ucomiss %xmm0, %xmm1
seta %cl
ja 0x407a4
movaps %xmm2, %xmm1
orb %al, %cl
je 0x407b6
cmpltss %xmm2, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_row_layout
NK_LIB void
nk_row_layout(struct nk_context *ctx, enum nk_layout_format fmt,
    float height, int cols, int width)
{
    /* update the current row and set the current row layout */
    struct nk_window *win;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return;

    win = ctx->current;
    nk_panel_layout(ctx, win, height, cols);
    if (fmt == NK_DYNAMIC)
        win->layout->row.type = NK_LAYOUT_DYNAMIC_FIXED;
    else win->layout->row.type = NK_LAYOUT_STATIC_FIXED;

    win->layout->row.ratio = 0;
    win->layout->row.filled = 0;
    win->layout->row.item_offset = 0;
    win->layout->row.item_width = (float)width;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movss %xmm0, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %r15
testq %rdi, %rdi
jne 0x4081b
movq 0x467fc(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x3059d(%rip), %rsi     # 0x70d9c
leaq 0x305b4(%rip), %rdx     # 0x70dba
movl $0x552e, %ecx           # imm = 0x552E
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r15), %r12
testq %r12, %r12
jne 0x4085c
movq 0x467c2(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x30563(%rip), %rsi     # 0x70d9c
leaq 0x3057a(%rip), %rdx     # 0x70dba
movl $0x552f, %ecx           # imm = 0x552F
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r15), %r12
cmpq $0x0, 0xa8(%r12)
jne 0x408a1
movq 0x46782(%rip), %r12     # 0x86ff0
movq (%r12), %rdi
leaq 0x30523(%rip), %rsi     # 0x70d9c
leaq 0x3053a(%rip), %rdx     # 0x70dba
movl $0x5530, %ecx           # imm = 0x5530
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r15), %r12
testq %r12, %r12
je 0x408f4
cmpq $0x0, 0xa8(%r12)
je 0x408f4
movq %r15, %rdi
movq %r12, %rsi
movss 0xc(%rsp), %xmm0
movl %r14d, %edx
callq 0x40a2e
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movq 0xa8(%r12), %rcx
shll $0x2, %eax
movl %eax, 0x70(%rcx)
xorl %eax, %eax
movq %rax, 0x88(%rcx)
movq %rax, 0x98(%rcx)
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
movss %xmm0, 0x90(%rcx)
addq $0x10, %rsp
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_layout_row_begin
NK_API void
nk_layout_row_begin(struct nk_context *ctx, enum nk_layout_format fmt,
    float row_height, int cols)
{
    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;
    nk_panel_layout(ctx, win, row_height, cols);
    if (fmt == NK_DYNAMIC)
        layout->row.type = NK_LAYOUT_DYNAMIC_ROW;
    else layout->row.type = NK_LAYOUT_STATIC_ROW;

    layout->row.ratio = 0;
    layout->row.filled = 0;
    layout->row.item_width = 0;
    layout->row.item_offset = 0;
    layout->row.columns = cols;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movss %xmm0, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %r14
testq %rdi, %rdi
jne 0x40952
movq 0x466c3(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x30465(%rip), %rsi     # 0x70d9c
leaq 0x3047c(%rip), %rdx     # 0x70dba
movl $0x555a, %ecx           # imm = 0x555A
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
jne 0x40991
movq 0x4668b(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x3042d(%rip), %rsi     # 0x70d9c
leaq 0x30444(%rip), %rdx     # 0x70dba
movl $0x555b, %ecx           # imm = 0x555B
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x409d3
movq 0x4664e(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x303f0(%rip), %rsi     # 0x70d9c
leaq 0x30407(%rip), %rdx     # 0x70dba
movl $0x555c, %ecx           # imm = 0x555C
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
je 0x40a23
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x40a23
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %ebx, %edx
callq 0x40a2e
xorl %eax, %eax
testl %ebp, %ebp
setne %al
leal 0x1(,%rax,4), %eax
movl %eax, 0x70(%r15)
xorl %eax, %eax
movq %rax, 0x88(%r15)
movl $0x0, 0x90(%r15)
movq %rax, 0x98(%r15)
movl %ebx, 0x80(%r15)
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_layout_row_push
NK_API void
nk_layout_row_push(struct nk_context *ctx, float ratio_or_width)
{
    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;
    NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW);
    if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW)
        return;

    if (layout->row.type == NK_LAYOUT_DYNAMIC_ROW) {
        float ratio = ratio_or_width;
        if ((ratio + layout->row.filled) > 1.0f) return;
        if (ratio > 0.0f)
            layout->row.item_width = NK_SATURATE(ratio);
        else layout->row.item_width = 1.0f - layout->row.filled;
    } else layout->row.item_width = ratio_or_width;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x40ca1
movq 0x46374(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x30116(%rip), %rsi     # 0x70d9c
leaq 0x3012d(%rip), %rdx     # 0x70dba
movl $0x5573, %ecx           # imm = 0x5573
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x40ce0
movq 0x4633c(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x300de(%rip), %rsi     # 0x70d9c
leaq 0x300f5(%rip), %rdx     # 0x70dba
movl $0x5574, %ecx           # imm = 0x5574
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x40d26
movq 0x462ff(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x300a1(%rip), %rsi     # 0x70d9c
leaq 0x300b8(%rip), %rdx     # 0x70dba
movl $0x5575, %ecx           # imm = 0x5575
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x40dc0
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x40dc0
movl 0x70(%rbx), %eax
movl %eax, %ecx
orl $0x4, %ecx
cmpl $0x5, %ecx
je 0x40d72
movq 0x462a6(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x30048(%rip), %rsi     # 0x70d9c
leaq 0x3005f(%rip), %rdx     # 0x70dba
movl $0x557b, %ecx           # imm = 0x557B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl 0x70(%rbx), %eax
cmpl $0x5, %eax
je 0x40db2
cmpl $0x1, %eax
jne 0x40dc0
movss 0x9c(%rbx), %xmm0
movaps %xmm0, %xmm1
addss 0x4(%rsp), %xmm1
ucomiss 0x2cb10(%rip), %xmm1    # 0x6d8a4
ja 0x40dc0
xorps %xmm1, %xmm1
movss 0x4(%rsp), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x40dc8
movss 0x2caf8(%rip), %xmm0    # 0x6d8a4
minss %xmm2, %xmm0
jmp 0x40db8
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movss 0x2cad4(%rip), %xmm1    # 0x6d8a4
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
jmp 0x40db8
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_row_end
NK_API void
nk_layout_row_end(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;
    NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW);
    if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW)
        return;
    layout->row.item_width = 0;
    layout->row.item_offset = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x40e11
movq 0x46204(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ffa6(%rip), %rsi     # 0x70d9c
leaq 0x2ffbd(%rip), %rdx     # 0x70dba
movl $0x558d, %ecx           # imm = 0x558D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x40e50
movq 0x461cc(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ff6e(%rip), %rsi     # 0x70d9c
leaq 0x2ff85(%rip), %rdx     # 0x70dba
movl $0x558e, %ecx           # imm = 0x558E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x40e92
movq 0x4618f(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ff31(%rip), %rsi     # 0x70d9c
leaq 0x2ff48(%rip), %rdx     # 0x70dba
movl $0x558f, %ecx           # imm = 0x558F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x40ef0
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x40ef0
movl 0x70(%rbx), %eax
movl %eax, %ecx
orl $0x4, %ecx
cmpl $0x5, %ecx
je 0x40eda
movq 0x4613e(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fee0(%rip), %rsi     # 0x70d9c
leaq 0x2fef7(%rip), %rdx     # 0x70dba
movl $0x5595, %ecx           # imm = 0x5595
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl 0x70(%rbx), %eax
orl $0x4, %eax
cmpl $0x5, %eax
jne 0x40ef0
xorl %eax, %eax
movl %eax, 0x90(%rbx)
movl %eax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_row_template_begin
NK_API void
nk_layout_row_template_begin(struct nk_context *ctx, float height)
{
    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;
    nk_panel_layout(ctx, win, height, 1);
    layout->row.type = NK_LAYOUT_TEMPLATE;
    layout->row.columns = 0;
    layout->row.ratio = 0;
    layout->row.item_width = 0;
    layout->row.item_height = 0;
    layout->row.item_offset = 0;
    layout->row.filled = 0;
    layout->row.item.x = 0;
    layout->row.item.y = 0;
    layout->row.item.w = 0;
    layout->row.item.h = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x410e5
movq 0x45f30(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fcd2(%rip), %rsi     # 0x70d9c
leaq 0x2fce9(%rip), %rdx     # 0x70dba
movl $0x55c8, %ecx           # imm = 0x55C8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
jne 0x41124
movq 0x45ef8(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fc9a(%rip), %rsi     # 0x70d9c
leaq 0x2fcb1(%rip), %rdx     # 0x70dba
movl $0x55c9, %ecx           # imm = 0x55C9
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x41166
movq 0x45ebb(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fc5d(%rip), %rsi     # 0x70d9c
leaq 0x2fc74(%rip), %rdx     # 0x70dba
movl $0x55ca, %ecx           # imm = 0x55CA
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
je 0x411b6
movq 0xa8(%rsi), %r14
testq %r14, %r14
je 0x411b6
movq %rbx, %rdi
movss 0x4(%rsp), %xmm0
movl $0x1, %edx
callq 0x40a2e
movl $0x8, 0x70(%r14)
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
movq $0x0, 0xa8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq