LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_menu_begin_symbol
NK_API nk_bool
nk_menu_begin_symbol(struct nk_context *ctx, const char *id,
    enum nk_symbol_type sym, struct nk_vec2 size)
{
    struct nk_window *win;
    const struct nk_input *in;
    struct nk_rect header;
    int is_clicked = nk_false;
    nk_flags state;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movaps %xmm0, 0x20(%rsp)
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3c7d8
movq 0x4883d(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2d54f(%rip), %rsi     # 0x69d0c
leaq 0x2d566(%rip), %rdx     # 0x69d2a
movl $0x543e, %ecx           # imm = 0x543E
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %r15
testq %r15, %r15
jne 0x3c817
movq 0x48805(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2d517(%rip), %rsi     # 0x69d0c
leaq 0x2d52e(%rip), %rdx     # 0x69d2a
movl $0x543f, %ecx           # imm = 0x543F
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %r15
cmpq $0x0, 0xa8(%r15)
jne 0x3c860
movq 0x487c8(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2d4da(%rip), %rsi     # 0x69d0c
leaq 0x2d4f1(%rip), %rdx     # 0x69d2a
xorl %r12d, %r12d
movl $0x5440, %ecx           # imm = 0x5440
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %r15
testq %r15, %r15
je 0x3c8fb
cmpq $0x0, 0xa8(%r15)
je 0x3c898
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x12990
movl %eax, %r12d
testl %eax, %eax
je 0x3c8fb
cmpl $0x1, %r12d
jne 0x3c89d
movq 0xa8(%r15), %rax
xorl %r9d, %r9d
testb $0x10, 0x5(%rax)
cmoveq %r14, %r9
jmp 0x3c8a0
xorl %r12d, %r12d
jmp 0x3c8fb
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 0x3c90b
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 0x3c2be
movl %eax, %r12d
movl %r12d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c973
movq 0x486a4(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2d3b5(%rip), %rsi     # 0x69d0c
leaq 0x2d3cc(%rip), %rdx     # 0x69d2a
movl $0x5eb9, %ecx           # imm = 0x5EB9
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0xa0(%rsp), %r12
testq %rbx, %rbx
jne 0x3c9ae
movq 0x48669(%rip), %rbp     # 0x84ff0
movq (%rbp), %rdi
leaq 0x2d37a(%rip), %rsi     # 0x69d0c
leaq 0x2d391(%rip), %rdx     # 0x69d2a
movl $0x5eba, %ecx           # imm = 0x5EBA
xorl %eax, %eax
callq 0x12ea0
movq (%rbp), %rdi
callq 0x13960
testq %r12, %r12
jne 0x3c9e1
movq 0x48636(%rip), %rbp     # 0x84ff0
movq (%rbp), %rdi
leaq 0x2d347(%rip), %rsi     # 0x69d0c
leaq 0x2d35e(%rip), %rdx     # 0x69d2a
movl $0x5ebb, %ecx           # imm = 0x5EBB
xorl %eax, %eax
callq 0x12ea0
movq (%rbp), %rdi
callq 0x13960
testq %r14, %r14
je 0x3ca81
xorl %ebp, %ebp
testq %r15, %r15
je 0x3caaf
testq %rbx, %rbx
je 0x3caaf
testq %r12, %r12
je 0x3caaf
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 0x43006
movl %eax, %ebp
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x3ca46
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 0x4ca9a
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0x3caaf
movq 0xc0(%rbx), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3caaf
movq 0x48568(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x2d27a(%rip), %rsi     # 0x69d0c
leaq 0x2d291(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x5ebc, %ecx           # imm = 0x5EBC
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
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_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_menu_begin_image_text
NK_API nk_bool
nk_menu_begin_image_text(struct nk_context *ctx, const char *title, int len,
    nk_flags align, struct nk_image img, struct nk_vec2 size)
{
    struct nk_window *win;
    struct nk_rect header;
    const struct nk_input *in;
    int is_clicked = nk_false;
    nk_flags state;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movaps %xmm0, 0x40(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3cb11
movq 0x48506(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2d217(%rip), %rsi     # 0x69d0c
leaq 0x2d22e(%rip), %rdx     # 0x69d2a
movl $0x5457, %ecx           # imm = 0x5457
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r14), %r12
testq %r12, %r12
jne 0x3cb52
movq 0x484cc(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2d1dd(%rip), %rsi     # 0x69d0c
leaq 0x2d1f4(%rip), %rdx     # 0x69d2a
movl $0x5458, %ecx           # imm = 0x5458
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r14), %r12
cmpq $0x0, 0xa8(%r12)
jne 0x3cb9e
movq 0x4848c(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2d19d(%rip), %rsi     # 0x69d0c
leaq 0x2d1b4(%rip), %rdx     # 0x69d2a
xorl %r13d, %r13d
movl $0x5459, %ecx           # imm = 0x5459
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r14), %r12
testq %r12, %r12
je 0x3cc6c
cmpq $0x0, 0xa8(%r12)
je 0x3cbe3
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x12990
movl %eax, %r13d
testl %eax, %eax
je 0x3cc6c
leaq 0x90(%rsp), %rax
cmpl $0x1, %r13d
jne 0x3cbeb
movq 0xa8(%r12), %rdx
xorl %ecx, %ecx
testb $0x10, 0x5(%rdx)
cmoveq %r14, %rcx
jmp 0x3cbed
xorl %r13d, %r13d
jmp 0x3cc6c
xorl %ecx, %ecx
leaq 0x2598(%r14), %rdi
leaq 0x68(%r12), %rsi
leaq 0x380(%r14), %rdx
movq 0x168(%r14), %r8
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movq 0x10(%rax), %r9
movq %r9, 0x10(%rsp)
movups (%rax), %xmm2
movups %xmm2, (%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3b495
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 0x3c2be
movl %eax, %r13d
movl %r13d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_menu_begin_symbol_text
NK_API nk_bool
nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len,
    nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size)
{
    struct nk_window *win;
    struct nk_rect header;
    const struct nk_input *in;
    int is_clicked = nk_false;
    nk_flags state;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps %xmm0, 0x20(%rsp)
movl %r8d, 0xc(%rsp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3cd0e
movq 0x48309(%rip), %r13     # 0x84ff0
movq (%r13), %rdi
leaq 0x2d01a(%rip), %rsi     # 0x69d0c
leaq 0x2d031(%rip), %rdx     # 0x69d2a
movl $0x5477, %ecx           # imm = 0x5477
xorl %eax, %eax
callq 0x12ea0
movq (%r13), %rdi
callq 0x13960
movq 0x4780(%r14), %r13
testq %r13, %r13
jne 0x3cd4f
movq 0x482cf(%rip), %r13     # 0x84ff0
movq (%r13), %rdi
leaq 0x2cfe0(%rip), %rsi     # 0x69d0c
leaq 0x2cff7(%rip), %rdx     # 0x69d2a
movl $0x5478, %ecx           # imm = 0x5478
xorl %eax, %eax
callq 0x12ea0
movq (%r13), %rdi
callq 0x13960
movq 0x4780(%r14), %r13
cmpq $0x0, 0xa8(%r13)
jne 0x3cd99
movq 0x48290(%rip), %r13     # 0x84ff0
movq (%r13), %rdi
leaq 0x2cfa1(%rip), %rsi     # 0x69d0c
leaq 0x2cfb8(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x5479, %ecx           # imm = 0x5479
xorl %eax, %eax
callq 0x12ea0
movq (%r13), %rdi
callq 0x13960
movq 0x4780(%r14), %r13
testq %r13, %r13
je 0x3ce40
cmpq $0x0, 0xa8(%r13)
je 0x3cdd2
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x12990
movl %eax, %ebp
testl %eax, %eax
je 0x3ce40
cmpl $0x1, %ebp
jne 0x3cdd6
movq 0xa8(%r13), %rcx
xorl %eax, %eax
testb $0x10, 0x5(%rcx)
cmoveq %r14, %rax
jmp 0x3cdd8
xorl %ebp, %ebp
jmp 0x3ce40
xorl %eax, %eax
movl %r15d, %r9d
movl %r12d, %r8d
movl 0xc(%rsp), %edx
leaq 0x2598(%r14), %rdi
leaq 0x68(%r13), %rsi
leaq 0x380(%r14), %r10
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %rcx
pushq %rax
pushq 0x168(%r14)
pushq %r10
pushq $0x0
callq 0x3b97e
addq $0x20, %rsp
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movaps 0x20(%rsp), %xmm2
callq 0x3c2be
movl %eax, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3cef7
movq 0x4811e(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2ce30(%rip), %rsi     # 0x69d0c
leaq 0x2ce47(%rip), %rdx     # 0x69d2a
movl $0x54c6, %ecx           # imm = 0x54C6
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3cf36
movq 0x480e6(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2cdf8(%rip), %rsi     # 0x69d0c
leaq 0x2ce0f(%rip), %rdx     # 0x69d2a
movl $0x54c7, %ecx           # imm = 0x54C7
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3cf78
movq 0x480a9(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2cdbb(%rip), %rsi     # 0x69d0c
leaq 0x2cdd2(%rip), %rdx     # 0x69d2a
movl $0x54c8, %ecx           # imm = 0x54C8
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3cf8f
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x3cf8f
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x7c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3cfda
movq 0x48043(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2cd55(%rip), %rsi     # 0x69d0c
leaq 0x2cd6c(%rip), %rdx     # 0x69d2a
movl $0x5543, %ecx           # imm = 0x5543
xorl %eax, %eax
movaps %xmm0, (%rsp)
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3d01b
jp 0x3d01b
movq 0x48005(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2cd17(%rip), %rsi     # 0x69d0c
leaq 0x2cd2e(%rip), %rdx     # 0x69d2a
movl $0x5544, %ecx           # imm = 0x5544
xorl %eax, %eax
movaps %xmm0, (%rsp)
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
xorps %xmm1, %xmm1
movaps (%rsp), %xmm0
testq %rbx, %rbx
je 0x3d069
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3d069
cmpq $0x0, 0xa8(%rax)
je 0x3d069
divss 0x4c(%rax), %xmm0
movss 0x297f1(%rip), %xmm2    # 0x66834
ucomiss %xmm0, %xmm2
setbe %al
ucomiss %xmm0, %xmm1
seta %cl
ja 0x3d054
movaps %xmm2, %xmm1
orb %al, %cl
je 0x3d066
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_O2/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 0x3d0cb
movq 0x47f4c(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2cc5d(%rip), %rsi     # 0x69d0c
leaq 0x2cc74(%rip), %rdx     # 0x69d2a
movl $0x552e, %ecx           # imm = 0x552E
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r15), %r12
testq %r12, %r12
jne 0x3d10c
movq 0x47f12(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2cc23(%rip), %rsi     # 0x69d0c
leaq 0x2cc3a(%rip), %rdx     # 0x69d2a
movl $0x552f, %ecx           # imm = 0x552F
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r15), %r12
cmpq $0x0, 0xa8(%r12)
jne 0x3d151
movq 0x47ed2(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x2cbe3(%rip), %rsi     # 0x69d0c
leaq 0x2cbfa(%rip), %rdx     # 0x69d2a
movl $0x5530, %ecx           # imm = 0x5530
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r15), %r12
testq %r12, %r12
je 0x3d1a1
cmpq $0x0, 0xa8(%r12)
je 0x3d1a1
movq %r15, %rdi
movq %r12, %rsi
movss 0xc(%rsp), %xmm0
movl %r14d, %edx
callq 0x3d2d6
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movq 0xa8(%r12), %rcx
shll $0x2, %eax
movl %eax, 0x70(%rcx)
andq $0x0, 0x88(%rcx)
andq $0x0, 0x98(%rcx)
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_O2/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 0x3d1fd
movq 0x47e18(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2cb2a(%rip), %rsi     # 0x69d0c
leaq 0x2cb41(%rip), %rdx     # 0x69d2a
movl $0x555a, %ecx           # imm = 0x555A
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
jne 0x3d23c
movq 0x47de0(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2caf2(%rip), %rsi     # 0x69d0c
leaq 0x2cb09(%rip), %rdx     # 0x69d2a
movl $0x555b, %ecx           # imm = 0x555B
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x3d27e
movq 0x47da3(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2cab5(%rip), %rsi     # 0x69d0c
leaq 0x2cacc(%rip), %rdx     # 0x69d2a
movl $0x555c, %ecx           # imm = 0x555C
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
je 0x3d2cb
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x3d2cb
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %ebx, %edx
callq 0x3d2d6
xorl %eax, %eax
testl %ebp, %ebp
setne %al
leal 0x1(,%rax,4), %eax
movl %eax, 0x70(%r15)
andq $0x0, 0x88(%r15)
andl $0x0, 0x90(%r15)
andq $0x0, 0x98(%r15)
movl %ebx, 0x80(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d543
movq 0x47ad2(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c7e4(%rip), %rsi     # 0x69d0c
leaq 0x2c7fb(%rip), %rdx     # 0x69d2a
movl $0x5573, %ecx           # imm = 0x5573
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3d582
movq 0x47a9a(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c7ac(%rip), %rsi     # 0x69d0c
leaq 0x2c7c3(%rip), %rdx     # 0x69d2a
movl $0x5574, %ecx           # imm = 0x5574
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3d5c8
movq 0x47a5d(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c76f(%rip), %rsi     # 0x69d0c
leaq 0x2c786(%rip), %rdx     # 0x69d2a
movl $0x5575, %ecx           # imm = 0x5575
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3d662
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x3d662
movl 0x70(%rbx), %eax
movl %eax, %ecx
orl $0x4, %ecx
cmpl $0x5, %ecx
je 0x3d614
movq 0x47a04(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c716(%rip), %rsi     # 0x69d0c
leaq 0x2c72d(%rip), %rdx     # 0x69d2a
movl $0x557b, %ecx           # imm = 0x557B
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movl 0x70(%rbx), %eax
cmpl $0x5, %eax
je 0x3d654
cmpl $0x1, %eax
jne 0x3d662
movss 0x9c(%rbx), %xmm0
movaps %xmm0, %xmm1
addss 0x4(%rsp), %xmm1
ucomiss 0x291fe(%rip), %xmm1    # 0x66834
ja 0x3d662
xorps %xmm1, %xmm1
movss 0x4(%rsp), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x3d66a
movss 0x291e6(%rip), %xmm0    # 0x66834
minss %xmm2, %xmm0
jmp 0x3d65a
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movss 0x291c2(%rip), %xmm1    # 0x66834
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
jmp 0x3d65a
// File: /workspace/github_c_makefile_star2_O2/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 0x3d6b3
movq 0x47962(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c674(%rip), %rsi     # 0x69d0c
leaq 0x2c68b(%rip), %rdx     # 0x69d2a
movl $0x558d, %ecx           # imm = 0x558D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3d6f2
movq 0x4792a(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c63c(%rip), %rsi     # 0x69d0c
leaq 0x2c653(%rip), %rdx     # 0x69d2a
movl $0x558e, %ecx           # imm = 0x558E
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3d734
movq 0x478ed(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c5ff(%rip), %rsi     # 0x69d0c
leaq 0x2c616(%rip), %rdx     # 0x69d2a
movl $0x558f, %ecx           # imm = 0x558F
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3d792
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x3d792
movl 0x70(%rbx), %eax
movl %eax, %ecx
orl $0x4, %ecx
cmpl $0x5, %ecx
je 0x3d77c
movq 0x4789c(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c5ae(%rip), %rsi     # 0x69d0c
leaq 0x2c5c5(%rip), %rdx     # 0x69d2a
movl $0x5595, %ecx           # imm = 0x5595
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movl 0x70(%rbx), %eax
orl $0x4, %eax
cmpl $0x5, %eax
jne 0x3d792
andl $0x0, 0x90(%rbx)
andl $0x0, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d985
movq 0x47690(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c3a2(%rip), %rsi     # 0x69d0c
leaq 0x2c3b9(%rip), %rdx     # 0x69d2a
movl $0x55c8, %ecx           # imm = 0x55C8
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
jne 0x3d9c4
movq 0x47658(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c36a(%rip), %rsi     # 0x69d0c
leaq 0x2c381(%rip), %rdx     # 0x69d2a
movl $0x55c9, %ecx           # imm = 0x55C9
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x3da06
movq 0x4761b(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c32d(%rip), %rsi     # 0x69d0c
leaq 0x2c344(%rip), %rdx     # 0x69d2a
movl $0x55ca, %ecx           # imm = 0x55CA
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rsi
testq %rsi, %rsi
je 0x3da4e
movq 0xa8(%rsi), %r14
testq %r14, %r14
je 0x3da4e
pushq $0x1
popq %rdx
movq %rbx, %rdi
movss 0x4(%rsp), %xmm0
callq 0x3d2d6
movl $0x8, 0x70(%r14)
andl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
andq $0x0, 0xa8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3da8e
movq 0x47587(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c299(%rip), %rsi     # 0x69d0c
leaq 0x2c2b0(%rip), %rdx     # 0x69d2a
movl $0x55e3, %ecx           # imm = 0x55E3
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3dacd
movq 0x4754f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c261(%rip), %rsi     # 0x69d0c
leaq 0x2c278(%rip), %rdx     # 0x69d2a
movl $0x55e4, %ecx           # imm = 0x55E4
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3db13
movq 0x47512(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c224(%rip), %rsi     # 0x69d0c
leaq 0x2c23b(%rip), %rdx     # 0x69d2a
movl $0x55e5, %ecx           # imm = 0x55E5
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3dbb1
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x3dbb1
cmpl $0x8, 0x70(%rbx)
je 0x3db55
movq 0x474c0(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c1d2(%rip), %rsi     # 0x69d0c
leaq 0x2c1e9(%rip), %rdx     # 0x69d2a
movl $0x55eb, %ecx           # imm = 0x55EB
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
cmpl $0x10, 0x80(%rbx)
jl 0x3db8a
movq 0x4748b(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c19d(%rip), %rsi     # 0x69d0c
leaq 0x2c1b4(%rip), %rdx     # 0x69d2a
movl $0x55ec, %ecx           # imm = 0x55EC
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
cmpl $0x8, 0x70(%rbx)
jne 0x3dbb1
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x3dbb1
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_O2/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 0x3dbf8
movq 0x4741d(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c12f(%rip), %rsi     # 0x69d0c
leaq 0x2c146(%rip), %rdx     # 0x69d2a
movl $0x55f7, %ecx           # imm = 0x55F7
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3dc37
movq 0x473e5(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c0f7(%rip), %rsi     # 0x69d0c
leaq 0x2c10e(%rip), %rdx     # 0x69d2a
movl $0x55f8, %ecx           # imm = 0x55F8
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3dc7d
movq 0x473a8(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c0ba(%rip), %rsi     # 0x69d0c
leaq 0x2c0d1(%rip), %rdx     # 0x69d2a
movl $0x55f9, %ecx           # imm = 0x55F9
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3dd24
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x3dd24
cmpl $0x8, 0x70(%rbx)
je 0x3dcbf
movq 0x47356(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c068(%rip), %rsi     # 0x69d0c
leaq 0x2c07f(%rip), %rdx     # 0x69d2a
movl $0x55ff, %ecx           # imm = 0x55FF
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
cmpl $0x10, 0x80(%rbx)
jl 0x3dcf4
movq 0x47321(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2c033(%rip), %rsi     # 0x69d0c
leaq 0x2c04a(%rip), %rdx     # 0x69d2a
movl $0x5600, %ecx           # imm = 0x5600
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
cmpl $0x8, 0x70(%rbx)
jne 0x3dd24
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x3dd24
movaps (%rsp), %xmm0
xorps 0x2885e(%rip), %xmm0    # 0x66570
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_O2/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 0x3dd6a
movq 0x472ab(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2bfbd(%rip), %rsi     # 0x69d0c
leaq 0x2bfd4(%rip), %rdx     # 0x69d2a
movl $0x560b, %ecx           # imm = 0x560B
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3dda9
movq 0x47273(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2bf85(%rip), %rsi     # 0x69d0c
leaq 0x2bf9c(%rip), %rdx     # 0x69d2a
movl $0x560c, %ecx           # imm = 0x560C
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3ddef
movq 0x47236(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2bf48(%rip), %rsi     # 0x69d0c
leaq 0x2bf5f(%rip), %rdx     # 0x69d2a
movl $0x560d, %ecx           # imm = 0x560D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3de91
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x3de91
cmpl $0x8, 0x70(%rbx)
je 0x3de31
movq 0x471e4(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2bef6(%rip), %rsi     # 0x69d0c
leaq 0x2bf0d(%rip), %rdx     # 0x69d2a
movl $0x5613, %ecx           # imm = 0x5613
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
cmpl $0x10, 0x80(%rbx)
jl 0x3de66
movq 0x471af(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2bec1(%rip), %rsi     # 0x69d0c
leaq 0x2bed8(%rip), %rdx     # 0x69d2a
movl $0x5614, %ecx           # imm = 0x5614
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
cmpl $0x8, 0x70(%rbx)
jne 0x3de91
movslq 0x80(%rbx), %rax
cmpq $0xf, %rax
jg 0x3de91
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_O2/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 0x3e0f8
movq 0x46f1d(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2bc2f(%rip), %rsi     # 0x69d0c
leaq 0x2bc46(%rip), %rdx     # 0x69d2a
movl $0x5653, %ecx           # imm = 0x5653
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
jne 0x3e137
movq 0x46ee5(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2bbf7(%rip), %rsi     # 0x69d0c
leaq 0x2bc0e(%rip), %rdx     # 0x69d2a
movl $0x5654, %ecx           # imm = 0x5654
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %rsi
cmpq $0x0, 0xa8(%rsi)
jne 0x3e179
movq 0x46ea8(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x2bbba(%rip), %rsi     # 0x69d0c
leaq 0x2bbd1(%rip), %rdx     # 0x69d2a
movl $0x5655, %ecx           # imm = 0x5655
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%r14), %rsi
testq %rsi, %rsi
je 0x3e1c0
movq 0xa8(%rsi), %r15
testq %r15, %r15
je 0x3e1c0
movq %r14, %rdi
movss 0x4(%rsp), %xmm0
movl %ebp, %edx
callq 0x3d2d6
xorl %eax, %eax
cmpl $0x1, %ebx
sete %al
leal 0x2(,%rax,4), %eax
movl %eax, 0x70(%r15)
andq $0x0, 0x88(%r15)
andl $0x0, 0x90(%r15)
andq $0x0, 0x98(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3e203
movq 0x46e12(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2bb24(%rip), %rsi     # 0x69d0c
leaq 0x2bb3b(%rip), %rdx     # 0x69d2a
movl $0x566b, %ecx           # imm = 0x566B
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3e242
movq 0x46dda(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2baec(%rip), %rsi     # 0x69d0c
leaq 0x2bb03(%rip), %rdx     # 0x69d2a
movl $0x566c, %ecx           # imm = 0x566C
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3e284
movq 0x46d9d(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2baaf(%rip), %rsi     # 0x69d0c
leaq 0x2bac6(%rip), %rdx     # 0x69d2a
movl $0x566d, %ecx           # imm = 0x566D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3e2b5
movq 0xa8(%rax), %rdi
testq %rdi, %rdi
je 0x3e2b5
andq $0x0, 0x90(%rdi)
andl $0x0, 0x98(%rdi)
addq $0xa0, %rdi
pushq $0x10
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23ed0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e301
movq 0x46d14(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2ba26(%rip), %rsi     # 0x69d0c
leaq 0x2ba3d(%rip), %rdx     # 0x69d2a
movl $0x567e, %ecx           # imm = 0x567E
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3e340
movq 0x46cdc(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b9ee(%rip), %rsi     # 0x69d0c
leaq 0x2ba05(%rip), %rdx     # 0x69d2a
movl $0x567f, %ecx           # imm = 0x567F
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3e382
movq 0x46c9f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b9b1(%rip), %rsi     # 0x69d0c
leaq 0x2b9c8(%rip), %rdx     # 0x69d2a
movl $0x5680, %ecx           # imm = 0x5680
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3e39f
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x3e39f
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_O2/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 0x3e3df
movq 0x46c36(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b948(%rip), %rsi     # 0x69d0c
leaq 0x2b95f(%rip), %rdx     # 0x69d2a
movl $0x568f, %ecx           # imm = 0x568F
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3e41e
movq 0x46bfe(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b910(%rip), %rsi     # 0x69d0c
leaq 0x2b927(%rip), %rdx     # 0x69d2a
movl $0x5690, %ecx           # imm = 0x5690
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x3e464
movq 0x46bbf(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b8d1(%rip), %rsi     # 0x69d0c
leaq 0x2b8e8(%rip), %rdx     # 0x69d2a
movl $0x5691, %ecx           # imm = 0x5691
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
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_O2/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 0x3e4b6
movq 0x46b5f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b871(%rip), %rsi     # 0x69d0c
leaq 0x2b888(%rip), %rdx     # 0x69d2a
movl $0x56a2, %ecx           # imm = 0x56A2
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3e4f5
movq 0x46b27(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b839(%rip), %rsi     # 0x69d0c
leaq 0x2b850(%rip), %rdx     # 0x69d2a
movl $0x56a3, %ecx           # imm = 0x56A3
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x3e53b
movq 0x46ae8(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b7fa(%rip), %rsi     # 0x69d0c
leaq 0x2b811(%rip), %rdx     # 0x69d2a
movl $0x56a4, %ecx           # imm = 0x56A4
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
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_O2/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 0x3e5ab
movq 0x46a6a(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b77c(%rip), %rsi     # 0x69d0c
leaq 0x2b793(%rip), %rdx     # 0x69d2a
movl $0x56b4, %ecx           # imm = 0x56B4
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3e5ea
movq 0x46a32(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b744(%rip), %rsi     # 0x69d0c
leaq 0x2b75b(%rip), %rdx     # 0x69d2a
movl $0x56b5, %ecx           # imm = 0x56B5
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x3e630
movq 0x469f3(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b705(%rip), %rsi     # 0x69d0c
leaq 0x2b71c(%rip), %rdx     # 0x69d2a
movl $0x56b6, %ecx           # imm = 0x56B6
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
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 0x28144(%rip), %xmm0    # 0x66790
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_O2/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 0x3e6ab
movq 0x4696a(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b67c(%rip), %rsi     # 0x69d0c
leaq 0x2b693(%rip), %rdx     # 0x69d2a
movl $0x56c4, %ecx           # imm = 0x56C4
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3e6ea
movq 0x46932(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b644(%rip), %rsi     # 0x69d0c
leaq 0x2b65b(%rip), %rdx     # 0x69d2a
movl $0x56c5, %ecx           # imm = 0x56C5
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
jne 0x3e730
movq 0x468f3(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x2b605(%rip), %rsi     # 0x69d0c
leaq 0x2b61c(%rip), %rdx     # 0x69d2a
movl $0x56c6, %ecx           # imm = 0x56C6
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
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 0x28044(%rip), %xmm0    # 0x66790
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