LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_layout_reset_min_row_height
NK_API void
nk_layout_reset_min_row_height(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.min_height = ctx->style.font->height;
    layout->row.min_height += ctx->style.text.padding.y*2;
    layout->row.min_height += ctx->style.window.min_row_height_padding*2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x38f17
movq 0x4f0fe(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x38e90(%rip), %rsi     # 0x71d8c
leaq 0x38ea7(%rip), %rdx     # 0x71daa
movl $0x54d6, %ecx           # imm = 0x54D6
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x38f4d
movq 0x4f0c8(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x38e5a(%rip), %rsi     # 0x71d8c
leaq 0x38e71(%rip), %rdx     # 0x71daa
movl $0x54d7, %ecx           # imm = 0x54D7
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x38f8a
movq 0x4f08b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x38e1d(%rip), %rsi     # 0x71d8c
leaq 0x38e34(%rip), %rdx     # 0x71daa
movl $0x54d8, %ecx           # imm = 0x54D8
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x38fe2
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38fe2
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x38fe2
movq 0x168(%rbx), %rcx
movss 0x8(%rcx), %xmm0
movss %xmm0, 0x7c(%rax)
movss 0x1c4(%rbx), %xmm1
addss %xmm1, %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x7c(%rax)
movss 0x24ac(%rbx), %xmm0
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x7c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_push_font
NK_API nk_bool
nk_style_push_font(struct nk_context *ctx, const struct nk_user_font *font)
{
    struct nk_config_stack_user_font *font_stack;
    struct nk_config_stack_user_font_element *element;

    NK_ASSERT(ctx);
    if (!ctx) return 0;

    font_stack = &ctx->stacks.fonts;
    NK_ASSERT(font_stack->head < (int)NK_LEN(font_stack->elements));
    if (font_stack->head >= (int)NK_LEN(font_stack->elements))
        return 0;

    element = &font_stack->elements[font_stack->head++];
    element->address = &ctx->style.font;
    element->old_value = ctx->style.font;
    ctx->style.font = font;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3907e
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, 0x2fc8(%rdi)
jl 0x39035
movq 0x4efe0(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
leaq 0x38d72(%rip), %rsi     # 0x71d8c
leaq 0x38d89(%rip), %rdx     # 0x71daa
movl $0x49de, %ecx           # imm = 0x49DE
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
movslq 0x2fc8(%r14), %rax
xorl %ebp, %ebp
cmpq $0x7, %rax
jg 0x390ac
leal 0x1(%rax), %ecx
movl %ecx, 0x2fc8(%r14)
shlq $0x4, %rax
leaq 0x168(%r14), %rcx
movq %rcx, 0x2fd0(%r14,%rax)
movq 0x168(%r14), %rcx
movq %rcx, 0x2fd8(%r14,%rax)
movq %rbx, 0x168(%r14)
movl $0x1, %ebp
jmp 0x390ac
movq 0x4ef6b(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x38cfd(%rip), %rsi     # 0x71d8c
leaq 0x38d14(%rip), %rdx     # 0x71daa
xorl %ebp, %ebp
movl $0x49da, %ecx           # imm = 0x49DA
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_pop_font
NK_API nk_bool
nk_style_pop_font(struct nk_context *ctx)
{
    struct nk_config_stack_user_font *font_stack;
    struct nk_config_stack_user_font_element *element;

    NK_ASSERT(ctx);
    if (!ctx) return 0;

    font_stack = &ctx->stacks.fonts;
    NK_ASSERT(font_stack->head > 0);
    if (font_stack->head < 1)
        return 0;

    element = &font_stack->elements[--font_stack->head];
    *element->address = element->old_value;
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3912a
movq %rdi, %rbx
cmpl $0x0, 0x2fc8(%rdi)
jg 0x390fa
movq 0x4ef1b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x38cad(%rip), %rsi     # 0x71d8c
leaq 0x38cc4(%rip), %rdx     # 0x71daa
movl $0x49f2, %ecx           # imm = 0x49F2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl 0x2fc8(%rbx), %eax
testl %eax, %eax
jle 0x3915a
decl %eax
movl %eax, 0x2fc8(%rbx)
shlq $0x4, %rax
movq 0x2fd0(%rbx,%rax), %rcx
movq 0x2fd8(%rbx,%rax), %rax
movq %rax, (%rcx)
movl $0x1, %ebx
jmp 0x3915c
movq 0x4eebf(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x38c51(%rip), %rsi     # 0x71d8c
leaq 0x38c68(%rip), %rdx     # 0x71daa
xorl %ebx, %ebx
movl $0x49ee, %ecx           # imm = 0x49EE
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x3915c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_set_cursor
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk, style_item, style_items)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(nk,float, floats)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk, vec2, vectors)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(nk,flags, flags)
NK_API nk_bool NK_STYLE_PUSH_IMPLEMENATION(struct nk,color, colors)

NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(style_item, style_items)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(float,floats)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(vec2, vectors)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(flags,flags)
NK_API nk_bool NK_STYLE_POP_IMPLEMENATION(color,colors)

NK_API nk_bool
nk_style_set_cursor(struct nk_context *ctx, enum nk_style_cursor c)
{
    struct nk_style *style;
    NK_ASSERT(ctx);
    if (!ctx) return 0;
    style = &ctx->style;
    if (style->cursors[c]) {
        style->cursor_active = style->cursors[c];
        return 1;
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3991a
movl %esi, %eax
movq 0x170(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x3994a
movq %rax, 0x1a8(%rdi)
movl $0x1, %ebx
jmp 0x3994c
movq 0x4e6cf(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x38461(%rip), %rsi     # 0x71d8c
leaq 0x38478(%rip), %rdx     # 0x71daa
xorl %ebx, %ebx
movl $0x4a2a, %ecx           # imm = 0x4A2A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
jmp 0x3994c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_style_load_all_cursors
NK_API void
nk_style_load_all_cursors(struct nk_context *ctx, struct nk_cursor *cursors)
{
    int i = 0;
    struct nk_style *style;
    NK_ASSERT(ctx);
    if (!ctx) return;
    style = &ctx->style;
    for (i = 0; i < NK_CURSOR_COUNT; ++i)
        style->cursors[i] = &cursors[i];
    style->cursor_visible = nk_true;
}

// Assembly:
testq %rdi, %rdi
je 0x39a3b
movdqa 0x34bd5(%rip), %xmm0    # 0x6e590
xorl %eax, %eax
movdqa 0x34bab(%rip), %xmm1    # 0x6e570
movdqa 0x34cd3(%rip), %xmm2    # 0x6e6a0
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x34c76(%rip), %xmm4    # 0x6e650
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %ecx
testb $0x1, %cl
je 0x39a08
movq %rsi, 0x170(%rdi,%rax,8)
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0x39a1e
leaq 0x28(%rsi), %rcx
movq %rcx, 0x178(%rdi,%rax,8)
addq $0x2, %rax
paddq %xmm4, %xmm0
addq $0x50, %rsi
cmpq $0x8, %rax
jne 0x399da
movl $0x1, 0x1b8(%rdi)
retq
pushq %rbx
movq 0x4e5ad(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x3833f(%rip), %rsi     # 0x71d8c
leaq 0x38356(%rip), %rdx     # 0x71daa
movl $0x4a4c, %ecx           # imm = 0x4A4C
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init_default
NK_API nk_bool
nk_init_default(struct nk_context *ctx, const struct nk_user_font *font)
{
    struct nk_allocator alloc;
    alloc.userdata.ptr = 0;
    alloc.alloc = nk_malloc;
    alloc.free = nk_mfree;
    return nk_init(ctx, &alloc, font);
}

// Assembly:
subq $0x18, %rsp
movq %rsi, %rdx
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq -0x148e3(%rip), %rax    # 0x2519e
movq %rax, 0x8(%rsi)
leaq -0x148e6(%rip), %rax    # 0x251a6
movq %rax, 0x10(%rsi)
callq 0x13ff0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init
NK_API nk_bool
nk_init(struct nk_context *ctx, struct nk_allocator *alloc,
    const struct nk_user_font *font)
{
    NK_ASSERT(alloc);
    if (!alloc) return 0;
    nk_setup(ctx, font);
    nk_buffer_init(&ctx->memory, alloc, NK_DEFAULT_COMMAND_BUFFER_SIZE);
    nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY);
    ctx->use_pool = nk_true;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x39b14
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x39bbd
leaq 0x2508(%rbx), %rdi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0x12d60
leaq 0x4720(%rbx), %rdi
movl $0x48, %esi
callq 0x25316
movq 0x10(%r14), %rax
movq %rax, 0x4730(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x4720(%rbx)
movl $0x10, 0x4750(%rbx)
movl $0x1, %ebp
movl %ebp, 0x4738(%rbx)
movq $0x0, 0x4740(%rbx)
movl %ebp, 0x471c(%rbx)
jmp 0x39b42
movq 0x4e4d5(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x38267(%rip), %rsi     # 0x71d8c
leaq 0x3827e(%rip), %rdx     # 0x71daa
xorl %ebp, %ebp
movl $0x4a99, %ecx           # imm = 0x4A99
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
callq 0x13780
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init_fixed
NK_API nk_bool
nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size,
    const struct nk_user_font *font)
{
    NK_ASSERT(memory);
    if (!memory) return 0;
    nk_setup(ctx, font);
    nk_buffer_init_fixed(&ctx->memory, memory, size);
    ctx->use_pool = nk_false;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x39b87
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x39bbd
leaq 0x2508(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12680
movl $0x0, 0x471c(%rbx)
movl $0x1, %ebx
jmp 0x39bb5
movq 0x4e462(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x381f4(%rip), %rsi     # 0x71d8c
leaq 0x3820b(%rip), %rdx     # 0x71daa
xorl %ebx, %ebx
movl $0x4a79, %ecx           # imm = 0x4A79
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_setup
NK_INTERN void
nk_setup(struct nk_context *ctx, const struct nk_user_font *font)
{
    NK_ASSERT(ctx);
    if (!ctx) return;
    nk_zero_struct(*ctx);
    nk_style_default(ctx);
    ctx->seq = 1;
    if (font) ctx->style.font = font;
#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
    nk_draw_list_init(&ctx->draw_list);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x39bfc
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
andq $0x3, %r15
je 0x39c31
movl $0x4, %r12d
subq %r15, %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
orq $0x4794, %r15           # imm = 0x4794
addq %rbx, %r12
jmp 0x39c3a
movq 0x4e3ed(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x3817f(%rip), %rsi     # 0x71d8c
leaq 0x38196(%rip), %rdx     # 0x71daa
movl $0x4a60, %ecx           # imm = 0x4A60
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13780
movl $0x4798, %r15d          # imm = 0x4798
movq %rbx, %r12
movl %r15d, %r13d
andl $-0x4, %r13d
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
andq $0x3, %r15
je 0x39c64
addq %r13, %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12a10
movl $0x1, 0x4794(%rbx)
testq %r14, %r14
je 0x39c84
movq %r14, 0x168(%rbx)
addq $0x30e0, %rbx           # imm = 0x30E0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13090
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_init_custom
NK_API nk_bool
nk_init_custom(struct nk_context *ctx, struct nk_buffer *cmds,
    struct nk_buffer *pool, const struct nk_user_font *font)
{
    NK_ASSERT(cmds);
    NK_ASSERT(pool);
    if (!cmds || !pool) return 0;

    nk_setup(ctx, font);
    ctx->memory = *cmds;
    if (pool->type == NK_BUFFER_FIXED) {
        /* take memory from buffer and alloc fixed pool */
        nk_pool_init_fixed(&ctx->pool, pool->memory.ptr, pool->memory.size);
    } else {
        /* create dynamic pool from buffer allocator */
        struct nk_allocator *alloc = &pool->pool;
        nk_pool_init(&ctx->pool, alloc, NK_POOL_DEFAULT_CAPACITY);
    }
    ctx->use_pool = nk_true;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x39ce4
movq 0x4e333(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x380c4(%rip), %rsi     # 0x71d8c
leaq 0x380db(%rip), %rdx     # 0x71daa
movl $0x4a84, %ecx           # imm = 0x4A84
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %r14, %r14
jne 0x39d17
movq 0x4e300(%rip), %r13     # 0x87ff0
movq (%r13), %rdi
leaq 0x38091(%rip), %rsi     # 0x71d8c
leaq 0x380a8(%rip), %rdx     # 0x71daa
movl $0x4a85, %ecx           # imm = 0x4A85
xorl %eax, %eax
callq 0x12d80
movq (%r13), %rdi
callq 0x13780
testq %r14, %r14
sete %cl
testq %r15, %r15
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x39e3d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x39bbd
leaq 0x2508(%rbx), %rdi
movl $0xf, %ecx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpl $0x0, 0x38(%r14)
je 0x39d9d
leaq 0x4720(%rbx), %rdi
movl $0x48, %esi
callq 0x25316
movq 0x30(%r14), %rax
movq %rax, 0x4730(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x4720(%rbx)
movl $0x10, 0x4750(%rbx)
movl $0x1, 0x4738(%rbx)
movq $0x0, 0x4740(%rbx)
jmp 0x39e2e
leaq 0x4720(%rbx), %rdi
movq 0x40(%r14), %r15
movq 0x48(%r14), %r14
movl $0x48, %esi
callq 0x25316
cmpq $0x217, %r14            # imm = 0x217
ja 0x39ded
movq 0x4e22a(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x37fbb(%rip), %rsi     # 0x71d8c
leaq 0x37fd2(%rip), %rdx     # 0x71daa
movl $0x4bd2, %ecx           # imm = 0x4BD2
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
cmpq $0x218, %r14            # imm = 0x218
jb 0x39e2e
leaq -0x218(%r14), %rax
movabsq $0xfc0fc0fc0fc0fc1, %rcx # imm = 0xFC0FC0FC0FC0FC1
mulq %rcx
shrq $0x5, %rdx
incl %edx
movl %edx, 0x4750(%rbx)
movq %r15, 0x4740(%rbx)
movl $0x0, 0x4738(%rbx)
movq %r14, 0x4758(%rbx)
movl $0x1, 0x471c(%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_free
NK_API void
nk_free(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    if (!ctx) return;
    nk_buffer_free(&ctx->memory);
    if (ctx->use_pool)
        nk_pool_free(&ctx->pool);

    nk_zero(&ctx->input, sizeof(ctx->input));
    nk_zero(&ctx->style, sizeof(ctx->style));
    nk_zero(&ctx->memory, sizeof(ctx->memory));

    ctx->seq = 0;
    ctx->build = 0;
    ctx->begin = 0;
    ctx->end = 0;
    ctx->active = 0;
    ctx->current = 0;
    ctx->freelist = 0;
    ctx->count = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x39eee
movq %rdi, %rbx
movq 0x2548(%rdi), %rsi
testq %rsi, %rsi
je 0x39e86
cmpl $0x0, 0x2540(%rbx)
je 0x39e86
movq 0x2538(%rbx), %rax
testq %rax, %rax
je 0x39e86
movq 0x2528(%rbx), %rdi
callq *%rax
cmpl $0x0, 0x471c(%rbx)
je 0x39ec3
movq 0x4740(%rbx), %rsi
cmpl $0x0, 0x4738(%rbx)
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x39ec3
movq 0x8(%rsi), %r14
movq 0x4720(%rbx), %rdi
callq *0x4730(%rbx)
movq %r14, %rsi
testq %r14, %r14
jne 0x39eaa
movq %rbx, %r14
andq $0x3, %r14
je 0x39f23
movl $0x4, %r15d
subq %r14, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
orq $0x164, %r14            # imm = 0x164
addq %rbx, %r15
jmp 0x39f2c
movq 0x4e0fb(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x37e8d(%rip), %rsi     # 0x71d8c
leaq 0x37ea4(%rip), %rdx     # 0x71daa
movl $0x4aae, %ecx           # imm = 0x4AAE
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13780
movl $0x168, %r14d           # imm = 0x168
movq %rbx, %r15
movl %r14d, %r12d
andl $-0x4, %r12d
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
andq $0x3, %r14
je 0x39f56
addq %r12, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x12b50
leaq 0x168(%rbx), %r15
movq %r15, %r12
andq $0x3, %r12
je 0x39f88
movl $0x4, %r14d
subq %r12, %r14
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x12b50
orq $0x239c, %r12           # imm = 0x239C
addq %r14, %r15
jmp 0x39f8e
movl $0x23a0, %r12d          # imm = 0x23A0
leaq 0x2508(%rbx), %r14
movl %r12d, %r13d
andl $-0x4, %r13d
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x12b50
andq $0x3, %r12
je 0x39fbf
addq %r13, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
movq %r14, %r15
andq $0x3, %r15
je 0x39fe7
movl $0x4, %r12d
subq %r15, %r12
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
orq $0x74, %r15
addq %r12, %r14
jmp 0x39fed
movl $0x78, %r15d
movl %r15d, %r12d
andl $-0x4, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
andq $0x3, %r15
je 0x3a017
addq %r12, %r14
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x12b50
movl $0x0, 0x4718(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4768(%rbx)
movups %xmm0, 0x4778(%rbx)
movups %xmm0, 0x4788(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_free_window
NK_LIB void
nk_free_window(struct nk_context *ctx, struct nk_window *win)
{
    /* unlink windows from list */
    struct nk_table *it = win->tables;
    if (win->popup.win) {
        nk_free_window(ctx, win->popup.win);
        win->popup.win = 0;
    }
    win->next = 0;
    win->prev = 0;

    while (it) {
        /*free window state tables */
        struct nk_table *n = it->next;
        nk_remove_table(win, it);
        nk_free_table(ctx, it);
        if (it == win->tables)
            win->tables = n;
        it = n;
    }

    /* link windows into freelist */
    {union nk_page_data *pd = NK_CONTAINER_OF(win, union nk_page_data, win);
    struct nk_page_element *pe = NK_CONTAINER_OF(pd, struct nk_page_element, data);
    nk_free_page_element(ctx, pe);}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x120(%rsi), %rsi
movq 0x1b8(%rbx), %r15
testq %rsi, %rsi
je 0x3a3a4
movq %r14, %rdi
callq 0x3a370
movq $0x0, 0x120(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rbx)
testq %r15, %r15
je 0x3a421
movq 0x1e8(%r15), %r12
cmpq %r15, 0x1b8(%rbx)
jne 0x3a3ca
movq %r12, 0x1b8(%rbx)
testq %r12, %r12
je 0x3a3de
movq 0x1f0(%r15), %rax
movq %rax, 0x1f0(%r12)
movq 0x1f0(%r15), %rax
testq %rax, %rax
je 0x3a3f1
movq %r12, 0x1e8(%rax)
leaq 0x1e8(%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x576ac
cmpq 0x1b8(%rbx), %r15
jne 0x3a419
movq %r12, 0x1b8(%rbx)
movq %r12, %r15
testq %r12, %r12
jne 0x3a3b3
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x576ac
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_remove_window
NK_LIB void
nk_remove_window(struct nk_context *ctx, struct nk_window *win)
{
    if (win == ctx->begin || win == ctx->end) {
        if (win == ctx->begin) {
            ctx->begin = win->next;
            if (win->next)
                win->next->prev = 0;
        }
        if (win == ctx->end) {
            ctx->end = win->prev;
            if (win->prev)
                win->prev->next = 0;
        }
    } else {
        if (win->next)
            win->next->prev = win->prev;
        if (win->prev)
            win->prev->next = win->next;
    }
    if (win == ctx->active || !ctx->active) {
        ctx->active = ctx->end;
        if (ctx->end)
            ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM;
    }
    win->next = 0;
    win->prev = 0;
    ctx->count--;
}

// Assembly:
movq 0x4768(%rdi), %rax
cmpq %rsi, %rax
je 0x3a479
cmpq %rsi, 0x4770(%rdi)
je 0x3a474
movq 0x1c8(%rsi), %rax
testq %rax, %rax
je 0x3a466
movq 0x1d0(%rsi), %rcx
movq %rcx, 0x1d0(%rax)
movq 0x1d0(%rsi), %rcx
testq %rcx, %rcx
jne 0x3a4b5
jmp 0x3a4bc
cmpq %rsi, %rax
jne 0x3a497
movq 0x1c8(%rsi), %rax
movq %rax, 0x4768(%rdi)
testq %rax, %rax
je 0x3a497
movq $0x0, 0x1d0(%rax)
cmpq %rsi, 0x4770(%rdi)
jne 0x3a4bc
movq 0x1d0(%rsi), %rcx
movq %rcx, 0x4770(%rdi)
testq %rcx, %rcx
je 0x3a4bc
xorl %eax, %eax
movq %rax, 0x1c8(%rcx)
movq 0x4778(%rdi), %rax
cmpq %rsi, %rax
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x3a4ea
movq 0x4770(%rdi), %rax
movq %rax, 0x4778(%rdi)
testq %rax, %rax
je 0x3a4ea
andb $-0x11, 0x49(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rsi)
decl 0x4790(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_find_window
NK_LIB struct nk_window*
nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name)
{
    struct nk_window *iter;
    iter = ctx->begin;
    while (iter) {
        NK_ASSERT(iter != iter->next);
        if (iter->name == hash) {
            int max_len = nk_strlen(iter->name_string);
            if (!nk_stricmpn(iter->name_string, name, max_len))
                return iter;
        }
        iter = iter->next;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4768(%rdi), %r13
testq %r13, %r13
je 0x3ad28
movq %rdx, %rbx
movl %esi, %ebp
movq 0x4d338(%rip), %r15     # 0x87ff0
leaq 0x370eb(%rip), %r12     # 0x71daa
cmpq 0x1c8(%r13), %r13
jne 0x3ace9
movq (%r15), %rdi
leaq 0x370ba(%rip), %rsi     # 0x71d8c
movq %r12, %rdx
movl $0x4f2b, %ecx           # imm = 0x4F2B
xorl %eax, %eax
callq 0x12d80
movq (%r15), %rdi
callq 0x13780
cmpl %ebp, 0x4(%r13)
jne 0x3ad1c
cmpb $0x0, 0x8(%r13)
je 0x3ad06
xorl %edx, %edx
cmpb $0x0, 0x9(%r13,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x3acf8
jmp 0x3ad08
xorl %edx, %edx
leaq 0x8(%r13), %rdi
movq %rbx, %rsi
callq 0x13660
testl %eax, %eax
cmoveq %r13, %r14
je 0x3ad2b
movq 0x1c8(%r13), %r13
testq %r13, %r13
jne 0x3acbf
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_insert_window
NK_LIB void
nk_insert_window(struct nk_context *ctx, struct nk_window *win,
    enum nk_window_insert_location loc)
{
    const struct nk_window *iter;
    NK_ASSERT(ctx);
    NK_ASSERT(win);
    if (!win || !ctx) return;

    iter = ctx->begin;
    while (iter) {
        NK_ASSERT(iter != iter->next);
        NK_ASSERT(iter != win);
        if (iter == win) return;
        iter = iter->next;
    }

    if (!ctx->begin) {
        win->next = 0;
        win->prev = 0;
        ctx->begin = win;
        ctx->end = win;
        ctx->count = 1;
        return;
    }
    if (loc == NK_INSERT_BACK) {
        struct nk_window *end;
        end = ctx->end;
        end->flags |= NK_WINDOW_ROM;
        end->next = win;
        win->prev = ctx->end;
        win->next = 0;
        ctx->end = win;
        ctx->active = ctx->end;
        ctx->end->flags &= ~(nk_flags)NK_WINDOW_ROM;
    } else {
        /*ctx->end->flags |= NK_WINDOW_ROM;*/
        ctx->begin->prev = win;
        win->next = ctx->begin;
        win->prev = 0;
        ctx->begin = win;
        ctx->begin->flags &= ~(nk_flags)NK_WINDOW_ROM;
    }
    ctx->count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x3ade3
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
leaq 0x4768(%rdi), %rax
movq 0x4d284(%rip), %rbp     # 0x87ff0
leaq 0x37019(%rip), %r15     # 0x71d8c
leaq 0x37030(%rip), %r12     # 0x71daa
movq %rax, 0x10(%rsp)
movq (%rax), %r13
testq %r13, %r13
je 0x3ae1d
cmpq 0x1c8(%r13), %r13
jne 0x3adb3
movq (%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x4f40, %ecx           # imm = 0x4F40
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
callq 0x13780
leaq 0x1c8(%r13), %rax
cmpq %r14, %r13
jne 0x3ad7f
movq (%rbp), %rdi
leaq 0x36fc2(%rip), %rsi     # 0x71d8c
leaq 0x36fd9(%rip), %rdx     # 0x71daa
movl $0x4f41, %ecx           # imm = 0x4F41
xorl %eax, %eax
callq 0x12d80
movq (%rbp), %rdi
jmp 0x3ae0a
movq 0x4d206(%rip), %rbx     # 0x87ff0
movq (%rbx), %rdi
leaq 0x36f98(%rip), %rsi     # 0x71d8c
leaq 0x36faf(%rip), %rdx     # 0x71daa
movl $0x4f3b, %ecx           # imm = 0x4F3B
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x3ae4c
cmpl $0x0, 0xc(%rsp)
je 0x3ae71
movq %r14, 0x1d0(%rax)
movq %rax, 0x1c8(%r14)
movq $0x0, 0x1d0(%r14)
jmp 0x3aea6
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%r14)
movq %r14, 0x4768(%rbx)
movq %r14, 0x4770(%rbx)
movl $0x1, 0x4790(%rbx)
jmp 0x3aeb4
movq 0x4770(%rbx), %rax
orl $0x1000, 0x48(%rax)     # imm = 0x1000
movq %r14, 0x1c8(%rax)
movq %rax, 0x1d0(%r14)
movq $0x0, 0x1c8(%r14)
movq %r14, 0x4770(%rbx)
leaq 0x4778(%rbx), %rcx
movq %r14, (%rcx)
andb $-0x11, 0x49(%r14)
incl 0x4790(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_create_panel
NK_LIB void*
nk_create_panel(struct nk_context *ctx)
{
    struct nk_page_element *elem;
    elem = nk_create_page_element(ctx);
    if (!elem) return 0;
    nk_zero_struct(*elem);
    return &elem->data.pan;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x576fb
testq %rax, %rax
je 0x3af06
movq %rax, %rbx
movq %rax, %r14
andq $0x3, %r14
je 0x3af0a
movl $0x4, %r12d
subq %r14, %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
orq $0x204, %r14            # imm = 0x204
movq %rbx, %r15
addq %r12, %r15
jmp 0x3af13
xorl %ebx, %ebx
jmp 0x3af3d
movl $0x208, %r14d           # imm = 0x208
movq %rbx, %r15
movl %r14d, %r12d
andl $-0x4, %r12d
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12b50
andq $0x3, %r14
je 0x3af3d
addq %r12, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x12b50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_bounds
NK_API struct nk_rect
nk_window_get_bounds(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_rect(0,0,0,0);
    return ctx->current->bounds;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c832
movq 0x4b7e3(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35575(%rip), %rsi     # 0x71d8c
leaq 0x3558c(%rip), %rdx     # 0x71daa
movl $0x5035, %ecx           # imm = 0x5035
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3c868
movq 0x4b7ad(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3553f(%rip), %rsi     # 0x71d8c
leaq 0x35556(%rip), %rdx     # 0x71daa
movl $0x5036, %ecx           # imm = 0x5036
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3c88b
movq 0x4780(%rbx), %rax
xorps %xmm1, %xmm1
testq %rax, %rax
je 0x3c88e
movsd 0x4c(%rax), %xmm0
movsd 0x54(%rax), %xmm1
jmp 0x3c88e
xorps %xmm1, %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_position
NK_API struct nk_vec2
nk_window_get_position(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->bounds.x, ctx->current->bounds.y);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c8ce
movq 0x4b747(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x354d9(%rip), %rsi     # 0x71d8c
leaq 0x354f0(%rip), %rdx     # 0x71daa
movl $0x503d, %ecx           # imm = 0x503D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3c904
movq 0x4b711(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x354a3(%rip), %rsi     # 0x71d8c
leaq 0x354ba(%rip), %rdx     # 0x71daa
movl $0x503e, %ecx           # imm = 0x503E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3c91d
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3c91d
movsd 0x4c(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_size
NK_API struct nk_vec2
nk_window_get_size(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->bounds.w, ctx->current->bounds.h);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c95d
movq 0x4b6b8(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3544a(%rip), %rsi     # 0x71d8c
leaq 0x35461(%rip), %rdx     # 0x71daa
movl $0x5045, %ecx           # imm = 0x5045
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3c993
movq 0x4b682(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35414(%rip), %rsi     # 0x71d8c
leaq 0x3542b(%rip), %rdx     # 0x71daa
movl $0x5046, %ecx           # imm = 0x5046
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3c9ac
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3c9ac
movsd 0x54(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_width
NK_API float
nk_window_get_width(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return 0;
    return ctx->current->bounds.w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3c9ec
movq 0x4b629(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x353bb(%rip), %rsi     # 0x71d8c
leaq 0x353d2(%rip), %rdx     # 0x71daa
movl $0x504d, %ecx           # imm = 0x504D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3ca22
movq 0x4b5f3(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35385(%rip), %rsi     # 0x71d8c
leaq 0x3539c(%rip), %rdx     # 0x71daa
movl $0x504e, %ecx           # imm = 0x504E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3ca3b
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3ca3b
movss 0x54(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_height
NK_API float
nk_window_get_height(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return 0;
    return ctx->current->bounds.h;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3ca7b
movq 0x4b59a(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3532c(%rip), %rsi     # 0x71d8c
leaq 0x35343(%rip), %rdx     # 0x71daa
movl $0x5055, %ecx           # imm = 0x5055
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3cab1
movq 0x4b564(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x352f6(%rip), %rsi     # 0x71d8c
leaq 0x3530d(%rip), %rdx     # 0x71daa
movl $0x5056, %ecx           # imm = 0x5056
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3caca
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3caca
movss 0x58(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_content_region
NK_API struct nk_rect
nk_window_get_content_region(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return nk_rect(0,0,0,0);
    return ctx->current->layout->clip;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3cb0a
movq 0x4b50b(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3529d(%rip), %rsi     # 0x71d8c
leaq 0x352b4(%rip), %rdx     # 0x71daa
movl $0x505d, %ecx           # imm = 0x505D
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3cb40
movq 0x4b4d5(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35267(%rip), %rsi     # 0x71d8c
leaq 0x3527e(%rip), %rdx     # 0x71daa
movl $0x505e, %ecx           # imm = 0x505E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3cb6a
movq 0x4780(%rbx), %rax
xorps %xmm1, %xmm1
testq %rax, %rax
je 0x3cb6d
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm0
movsd 0x4c(%rax), %xmm1
jmp 0x3cb6d
xorps %xmm1, %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_content_region_min
NK_API struct nk_vec2
nk_window_get_content_region_min(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->layout->clip.x, ctx->current->layout->clip.y);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3cbad
movq 0x4b468(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x351fa(%rip), %rsi     # 0x71d8c
leaq 0x35211(%rip), %rdx     # 0x71daa
movl $0x5065, %ecx           # imm = 0x5065
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3cbe3
movq 0x4b432(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x351c4(%rip), %rsi     # 0x71d8c
leaq 0x351db(%rip), %rdx     # 0x71daa
movl $0x5066, %ecx           # imm = 0x5066
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3cc20
movq 0x4b3f5(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35187(%rip), %rsi     # 0x71d8c
leaq 0x3519e(%rip), %rdx     # 0x71daa
movl $0x5067, %ecx           # imm = 0x5067
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3cc40
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3cc40
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_content_region_max
NK_API struct nk_vec2
nk_window_get_content_region_max(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->layout->clip.x + ctx->current->layout->clip.w,
        ctx->current->layout->clip.y + ctx->current->layout->clip.h);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3cc80
movq 0x4b395(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35127(%rip), %rsi     # 0x71d8c
leaq 0x3513e(%rip), %rdx     # 0x71daa
movl $0x506e, %ecx           # imm = 0x506E
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3ccb6
movq 0x4b35f(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x350f1(%rip), %rsi     # 0x71d8c
leaq 0x35108(%rip), %rdx     # 0x71daa
movl $0x506f, %ecx           # imm = 0x506F
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3ccf3
movq 0x4b322(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x350b4(%rip), %rsi     # 0x71d8c
leaq 0x350cb(%rip), %rdx     # 0x71daa
movl $0x5070, %ecx           # imm = 0x5070
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3cd1b
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3cd1b
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm1
movsd 0x4c(%rax), %xmm0
addps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_content_region_size
NK_API struct nk_vec2
nk_window_get_content_region_size(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current) return nk_vec2(0,0);
    return nk_vec2(ctx->current->layout->clip.w, ctx->current->layout->clip.h);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3cd5b
movq 0x4b2ba(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x3504c(%rip), %rsi     # 0x71d8c
leaq 0x35063(%rip), %rdx     # 0x71daa
movl $0x5078, %ecx           # imm = 0x5078
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3cd91
movq 0x4b284(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x35016(%rip), %rsi     # 0x71d8c
leaq 0x3502d(%rip), %rdx     # 0x71daa
movl $0x5079, %ecx           # imm = 0x5079
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3cdce
movq 0x4b247(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34fd9(%rip), %rsi     # 0x71d8c
leaq 0x34ff0(%rip), %rdx     # 0x71daa
movl $0x507a, %ecx           # imm = 0x507A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x3cdee
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3cdee
movq 0xa8(%rax), %rax
movsd 0x4c(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_canvas
NK_API struct nk_command_buffer*
nk_window_get_canvas(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current) return 0;
    return &ctx->current->buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3ce2e
movq 0x4b1e7(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34f79(%rip), %rsi     # 0x71d8c
leaq 0x34f90(%rip), %rdx     # 0x71daa
movl $0x5081, %ecx           # imm = 0x5081
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3ce64
movq 0x4b1b1(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34f43(%rip), %rsi     # 0x71d8c
leaq 0x34f5a(%rip), %rdx     # 0x71daa
movl $0x5082, %ecx           # imm = 0x5082
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3cea1
movq 0x4b174(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34f06(%rip), %rsi     # 0x71d8c
leaq 0x34f1d(%rip), %rdx     # 0x71daa
movl $0x5083, %ecx           # imm = 0x5083
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x3ceba
movq 0x4780(%rbx), %rcx
leaq 0x68(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
jmp 0x3cebc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_panel
NK_API struct nk_panel*
nk_window_get_panel(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return 0;
    return ctx->current->layout;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3cefc
movq 0x4b119(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34eab(%rip), %rsi     # 0x71d8c
leaq 0x34ec2(%rip), %rdx     # 0x71daa
movl $0x508a, %ecx           # imm = 0x508A
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3cf32
movq 0x4b0e3(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34e75(%rip), %rsi     # 0x71d8c
leaq 0x34e8c(%rip), %rdx     # 0x71daa
movl $0x508b, %ecx           # imm = 0x508B
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
testq %rbx, %rbx
je 0x3cf4c
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3cf4c
movq 0xa8(%rax), %rax
jmp 0x3cf4e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_get_scroll
NK_API void
nk_window_get_scroll(struct nk_context *ctx, nk_uint *offset_x, nk_uint *offset_y)
{
    struct nk_window *win;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current)
        return ;
    win = ctx->current;
    if (offset_x)
      *offset_x = win->scrollbar.x;
    if (offset_y)
      *offset_y = win->scrollbar.y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
jne 0x3cf9a
movq 0x4b07d(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x34e0e(%rip), %rsi     # 0x71d8c
leaq 0x34e25(%rip), %rdx     # 0x71daa
movl $0x5093, %ecx           # imm = 0x5093
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%r15)
jne 0x3cfd2
movq 0x4b045(%rip), %r12     # 0x87ff0
movq (%r12), %rdi
leaq 0x34dd6(%rip), %rsi     # 0x71d8c
leaq 0x34ded(%rip), %rdx     # 0x71daa
movl $0x5094, %ecx           # imm = 0x5094
xorl %eax, %eax
callq 0x12d80
movq (%r12), %rdi
callq 0x13780
testq %r15, %r15
je 0x3cff8
movq 0x4780(%r15), %rax
testq %rax, %rax
je 0x3cff8
testq %r14, %r14
je 0x3cfee
movl 0x5c(%rax), %ecx
movl %ecx, (%r14)
testq %rbx, %rbx
je 0x3cff8
movl 0x60(%rax), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_has_focus
NK_API nk_bool
nk_window_has_focus(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current) return 0;
    return ctx->current == ctx->active;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3d03c
movq 0x4afd9(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34d6b(%rip), %rsi     # 0x71d8c
leaq 0x34d82(%rip), %rdx     # 0x71daa
movl $0x50a0, %ecx           # imm = 0x50A0
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3d072
movq 0x4afa3(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34d35(%rip), %rsi     # 0x71d8c
leaq 0x34d4c(%rip), %rdx     # 0x71daa
movl $0x50a1, %ecx           # imm = 0x50A1
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3d0af
movq 0x4af66(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34cf8(%rip), %rsi     # 0x71d8c
leaq 0x34d0f(%rip), %rdx     # 0x71daa
movl $0x50a2, %ecx           # imm = 0x50A2
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorl %eax, %eax
testq %rbx, %rbx
je 0x3d0ce
movq 0x4780(%rbx), %rcx
testq %rcx, %rcx
je 0x3d0ce
xorl %eax, %eax
cmpq 0x4778(%rbx), %rcx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_is_hovered
NK_API nk_bool
nk_window_is_hovered(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current || (ctx->current->flags & NK_WINDOW_HIDDEN))
        return 0;
    else {
        struct nk_rect actual_bounds = ctx->current->bounds;
        if (ctx->begin->flags & NK_WINDOW_MINIMIZED) {
            actual_bounds.h = ctx->current->layout->header_height;
        }
        return nk_input_is_mouse_hovering_rect(&ctx->input, actual_bounds);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3d10e
movq 0x4af07(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34c99(%rip), %rsi     # 0x71d8c
leaq 0x34cb0(%rip), %rdx     # 0x71daa
movl $0x50a9, %ecx           # imm = 0x50A9
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
cmpq $0x0, 0x4780(%rbx)
jne 0x3d144
movq 0x4aed1(%rip), %r14     # 0x87ff0
movq (%r14), %rdi
leaq 0x34c63(%rip), %rsi     # 0x71d8c
leaq 0x34c7a(%rip), %rdx     # 0x71daa
movl $0x50aa, %ecx           # imm = 0x50AA
xorl %eax, %eax
callq 0x12d80
movq (%r14), %rdi
callq 0x13780
xorl %eax, %eax
testq %rbx, %rbx
je 0x3d1c6
movq 0x4780(%rbx), %rcx
testq %rcx, %rcx
je 0x3d1c6
testb $0x20, 0x49(%rcx)
jne 0x3d1c6
movsd 0x4c(%rcx), %xmm0
movsd 0x54(%rcx), %xmm1
movq 0x4768(%rbx), %rdx
testb $-0x80, 0x49(%rdx)
je 0x3d18a
movq 0xa8(%rcx), %rcx
movss 0x38(%rcx), %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm2     # xmm2 = xmm2[2,0],xmm1[2,3]
movaps %xmm2, %xmm1
movss 0x144(%rbx), %xmm2
ucomiss %xmm0, %xmm2
jb 0x3d1c6
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
ucomiss %xmm2, %xmm3
jbe 0x3d1c6
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss 0x148(%rbx), %xmm2
ucomiss %xmm3, %xmm2
jb 0x3d1c6
addps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorl %eax, %eax
ucomiss %xmm2, %xmm0
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq