LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_subimage_handle
NK_API struct nk_image
nk_subimage_handle(nk_handle handle, nk_ushort w, nk_ushort h, struct nk_rect r)
{
    struct nk_image s;
    nk_zero(&s, sizeof(s));
    s.handle = handle;
    s.w = w; s.h = h;
    s.region[0] = (nk_ushort)r.x;
    s.region[1] = (nk_ushort)r.y;
    s.region[2] = (nk_ushort)r.w;
    s.region[3] = (nk_ushort)r.h;
    return s;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movw %cx, %ax
movw %dx, %cx
movq %rdi, %rdx
movq %rdx, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movlpd %xmm0, 0x20(%rsp)
movlpd %xmm1, 0x28(%rsp)
movw %cx, 0x1e(%rsp)
movw %ax, 0x1c(%rsp)
movl $0x18, %esi
callq 0x2f0e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rdi)
movw 0x1e(%rsp), %cx
movw %cx, 0x8(%rdi)
movw 0x1c(%rsp), %cx
movw %cx, 0xa(%rdi)
cvttss2si 0x20(%rsp), %ecx
movw %cx, 0xc(%rdi)
cvttss2si 0x24(%rsp), %ecx
movw %cx, 0xe(%rdi)
cvttss2si 0x28(%rsp), %ecx
movw %cx, 0x10(%rdi)
cvttss2si 0x2c(%rsp), %ecx
movw %cx, 0x12(%rdi)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_image_handle
NK_API struct nk_image
nk_image_handle(nk_handle handle)
{
    struct nk_image s;
    nk_zero(&s, sizeof(s));
    s.handle = handle;
    s.w = 0; s.h = 0;
    s.region[0] = 0;
    s.region[1] = 0;
    s.region[2] = 0;
    s.region[3] = 0;
    return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x18, %esi
callq 0x2f0e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rdi)
movw $0x0, 0x8(%rdi)
movw $0x0, 0xa(%rdi)
movw $0x0, 0xc(%rdi)
movw $0x0, 0xe(%rdi)
movw $0x0, 0x10(%rdi)
movw $0x0, 0x12(%rdi)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_image_ptr
NK_API struct nk_image
nk_image_ptr(void *ptr)
{
    struct nk_image s;
    nk_zero(&s, sizeof(s));
    NK_ASSERT(ptr);
    s.handle.ptr = ptr;
    s.w = 0; s.h = 0;
    s.region[0] = 0;
    s.region[1] = 0;
    s.region[2] = 0;
    s.region[3] = 0;
    return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x18, %esi
callq 0x2f0e0
cmpq $0x0, 0x10(%rsp)
jne 0x6833a
movq 0x5cce2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x49088(%rip), %rsi     # 0xb13a0
leaq 0x4909f(%rip), %rdx     # 0xb13be
movl $0x5d34, %ecx           # imm = 0x5D34
movb $0x0, %al
callq 0x13ec0
movq 0x5ccbe(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6833c
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq 0x10(%rsp), %rdx
movq %rdx, (%rcx)
movw $0x0, 0x8(%rcx)
movw $0x0, 0xa(%rcx)
movw $0x0, 0xc(%rcx)
movw $0x0, 0xe(%rcx)
movw $0x0, 0x10(%rcx)
movw $0x0, 0x12(%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_image_id
NK_API struct nk_image
nk_image_id(int id)
{
    struct nk_image s;
    nk_zero(&s, sizeof(s));
    s.handle.id = id;
    s.w = 0; s.h = 0;
    s.region[0] = 0;
    s.region[1] = 0;
    s.region[2] = 0;
    s.region[3] = 0;
    return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x14(%rsp)
movl $0x18, %esi
callq 0x2f0e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, (%rdi)
movw $0x0, 0x8(%rdi)
movw $0x0, 0xa(%rdi)
movw $0x0, 0xc(%rdi)
movw $0x0, 0xe(%rdi)
movw $0x0, 0x10(%rdi)
movw $0x0, 0x12(%rdi)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_image
NK_API void
nk_image(struct nk_context *ctx, struct nk_image img)
{
    struct nk_window *win;
    struct nk_rect bounds;

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

    win = ctx->current;
    if (!nk_widget(&bounds, ctx)) return;
    nk_draw_image(&win->buffer, bounds, &img, nk_white);
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x6842d
movq 0x5cbef(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48f95(%rip), %rsi     # 0xb13a0
leaq 0x48fac(%rip), %rdx     # 0xb13be
movl $0x5d56, %ecx           # imm = 0x5D56
movb $0x0, %al
callq 0x13ec0
movq 0x5cbcb(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6842f
jmp 0x68431
movq 0x20(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x68473
movq 0x5cba9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48f4f(%rip), %rsi     # 0xb13a0
leaq 0x48f66(%rip), %rdx     # 0xb13be
movl $0x5d57, %ecx           # imm = 0x5D57
movb $0x0, %al
callq 0x13ec0
movq 0x5cb85(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68475
jmp 0x68477
movq 0x20(%rsp), %rax
movq 0x4780(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x684c0
movq 0x5cb5c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48f02(%rip), %rsi     # 0xb13a0
leaq 0x48f19(%rip), %rdx     # 0xb13be
movl $0x5d58, %ecx           # imm = 0x5D58
movb $0x0, %al
callq 0x13ec0
movq 0x5cb38(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x684c2
cmpq $0x0, 0x20(%rsp)
je 0x684ef
movq 0x20(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x684ef
movq 0x20(%rsp), %rax
movq 0x4780(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x684f1
jmp 0x6853c
movq 0x20(%rsp), %rax
movq 0x4780(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x139c0
cmpl $0x0, %eax
jne 0x68518
jmp 0x6853c
movq (%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl 0x48d79(%rip), %edx     # 0xb12b0
callq 0x14690
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_image_color
NK_API void
nk_image_color(struct nk_context *ctx, struct nk_image img, struct nk_color col)
{
    struct nk_window *win;
    struct nk_rect bounds;

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

    win = ctx->current;
    if (!nk_widget(&bounds, ctx)) return;
    nk_draw_image(&win->buffer, bounds, &img, col);
}

// Assembly:
subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x685a2
movq 0x5ca7a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48e20(%rip), %rsi     # 0xb13a0
leaq 0x48e37(%rip), %rdx     # 0xb13be
movl $0x5d65, %ecx           # imm = 0x5D65
movb $0x0, %al
callq 0x13ec0
movq 0x5ca56(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x685a4
jmp 0x685a6
movq 0x28(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
jne 0x685e8
movq 0x5ca34(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48dda(%rip), %rsi     # 0xb13a0
leaq 0x48df1(%rip), %rdx     # 0xb13be
movl $0x5d66, %ecx           # imm = 0x5D66
movb $0x0, %al
callq 0x13ec0
movq 0x5ca10(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x685ea
jmp 0x685ec
movq 0x28(%rsp), %rax
movq 0x4780(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x68635
movq 0x5c9e7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48d8d(%rip), %rsi     # 0xb13a0
leaq 0x48da4(%rip), %rdx     # 0xb13be
movl $0x5d67, %ecx           # imm = 0x5D67
movb $0x0, %al
callq 0x13ec0
movq 0x5c9c3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68637
cmpq $0x0, 0x28(%rsp)
je 0x68664
movq 0x28(%rsp), %rax
cmpq $0x0, 0x4780(%rax)
je 0x68664
movq 0x28(%rsp), %rax
movq 0x4780(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x68666
jmp 0x686b0
movq 0x28(%rsp), %rax
movq 0x4780(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x139c0
cmpl $0x0, %eax
jne 0x6868d
jmp 0x686b0
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x68, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl 0x34(%rsp), %edx
callq 0x14690
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_sub9slice_ptr
NK_API struct nk_nine_slice
nk_sub9slice_ptr(void *ptr, nk_ushort w, nk_ushort h, struct nk_rect rgn, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b)
{
    struct nk_nine_slice s;
    struct nk_image *i = &s.img;
    nk_zero(&s, sizeof(s));
    i->handle.ptr = ptr;
    i->w = w; i->h = h;
    i->region[0] = (nk_ushort)rgn.x;
    i->region[1] = (nk_ushort)rgn.y;
    i->region[2] = (nk_ushort)rgn.w;
    i->region[3] = (nk_ushort)rgn.h;
    s.l = l; s.t = t; s.r = r; s.b = b;
    return s;
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %eax
movl 0x4(%rsp), %ecx
movl %eax, 0x8(%rsp)
movl %edx, %eax
movl 0x8(%rsp), %edx
movl %eax, 0xc(%rsp)
movq %rsi, %r8
movl 0xc(%rsp), %esi
movq %rdi, 0x10(%rsp)
movw %r9w, %ax
movq %rdi, %r9
movq %r9, 0x18(%rsp)
movw 0x58(%rsp), %r9w
movw 0x50(%rsp), %r9w
movlpd %xmm0, 0x38(%rsp)
movlpd %xmm1, 0x40(%rsp)
movq %r8, 0x30(%rsp)
movw %si, 0x2e(%rsp)
movw %dx, 0x2c(%rsp)
movw %cx, 0x2a(%rsp)
movw %ax, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x20, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rdx, (%rcx)
movw 0x2e(%rsp), %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x8(%rcx)
movw 0x2c(%rsp), %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xa(%rcx)
cvttss2si 0x38(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xc(%rcx)
cvttss2si 0x3c(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xe(%rcx)
cvttss2si 0x40(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x10(%rcx)
cvttss2si 0x44(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x12(%rcx)
movw 0x2a(%rsp), %cx
movw %cx, 0x18(%rdi)
movw 0x28(%rsp), %cx
movw %cx, 0x1a(%rdi)
movw 0x50(%rsp), %cx
movw %cx, 0x1c(%rdi)
movw 0x58(%rsp), %cx
movw %cx, 0x1e(%rdi)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_sub9slice_id
NK_API struct nk_nine_slice
nk_sub9slice_id(int id, nk_ushort w, nk_ushort h, struct nk_rect rgn, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b)
{
    struct nk_nine_slice s;
    struct nk_image *i = &s.img;
    nk_zero(&s, sizeof(s));
    i->handle.id = id;
    i->w = w; i->h = h;
    i->region[0] = (nk_ushort)rgn.x;
    i->region[1] = (nk_ushort)rgn.y;
    i->region[2] = (nk_ushort)rgn.w;
    i->region[3] = (nk_ushort)rgn.h;
    s.l = l; s.t = t; s.r = r; s.b = b;
    return s;
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %eax
movl 0x4(%rsp), %ecx
movl %eax, 0x8(%rsp)
movl %edx, %eax
movl 0x8(%rsp), %edx
movl %eax, 0xc(%rsp)
movl %esi, %r8d
movl 0xc(%rsp), %esi
movq %rdi, 0x10(%rsp)
movw %r9w, %ax
movq %rdi, %r9
movq %r9, 0x18(%rsp)
movw 0x58(%rsp), %r9w
movw 0x50(%rsp), %r9w
movlpd %xmm0, 0x38(%rsp)
movlpd %xmm1, 0x40(%rsp)
movl %r8d, 0x34(%rsp)
movw %si, 0x32(%rsp)
movw %dx, 0x30(%rsp)
movw %cx, 0x2e(%rsp)
movw %ax, 0x2c(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x20, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x34(%rsp), %edx
movq 0x20(%rsp), %rcx
movl %edx, (%rcx)
movw 0x32(%rsp), %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x8(%rcx)
movw 0x30(%rsp), %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xa(%rcx)
cvttss2si 0x38(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xc(%rcx)
cvttss2si 0x3c(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xe(%rcx)
cvttss2si 0x40(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x10(%rcx)
cvttss2si 0x44(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x12(%rcx)
movw 0x2e(%rsp), %cx
movw %cx, 0x18(%rdi)
movw 0x2c(%rsp), %cx
movw %cx, 0x1a(%rdi)
movw 0x50(%rsp), %cx
movw %cx, 0x1c(%rdi)
movw 0x58(%rsp), %cx
movw %cx, 0x1e(%rdi)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_sub9slice_handle
NK_API struct nk_nine_slice
nk_sub9slice_handle(nk_handle handle, nk_ushort w, nk_ushort h, struct nk_rect rgn, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b)
{
    struct nk_nine_slice s;
    struct nk_image *i = &s.img;
    nk_zero(&s, sizeof(s));
    i->handle = handle;
    i->w = w; i->h = h;
    i->region[0] = (nk_ushort)rgn.x;
    i->region[1] = (nk_ushort)rgn.y;
    i->region[2] = (nk_ushort)rgn.w;
    i->region[3] = (nk_ushort)rgn.h;
    s.l = l; s.t = t; s.r = r; s.b = b;
    return s;
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %eax
movl 0x4(%rsp), %ecx
movl %eax, 0x8(%rsp)
movl %edx, %eax
movl 0x8(%rsp), %edx
movl %eax, 0xc(%rsp)
movq %rsi, %r8
movl 0xc(%rsp), %esi
movq %rdi, 0x10(%rsp)
movw %r9w, %ax
movq %rdi, %r9
movq %r9, 0x18(%rsp)
movw 0x58(%rsp), %r9w
movw 0x50(%rsp), %r9w
movq %r8, 0x40(%rsp)
movlpd %xmm0, 0x30(%rsp)
movlpd %xmm1, 0x38(%rsp)
movw %si, 0x2e(%rsp)
movw %dx, 0x2c(%rsp)
movw %cx, 0x2a(%rsp)
movw %ax, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x20, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x40(%rsp), %rdx
movq %rdx, (%rcx)
movw 0x2e(%rsp), %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x8(%rcx)
movw 0x2c(%rsp), %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xa(%rcx)
cvttss2si 0x30(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xc(%rcx)
cvttss2si 0x34(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0xe(%rcx)
cvttss2si 0x38(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x10(%rcx)
cvttss2si 0x3c(%rsp), %ecx
movw %cx, %dx
movq 0x20(%rsp), %rcx
movw %dx, 0x12(%rcx)
movw 0x2a(%rsp), %cx
movw %cx, 0x18(%rdi)
movw 0x28(%rsp), %cx
movw %cx, 0x1a(%rdi)
movw 0x50(%rsp), %cx
movw %cx, 0x1c(%rdi)
movw 0x58(%rsp), %cx
movw %cx, 0x1e(%rdi)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_nine_slice_handle
NK_API struct nk_nine_slice
nk_nine_slice_handle(nk_handle handle, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b)
{
    struct nk_nine_slice s;
    struct nk_image *i = &s.img;
    nk_zero(&s, sizeof(s));
    i->handle = handle;
    i->w = 0; i->h = 0;
    i->region[0] = 0;
    i->region[1] = 0;
    i->region[2] = 0;
    i->region[3] = 0;
    s.l = l; s.t = t; s.r = r; s.b = b;
    return s;
}

// Assembly:
subq $0x38, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %eax
movl 0x4(%rsp), %ecx
movl %eax, 0x8(%rsp)
movl %edx, %eax
movl 0x8(%rsp), %edx
movl %eax, 0xc(%rsp)
movq %rsi, %r8
movl 0xc(%rsp), %esi
movq %rdi, 0x10(%rsp)
movw %r9w, %ax
movq %rdi, %r9
movq %r9, 0x18(%rsp)
movq %r8, 0x30(%rsp)
movw %si, 0x2e(%rsp)
movw %dx, 0x2c(%rsp)
movw %cx, 0x2a(%rsp)
movw %ax, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x20, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
movq %rdx, (%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0x8(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0xa(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0xc(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0xe(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0x10(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0x12(%rcx)
movw 0x2e(%rsp), %cx
movw %cx, 0x18(%rdi)
movw 0x2c(%rsp), %cx
movw %cx, 0x1a(%rdi)
movw 0x2a(%rsp), %cx
movw %cx, 0x1c(%rdi)
movw 0x28(%rsp), %cx
movw %cx, 0x1e(%rdi)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_nine_slice_ptr
NK_API struct nk_nine_slice
nk_nine_slice_ptr(void *ptr, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b)
{
    struct nk_nine_slice s;
    struct nk_image *i = &s.img;
    nk_zero(&s, sizeof(s));
    NK_ASSERT(ptr);
    i->handle.ptr = ptr;
    i->w = 0; i->h = 0;
    i->region[0] = 0;
    i->region[1] = 0;
    i->region[2] = 0;
    i->region[3] = 0;
    s.l = l; s.t = t; s.r = r; s.b = b;
    return s;
}

// Assembly:
subq $0x38, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %eax
movl 0x4(%rsp), %ecx
movl %eax, 0x8(%rsp)
movl %edx, %eax
movl 0x8(%rsp), %edx
movl %eax, 0xc(%rsp)
movq %rsi, %r8
movl 0xc(%rsp), %esi
movq %rdi, 0x10(%rsp)
movw %r9w, %ax
movq %rdi, %r9
movq %r9, 0x18(%rsp)
movq %r8, 0x30(%rsp)
movw %si, 0x2e(%rsp)
movw %dx, 0x2c(%rsp)
movw %cx, 0x2a(%rsp)
movw %ax, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x20, %esi
callq 0x2f0e0
cmpq $0x0, 0x30(%rsp)
jne 0x68b98
movq 0x5c484(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x4882a(%rip), %rsi     # 0xb13a0
leaq 0x48841(%rip), %rdx     # 0xb13be
movl $0x5dba, %ecx           # imm = 0x5DBA
movb $0x0, %al
callq 0x13ec0
movq 0x5c460(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68b9a
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x20(%rsp), %rdx
movw $0x0, 0x8(%rdx)
movq 0x20(%rsp), %rdx
movw $0x0, 0xa(%rdx)
movq 0x20(%rsp), %rdx
movw $0x0, 0xc(%rdx)
movq 0x20(%rsp), %rdx
movw $0x0, 0xe(%rdx)
movq 0x20(%rsp), %rdx
movw $0x0, 0x10(%rdx)
movq 0x20(%rsp), %rdx
movw $0x0, 0x12(%rdx)
movw 0x2e(%rsp), %dx
movw %dx, 0x18(%rcx)
movw 0x2c(%rsp), %dx
movw %dx, 0x1a(%rcx)
movw 0x2a(%rsp), %dx
movw %dx, 0x1c(%rcx)
movw 0x28(%rsp), %dx
movw %dx, 0x1e(%rcx)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_nine_slice_id
NK_API struct nk_nine_slice
nk_nine_slice_id(int id, nk_ushort l, nk_ushort t, nk_ushort r, nk_ushort b)
{
    struct nk_nine_slice s;
    struct nk_image *i = &s.img;
    nk_zero(&s, sizeof(s));
    i->handle.id = id;
    i->w = 0; i->h = 0;
    i->region[0] = 0;
    i->region[1] = 0;
    i->region[2] = 0;
    i->region[3] = 0;
    s.l = l; s.t = t; s.r = r; s.b = b;
    return s;
}

// Assembly:
subq $0x38, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %eax
movl 0x4(%rsp), %ecx
movl %eax, 0x8(%rsp)
movl %edx, %eax
movl 0x8(%rsp), %edx
movl %eax, 0xc(%rsp)
movl %esi, %r8d
movl 0xc(%rsp), %esi
movq %rdi, 0x10(%rsp)
movw %r9w, %ax
movq %rdi, %r9
movq %r9, 0x18(%rsp)
movl %r8d, 0x34(%rsp)
movw %si, 0x32(%rsp)
movw %dx, 0x30(%rsp)
movw %cx, 0x2e(%rsp)
movw %ax, 0x2c(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x20, %esi
callq 0x2f0e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x34(%rsp), %edx
movq 0x20(%rsp), %rcx
movl %edx, (%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0x8(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0xa(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0xc(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0xe(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0x10(%rcx)
movq 0x20(%rsp), %rcx
movw $0x0, 0x12(%rcx)
movw 0x32(%rsp), %cx
movw %cx, 0x18(%rdi)
movw 0x30(%rsp), %cx
movw %cx, 0x1a(%rdi)
movw 0x2e(%rsp), %cx
movw %cx, 0x1c(%rdi)
movw 0x2c(%rsp), %cx
movw %cx, 0x1e(%rdi)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_button_push_behavior
NK_API nk_bool
nk_button_push_behavior(struct nk_context *ctx, enum nk_button_behavior behavior)
{
    struct nk_config_stack_button_behavior *button_stack;
    struct nk_config_stack_button_behavior_element *element;

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

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

    element = &button_stack->elements[button_stack->head++];
    element->address = &ctx->button_behavior;
    element->old_value = ctx->button_behavior;
    ctx->button_behavior = behavior;
    return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x68e38
movq 0x5c1e4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x4858a(%rip), %rsi     # 0xb13a0
leaq 0x485a1(%rip), %rdx     # 0xb13be
movl $0x5f76, %ecx           # imm = 0x5F76
movb $0x0, %al
callq 0x13ec0
movq 0x5c1c0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68e3a
cmpq $0x0, 0x18(%rsp)
jne 0x68e4f
movl $0x0, 0x24(%rsp)
jmp 0x68f19
movq 0x18(%rsp), %rax
addq $0x25a0, %rax           # imm = 0x25A0
addq $0xab0, %rax            # imm = 0xAB0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x8, (%rax)
jl 0x68ea2
movq 0x5c17a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x48520(%rip), %rsi     # 0xb13a0
leaq 0x48537(%rip), %rdx     # 0xb13be
movl $0x5f7a, %ecx           # imm = 0x5F7A
movb $0x0, %al
callq 0x13ec0
movq 0x5c156(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68ea4
movq 0x8(%rsp), %rax
cmpl $0x8, (%rax)
jl 0x68eb8
movl $0x0, 0x24(%rsp)
jmp 0x68f19
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
addq $0x259c, %rcx           # imm = 0x259C
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl 0x259c(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x259c(%rax)
movl $0x1, 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_button_pop_behavior
NK_API nk_bool
nk_button_pop_behavior(struct nk_context *ctx)
{
    struct nk_config_stack_button_behavior *button_stack;
    struct nk_config_stack_button_behavior_element *element;

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

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x68f74
movq 0x5c0a8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x4844e(%rip), %rsi     # 0xb13a0
leaq 0x48465(%rip), %rdx     # 0xb13be
movl $0x5f8a, %ecx           # imm = 0x5F8A
movb $0x0, %al
callq 0x13ec0
movq 0x5c084(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68f76
cmpq $0x0, 0x18(%rsp)
jne 0x68f8b
movl $0x0, 0x24(%rsp)
jmp 0x69032
movq 0x18(%rsp), %rax
addq $0x25a0, %rax           # imm = 0x25A0
addq $0xab0, %rax            # imm = 0xAB0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jg 0x68fde
movq 0x5c03e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x483e4(%rip), %rsi     # 0xb13a0
leaq 0x483fb(%rip), %rdx     # 0xb13be
movl $0x5f8e, %ecx           # imm = 0x5F8E
movb $0x0, %al
callq 0x13ec0
movq 0x5c01a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x68fe0
movq 0x10(%rsp), %rax
cmpl $0x1, (%rax)
jge 0x68ff4
movl $0x0, 0x24(%rsp)
jmp 0x69032
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x10(%rsp), %rdx
movl (%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_check_flags_text
NK_API unsigned int
nk_check_flags_text(struct nk_context *ctx, const char *text, int len,
    unsigned int flags, unsigned int value)
{
    int old_active;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    if (!ctx || !text) return flags;
    old_active = (int)((flags & value) & value);
    if (nk_check_text(ctx, text, len, old_active))
        flags |= value;
    else flags &= ~value;
    return flags;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x6b6f6
movq 0x59926(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45ccc(%rip), %rsi     # 0xb13a0
leaq 0x45ce3(%rip), %rdx     # 0xb13be
movl $0x6187, %ecx           # imm = 0x6187
movb $0x0, %al
callq 0x13ec0
movq 0x59902(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b6f8
jmp 0x6b6fa
cmpq $0x0, 0x10(%rsp)
jne 0x6b735
movq 0x598e7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45c8d(%rip), %rsi     # 0xb13a0
leaq 0x45ca4(%rip), %rdx     # 0xb13be
movl $0x6188, %ecx           # imm = 0x6188
movb $0x0, %al
callq 0x13ec0
movq 0x598c3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b737
cmpq $0x0, 0x18(%rsp)
je 0x6b747
cmpq $0x0, 0x10(%rsp)
jne 0x6b751
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6b7a0
movl 0x8(%rsp), %eax
andl 0x4(%rsp), %eax
andl 0x4(%rsp), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl (%rsp), %ecx
callq 0x14560
cmpl $0x0, %eax
je 0x6b789
movl 0x4(%rsp), %eax
orl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x6b798
movl 0x4(%rsp), %eax
xorl $-0x1, %eax
andl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_checkbox_text
NK_API nk_bool
nk_checkbox_text(struct nk_context *ctx, const char *text, int len, nk_bool *active)
{
    int old_val;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_val = *active;
    *active = nk_check_text(ctx, text, len, *active);
    return old_val != *active;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6b802
movq 0x5981a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45bc0(%rip), %rsi     # 0xb13a0
leaq 0x45bd7(%rip), %rdx     # 0xb13be
movl $0x6194, %ecx           # imm = 0x6194
movb $0x0, %al
callq 0x13ec0
movq 0x597f6(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b804
jmp 0x6b806
cmpq $0x0, 0x20(%rsp)
jne 0x6b841
movq 0x597db(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45b81(%rip), %rsi     # 0xb13a0
leaq 0x45b98(%rip), %rdx     # 0xb13be
movl $0x6195, %ecx           # imm = 0x6195
movb $0x0, %al
callq 0x13ec0
movq 0x597b7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b843
jmp 0x6b845
cmpq $0x0, 0x10(%rsp)
jne 0x6b880
movq 0x5979c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45b42(%rip), %rsi     # 0xb13a0
leaq 0x45b59(%rip), %rdx     # 0xb13be
movl $0x6196, %ecx           # imm = 0x6196
movb $0x0, %al
callq 0x13ec0
movq 0x59778(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b882
cmpq $0x0, 0x28(%rsp)
je 0x6b89a
cmpq $0x0, 0x20(%rsp)
je 0x6b89a
cmpq $0x0, 0x10(%rsp)
jne 0x6b8a4
movl $0x0, 0x34(%rsp)
jmp 0x6b8e9
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rax
movl (%rax), %ecx
callq 0x14560
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_checkbox_text_align
NK_API nk_bool
nk_checkbox_text_align(struct nk_context *ctx, const char *text, int len, nk_bool *active, nk_flags widget_alignment, nk_flags text_alignment)
{
    int old_val;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_val = *active;
    *active = nk_check_text_align(ctx, text, len, *active, widget_alignment, text_alignment);
    return old_val != *active;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6b95c
movq 0x596c0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45a66(%rip), %rsi     # 0xb13a0
leaq 0x45a7d(%rip), %rdx     # 0xb13be
movl $0x61a0, %ecx           # imm = 0x61A0
movb $0x0, %al
callq 0x13ec0
movq 0x5969c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b95e
jmp 0x6b960
cmpq $0x0, 0x20(%rsp)
jne 0x6b99b
movq 0x59681(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45a27(%rip), %rsi     # 0xb13a0
leaq 0x45a3e(%rip), %rdx     # 0xb13be
movl $0x61a1, %ecx           # imm = 0x61A1
movb $0x0, %al
callq 0x13ec0
movq 0x5965d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b99d
jmp 0x6b99f
cmpq $0x0, 0x10(%rsp)
jne 0x6b9da
movq 0x59642(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x459e8(%rip), %rsi     # 0xb13a0
leaq 0x459ff(%rip), %rdx     # 0xb13be
movl $0x61a2, %ecx           # imm = 0x61A2
movb $0x0, %al
callq 0x13ec0
movq 0x5961e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6b9dc
cmpq $0x0, 0x28(%rsp)
je 0x6b9f4
cmpq $0x0, 0x20(%rsp)
je 0x6b9f4
cmpq $0x0, 0x10(%rsp)
jne 0x6b9fe
movl $0x0, 0x34(%rsp)
jmp 0x6ba4d
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
callq 0x14280
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_checkbox_flags_text
NK_API nk_bool
nk_checkbox_flags_text(struct nk_context *ctx, const char *text, int len,
    unsigned int *flags, unsigned int value)
{
    nk_bool active;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(flags);
    if (!ctx || !text || !flags) return 0;

    active = (int)((*flags & value) & value);
    if (nk_checkbox_text(ctx, text, len, &active)) {
        if (active) *flags |= value;
        else *flags &= ~value;
        return 1;
    }
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6bab7
movq 0x59565(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x4590b(%rip), %rsi     # 0xb13a0
leaq 0x45922(%rip), %rdx     # 0xb13be
movl $0x61ad, %ecx           # imm = 0x61AD
movb $0x0, %al
callq 0x13ec0
movq 0x59541(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6bab9
jmp 0x6babb
cmpq $0x0, 0x20(%rsp)
jne 0x6baf6
movq 0x59526(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x458cc(%rip), %rsi     # 0xb13a0
leaq 0x458e3(%rip), %rdx     # 0xb13be
movl $0x61ae, %ecx           # imm = 0x61AE
movb $0x0, %al
callq 0x13ec0
movq 0x59502(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6baf8
jmp 0x6bafa
cmpq $0x0, 0x10(%rsp)
jne 0x6bb35
movq 0x594e7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x4588d(%rip), %rsi     # 0xb13a0
leaq 0x458a4(%rip), %rdx     # 0xb13be
movl $0x61af, %ecx           # imm = 0x61AF
movb $0x0, %al
callq 0x13ec0
movq 0x594c3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6bb37
cmpq $0x0, 0x28(%rsp)
je 0x6bb4f
cmpq $0x0, 0x20(%rsp)
je 0x6bb4f
cmpq $0x0, 0x10(%rsp)
jne 0x6bb59
movl $0x0, 0x34(%rsp)
jmp 0x6bbc1
movq 0x10(%rsp), %rax
movl (%rax), %eax
andl 0xc(%rsp), %eax
andl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
leaq 0x8(%rsp), %rcx
callq 0x13350
cmpl $0x0, %eax
je 0x6bbb9
cmpl $0x0, 0x8(%rsp)
je 0x6bb9f
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x6bbaf
movl 0xc(%rsp), %ecx
xorl $-0x1, %ecx
movq 0x10(%rsp), %rax
andl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, 0x34(%rsp)
jmp 0x6bbc1
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_radio_text
NK_API nk_bool
nk_radio_text(struct nk_context *ctx, const char *text, int len, nk_bool *active)
{
    int old_value;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_value = *active;
    *active = nk_option_text(ctx, text, len, old_value);
    return old_value != *active;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6c2b2
movq 0x58d6a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45110(%rip), %rsi     # 0xb13a0
leaq 0x45127(%rip), %rdx     # 0xb13be
movl $0x6211, %ecx           # imm = 0x6211
movb $0x0, %al
callq 0x13ec0
movq 0x58d46(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6c2b4
jmp 0x6c2b6
cmpq $0x0, 0x20(%rsp)
jne 0x6c2f1
movq 0x58d2b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x450d1(%rip), %rsi     # 0xb13a0
leaq 0x450e8(%rip), %rdx     # 0xb13be
movl $0x6212, %ecx           # imm = 0x6212
movb $0x0, %al
callq 0x13ec0
movq 0x58d07(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6c2f3
jmp 0x6c2f5
cmpq $0x0, 0x10(%rsp)
jne 0x6c330
movq 0x58cec(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x45092(%rip), %rsi     # 0xb13a0
leaq 0x450a9(%rip), %rdx     # 0xb13be
movl $0x6213, %ecx           # imm = 0x6213
movb $0x0, %al
callq 0x13ec0
movq 0x58cc8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6c332
cmpq $0x0, 0x28(%rsp)
je 0x6c34a
cmpq $0x0, 0x20(%rsp)
je 0x6c34a
cmpq $0x0, 0x10(%rsp)
jne 0x6c354
movl $0x0, 0x34(%rsp)
jmp 0x6c396
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x14b60
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_radio_text_align
NK_API nk_bool
nk_radio_text_align(struct nk_context *ctx, const char *text, int len, nk_bool *active, nk_flags widget_alignment, nk_flags text_alignment)
{
    int old_value;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_value = *active;
    *active = nk_option_text_align(ctx, text, len, old_value, widget_alignment, text_alignment);
    return old_value != *active;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6c3fc
movq 0x58c20(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x44fc6(%rip), %rsi     # 0xb13a0
leaq 0x44fdd(%rip), %rdx     # 0xb13be
movl $0x621d, %ecx           # imm = 0x621D
movb $0x0, %al
callq 0x13ec0
movq 0x58bfc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6c3fe
jmp 0x6c400
cmpq $0x0, 0x20(%rsp)
jne 0x6c43b
movq 0x58be1(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x44f87(%rip), %rsi     # 0xb13a0
leaq 0x44f9e(%rip), %rdx     # 0xb13be
movl $0x621e, %ecx           # imm = 0x621E
movb $0x0, %al
callq 0x13ec0
movq 0x58bbd(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6c43d
jmp 0x6c43f
cmpq $0x0, 0x10(%rsp)
jne 0x6c47a
movq 0x58ba2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x44f48(%rip), %rsi     # 0xb13a0
leaq 0x44f5f(%rip), %rdx     # 0xb13be
movl $0x621f, %ecx           # imm = 0x621F
movb $0x0, %al
callq 0x13ec0
movq 0x58b7e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x6c47c
cmpq $0x0, 0x28(%rsp)
je 0x6c494
cmpq $0x0, 0x20(%rsp)
je 0x6c494
cmpq $0x0, 0x10(%rsp)
jne 0x6c49e
movl $0x0, 0x34(%rsp)
jmp 0x6c4ea
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x4(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
callq 0x14bc0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_slider_int
NK_API nk_bool
nk_slider_int(struct nk_context *ctx, int min, int *val, int max, int step)
{
    int ret;
    float value = (float)*val;
    ret = nk_slider_float(ctx, (float)min, &value, (float)max, (float)step);
    *val =  (int)value;
    return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq 0x10(%rsp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
cvtsi2ssl 0x1c(%rsp), %xmm0
cvtsi2ssl 0xc(%rsp), %xmm1
cvtsi2ssl 0x8(%rsp), %xmm2
movq %rsp, %rsi
callq 0x144a0
movl %eax, 0x4(%rsp)
cvttss2si (%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%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_textedit_makeundo_delete
NK_INTERN void
nk_textedit_makeundo_delete(struct nk_text_edit *state, int where, int length)
{
    int i;
    nk_rune *p = nk_textedit_createundo(&state->undo, where, length, 0);
    if (p) {
        for (i=0; i < length; ++i)
            p[i] = nk_str_rune_at(&state->string, where+i);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0xc0, %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
xorl %ecx, %ecx
callq 0x8bb80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6f5bf
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x6f5bd
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movl 0x1c(%rsp), %esi
addl 0x14(%rsp), %esi
callq 0x13a90
movl %eax, %edx
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6f581
jmp 0x6f5bf
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_delete_selection
NK_API void
nk_textedit_delete_selection(struct nk_text_edit *state)
{
    /* delete the section */
    nk_textedit_clamp(state);
    if (NK_TEXT_HAS_SELECTION(state)) {
        if (state->select_start < state->select_end) {
            nk_textedit_delete(state, state->select_start,
                state->select_end - state->select_start);
            state->select_end = state->cursor = state->select_start;
        } else {
            nk_textedit_delete(state, state->select_end,
                state->select_start - state->select_end);
            state->select_start = state->cursor = state->select_end;
        }
        state->has_preferred_x = 0;
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x6f6b0
movq (%rsp), %rax
movl 0xac(%rax), %eax
movq (%rsp), %rcx
cmpl 0xb0(%rcx), %eax
je 0x6f6a5
movq (%rsp), %rax
movl 0xac(%rax), %eax
movq (%rsp), %rcx
cmpl 0xb0(%rcx), %eax
jge 0x6f655
movq (%rsp), %rdi
movq (%rsp), %rax
movl 0xac(%rax), %esi
movq (%rsp), %rax
movl 0xb0(%rax), %edx
movq (%rsp), %rax
subl 0xac(%rax), %edx
callq 0x133b0
movq (%rsp), %rax
movl 0xac(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xa8(%rax)
movq (%rsp), %rax
movl %ecx, 0xb0(%rax)
jmp 0x6f69a
movq (%rsp), %rdi
movq (%rsp), %rax
movl 0xb0(%rax), %esi
movq (%rsp), %rax
movl 0xac(%rax), %edx
movq (%rsp), %rax
subl 0xb0(%rax), %edx
callq 0x133b0
movq (%rsp), %rax
movl 0xb0(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xa8(%rax)
movq (%rsp), %rax
movl %ecx, 0xac(%rax)
movq (%rsp), %rax
movb $0x0, 0xb7(%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_clamp
NK_INTERN void
nk_textedit_clamp(struct nk_text_edit *state)
{
    /* make the selection/cursor state valid if client altered the string */
    int n = state->string.len;
    if (NK_TEXT_HAS_SELECTION(state)) {
        if (state->select_start > n) state->select_start = n;
        if (state->select_end   > n) state->select_end = n;
        /* if clamping forced them to be equal, move the cursor to match */
        if (state->select_start == state->select_end)
            state->cursor = state->select_start;
    }
    if (state->cursor > n) state->cursor = n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x90(%rax), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0xac(%rax), %eax
movq -0x8(%rsp), %rcx
cmpl 0xb0(%rcx), %eax
je 0x6f74c
movq -0x8(%rsp), %rax
movl 0xac(%rax), %eax
cmpl -0xc(%rsp), %eax
jle 0x6f6fc
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xac(%rax)
movq -0x8(%rsp), %rax
movl 0xb0(%rax), %eax
cmpl -0xc(%rsp), %eax
jle 0x6f71c
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xb0(%rax)
movq -0x8(%rsp), %rax
movl 0xac(%rax), %eax
movq -0x8(%rsp), %rcx
cmpl 0xb0(%rcx), %eax
jne 0x6f74a
movq -0x8(%rsp), %rax
movl 0xac(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xa8(%rax)
jmp 0x6f74c
movq -0x8(%rsp), %rax
movl 0xa8(%rax), %eax
cmpl -0xc(%rsp), %eax
jle 0x6f76c
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xa8(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_cut
NK_API nk_bool
nk_textedit_cut(struct nk_text_edit *state)
{
    /* API cut: delete selection */
    if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
        return 0;
    if (NK_TEXT_HAS_SELECTION(state)) {
        nk_textedit_delete_selection(state); /* implicitly clamps */
        state->has_preferred_x = 0;
        return 1;
    }
   return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0xb4(%rax), %eax
cmpl $0x0, %eax
jne 0x6f794
movl $0x0, 0x14(%rsp)
jmp 0x6f7d4
movq 0x8(%rsp), %rax
movl 0xac(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0xb0(%rcx), %eax
je 0x6f7cc
movq 0x8(%rsp), %rdi
callq 0x150d0
movq 0x8(%rsp), %rax
movb $0x0, 0xb7(%rax)
movl $0x1, 0x14(%rsp)
jmp 0x6f7d4
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_paste
NK_API nk_bool
nk_textedit_paste(struct nk_text_edit *state, char const *ctext, int len)
{
    /* API paste: replace existing selection with passed-in text */
    int glyphs;
    const char *text = (const char *) ctext;
    if (state->mode == NK_TEXT_EDIT_MODE_VIEW) return 0;

    /* if there's a selection, the paste should delete it */
    nk_textedit_clamp(state);
    nk_textedit_delete_selection(state);

    /* try to insert the characters */
    glyphs = nk_utf_len(ctext, len);
    if (nk_str_insert_text_char(&state->string, state->cursor, text, len)) {
        nk_textedit_makeundo_insert(state, state->cursor, glyphs);
        state->cursor += len;
        state->has_preferred_x = 0;
        return 1;
    }
    /* remove the undo since we didn't actually insert the characters */
    if (state->undo.undo_point)
        --state->undo.undo_point;
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movzbl 0xb4(%rax), %eax
cmpl $0x0, %eax
jne 0x6f819
movl $0x0, 0x24(%rsp)
jmp 0x6f8d7
movq 0x18(%rsp), %rdi
callq 0x6f6b0
movq 0x18(%rsp), %rdi
callq 0x150d0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x137e0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %esi
movq (%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x13490
cmpl $0x0, %eax
je 0x6f8a9
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %esi
movl 0x8(%rsp), %edx
callq 0x6f8e0
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0xa8(%rax), %ecx
movl %ecx, 0xa8(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0xb7(%rax)
movl $0x1, 0x24(%rsp)
jmp 0x6f8d7
movq 0x18(%rsp), %rax
cmpw $0x0, 0x1500(%rax)
je 0x6f8cf
movq 0x18(%rsp), %rax
movw 0x1500(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x1500(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_makeundo_replace
NK_INTERN void
nk_textedit_makeundo_replace(struct nk_text_edit *state, int where,
    int old_length, int new_length)
{
    int i;
    nk_rune *p = nk_textedit_createundo(&state->undo, where, old_length, new_length);
    if (p) {
        for (i=0; i < old_length; ++i)
            p[i] = nk_str_rune_at(&state->string, where+i);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
addq $0xc0, %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movl 0x14(%rsp), %ecx
callq 0x8bb80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6fcc5
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x6fcc3
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movl 0x1c(%rsp), %esi
addl 0x10(%rsp), %esi
callq 0x13a90
movl %eax, %edx
movq 0x8(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x6fc87
jmp 0x6fcc5
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_textedit_init_fixed
NK_API void
nk_textedit_init_fixed(struct nk_text_edit *state, void *memory, nk_size size)
{
    NK_ASSERT(state);
    NK_ASSERT(memory);
    if (!state || !memory || !size) return;
    NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
    nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
    nk_str_init_fixed(&state->string, memory, size);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x703fd
movq 0x54c1f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x40fc5(%rip), %rsi     # 0xb13a0
leaq 0x40fdc(%rip), %rdx     # 0xb13be
movl $0x6a3f, %ecx           # imm = 0x6A3F
movb $0x0, %al
callq 0x13ec0
movq 0x54bfb(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x703ff
jmp 0x70401
cmpq $0x0, 0x8(%rsp)
jne 0x7043c
movq 0x54be0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x40f86(%rip), %rsi     # 0xb13a0
leaq 0x40f9d(%rip), %rdx     # 0xb13be
movl $0x6a40, %ecx           # imm = 0x6A40
movb $0x0, %al
callq 0x13ec0
movq 0x54bbc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x7043e
cmpq $0x0, 0x10(%rsp)
je 0x70455
cmpq $0x0, 0x8(%rsp)
je 0x70455
cmpq $0x0, (%rsp)
jne 0x70457
jmp 0x7048f
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 0x15290
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)