LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x411f6
movq 0x45e1f(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fbc1(%rip), %rsi     # 0x70d9c
leaq 0x2fbd8(%rip), %rdx     # 0x70dba
movl $0x55e3, %ecx           # imm = 0x55E3
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41235
movq 0x45de7(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fb89(%rip), %rsi     # 0x70d9c
leaq 0x2fba0(%rip), %rdx     # 0x70dba
movl $0x55e4, %ecx           # imm = 0x55E4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x4127b
movq 0x45daa(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fb4c(%rip), %rsi     # 0x70d9c
leaq 0x2fb63(%rip), %rdx     # 0x70dba
movl $0x55e5, %ecx           # imm = 0x55E5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41319
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x41319
cmpl $0x8, 0x70(%rbx)
je 0x412bd
movq 0x45d58(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fafa(%rip), %rsi     # 0x70d9c
leaq 0x2fb11(%rip), %rdx     # 0x70dba
movl $0x55eb, %ecx           # imm = 0x55EB
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x10, 0x80(%rbx)
jl 0x412f2
movq 0x45d23(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fac5(%rip), %rsi     # 0x70d9c
leaq 0x2fadc(%rip), %rdx     # 0x70dba
movl $0x55ec, %ecx           # imm = 0x55EC
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x8, 0x70(%rbx)
jne 0x41319
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x41319
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_O3/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 0x41360
movq 0x45cb5(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fa57(%rip), %rsi     # 0x70d9c
leaq 0x2fa6e(%rip), %rdx     # 0x70dba
movl $0x55f7, %ecx           # imm = 0x55F7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x4139f
movq 0x45c7d(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2fa1f(%rip), %rsi     # 0x70d9c
leaq 0x2fa36(%rip), %rdx     # 0x70dba
movl $0x55f8, %ecx           # imm = 0x55F8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x413e5
movq 0x45c40(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f9e2(%rip), %rsi     # 0x70d9c
leaq 0x2f9f9(%rip), %rdx     # 0x70dba
movl $0x55f9, %ecx           # imm = 0x55F9
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x4148c
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x4148c
cmpl $0x8, 0x70(%rbx)
je 0x41427
movq 0x45bee(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f990(%rip), %rsi     # 0x70d9c
leaq 0x2f9a7(%rip), %rdx     # 0x70dba
movl $0x55ff, %ecx           # imm = 0x55FF
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x10, 0x80(%rbx)
jl 0x4145c
movq 0x45bb9(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f95b(%rip), %rsi     # 0x70d9c
leaq 0x2f972(%rip), %rdx     # 0x70dba
movl $0x5600, %ecx           # imm = 0x5600
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x8, 0x70(%rbx)
jne 0x4148c
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x4148c
movaps (%rsp), %xmm0
xorps 0x2c0f6(%rip), %xmm0    # 0x6d570
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_O3/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 0x414d2
movq 0x45b43(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f8e5(%rip), %rsi     # 0x70d9c
leaq 0x2f8fc(%rip), %rdx     # 0x70dba
movl $0x560b, %ecx           # imm = 0x560B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41511
movq 0x45b0b(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f8ad(%rip), %rsi     # 0x70d9c
leaq 0x2f8c4(%rip), %rdx     # 0x70dba
movl $0x560c, %ecx           # imm = 0x560C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x41557
movq 0x45ace(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f870(%rip), %rsi     # 0x70d9c
leaq 0x2f887(%rip), %rdx     # 0x70dba
movl $0x560d, %ecx           # imm = 0x560D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x415f9
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x415f9
cmpl $0x8, 0x70(%rbx)
je 0x41599
movq 0x45a7c(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f81e(%rip), %rsi     # 0x70d9c
leaq 0x2f835(%rip), %rdx     # 0x70dba
movl $0x5613, %ecx           # imm = 0x5613
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x10, 0x80(%rbx)
jl 0x415ce
movq 0x45a47(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f7e9(%rip), %rsi     # 0x70d9c
leaq 0x2f800(%rip), %rdx     # 0x70dba
movl $0x5614, %ecx           # imm = 0x5614
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpl $0x8, 0x70(%rbx)
jne 0x415f9
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x415f9
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_O3/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 0x4186d
movq 0x457a8(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2f54a(%rip), %rsi     # 0x70d9c
leaq 0x2f561(%rip), %rdx     # 0x70dba
movl $0x5653, %ecx           # imm = 0x5653
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
jne 0x418ac
movq 0x45770(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2f512(%rip), %rsi     # 0x70d9c
leaq 0x2f529(%rip), %rdx     # 0x70dba
movl $0x5654, %ecx           # imm = 0x5654
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x418ee
movq 0x45733(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2f4d5(%rip), %rsi     # 0x70d9c
leaq 0x2f4ec(%rip), %rdx     # 0x70dba
movl $0x5655, %ecx           # imm = 0x5655
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
je 0x41938
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x41938
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %ebp, %edx
callq 0x40a2e
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_O3/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 0x4197c
movq 0x45699(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f43b(%rip), %rsi     # 0x70d9c
leaq 0x2f452(%rip), %rdx     # 0x70dba
movl $0x566b, %ecx           # imm = 0x566B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x419bb
movq 0x45661(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f403(%rip), %rsi     # 0x70d9c
leaq 0x2f41a(%rip), %rdx     # 0x70dba
movl $0x566c, %ecx           # imm = 0x566C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x419fd
movq 0x45624(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f3c6(%rip), %rsi     # 0x70d9c
leaq 0x2f3dd(%rip), %rdx     # 0x70dba
movl $0x566d, %ecx           # imm = 0x566D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41a70
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x41a70
movq $0x0, 0x90(%rbx)
movl $0x0, 0x98(%rbx)
addq $0xa0, %rbx
movq %rbx, %r14
andq $0x3, %r14
je 0x41a6a
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
leaq (%rbx,%r15), %rdi
addq $0xc, %rdi
movq $0x0, -0xc(%rdi)
movl $0x0, -0x4(%rdi)
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12b50
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x41aba
movq 0x4555b(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f2fd(%rip), %rsi     # 0x70d9c
leaq 0x2f314(%rip), %rdx     # 0x70dba
movl $0x567e, %ecx           # imm = 0x567E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41af9
movq 0x45523(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f2c5(%rip), %rsi     # 0x70d9c
leaq 0x2f2dc(%rip), %rdx     # 0x70dba
movl $0x567f, %ecx           # imm = 0x567F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x41b3b
movq 0x454e6(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f288(%rip), %rsi     # 0x70d9c
leaq 0x2f29f(%rip), %rdx     # 0x70dba
movl $0x5680, %ecx           # imm = 0x5680
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x41b58
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x41b58
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_O3/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 0x41b98
movq 0x4547d(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f21f(%rip), %rsi     # 0x70d9c
leaq 0x2f236(%rip), %rdx     # 0x70dba
movl $0x568f, %ecx           # imm = 0x568F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41bd7
movq 0x45445(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f1e7(%rip), %rsi     # 0x70d9c
leaq 0x2f1fe(%rip), %rdx     # 0x70dba
movl $0x5690, %ecx           # imm = 0x5690
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x41c1d
movq 0x45406(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f1a8(%rip), %rsi     # 0x70d9c
leaq 0x2f1bf(%rip), %rdx     # 0x70dba
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
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_widget_bounds
NK_API struct nk_rect
nk_layout_widget_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->at_x;
    ret.y = layout->at_y;
    ret.w = layout->bounds.w - NK_MAX(layout->at_x - layout->bounds.x,0);
    ret.h = layout->row.height;
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41c6f
movq 0x453a6(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f148(%rip), %rsi     # 0x70d9c
leaq 0x2f15f(%rip), %rdx     # 0x70dba
movl $0x56a2, %ecx           # imm = 0x56A2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41cae
movq 0x4536e(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f110(%rip), %rsi     # 0x70d9c
leaq 0x2f127(%rip), %rdx     # 0x70dba
movl $0x56a3, %ecx           # imm = 0x56A3
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x41cf4
movq 0x4532f(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f0d1(%rip), %rsi     # 0x70d9c
leaq 0x2f0e8(%rip), %rdx     # 0x70dba
movl $0x56a4, %ecx           # imm = 0x56A4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
movsd 0x28(%rax), %xmm0
movss 0x10(%rax), %xmm1
movss 0x8(%rax), %xmm2
movaps %xmm0, %xmm3
subss %xmm2, %xmm3
xorps %xmm2, %xmm2
maxss %xmm3, %xmm2
subss %xmm2, %xmm1
movss 0x78(%rax), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
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_space_to_screen
NK_API struct nk_vec2
nk_layout_space_to_screen(struct nk_context *ctx, struct nk_vec2 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->at_x - (float)*layout->offset_x;
    ret.y += layout->at_y - (float)*layout->offset_y;
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, (%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41d64
movq 0x452b1(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f053(%rip), %rsi     # 0x70d9c
leaq 0x2f06a(%rip), %rdx     # 0x70dba
movl $0x56b4, %ecx           # imm = 0x56B4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41da3
movq 0x45279(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2f01b(%rip), %rsi     # 0x70d9c
leaq 0x2f032(%rip), %rdx     # 0x70dba
movl $0x56b5, %ecx           # imm = 0x56B5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x41de9
movq 0x4523a(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2efdc(%rip), %rsi     # 0x70d9c
leaq 0x2eff3(%rip), %rdx     # 0x70dba
movl $0x56b6, %ecx           # imm = 0x56B6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movss (%rdx), %xmm0
movss (%rcx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x2ba0b(%rip), %xmm0    # 0x6d810
orpd %xmm0, %xmm1
subpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm1
movsd 0x28(%rax), %xmm0
subps %xmm1, %xmm0
addps (%rsp), %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_layout_space_to_local
NK_API struct nk_vec2
nk_layout_space_to_local(struct nk_context *ctx, struct nk_vec2 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->at_x + (float)*layout->offset_x;
    ret.y += -layout->at_y + (float)*layout->offset_y;
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, (%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41e64
movq 0x451b1(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ef53(%rip), %rsi     # 0x70d9c
leaq 0x2ef6a(%rip), %rdx     # 0x70dba
movl $0x56c4, %ecx           # imm = 0x56C4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41ea3
movq 0x45179(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ef1b(%rip), %rsi     # 0x70d9c
leaq 0x2ef32(%rip), %rdx     # 0x70dba
movl $0x56c5, %ecx           # imm = 0x56C5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x41ee9
movq 0x4513a(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2eedc(%rip), %rsi     # 0x70d9c
leaq 0x2eef3(%rip), %rdx     # 0x70dba
movl $0x56c6, %ecx           # imm = 0x56C6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movss (%rdx), %xmm0
movss (%rcx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x2b90b(%rip), %xmm0    # 0x6d810
orpd %xmm0, %xmm1
subpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movsd 0x28(%rax), %xmm1
subps %xmm1, %xmm0
addps (%rsp), %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_layout_space_rect_to_screen
NK_API struct nk_rect
nk_layout_space_rect_to_screen(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->at_x - (float)*layout->offset_x;
    ret.y += layout->at_y - (float)*layout->offset_y;
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x41f69
movq 0x450ac(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ee4e(%rip), %rsi     # 0x70d9c
leaq 0x2ee65(%rip), %rdx     # 0x70dba
movl $0x56d4, %ecx           # imm = 0x56D4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x41fa8
movq 0x45074(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ee16(%rip), %rsi     # 0x70d9c
leaq 0x2ee2d(%rip), %rdx     # 0x70dba
movl $0x56d5, %ecx           # imm = 0x56D5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x41fee
movq 0x45035(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2edd7(%rip), %rsi     # 0x70d9c
leaq 0x2edee(%rip), %rdx     # 0x70dba
movl $0x56d6, %ecx           # imm = 0x56D6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movsd 0x28(%rax), %xmm0
movss (%rdx), %xmm1
movss (%rcx), %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
movapd 0x2b801(%rip), %xmm1    # 0x6d810
orpd %xmm1, %xmm2
subpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm1
subps %xmm1, %xmm0
addps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_space_rect_to_local
NK_API struct nk_rect
nk_layout_space_rect_to_local(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->at_x + (float)*layout->offset_x;
    ret.y += -layout->at_y + (float)*layout->offset_y;
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x42073
movq 0x44fa2(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ed44(%rip), %rsi     # 0x70d9c
leaq 0x2ed5b(%rip), %rdx     # 0x70dba
movl $0x56e4, %ecx           # imm = 0x56E4
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x420b2
movq 0x44f6a(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2ed0c(%rip), %rsi     # 0x70d9c
leaq 0x2ed23(%rip), %rdx     # 0x70dba
movl $0x56e5, %ecx           # imm = 0x56E5
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x420f8
movq 0x44f2b(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2eccd(%rip), %rsi     # 0x70d9c
leaq 0x2ece4(%rip), %rdx     # 0x70dba
movl $0x56e6, %ecx           # imm = 0x56E6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movsd 0x28(%rax), %xmm1
movss (%rdx), %xmm0
movss (%rcx), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
movapd 0x2b6f7(%rip), %xmm0    # 0x6d810
orpd %xmm0, %xmm2
subpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
subps %xmm1, %xmm0
addps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_panel_alloc_space
NK_LIB void
nk_panel_alloc_space(struct nk_rect *bounds, const 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;

    /* check if the end of the row has been hit and begin new row if so */
    win = ctx->current;
    layout = win->layout;
    if (layout->row.index >= layout->row.columns)
        nk_panel_alloc_row(ctx, win);

    /* calculate widget position and size */
    nk_layout_widget_space(bounds, ctx, win, nk_true);
    layout->row.index++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jne 0x4218f
movq 0x44e86(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2ec28(%rip), %rsi     # 0x70d9c
leaq 0x2ec3f(%rip), %rdx     # 0x70dba
movl $0x5783, %ecx           # imm = 0x5783
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
jne 0x421ce
movq 0x44e4e(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2ebf0(%rip), %rsi     # 0x70d9c
leaq 0x2ec07(%rip), %rdx     # 0x70dba
movl $0x5784, %ecx           # imm = 0x5784
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%rbx), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x42210
movq 0x44e11(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2ebb3(%rip), %rsi     # 0x70d9c
leaq 0x2ebca(%rip), %rdx     # 0x70dba
movl $0x5785, %ecx           # imm = 0x5785
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
je 0x42253
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x42253
movl 0x80(%r15), %edx
cmpl %edx, 0x74(%r15)
jl 0x4223f
movss 0x78(%r15), %xmm0
subss 0x24b8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x40a2e
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x577f5
incl 0x74(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_tree_state_pop
NK_API void
nk_tree_state_pop(struct nk_context *ctx)
{
    struct nk_window *win = 0;
    struct nk_panel *layout = 0;

    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->at_x -= ctx->style.tab.indent + (float)*layout->offset_x;
    layout->bounds.w += ctx->style.tab.indent + ctx->style.window.padding.x;
    NK_ASSERT(layout->row.tree_depth);
    layout->row.tree_depth--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4281c
movq 0x447f9(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2e59b(%rip), %rsi     # 0x70d9c
leaq 0x2e5b2(%rip), %rdx     # 0x70dba
movl $0x585a, %ecx           # imm = 0x585A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x4285b
movq 0x447c1(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2e563(%rip), %rsi     # 0x70d9c
leaq 0x2e57a(%rip), %rdx     # 0x70dba
movl $0x585b, %ecx           # imm = 0x585B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x428a1
movq 0x44784(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2e526(%rip), %rsi     # 0x70d9c
leaq 0x2e53d(%rip), %rdx     # 0x70dba
movl $0x585c, %ecx           # imm = 0x585C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x42933
movq 0xa8(%rax), %r14
testq %r14, %r14
je 0x42933
movss 0x1ff8(%rbx), %xmm0
movq 0x18(%r14), %rax
movl (%rax), %eax
cvtsi2ss %rax, %xmm1
addss %xmm0, %xmm1
movss 0x28(%r14), %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x28(%r14)
addss 0x24cc(%rbx), %xmm0
addss 0x10(%r14), %xmm0
movss %xmm0, 0x10(%r14)
movl 0xb0(%r14), %eax
testl %eax, %eax
jne 0x4292a
movq 0x446f2(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x2e494(%rip), %rsi     # 0x70d9c
leaq 0x2e4ab(%rip), %rdx     # 0x70dba
movl $0x5864, %ecx           # imm = 0x5864
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl 0xb0(%r14), %eax
decl %eax
movl %eax, 0xb0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_tree_base
NK_INTERN int
nk_tree_base(struct nk_context *ctx, enum nk_tree_type type,
    struct nk_image *img, const char *title, enum nk_collapse_states initial_state,
    const char *hash, int len, int line)
{
    struct nk_window *win = ctx->current;
    int title_len = 0;
    nk_hash tree_hash = 0;
    nk_uint *state = 0;

    /* retrieve tree state from internal widget state tables */
    if (!hash) {
        title_len = (int)nk_strlen(title);
        tree_hash = nk_murmur_hash(title, (int)title_len, (nk_hash)line);
    } else tree_hash = nk_murmur_hash(hash, len, (nk_hash)line);
    state = nk_find_value(win, tree_hash);
    if (!state) {
        state = nk_add_value(ctx, win, tree_hash, 0);
        *state = initial_state;
    }
    return nk_tree_state_base(ctx, type, img, title, (enum nk_collapse_states*)state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl 0x48(%rsp), %r12d
movq 0x4780(%rdi), %r13
testq %r9, %r9
je 0x42992
movl 0x40(%rsp), %esi
movq %r9, %rdi
jmp 0x4299f
movq %rbx, %rdi
callq 0x12f10
movq %rbx, %rdi
movl %eax, %esi
movl %r12d, %edx
callq 0x12560
movq 0x1b8(%r13), %rcx
testq %rcx, %rcx
je 0x429e5
movl 0x4(%rcx), %edx
testq %rdx, %rdx
je 0x429d4
leaq 0xf8(%rcx), %r8
cmpl %eax, -0xf0(%r8)
je 0x429dd
addq $0x4, %r8
decq %rdx
jne 0x429c2
movq 0x1e8(%rcx), %rcx
jmp 0x429ae
movl (%r13), %eax
movl %eax, (%rcx)
jmp 0x429fc
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x437e2
movq %rax, %r8
movl 0x4(%rsp), %eax
movl %eax, (%r8)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42263
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_add_value
NK_LIB nk_uint*
nk_add_value(struct nk_context *ctx, struct nk_window *win,
            nk_hash name, nk_uint value)
{
    NK_ASSERT(ctx);
    NK_ASSERT(win);
    if (!win || !ctx) return 0;
    if (!win->tables || win->tables->size >= NK_VALUE_PAGE_CAPACITY) {
        struct nk_table *tbl = nk_create_table(ctx);
        NK_ASSERT(tbl);
        if (!tbl) return 0;
        nk_push_table(win, tbl);
    }
    win->tables->seq = win->seq;
    win->tables->keys[win->tables->size] = name;
    win->tables->values[win->tables->size] = value;
    return &win->tables->values[win->tables->size++];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x4386f
testq %rbx, %rbx
je 0x438a7
movl %edx, %ebp
movq 0x1b8(%rbx), %r14
testq %r14, %r14
je 0x43816
movl 0x4(%r14), %eax
cmpl $0x3c, %eax
jb 0x43979
callq 0x56b07
testq %rax, %rax
je 0x438c9
movq %rax, %r14
movq %rax, %r15
andq $0x3, %r15
je 0x438fd
movl $0x4, %r12d
subq %r15, %r12
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
leaq (%r14,%r12), %rdi
movl $0x204, %edx            # imm = 0x204
xorl %esi, %esi
callq 0x12b50
leaq (%r14,%r12), %rdi
addq $0x204, %rdi            # imm = 0x204
xorl %esi, %esi
movq %r15, %rdx
jmp 0x43907
movq 0x4377a(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2d51c(%rip), %rsi     # 0x70d9c
leaq 0x2d533(%rip), %rdx     # 0x70dba
xorl %r15d, %r15d
movl $0x4c6a, %ecx           # imm = 0x4C6A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
jne 0x4399f
movq 0x43742(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x2d4e4(%rip), %rsi     # 0x70d9c
leaq 0x2d4fb(%rip), %rdx     # 0x70dba
xorl %r15d, %r15d
movl $0x4c6b, %ecx           # imm = 0x4C6B
jmp 0x438e9
movq 0x43720(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x2d4c2(%rip), %rsi     # 0x70d9c
leaq 0x2d4d9(%rip), %rdx     # 0x70dba
xorl %r15d, %r15d
movl $0x4c6f, %ecx           # imm = 0x4C6F
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
jmp 0x4399f
movl $0x208, %edx            # imm = 0x208
movq %r14, %rdi
xorl %esi, %esi
callq 0x12b50
movq 0x1b8(%rbx), %rax
testq %rax, %rax
je 0x4394a
movq %r14, 0x1f0(%rax)
movq %rax, 0x1e8(%r14)
movq $0x0, 0x1f0(%r14)
movl $0x0, 0x4(%r14)
movq %r14, 0x1b8(%rbx)
incl 0x1c0(%rbx)
xorl %eax, %eax
jmp 0x43979
movq %r14, 0x1b8(%rbx)
movl $0x0, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x1e8(%r14)
movl $0x1, 0x1c0(%rbx)
movq 0x1b8(%rbx), %r14
movl 0x4(%r14), %eax
movl (%rbx), %ecx
movl %ecx, (%r14)
movl %eax, %ecx
leaq (%r14,%rcx,4), %r15
addq $0xf8, %r15
movl %ebp, -0xf0(%r15)
movl $0x0, (%r15)
incl %eax
movl %eax, 0x4(%r14)
movq %r15, %rax
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_list_view_end
NK_API void
nk_list_view_end(struct nk_list_view *view)
{
    struct nk_context *ctx;
    struct nk_window *win;
    struct nk_panel *layout;

    NK_ASSERT(view);
    NK_ASSERT(view->ctx);
    NK_ASSERT(view->scroll_pointer);
    if (!view || !view->ctx) return;

    ctx = view->ctx;
    win = ctx->current;
    layout = win->layout;
    layout->at_y = layout->bounds.y + (float)view->total_height;
    *view->scroll_pointer = *view->scroll_pointer + view->scroll_value;
    nk_group_end(view->ctx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x441df
movq 0x42e36(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2cbd8(%rip), %rsi     # 0x70d9c
leaq 0x2cbef(%rip), %rdx     # 0x70dba
movl $0x5a4b, %ecx           # imm = 0x5A4B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x10(%rbx)
jne 0x44212
movq 0x42e03(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2cba5(%rip), %rsi     # 0x70d9c
leaq 0x2cbbc(%rip), %rdx     # 0x70dba
movl $0x5a4c, %ecx           # imm = 0x5A4C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x18(%rbx)
jne 0x44245
movq 0x42dd0(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2cb72(%rip), %rsi     # 0x70d9c
leaq 0x2cb89(%rip), %rdx     # 0x70dba
movl $0x5a4d, %ecx           # imm = 0x5A4D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x44280
cvtsi2ssl 0xc(%rbx), %xmm0
movq 0x4780(%rdi), %rax
movq 0xa8(%rax), %rax
addss 0xc(%rax), %xmm0
movss %xmm0, 0x2c(%rax)
movq 0x18(%rbx), %rax
movl 0x20(%rbx), %ecx
addl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12160
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_widget_bounds
NK_API struct nk_rect
nk_widget_bounds(struct nk_context *ctx)
{
    struct nk_rect bounds;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current)
        return nk_rect(0,0,0,0);
    nk_layout_peek(&bounds, ctx);
    return bounds;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x442c3
movq 0x42d52(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2caf4(%rip), %rsi     # 0x70d9c
leaq 0x2cb0b(%rip), %rdx     # 0x70dba
movl $0x5a65, %ecx           # imm = 0x5A65
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x44303
movq 0x42d1c(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2cabe(%rip), %rsi     # 0x70d9c
leaq 0x2cad5(%rip), %rdx     # 0x70dba
movl $0x5a66, %ecx           # imm = 0x5A66
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
je 0x44326
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4432e
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
jmp 0x4431e
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_peek
NK_LIB void
nk_layout_peek(struct nk_rect *bounds, struct nk_context *ctx)
{
    float y;
    int index;
    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) {
        *bounds = nk_rect(0,0,0,0);
        return;
    }

    win = ctx->current;
    layout = win->layout;
    y = layout->at_y;
    index = layout->row.index;
    if (layout->row.index >= layout->row.columns) {
        layout->at_y += layout->row.height;
        layout->row.index = 0;
    }
    nk_layout_widget_space(bounds, ctx, win, nk_false);
    if (!layout->row.index) {
        bounds->x -= layout->row.item_offset;
    }
    layout->at_y = y;
    layout->row.index = index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4780(%rsi), %rax
testq %rax, %rax
jne 0x4437a
movq 0x42ca2(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2ca44(%rip), %rsi     # 0x70d9c
leaq 0x2ca5b(%rip), %rdx     # 0x70dba
movl $0x579c, %ecx           # imm = 0x579C
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x443bc
movq 0x42c65(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
leaq 0x2ca07(%rip), %rsi     # 0x70d9c
leaq 0x2ca1e(%rip), %rdx     # 0x70dba
movl $0x579d, %ecx           # imm = 0x579D
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movq 0x4780(%r14), %rax
testq %rax, %rax
je 0x44430
movq 0xa8(%rax), %r15
testq %r15, %r15
je 0x44430
movss 0x2c(%r15), %xmm1
movl 0x74(%r15), %ebp
cmpl 0x80(%r15), %ebp
jl 0x443f3
movss 0x78(%r15), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x2c(%r15)
movl $0x0, 0x74(%r15)
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x577f5
cmpl $0x0, 0x74(%r15)
jne 0x4441e
movss (%rbx), %xmm0
subss 0x98(%r15), %xmm0
movss %xmm0, (%rbx)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x2c(%r15)
movl %ebp, 0x74(%r15)
jmp 0x44436
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
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_widget_position
NK_API struct nk_vec2
nk_widget_position(struct nk_context *ctx)
{
    struct nk_rect bounds;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current)
        return nk_vec2(0,0);

    nk_layout_peek(&bounds, ctx);
    return nk_vec2(bounds.x, bounds.y);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4447c
movq 0x42b99(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c93b(%rip), %rsi     # 0x70d9c
leaq 0x2c952(%rip), %rdx     # 0x70dba
movl $0x5a70, %ecx           # imm = 0x5A70
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x444bc
movq 0x42b63(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c905(%rip), %rsi     # 0x70d9c
leaq 0x2c91c(%rip), %rdx     # 0x70dba
movl $0x5a71, %ecx           # imm = 0x5A71
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
je 0x444d6
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4432e
movaps (%r14), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x444ce
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_widget_size
NK_API struct nk_vec2
nk_widget_size(struct nk_context *ctx)
{
    struct nk_rect bounds;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current)
        return nk_vec2(0,0);

    nk_layout_peek(&bounds, ctx);
    return nk_vec2(bounds.w, bounds.h);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x44516
movq 0x42aff(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c8a1(%rip), %rsi     # 0x70d9c
leaq 0x2c8b8(%rip), %rdx     # 0x70dba
movl $0x5a7c, %ecx           # imm = 0x5A7C
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x44556
movq 0x42ac9(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c86b(%rip), %rsi     # 0x70d9c
leaq 0x2c882(%rip), %rdx     # 0x70dba
movl $0x5a7d, %ecx           # imm = 0x5A7D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
je 0x44573
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4432e
movaps (%r14), %xmm0
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x4456b
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_widget_width
NK_API float
nk_widget_width(struct nk_context *ctx)
{
    struct nk_rect bounds;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current)
        return 0;

    nk_layout_peek(&bounds, ctx);
    return bounds.w;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x445b3
movq 0x42a62(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c804(%rip), %rsi     # 0x70d9c
leaq 0x2c81b(%rip), %rdx     # 0x70dba
movl $0x5a88, %ecx           # imm = 0x5A88
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x445f3
movq 0x42a2c(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c7ce(%rip), %rsi     # 0x70d9c
leaq 0x2c7e5(%rip), %rdx     # 0x70dba
movl $0x5a89, %ecx           # imm = 0x5A89
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
je 0x44611
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4432e
movss 0x8(%r14), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x44609
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_widget_height
NK_API float
nk_widget_height(struct nk_context *ctx)
{
    struct nk_rect bounds;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current)
        return 0;

    nk_layout_peek(&bounds, ctx);
    return bounds.h;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x44651
movq 0x429c4(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c766(%rip), %rsi     # 0x70d9c
leaq 0x2c77d(%rip), %rdx     # 0x70dba
movl $0x5a94, %ecx           # imm = 0x5A94
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x44691
movq 0x4298e(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c730(%rip), %rsi     # 0x70d9c
leaq 0x2c747(%rip), %rdx     # 0x70dba
movl $0x5a95, %ecx           # imm = 0x5A95
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
je 0x446af
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4432e
movss 0xc(%r14), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x446a7
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_widget_is_hovered
NK_API nk_bool
nk_widget_is_hovered(struct nk_context *ctx)
{
    struct nk_rect c, v;
    struct nk_rect bounds;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current || ctx->active != ctx->current)
        return 0;

    c = ctx->current->layout->clip;
    c.x = (float)((int)c.x);
    c.y = (float)((int)c.y);
    c.w = (float)((int)c.w);
    c.h = (float)((int)c.h);

    nk_layout_peek(&bounds, ctx);
    nk_unify(&v, &c, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h);
    if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds.x, bounds.y, bounds.w, bounds.h))
        return 0;
    return nk_input_is_mouse_hovering_rect(&ctx->input, bounds);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x446f0
movq 0x42925(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c6c7(%rip), %rsi     # 0x70d9c
leaq 0x2c6de(%rip), %rdx     # 0x70dba
movl $0x5aa1, %ecx           # imm = 0x5AA1
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x44736
movq 0x428ed(%rip), %r14     # 0x86ff0
movq (%r14), %rdi
leaq 0x2c68f(%rip), %rsi     # 0x70d9c
leaq 0x2c6a6(%rip), %rdx     # 0x70dba
xorl %ebp, %ebp
movl $0x5aa2, %ecx           # imm = 0x5AA2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x447a3
xorl %ebp, %ebp
cmpq %rax, 0x4778(%rbx)
jne 0x447a3
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm0
movsd 0x4c(%rax), %xmm1
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4432e
movaps (%r14), %xmm0
movaps 0x10(%rsp), %xmm2
movaps %xmm2, %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movaps 0x20(%rsp), %xmm3
movhps 0x8(%r14), %xmm3        # xmm3 = xmm3[0,1],mem[0,1]
addps %xmm1, %xmm3
movlhps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
cmpltps %xmm3, %xmm0
movmskps %xmm0, %eax
cmpl $0xf, %eax
je 0x447ae
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd (%rsp), %xmm0
movss 0x144(%rbx), %xmm2
ucomiss %xmm0, %xmm2
jb 0x447a3
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
ucomiss %xmm2, %xmm3
jbe 0x447a3
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss 0x148(%rbx), %xmm2
ucomiss %xmm3, %xmm2
jb 0x447a3
addps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorl %ebp, %ebp
ucomiss %xmm2, %xmm0
seta %bpl
jmp 0x447a3