LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %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
cmpq $0x0, 0x4780(%r14)
jne 0x4028f
movq 0x47d88(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x31b19(%rip), %rsi     # 0x71d8c
leaq 0x31b30(%rip), %rdx     # 0x71daa
movl $0x53e7, %ecx           # imm = 0x53E7
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x402ce
movq 0x47d49(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x31ada(%rip), %rsi     # 0x71d8c
leaq 0x31af1(%rip), %rdx     # 0x71daa
movl $0x53e8, %ecx           # imm = 0x53E8
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x40372
cmpq $0x0, 0xa8(%rax)
je 0x40372
movq 0x120(%rbx), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x40312
cmpl %ebp, 0x158(%rbx)
jne 0x40312
cmpl $0x40, 0x128(%rbx)
sete %cl
jmp 0x40314
xorl %ecx, %ecx
testq %rax, %rax
sete %al
testl %r15d, %r15d
sete %dl
testb %al, %dl
jne 0x40372
orb %cl, %al
testb $0x1, %al
je 0x40372
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 0x3e7a8
testl %eax, %eax
je 0x40372
movl $0x40, 0x128(%rbx)
movl %ebp, 0x158(%rbx)
movl $0x1, %r12d
movl %r12d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movaps %xmm0, 0x30(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x40400
movq 0x47c15(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x319a7(%rip), %rsi     # 0x71d8c
leaq 0x319be(%rip), %rdx     # 0x71daa
movl $0x5425, %ecx           # imm = 0x5425
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r14)
jne 0x40436
movq 0x47bdf(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x31971(%rip), %rsi     # 0x71d8c
leaq 0x31988(%rip), %rdx     # 0x71daa
movl $0x5426, %ecx           # imm = 0x5426
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x40473
movq 0x47ba2(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x31934(%rip), %rsi     # 0x71d8c
leaq 0x3194b(%rip), %rdx     # 0x71daa
movl $0x5427, %ecx           # imm = 0x5427
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
xorl %eax, %eax
testq %r14, %r14
je 0x40529
movq 0x4780(%r14), %r15
testq %r15, %r15
je 0x40529
cmpq $0x0, 0xa8(%r15)
je 0x40529
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
testl %eax, %eax
je 0x40529
leaq 0x60(%rsp), %rdx
cmpl $0x1, %eax
jne 0x404cb
movq 0xa8(%r15), %rax
xorl %r8d, %r8d
testb $0x10, 0x5(%rax)
cmoveq %r14, %r8
jmp 0x404ce
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(%rdx), %rax
movq %rax, 0x10(%rsp)
movups (%rdx), %xmm2
movups %xmm2, (%rsp)
xorl %edx, %edx
callq 0x40533
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 0x40218
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x38, %rsp
movaps %xmm0, 0x20(%rsp)
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x4075c
movq 0x478b9(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x3164b(%rip), %rsi     # 0x71d8c
leaq 0x31662(%rip), %rdx     # 0x71daa
movl $0x543e, %ecx           # imm = 0x543E
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r14)
jne 0x40792
movq 0x47883(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x31615(%rip), %rsi     # 0x71d8c
leaq 0x3162c(%rip), %rdx     # 0x71daa
movl $0x543f, %ecx           # imm = 0x543F
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x407cf
movq 0x47846(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x315d8(%rip), %rsi     # 0x71d8c
leaq 0x315ef(%rip), %rdx     # 0x71daa
movl $0x5440, %ecx           # imm = 0x5440
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
xorl %eax, %eax
testq %r14, %r14
je 0x4087d
movq 0x4780(%r14), %r15
testq %r15, %r15
je 0x4087d
cmpq $0x0, 0xa8(%r15)
je 0x4087d
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
testl %eax, %eax
je 0x4087d
cmpl $0x1, %eax
jne 0x40822
movq 0xa8(%r15), %rax
xorl %r9d, %r9d
testb $0x10, 0x5(%rax)
cmoveq %r14, %r9
jmp 0x40825
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 0x40888
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 0x40218
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x408f0
movq 0x47727(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x314b8(%rip), %rsi     # 0x71d8c
leaq 0x314cf(%rip), %rdx     # 0x71daa
movl $0x5eb9, %ecx           # imm = 0x5EB9
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0xa0(%rsp), %r12
testq %rbx, %rbx
jne 0x4092b
movq 0x476ec(%rip), %rbp     # 0x87ff0
movq (%rbp), %rdi
leaq 0x3147d(%rip), %rsi     # 0x71d8c
leaq 0x31494(%rip), %rdx     # 0x71daa
movl $0x5eba, %ecx           # imm = 0x5EBA
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r12, %r12
jne 0x4095e
movq 0x476b9(%rip), %rbp     # 0x87ff0
movq (%rbp), %rdi
leaq 0x3144a(%rip), %rsi     # 0x71d8c
leaq 0x31461(%rip), %rdx     # 0x71daa
movl $0x5ebb, %ecx           # imm = 0x5EBB
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
testq %r14, %r14
jne 0x40991
movq 0x47686(%rip), %rbp     # 0x87ff0
movq (%rbp), %rdi
leaq 0x31417(%rip), %rsi     # 0x71d8c
leaq 0x3142e(%rip), %rdx     # 0x71daa
movl $0x5ebc, %ecx           # imm = 0x5EBC
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
xorl %ebp, %ebp
testq %r15, %r15
je 0x40a27
testq %r14, %r14
je 0x40a27
testq %rbx, %rbx
je 0x40a27
testq %r12, %r12
je 0x40a27
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 0x4761a
movl %eax, %ebp
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x409ee
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 0x522f0
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0x40a27
movq 0xc0(%rbx), %rsi
movq %r14, %rdi
callq *%rax
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_O1/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 %r12
pushq %rbx
subq $0x50, %rsp
movaps %xmm0, 0x40(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x40a87
movq 0x47590(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x31321(%rip), %rsi     # 0x71d8c
leaq 0x31338(%rip), %rdx     # 0x71daa
movl $0x5457, %ecx           # imm = 0x5457
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r14)
jne 0x40abf
movq 0x47558(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x312e9(%rip), %rsi     # 0x71d8c
leaq 0x31300(%rip), %rdx     # 0x71daa
movl $0x5458, %ecx           # imm = 0x5458
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x40afe
movq 0x47519(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x312aa(%rip), %rsi     # 0x71d8c
leaq 0x312c1(%rip), %rdx     # 0x71daa
movl $0x5459, %ecx           # imm = 0x5459
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
xorl %eax, %eax
testq %r14, %r14
je 0x40bdc
movq 0x4780(%r14), %r12
testq %r12, %r12
je 0x40bdc
cmpq $0x0, 0xa8(%r12)
je 0x40bdc
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x128e0
testl %eax, %eax
je 0x40bdc
leaq 0x80(%rsp), %rcx
cmpl $0x1, %eax
jne 0x40b5e
movq 0xa8(%r12), %rdx
xorl %eax, %eax
testb $0x10, 0x5(%rdx)
cmoveq %r14, %rax
jmp 0x40b60
xorl %eax, %eax
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(%rcx), %r9
movq %r9, 0x10(%rsp)
movups (%rcx), %xmm2
movups %xmm2, (%rsp)
movq %rax, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3f331
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 0x40218
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movaps %xmm0, 0x10(%rsp)
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x40c76
movq 0x473a1(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x31132(%rip), %rsi     # 0x71d8c
leaq 0x31149(%rip), %rdx     # 0x71daa
movl $0x5477, %ecx           # imm = 0x5477
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r14)
jne 0x40cae
movq 0x47369(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x310fa(%rip), %rsi     # 0x71d8c
leaq 0x31111(%rip), %rdx     # 0x71daa
movl $0x5478, %ecx           # imm = 0x5478
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x40ced
movq 0x4732a(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x310bb(%rip), %rsi     # 0x71d8c
leaq 0x310d2(%rip), %rdx     # 0x71daa
movl $0x5479, %ecx           # imm = 0x5479
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
xorl %eax, %eax
testq %r14, %r14
je 0x40da2
movq 0x4780(%r14), %r13
testq %r13, %r13
je 0x40da2
cmpq $0x0, 0xa8(%r13)
je 0x40da2
movq %rsp, %rdi
movq %r14, %rsi
callq 0x128e0
testl %eax, %eax
je 0x40da2
cmpl $0x1, %eax
jne 0x40d3d
movq 0xa8(%r13), %rcx
xorl %eax, %eax
testb $0x10, 0x5(%rcx)
cmoveq %r14, %rax
jmp 0x40d3f
xorl %eax, %eax
leaq 0x2598(%r14), %rdi
leaq 0x68(%r13), %rsi
leaq 0x380(%r14), %r10
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl %r12d, %edx
movq %rbx, %rcx
movl %r15d, %r8d
movl %ebp, %r9d
pushq %rax
pushq 0x168(%r14)
pushq %r10
pushq $0x0
callq 0x3f85e
addq $0x20, %rsp
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movaps 0x10(%rsp), %xmm2
callq 0x40218
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x40ecf
movq 0x47146(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30ed8(%rip), %rsi     # 0x71d8c
leaq 0x30eef(%rip), %rdx     # 0x71daa
movl $0x54c6, %ecx           # imm = 0x54C6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x40f05
movq 0x47110(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30ea2(%rip), %rsi     # 0x71d8c
leaq 0x30eb9(%rip), %rdx     # 0x71daa
movl $0x54c7, %ecx           # imm = 0x54C7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x40f42
movq 0x470d3(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30e65(%rip), %rsi     # 0x71d8c
leaq 0x30e7c(%rip), %rdx     # 0x71daa
movl $0x54c8, %ecx           # imm = 0x54C8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x40f6a
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x40f6a
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x40f6a
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x7c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x40fb5
movq 0x47068(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30dfa(%rip), %rsi     # 0x71d8c
leaq 0x30e11(%rip), %rdx     # 0x71daa
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 0x40ff6
jp 0x40ff6
movq 0x4702a(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30dbc(%rip), %rsi     # 0x71d8c
leaq 0x30dd3(%rip), %rdx     # 0x71daa
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 0x41044
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41044
cmpq $0x0, 0xa8(%rax)
je 0x41044
divss 0x4c(%rax), %xmm0
movss 0x2d896(%rip), %xmm2    # 0x6e8b4
ucomiss %xmm0, %xmm2
setbe %al
ucomiss %xmm0, %xmm1
seta %cl
ja 0x4102f
movaps %xmm2, %xmm1
orb %al, %cl
je 0x41041
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_O1/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 0x410a6
movq 0x46f71(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x30d02(%rip), %rsi     # 0x71d8c
leaq 0x30d19(%rip), %rdx     # 0x71daa
movl $0x552e, %ecx           # imm = 0x552E
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r15)
jne 0x410de
movq 0x46f39(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x30cca(%rip), %rsi     # 0x71d8c
leaq 0x30ce1(%rip), %rdx     # 0x71daa
movl $0x552f, %ecx           # imm = 0x552F
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
movq 0x4780(%r15), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x4111d
movq 0x46efa(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x30c8b(%rip), %rsi     # 0x71d8c
leaq 0x30ca2(%rip), %rdx     # 0x71daa
movl $0x5530, %ecx           # imm = 0x5530
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
je 0x41181
movq 0x4780(%r15), %r12
testq %r12, %r12
je 0x41181
cmpq $0x0, 0xa8(%r12)
je 0x41181
movq %r15, %rdi
movq %r12, %rsi
movss 0xc(%rsp), %xmm0
movl %r14d, %edx
callq 0x412be
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_O1/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 0x411df
movq 0x46e36(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x30bc8(%rip), %rsi     # 0x71d8c
leaq 0x30bdf(%rip), %rdx     # 0x71daa
movl $0x555a, %ecx           # imm = 0x555A
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r14)
jne 0x41215
movq 0x46e00(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x30b92(%rip), %rsi     # 0x71d8c
leaq 0x30ba9(%rip), %rdx     # 0x71daa
movl $0x555b, %ecx           # imm = 0x555B
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x41252
movq 0x46dc3(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x30b55(%rip), %rsi     # 0x71d8c
leaq 0x30b6c(%rip), %rdx     # 0x71daa
movl $0x555c, %ecx           # imm = 0x555C
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
je 0x412b3
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
je 0x412b3
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x412b3
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %ebx, %edx
callq 0x412be
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_O1/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 0x41527
movq 0x46aee(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30880(%rip), %rsi     # 0x71d8c
leaq 0x30897(%rip), %rdx     # 0x71daa
movl $0x5573, %ecx           # imm = 0x5573
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x4155d
movq 0x46ab8(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3084a(%rip), %rsi     # 0x71d8c
leaq 0x30861(%rip), %rdx     # 0x71daa
movl $0x5574, %ecx           # imm = 0x5574
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x4159a
movq 0x46a7b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3080d(%rip), %rsi     # 0x71d8c
leaq 0x30824(%rip), %rdx     # 0x71daa
movl $0x5575, %ecx           # imm = 0x5575
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x4164b
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x4164b
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x4164b
movl 0x70(%rbx), %eax
orl $0x4, %eax
cmpl $0x5, %eax
je 0x415fa
movq 0x46a1b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x307ad(%rip), %rsi     # 0x71d8c
leaq 0x307c4(%rip), %rdx     # 0x71daa
movl $0x557b, %ecx           # imm = 0x557B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl 0x70(%rbx), %eax
cmpl $0x5, %eax
je 0x4163d
cmpl $0x1, %eax
jne 0x4164b
movss 0x9c(%rbx), %xmm0
movaps %xmm0, %xmm1
addss 0x4(%rsp), %xmm1
ucomiss 0x2d295(%rip), %xmm1    # 0x6e8b4
ja 0x4164b
xorps %xmm1, %xmm1
movss 0x4(%rsp), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x41653
movss 0x2d27d(%rip), %xmm0    # 0x6e8b4
minss %xmm2, %xmm0
jmp 0x41643
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movss 0x2d259(%rip), %xmm1    # 0x6e8b4
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
jmp 0x41643
// File: /workspace/github_c_makefile_star2_O1/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 0x4169c
movq 0x46979(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3070b(%rip), %rsi     # 0x71d8c
leaq 0x30722(%rip), %rdx     # 0x71daa
movl $0x558d, %ecx           # imm = 0x558D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x416d2
movq 0x46943(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x306d5(%rip), %rsi     # 0x71d8c
leaq 0x306ec(%rip), %rdx     # 0x71daa
movl $0x558e, %ecx           # imm = 0x558E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x4170f
movq 0x46906(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30698(%rip), %rsi     # 0x71d8c
leaq 0x306af(%rip), %rdx     # 0x71daa
movl $0x558f, %ecx           # imm = 0x558F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x4177c
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x4177c
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x4177c
movl 0x70(%rbx), %eax
orl $0x4, %eax
cmpl $0x5, %eax
je 0x41763
movq 0x468b2(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30644(%rip), %rsi     # 0x71d8c
leaq 0x3065b(%rip), %rdx     # 0x71daa
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 0x4177c
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_O1/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 0x4198a
movq 0x4668b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3041d(%rip), %rsi     # 0x71d8c
leaq 0x30434(%rip), %rdx     # 0x71daa
movl $0x55c8, %ecx           # imm = 0x55C8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x419c0
movq 0x46655(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x303e7(%rip), %rsi     # 0x71d8c
leaq 0x303fe(%rip), %rdx     # 0x71daa
movl $0x55c9, %ecx           # imm = 0x55C9
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x419fd
movq 0x46618(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x303aa(%rip), %rsi     # 0x71d8c
leaq 0x303c1(%rip), %rdx     # 0x71daa
movl $0x55ca, %ecx           # imm = 0x55CA
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x41a5e
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
je 0x41a5e
movq 0xa8(%rsi), %r14
testq %r14, %r14
je 0x41a5e
movq %rbx, %rdi
movss 0x4(%rsp), %xmm0
movl $0x1, %edx
callq 0x412be
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
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_row_template_push_dynamic
NK_API void
nk_layout_row_template_push_dynamic(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_TEMPLATE);
    NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
    if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
    if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
    layout->row.templates[layout->row.columns++] = -1.0f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41a9e
movq 0x46577(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30309(%rip), %rsi     # 0x71d8c
leaq 0x30320(%rip), %rdx     # 0x71daa
movl $0x55e3, %ecx           # imm = 0x55E3
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x41ad4
movq 0x46541(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x302d3(%rip), %rsi     # 0x71d8c
leaq 0x302ea(%rip), %rdx     # 0x71daa
movl $0x55e4, %ecx           # imm = 0x55E4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x41b11
movq 0x46504(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30296(%rip), %rsi     # 0x71d8c
leaq 0x302ad(%rip), %rdx     # 0x71daa
movl $0x55e5, %ecx           # imm = 0x55E5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x41bc8
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41bc8
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x41bc8
cmpl $0x8, 0x70(%rbx)
je 0x41b6c
movq 0x464a9(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3023b(%rip), %rsi     # 0x71d8c
leaq 0x30252(%rip), %rdx     # 0x71daa
movl $0x55eb, %ecx           # imm = 0x55EB
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x10, 0x80(%rbx)
jl 0x41ba1
movq 0x46474(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30206(%rip), %rsi     # 0x71d8c
leaq 0x3021d(%rip), %rdx     # 0x71daa
movl $0x55ec, %ecx           # imm = 0x55EC
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x8, 0x70(%rbx)
jne 0x41bc8
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x41bc8
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rbx)
movl $0xbf800000, 0xb4(%rbx,%rax,4) # imm = 0xBF800000
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_row_template_push_variable
NK_API void
nk_layout_row_template_push_variable(struct nk_context *ctx, float min_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_TEMPLATE);
    NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
    if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
    if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
    layout->row.templates[layout->row.columns++] = -min_width;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, (%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41c0f
movq 0x46406(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30198(%rip), %rsi     # 0x71d8c
leaq 0x301af(%rip), %rdx     # 0x71daa
movl $0x55f7, %ecx           # imm = 0x55F7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x41c45
movq 0x463d0(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30162(%rip), %rsi     # 0x71d8c
leaq 0x30179(%rip), %rdx     # 0x71daa
movl $0x55f8, %ecx           # imm = 0x55F8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x41c82
movq 0x46393(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30125(%rip), %rsi     # 0x71d8c
leaq 0x3013c(%rip), %rdx     # 0x71daa
movl $0x55f9, %ecx           # imm = 0x55F9
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x41d42
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41d42
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x41d42
cmpl $0x8, 0x70(%rbx)
je 0x41cdd
movq 0x46338(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x300ca(%rip), %rsi     # 0x71d8c
leaq 0x300e1(%rip), %rdx     # 0x71daa
movl $0x55ff, %ecx           # imm = 0x55FF
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x10, 0x80(%rbx)
jl 0x41d12
movq 0x46303(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x30095(%rip), %rsi     # 0x71d8c
leaq 0x300ac(%rip), %rdx     # 0x71daa
movl $0x5600, %ecx           # imm = 0x5600
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x8, 0x70(%rbx)
jne 0x41d42
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x41d42
movaps (%rsp), %xmm0
xorps 0x2c840(%rip), %xmm0    # 0x6e570
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rbx)
movss %xmm0, 0xb4(%rbx,%rax,4)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_row_template_push_static
NK_API void
nk_layout_row_template_push_static(struct nk_context *ctx, float 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_TEMPLATE);
    NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
    if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
    if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
    layout->row.templates[layout->row.columns++] = width;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41d88
movq 0x4628d(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3001f(%rip), %rsi     # 0x71d8c
leaq 0x30036(%rip), %rdx     # 0x71daa
movl $0x560b, %ecx           # imm = 0x560B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x41dbe
movq 0x46257(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2ffe9(%rip), %rsi     # 0x71d8c
leaq 0x30000(%rip), %rdx     # 0x71daa
movl $0x560c, %ecx           # imm = 0x560C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x41dfb
movq 0x4621a(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2ffac(%rip), %rsi     # 0x71d8c
leaq 0x2ffc3(%rip), %rdx     # 0x71daa
movl $0x560d, %ecx           # imm = 0x560D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x41eb6
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41eb6
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x41eb6
cmpl $0x8, 0x70(%rbx)
je 0x41e56
movq 0x461bf(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2ff51(%rip), %rsi     # 0x71d8c
leaq 0x2ff68(%rip), %rdx     # 0x71daa
movl $0x5613, %ecx           # imm = 0x5613
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x10, 0x80(%rbx)
jl 0x41e8b
movq 0x4618a(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2ff1c(%rip), %rsi     # 0x71d8c
leaq 0x2ff33(%rip), %rdx     # 0x71daa
movl $0x5614, %ecx           # imm = 0x5614
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x8, 0x70(%rbx)
jne 0x41eb6
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x41eb6
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rbx)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0xb4(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_space_begin
NK_API void
nk_layout_space_begin(struct nk_context *ctx, enum nk_layout_format fmt,
    float height, int widget_count)
{
    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, widget_count);
    if (fmt == NK_STATIC)
        layout->row.type = NK_LAYOUT_STATIC_FREE;
    else layout->row.type = NK_LAYOUT_DYNAMIC_FREE;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movss %xmm0, 0x4(%rsp)
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x4214c
movq 0x45ec9(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x2fc5b(%rip), %rsi     # 0x71d8c
leaq 0x2fc72(%rip), %rdx     # 0x71daa
movl $0x5653, %ecx           # imm = 0x5653
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r14)
jne 0x42182
movq 0x45e93(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x2fc25(%rip), %rsi     # 0x71d8c
leaq 0x2fc3c(%rip), %rdx     # 0x71daa
movl $0x5654, %ecx           # imm = 0x5654
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x421bf
movq 0x45e56(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x2fbe8(%rip), %rsi     # 0x71d8c
leaq 0x2fbff(%rip), %rdx     # 0x71daa
movl $0x5655, %ecx           # imm = 0x5655
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
testq %r14, %r14
je 0x4221a
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
je 0x4221a
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x4221a
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %ebp, %edx
callq 0x412be
xorl %eax, %eax
cmpl $0x1, %ebx
sete %al
leal 0x2(,%rax,4), %eax
movl %eax, 0x70(%r15)
xorl %eax, %eax
movq %rax, 0x88(%r15)
movl $0x0, 0x90(%r15)
movq %rax, 0x98(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_space_end
NK_API void
nk_layout_space_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;
    layout->row.item_width = 0;
    layout->row.item_height = 0;
    layout->row.item_offset = 0;
    nk_zero(&layout->row.item, sizeof(layout->row.item));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4225e
movq 0x45db7(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2fb49(%rip), %rsi     # 0x71d8c
leaq 0x2fb60(%rip), %rdx     # 0x71daa
movl $0x566b, %ecx           # imm = 0x566B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x42294
movq 0x45d81(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2fb13(%rip), %rsi     # 0x71d8c
leaq 0x2fb2a(%rip), %rdx     # 0x71daa
movl $0x566c, %ecx           # imm = 0x566C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x422d1
movq 0x45d44(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2fad6(%rip), %rsi     # 0x71d8c
leaq 0x2faed(%rip), %rdx     # 0x71daa
movl $0x566d, %ecx           # imm = 0x566D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x4236f
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x4236f
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x4236f
movq $0x0, 0x90(%rbx)
movl $0x0, 0x98(%rbx)
addq $0xa0, %rbx
movq %rbx, %r14
andq $0x3, %r14
je 0x4233a
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
orq $0xc, %r14
addq %r15, %rbx
jmp 0x42340
movl $0x10, %r14d
movl %r14d, %r15d
andl $-0x4, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
andq $0x3, %r14
je 0x4236f
addq %r15, %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12b50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_space_push
NK_API void
nk_layout_space_push(struct nk_context *ctx, struct nk_rect rect)
{
    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.item = rect;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x423b9
movq 0x45c5c(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2f9ee(%rip), %rsi     # 0x71d8c
leaq 0x2fa05(%rip), %rdx     # 0x71daa
movl $0x567e, %ecx           # imm = 0x567E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x423ef
movq 0x45c26(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2f9b8(%rip), %rsi     # 0x71d8c
leaq 0x2f9cf(%rip), %rdx     # 0x71daa
movl $0x567f, %ecx           # imm = 0x567F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x4242c
movq 0x45be9(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2f97b(%rip), %rsi     # 0x71d8c
leaq 0x2f992(%rip), %rdx     # 0x71daa
movl $0x5680, %ecx           # imm = 0x5680
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x4245a
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x4245a
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x4245a
movaps (%rsp), %xmm0
unpcklpd 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movups %xmm0, 0xa0(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_space_bounds
NK_API struct nk_rect
nk_layout_space_bounds(struct nk_context *ctx)
{
    struct nk_rect ret;
    struct nk_window *win;
    struct nk_panel *layout;

    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    win = ctx->current;
    layout = win->layout;

    ret.x = layout->clip.x;
    ret.y = layout->clip.y;
    ret.w = layout->clip.w;
    ret.h = layout->row.height;
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4249a
movq 0x45b7b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2f90d(%rip), %rsi     # 0x71d8c
leaq 0x2f924(%rip), %rdx     # 0x71daa
movl $0x568f, %ecx           # imm = 0x568F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x424d0
movq 0x45b45(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2f8d7(%rip), %rsi     # 0x71d8c
leaq 0x2f8ee(%rip), %rdx     # 0x71daa
movl $0x5690, %ecx           # imm = 0x5690
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x4250d
movq 0x45b08(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x2f89a(%rip), %rsi     # 0x71d8c
leaq 0x2f8b1(%rip), %rdx     # 0x71daa
movl $0x5691, %ecx           # imm = 0x5691
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm0
movss 0x78(%rax), %xmm2
movss 0x4c(%rax), %xmm1
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
addq $0x8, %rsp
popq %rbx
popq %r14
retq