LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_clear_state
NK_LIB void
nk_textedit_clear_state(struct nk_text_edit *state, enum nk_text_edit_type type,
    nk_plugin_filter filter)
{
    /* reset the state to default */
   state->undo.undo_point = 0;
   state->undo.undo_char_point = 0;
   state->undo.redo_point = NK_TEXTEDIT_UNDOSTATECOUNT;
   state->undo.redo_char_point = NK_TEXTEDIT_UNDOCHARCOUNT;
   state->select_end = state->select_start = 0;
   state->cursor = 0;
   state->has_preferred_x = 0;
   state->preferred_x = 0;
   state->cursor_at_end_of_line = 0;
   state->initialized = 1;
   state->single_line = (unsigned char)(type == NK_TEXT_EDIT_SINGLE_LINE);
   state->mode = NK_TEXT_EDIT_MODE_VIEW;
   state->filter = filter;
   state->scrollbar = nk_vec2(0,0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movw $0x0, 0x1500(%rax)
movq 0x20(%rsp), %rax
movw $0x0, 0x1504(%rax)
movq 0x20(%rsp), %rax
movw $0x63, 0x1502(%rax)
movq 0x20(%rsp), %rax
movw $0x3e7, 0x1506(%rax)    # imm = 0x3E7
movq 0x20(%rsp), %rax
movl $0x0, 0xac(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0xb0(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0xa8(%rax)
movq 0x20(%rsp), %rax
movb $0x0, 0xb7(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0xbc(%rax)
movq 0x20(%rsp), %rax
movb $0x0, 0xb5(%rax)
movq 0x20(%rsp), %rax
movb $0x1, 0xb6(%rax)
movl 0x1c(%rsp), %eax
testl %eax, %eax
movq 0x20(%rsp), %rax
sete 0xb8(%rax)
movq 0x20(%rsp), %rax
movb $0x0, 0xb4(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x13460
movq (%rsp), %rax
movlpd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0xa0(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_init
NK_API void
nk_textedit_init(struct nk_text_edit *state, struct nk_allocator *alloc, nk_size size)
{
    NK_ASSERT(state);
    NK_ASSERT(alloc);
    if (!state || !alloc) return;
    NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
    nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
    nk_str_init(&state->string, alloc, size);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x705fd
movq 0x54a1f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x40dc5(%rip), %rsi     # 0xb13a0
leaq 0x40ddc(%rip), %rdx     # 0xb13be
movl $0x6a49, %ecx           # imm = 0x6A49
movb $0x0, %al
callq 0x13ec0
movq 0x549fb(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x705ff
jmp 0x70601
cmpq $0x0, 0x8(%rsp)
jne 0x7063c
movq 0x549e0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x40d86(%rip), %rsi     # 0xb13a0
leaq 0x40d9d(%rip), %rdx     # 0xb13be
movl $0x6a4a, %ecx           # imm = 0x6A4A
movb $0x0, %al
callq 0x13ec0
movq 0x549bc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x7063e
cmpq $0x0, 0x10(%rsp)
je 0x7064e
cmpq $0x0, 0x8(%rsp)
jne 0x70650
jmp 0x70688
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x1508, %edx           # imm = 0x1508
callq 0x49d50
movq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x704a0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x14b50
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_init_default
NK_API void
nk_textedit_init_default(struct nk_text_edit *state)
{
    NK_ASSERT(state);
    if (!state) return;
    NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
    nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
    nk_str_init_default(&state->string);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x706cf
movq 0x5494d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x40cf3(%rip), %rsi     # 0xb13a0
leaq 0x40d0a(%rip), %rdx     # 0xb13be
movl $0x6a54, %ecx           # imm = 0x6A54
movb $0x0, %al
callq 0x13ec0
movq 0x54929(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x706d1
cmpq $0x0, (%rsp)
jne 0x706da
jmp 0x70706
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x1508, %edx           # imm = 0x1508
callq 0x49d50
movq (%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x704a0
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x149c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_filter_hex
NK_API nk_bool
nk_filter_hex(const struct nk_text_edit *box, nk_rune unicode)
{
    NK_UNUSED(box);
    if ((unicode < '0' || unicode > '9') &&
        (unicode < 'a' || unicode > 'f') &&
        (unicode < 'A' || unicode > 'F'))
        return nk_false;
    else return nk_true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x30, -0x14(%rsp)
jb 0x708b7
cmpl $0x39, -0x14(%rsp)
jbe 0x708dd
cmpl $0x61, -0x14(%rsp)
jb 0x708c5
cmpl $0x66, -0x14(%rsp)
jbe 0x708dd
cmpl $0x41, -0x14(%rsp)
jb 0x708d3
cmpl $0x46, -0x14(%rsp)
jbe 0x708dd
movl $0x0, -0x4(%rsp)
jmp 0x708e5
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_edit_focus
NK_API void
nk_edit_focus(struct nk_context *ctx, nk_flags flags)
{
    nk_hash hash;
    struct nk_window *win;

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

    win = ctx->current;
    hash = win->edit.seq;
    win->edit.active = nk_true;
    win->edit.name = hash;
    if (flags & NK_EDIT_ALWAYS_INSERT_MODE)
        win->edit.mode = NK_TEXT_EDIT_MODE_INSERT;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x70998
movq 0x54684(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x40a2a(%rip), %rsi     # 0xb13a0
leaq 0x40a41(%rip), %rdx     # 0xb13be
movl $0x6d11, %ecx           # imm = 0x6D11
movb $0x0, %al
callq 0x13ec0
movq 0x54660(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x7099a
jmp 0x7099c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x709de
movq 0x5463e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x409e4(%rip), %rsi     # 0xb13a0
leaq 0x409fb(%rip), %rdx     # 0xb13be
movl $0x6d12, %ecx           # imm = 0x6D12
movb $0x0, %al
callq 0x13ec0
movq 0x5461a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x709e0
cmpq $0x0, 0x10(%rsp)
je 0x709f7
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x709f9
jmp 0x70a4c
movq 0x10(%rsp), %rax
movq 0x4780(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x184(%rax), %eax
movl %eax, 0x8(%rsp)
movq (%rsp), %rax
movl $0x1, 0x18c(%rax)
movl 0x8(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x180(%rax)
movl 0xc(%rsp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x70a4c
movq (%rsp), %rax
movb $0x1, 0x1a8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_edit_unfocus
NK_API void
nk_edit_unfocus(struct nk_context *ctx)
{
    struct nk_window *win;
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return;

    win = ctx->current;
    win->edit.active = nk_false;
    win->edit.name = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x70aa4
movq 0x54578(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x4091e(%rip), %rsi     # 0xb13a0
leaq 0x40935(%rip), %rdx     # 0xb13be
movl $0x6d20, %ecx           # imm = 0x6D20
movb $0x0, %al
callq 0x13ec0
movq 0x54554(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x70aa6
jmp 0x70aa8
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x70aea
movq 0x54532(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x408d8(%rip), %rsi     # 0xb13a0
leaq 0x408ef(%rip), %rdx     # 0xb13be
movl $0x6d21, %ecx           # imm = 0x6D21
movb $0x0, %al
callq 0x13ec0
movq 0x5450e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x70aec
cmpq $0x0, 0x10(%rsp)
je 0x70b03
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x70b05
jmp 0x70b34
movq 0x10(%rsp), %rax
movq 0x4780(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, 0x18c(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x180(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_edit_string_zero_terminated
NK_API nk_flags
nk_edit_string_zero_terminated(struct nk_context *ctx, nk_flags flags,
    char *buffer, int max, nk_plugin_filter filter)
{
    nk_flags result;
    int len = nk_strlen(buffer);
    result = nk_edit_string(ctx, flags, buffer, &len, max, filter);
    buffer[NK_MIN(NK_MAX(max-1,0), len)] = '\0';
    return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14050
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %r8d
movq 0x20(%rsp), %r9
leaq 0x18(%rsp), %rcx
callq 0x15140
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x73d3d
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x73d48
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x73d7b
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x73d66
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x73d71
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x73d83
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_int
NK_API void
nk_property_int(struct nk_context *ctx, const char *name,
    int min, int *val, int max, int step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);
    NK_ASSERT(val);

    if (!ctx || !ctx->current || !name || !val) return;
    variant = nk_property_variant_int(*val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT);
    *val = variant.value.i;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq %rcx, 0x68(%rsp)
movl %r8d, 0x64(%rsp)
movl %r9d, 0x60(%rsp)
movss %xmm0, 0x5c(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x73e0b
movq 0x51211(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3d5b7(%rip), %rsi     # 0xb13a0
leaq 0x3d5ce(%rip), %rdx     # 0xb13be
movl $0x6f54, %ecx           # imm = 0x6F54
movb $0x0, %al
callq 0x13ec0
movq 0x511ed(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x73e0d
jmp 0x73e0f
cmpq $0x0, 0x78(%rsp)
jne 0x73e4a
movq 0x511d2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3d578(%rip), %rsi     # 0xb13a0
leaq 0x3d58f(%rip), %rdx     # 0xb13be
movl $0x6f55, %ecx           # imm = 0x6F55
movb $0x0, %al
callq 0x13ec0
movq 0x511ae(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x73e4c
jmp 0x73e4e
cmpq $0x0, 0x68(%rsp)
jne 0x73e89
movq 0x51193(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3d539(%rip), %rsi     # 0xb13a0
leaq 0x3d550(%rip), %rdx     # 0xb13be
movl $0x6f56, %ecx           # imm = 0x6F56
movb $0x0, %al
callq 0x13ec0
movq 0x5116f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x73e8b
cmpq $0x0, 0x80(%rsp)
je 0x73eb8
movq 0x80(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x73eb8
cmpq $0x0, 0x78(%rsp)
je 0x73eb8
cmpq $0x0, 0x68(%rsp)
jne 0x73eba
jmp 0x73f16
movq 0x68(%rsp), %rax
movl (%rax), %esi
movl 0x74(%rsp), %edx
movl 0x64(%rsp), %ecx
movl 0x60(%rsp), %r8d
leaq 0x8(%rsp), %rdi
callq 0x73f20
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x14160
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movss 0x5c(%rsp), %xmm0
leaq 0x30(%rsp), %rdx
xorl %ecx, %ecx
callq 0x73f60
movl 0x38(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, (%rax)
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_variant_int
NK_LIB struct nk_property_variant
nk_property_variant_int(int value, int min_value, int max_value, int step)
{
    struct nk_property_variant result;
    result.kind = NK_PROPERTY_INT;
    result.value.i = value;
    result.min_value.i = min_value;
    result.max_value.i = max_value;
    result.step.i = step;
    return result;
}

// Assembly:
movq %rdi, %rax
movl %esi, -0x4(%rsp)
movl %edx, -0x8(%rsp)
movl %ecx, -0xc(%rsp)
movl %r8d, -0x10(%rsp)
movl $0x0, (%rdi)
movl -0x4(%rsp), %ecx
movl %ecx, 0x8(%rdi)
movl -0x8(%rsp), %ecx
movl %ecx, 0x10(%rdi)
movl -0xc(%rsp), %ecx
movl %ecx, 0x18(%rdi)
movl -0x10(%rsp), %ecx
movl %ecx, 0x20(%rdi)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_float
NK_API void
nk_property_float(struct nk_context *ctx, const char *name,
    float min, float *val, float max, float step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);
    NK_ASSERT(val);

    if (!ctx || !ctx->current || !name || !val) return;
    variant = nk_property_variant_float(*val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    *val = variant.value.f;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movss %xmm0, 0x74(%rsp)
movq %rdx, 0x68(%rsp)
movss %xmm1, 0x64(%rsp)
movss %xmm2, 0x60(%rsp)
movss %xmm3, 0x5c(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x7474f
movq 0x508cd(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3cc73(%rip), %rsi     # 0xb13a0
leaq 0x3cc8a(%rip), %rdx     # 0xb13be
movl $0x6f62, %ecx           # imm = 0x6F62
movb $0x0, %al
callq 0x13ec0
movq 0x508a9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74751
jmp 0x74753
cmpq $0x0, 0x78(%rsp)
jne 0x7478e
movq 0x5088e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3cc34(%rip), %rsi     # 0xb13a0
leaq 0x3cc4b(%rip), %rdx     # 0xb13be
movl $0x6f63, %ecx           # imm = 0x6F63
movb $0x0, %al
callq 0x13ec0
movq 0x5086a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74790
jmp 0x74792
cmpq $0x0, 0x68(%rsp)
jne 0x747cd
movq 0x5084f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3cbf5(%rip), %rsi     # 0xb13a0
leaq 0x3cc0c(%rip), %rdx     # 0xb13be
movl $0x6f64, %ecx           # imm = 0x6F64
movb $0x0, %al
callq 0x13ec0
movq 0x5082b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x747cf
cmpq $0x0, 0x80(%rsp)
je 0x747fc
movq 0x80(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x747fc
cmpq $0x0, 0x78(%rsp)
je 0x747fc
cmpq $0x0, 0x68(%rsp)
jne 0x747fe
jmp 0x74868
movq 0x68(%rsp), %rax
movss (%rax), %xmm0
movss 0x74(%rsp), %xmm1
movss 0x64(%rsp), %xmm2
movss 0x60(%rsp), %xmm3
leaq 0x8(%rsp), %rdi
callq 0x74870
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x14160
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movss 0x5c(%rsp), %xmm0
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x73f60
movss 0x38(%rsp), %xmm0
movq 0x68(%rsp), %rax
movss %xmm0, (%rax)
addq $0x88, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_variant_float
NK_LIB struct nk_property_variant
nk_property_variant_float(float value, float min_value, float max_value, float step)
{
    struct nk_property_variant result;
    result.kind = NK_PROPERTY_FLOAT;
    result.value.f = value;
    result.min_value.f = min_value;
    result.max_value.f = max_value;
    result.step.f = step;
    return result;
}

// Assembly:
movq %rdi, %rax
movss %xmm0, -0x4(%rsp)
movss %xmm1, -0x8(%rsp)
movss %xmm2, -0xc(%rsp)
movss %xmm3, -0x10(%rsp)
movl $0x1, (%rdi)
movss -0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rdi)
movss -0x8(%rsp), %xmm0
movss %xmm0, 0x10(%rdi)
movss -0xc(%rsp), %xmm0
movss %xmm0, 0x18(%rdi)
movss -0x10(%rsp), %xmm0
movss %xmm0, 0x20(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_double
NK_API void
nk_property_double(struct nk_context *ctx, const char *name,
    double min, double *val, double max, double step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);
    NK_ASSERT(val);

    if (!ctx || !ctx->current || !name || !val) return;
    variant = nk_property_variant_double(*val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    *val = variant.value.d;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
movsd %xmm2, 0x58(%rsp)
movss %xmm3, 0x54(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x7492f
movq 0x506ed(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3ca93(%rip), %rsi     # 0xb13a0
leaq 0x3caaa(%rip), %rdx     # 0xb13be
movl $0x6f70, %ecx           # imm = 0x6F70
movb $0x0, %al
callq 0x13ec0
movq 0x506c9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74931
jmp 0x74933
cmpq $0x0, 0x78(%rsp)
jne 0x7496e
movq 0x506ae(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3ca54(%rip), %rsi     # 0xb13a0
leaq 0x3ca6b(%rip), %rdx     # 0xb13be
movl $0x6f71, %ecx           # imm = 0x6F71
movb $0x0, %al
callq 0x13ec0
movq 0x5068a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74970
jmp 0x74972
cmpq $0x0, 0x68(%rsp)
jne 0x749ad
movq 0x5066f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3ca15(%rip), %rsi     # 0xb13a0
leaq 0x3ca2c(%rip), %rdx     # 0xb13be
movl $0x6f72, %ecx           # imm = 0x6F72
movb $0x0, %al
callq 0x13ec0
movq 0x5064b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x749af
cmpq $0x0, 0x80(%rsp)
je 0x749dc
movq 0x80(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x749dc
cmpq $0x0, 0x78(%rsp)
je 0x749dc
cmpq $0x0, 0x68(%rsp)
jne 0x749de
jmp 0x74a44
movq 0x68(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x70(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
movsd 0x58(%rsp), %xmm3
movq %rsp, %rdi
callq 0x74a50
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
movl $0x28, %edx
callq 0x14160
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movss 0x54(%rsp), %xmm0
leaq 0x28(%rsp), %rdx
movl $0x1, %ecx
callq 0x73f60
movsd 0x30(%rsp), %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_property_variant_double
NK_LIB struct nk_property_variant
nk_property_variant_double(double value, double min_value, double max_value,
    double step)
{
    struct nk_property_variant result;
    result.kind = NK_PROPERTY_DOUBLE;
    result.value.d = value;
    result.min_value.d = min_value;
    result.max_value.d = max_value;
    result.step.d = step;
    return result;
}

// Assembly:
movq %rdi, %rax
movsd %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movsd %xmm2, -0x18(%rsp)
movsd %xmm3, -0x20(%rsp)
movl $0x2, (%rdi)
movsd -0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_propertyi
NK_API int
nk_propertyi(struct nk_context *ctx, const char *name, int min, int val,
    int max, int step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);

    if (!ctx || !ctx->current || !name) return val;
    variant = nk_property_variant_int(val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_INT);
    val = variant.value.i;
    return val;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movl %ecx, 0x68(%rsp)
movl %r8d, 0x64(%rsp)
movl %r9d, 0x60(%rsp)
movss %xmm0, 0x5c(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x74b04
movq 0x50518(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3c8be(%rip), %rsi     # 0xb13a0
leaq 0x3c8d5(%rip), %rdx     # 0xb13be
movl $0x6f7e, %ecx           # imm = 0x6F7E
movb $0x0, %al
callq 0x13ec0
movq 0x504f4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74b06
jmp 0x74b08
cmpq $0x0, 0x70(%rsp)
jne 0x74b43
movq 0x504d9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3c87f(%rip), %rsi     # 0xb13a0
leaq 0x3c896(%rip), %rdx     # 0xb13be
movl $0x6f7f, %ecx           # imm = 0x6F7F
movb $0x0, %al
callq 0x13ec0
movq 0x504b5(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74b45
cmpq $0x0, 0x78(%rsp)
je 0x74b64
movq 0x78(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x74b64
cmpq $0x0, 0x70(%rsp)
jne 0x74b71
movl 0x68(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x74bcf
movl 0x68(%rsp), %esi
movl 0x6c(%rsp), %edx
movl 0x64(%rsp), %ecx
movl 0x60(%rsp), %r8d
leaq 0x8(%rsp), %rdi
callq 0x73f20
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x14160
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movss 0x5c(%rsp), %xmm0
leaq 0x30(%rsp), %rdx
xorl %ecx, %ecx
callq 0x73f60
movl 0x38(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_propertyf
NK_API float
nk_propertyf(struct nk_context *ctx, const char *name, float min,
    float val, float max, float step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);

    if (!ctx || !ctx->current || !name) return val;
    variant = nk_property_variant_float(val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    val = variant.value.f;
    return val;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movss %xmm0, 0x6c(%rsp)
movss %xmm1, 0x68(%rsp)
movss %xmm2, 0x64(%rsp)
movss %xmm3, 0x60(%rsp)
movss %xmm4, 0x5c(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x74c4a
movq 0x503d2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3c778(%rip), %rsi     # 0xb13a0
leaq 0x3c78f(%rip), %rdx     # 0xb13be
movl $0x6f8c, %ecx           # imm = 0x6F8C
movb $0x0, %al
callq 0x13ec0
movq 0x503ae(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74c4c
jmp 0x74c4e
cmpq $0x0, 0x70(%rsp)
jne 0x74c89
movq 0x50393(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3c739(%rip), %rsi     # 0xb13a0
leaq 0x3c750(%rip), %rdx     # 0xb13be
movl $0x6f8d, %ecx           # imm = 0x6F8D
movb $0x0, %al
callq 0x13ec0
movq 0x5036f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74c8b
cmpq $0x0, 0x78(%rsp)
je 0x74caa
movq 0x78(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x74caa
cmpq $0x0, 0x70(%rsp)
jne 0x74cbb
movss 0x68(%rsp), %xmm0
movss %xmm0, 0x84(%rsp)
jmp 0x74d2b
movss 0x68(%rsp), %xmm0
movss 0x6c(%rsp), %xmm1
movss 0x64(%rsp), %xmm2
movss 0x60(%rsp), %xmm3
leaq 0x8(%rsp), %rdi
callq 0x74870
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x14160
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movss 0x5c(%rsp), %xmm0
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x73f60
movss 0x38(%rsp), %xmm0
movss %xmm0, 0x68(%rsp)
movss 0x68(%rsp), %xmm0
movss %xmm0, 0x84(%rsp)
movss 0x84(%rsp), %xmm0
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_propertyd
NK_API double
nk_propertyd(struct nk_context *ctx, const char *name, double min,
    double val, double max, double step, float inc_per_pixel)
{
    struct nk_property_variant variant;
    NK_ASSERT(ctx);
    NK_ASSERT(name);

    if (!ctx || !ctx->current || !name) return val;
    variant = nk_property_variant_double(val, min, max, step);
    nk_property(ctx, name, &variant, inc_per_pixel, NK_FILTER_FLOAT);
    val = variant.value.d;
    return val;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movsd %xmm1, 0x70(%rsp)
movsd %xmm2, 0x68(%rsp)
movsd %xmm3, 0x60(%rsp)
movss %xmm4, 0x5c(%rsp)
cmpq $0x0, 0x88(%rsp)
jne 0x74db3
movq 0x50269(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3c60f(%rip), %rsi     # 0xb13a0
leaq 0x3c626(%rip), %rdx     # 0xb13be
movl $0x6f9a, %ecx           # imm = 0x6F9A
movb $0x0, %al
callq 0x13ec0
movq 0x50245(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74db5
jmp 0x74db7
cmpq $0x0, 0x80(%rsp)
jne 0x74df5
movq 0x50227(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3c5cd(%rip), %rsi     # 0xb13a0
leaq 0x3c5e4(%rip), %rdx     # 0xb13be
movl $0x6f9b, %ecx           # imm = 0x6F9B
movb $0x0, %al
callq 0x13ec0
movq 0x50203(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x74df7
cmpq $0x0, 0x88(%rsp)
je 0x74e1f
movq 0x88(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x74e1f
cmpq $0x0, 0x80(%rsp)
jne 0x74e30
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x74ea6
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
movsd 0x68(%rsp), %xmm2
movsd 0x60(%rsp), %xmm3
leaq 0x8(%rsp), %rdi
callq 0x74a50
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x14160
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movss 0x5c(%rsp), %xmm0
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x73f60
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_shrink_rect
NK_LIB struct nk_rect
nk_shrink_rect(struct nk_rect r, float amount)
{
    struct nk_rect res;
    r.w = NK_MAX(r.w, 2 * amount);
    r.h = NK_MAX(r.h, 2 * amount);
    res.x = r.x + amount;
    res.y = r.y + amount;
    res.w = r.w - 2 * amount;
    res.h = r.h - 2 * amount;
    return res;
}

// Assembly:
movlpd %xmm0, -0x20(%rsp)
movlpd %xmm1, -0x18(%rsp)
movss %xmm2, -0x24(%rsp)
movss -0x18(%rsp), %xmm1
movss 0x37ec4(%rip), %xmm0    # 0xad4e4
mulss -0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x75641
movss 0x37eb1(%rip), %xmm0    # 0xad4e4
mulss -0x24(%rsp), %xmm0
movss %xmm0, -0x28(%rsp)
jmp 0x7564d
movss -0x18(%rsp), %xmm0
movss %xmm0, -0x28(%rsp)
movss -0x28(%rsp), %xmm0
movss %xmm0, -0x18(%rsp)
movss -0x14(%rsp), %xmm1
movss 0x37e7d(%rip), %xmm0    # 0xad4e4
mulss -0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x75688
movss 0x37e6a(%rip), %xmm0    # 0xad4e4
mulss -0x24(%rsp), %xmm0
movss %xmm0, -0x2c(%rsp)
jmp 0x75694
movss -0x14(%rsp), %xmm0
movss %xmm0, -0x2c(%rsp)
movss -0x2c(%rsp), %xmm0
movss %xmm0, -0x14(%rsp)
movss -0x20(%rsp), %xmm0
movss -0x24(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x10(%rsp)
movss -0x1c(%rsp), %xmm0
movss -0x24(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rsp)
movss -0x18(%rsp), %xmm0
movss -0x24(%rsp), %xmm1
addss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rsp)
movss -0x14(%rsp), %xmm0
movss -0x24(%rsp), %xmm1
addss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rsp)
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_chart_end
NK_API void
nk_chart_end(struct nk_context *ctx)
{
    struct nk_window *win;
    struct nk_chart *chart;

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

    win = ctx->current;
    chart = &win->layout->chart;
    NK_MEMSET(chart, 0, sizeof(*chart));
    return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x76b54
movq 0x4e4c8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3a86e(%rip), %rsi     # 0xb13a0
leaq 0x3a885(%rip), %rdx     # 0xb13be
movl $0x70b7, %ecx           # imm = 0x70B7
movb $0x0, %al
callq 0x13ec0
movq 0x4e4a4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x76b56
jmp 0x76b58
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x76b9a
movq 0x4e482(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3a828(%rip), %rsi     # 0xb13a0
leaq 0x3a83f(%rip), %rdx     # 0xb13be
movl $0x70b8, %ecx           # imm = 0x70B8
movb $0x0, %al
callq 0x13ec0
movq 0x4e45e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x76b9c
cmpq $0x0, 0x10(%rsp)
je 0x76bb3
movq 0x10(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x76bb5
jmp 0x76bec
movq 0x10(%rsp), %rax
movq 0x4780(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
addq $0xf8, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0xc4, %edx
callq 0x49d50
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_button_behavior
NK_LIB nk_bool
nk_button_behavior(nk_flags *state, struct nk_rect r,
    const struct nk_input *i, enum nk_button_behavior behavior)
{
    int ret = 0;
    nk_widget_state_reset(state);
    if (!i) return 0;
    if (nk_input_is_mouse_hovering_rect(i, r)) {
        *state = NK_WIDGET_STATE_HOVERED;
        if (nk_input_is_mouse_down(i, NK_BUTTON_LEFT))
            *state = NK_WIDGET_STATE_ACTIVE;
        if (nk_input_has_mouse_click_in_button_rect(i, NK_BUTTON_LEFT, r)) {
            ret = (behavior != NK_BUTTON_DEFAULT) ?
                nk_input_is_mouse_down(i, NK_BUTTON_LEFT):
#ifdef NK_BUTTON_TRIGGER_ON_RELEASE
                nk_input_is_mouse_released(i, NK_BUTTON_LEFT);
#else
                nk_input_is_mouse_pressed(i, NK_BUTTON_LEFT);
#endif
        }
    }
    if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(i, r))
        *state |= NK_WIDGET_STATE_ENTERED;
    else if (nk_input_is_mouse_prev_hovering_rect(i, r))
        *state |= NK_WIDGET_STATE_LEFT;
    return ret;
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x24(%rsp)
movlpd %xmm1, 0x2c(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x780a2
movq 0x18(%rsp), %rax
movl $0x6, (%rax)
jmp 0x780ad
movq 0x18(%rsp), %rax
movl $0x4, (%rax)
cmpq $0x0, 0x10(%rsp)
jne 0x780c2
movl $0x0, 0x34(%rsp)
jmp 0x781bf
movq 0x10(%rsp), %rdi
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
callq 0x15440
cmpl $0x0, %eax
je 0x78156
movq 0x18(%rsp), %rax
movl $0x12, (%rax)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x14190
cmpl $0x0, %eax
je 0x78104
movq 0x18(%rsp), %rax
movl $0x22, (%rax)
movq 0x10(%rsp), %rdi
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
xorl %eax, %eax
xorl %esi, %esi
callq 0x143a0
cmpl $0x0, %eax
je 0x78154
cmpl $0x0, 0xc(%rsp)
je 0x7813c
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x14190
movl %eax, 0x4(%rsp)
jmp 0x7814c
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x15040
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x78156
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7818e
movq 0x10(%rsp), %rdi
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
callq 0x14d70
cmpl $0x0, %eax
jne 0x7818e
movq 0x18(%rsp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x781b7
movq 0x10(%rsp), %rdi
movsd 0x24(%rsp), %xmm0
movsd 0x2c(%rsp), %xmm1
callq 0x14d70
cmpl $0x0, %eax
je 0x781b5
movq 0x18(%rsp), %rax
movl (%rax), %ecx
orl $0x40, %ecx
movl %ecx, (%rax)
jmp 0x781b7
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_button_symbol
NK_LIB void
nk_draw_button_symbol(struct nk_command_buffer *out,
    const struct nk_rect *bounds, const struct nk_rect *content,
    nk_flags state, const struct nk_style_button *style,
    enum nk_symbol_type type, const struct nk_user_font *font)
{
    struct nk_color sym, bg;
    const struct nk_style_item *background;

    /* select correct colors/images */
    background = nk_draw_button(out, bounds, state, style);
    if (background->type == NK_STYLE_ITEM_COLOR)
        bg = background->data.color;
    else bg = style->text_background;

    if (state & NK_WIDGET_STATE_HOVER)
        sym = style->text_hover;
    else if (state & NK_WIDGET_STATE_ACTIVED)
        sym = style->text_active;
    else sym = style->text_normal;

    sym = nk_rgb_factor(sym, style->color_factor_text);
    nk_draw_symbol(out, type, *content, bg, sym, 1, font);
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x2c(%rsp), %edx
movq 0x20(%rsp), %rcx
callq 0x69a10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x7822b
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x7823a
movq 0x20(%rsp), %rax
movl 0x80(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x78257
movq 0x20(%rsp), %rax
movl 0x88(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x78285
movl 0x2c(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x78274
movq 0x20(%rsp), %rax
movl 0x8c(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x78283
movq 0x20(%rsp), %rax
movl 0x84(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x78285
movq 0x20(%rsp), %rax
movss 0x94(%rax), %xmm0
movl 0x18(%rsp), %edi
callq 0x15100
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x30(%rsp), %rax
movq 0x50(%rsp), %r8
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %ecx
movss 0x35215(%rip), %xmm2    # 0xad4e8
callq 0x79710
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_tooltip_end
NK_API void
nk_tooltip_end(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return;
    ctx->current->seq--;
    nk_popup_close(ctx);
    nk_popup_end(ctx);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x7c63f
movq 0x489dd(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x34d83(%rip), %rsi     # 0xb13a0
leaq 0x34d9a(%rip), %rdx     # 0xb13be
movl $0x7542, %ecx           # imm = 0x7542
movb $0x0, %al
callq 0x13ec0
movq 0x489b9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x7c641
jmp 0x7c643
movq (%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x7c684
movq 0x48998(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x34d3e(%rip), %rsi     # 0xb13a0
leaq 0x34d55(%rip), %rdx     # 0xb13be
movl $0x7543, %ecx           # imm = 0x7543
movb $0x0, %al
callq 0x13ec0
movq 0x48974(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x7c686
cmpq $0x0, (%rsp)
je 0x7c69b
movq (%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x7c69d
jmp 0x7c6c1
movq (%rsp), %rax
movq 0x4780(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rdi
callq 0x153c0
movq (%rsp), %rdi
callq 0x143f0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_str_match_star
NK_INTERN int
nk_str_match_star(int c, const char *regexp, const char *text)
{
    do {/* a '* matches zero or more instances */
        if (nk_str_match_here(regexp, text))
            return 1;
    } while (*text != '\0' && (*text++ == c || c == '.'));
    return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2bd60
cmpl $0x0, %eax
je 0x7ca70
movl $0x1, 0x24(%rsp)
jmp 0x7cac9
jmp 0x7ca72
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x7cab9
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movsbl (%rax), %ecx
movb $0x1, %al
cmpl 0x20(%rsp), %ecx
movb %al, 0xe(%rsp)
je 0x7cab1
cmpl $0x2e, 0x20(%rsp)
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7ca52
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_buffer_align
NK_LIB void*
nk_buffer_align(void *unaligned,
    nk_size align, nk_size *alignment,
    enum nk_buffer_allocation_type type)
{
    void *memory = 0;
    switch (type) {
    default:
    case NK_BUFFER_MAX:
    case NK_BUFFER_FRONT:
        if (align) {
            memory = NK_ALIGN_PTR(unaligned, align);
            *alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned);
        } else {
            memory = unaligned;
            *alignment = 0;
        }
        break;
    case NK_BUFFER_BACK:
        if (align) {
            memory = NK_ALIGN_PTR_BACK(unaligned, align);
            *alignment = (nk_size)((nk_byte*)unaligned - (nk_byte*)memory);
        } else {
            memory = unaligned;
            *alignment = 0;
        }
        break;
    }
    return memory;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq $0x0, -0x28(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x2c(%rsp)
testl %eax, %eax
je 0x7cb22
jmp 0x7cb0a
movl -0x2c(%rsp), %eax
subl $0x1, %eax
je 0x7cb7f
jmp 0x7cb15
movl -0x2c(%rsp), %eax
subl $0x2, %eax
je 0x7cb22
jmp 0x7cb20
jmp 0x7cb22
cmpq $0x0, -0x10(%rsp)
je 0x7cb67
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rax
subq %rax, %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x7cb7d
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x7cbd0
cmpq $0x0, -0x10(%rsp)
je 0x7cbb8
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x8(%rsp), %rcx
movq -0x28(%rsp), %rax
subq %rax, %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x7cbce
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x7cbd0
movq -0x28(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_round_up_pow2
NK_LIB nk_uint
nk_round_up_pow2(nk_uint v)
{
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v++;
    return v;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x2, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x4, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x8, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_push_command
NK_INTERN struct nk_draw_command*
nk_draw_list_push_command(struct nk_draw_list *list, struct nk_rect clip,
    nk_handle texture)
{
    NK_STORAGE const nk_size cmd_align = NK_ALIGNOF(struct nk_draw_command);
    NK_STORAGE const nk_size cmd_size = sizeof(struct nk_draw_command);
    struct nk_draw_command *cmd;

    NK_ASSERT(list);
    cmd = (struct nk_draw_command*)
        nk_buffer_alloc(list->buffer, NK_BUFFER_BACK, cmd_size, cmd_align);

    if (!cmd) return 0;
    if (!list->cmd_count) {
        nk_byte *memory = (nk_byte*)nk_buffer_memory(list->buffer);
        nk_size total = nk_buffer_total(list->buffer);
        memory = nk_ptr_add(nk_byte, memory, total);
        list->cmd_offset = (nk_size)(memory - (nk_byte*)cmd);
    }

    cmd->elem_count = 0;
    cmd->clip_rect = clip;
    cmd->texture = texture;
#ifdef NK_INCLUDE_COMMAND_USERDATA
    cmd->userdata = list->userdata;
#endif

    list->cmd_count++;
    list->clip_rect = clip;
    return cmd;
}

// Assembly:
subq $0x48, %rsp
movlpd %xmm0, 0x30(%rsp)
movlpd %xmm1, 0x38(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x7dd35
movq 0x472e7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x3368d(%rip), %rsi     # 0xb13a0
leaq 0x336a4(%rip), %rdx     # 0xb13be
movl $0x25a0, %ecx           # imm = 0x25A0
movb $0x0, %al
callq 0x13ec0
movq 0x472c3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x7dd37
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
movl $0x1, %esi
movl $0x20, %edx
movl $0x8, %ecx
callq 0x2f2e0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7dd72
movq $0x0, 0x40(%rsp)
jmp 0x7de38
movq 0x20(%rsp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x7ddd4
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x141e0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x152e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x4(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0xc(%rax)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movl 0xd0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xd0(%rax)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__match
NK_INTERN void
nk__match(unsigned char *data, unsigned int length)
{
    /* INVERSE of memmove... write each byte before copying the next...*/
    NK_ASSERT (nk__dout + length <= nk__barrier);
    if (nk__dout + length > nk__barrier) { nk__dout += length; return; }
    if (data < nk__barrier4) { nk__dout = nk__barrier+1; return; }
    while (length--) *nk__dout++ = *data++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x414f4(%rip), %rax     # 0xc63a8
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0x414d6(%rip), %rax     # 0xc6398
jbe 0x84ef7
movq 0x40125(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x2c4cb(%rip), %rsi     # 0xb13a0
leaq 0x2c4e2(%rip), %rdx     # 0xb13be
movl $0x436e, %ecx           # imm = 0x436E
movb $0x0, %al
callq 0x13ec0
movq 0x40101(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x84ef9
movq 0x414a8(%rip), %rax     # 0xc63a8
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0x4148a(%rip), %rax     # 0xc6398
jbe 0x84f29
movl 0xc(%rsp), %ecx
movq 0x4148d(%rip), %rax     # 0xc63a8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x41481(%rip)     # 0xc63a8
jmp 0x84f8b
movq 0x10(%rsp), %rax
cmpq 0x4146b(%rip), %rax     # 0xc63a0
jae 0x84f4b
movq 0x4145a(%rip), %rax     # 0xc6398
addq $0x1, %rax
movq %rax, 0x4145f(%rip)     # 0xc63a8
jmp 0x84f8b
jmp 0x84f4d
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x0, %eax
je 0x84f8b
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x4142f(%rip), %rax     # 0xc63a8
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x41421(%rip)     # 0xc63a8
movb %cl, (%rax)
jmp 0x84f4d
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__lit
NK_INTERN void
nk__lit(unsigned char *data, unsigned int length)
{
    NK_ASSERT (nk__dout + length <= nk__barrier);
    if (nk__dout + length > nk__barrier) { nk__dout += length; return; }
    if (data < nk__barrier2) { nk__dout = nk__barrier+1; return; }
    NK_MEMCPY(nk__dout, data, length);
    nk__dout += length;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x41404(%rip), %rax     # 0xc63a8
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0x413e6(%rip), %rax     # 0xc6398
jbe 0x84fe7
movq 0x40035(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x2c3db(%rip), %rsi     # 0xb13a0
leaq 0x2c3f2(%rip), %rdx     # 0xb13be
movl $0x4376, %ecx           # imm = 0x4376
movb $0x0, %al
callq 0x13ec0
movq 0x40011(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x84fe9
movq 0x413b8(%rip), %rax     # 0xc63a8
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0x4139a(%rip), %rax     # 0xc6398
jbe 0x85019
movl 0xc(%rsp), %ecx
movq 0x4139d(%rip), %rax     # 0xc63a8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x41391(%rip)     # 0xc63a8
jmp 0x85069
movq 0x10(%rsp), %rax
cmpq 0x41363(%rip), %rax     # 0xc6388
jae 0x8503b
movq 0x4136a(%rip), %rax     # 0xc6398
addq $0x1, %rax
movq %rax, 0x4136f(%rip)     # 0xc63a8
jmp 0x85069
movq 0x41366(%rip), %rdi     # 0xc63a8
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x2f750
movl 0xc(%rsp), %ecx
movq 0x4134b(%rip), %rax     # 0xc63a8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x4133f(%rip)     # 0xc63a8
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_range_glyph_count
NK_INTERN int
nk_range_glyph_count(const nk_rune *range, int count)
{
    int i = 0;
    int total_glyphs = 0;
    for (i = 0; i < count; ++i) {
        int diff;
        nk_rune f = range[(i*2)+0];
        nk_rune t = range[(i*2)+1];
        NK_ASSERT(t >= f);
        diff = (int)((t - f) + 1);
        total_glyphs += diff;
    }
    return total_glyphs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x8516d
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x85140
movq 0x3fedc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x2c282(%rip), %rsi     # 0xb13a0
leaq 0x2c299(%rip), %rdx     # 0xb13be
movl $0x40db, %ecx           # imm = 0x40DB
movb $0x0, %al
callq 0x13ec0
movq 0x3feb8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x85142
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x850c5
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_start_buffer
NK_LIB void
nk_start_buffer(struct nk_context *ctx, struct nk_command_buffer *buffer)
{
    NK_ASSERT(ctx);
    NK_ASSERT(buffer);
    if (!ctx || !buffer) return;
    buffer->begin = ctx->memory.allocated;
    buffer->end = buffer->begin;
    buffer->last = buffer->begin;
    buffer->clip = nk_null_rect;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x855f9
movq 0x3fa23(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x2bdc9(%rip), %rsi     # 0xb13a0
leaq 0x2bde0(%rip), %rdx     # 0xb13be
movl $0x4b06, %ecx           # imm = 0x4B06
movb $0x0, %al
callq 0x13ec0
movq 0x3f9ff(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x855fb
jmp 0x855fd
cmpq $0x0, 0x8(%rsp)
jne 0x85638
movq 0x3f9e4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x2bd8a(%rip), %rsi     # 0xb13a0
leaq 0x2bda1(%rip), %rdx     # 0xb13be
movl $0x4b07, %ecx           # imm = 0x4B07
movb $0x0, %al
callq 0x13ec0
movq 0x3f9c0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x8563a
cmpq $0x0, 0x10(%rsp)
je 0x8564a
cmpq $0x0, 0x8(%rsp)
jne 0x8564c
jmp 0x856a0
movq 0x10(%rsp), %rax
movq 0x2560(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x281d3(%rip), %rcx     # 0xad864
movq %rcx, 0x8(%rax)
movq 0x281d0(%rip), %rcx     # 0xad86c
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)