LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x35b07
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2fc8(%rdi), %eax
cmpl $0x8, %eax
jl 0x35acd
movq 0x4f556(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x34268(%rip), %rsi     # 0x69d0c
leaq 0x3427f(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x49de, %ecx           # imm = 0x49DE
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movl 0x2fc8(%r14), %eax
cmpl $0x7, %eax
jg 0x35b35
leal 0x1(%rax), %ecx
movl %ecx, 0x2fc8(%r14)
cltq
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)
pushq $0x1
popq %rbp
jmp 0x35b35
movq 0x4f4e2(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x341f4(%rip), %rsi     # 0x69d0c
leaq 0x3420b(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x49da, %ecx           # imm = 0x49DA
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
movl %ebp, %eax
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_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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x35bb4
movq %rdi, %rbx
movl 0x2fc8(%rdi), %eax
testl %eax, %eax
jg 0x35b90
movq 0x4f491(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x341a3(%rip), %rsi     # 0x69d0c
leaq 0x341ba(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x49f2, %ecx           # imm = 0x49F2
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movl 0x2fc8(%rbx), %eax
testl %eax, %eax
jle 0x35be2
decl %eax
movl %eax, 0x2fc8(%rbx)
shlq $0x4, %rax
movq 0x2fd0(%rbx,%rax), %rcx
movq 0x2fd8(%rbx,%rax), %rax
movq %rax, (%rcx)
pushq $0x1
popq %rbp
jmp 0x35be2
movq 0x4f435(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x34147(%rip), %rsi     # 0x69d0c
leaq 0x3415e(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x49ee, %ecx           # imm = 0x49EE
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3637a
movl %esi, %eax
movq 0x170(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x363aa
movq %rax, 0x1a8(%rdi)
pushq $0x1
popq %rbx
jmp 0x363ac
movq 0x4ec6f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x33981(%rip), %rsi     # 0x69d0c
leaq 0x33998(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x4a2a, %ecx           # imm = 0x4A2A
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x363ac
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36430
xorl %eax, %eax
cmpq $0x7, %rax
je 0x36425
movq %rsi, 0x170(%rdi,%rax,8)
incq %rax
addq $0x28, %rsi
jmp 0x3640e
movl $0x1, 0x1b8(%rdi)
retq
pushq %rbx
movq 0x4ebb8(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x338ca(%rip), %rsi     # 0x69d0c
leaq 0x338e1(%rip), %rdx     # 0x69d2a
movl $0x4a4c, %ecx           # imm = 0x4A4C
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsi)
leaq -0x126c3(%rip), %rax    # 0x23db0
movq %rax, 0x8(%rsi)
leaq -0x126c6(%rip), %rax    # 0x23db8
movq %rax, 0x10(%rsi)
callq 0x14240
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x364d5
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x3657c
leaq 0x2508(%rbx), %rdi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0x12e80
leaq 0x4720(%rbx), %rdi
movq %r14, %rsi
callq 0x3674a
movl $0x1, 0x471c(%rbx)
pushq $0x1
popq %rbx
jmp 0x36503
movq 0x4eb14(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x33826(%rip), %rsi     # 0x69d0c
leaq 0x3383d(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x4a99, %ecx           # imm = 0x4A99
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36546
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x3657c
leaq 0x2508(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x126f0
andl $0x0, 0x471c(%rbx)
pushq $0x1
popq %rbx
jmp 0x36574
movq 0x4eaa3(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x337b5(%rip), %rsi     # 0x69d0c
leaq 0x337cc(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x4a79, %ecx           # imm = 0x4A79
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x365c9
movq %rsi, %r14
movq %rdi, %rbx
movl $0x4798, %esi           # imm = 0x4798
callq 0x23ed0
movq %rbx, %rdi
callq 0x12240
movl $0x1, 0x4794(%rbx)
testq %r14, %r14
je 0x365b3
movq %r14, 0x168(%rbx)
addq $0x30e0, %rbx           # imm = 0x30E0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x131e0
movq 0x4ea20(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x33732(%rip), %rsi     # 0x69d0c
leaq 0x33749(%rip), %rdx     # 0x69d2a
movl $0x4a60, %ecx           # imm = 0x4A60
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdx, %r14
testq %rsi, %rsi
je 0x3664f
testq %r14, %r14
je 0x36686
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x3657c
leaq 0x2508(%rbx), %rdi
pushq $0xf
popq %rcx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpl $0x0, 0x38(%r14)
je 0x366b9
addq $0x20, %r14
leaq 0x4720(%rbx), %rdi
movq %r14, %rsi
callq 0x3674a
jmp 0x36735
movq 0x4e99a(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x336ac(%rip), %rsi     # 0x69d0c
leaq 0x336c3(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x4a84, %ecx           # imm = 0x4A84
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
testq %r14, %r14
jne 0x36742
movq 0x4e963(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x33675(%rip), %rsi     # 0x69d0c
leaq 0x3368c(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x4a85, %ecx           # imm = 0x4A85
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x36742
leaq 0x4720(%rbx), %rdi
movq 0x40(%r14), %r15
movq 0x48(%r14), %r14
pushq $0x48
popq %rsi
callq 0x23ed0
cmpq $0x217, %r14            # imm = 0x217
jbe 0x36709
leaq -0x218(%r14), %rax
movl $0x208, %ecx            # imm = 0x208
xorl %edx, %edx
divq %rcx
incl %eax
movl %eax, 0x4750(%rbx)
movq %r15, 0x4740(%rbx)
andl $0x0, 0x4738(%rbx)
movq %r14, 0x4758(%rbx)
jmp 0x36735
movq 0x4e8e0(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x335f2(%rip), %rsi     # 0x69d0c
leaq 0x33609(%rip), %rdx     # 0x69d2a
movl $0x4bd2, %ecx           # imm = 0x4BD2
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movl $0x1, 0x471c(%rbx)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_pool_init
NK_LIB void
nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc,
    unsigned int capacity)
{
    NK_ASSERT(capacity >= 1);
    nk_zero(pool, sizeof(*pool));
    pool->alloc = *alloc;
    pool->capacity = capacity;
    pool->type = NK_BUFFER_DYNAMIC;
    pool->pages = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x48
popq %rsi
callq 0x23ed0
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movups (%rbx), %xmm0
movups %xmm0, (%r14)
movl $0x10, 0x30(%r14)
movl $0x1, 0x18(%r14)
andq $0x0, 0x20(%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_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 %rbx
testq %rdi, %rdi
je 0x3682a
movq %rdi, %rbx
leaq 0x2508(%rdi), %r14
movq %r14, %rdi
callq 0x13f80
cmpl $0x0, 0x471c(%rbx)
je 0x367dc
cmpl $0x0, 0x4738(%rbx)
je 0x367dc
movq 0x4740(%rbx), %rsi
testq %rsi, %rsi
je 0x367dc
movq 0x8(%rsi), %r15
movq 0x4720(%rbx), %rdi
callq *0x4730(%rbx)
movq %r15, %rsi
jmp 0x367c1
movl $0x168, %esi            # imm = 0x168
movq %rbx, %rdi
callq 0x23ed0
leaq 0x168(%rbx), %rdi
movl $0x23a0, %esi           # imm = 0x23A0
callq 0x23ed0
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x23ed0
andl $0x0, 0x4718(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4768(%rbx)
movups %xmm0, 0x4778(%rbx)
movups %xmm0, 0x4788(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x4e7bf(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x334d1(%rip), %rsi     # 0x69d0c
leaq 0x334e8(%rip), %rdx     # 0x69d2a
movl $0x4aae, %ecx           # imm = 0x4AAE
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13960
// File: /workspace/github_c_makefile_star2_O2/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 0x36a73
movq %r14, %rdi
callq 0x36a42
andq $0x0, 0x120(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rbx)
testq %r15, %r15
je 0x36ab7
movq 0x1e8(%r15), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36acd
movq %r14, %rdi
movq %r15, %rsi
callq 0x51795
cmpq 0x1b8(%rbx), %r15
movq %r12, %r15
jne 0x36a7d
movq %r12, 0x1b8(%rbx)
movq %r12, %r15
jmp 0x36a7d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51795
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_remove_table
NK_LIB void
nk_remove_table(struct nk_window *win, struct nk_table *tbl)
{
    if (win->tables == tbl)
        win->tables = tbl->next;
    if (tbl->next)
        tbl->next->prev = tbl->prev;
    if (tbl->prev)
        tbl->prev->next = tbl->next;
    tbl->next = 0;
    tbl->prev = 0;
}

// Assembly:
movq 0x1e8(%rsi), %rax
cmpq %rsi, 0x1b8(%rdi)
jne 0x36ae4
movq %rax, 0x1b8(%rdi)
movq 0x1f0(%rsi), %rcx
testq %rax, %rax
je 0x36af7
movq %rcx, 0x1f0(%rax)
testq %rcx, %rcx
je 0x36b03
movq %rax, 0x1e8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1e8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq %rsi, 0x4768(%rdi)
je 0x36b42
movq 0x4770(%rdi), %rcx
cmpq %rsi, %rcx
je 0x36b5d
movq 0x1c8(%rsi), %rdx
movq 0x1d0(%rsi), %rax
testq %rdx, %rdx
je 0x36b3d
movq %rax, 0x1d0(%rdx)
movq %rcx, %r8
jmp 0x36b82
movq 0x1c8(%rsi), %rax
movq %rax, 0x4768(%rdi)
testq %rax, %rax
je 0x36b5d
andq $0x0, 0x1d0(%rax)
movq 0x4770(%rdi), %r8
cmpq %rsi, %r8
jne 0x36b91
movq 0x1d0(%rsi), %rax
movq %rax, 0x4770(%rdi)
xorl %edx, %edx
movq %rax, %rcx
movl $0x0, %r8d
testq %rax, %rax
je 0x36b91
movq %rdx, 0x1c8(%rax)
movq %rcx, %r8
movq 0x4778(%rdi), %rax
cmpq %rsi, %rax
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x36bb9
movq %r8, 0x4778(%rdi)
testq %r8, %r8
je 0x36bb9
andb $-0x11, 0x49(%r8)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rsi)
decl 0x4790(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r13
addq $0x4768, %r13           # imm = 0x4768
movq 0x4dcff(%rip), %r15     # 0x84ff0
movq (%r13), %r12
testq %r12, %r12
je 0x37356
cmpq 0x1c8(%r12), %r12
jne 0x37329
movq (%r15), %rdi
leaq 0x329fe(%rip), %rsi     # 0x69d0c
leaq 0x32a15(%rip), %rdx     # 0x69d2a
movl $0x4f2b, %ecx           # imm = 0x4F2B
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
leaq 0x1c8(%r12), %r13
cmpl %ebp, 0x4(%r12)
jne 0x372f1
leaq 0x8(%r12), %r14
movq %r14, %rdi
callq 0x13040
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x13830
testl %eax, %eax
jne 0x372f1
movq %r12, %rax
addq $0x8, %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_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 0x37426
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
leaq 0x4768(%rdi), %rax
movq 0x4dc41(%rip), %rbp     # 0x84ff0
leaq 0x32956(%rip), %r15     # 0x69d0c
leaq 0x3296d(%rip), %r12     # 0x69d2a
movq %rax, 0x10(%rsp)
movq (%rax), %r13
testq %r13, %r13
je 0x37460
cmpq 0x1c8(%r13), %r13
jne 0x373f6
movq (%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x4f40, %ecx           # imm = 0x4F40
xorl %eax, %eax
callq 0x12ea0
movq (%rbp), %rdi
callq 0x13960
leaq 0x1c8(%r13), %rax
cmpq %r14, %r13
jne 0x373c2
movq (%rbp), %rdi
leaq 0x328ff(%rip), %rsi     # 0x69d0c
leaq 0x32916(%rip), %rdx     # 0x69d2a
movl $0x4f41, %ecx           # imm = 0x4F41
xorl %eax, %eax
callq 0x12ea0
movq (%rbp), %rdi
jmp 0x3744d
movq 0x4dbc3(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x328d5(%rip), %rsi     # 0x69d0c
leaq 0x328ec(%rip), %rdx     # 0x69d2a
movl $0x4f3b, %ecx           # imm = 0x4F3B
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13960
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x3748c
cmpl $0x0, 0xc(%rsp)
je 0x374b1
movq %r14, 0x1d0(%rax)
movq %rax, 0x1c8(%r14)
andq $0x0, 0x1d0(%r14)
jmp 0x374e3
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%r14)
movq %r14, 0x4768(%rbx)
movq %r14, 0x4770(%rbx)
movl $0x1, 0x4790(%rbx)
jmp 0x374f1
movq 0x4770(%rbx), %rax
orl $0x1000, 0x48(%rax)     # imm = 0x1000
movq %r14, 0x1c8(%rax)
movq %rax, 0x1d0(%r14)
andq $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_O2/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 0x38c0c
movq 0x4c409(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x3111b(%rip), %rsi     # 0x69d0c
leaq 0x31132(%rip), %rdx     # 0x69d2a
movl $0x5035, %ecx           # imm = 0x5035
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38c50
movq 0x4c3d1(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x310e3(%rip), %rsi     # 0x69d0c
leaq 0x310fa(%rip), %rdx     # 0x69d2a
movl $0x5036, %ecx           # imm = 0x5036
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38c62
movsd 0x4c(%rax), %xmm0
movsd 0x54(%rax), %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
jmp 0x38c5a
// File: /workspace/github_c_makefile_star2_O2/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 0x38ca2
movq 0x4c373(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x31085(%rip), %rsi     # 0x69d0c
leaq 0x3109c(%rip), %rdx     # 0x69d2a
movl $0x503d, %ecx           # imm = 0x503D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38ce6
movq 0x4c33b(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x3104d(%rip), %rsi     # 0x69d0c
leaq 0x31064(%rip), %rdx     # 0x69d2a
movl $0x503e, %ecx           # imm = 0x503E
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38cf3
movsd 0x4c(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x38ceb
// File: /workspace/github_c_makefile_star2_O2/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 0x38d30
movq 0x4c2e5(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30ff7(%rip), %rsi     # 0x69d0c
leaq 0x3100e(%rip), %rdx     # 0x69d2a
movl $0x5045, %ecx           # imm = 0x5045
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38d74
movq 0x4c2ad(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30fbf(%rip), %rsi     # 0x69d0c
leaq 0x30fd6(%rip), %rdx     # 0x69d2a
movl $0x5046, %ecx           # imm = 0x5046
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38d81
movsd 0x54(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x38d79
// File: /workspace/github_c_makefile_star2_O2/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 0x38dbe
movq 0x4c257(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30f69(%rip), %rsi     # 0x69d0c
leaq 0x30f80(%rip), %rdx     # 0x69d2a
movl $0x504d, %ecx           # imm = 0x504D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38e02
movq 0x4c21f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30f31(%rip), %rsi     # 0x69d0c
leaq 0x30f48(%rip), %rdx     # 0x69d2a
movl $0x504e, %ecx           # imm = 0x504E
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38e0f
movss 0x54(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x38e07
// File: /workspace/github_c_makefile_star2_O2/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 0x38e4c
movq 0x4c1c9(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30edb(%rip), %rsi     # 0x69d0c
leaq 0x30ef2(%rip), %rdx     # 0x69d2a
movl $0x5055, %ecx           # imm = 0x5055
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38e90
movq 0x4c191(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30ea3(%rip), %rsi     # 0x69d0c
leaq 0x30eba(%rip), %rdx     # 0x69d2a
movl $0x5056, %ecx           # imm = 0x5056
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38e9d
movss 0x58(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x38e95
// File: /workspace/github_c_makefile_star2_O2/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 0x38eda
movq 0x4c13b(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30e4d(%rip), %rsi     # 0x69d0c
leaq 0x30e64(%rip), %rdx     # 0x69d2a
movl $0x505d, %ecx           # imm = 0x505D
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38f1e
movq 0x4c103(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30e15(%rip), %rsi     # 0x69d0c
leaq 0x30e2c(%rip), %rdx     # 0x69d2a
movl $0x505e, %ecx           # imm = 0x505E
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x38f37
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm0
movsd 0x4c(%rax), %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
jmp 0x38f2f
// File: /workspace/github_c_makefile_star2_O2/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 0x38f77
movq 0x4c09e(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30db0(%rip), %rsi     # 0x69d0c
leaq 0x30dc7(%rip), %rdx     # 0x69d2a
movl $0x5065, %ecx           # imm = 0x5065
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x38fb6
movq 0x4c066(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30d78(%rip), %rsi     # 0x69d0c
leaq 0x30d8f(%rip), %rdx     # 0x69d2a
movl $0x5066, %ecx           # imm = 0x5066
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x38ff8
movq 0x4c029(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30d3b(%rip), %rsi     # 0x69d0c
leaq 0x30d52(%rip), %rdx     # 0x69d2a
movl $0x5067, %ecx           # imm = 0x5067
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3900c
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x39004
// File: /workspace/github_c_makefile_star2_O2/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 0x39049
movq 0x4bfcc(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30cde(%rip), %rsi     # 0x69d0c
leaq 0x30cf5(%rip), %rdx     # 0x69d2a
movl $0x506e, %ecx           # imm = 0x506E
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x39088
movq 0x4bf94(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30ca6(%rip), %rsi     # 0x69d0c
leaq 0x30cbd(%rip), %rdx     # 0x69d2a
movl $0x506f, %ecx           # imm = 0x506F
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x390ca
movq 0x4bf57(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30c69(%rip), %rsi     # 0x69d0c
leaq 0x30c80(%rip), %rdx     # 0x69d2a
movl $0x5070, %ecx           # imm = 0x5070
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x390e6
movq 0xa8(%rax), %rax
movsd 0x44(%rax), %xmm1
movsd 0x4c(%rax), %xmm0
addps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x390de
// File: /workspace/github_c_makefile_star2_O2/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 0x39123
movq 0x4bef2(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30c04(%rip), %rsi     # 0x69d0c
leaq 0x30c1b(%rip), %rdx     # 0x69d2a
movl $0x5078, %ecx           # imm = 0x5078
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x39162
movq 0x4beba(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30bcc(%rip), %rsi     # 0x69d0c
leaq 0x30be3(%rip), %rdx     # 0x69d2a
movl $0x5079, %ecx           # imm = 0x5079
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x391a4
movq 0x4be7d(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30b8f(%rip), %rsi     # 0x69d0c
leaq 0x30ba6(%rip), %rdx     # 0x69d2a
movl $0x507a, %ecx           # imm = 0x507A
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x391b8
movq 0xa8(%rax), %rax
movsd 0x4c(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
jmp 0x391b0
// File: /workspace/github_c_makefile_star2_O2/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 0x391f5
movq 0x4be20(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30b32(%rip), %rsi     # 0x69d0c
leaq 0x30b49(%rip), %rdx     # 0x69d2a
movl $0x5081, %ecx           # imm = 0x5081
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rcx
testq %rcx, %rcx
jne 0x39234
movq 0x4bde8(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30afa(%rip), %rsi     # 0x69d0c
leaq 0x30b11(%rip), %rdx     # 0x69d2a
movl $0x5082, %ecx           # imm = 0x5082
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rcx
cmpq $0x0, 0xa8(%rcx)
jne 0x39271
movq 0x4bdab(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30abd(%rip), %rsi     # 0x69d0c
leaq 0x30ad4(%rip), %rdx     # 0x69d2a
movl $0x5083, %ecx           # imm = 0x5083
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rcx
leaq 0x68(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %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_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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x392bd
movq 0x4bd58(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30a6a(%rip), %rsi     # 0x69d0c
leaq 0x30a81(%rip), %rdx     # 0x69d2a
movl $0x508a, %ecx           # imm = 0x508A
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x39304
movq 0x4bd20(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x30a32(%rip), %rsi     # 0x69d0c
leaq 0x30a49(%rip), %rdx     # 0x69d2a
xorl %r14d, %r14d
movl $0x508b, %ecx           # imm = 0x508B
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3930b
movq 0xa8(%rax), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39358
movq 0x4bcbf(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x309d0(%rip), %rsi     # 0x69d0c
leaq 0x309e7(%rip), %rdx     # 0x69d2a
movl $0x5093, %ecx           # imm = 0x5093
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r15), %rax
testq %rax, %rax
jne 0x3939e
movq 0x4bc85(%rip), %r12     # 0x84ff0
movq (%r12), %rdi
leaq 0x30996(%rip), %rsi     # 0x69d0c
leaq 0x309ad(%rip), %rdx     # 0x69d2a
movl $0x5094, %ecx           # imm = 0x5094
xorl %eax, %eax
callq 0x12ea0
movq (%r12), %rdi
callq 0x13960
movq 0x4780(%r15), %rax
testq %rax, %rax
je 0x393b3
testq %r14, %r14
je 0x393a9
movl 0x5c(%rax), %ecx
movl %ecx, (%r14)
testq %rbx, %rbx
je 0x393b3
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_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x393f7
movq 0x4bc1e(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30930(%rip), %rsi     # 0x69d0c
leaq 0x30947(%rip), %rdx     # 0x69d2a
movl $0x50a0, %ecx           # imm = 0x50A0
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x39436
movq 0x4bbe6(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x308f8(%rip), %rsi     # 0x69d0c
leaq 0x3090f(%rip), %rdx     # 0x69d2a
movl $0x50a1, %ecx           # imm = 0x50A1
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3947a
movq 0x4bba9(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x308bb(%rip), %rsi     # 0x69d0c
leaq 0x308d2(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x50a2, %ecx           # imm = 0x50A2
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x39487
xorl %ebp, %ebp
cmpq 0x4778(%rbx), %rax
sete %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x394c6
movq 0x4bb4f(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30861(%rip), %rsi     # 0x69d0c
leaq 0x30878(%rip), %rdx     # 0x69d2a
movl $0x50a9, %ecx           # imm = 0x50A9
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
jne 0x3950a
movq 0x4bb17(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30829(%rip), %rsi     # 0x69d0c
leaq 0x30840(%rip), %rdx     # 0x69d2a
movl $0x50aa, %ecx           # imm = 0x50AA
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
testq %rax, %rax
je 0x3954c
testb $0x20, 0x49(%rax)
jne 0x3954c
movsd 0x4c(%rax), %xmm0
movsd 0x54(%rax), %xmm1
movq 0x4768(%rbx), %rcx
testb $-0x80, 0x49(%rcx)
je 0x3953d
movq 0xa8(%rax), %rax
movss 0x38(%rax), %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm2     # xmm2 = xmm2[2,0],xmm1[2,3]
movaps %xmm2, %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x143d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_is_any_hovered
NK_API nk_bool
nk_window_is_any_hovered(struct nk_context *ctx)
{
    struct nk_window *iter;
    NK_ASSERT(ctx);
    if (!ctx) return 0;
    iter = ctx->begin;
    while (iter) {
        /* check if window is being hovered */
        if(!(iter->flags & NK_WINDOW_HIDDEN)) {
            /* check if window popup is being hovered */
            if (iter->popup.active && iter->popup.win && nk_input_is_mouse_hovering_rect(&ctx->input, iter->popup.win->bounds))
                return 1;

            if (iter->flags & NK_WINDOW_MINIMIZED) {
                struct nk_rect header = iter->bounds;
                header.h = ctx->style.font->height + 2 * ctx->style.window.header.padding.y;
                if (nk_input_is_mouse_hovering_rect(&ctx->input, header))
                    return 1;
            } else if (nk_input_is_mouse_hovering_rect(&ctx->input, iter->bounds)) {
                return 1;
            }
        }
        iter = iter->next;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3960a
movq %rdi, %r14
leaq 0x4768(%rdi), %r15
pushq $0x1
popq %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x3963a
movl 0x48(%r15), %ebp
btl $0xd, %ebp
jb 0x395fe
cmpl $0x0, 0x15c(%r15)
je 0x395b9
movq 0x120(%r15), %rax
testq %rax, %rax
je 0x395b9
movsd 0x4c(%rax), %xmm0
movsd 0x54(%rax), %xmm1
movq %r14, %rdi
callq 0x143d0
testl %eax, %eax
jne 0x3963c
movsd 0x4c(%r15), %xmm0
movsd 0x54(%r15), %xmm1
testw %bp, %bp
js 0x395cf
movq %r14, %rdi
jmp 0x395f5
movq 0x168(%r14), %rax
movss 0x2408(%r14), %xmm2
addss %xmm2, %xmm2
addss 0x8(%rax), %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm2     # xmm2 = xmm2[2,0],xmm1[2,3]
movq %r14, %rdi
movaps %xmm2, %xmm1
callq 0x143d0
testl %eax, %eax
jne 0x3963c
addq $0x1c8, %r15            # imm = 0x1C8
jmp 0x39573
movq 0x4b9df(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x306f1(%rip), %rsi     # 0x69d0c
leaq 0x30708(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x50b9, %ecx           # imm = 0x50B9
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x3963c
xorl %ebx, %ebx
movl %ebx, %eax
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_window_is_collapsed
NK_API nk_bool
nk_window_is_collapsed(struct nk_context *ctx, const char *name)
{
    int title_len;
    nk_hash title_hash;
    struct nk_window *win;
    NK_ASSERT(ctx);
    if (!ctx) return 0;

    title_len = (int)nk_strlen(name);
    title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
    win = nk_find_window(ctx, title_hash, name);
    if (!win) return 0;
    return win->flags & NK_WINDOW_MINIMIZED;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x396a6
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x13040
pushq $0x40
popq %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x125c0
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x372d0
testq %rax, %rax
je 0x396d6
movl $0x8000, %ebx           # imm = 0x8000
andl 0x48(%rax), %ebx
jmp 0x396d8
movq 0x4b943(%rip), %r14     # 0x84ff0
movq (%r14), %rdi
leaq 0x30655(%rip), %rsi     # 0x69d0c
leaq 0x3066c(%rip), %rdx     # 0x69d2a
xorl %ebx, %ebx
movl $0x50dd, %ecx           # imm = 0x50DD
xorl %eax, %eax
callq 0x12ea0
movq (%r14), %rdi
callq 0x13960
jmp 0x396d8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_is_closed
NK_API nk_bool
nk_window_is_closed(struct nk_context *ctx, const char *name)
{
    int title_len;
    nk_hash title_hash;
    struct nk_window *win;
    NK_ASSERT(ctx);
    if (!ctx) return 1;

    title_len = (int)nk_strlen(name);
    title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
    win = nk_find_window(ctx, title_hash, name);
    if (!win) return 1;
    return (win->flags & NK_WINDOW_CLOSED);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x39725
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x13040
pushq $0x40
popq %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x125c0
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x372d0
testq %rax, %rax
je 0x39751
movq %rax, %rcx
movl $0x4000, %eax           # imm = 0x4000
andl 0x48(%rcx), %eax
jmp 0x39754
movq 0x4b8c4(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x305d6(%rip), %rsi     # 0x69d0c
leaq 0x305ed(%rip), %rdx     # 0x69d2a
movl $0x50ec, %ecx           # imm = 0x50EC
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
pushq $0x1
popq %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_window_is_active
NK_API nk_bool
nk_window_is_active(struct nk_context *ctx, const char *name)
{
    int title_len;
    nk_hash title_hash;
    struct nk_window *win;
    NK_ASSERT(ctx);
    if (!ctx) return 0;

    title_len = (int)nk_strlen(name);
    title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
    win = nk_find_window(ctx, title_hash, name);
    if (!win) return 0;
    return win == ctx->active;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3981b
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x13040
pushq $0x40
popq %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x125c0
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x372d0
xorl %ebp, %ebp
testq %rax, %rax
je 0x39849
cmpq 0x4778(%rbx), %rax
sete %bpl
jmp 0x39849
movq 0x4b7ce(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x304e0(%rip), %rsi     # 0x69d0c
leaq 0x304f7(%rip), %rdx     # 0x69d2a
xorl %ebp, %ebp
movl $0x510a, %ecx           # imm = 0x510A
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
callq 0x13960
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_window_close
NK_API void
nk_window_close(struct nk_context *ctx, const char *name)
{
    struct nk_window *win;
    NK_ASSERT(ctx);
    if (!ctx) return;
    win = nk_window_find(ctx, name);
    if (!win) return;
    NK_ASSERT(ctx->current != win && "You cannot close a currently active window");
    if (ctx->current == win) return;
    win->flags |= NK_WINDOW_HIDDEN;
    win->flags |= NK_WINDOW_CLOSED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x398ec
movq %rdi, %rbx
callq 0x12ac0
testq %rax, %rax
je 0x398e6
movq %rax, %r14
movq 0x4780(%rbx), %rax
cmpq %r14, %rax
jne 0x398dc
movq 0x4b740(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
leaq 0x30452(%rip), %rsi     # 0x69d0c
leaq 0x30469(%rip), %rdx     # 0x69d2a
movl $0x5124, %ecx           # imm = 0x5124
xorl %eax, %eax
callq 0x12ea0
movq (%r15), %rdi
callq 0x13960
movq 0x4780(%rbx), %rax
cmpq %r14, %rax
je 0x398e6
orb $0x60, 0x49(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq 0x4b6fd(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x3040f(%rip), %rsi     # 0x69d0c
leaq 0x30426(%rip), %rdx     # 0x69d2a
movl $0x5120, %ecx           # imm = 0x5120
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13960