LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__next
NK_API const struct nk_command*
nk__next(struct nk_context *ctx, const struct nk_command *cmd)
{
    nk_byte *buffer;
    const struct nk_command *next;
    NK_ASSERT(ctx);
    if (!ctx || !cmd || !ctx->count) return 0;
    if (cmd->next >= ctx->memory.allocated) return 0;
    buffer = (nk_byte*)ctx->memory.memory.ptr;
    next = nk_ptr_add_const(struct nk_command, buffer, cmd->next);
    return next;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x3c0f9
movq 0x88f23(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x752c9(%rip), %rsi     # 0xb13a0
leaq 0x752e0(%rip), %rdx     # 0xb13be
movl $0x4ba4, %ecx           # imm = 0x4BA4
movb $0x0, %al
callq 0x13ec0
movq 0x88eff(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3c0fb
cmpq $0x0, 0x18(%rsp)
je 0x3c119
cmpq $0x0, 0x10(%rsp)
je 0x3c119
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4790(%rax)
jne 0x3c124
movq $0x0, 0x20(%rsp)
jmp 0x3c172
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x2560(%rcx), %rax
jb 0x3c146
movq $0x0, 0x20(%rsp)
jmp 0x3c172
movq 0x18(%rsp), %rax
movq 0x2548(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x8(%rcx), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: stbrp_setup_heuristic
STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
{
   switch (context->init_mode) {
      case STBRP__INIT_skyline:
         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
         context->heuristic = heuristic;
         break;
      default:
         STBRP_ASSERT(0);
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
jne 0x3c279
jmp 0x3c23c
cmpl $0x0, 0xc(%rsp)
je 0x3c24a
cmpl $0x1, 0xc(%rsp)
jne 0x3c24c
jmp 0x3c26b
leaq 0x7517f(%rip), %rdi     # 0xb13d2
leaq 0x75164(%rip), %rsi     # 0xb13be
movl $0x2b3a, %edx           # imm = 0x2B3A
leaq 0x751d5(%rip), %rcx     # 0xb143b
callq 0x13b40
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x3c298
leaq 0x752a1(%rip), %rdi     # 0xb1521
leaq 0x75137(%rip), %rsi     # 0xb13be
movl $0x2b3e, %edx           # imm = 0x2B3E
leaq 0x751a8(%rip), %rcx     # 0xb143b
callq 0x13b40
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: stbrp_init_target
STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
{
   int i;

   for (i=0; i < num_nodes-1; ++i)
      nodes[i].next = &nodes[i+1];
   nodes[i].next = NULL;
   context->init_mode = STBRP__INIT_skyline;
   context->heuristic = STBRP_HEURISTIC_Skyline_default;
   context->free_head = &nodes[0];
   context->active_head = &context->extra[0];
   context->width = width;
   context->height = height;
   context->num_nodes = num_nodes;
   stbrp_setup_allow_out_of_mem(context, 0);

   /*  node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) */
   context->extra[0].x = 0;
   context->extra[0].y = 0;
   context->extra[0].next = &context->extra[1];
   context->extra[1].x = (stbrp_coord) width;
   context->extra[1].y = (1<<30);
   context->extra[1].next = NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3c359
movq 0x10(%rsp), %rcx
movl 0x8(%rsp), %eax
addl $0x1, %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3c313
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0x1, 0xc(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rcx
addq $0x28, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x148d0
movq 0x20(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x20(%rsp), %rcx
addq $0x28, %rcx
addq $0x10, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x38(%rax)
movq 0x20(%rsp), %rax
movl $0x40000000, 0x3c(%rax) # imm = 0x40000000
movq 0x20(%rsp), %rax
movq $0x0, 0x40(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: rect_height_compare
static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
{
   const stbrp_rect *p = (const stbrp_rect *) a;
   const stbrp_rect *q = (const stbrp_rect *) b;
   if (p->h > q->h)
      return -1;
   if (p->h < q->h)
      return  1;
   return (p->w > q->w) ? -1 : (p->w < q->w);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x3c6ea
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x3c747
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3c706
movl $0x1, -0x4(%rsp)
jmp 0x3c747
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x3c723
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rsp)
jmp 0x3c73f
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x4(%rcx), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %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: stbtt_GetKerningTableLength
STBTT_DEF int  stbtt_GetKerningTableLength(const stbtt_fontinfo *info)
{
   stbtt_uint8 *data = info->data + info->kern;

   /*  we only look at the first table. it must be 'horizontal' and format 0. */
   if (!info->kern)
      return 0;
   if (ttUSHORT(data+2) < 1) /*  number of tables, need at least 1 */
      return 0;
   if (ttUSHORT(data+8) != 1) /*  horizontal flag must be set in format */
      return 0;

   return ttUSHORT(data+10);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x2c(%rcx), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x3e9f7
movl $0x0, 0x14(%rsp)
jmp 0x3ea49
movq (%rsp), %rdi
addq $0x2, %rdi
callq 0x3cf00
movzwl %ax, %eax
cmpl $0x1, %eax
jge 0x3ea16
movl $0x0, 0x14(%rsp)
jmp 0x3ea49
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x3cf00
movzwl %ax, %eax
cmpl $0x1, %eax
je 0x3ea35
movl $0x0, 0x14(%rsp)
jmp 0x3ea49
movq (%rsp), %rdi
addq $0xa, %rdi
callq 0x3cf00
movzwl %ax, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: stbtt_GetKerningTable
STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length)
{
   stbtt_uint8 *data = info->data + info->kern;
   int k, length;

   /*  we only look at the first table. it must be 'horizontal' and format 0. */
   if (!info->kern)
      return 0;
   if (ttUSHORT(data+2) < 1) /*  number of tables, need at least 1 */
      return 0;
   if (ttUSHORT(data+8) != 1) /*  horizontal flag must be set in format */
      return 0;

   length = ttUSHORT(data+10);
   if (table_length < length)
      length = table_length;

   for (k = 0; k < length; k++)
   {
      table[k].glyph1 = ttUSHORT(data+18+(k*6));
      table[k].glyph2 = ttUSHORT(data+20+(k*6));
      table[k].advance = ttSHORT(data+22+(k*6));
   }

   return length;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x2c(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x3eaa4
movl $0x0, 0x34(%rsp)
jmp 0x3ebcb
movq 0x10(%rsp), %rdi
addq $0x2, %rdi
callq 0x3cf00
movzwl %ax, %eax
cmpl $0x1, %eax
jge 0x3eac7
movl $0x0, 0x34(%rsp)
jmp 0x3ebcb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3cf00
movzwl %ax, %eax
cmpl $0x1, %eax
je 0x3eaea
movl $0x0, 0x34(%rsp)
jmp 0x3ebcb
movq 0x10(%rsp), %rdi
addq $0xa, %rdi
callq 0x3cf00
movzwl %ax, %eax
movl %eax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x3eb11
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x3ebc3
movq 0x10(%rsp), %rdi
addq $0x12, %rdi
imull $0x6, 0xc(%rsp), %eax
cltq
addq %rax, %rdi
callq 0x3cf00
movzwl %ax, %ecx
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
addq $0x14, %rdi
imull $0x6, 0xc(%rsp), %eax
cltq
addq %rax, %rdi
callq 0x3cf00
movzwl %ax, %ecx
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rdi
addq $0x16, %rdi
imull $0x6, 0xc(%rsp), %eax
cltq
addq %rax, %rdi
callq 0x3cf20
movswl %ax, %ecx
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3eb19
movl 0x8(%rsp), %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: stbtt_FindSVGDoc
STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)
{
   int i;
   stbtt_uint8 *data = info->data;
   stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info);

   int numEntries = ttUSHORT(svg_doc_list);
   stbtt_uint8 *svg_docs = svg_doc_list + 2;

   for(i=0; i<numEntries; i++) {
      stbtt_uint8 *svg_doc = svg_docs + (12 * i);
      if ((gl >= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2)))
         return svg_doc;
   }
   return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3fa80
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3cf00
movzwl %ax, %eax
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x3fa66
movq 0x20(%rsp), %rax
imull $0xc, 0x40(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3cf00
movw %ax, %cx
movl 0xc(%rsp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jl 0x3fa57
movl 0x44(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq $0x2, %rdi
callq 0x3cf00
movw %ax, %cx
movl 0x8(%rsp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jg 0x3fa57
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x3fa6f
jmp 0x3fa59
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x3f9e8
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: stbtt__get_svg
static int stbtt__get_svg(stbtt_fontinfo *info)
{
   stbtt_uint32 t;
   if (info->svg < 0) {
      t = stbtt__find_table(info->data, info->fontstart, "SVG ");
      if (t) {
         stbtt_uint32 offset = ttULONG(info->data + t + 2);
         info->svg = t + offset;
      } else {
         info->svg = 0;
      }
   }
   return info->svg;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x34(%rax)
jge 0x3faf9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
leaq 0x7209e(%rip), %rdx     # 0xb1b4a
callq 0x3f670
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x3faeb
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %eax
addq %rax, %rdi
addq $0x2, %rdi
callq 0x3cf40
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %ecx
addl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x34(%rax)
jmp 0x3faf7
movq 0x10(%rsp), %rax
movl $0x0, 0x34(%rax)
jmp 0x3faf9
movq 0x10(%rsp), %rax
movl 0x34(%rax), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: stbtt_GetGlyphSVG
STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg)
{
   stbtt_uint8 *data = info->data;
   stbtt_uint8 *svg_doc;

   if (info->svg == 0)
      return 0;

   svg_doc = stbtt_FindSVGDoc(info, gl);
   if (svg_doc != NULL) {
      *svg = (char *) data + info->svg + ttULONG(svg_doc + 4);
      return ttULONG(svg_doc + 8);
   } else {
      return 0;
   }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x3fb45
movl $0x0, 0x34(%rsp)
jmp 0x3fbb0
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x13c20
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3fba8
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x34(%rcx), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
callq 0x3cf40
movq (%rsp), %rcx
movl %eax, %eax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x3cf40
movl %eax, 0x34(%rsp)
jmp 0x3fbb0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_range_count
NK_INTERN int
nk_range_count(const nk_rune *range)
{
    const nk_rune *iter = range;
    NK_ASSERT(range);
    if (!range) return 0;
    while (*(iter++) != 0);
    return (iter == range) ? 0 : (int)((iter - range)/2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x46fbe
movq 0x7e05e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a404(%rip), %rsi     # 0xb13a0
leaq 0x6a41b(%rip), %rdx     # 0xb13be
movl $0x40cd, %ecx           # imm = 0x40CD
movb $0x0, %al
callq 0x13ec0
movq 0x7e03a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x46fc0
cmpq $0x0, 0x18(%rsp)
jne 0x46fd2
movl $0x0, 0x24(%rsp)
jmp 0x47027
jmp 0x46fd4
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rsp)
cmpl $0x0, (%rax)
je 0x46fec
jmp 0x46fd4
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x47000
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x4701f
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 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_font_config
NK_API struct nk_font_config
nk_font_config(float pixel_height)
{
    struct nk_font_config cfg;
    nk_zero_struct(cfg);
    cfg.ttf_blob = 0;
    cfg.ttf_size = 0;
    cfg.ttf_data_owned_by_atlas = 0;
    cfg.size = pixel_height;
    cfg.oversample_h = 3;
    cfg.oversample_v = 1;
    cfg.pixel_snap = 0;
    cfg.coord_type = NK_COORD_UV;
    cfg.spacing = nk_vec2(0,0);
    cfg.range = nk_font_default_glyph_ranges();
    cfg.merge_mode = 0;
    cfg.fallback_glyph = '?';
    cfg.font = 0;
    cfg.n = 0;
    return cfg;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movss %xmm0, 0x24(%rsp)
movl $0x58, %esi
callq 0x2f0e0
movq 0x8(%rsp), %rdi
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x20(%rdi)
movb $0x3, 0x1c(%rdi)
movb $0x1, 0x1b(%rdi)
movb $0x0, 0x1a(%rdi)
movl $0x0, 0x24(%rdi)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x13460
movq 0x8(%rsp), %rdi
movlpd %xmm0, 0x1c(%rsp)
movq 0x1c(%rsp), %rax
movq %rax, 0x28(%rdi)
callq 0x13330
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rdi)
movb $0x0, 0x19(%rdi)
movl $0x3f, 0x40(%rdi)
movq $0x0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_font_atlas_init_default
NK_API void
nk_font_atlas_init_default(struct nk_font_atlas *atlas)
{
    NK_ASSERT(atlas);
    if (!atlas) return;
    nk_zero_struct(*atlas);
    atlas->temporary.userdata.ptr = 0;
    atlas->temporary.alloc = nk_malloc;
    atlas->temporary.free = nk_mfree;
    atlas->permanent.userdata.ptr = 0;
    atlas->permanent.alloc = nk_malloc;
    atlas->permanent.free = nk_mfree;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4711f
movq 0x7defd(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a2a3(%rip), %rsi     # 0xb13a0
leaq 0x6a2ba(%rip), %rdx     # 0xb13be
movl $0x440b, %ecx           # imm = 0x440B
movb $0x0, %al
callq 0x13ec0
movq 0x7ded9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x47121
cmpq $0x0, (%rsp)
jne 0x4712a
jmp 0x4718c
movq (%rsp), %rdi
movl $0x190, %esi            # imm = 0x190
callq 0x2f0e0
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
leaq -0x1822f(%rip), %rcx    # 0x2ef20
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
leaq -0x1821e(%rip), %rcx    # 0x2ef40
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
leaq -0x18259(%rip), %rcx    # 0x2ef20
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
leaq -0x18248(%rip), %rcx    # 0x2ef40
movq %rcx, 0x20(%rax)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_font_atlas_init
NK_API void
nk_font_atlas_init(struct nk_font_atlas *atlas, struct nk_allocator *alloc)
{
    NK_ASSERT(atlas);
    NK_ASSERT(alloc);
    if (!atlas || !alloc) return;
    nk_zero_struct(*atlas);
    atlas->permanent = *alloc;
    atlas->temporary = *alloc;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x471d9
movq 0x7de43(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a1e9(%rip), %rsi     # 0xb13a0
leaq 0x6a200(%rip), %rdx     # 0xb13be
movl $0x4419, %ecx           # imm = 0x4419
movb $0x0, %al
callq 0x13ec0
movq 0x7de1f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x471db
jmp 0x471dd
cmpq $0x0, 0x8(%rsp)
jne 0x47218
movq 0x7de04(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a1aa(%rip), %rsi     # 0xb13a0
leaq 0x6a1c1(%rip), %rdx     # 0xb13be
movl $0x441a, %ecx           # imm = 0x441A
movb $0x0, %al
callq 0x13ec0
movq 0x7dde0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4721a
cmpq $0x0, 0x10(%rsp)
je 0x4722a
cmpq $0x0, 0x8(%rsp)
jne 0x4722c
jmp 0x4727d
movq 0x10(%rsp), %rdi
movl $0x190, %esi            # imm = 0x190
callq 0x2f0e0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x38(%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_font_atlas_init_custom
NK_API void
nk_font_atlas_init_custom(struct nk_font_atlas *atlas,
    struct nk_allocator *permanent, struct nk_allocator *temporary)
{
    NK_ASSERT(atlas);
    NK_ASSERT(permanent);
    NK_ASSERT(temporary);
    if (!atlas || !permanent || !temporary) return;
    nk_zero_struct(*atlas);
    atlas->permanent = *permanent;
    atlas->temporary = *temporary;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x472dd
movq 0x7dd3f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a0e5(%rip), %rsi     # 0xb13a0
leaq 0x6a0fc(%rip), %rdx     # 0xb13be
movl $0x4424, %ecx           # imm = 0x4424
movb $0x0, %al
callq 0x13ec0
movq 0x7dd1b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x472df
jmp 0x472e1
cmpq $0x0, 0x8(%rsp)
jne 0x4731c
movq 0x7dd00(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a0a6(%rip), %rsi     # 0xb13a0
leaq 0x6a0bd(%rip), %rdx     # 0xb13be
movl $0x4425, %ecx           # imm = 0x4425
movb $0x0, %al
callq 0x13ec0
movq 0x7dcdc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4731e
jmp 0x47320
cmpq $0x0, (%rsp)
jne 0x4735a
movq 0x7dcc2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6a068(%rip), %rsi     # 0xb13a0
leaq 0x6a07f(%rip), %rdx     # 0xb13be
movl $0x4426, %ecx           # imm = 0x4426
movb $0x0, %al
callq 0x13ec0
movq 0x7dc9e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4735c
cmpq $0x0, 0x10(%rsp)
je 0x47373
cmpq $0x0, 0x8(%rsp)
je 0x47373
cmpq $0x0, (%rsp)
jne 0x47375
jmp 0x473c5
movq 0x10(%rsp), %rdi
movl $0x190, %esi            # imm = 0x190
callq 0x2f0e0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x38(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_font_atlas_begin
NK_API void
nk_font_atlas_begin(struct nk_font_atlas *atlas)
{
    NK_ASSERT(atlas);
    NK_ASSERT(atlas->temporary.alloc && atlas->temporary.free);
    NK_ASSERT(atlas->permanent.alloc && atlas->permanent.free);
    if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free ||
        !atlas->temporary.alloc || !atlas->temporary.free) return;
    if (atlas->glyphs) {
        atlas->permanent.free(atlas->permanent.userdata, atlas->glyphs);
        atlas->glyphs = 0;
    }
    if (atlas->pixel) {
        atlas->permanent.free(atlas->permanent.userdata, atlas->pixel);
        atlas->pixel = 0;
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4740f
movq 0x7dc0d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x69fb3(%rip), %rsi     # 0xb13a0
leaq 0x69fca(%rip), %rdx     # 0xb13be
movl $0x442f, %ecx           # imm = 0x442F
movb $0x0, %al
callq 0x13ec0
movq 0x7dbe9(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x47411
jmp 0x47413
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x47429
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x4745c
movq 0x7dbc0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x69f66(%rip), %rsi     # 0xb13a0
leaq 0x69f7d(%rip), %rdx     # 0xb13be
movl $0x4430, %ecx           # imm = 0x4430
movb $0x0, %al
callq 0x13ec0
movq 0x7db9c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4745e
jmp 0x47460
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x47476
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x474a9
movq 0x7db73(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x69f19(%rip), %rsi     # 0xb13a0
leaq 0x69f30(%rip), %rdx     # 0xb13be
movl $0x4431, %ecx           # imm = 0x4431
movb $0x0, %al
callq 0x13ec0
movq 0x7db4f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x474ab
cmpq $0x0, (%rsp)
je 0x474de
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x474de
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x474de
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x474de
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x474e0
jmp 0x47548
movq (%rsp), %rax
cmpq $0x0, 0x168(%rax)
je 0x4751a
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movq (%rsp), %rdx
movq 0x168(%rdx), %rsi
movq 0x10(%rcx), %rdi
callq *%rax
movq (%rsp), %rax
movq $0x0, 0x168(%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x47548
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movq (%rsp), %rdx
movq (%rdx), %rsi
movq 0x10(%rcx), %rdi
callq *%rax
movq (%rsp), %rax
movq $0x0, (%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_decode_85
NK_INTERN void
nk_decode_85(unsigned char* dst, const unsigned char* src)
{
    while (*src)
    {
        unsigned int tmp =
            nk_decode_85_byte((char)src[0]) +
            85 * (nk_decode_85_byte((char)src[1]) +
            85 * (nk_decode_85_byte((char)src[2]) +
            85 * (nk_decode_85_byte((char)src[3]) +
            85 * nk_decode_85_byte((char)src[4]))));

        /* we can't assume little-endianess. */
        dst[0] = (unsigned char)((tmp >> 0) & 0xFF);
        dst[1] = (unsigned char)((tmp >> 8) & 0xFF);
        dst[2] = (unsigned char)((tmp >> 16) & 0xFF);
        dst[3] = (unsigned char)((tmp >> 24) & 0xFF);

        src += 5;
        dst += 4;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x48ec3
movq 0x18(%rsp), %rax
movsbl (%rax), %edi
callq 0x85070
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %edi
callq 0x85070
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x2(%rax), %edi
callq 0x85070
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x3(%rax), %edi
callq 0x85070
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x4(%rax), %edi
callq 0x85070
movl 0x4(%rsp), %esi
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
movl %eax, %edi
movl 0x10(%rsp), %eax
imull $0x55, %edi, %edi
addl %edi, %esi
imull $0x55, %esi, %esi
addl %esi, %edx
imull $0x55, %edx, %edx
addl %edx, %ecx
imull $0x55, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movl 0x14(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0x1(%rax)
movl 0x14(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0x2(%rax)
movl 0x14(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0x3(%rax)
movq 0x18(%rsp), %rax
addq $0x5, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0x48dbe
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_font_atlas_add_default
NK_API struct nk_font*
nk_font_atlas_add_default(struct nk_font_atlas *atlas,
    float pixel_height, const struct nk_font_config *config)
{
    NK_ASSERT(atlas);
    NK_ASSERT(atlas->temporary.alloc);
    NK_ASSERT(atlas->temporary.free);
    NK_ASSERT(atlas->permanent.alloc);
    NK_ASSERT(atlas->permanent.free);
    return nk_font_atlas_add_compressed_base85(atlas,
        nk_proggy_clean_ttf_compressed_data_base85, pixel_height, config);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x48f1e
movq 0x7c0fe(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x684a4(%rip), %rsi     # 0xb13a0
leaq 0x684bb(%rip), %rdx     # 0xb13be
movl $0x450d, %ecx           # imm = 0x450D
movb $0x0, %al
callq 0x13ec0
movq 0x7c0da(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x48f20
jmp 0x48f22
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x48f61
movq 0x7c0bb(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x68461(%rip), %rsi     # 0xb13a0
leaq 0x68478(%rip), %rdx     # 0xb13be
movl $0x450e, %ecx           # imm = 0x450E
movb $0x0, %al
callq 0x13ec0
movq 0x7c097(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x48f63
jmp 0x48f65
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x48fa4
movq 0x7c078(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6841e(%rip), %rsi     # 0xb13a0
leaq 0x68435(%rip), %rdx     # 0xb13be
movl $0x450f, %ecx           # imm = 0x450F
movb $0x0, %al
callq 0x13ec0
movq 0x7c054(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x48fa6
jmp 0x48fa8
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x48fe7
movq 0x7c035(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x683db(%rip), %rsi     # 0xb13a0
leaq 0x683f2(%rip), %rdx     # 0xb13be
movl $0x4510, %ecx           # imm = 0x4510
movb $0x0, %al
callq 0x13ec0
movq 0x7c011(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x48fe9
jmp 0x48feb
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4902a
movq 0x7bff2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x68398(%rip), %rsi     # 0xb13a0
leaq 0x683af(%rip), %rdx     # 0xb13be
movl $0x4511, %ecx           # imm = 0x4511
movb $0x0, %al
callq 0x13ec0
movq 0x7bfce(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4902c
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movq (%rsp), %rdx
leaq 0x648ee(%rip), %rsi     # 0xad930
callq 0x138a0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_memset
NK_LIB void
nk_memset(void *ptr, int c0, nk_size size)
{
    #define nk_word unsigned
    #define nk_wsize sizeof(nk_word)
    #define nk_wmask (nk_wsize - 1)
    nk_byte *dst = (nk_byte*)ptr;
    unsigned c = 0;
    nk_size t = 0;

    if ((c = (nk_byte)c0) != 0) {
        c = (c << 8) | c; /* at least 16-bits  */
        if (sizeof(unsigned int) > 2)
            c = (c << 16) | c; /* at least 32-bits*/
    }

    /* too small of a word count */
    dst = (nk_byte*)ptr;
    if (size < 3 * nk_wsize) {
        while (size--) *dst++ = (nk_byte)c0;
        return;
    }

    /* align destination */
    if ((t = NK_PTR_TO_UINT(dst) & nk_wmask) != 0) {
        t = nk_wsize -t;
        size -= t;
        do {
            *dst++ = (nk_byte)c0;
        } while (--t != 0);
    }

    /* fill word */
    t = size / nk_wsize;
    do {
        *(nk_word*)((void*)dst) = c;
        dst += nk_wsize;
    } while (--t != 0);

    /* fill trailing bytes */
    t = (size & nk_wmask);
    if (t != 0) {
        do {
            *dst++ = (nk_byte)c0;
        } while (--t != 0);
    }

    #undef nk_word
    #undef nk_wsize
    #undef nk_wmask
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movq $0x0, -0x30(%rsp)
movl -0xc(%rsp), %eax
movzbl %al, %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, %eax
je 0x49da7
movl -0x24(%rsp), %eax
shll $0x8, %eax
orl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
shll $0x10, %eax
orl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0xc, -0x18(%rsp)
jae 0x49df2
jmp 0x49dbb
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
cmpq $0x0, %rax
je 0x49ded
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
jmp 0x49dbb
jmp 0x49ed8
movq -0x20(%rsp), %rax
andq $0x3, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
je 0x49e56
movl $0x4, %eax
subq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rcx
movq -0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
movq -0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
jne 0x49e27
jmp 0x49e56
movq -0x18(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x30(%rsp)
movl -0x24(%rsp), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rsp)
movq -0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
jne 0x49e64
movq -0x18(%rsp), %rax
andq $0x3, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x30(%rsp)
je 0x49ed8
jmp 0x49ea9
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
movq -0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
jne 0x49ea9
jmp 0x49ed8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_font_baker
NK_INTERN struct nk_font_baker*
nk_font_baker(void *memory, int glyph_count, int count, struct nk_allocator *alloc)
{
    struct nk_font_baker *baker;
    if (!memory) return 0;
    /* setup baker inside a memory block  */
    baker = (struct nk_font_baker*)NK_ALIGN_PTR(memory, nk_baker_align);
    baker->build = (struct nk_font_bake_data*)NK_ALIGN_PTR((baker + 1), nk_build_align);
    baker->packed_chars = (stbtt_packedchar*)NK_ALIGN_PTR((baker->build + count), nk_char_align);
    baker->rects = (struct stbrp_rect*)NK_ALIGN_PTR((baker->packed_chars + glyph_count), nk_rect_align);
    baker->ranges = (stbtt_pack_range*)NK_ALIGN_PTR((baker->rects + glyph_count), nk_range_align);
    baker->alloc = *alloc;
    return baker;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x49f08
movq $0x0, -0x8(%rsp)
jmp 0x49fd3
movq -0x10(%rsp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
addq $0x78, %rcx
addq $0x7, %rcx
andq $-0x8, %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rsp), %rax
movq 0x58(%rax), %rcx
movslq -0x18(%rsp), %rax
imulq $0xb8, %rax, %rax
addq %rax, %rcx
addq $0x3, %rcx
andq $-0x4, %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rsp), %rax
movq 0x60(%rax), %rcx
movslq -0x14(%rsp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rcx
addq $0x3, %rcx
andq $-0x4, %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x68(%rax)
movq -0x28(%rsp), %rax
movq 0x68(%rax), %rcx
movslq -0x14(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
addq $0x7, %rcx
andq $-0x8, %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x70(%rax)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_font_bake_convert
NK_INTERN void
nk_font_bake_convert(void *out_memory, int img_width, int img_height,
    const void *in_memory)
{
    int n = 0;
    nk_rune *dst;
    const nk_byte *src;

    NK_ASSERT(out_memory);
    NK_ASSERT(in_memory);
    NK_ASSERT(img_width);
    NK_ASSERT(img_height);
    if (!out_memory || !in_memory || !img_height || !img_width) return;

    dst = (nk_rune*)out_memory;
    src = (const nk_byte*)in_memory;
    for (n = (int)(img_width * img_height); n > 0; n--)
        *dst++ = ((nk_rune)(*src++) << 24) | 0x00FFFFFF;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x4b729
movq 0x798f3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x65c99(%rip), %rsi     # 0xb13a0
leaq 0x65cb0(%rip), %rdx     # 0xb13be
movl $0x4244, %ecx           # imm = 0x4244
movb $0x0, %al
callq 0x13ec0
movq 0x798cf(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4b72b
jmp 0x4b72d
cmpq $0x0, 0x20(%rsp)
jne 0x4b768
movq 0x798b4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x65c5a(%rip), %rsi     # 0xb13a0
leaq 0x65c71(%rip), %rdx     # 0xb13be
movl $0x4245, %ecx           # imm = 0x4245
movb $0x0, %al
callq 0x13ec0
movq 0x79890(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4b76a
jmp 0x4b76c
cmpl $0x0, 0x2c(%rsp)
jne 0x4b7a6
movq 0x79876(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x65c1c(%rip), %rsi     # 0xb13a0
leaq 0x65c33(%rip), %rdx     # 0xb13be
movl $0x4246, %ecx           # imm = 0x4246
movb $0x0, %al
callq 0x13ec0
movq 0x79852(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4b7a8
jmp 0x4b7aa
cmpl $0x0, 0x28(%rsp)
jne 0x4b7e4
movq 0x79838(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x65bde(%rip), %rsi     # 0xb13a0
leaq 0x65bf5(%rip), %rdx     # 0xb13be
movl $0x4247, %ecx           # imm = 0x4247
movb $0x0, %al
callq 0x13ec0
movq 0x79814(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4b7e6
cmpq $0x0, 0x30(%rsp)
je 0x4b804
cmpq $0x0, 0x20(%rsp)
je 0x4b804
cmpl $0x0, 0x28(%rsp)
je 0x4b804
cmpl $0x0, 0x2c(%rsp)
jne 0x4b806
jmp 0x4b86b
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
imull 0x28(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x4b86b
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movzbl (%rax), %ecx
shll $0x18, %ecx
orl $0xffffff, %ecx         # imm = 0xFFFFFF
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4b827
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_begin
NK_API void
nk_input_begin(struct nk_context *ctx)
{
    int i;
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    for (i = 0; i < NK_BUTTON_MAX; ++i)
        in->mouse.buttons[i].clicked = 0;

    in->keyboard.text_len = 0;
    in->mouse.scroll_delta = nk_vec2(0,0);
    in->mouse.prev.x = in->mouse.pos.x;
    in->mouse.prev.y = in->mouse.pos.y;
    in->mouse.delta.x = 0;
    in->mouse.delta.y = 0;
    for (i = 0; i < NK_KEY_MAX; i++)
        in->keyboard.keys[i].clicked = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4c2a4
movq 0x78d78(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x6511e(%rip), %rsi     # 0xb13a0
leaq 0x65135(%rip), %rdx     # 0xb13be
movl $0x4603, %ecx           # imm = 0x4603
movb $0x0, %al
callq 0x13ec0
movq 0x78d54(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c2a6
cmpq $0x0, 0x20(%rsp)
jne 0x4c2b3
jmp 0x4c3b2
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x4c2f7
movq 0x10(%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4c2c5
movq 0x10(%rsp), %rax
movl $0x0, 0x100(%rax)
movq 0x10(%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, 0x15c(%rax)
movq 0x10(%rsp), %rax
movss 0x144(%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x14c(%rax)
movq 0x10(%rsp), %rax
movss 0x148(%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x150(%rax)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x154(%rax)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x158(%rax)
movl $0x0, 0x1c(%rsp)
cmpl $0x1e, 0x1c(%rsp)
jge 0x4c3b2
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl $0x0, 0x4(%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4c38c
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_end
NK_API void
nk_input_end(struct nk_context *ctx)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->mouse.grab)
        in->mouse.grab = 0;
    if (in->mouse.ungrab) {
        in->mouse.grabbed = 0;
        in->mouse.ungrab = 0;
        in->mouse.grab = 0;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c404
movq 0x78c18(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64fbe(%rip), %rsi     # 0xb13a0
leaq 0x64fd5(%rip), %rdx     # 0xb13be
movl $0x4616, %ecx           # imm = 0x4616
movb $0x0, %al
callq 0x13ec0
movq 0x78bf4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c406
cmpq $0x0, 0x10(%rsp)
jne 0x4c410
jmp 0x4c466
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, 0x164(%rax)
je 0x4c434
movq 0x8(%rsp), %rax
movb $0x0, 0x164(%rax)
movq 0x8(%rsp), %rax
cmpb $0x0, 0x166(%rax)
je 0x4c466
movq 0x8(%rsp), %rax
movb $0x0, 0x165(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x166(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x164(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_motion
NK_API void
nk_input_motion(struct nk_context *ctx, int x, int y)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    in->mouse.pos.x = (float)x;
    in->mouse.pos.y = (float)y;
    in->mouse.delta.x = in->mouse.pos.x - in->mouse.prev.x;
    in->mouse.delta.y = in->mouse.pos.y - in->mouse.prev.y;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c4bc
movq 0x78b60(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64f06(%rip), %rsi     # 0xb13a0
leaq 0x64f1d(%rip), %rdx     # 0xb13be
movl $0x4625, %ecx           # imm = 0x4625
movb $0x0, %al
callq 0x13ec0
movq 0x78b3c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c4be
cmpq $0x0, 0x10(%rsp)
jne 0x4c4c8
jmp 0x4c53d
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cvtsi2ssl 0xc(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x144(%rax)
cvtsi2ssl 0x8(%rsp), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x148(%rax)
movq (%rsp), %rax
movss 0x144(%rax), %xmm0
movq (%rsp), %rax
subss 0x14c(%rax), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x154(%rax)
movq (%rsp), %rax
movss 0x148(%rax), %xmm0
movq (%rsp), %rax
subss 0x150(%rax), %xmm0
movq (%rsp), %rax
movss %xmm0, 0x158(%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_input_key
NK_API void
nk_input_key(struct nk_context *ctx, enum nk_keys key, nk_bool down)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
#ifdef NK_KEYSTATE_BASED_INPUT
    if (in->keyboard.keys[key].down != down)
        in->keyboard.keys[key].clicked++;
#else
    in->keyboard.keys[key].clicked++;
#endif
    in->keyboard.keys[key].down = down;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c59c
movq 0x78a80(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64e26(%rip), %rsi     # 0xb13a0
leaq 0x64e3d(%rip), %rdx     # 0xb13be
movl $0x4631, %ecx           # imm = 0x4631
movb $0x0, %al
callq 0x13ec0
movq 0x78a5c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c59e
cmpq $0x0, 0x10(%rsp)
jne 0x4c5a8
jmp 0x4c5e4
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl (%rax,%rcx,8), %eax
cmpl 0x8(%rsp), %eax
je 0x4c5d5
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax,%rcx,8)
movl 0x8(%rsp), %edx
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_button
NK_API void
nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, nk_bool down)
{
    struct nk_mouse_button *btn;
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->mouse.buttons[id].down == down) return;

    btn = &in->mouse.buttons[id];
    btn->clicked_pos.x = (float)x;
    btn->clicked_pos.y = (float)y;
    btn->down = down;
    btn->clicked++;

    /* Fix Click-Drag for touch events. */
    in->mouse.delta.x = 0;
    in->mouse.delta.y = 0;
#ifdef NK_BUTTON_TRIGGER_ON_RELEASE
    if (down == 1 && id == NK_BUTTON_LEFT)
    {
        in->mouse.down_pos.x = btn->clicked_pos.x;
        in->mouse.down_pos.y = btn->clicked_pos.y;
    }
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4c645
movq 0x789d7(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64d7d(%rip), %rsi     # 0xb13a0
leaq 0x64d94(%rip), %rdx     # 0xb13be
movl $0x4641, %ecx           # imm = 0x4641
movb $0x0, %al
callq 0x13ec0
movq 0x789b3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c647
cmpq $0x0, 0x20(%rsp)
jne 0x4c654
jmp 0x4c6ed
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl 0x10(%rsp), %eax
jne 0x4c67c
jmp 0x4c6ed
movq (%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cvtsi2ssl 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x8(%rax)
cvtsi2ssl 0x14(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0xc(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x154(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x158(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_input_scroll
NK_API void
nk_input_scroll(struct nk_context *ctx, struct nk_vec2 val)
{
    NK_ASSERT(ctx);
    if (!ctx) return;
    ctx->input.mouse.scroll_delta.x += val.x;
    ctx->input.mouse.scroll_delta.y += val.y;
}

// Assembly:
subq $0x18, %rsp
movlpd %xmm0, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4c74a
movq 0x788d2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64c78(%rip), %rsi     # 0xb13a0
leaq 0x64c8f(%rip), %rdx     # 0xb13be
movl $0x465a, %ecx           # imm = 0x465A
movb $0x0, %al
callq 0x13ec0
movq 0x788ae(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c74c
cmpq $0x0, 0x8(%rsp)
jne 0x4c756
jmp 0x4c78c
movss 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
addss 0x15c(%rax), %xmm0
movss %xmm0, 0x15c(%rax)
movss 0x14(%rsp), %xmm0
movq 0x8(%rsp), %rax
addss 0x160(%rax), %xmm0
movss %xmm0, 0x160(%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_input_glyph
NK_API void
nk_input_glyph(struct nk_context *ctx, const nk_glyph glyph)
{
    int len = 0;
    nk_rune unicode;
    struct nk_input *in;

    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;

    len = nk_utf_decode(glyph, &unicode, NK_UTF_SIZE);
    if (len && ((in->keyboard.text_len + len) < NK_INPUT_MAX)) {
        nk_utf_encode(unicode, &in->keyboard.text[in->keyboard.text_len],
            NK_INPUT_MAX - in->keyboard.text_len);
        in->keyboard.text_len += len;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4c7f1
movq 0x7882b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x64bd1(%rip), %rsi     # 0xb13a0
leaq 0x64be8(%rip), %rdx     # 0xb13be
movl $0x4666, %ecx           # imm = 0x4666
movb $0x0, %al
callq 0x13ec0
movq 0x78807(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x4c7f3
cmpq $0x0, 0x20(%rsp)
jne 0x4c800
jmp 0x4c886
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x14030
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x4c886
movq 0x8(%rsp), %rax
movl 0x100(%rax), %eax
addl 0x14(%rsp), %eax
cmpl $0x10, %eax
jge 0x4c886
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0xf0, %rsi
movq 0x8(%rsp), %rax
movslq 0x100(%rax), %rax
addq %rax, %rsi
movq 0x8(%rsp), %rax
movl $0x10, %edx
subl 0x100(%rax), %edx
callq 0x13f80
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
addl 0x100(%rax), %ecx
movl %ecx, 0x100(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)